@prisma/cli-init 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,13 +1,3069 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  Engine,
+  encodeAPIKey,
+  ensureDirectory,
+  getDataDirPath,
+  integer,
+  literal,
+  minLength,
+  minValue,
+  number,
+  object,
+  optional,
+  parseJson,
+  pipe,
+  readDirectoryNames,
+  readFileAsText,
+  safeParse,
+  streamAsTextTo,
+  string,
+  url,
+  withResolvers,
+  y
+} from "./chunk-ASMCGOOW.js";
 import {
   credentialsFile,
   poll,
   printPpgInitOutput,
   requestOrThrow,
   successMessage
-} from "./chunk-CMRCQXCF.js";
+} from "./chunk-SORRSNB3.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-YX4UTTNJ.js";
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
+    "use strict";
+    var constants = __require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d2) {
+        cwd = null;
+        chdir.call(process, d2);
+      };
+      if (Object.setPrototypeOf)
+        Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module.exports = patch;
+    function patch(fs3) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        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);
+        };
+        fs3.lchmodSync = function() {
+        };
+      }
+      if (fs3.chown && !fs3.lchown) {
+        fs3.lchown = function(path3, uid, gid, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs3.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        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() {
+                  fs3.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb)
+                cb(er);
+            });
+          }
+          if (Object.setPrototypeOf)
+            Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs3.rename);
+      }
+      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") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf)
+          Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(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(fs3, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs3.readSync);
+      function patchLchmod(fs4) {
+        fs4.lchmod = function(path3, mode, callback) {
+          fs4.open(
+            path3,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback)
+                  callback(err);
+                return;
+              }
+              fs4.fchmod(fd, mode, function(err2) {
+                fs4.close(fd, function(err22) {
+                  if (callback)
+                    callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs4.lchmodSync = function(path3, mode) {
+          var fd = fs4.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs4.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs4.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs4.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      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;
+              }
+              fs4.futimes(fd, at, mt, function(er2) {
+                fs4.close(fd, function(er22) {
+                  if (cb)
+                    cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs4.lutimesSync = function(path3, at, mt) {
+            var fd = fs4.openSync(path3, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs4.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs4.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs4.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs4.futimes) {
+          fs4.lutimes = function(_a, _b, _c, cb) {
+            if (cb)
+              process.nextTick(cb);
+          };
+          fs4.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs3, target, mode, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs3, target, mode);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs3, target, uid, gid, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs3, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0)
+                stats.uid += 4294967296;
+              if (stats.gid < 0)
+                stats.gid += 4294967296;
+            }
+            if (cb)
+              cb.apply(this, arguments);
+          }
+          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(fs3, target, options) : orig.call(fs3, target);
+          if (stats) {
+            if (stats.uid < 0)
+              stats.uid += 4294967296;
+            if (stats.gid < 0)
+              stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    "use strict";
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs3) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path3, options) {
+        if (!(this instanceof ReadStream))
+          return new ReadStream(path3, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path3;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding)
+          this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path3, options) {
+        if (!(this instanceof WriteStream))
+          return new WriteStream(path3, options);
+        Stream.call(this);
+        this.path = path3;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs3.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
+    "use strict";
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+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 fs3 = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = __require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs3[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs3, queue);
+      fs3.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs3, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs3.close);
+      fs3.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs3, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs3.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs3[gracefulQueue]);
+          __require("assert").equal(fs3[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      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(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, [path4, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      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(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, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs4.appendFile;
+      if (fs$appendFile)
+        fs4.appendFile = appendFile;
+      function appendFile(path3, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        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, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs4.copyFile;
+      if (fs$copyFile)
+        fs4.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs4.readdir;
+      fs4.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path3, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        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(path4, options2, cb2, startTime) {
+          return fs$readdir(path4, options2, fs$readdirCallback(
+            path4,
+            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,
+                [path4, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs4);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs4.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs4.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs4, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs4, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs4, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs4, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path3, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path3, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path3, options) {
+        return new fs4.ReadStream(path3, options);
+      }
+      function createWriteStream(path3, options) {
+        return new fs4.WriteStream(path3, options);
+      }
+      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(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, [path4, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs4;
+    }
+    function enqueue(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 < fs3[gracefulQueue].length; ++i) {
+        if (fs3[gracefulQueue][i].length > 2) {
+          fs3[gracefulQueue][i][3] = now;
+          fs3[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs3[gracefulQueue].length === 0)
+        return;
+      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) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs3[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts;
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(this._errors.length - 1, this._errors.length);
+          this._timeouts = this._cachedTimeouts.slice(0);
+          timeout = this._timeouts.shift();
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      var timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && options.forever,
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a2, b) {
+        return a2 - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_retry();
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module) {
+    "use strict";
+    module.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module) {
+    "use strict";
+    var process2 = global.process;
+    var processOk = function(process3) {
+      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+    };
+    if (!processOk(process2)) {
+      module.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process2.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process2.__signal_exit_emitter__) {
+        emitter = process2.__signal_exit_emitter__;
+      } else {
+        emitter = process2.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process2.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process2.emit = originalProcessEmit;
+        process2.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process2.kill(process2.pid, sig);
+          }
+        };
+      });
+      module.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process2.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process2.emit = processEmit;
+        process2.reallyExit = processReallyExit;
+      };
+      module.exports.load = load;
+      originalProcessReallyExit = process2.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process2.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        originalProcessReallyExit.call(process2, process2.exitCode);
+      };
+      originalProcessEmit = process2.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process2.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process2.exitCode, null);
+          emit("afterexit", process2.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js
+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, fs3, callback) {
+      const cachedPrecision = fs3[cacheSymbol];
+      if (cachedPrecision) {
+        return fs3.stat(file, (err, stat) => {
+          if (err) {
+            return callback(err);
+          }
+          callback(null, stat.mtime, cachedPrecision);
+        });
+      }
+      const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+      fs3.utimes(file, mtime, mtime, (err) => {
+        if (err) {
+          return callback(err);
+        }
+        fs3.stat(file, (err2, stat) => {
+          if (err2) {
+            return callback(err2);
+          }
+          const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+          Object.defineProperty(fs3, cacheSymbol, { value: precision });
+          callback(null, stat.mtime, precision);
+        });
+      });
+    }
+    function getMtime(precision) {
+      let now = Date.now();
+      if (precision === "s") {
+        now = Math.ceil(now / 1e3) * 1e3;
+      }
+      return new Date(now);
+    }
+    module.exports.probe = probe;
+    module.exports.getMtime = getMtime;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
+    "use strict";
+    var path3 = __require("path");
+    var fs3 = require_graceful_fs();
+    var retry = require_retry2();
+    var onExit = require_signal_exit();
+    var mtimePrecision = require_mtime_precision();
+    var locks = {};
+    function getLockFile(file, options) {
+      return options.lockfilePath || `${file}.lock`;
+    }
+    function resolveCanonicalPath(file, options, callback) {
+      if (!options.realpath) {
+        return callback(null, path3.resolve(file));
+      }
+      options.fs.realpath(file, callback);
+    }
+    function acquireLock(file, options, callback) {
+      const lockfilePath = getLockFile(file, options);
+      options.fs.mkdir(lockfilePath, (err) => {
+        if (!err) {
+          return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
+            if (err2) {
+              options.fs.rmdir(lockfilePath, () => {
+              });
+              return callback(err2);
+            }
+            callback(null, mtime, mtimePrecision2);
+          });
+        }
+        if (err.code !== "EEXIST") {
+          return callback(err);
+        }
+        if (options.stale <= 0) {
+          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+        }
+        options.fs.stat(lockfilePath, (err2, stat) => {
+          if (err2) {
+            if (err2.code === "ENOENT") {
+              return acquireLock(file, { ...options, stale: 0 }, callback);
+            }
+            return callback(err2);
+          }
+          if (!isLockStale(stat, options)) {
+            return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+          }
+          removeLock(file, options, (err3) => {
+            if (err3) {
+              return callback(err3);
+            }
+            acquireLock(file, { ...options, stale: 0 }, callback);
+          });
+        });
+      });
+    }
+    function isLockStale(stat, options) {
+      return stat.mtime.getTime() < Date.now() - options.stale;
+    }
+    function removeLock(file, options, callback) {
+      options.fs.rmdir(getLockFile(file, options), (err) => {
+        if (err && err.code !== "ENOENT") {
+          return callback(err);
+        }
+        callback();
+      });
+    }
+    function updateLock(file, options) {
+      const lock3 = locks[file];
+      if (lock3.updateTimeout) {
+        return;
+      }
+      lock3.updateDelay = lock3.updateDelay || options.update;
+      lock3.updateTimeout = setTimeout(() => {
+        lock3.updateTimeout = null;
+        options.fs.stat(lock3.lockfilePath, (err, stat) => {
+          const isOverThreshold = lock3.lastUpdate + options.stale < Date.now();
+          if (err) {
+            if (err.code === "ENOENT" || isOverThreshold) {
+              return setLockAsCompromised(file, lock3, Object.assign(err, { code: "ECOMPROMISED" }));
+            }
+            lock3.updateDelay = 1e3;
+            return updateLock(file, options);
+          }
+          const isMtimeOurs = lock3.mtime.getTime() === stat.mtime.getTime();
+          if (!isMtimeOurs) {
+            return setLockAsCompromised(
+              file,
+              lock3,
+              Object.assign(
+                new Error("Unable to update lock within the stale threshold"),
+                { code: "ECOMPROMISED" }
+              )
+            );
+          }
+          const mtime = mtimePrecision.getMtime(lock3.mtimePrecision);
+          options.fs.utimes(lock3.lockfilePath, mtime, mtime, (err2) => {
+            const isOverThreshold2 = lock3.lastUpdate + options.stale < Date.now();
+            if (lock3.released) {
+              return;
+            }
+            if (err2) {
+              if (err2.code === "ENOENT" || isOverThreshold2) {
+                return setLockAsCompromised(file, lock3, Object.assign(err2, { code: "ECOMPROMISED" }));
+              }
+              lock3.updateDelay = 1e3;
+              return updateLock(file, options);
+            }
+            lock3.mtime = mtime;
+            lock3.lastUpdate = Date.now();
+            lock3.updateDelay = null;
+            updateLock(file, options);
+          });
+        });
+      }, lock3.updateDelay);
+      if (lock3.updateTimeout.unref) {
+        lock3.updateTimeout.unref();
+      }
+    }
+    function setLockAsCompromised(file, lock3, err) {
+      lock3.released = true;
+      if (lock3.updateTimeout) {
+        clearTimeout(lock3.updateTimeout);
+      }
+      if (locks[file] === lock3) {
+        delete locks[file];
+      }
+      lock3.options.onCompromised(err);
+    }
+    function lock2(file, options, callback) {
+      options = {
+        stale: 1e4,
+        update: null,
+        realpath: true,
+        retries: 0,
+        fs: fs3,
+        onCompromised: (err) => {
+          throw err;
+        },
+        ...options
+      };
+      options.retries = options.retries || 0;
+      options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+      options.stale = Math.max(options.stale || 0, 2e3);
+      options.update = options.update == null ? options.stale / 2 : options.update || 0;
+      options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const operation = retry.operation(options.retries);
+        operation.attempt(() => {
+          acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
+            if (operation.retry(err2)) {
+              return;
+            }
+            if (err2) {
+              return callback(operation.mainError());
+            }
+            const lock3 = locks[file2] = {
+              lockfilePath: getLockFile(file2, options),
+              mtime,
+              mtimePrecision: mtimePrecision2,
+              options,
+              lastUpdate: Date.now()
+            };
+            updateLock(file2, options);
+            callback(null, (releasedCallback) => {
+              if (lock3.released) {
+                return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
+              }
+              unlock(file2, { ...options, realpath: false }, releasedCallback);
+            });
+          });
+        });
+      });
+    }
+    function unlock(file, options, callback) {
+      options = {
+        fs: fs3,
+        realpath: true,
+        ...options
+      };
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        const lock3 = locks[file2];
+        if (!lock3) {
+          return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+        }
+        lock3.updateTimeout && clearTimeout(lock3.updateTimeout);
+        lock3.released = true;
+        delete locks[file2];
+        removeLock(file2, options, callback);
+      });
+    }
+    function check2(file, options, callback) {
+      options = {
+        stale: 1e4,
+        realpath: true,
+        fs: fs3,
+        ...options
+      };
+      options.stale = Math.max(options.stale || 0, 2e3);
+      resolveCanonicalPath(file, options, (err, file2) => {
+        if (err) {
+          return callback(err);
+        }
+        options.fs.stat(getLockFile(file2, options), (err2, stat) => {
+          if (err2) {
+            return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
+          }
+          return callback(null, !isLockStale(stat, options));
+        });
+      });
+    }
+    function getLocks() {
+      return locks;
+    }
+    onExit(() => {
+      for (const file in locks) {
+        const options = locks[file].options;
+        try {
+          options.fs.rmdirSync(getLockFile(file, options));
+        } catch (e) {
+        }
+      }
+    });
+    module.exports.lock = lock2;
+    module.exports.unlock = unlock;
+    module.exports.check = check2;
+    module.exports.getLocks = getLocks;
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
+    "use strict";
+    var fs3 = require_graceful_fs();
+    function createSyncFs(fs4) {
+      const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
+      const newFs = { ...fs4 };
+      methods.forEach((method) => {
+        newFs[method] = (...args) => {
+          const callback = args.pop();
+          let ret;
+          try {
+            ret = fs4[`${method}Sync`](...args);
+          } catch (err) {
+            return callback(err);
+          }
+          callback(null, ret);
+        };
+      });
+      return newFs;
+    }
+    function toPromise(method) {
+      return (...args) => new Promise((resolve2, reject) => {
+        args.push((err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve2(result);
+          }
+        });
+        method(...args);
+      });
+    }
+    function toSync(method) {
+      return (...args) => {
+        let err;
+        let result;
+        args.push((_err, _result) => {
+          err = _err;
+          result = _result;
+        });
+        method(...args);
+        if (err) {
+          throw err;
+        }
+        return result;
+      };
+    }
+    function toSyncOptions(options) {
+      options = { ...options };
+      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" });
+      }
+      return options;
+    }
+    module.exports = {
+      toPromise,
+      toSync,
+      toSyncOptions
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS({
+  "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js"(exports, module) {
+    "use strict";
+    var lockfile = require_lockfile();
+    var { toPromise, toSync, toSyncOptions } = require_adapter();
+    async function lock2(file, options) {
+      const release = await toPromise(lockfile.lock)(file, options);
+      return toPromise(release);
+    }
+    function lockSync(file, options) {
+      const release = toSync(lockfile.lock)(file, toSyncOptions(options));
+      return toSync(release);
+    }
+    function unlock(file, options) {
+      return toPromise(lockfile.unlock)(file, options);
+    }
+    function unlockSync(file, options) {
+      return toSync(lockfile.unlock)(file, toSyncOptions(options));
+    }
+    function check2(file, options) {
+      return toPromise(lockfile.check)(file, options);
+    }
+    function checkSync(file, options) {
+      return toSync(lockfile.check)(file, toSyncOptions(options));
+    }
+    module.exports = lock2;
+    module.exports.lock = lock2;
+    module.exports.unlock = unlock;
+    module.exports.lockSync = lockSync;
+    module.exports.unlockSync = unlockSync;
+    module.exports.check = check2;
+    module.exports.checkSync = checkSync;
+  }
+});
+
+// src/Init.ts
+import { confirm, input, select } from "@inquirer/prompts";
+
+// ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input2 = "") {
+  if (!input2) {
+    return input2;
+  }
+  return input2.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var normalize = function(path3) {
+  if (path3.length === 0) {
+    return ".";
+  }
+  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) {
+    path3 += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path3)) {
+    path3 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path3}`;
+    }
+    return `//${path3}`;
+  }
+  return isPathAbsolute && !isAbsolute(path3) ? `/${path3}` : path3;
+};
+var join = function(...segments) {
+  let path3 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path3.length > 0) {
+      const pathTrailing = path3[path3.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path3 += seg.slice(1);
+      } else {
+        path3 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path3 += seg;
+    }
+  }
+  return normalize(path3);
+};
+function normalizeString(path3, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path3.length; ++index) {
+    if (index < path3.length) {
+      char = path3[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1)
+        ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path3.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path3.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(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(path3) {
+  const base = path3.split(SLASH_RE).pop();
+  if (!base) {
+    return void 0;
+  }
+  const separatorIndex = base.lastIndexOf(".");
+  if (separatorIndex <= 0) {
+    return base;
+  }
+  return base.slice(0, separatorIndex);
+}
+
+// ../../node_modules/.pnpm/get-port-please@3.1.2/node_modules/get-port-please/dist/index.mjs
+import { createServer } from "net";
+import { networkInterfaces } from "os";
+var unsafePorts = /* @__PURE__ */ new Set([
+  1,
+  // tcpmux
+  7,
+  // echo
+  9,
+  // discard
+  11,
+  // systat
+  13,
+  // daytime
+  15,
+  // netstat
+  17,
+  // qotd
+  19,
+  // chargen
+  20,
+  // ftp data
+  21,
+  // ftp access
+  22,
+  // ssh
+  23,
+  // telnet
+  25,
+  // smtp
+  37,
+  // time
+  42,
+  // name
+  43,
+  // nicname
+  53,
+  // domain
+  69,
+  // tftp
+  77,
+  // priv-rjs
+  79,
+  // finger
+  87,
+  // ttylink
+  95,
+  // supdup
+  101,
+  // hostriame
+  102,
+  // iso-tsap
+  103,
+  // gppitnp
+  104,
+  // acr-nema
+  109,
+  // pop2
+  110,
+  // pop3
+  111,
+  // sunrpc
+  113,
+  // auth
+  115,
+  // sftp
+  117,
+  // uucp-path
+  119,
+  // nntp
+  123,
+  // NTP
+  135,
+  // loc-srv /epmap
+  137,
+  // netbios
+  139,
+  // netbios
+  143,
+  // imap2
+  161,
+  // snmp
+  179,
+  // BGP
+  389,
+  // ldap
+  427,
+  // SLP (Also used by Apple Filing Protocol)
+  465,
+  // smtp+ssl
+  512,
+  // print / exec
+  513,
+  // login
+  514,
+  // shell
+  515,
+  // printer
+  526,
+  // tempo
+  530,
+  // courier
+  531,
+  // chat
+  532,
+  // netnews
+  540,
+  // uucp
+  548,
+  // AFP (Apple Filing Protocol)
+  554,
+  // rtsp
+  556,
+  // remotefs
+  563,
+  // nntp+ssl
+  587,
+  // smtp (rfc6409)
+  601,
+  // syslog-conn (rfc3195)
+  636,
+  // ldap+ssl
+  989,
+  // ftps-data
+  990,
+  // ftps
+  993,
+  // ldap+ssl
+  995,
+  // pop3+ssl
+  1719,
+  // h323gatestat
+  1720,
+  // h323hostcall
+  1723,
+  // pptp
+  2049,
+  // nfs
+  3659,
+  // apple-sasl / PasswordServer
+  4045,
+  // lockd
+  5060,
+  // sip
+  5061,
+  // sips
+  6e3,
+  // X11
+  6566,
+  // sane-port
+  6665,
+  // Alternate IRC [Apple addition]
+  6666,
+  // Alternate IRC [Apple addition]
+  6667,
+  // Standard IRC [Apple addition]
+  6668,
+  // Alternate IRC [Apple addition]
+  6669,
+  // Alternate IRC [Apple addition]
+  6697,
+  // IRC + TLS
+  10080
+  // Amanda
+]);
+function isUnsafePort(port) {
+  return unsafePorts.has(port);
+}
+function isSafePort(port) {
+  return !isUnsafePort(port);
+}
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var GetPortError = class extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.message = message;
+    __publicField(this, "name", "GetPortError");
+  }
+};
+function _log(verbose, message) {
+  if (verbose) {
+    console.log(`[get-port] ${message}`);
+  }
+}
+function _generateRange(from, to) {
+  if (to < from) {
+    return [];
+  }
+  const r = [];
+  for (let index = from; index <= to; index++) {
+    r.push(index);
+  }
+  return r;
+}
+function _tryPort(port, host) {
+  return new Promise((resolve2) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", () => {
+      resolve2(false);
+    });
+    server.listen({ port, host }, () => {
+      const { port: port2 } = server.address();
+      server.close(() => {
+        resolve2(isSafePort(port2) && port2);
+      });
+    });
+  });
+}
+function _getLocalHosts(additional) {
+  const hosts = new Set(additional);
+  for (const _interface of Object.values(networkInterfaces())) {
+    for (const config of _interface || []) {
+      if (config.address && !config.internal && !config.address.startsWith("fe80::")) {
+        hosts.add(config.address);
+      }
+    }
+  }
+  return [...hosts];
+}
+async function _findPort(ports, host) {
+  for (const port of ports) {
+    const r = await _tryPort(port, host);
+    if (r) {
+      return r;
+    }
+  }
+}
+function _fmtOnHost(hostname) {
+  return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+}
+var HOSTNAME_RE = /^(?!-)[\d.:A-Za-z-]{1,63}(?<!-)$/;
+function _validateHostname(hostname, _public, verbose) {
+  if (hostname && !HOSTNAME_RE.test(hostname)) {
+    const fallbackHost = _public ? "0.0.0.0" : "127.0.0.1";
+    _log(
+      verbose,
+      `Invalid hostname: ${JSON.stringify(hostname)}. Using ${JSON.stringify(
+        fallbackHost
+      )} as fallback.`
+    );
+    return fallbackHost;
+  }
+  return hostname;
+}
+async function getPort(_userOptions = {}) {
+  if (typeof _userOptions === "number" || typeof _userOptions === "string") {
+    _userOptions = { port: Number.parseInt(_userOptions + "") || 0 };
+  }
+  const _port = Number(_userOptions.port ?? process.env.PORT);
+  const _userSpecifiedAnyPort = Boolean(
+    _userOptions.port || _userOptions.ports?.length || _userOptions.portRange?.length
+  );
+  const options = {
+    name: "default",
+    random: _port === 0,
+    ports: [],
+    portRange: [],
+    alternativePortRange: _userSpecifiedAnyPort ? [] : [3e3, 3100],
+    verbose: false,
+    ..._userOptions,
+    port: _port,
+    host: _validateHostname(
+      _userOptions.host ?? process.env.HOST,
+      _userOptions.public,
+      _userOptions.verbose
+    )
+  };
+  if (options.random && !_userSpecifiedAnyPort) {
+    return getRandomPort(options.host);
+  }
+  const portsToCheck = [
+    options.port,
+    ...options.ports,
+    ..._generateRange(...options.portRange)
+  ].filter((port) => {
+    if (!port) {
+      return false;
+    }
+    if (!isSafePort(port)) {
+      _log(options.verbose, `Ignoring unsafe port: ${port}`);
+      return false;
+    }
+    return true;
+  });
+  if (portsToCheck.length === 0) {
+    portsToCheck.push(3e3);
+  }
+  let availablePort = await _findPort(portsToCheck, options.host);
+  if (!availablePort && options.alternativePortRange.length > 0) {
+    availablePort = await _findPort(
+      _generateRange(...options.alternativePortRange),
+      options.host
+    );
+    if (portsToCheck.length > 0) {
+      let message = `Unable to find an available port (tried ${portsToCheck.join(
+        "-"
+      )} ${_fmtOnHost(options.host)}).`;
+      if (availablePort) {
+        message += ` Using alternative port ${availablePort}.`;
+      }
+      _log(options.verbose, message);
+    }
+  }
+  if (!availablePort && _userOptions.random !== false) {
+    availablePort = await getRandomPort(options.host);
+    if (availablePort) {
+      _log(options.verbose, `Using random port ${availablePort}`);
+    }
+  }
+  if (!availablePort) {
+    const triedRanges = [
+      options.port,
+      options.portRange.join("-"),
+      options.alternativePortRange.join("-")
+    ].filter(Boolean).join(", ");
+    throw new GetPortError(
+      `Unable to find an available port ${_fmtOnHost(
+        options.host
+      )} (tried ${triedRanges})`
+    );
+  }
+  return availablePort;
+}
+async function getRandomPort(host) {
+  const port = await checkPort(0, host);
+  if (port === false) {
+    throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
+  }
+  return port;
+}
+async function checkPort(port, host = process.env.HOST, verbose) {
+  if (!host) {
+    host = _getLocalHosts([void 0, "0.0.0.0"]);
+  }
+  if (!Array.isArray(host)) {
+    return _tryPort(port, host);
+  }
+  for (const _host of host) {
+    const _port = await _tryPort(port, _host);
+    if (_port === false) {
+      if (port < 1024 && verbose) {
+        _log(
+          verbose,
+          `Unable to listen to the privileged port ${port} ${_fmtOnHost(
+            _host
+          )}`
+        );
+      }
+      return false;
+    }
+    if (port === 0 && _port !== 0) {
+      port = _port;
+    }
+  }
+  return port;
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-ANXBDSUI.js
+var s = { done: false, hasNext: false };
+var o = (t) => ({ hasNext: true, next: t, done: false });
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-3GOCSNFN.js
+function C(t, ...o3) {
+  let n = t, u3 = o3.map((e) => "lazy" in e ? y2(e) : void 0), p = 0;
+  for (; p < o3.length; ) {
+    if (u3[p] === void 0 || !B(n)) {
+      let i = o3[p];
+      n = i(n), p += 1;
+      continue;
+    }
+    let r = [];
+    for (let i = p; i < o3.length; i++) {
+      let l = u3[i];
+      if (l === void 0 || (r.push(l), l.isSingle))
+        break;
+    }
+    let a2 = [];
+    for (let i of n)
+      if (f(i, a2, r))
+        break;
+    let { isSingle: s2 } = r.at(-1);
+    n = s2 ? a2[0] : a2, p += r.length;
+  }
+  return n;
+}
+function f(t, o3, n) {
+  if (n.length === 0)
+    return o3.push(t), false;
+  let u3 = t, p = s, e = false;
+  for (let [r, a2] of n.entries()) {
+    let { index: s2, items: i } = a2;
+    if (i.push(u3), p = a2(u3, s2, i), a2.index += 1, p.hasNext) {
+      if (p.hasMany ?? false) {
+        for (let l of p.next)
+          if (f(l, o3, n.slice(r + 1)))
+            return true;
+        return e;
+      }
+      u3 = p.next;
+    }
+    if (!p.hasNext)
+      break;
+    p.done && (e = true);
+  }
+  return p.hasNext && o3.push(u3), e;
+}
+function y2(t) {
+  let { lazy: o3, lazyArgs: n } = t, u3 = o3(...n);
+  return Object.assign(u3, { isSingle: o3.single ?? false, index: 0, items: [] });
+}
+function B(t) {
+  return typeof t == "string" || typeof t == "object" && t !== null && Symbol.iterator in t;
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-LFJW7BOT.js
+function y3(t, i) {
+  let a2 = i.length - t.length;
+  if (a2 === 1) {
+    let [n, ...r] = i;
+    return C(n, { lazy: t, lazyArgs: r });
+  }
+  if (a2 === 0) {
+    let n = { lazy: t, lazyArgs: i };
+    return Object.assign((e) => C(e, n), n);
+  }
+  throw new Error("Wrong number of arguments");
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-D6FCK2GA.js
+function u(o3, n, a2) {
+  let t = (r) => o3(r, ...n);
+  return a2 === void 0 ? t : Object.assign(t, { lazy: a2, lazyArgs: n });
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-WIMGWYZL.js
+function u2(r, n, o3) {
+  let a2 = r.length - n.length;
+  if (a2 === 0)
+    return r(...n);
+  if (a2 === 1)
+    return u(r, n, o3);
+  throw new Error("Wrong number of arguments");
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-ENS7GPLZ.js
+function a(...r) {
+  return u2(o2, r);
+}
+function o2(r, t) {
+  let e = [];
+  for (let n = r; n < t; n++)
+    e.push(n);
+  return e;
+}
+
+// ../../node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-GKXRNLHM.js
+function d(...e) {
+  return y3(f2, e);
+}
+function f2(e) {
+  if (e.length === 0)
+    return o;
+  let n = /* @__PURE__ */ new Map();
+  for (let r of e)
+    n.set(r, (n.get(r) ?? 0) + 1);
+  return (r) => {
+    let t = n.get(r);
+    return t === void 0 || t === 0 ? { done: false, hasNext: true, next: r } : (n.set(r, t - 1), s);
+  };
+}
+
+// ../../dev/server/src/port.ts
+var DEFAULT_DATABASE_PORT = 51214;
+var DEFAULT_SERVER_PORT = 51213;
+var DEFAULT_SHADOW_DATABASE_PORT = 51215;
+var MAX_PORT = 65535;
+var NO_PORT = -Infinity;
+async function pickPorts(options) {
+  const { debug, name, requestedPorts, servers } = options;
+  const { portsUsedByOtherServers, portsUsedByThisServerLastTime } = extractUsedPorts(name, servers);
+  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)}`);
+  }
+  const pickedPorts = { databasePort: NO_PORT, port: NO_PORT, shadowDatabasePort: NO_PORT };
+  const portKeys = ["port", "databasePort", "shadowDatabasePort"];
+  for (const portKey of portKeys) {
+    const port = await trySpecificPorts({
+      debug,
+      portKey,
+      portsUsedByOtherServers,
+      portsUsedByThisServerLastTime,
+      requestedPorts
+    }) ?? await tryAnyPort({ debug, pickedPorts, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime });
+    if (debug) {
+      console.debug(`Got port for "${portKey}": ${port}`);
+    }
+    pickedPorts[portKey] = port;
+  }
+  if (debug) {
+    console.debug(`Picked ports: ${JSON.stringify(pickedPorts)}`);
+  }
+  return pickedPorts;
+}
+async function trySpecificPorts(options) {
+  const { debug, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime, requestedPorts } = options;
+  const { [portKey]: requestedPort, ...otherRequestedPorts } = requestedPorts;
+  if (isPortSpecified(requestedPort)) {
+    await assertPickablePort({ debug, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort });
+    return requestedPort;
+  }
+  const portUsedLastTime = portsUsedByThisServerLastTime?.[portKey] ?? NO_PORT;
+  if (!isPortSpecified(portUsedLastTime)) {
+    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 (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.`
+      );
+    }
+    return null;
+  }
+  if (await checkPort(portUsedLastTime) === false) {
+    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 (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, 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),
+    ...Object.keys(portsUsedByOtherServers).map(Number),
+    ...Object.values(portsUsedByThisServerLastTime || {})
+  ];
+  const maximumSpecificPort = Math.min(Math.max(minimumPort, ...excludedPorts) + 100, MAX_PORT);
+  const ports = d(a(minimumPort, maximumSpecificPort), excludedPorts);
+  const defaultPort2 = {
+    port: DEFAULT_SERVER_PORT,
+    databasePort: DEFAULT_DATABASE_PORT,
+    shadowDatabasePort: DEFAULT_SHADOW_DATABASE_PORT
+  }[portKey];
+  try {
+    return await getPort({
+      port: defaultPort2 in portsUsedByOtherServers || Object.values(pickedPorts).includes(defaultPort2) || Object.values(portsUsedByThisServerLastTime || {}).includes(defaultPort2) ? void 0 : defaultPort2,
+      ports
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "GetPortError" && maximumSpecificPort + 1 <= MAX_PORT) {
+      if (debug) {
+        console.debug(`Expanding port lookup to range [${maximumSpecificPort + 1}, ${MAX_PORT}].`);
+      }
+      return await getPort({ portRange: [maximumSpecificPort + 1, MAX_PORT] });
+    }
+    throw error;
+  }
+}
+function isPortSpecified(port) {
+  return port >= 0;
+}
+function extractUsedPorts(name, servers) {
+  const portsUsedByOtherServers = {};
+  let portsUsedByThisServerLastTime;
+  for (const server of servers) {
+    const { databasePort, port, shadowDatabasePort } = server;
+    if (server.name === name) {
+      portsUsedByThisServerLastTime = { databasePort, port, shadowDatabasePort };
+      continue;
+    }
+    portsUsedByOtherServers[databasePort] = true;
+    portsUsedByOtherServers[port] = true;
+    portsUsedByOtherServers[shadowDatabasePort] = true;
+  }
+  return { portsUsedByOtherServers, portsUsedByThisServerLastTime };
+}
+async function assertPickablePort(options) {
+  const { debug, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort } = options;
+  if (requestedPort in portsUsedByOtherServers) {
+    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 (debug) {
+      console.error(`Port ${requestedPort} was requested for "${portKey}", but also for another key.`);
+    }
+    throw new PortRequestedTwiceError(requestedPort);
+  }
+  if (isUnsafePort(requestedPort)) {
+    if (debug) {
+      console.error(`Port ${requestedPort} was requested for "${portKey}", but is unsafe.`);
+    }
+    throw new PortNotAvailableError(requestedPort);
+  }
+  if (await checkPort(requestedPort) === false) {
+    if (debug) {
+      console.error(`Port ${requestedPort} was requested for "${portKey}", but is not available.`);
+    }
+    throw new PortNotAvailableError(requestedPort);
+  }
+}
+var PortNotAvailableError = class extends Error {
+  constructor(port) {
+    super(`Port \`${port}\` is not available.`);
+    this.port = port;
+  }
+  name = "PortNotAvailableError";
+};
+var PortRequestedTwiceError = class extends Error {
+  constructor(port) {
+    super(`Port number \`${port}\` was requested twice. Please choose a different port for each service.`);
+    this.port = port;
+  }
+  name = "PortRequestedTwiceError";
+};
+var PortBelongsToAnotherServerError = class extends Error {
+  constructor(port) {
+    super(`Port number \`${port}\` belongs to another Prisma Dev server. Please choose a different port.`);
+    this.port = port;
+  }
+  name = "PortBelongsToAnotherServerError";
+};
+
+// ../../dev/server/src/db.ts
+var BASE_PGLITE_OPTIONS = {
+  connectionLimit: 1,
+  connectTimeout: 0,
+  database: "template1",
+  maxIdleConnectionLifetime: 0,
+  password: "postgres",
+  poolTimeout: 0,
+  socketTimeout: 0,
+  sslMode: "disable",
+  username: "postgres"
+};
+var BASE_DB_URL = `postgres://${BASE_PGLITE_OPTIONS.username}:${BASE_PGLITE_OPTIONS.password}@localhost`;
+var CONNECTION_STRING_QUERY_PARAMS = new URLSearchParams({ sslmode: BASE_PGLITE_OPTIONS.sslMode });
+var PRISMA_ORM_CONNECTION_STRING_QUERY_PARAMS = new URLSearchParams({
+  ...Object.fromEntries(CONNECTION_STRING_QUERY_PARAMS.entries()),
+  connection_limit: String(BASE_PGLITE_OPTIONS.connectionLimit),
+  connect_timeout: String(BASE_PGLITE_OPTIONS.connectTimeout),
+  max_idle_connection_lifetime: String(BASE_PGLITE_OPTIONS.maxIdleConnectionLifetime),
+  pool_timeout: String(BASE_PGLITE_OPTIONS.poolTimeout),
+  single_use_connections: "true",
+  socket_timeout: String(BASE_PGLITE_OPTIONS.socketTimeout)
+});
+async function startDBServer(purpose, serverState) {
+  const port = purpose === "database" ? serverState.databasePort : serverState.shadowDatabasePort;
+  if (serverState.dryRun) {
+    return getStartDBServerResult(purpose, serverState, { db: null, port, server: null });
+  }
+  const { debug } = serverState;
+  const getDBFn = purpose === "shadow_database" ? getShadowDB : getDB;
+  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, inspect: debug, port });
+  if (debug) {
+    server.addEventListener("listening", (event) => {
+      const { detail } = event;
+      console.debug(`[${purpose}] server listening on ${JSON.stringify(detail)}`);
+    });
+    server.addEventListener("connection", (event) => {
+      const { clientAddress, clientPort } = event.detail;
+      console.debug(`[${purpose}] client connected from ${clientAddress}:${clientPort}`);
+    });
+    server.addEventListener("error", (event) => {
+      const { detail } = event;
+      console.error(`[${purpose}] server error:`, detail);
+    });
+  }
+  try {
+    await server.start();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EADDRINUSE") {
+      throw new PortNotAvailableError(port);
+    }
+    throw error;
+  }
+  return getStartDBServerResult(purpose, serverState, { db, port, server });
+}
+function getStartDBServerResult(purpose, serverState, options) {
+  const { debug } = serverState;
+  const { db, port, server } = options || {};
+  if (debug) {
+    console.debug(`[${purpose}] server started on port ${port}`);
+  }
+  return {
+    ...BASE_PGLITE_OPTIONS,
+    close: async () => {
+      const errors = [];
+      try {
+        await server?.stop();
+        if (debug) {
+          console.debug(`[${purpose}] server stopped on port ${port}`);
+        }
+      } catch (error) {
+        console.error(`[${purpose}] server stop error`, error);
+        errors.push(error);
+      }
+      if (purpose === "database") {
+        try {
+          await db?.syncToFs();
+          if (debug) {
+            console.debug(`[${purpose}] synced to filesystem`);
+          }
+        } catch (error) {
+          console.error(`[${purpose}] sync error`, error);
+          errors.push(error);
+        }
+      }
+      try {
+        await db?.close();
+        if (debug) {
+          console.debug(`[${purpose}] closed`);
+        }
+      } catch (error) {
+        console.error(`[${purpose}] close error`, error);
+        errors.push(error);
+      }
+      if (errors.length > 0) {
+        throw new AggregateError(errors, `Failed to close ${purpose} properly`);
+      }
+    },
+    connectionString: getConnectionString(port, CONNECTION_STRING_QUERY_PARAMS),
+    dump: async (destinationPath) => {
+      if (purpose === "shadow_database" || !db) {
+        return;
+      }
+      await dumpDB({ db, debug, destinationPath });
+    },
+    port,
+    prismaORMConnectionString: getConnectionString(port, PRISMA_ORM_CONNECTION_STRING_QUERY_PARAMS),
+    terminalCommand: `PGPASSWORD=${BASE_PGLITE_OPTIONS.password} PGSSLMODE=${BASE_PGLITE_OPTIONS.sslMode} psql -h localhost -p ${port} -U ${BASE_PGLITE_OPTIONS.username} -d ${BASE_PGLITE_OPTIONS.database}`
+  };
+}
+function getConnectionString(port, queryParams) {
+  return `${BASE_DB_URL}:${port}/${BASE_PGLITE_OPTIONS.database}?${queryParams.toString()}`;
+}
+async function getDB(dataDir, debug) {
+  const { PGlite } = await import("@electric-sql/pglite");
+  return await PGlite.create({
+    database: BASE_PGLITE_OPTIONS.database,
+    dataDir,
+    debug: debug ? 5 : void 0,
+    relaxedDurability: false,
+    username: BASE_PGLITE_OPTIONS.username
+  });
+}
+async function getShadowDB(_dataDir, debug) {
+  const { PGlite } = await import("@electric-sql/pglite");
+  return await PGlite.create({
+    database: BASE_PGLITE_OPTIONS.database,
+    dataDir: "memory://",
+    debug: debug ? 5 : void 0,
+    relaxedDurability: false,
+    username: BASE_PGLITE_OPTIONS.username
+  });
+}
+async function dumpDB(options) {
+  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: [
+      // TODO: enable once it's fixed by PGLite team. This is highly recommended for cross-major-version pg restores.
+      // "--quote-all-identifiers",
+      // TODO: remove once we decide to also dump data.
+      "--schema-only",
+      "--no-owner"
+      // avoids `ALTER TABLE public."Post" OWNER TO postgres;`
+    ],
+    fileName: destinationPath ? filename(destinationPath) : void 0,
+    // workaround, see https://prisma-company.slack.com/archives/C08LDD4THBJ/p1749486737052709?thread_ts=1749211391.517819&cid=C08LDD4THBJ
+    pg: await pg.clone()
+  });
+  if (destinationPath) {
+    if (debug) {
+      console.debug(`[DB] Dumping database to ${destinationPath}`);
+    }
+    return await streamAsTextTo(dumpFile, destinationPath);
+  }
+  if (debug) {
+    console.debug(`[DB] Dumping database to memory`);
+  }
+  return await dumpFile.text();
+}
+
+// ../../dev/server/src/http.ts
+import { createServer as createServer2 } from "http";
+import { promisify } from "util";
+import getPlatformModule from "@prisma/get-platform";
+async function startHTTPServer(dbServer, serverState) {
+  const { port } = serverState;
+  if (serverState.dryRun) {
+    return getStartHTTPServerResult(port, null);
+  }
+  const app = await getApp(port, dbServer, serverState);
+  const { promise: waitReady, reject, resolve: resolve2 } = withResolvers();
+  const { serve } = await import("@hono/node-server");
+  const server = serve({ createServer: createServer2, fetch: app.fetch, overrideGlobalObjects: false, port }, resolve2);
+  server.on("error", (error) => {
+    if (typeof error === "object" && "code" in error && error.code === "EADDRINUSE") {
+      return reject(new PortNotAvailableError(port));
+    }
+    console.error("[Accelerate]", error);
+  });
+  await waitReady;
+  return getStartHTTPServerResult(port, server);
+}
+function getStartHTTPServerResult(port, server) {
+  return {
+    async close() {
+      if (!server) {
+        return;
+      }
+      await Promise.allSettled([promisify(server.close.bind(server))(), Engine.stopAll()]);
+    },
+    port,
+    url: `http://localhost:${port}`
+  };
+}
+async function getApp(port, dbServer, serverState) {
+  const { debug } = serverState;
+  const [{ Hono }, { accelerateRoute }, { utilityRoute }] = await Promise.all([
+    import("hono/tiny"),
+    import("./accelerate-GABM6I4V.js"),
+    import("./utility-W6LOZZIT.js")
+  ]);
+  const app = new Hono();
+  const platform = await getPlatformModule.getPlatformInfo();
+  if (debug) {
+    console.debug("[Accelerate] platform info: %s", JSON.stringify(platform));
+  }
+  if (debug) {
+    const { logger } = await import("hono/logger");
+    app.use(
+      "*",
+      logger((...args) => console.log("[Accelerate]", ...args))
+    );
+  }
+  app.use("*", async (ctx, next) => {
+    ctx.set("db", dbServer);
+    ctx.set("debug", Boolean(debug));
+    ctx.set("platform", platform);
+    ctx.set("port", port);
+    ctx.set("protocol", "http");
+    ctx.set("serverState", serverState);
+    ctx.set("shadowDBPort", serverState.shadowDatabasePort);
+    return await next();
+  });
+  const mainRoute = new Hono();
+  mainRoute.route("/", accelerateRoute);
+  mainRoute.route("/", utilityRoute);
+  app.route("/", mainRoute);
+  return app;
+}
+
+// ../../dev/server/src/state.ts
+import { writeFile } from "fs/promises";
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+
+// ../../dev/server/src/kernel.ts
+function checkProcessExists(pid, debug) {
+  if (pid == null) {
+    return false;
+  }
+  try {
+    return y.kill?.(pid, 0) ?? true;
+  } catch (error) {
+    if (debug) {
+      console.error(`Error checking if process with PID ${pid} exists:`, error);
+    }
+    return false;
+  }
+}
+
+// ../../dev/server/src/state.ts
+var urlSchema = pipe(string(), url());
+var databaseSchema = object({
+  connectionString: urlSchema,
+  prismaORMConnectionString: optional(urlSchema),
+  terminalCommand: optional(string())
+});
+var serverSchema = object({
+  url: urlSchema
+});
+var portSchema = pipe(number(), integer(), minValue(1));
+var exportsSchema = object({
+  database: databaseSchema,
+  http: serverSchema,
+  ppg: serverSchema,
+  shadowDatabase: databaseSchema
+});
+var serverDumpV1Schema = object({
+  databasePort: portSchema,
+  exports: optional(exportsSchema),
+  name: pipe(string(), minLength(1)),
+  pid: optional(pipe(number(), integer(), minValue(0))),
+  port: portSchema,
+  shadowDatabasePort: portSchema,
+  version: literal("1")
+});
+var PRIVATE_INITIALIZE_SYMBOL = Symbol("initialize");
+var DEFAULT_NAME = "default";
+var ServerState = class {
+  _databasePort;
+  debug;
+  dryRun;
+  name;
+  persistenceMode;
+  pid;
+  _port;
+  _shadowDatabasePort;
+  constructor(options) {
+    this._databasePort = options.databasePort ?? NO_PORT;
+    this.debug = options.debug ?? false;
+    this.dryRun = options.dryRun ?? false;
+    this.name = options.name ?? DEFAULT_NAME;
+    this.persistenceMode = options.persistenceMode;
+    this.pid = options.pid ?? y.pid;
+    this._port = options.port ?? NO_PORT;
+    this._shadowDatabasePort = options.shadowDatabasePort ?? NO_PORT;
+  }
+  static async createExclusively(options) {
+    const serverState = options?.dryRun !== true && options?.persistenceMode !== "stateless" ? new StatefulServerState(options) : new StatelessServerState(options);
+    await serverState[PRIVATE_INITIALIZE_SYMBOL]();
+    return serverState;
+  }
+  static async fromServerDump(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 (debug) {
+        console.debug(`[State] No server dump file found at: ${serverDumpPath}`);
+      }
+      return null;
+    }
+    if (debug) {
+      console.debug(`[State] server dump file found at "${serverDumpPath}":`);
+      console.debug(serverDumpFileContent);
+    }
+    const {
+      issues,
+      output: serverDump,
+      success
+    } = safeParse(pipe(string(), parseJson(), serverDumpV1Schema), serverDumpFileContent);
+    if (!success) {
+      if (debug) {
+        console.debug(`[State] Invalid server dump file at "${serverDumpPath}":
+${JSON.stringify(issues, null, 2)}`);
+      }
+      throw new Error(`Invalid Prisma Dev state for "${name}".`);
+    }
+    return new StatefulServerState({
+      databasePort: serverDump.databasePort,
+      debug,
+      dryRun: false,
+      name,
+      pid: serverDump.pid,
+      port: serverDump.port,
+      serverDump,
+      shadowDatabasePort: serverDump.shadowDatabasePort
+    });
+  }
+  static async scan(options) {
+    const { debug } = options ?? {};
+    const dataDirsPath = join(getDataDirPath(DEFAULT_NAME), "..");
+    if (debug) {
+      console.debug(`[State] scanning for server states in: ${dataDirsPath}`);
+    }
+    const names = await readDirectoryNames(dataDirsPath);
+    if (debug) {
+      console.debug(`[State] found server names: ${JSON.stringify(names)}`);
+    }
+    return await Promise.all(names.map((name) => getServerStatus(name, options)));
+  }
+  get databasePort() {
+    return this._databasePort;
+  }
+  get port() {
+    return this._port;
+  }
+  get shadowDatabasePort() {
+    return this._shadowDatabasePort;
+  }
+};
+var StatelessServerState = class extends ServerState {
+  constructor(options) {
+    super({
+      ...options,
+      databasePort: options?.databasePort ?? DEFAULT_DATABASE_PORT,
+      persistenceMode: "stateless",
+      port: options?.port ?? DEFAULT_SERVER_PORT,
+      shadowDatabasePort: options?.shadowDatabasePort ?? DEFAULT_SHADOW_DATABASE_PORT
+    });
+  }
+  get databaseDumpPath() {
+    return "<DUMP_PATH>";
+  }
+  get pgliteDataDirPath() {
+    return "memory://";
+  }
+  async [PRIVATE_INITIALIZE_SYMBOL]() {
+  }
+  async close() {
+  }
+  async writeServerDump() {
+  }
+};
+var StatefulServerState = class _StatefulServerState extends ServerState {
+  #databaseDumpPath;
+  #dataDirPath;
+  #pglitePath;
+  #serverDumpPath;
+  #serverDump;
+  #unlock = null;
+  constructor(options) {
+    super({ ...options, persistenceMode: "stateful" });
+    this.#dataDirPath = getDataDirPath(this.name);
+    this.#databaseDumpPath = join(this.#dataDirPath, "db_dump.bak");
+    this.#pglitePath = join(this.#dataDirPath, ".pglite");
+    this.#serverDump = options?.serverDump ?? null;
+    this.#serverDumpPath = _StatefulServerState.getServerDumpPath(this.#dataDirPath);
+  }
+  static getServerDumpPath(dataDirPath) {
+    return join(dataDirPath, "server.json");
+  }
+  get databaseDumpPath() {
+    return this.#databaseDumpPath;
+  }
+  get exports() {
+    return this.#serverDump?.exports;
+  }
+  get pgliteDataDirPath() {
+    return this.#pglitePath;
+  }
+  async [PRIVATE_INITIALIZE_SYMBOL]() {
+    await ensureDirectory(this.#dataDirPath);
+    if (this.debug) {
+      console.debug(`[State] using data directory: ${this.#dataDirPath}`);
+    }
+    try {
+      this.#unlock = await (0, import_proper_lockfile.lock)(this.#dataDirPath, { lockfilePath: join(this.#dataDirPath, ".lock") });
+      if (this.debug) {
+        console.debug(`[State] obtained lock on: ${this.#dataDirPath}`);
+      }
+      const servers = await ServerState.scan({ debug: this.debug, onlyMetadata: true });
+      const ports = await pickPorts({
+        debug: this.debug,
+        name: this.name,
+        requestedPorts: {
+          databasePort: this.databasePort,
+          port: this.port,
+          shadowDatabasePort: this.shadowDatabasePort
+        },
+        servers
+      });
+      this._databasePort = ports.databasePort;
+      this._port = ports.port;
+      this._shadowDatabasePort = ports.shadowDatabasePort;
+      await this.writeServerDump();
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ELOCKED") {
+        throw new ServerAlreadyRunningError(this);
+      }
+      throw error;
+    }
+  }
+  async close() {
+    if (this.#unlock == null) {
+      return;
+    }
+    try {
+      await this.#unlock();
+      this.#unlock = null;
+      if (this.debug) {
+        console.debug(`[State] released lock on: ${this.#dataDirPath}`);
+      }
+    } catch (error) {
+      console.error(`[State] failed to release lock on: ${this.#dataDirPath}`);
+      throw error;
+    }
+  }
+  async writeServerDump(exports) {
+    this.#serverDump = {
+      name: this.name,
+      version: "1",
+      pid: y.pid,
+      port: this.port,
+      databasePort: this.databasePort,
+      shadowDatabasePort: this.shadowDatabasePort,
+      exports
+    };
+    await writeFile(this.#serverDumpPath, `${JSON.stringify(this.#serverDump, null, 2)}
+`, { encoding: "utf-8" });
+  }
+};
+async function getServerStatus(name, options) {
+  const { debug, onlyMetadata } = options || {};
+  const baseResult = {
+    databasePort: -1,
+    exports: void 0,
+    name,
+    pid: void 0,
+    port: -1,
+    shadowDatabasePort: -1,
+    version: "1"
+  };
+  try {
+    const serverState = await ServerState.fromServerDump({ debug, name });
+    if (!serverState) {
+      if (debug) {
+        console.debug(`[State] no server state found for name: ${name}`);
+      }
+      return { ...baseResult, status: "no_such_server" };
+    }
+    baseResult.databasePort = serverState.databasePort;
+    baseResult.exports = serverState.exports;
+    baseResult.pid = serverState.pid;
+    baseResult.port = serverState.port;
+    baseResult.shadowDatabasePort = serverState.shadowDatabasePort;
+    const { exports, pid } = serverState;
+    if (onlyMetadata) {
+      return { ...baseResult, status: "unknown" };
+    }
+    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" };
+    }
+    const dataDirPath = getDataDirPath(name);
+    try {
+      if (!await (0, import_proper_lockfile.check)(dataDirPath, { lockfilePath: join(dataDirPath, ".lock") })) {
+        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 (debug) {
+        console.error(`[State] server state for "${name}" failed to check lock:`, error);
+      }
+    }
+    if (!exports) {
+      return { ...baseResult, status: "starting_up" };
+    }
+    const { http } = exports;
+    const { hc } = await import("hono/client");
+    const healthResponse = await hc(http.url).health.$get();
+    if (!healthResponse.ok) {
+      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 !== name) {
+      if (debug) {
+        console.debug(`[State] server state for "${name}" has mismatched health response: ${JSON.stringify(health)}`);
+      }
+      return { ...baseResult, status: "unknown" };
+    }
+    if (debug) {
+      console.debug(`[State] server state for "${name}" is live: ${JSON.stringify(health)}`);
+    }
+    return { ...baseResult, status: "running" };
+  } catch (error) {
+    if (debug) {
+      console.error(`[State] failed to get server status for "${name}":`, error);
+    }
+    return { ...baseResult, status: "error" };
+  }
+}
+var ServerStateAlreadyExistsError = class extends Error {
+  name = "ServerStateAlreadyExistsError";
+  constructor(name) {
+    super(`A Prisma Dev server with the name "${name}" is already running.`);
+  }
+};
+var ServerAlreadyRunningError = class extends ServerStateAlreadyExistsError {
+  #server;
+  name = "ServerAlreadyRunningError";
+  constructor(server) {
+    super(server.name);
+    this.#server = server;
+  }
+  get server() {
+    return ServerState.fromServerDump({ debug: this.#server.debug, name: this.#server.name });
+  }
+};
+
+// ../../dev/server/src/index.ts
+async function unstable_startServer(options) {
+  const serverState = await ServerState.createExclusively(options);
+  const [dbServer, shadowDbServer] = await Promise.all([
+    startDBServer("database", serverState),
+    startDBServer("shadow_database", serverState)
+  ]);
+  const httpServer = await startHTTPServer(dbServer, serverState);
+  const ppgURL = `prisma+postgres://localhost:${httpServer.port}/?${new URLSearchParams({
+    api_key: encodeAPIKey({
+      databaseUrl: dbServer.prismaORMConnectionString,
+      name: serverState.name,
+      shadowDatabaseUrl: shadowDbServer.prismaORMConnectionString
+    })
+  }).toString()}`;
+  const exports = {
+    database: {
+      connectionString: dbServer.connectionString,
+      prismaORMConnectionString: dbServer.prismaORMConnectionString,
+      terminalCommand: dbServer.terminalCommand
+    },
+    http: { url: httpServer.url },
+    ppg: { url: ppgURL },
+    shadowDatabase: {
+      connectionString: shadowDbServer.prismaORMConnectionString,
+      prismaORMConnectionString: shadowDbServer.prismaORMConnectionString,
+      terminalCommand: shadowDbServer.terminalCommand
+    }
+  };
+  await serverState.writeServerDump(exports);
+  return {
+    ...exports,
+    close: () => closeServer(serverState, [httpServer, dbServer, shadowDbServer]),
+    name: serverState.name
+  };
+  async function closeServer(serverState2, servers) {
+    const results = await Promise.allSettled(servers.map((server) => server.close()));
+    const errors = results.filter((result) => result.status === "rejected").map((result) => new Error(result.reason));
+    try {
+      await serverState2.close();
+    } catch (error) {
+      errors.push(error);
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, `Failed to close some servers`);
+    }
+  }
+}
 
 // src/Init.ts
-import { confirm, input, select } from "@inquirer/prompts";
 import internals from "@prisma/internals";
 import dotenv from "dotenv";
 import { Schema as Shape } from "effect";
@@ -78,7 +3134,7 @@ var getRegionsOrThrow = async (input2) => {
 };
 var getPrismaPostgresRegionsOrThrow = async (input2) => {
   const regions = await getRegionsOrThrow(input2);
-  const ppgRegions = regions.filter((_) => _.ppgStatus !== "unsupported").sort((a, b) => b.displayName.localeCompare(a.displayName));
+  const ppgRegions = regions.filter((_) => _.ppgStatus !== "unsupported").sort((a2, b) => b.displayName.localeCompare(a2.displayName));
   return ppgRegions;
 };
 
@@ -89,7 +3145,6 @@ function printError(text) {
 }
 
 // src/Init.ts
-var PRISMA_DEV_DEFAULT_URL = "prisma+postgres://localhost:51213/?api_key=eyJkYXRhYmFzZVVybCI6InBvc3RncmVzOi8vcG9zdGdyZXM6cG9zdGdyZXNAbG9jYWxob3N0OjUxMjE0L3RlbXBsYXRlMT9jb25uZWN0aW9uX2xpbWl0PTEmY29ubmVjdF90aW1lb3V0PTAmbWF4X2lkbGVfY29ubmVjdGlvbl9saWZldGltZT0wJnBvb2xfdGltZW91dD0wJnNvY2tldF90aW1lb3V0PTAmc3NsbW9kZT1kaXNhYmxlIiwic2hhZG93RGF0YWJhc2VVcmwiOiJwb3N0Z3JlczovL3Bvc3RncmVzOnBvc3RncmVzQGxvY2FsaG9zdDo1MTIxNS90ZW1wbGF0ZTE_Y29ubmVjdGlvbl9saW1pdD0xJmNvbm5lY3RfdGltZW91dD0wJm1heF9pZGxlX2Nvbm5lY3Rpb25fbGlmZXRpbWU9MCZwb29sX3RpbWVvdXQ9MCZzb2NrZXRfdGltZW91dD0wJnNzbG1vZGU9ZGlzYWJsZSJ9";
 var defaultSchema = (props) => {
   const {
     datasourceProvider = "postgresql",
@@ -148,19 +3203,33 @@ model User {
   }
   return schema;
 };
-var defaultEnv = (url = PRISMA_DEV_DEFAULT_URL, comments = true) => {
+var defaultEnv = async (url2, comments = true) => {
+  if (url2 === void 0) {
+    let created = false;
+    const state = await ServerState.fromServerDump() || (created = true, await ServerState.createExclusively({ persistenceMode: "stateful" }));
+    if (created) {
+      await state.close();
+    }
+    const server = await unstable_startServer({
+      databasePort: state.databasePort,
+      dryRun: true,
+      port: state.port,
+      shadowDatabasePort: state.shadowDatabasePort
+    });
+    url2 = server.ppg.url;
+  }
   let env = comments ? `# Environment variables declared in this file are automatically made available to Prisma.
 # See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema
 
 # Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB and CockroachDB.
 # See the documentation for all the connection string options: https://pris.ly/d/connection-strings
 
-${url === PRISMA_DEV_DEFAULT_URL ? `# The following \`prisma+postgres\` URL is similar to the URL produced by running a local Prisma Postgres 
+${url2.startsWith("prisma+postgres:") && url2.includes("localhost") ? `# The following \`prisma+postgres\` URL is similar to the URL produced by running a local Prisma Postgres 
 # server with the \`prisma dev\` CLI command, when not choosing any non-default ports or settings. The API key, unlike the 
 # one found in a remote Prisma Postgres URL, does not contain any sensitive information.
 
 ` : ""}` : "";
-  env += `DATABASE_URL="${url}"`;
+  env += `DATABASE_URL="${url2}"`;
   return env;
 };
 var defaultPort = (datasourceProvider) => {
@@ -279,7 +3348,7 @@ var Init = class _Init {
     if (outputDirName) {
       throw Error("The init command does not take any argument.");
     }
-    const { datasourceProvider, url } = await match(args).with(
+    const { datasourceProvider, url: url2 } = await match(args).with(
       {
         "--datasource-provider": P.when(
           (datasourceProvider2) => Boolean(datasourceProvider2)
@@ -288,16 +3357,16 @@ var Init = class _Init {
       (input2) => {
         const datasourceProvider2 = input2["--datasource-provider"].toLowerCase();
         assertDatasourceProvider(datasourceProvider2);
-        const url2 = defaultURL(datasourceProvider2);
-        return { datasourceProvider: datasourceProvider2, url: url2 };
+        const url3 = defaultURL(datasourceProvider2);
+        return { datasourceProvider: datasourceProvider2, url: url3 };
       }
     ).with(
       {
-        "--url": P.when((url2) => Boolean(url2))
+        "--url": P.when((url3) => Boolean(url3))
       },
       async (input2) => {
-        const url2 = input2["--url"];
-        const canConnect = await internals.canConnectToDatabase(url2);
+        const url3 = input2["--url"];
+        const canConnect = await internals.canConnectToDatabase(url3);
         if (canConnect !== true) {
           const { code, message } = canConnect;
           if (code !== "P1003") {
@@ -308,8 +3377,8 @@ var Init = class _Init {
             }
           }
         }
-        const datasourceProvider2 = internals.protocolToConnectorType(`${url2.split(":")[0]}:`);
-        return { datasourceProvider: datasourceProvider2, url: url2 };
+        const datasourceProvider2 = internals.protocolToConnectorType(`${url3.split(":")[0]}:`);
+        return { datasourceProvider: datasourceProvider2, url: url3 };
       }
     ).otherwise(() => {
       return {
@@ -330,7 +3399,7 @@ var Init = class _Init {
     let generatedSchema;
     let generatedName;
     if (isPpgCommand) {
-      const PlatformCommands = await import("./_-O567UZLT.js");
+      const PlatformCommands = await import("./_-WIN5AVS3.js");
       const credentials = await credentialsFile.load();
       if (internals.isError(credentials))
         throw credentials;
@@ -481,11 +3550,11 @@ var Init = class _Init {
         withModel: args["--with-model"]
       })
     );
-    const databaseUrl = prismaPostgresDatabaseUrl || url;
+    const databaseUrl = prismaPostgresDatabaseUrl || url2;
     const warnings = [];
     const envPath = path2.join(outputDir, ".env");
     if (!fs2.existsSync(envPath)) {
-      fs2.writeFileSync(envPath, defaultEnv(databaseUrl));
+      fs2.writeFileSync(envPath, await defaultEnv(databaseUrl));
     } else {
       const envFile = fs2.readFileSync(envPath, { encoding: "utf8" });
       const config = dotenv.parse(envFile);
@@ -525,39 +3594,41 @@ var Init = class _Init {
       console.error("Failed to append client path to .gitignore file, reason: ", e);
     }
     const steps = [];
-    if (datasourceProvider === "mongodb") {
-      steps.push(`Define models in the schema.prisma file.`);
+    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 {
       steps.push(
         `Run ${green(internals.getCommandWithExecutor("prisma db pull"))} to turn your database schema into a Prisma schema.`
       );
     }
-    steps.push(
-      `Run ${green(
-        internals.getCommandWithExecutor("prisma generate")
-      )} to generate the Prisma Client. You can then start querying your database.`
-    );
+    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 real-time database events. Read: https://pris.ly/cli/beyond-orm`
+      )} with scalable connection pooling, global caching, and a managed serverless Postgres database. Read: https://pris.ly/cli/beyond-orm`
     );
-    if (!url && !args["--datasource-provider"]) {
-      steps.unshift(
-        `Set the ${green("provider")} of the ${green("datasource")} block in ${green(
-          "schema.prisma"
-        )} to match your database: ${green("postgresql")}, ${green("mysql")}, ${green("sqlite")}, ${green(
-          "sqlserver"
-        )}, ${green("mongodb")} or ${green("cockroachdb")}.`
-      );
-    }
-    if (!args["--url"]) {
-      steps.unshift(
-        `Set the ${green("DATABASE_URL")} in the ${green(
-          ".env"
-        )} file to point to your existing database. If your database has no tables yet, read https://pris.ly/d/getting-started`
-      );
-    }
     const defaultOutput = `
 \u2714 Your Prisma schema was created at ${green("prisma/schema.prisma")}
   You can now open it in your favorite editor.
@@ -565,7 +3636,7 @@ ${warnings.length > 0 && internals.logger.should.warn() ? `
 ${warnings.join("\n")}
 ` : ""}
 Next steps:
-${steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}
+${steps.map((s2, i) => `${i + 1}. ${s2}`).join("\n")}
 
 More information in our documentation:
 ${internals.link("https://pris.ly/d/getting-started")}