@prisma/internals 6.6.0-dev.34 → 6.6.0-dev.36

package/dist/{chunk-GNEFDTJE.js → chunk-WSCZQCHP.js}

@@ -26,8 +26,8 @@ var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__g
   mod
 ));
 var __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_GNEFDTJE_exports = {};
-__export2(chunk_GNEFDTJE_exports, {
+var chunk_WSCZQCHP_exports = {};
+__export2(chunk_WSCZQCHP_exports, {
   checkTypeScriptVersion: () => checkTypeScriptVersion,
   checkUnsupportedDataProxy: () => checkUnsupportedDataProxy,
   debug: () => debug5,
@@ -52,22 +52,22 @@ __export2(chunk_GNEFDTJE_exports, {
   loadEnvFile: () => loadEnvFile,
   loadSchemaContext: () => loadSchemaContext,
   prismaClientResolver: () => prismaClientResolver,
+  processSchemaResult: () => processSchemaResult,
   sendPanic: () => sendPanic,
   skipIndex: () => skipIndex
 });
-module.exports = __toCommonJS2(chunk_GNEFDTJE_exports);
-var import_chunk_ETNCBIDF = require("./chunk-ETNCBIDF.js");
+module.exports = __toCommonJS2(chunk_WSCZQCHP_exports);
 var import_chunk_GHHABGYW = require("./chunk-GHHABGYW.js");
 var import_chunk_EUTJYQDW = require("./chunk-EUTJYQDW.js");
-var import_chunk_IPKE37QC = require("./chunk-IPKE37QC.js");
 var import_chunk_DGZO4GAJ = require("./chunk-DGZO4GAJ.js");
+var import_chunk_ETNCBIDF = require("./chunk-ETNCBIDF.js");
 var import_chunk_72UZXEBG = require("./chunk-72UZXEBG.js");
 var import_chunk_X77CS5RK = require("./chunk-X77CS5RK.js");
 var import_chunk_EIERU2IM = require("./chunk-EIERU2IM.js");
 var import_chunk_RS2R7COT = require("./chunk-RS2R7COT.js");
 var import_chunk_X3P4J7WW = require("./chunk-X3P4J7WW.js");
 var import_chunk_IKQFIRRX = require("./chunk-IKQFIRRX.js");
-var import_chunk_JHQHVXIR = require("./chunk-JHQHVXIR.js");
+var import_chunk_OSHZ4P3G = require("./chunk-OSHZ4P3G.js");
 var import_chunk_ZCVVZ6U6 = require("./chunk-ZCVVZ6U6.js");
 var import_chunk_5V36RLCO = require("./chunk-5V36RLCO.js");
 var import_chunk_5FJ3MENK = require("./chunk-5FJ3MENK.js");
@@ -78,11 +78,11 @@ var import_chunk_FNA4EAZ6 = require("./chunk-FNA4EAZ6.js");
 var import_chunk_J77ZIDXB = require("./chunk-J77ZIDXB.js");
 var import_chunk_2T4NJDHK = require("./chunk-2T4NJDHK.js");
 var import_chunk_R3J2O23S = require("./chunk-R3J2O23S.js");
-var import_chunk_TSJICM5S = require("./chunk-TSJICM5S.js");
+var import_chunk_CRVLHWC5 = require("./chunk-CRVLHWC5.js");
 var import_chunk_7CMXNYMQ = require("./chunk-7CMXNYMQ.js");
-var import_chunk_2TQR7BKX = require("./chunk-2TQR7BKX.js");
-var import_chunk_WD2267J3 = require("./chunk-WD2267J3.js");
-var import_chunk_X3CLVIIZ = require("./chunk-X3CLVIIZ.js");
+var import_chunk_Q6VZHKYE = require("./chunk-Q6VZHKYE.js");
+var import_chunk_2VT4AM4Y = require("./chunk-2VT4AM4Y.js");
+var import_chunk_VLBKBUPL = require("./chunk-VLBKBUPL.js");
 var import_chunk_YRBRUREX = require("./chunk-YRBRUREX.js");
 var import_chunk_XKZ6CBLA = require("./chunk-XKZ6CBLA.js");
 var import_chunk_R7U45FIQ = require("./chunk-R7U45FIQ.js");
@@ -99,39 +99,37 @@ var import_chunk_V37JTUKZ = require("./chunk-V37JTUKZ.js");
 var import_chunk_MBB2KJWX = require("./chunk-MBB2KJWX.js");
 var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
 var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
-var import_debug = __toESM2(require("@prisma/debug"));
-var import_config = require("@prisma/config");
+var import_debug = require("@prisma/debug");
+var import_schema_files_loader = require("@prisma/schema-files-loader");
 var import_fs = __toESM2(require("fs"));
-var import_debug2 = __toESM2(require("@prisma/debug"));
-var import_node_path = __toESM2(require("node:path"));
-var import_node_process = __toESM2(require("node:process"));
-var import_node_path2 = __toESM2(require("node:path"));
-var import_node_fs = __toESM2(require("node:fs"));
-var import_node_url = require("node:url");
-var import_node_fs2 = __toESM2(require("node:fs"));
-var import_fs2 = __toESM2(require("fs"));
 var import_path = __toESM2(require("path"));
-var import_debug3 = require("@prisma/debug");
-var import_schema_files_loader = require("@prisma/schema-files-loader");
-var import_fs3 = __toESM2(require("fs"));
-var import_path2 = __toESM2(require("path"));
 var import_util = require("util");
+var import_debug2 = __toESM2(require("@prisma/debug"));
 var import_crypto = __toESM2(require("crypto"));
-var import_path3 = __toESM2(require("path"));
-var import_debug4 = __toESM2(require("@prisma/debug"));
+var import_path2 = __toESM2(require("path"));
+var import_debug3 = __toESM2(require("@prisma/debug"));
 var import_engines = require("@prisma/engines");
 var import_fetch_engine = require("@prisma/fetch-engine");
 var import_get_platform = require("@prisma/get-platform");
+var import_path3 = __toESM2(require("path"));
+var import_debug4 = __toESM2(require("@prisma/debug"));
+var import_fs2 = __toESM2(require("fs"));
 var import_path4 = __toESM2(require("path"));
 var import_debug5 = __toESM2(require("@prisma/debug"));
-var import_fs4 = __toESM2(require("fs"));
+var import_fs3 = __toESM2(require("fs"));
 var import_path5 = __toESM2(require("path"));
-var import_debug6 = __toESM2(require("@prisma/debug"));
-var import_fs5 = __toESM2(require("fs"));
-var import_path6 = __toESM2(require("path"));
 var import_get_platform2 = require("@prisma/get-platform");
-var import_fs6 = __toESM2(require("fs"));
+var import_fs4 = __toESM2(require("fs"));
 var import_os = __toESM2(require("os"));
+var import_path6 = __toESM2(require("path"));
+var import_debug6 = __toESM2(require("@prisma/debug"));
+var import_node_path = __toESM2(require("node:path"));
+var import_node_process = __toESM2(require("node:process"));
+var import_node_path2 = __toESM2(require("node:path"));
+var import_node_fs = __toESM2(require("node:fs"));
+var import_node_url = require("node:url");
+var import_node_fs2 = __toESM2(require("node:fs"));
+var import_fs5 = __toESM2(require("fs"));
 var import_path7 = __toESM2(require("path"));
 var import_prompts = __toESM2(require("prompts"));
 var import_get_platform3 = require("@prisma/get-platform");
@@ -139,13 +137,13 @@ var require_readdir_glob = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/readdir-glob@1.1.2/node_modules/readdir-glob/index.js"(exports2, module2) {
     "use strict";
     module2.exports = readdirGlob;
-    var fs10 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    var fs9 = (0, import_chunk_2ESYSVXG.__require)("fs");
     var { EventEmitter } = (0, import_chunk_2ESYSVXG.__require)("events");
     var { Minimatch } = (0, import_chunk_KYMYLH7F.require_minimatch)();
     var { resolve } = (0, import_chunk_2ESYSVXG.__require)("path");
     function readdir(dir2, strict) {
       return new Promise((resolve2, reject2) => {
-        fs10.readdir(dir2, { withFileTypes: true }, (err, files) => {
+        fs9.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -178,7 +176,7 @@ var require_readdir_glob = (0, import_chunk_2ESYSVXG.__commonJS)({
     }
     function stat2(file, followSymlinks) {
       return new Promise((resolve2, reject2) => {
-        const statFunc = followSymlinks ? fs10.stat : fs10.lstat;
+        const statFunc = followSymlinks ? fs9.stat : fs9.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -8248,7 +8246,7 @@ var require_isPlainObject = (0, import_chunk_2ESYSVXG.__commonJS)({
 var require_file = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/archiver-utils@4.0.1/node_modules/archiver-utils/file.js"(exports2, module2) {
     "use strict";
-    var fs10 = (0, import_chunk_RAYPCPVU.require_graceful_fs)();
+    var fs9 = (0, import_chunk_RAYPCPVU.require_graceful_fs)();
     var path11 = (0, import_chunk_2ESYSVXG.__require)("path");
     var flatten = require_flatten();
     var difference = require_difference();
@@ -8275,7 +8273,7 @@ var require_file = (0, import_chunk_2ESYSVXG.__commonJS)({
     };
     file.exists = function() {
       var filepath = path11.join.apply(path11, arguments);
-      return fs10.existsSync(filepath);
+      return fs9.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options2 = isPlainObject(args[0]) ? args.shift() : {};
@@ -8293,7 +8291,7 @@ var require_file = (0, import_chunk_2ESYSVXG.__commonJS)({
             if (typeof options2.filter === "function") {
               return options2.filter(filepath);
             } else {
-              return fs10.statSync(filepath)[options2.filter]();
+              return fs9.statSync(filepath)[options2.filter]();
             }
           } catch (e) {
             return false;
@@ -8400,7 +8398,7 @@ var require_file = (0, import_chunk_2ESYSVXG.__commonJS)({
 var require_archiver_utils = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/archiver-utils@4.0.1/node_modules/archiver-utils/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = (0, import_chunk_RAYPCPVU.require_graceful_fs)();
+    var fs9 = (0, import_chunk_RAYPCPVU.require_graceful_fs)();
     var path11 = (0, import_chunk_2ESYSVXG.__require)("path");
     var lazystream = require_lazystream();
     var normalizePath = require_normalize_path();
@@ -8448,7 +8446,7 @@ var require_archiver_utils = (0, import_chunk_2ESYSVXG.__commonJS)({
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs10.createReadStream(filepath);
+        return fs9.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -8476,7 +8474,7 @@ var require_archiver_utils = (0, import_chunk_2ESYSVXG.__commonJS)({
         callback = base;
         base = dirpath;
       }
-      fs10.readdir(dirpath, function(err, list) {
+      fs9.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -8489,7 +8487,7 @@ var require_archiver_utils = (0, import_chunk_2ESYSVXG.__commonJS)({
             return callback(null, results);
           }
           filepath = path11.join(dirpath, file);
-          fs10.stat(filepath, function(err2, stats) {
+          fs9.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
               relative: path11.relative(base, filepath).replace(/\\/g, "/"),
@@ -8549,7 +8547,7 @@ var require_error = (0, import_chunk_2ESYSVXG.__commonJS)({
 var require_core = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/archiver@6.0.2/node_modules/archiver/lib/core.js"(exports2, module2) {
     "use strict";
-    var fs10 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    var fs9 = (0, import_chunk_2ESYSVXG.__require)("fs");
     var glob = require_readdir_glob();
     var async = (init_async(), (0, import_chunk_2ESYSVXG.__toCommonJS)(async_exports));
     var path11 = (0, import_chunk_2ESYSVXG.__require)("path");
@@ -8613,7 +8611,7 @@ var require_core = (0, import_chunk_2ESYSVXG.__commonJS)({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs10.Stats) {
+      if (data.stats && data.stats instanceof fs9.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -8784,7 +8782,7 @@ var require_core = (0, import_chunk_2ESYSVXG.__commonJS)({
         callback();
         return;
       }
-      fs10.lstat(task.filepath, function(err, stats) {
+      fs9.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -8827,7 +8825,7 @@ var require_core = (0, import_chunk_2ESYSVXG.__commonJS)({
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs10.readlinkSync(task.filepath);
+        var linkPath = fs9.readlinkSync(task.filepath);
         var dirName = path11.dirname(task.filepath);
         task.data.type = "symlink";
         task.data.linkname = path11.relative(dirName, path11.resolve(dirName, linkPath));
@@ -14013,8 +14011,8 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
           status: "disabled"
         };
       }
-      const config2 = await Config.new(state);
-      const cacheResponse = await config2.checkCache(state);
+      const config = await Config.new(state);
+      const cacheResponse = await config.checkCache(state);
       state.check_if_update_available = cacheResponse.stale === true || !cacheResponse.cache;
       const child = spawn(state);
       if (state.unref) {
@@ -14029,7 +14027,7 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
       }
       for (const key of Object.keys(state)) {
         if (state[key]) {
-          await config2.set({
+          await config.set({
             [key]: state[key]
           });
         }
@@ -14041,7 +14039,7 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
           data: cacheResponse.cache.output
         };
       }
-      await config2.set({
+      await config.set({
         last_reminder: state.now()
       });
       return {
@@ -14104,11 +14102,11 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
 var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../../node_modules/.pnpm/tmp@0.2.3/node_modules/tmp/lib/tmp.js"(exports2, module2) {
     "use strict";
-    var fs10 = (0, import_chunk_2ESYSVXG.__require)("fs");
+    var fs9 = (0, import_chunk_2ESYSVXG.__require)("fs");
     var os3 = (0, import_chunk_2ESYSVXG.__require)("os");
     var path11 = (0, import_chunk_2ESYSVXG.__require)("path");
     var crypto3 = (0, import_chunk_2ESYSVXG.__require)("crypto");
-    var _c = { fs: fs10.constants, os: os3.constants };
+    var _c = { fs: fs9.constants, os: os3.constants };
     var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     var TEMPLATE_PATTERN = /XXXXXX/;
     var DEFAULT_TRIES = 3;
@@ -14120,13 +14118,13 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
     var FILE_MODE = 384;
     var EXIT = "exit";
     var _removeObjects = [];
-    var FN_RMDIR_SYNC = fs10.rmdirSync.bind(fs10);
+    var FN_RMDIR_SYNC = fs9.rmdirSync.bind(fs9);
     var _gracefulCleanup = false;
     function rimraf(dirPath, callback) {
-      return fs10.rm(dirPath, { recursive: true }, callback);
+      return fs9.rm(dirPath, { recursive: true }, callback);
     }
     function FN_RIMRAF_SYNC(dirPath) {
-      return fs10.rmSync(dirPath, { recursive: true });
+      return fs9.rmSync(dirPath, { recursive: true });
     }
     function tmpName(options2, callback) {
       const args = _parseArguments(options2, callback), opts = args[0], cb = args[1];
@@ -14139,7 +14137,7 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       (function _getUniqueName() {
         try {
           const name = _generateTmpName(opts);
-          fs10.stat(name, function(err) {
+          fs9.stat(name, function(err) {
             if (!err) {
               if (tries-- > 0) return _getUniqueName();
               return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
@@ -14158,7 +14156,7 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       do {
         const name = _generateTmpName(opts);
         try {
-          fs10.statSync(name);
+          fs9.statSync(name);
         } catch (e) {
           return name;
         }
@@ -14169,10 +14167,10 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       const args = _parseArguments(options2, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs10.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs9.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2) return cb(err2);
           if (opts.discardDescriptor) {
-            return fs10.close(fd, function _discardCallback(possibleErr) {
+            return fs9.close(fd, function _discardCallback(possibleErr) {
               return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
             });
           } else {
@@ -14186,9 +14184,9 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       const args = _parseArguments(options2), opts = args[0];
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      var fd = fs10.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      var fd = fs9.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs10.closeSync(fd);
+        fs9.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -14201,7 +14199,7 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       const args = _parseArguments(options2, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs10.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs9.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2) return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
         });
@@ -14210,7 +14208,7 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
     function dirSync(options2) {
       const args = _parseArguments(options2), opts = args[0];
       const name = tmpNameSync(opts);
-      fs10.mkdirSync(name, opts.mode || DIR_MODE);
+      fs9.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
@@ -14224,20 +14222,20 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
         next();
       };
       if (0 <= fdPath[0])
-        fs10.close(fdPath[0], function() {
-          fs10.unlink(fdPath[1], _handler);
+        fs9.close(fdPath[0], function() {
+          fs9.unlink(fdPath[1], _handler);
         });
-      else fs10.unlink(fdPath[1], _handler);
+      else fs9.unlink(fdPath[1], _handler);
     }
     function _removeFileSync(fdPath) {
       let rethrownException = null;
       try {
-        if (0 <= fdPath[0]) fs10.closeSync(fdPath[0]);
+        if (0 <= fdPath[0]) fs9.closeSync(fdPath[0]);
       } catch (e) {
         if (!_isEBADF(e) && !_isENOENT(e)) throw e;
       } finally {
         try {
-          fs10.unlinkSync(fdPath[1]);
+          fs9.unlinkSync(fdPath[1]);
         } catch (e) {
           if (!_isENOENT(e)) rethrownException = e;
         }
@@ -14253,7 +14251,7 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
       return sync ? removeCallbackSync : removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts, sync) {
-      const removeFunction = opts.unsafeCleanup ? rimraf : fs10.rmdir.bind(fs10);
+      const removeFunction = opts.unsafeCleanup ? rimraf : fs9.rmdir.bind(fs9);
       const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
       const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
       const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
@@ -14414,89 +14412,72 @@ var require_tmp = (0, import_chunk_2ESYSVXG.__commonJS)({
     module2.exports.setGracefulCleanup = setGracefulCleanup;
   }
 });
-var typeMappings = {
-  directory: "isDirectory",
-  file: "isFile"
-};
-function checkType(type) {
-  if (Object.hasOwnProperty.call(typeMappings, type)) {
-    return;
+var debug2 = (0, import_debug2.default)("prisma:format");
+async function formatSchema({ schemas }, inputFormattingOptions) {
+  if (process.env.FORCE_PANIC_PRISMA_SCHEMA) {
+    handleFormatPanic(
+      () => {
+        import_chunk_R7U45FIQ.prismaSchemaWasm.debug_panic();
+      },
+      { schemas }
+    );
   }
-  throw new Error(`Invalid type specified: ${type}`);
-}
-var matchType = (type, stat2) => stat2[typeMappings[type]]();
-var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
-function locatePathSync(paths2, {
-  cwd = import_node_process.default.cwd(),
-  type = "file",
-  allowSymlinks = true
-} = {}) {
-  checkType(type);
-  cwd = toPath2(cwd);
-  const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
-  for (const path_ of paths2) {
-    try {
-      const stat2 = statFunction(import_node_path2.default.resolve(cwd, path_), {
-        throwIfNoEntry: false
-      });
-      if (!stat2) {
-        continue;
-      }
-      if (matchType(type, stat2)) {
-        return path_;
-      }
-    } catch {
+  const defaultFormattingOptions = {
+    tabSize: 2,
+    insertSpaces: true
+  };
+  const documentFormattingParams = {
+    textDocument: { uri: "file:/dev/null" },
+    options: {
+      ...defaultFormattingOptions,
+      ...inputFormattingOptions
     }
+  };
+  const { formattedMultipleSchemas, lintDiagnostics } = handleFormatPanic(
+    () => {
+      const formattedMultipleSchemasRaw = formatWasm(JSON.stringify(schemas), documentFormattingParams);
+      const formattedMultipleSchemas2 = JSON.parse(formattedMultipleSchemasRaw);
+      const lintDiagnostics2 = (0, import_chunk_7CMXNYMQ.lintSchema)({ schemas: formattedMultipleSchemas2 });
+      return { formattedMultipleSchemas: formattedMultipleSchemas2, lintDiagnostics: lintDiagnostics2 };
+    },
+    { schemas }
+  );
+  const lintWarnings = (0, import_chunk_7CMXNYMQ.getLintWarningsAsText)(lintDiagnostics);
+  if (lintWarnings && import_chunk_MBB2KJWX.logger_exports.should.warn()) {
+    console.warn(lintWarnings);
   }
+  return Promise.resolve(formattedMultipleSchemas);
 }
-function pathExistsSync(path11) {
+function handleFormatPanic(tryCb, { schemas }) {
   try {
-    import_node_fs2.default.accessSync(path11);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var findUpStop = Symbol("findUpStop");
-function findUpMultipleSync(name, options2 = {}) {
-  let directory = import_node_path.default.resolve((0, import_chunk_KYMYLH7F.toPath)(options2.cwd) ?? "");
-  const { root } = import_node_path.default.parse(directory);
-  const stopAt = import_node_path.default.resolve(directory, (0, import_chunk_KYMYLH7F.toPath)(options2.stopAt) ?? root);
-  const limit = options2.limit ?? Number.POSITIVE_INFINITY;
-  const paths2 = [name].flat();
-  const runMatcher = (locateOptions) => {
-    if (typeof name !== "function") {
-      return locatePathSync(paths2, locateOptions);
-    }
-    const foundPath = name(locateOptions.cwd);
-    if (typeof foundPath === "string") {
-      return locatePathSync([foundPath], locateOptions);
-    }
-    return foundPath;
-  };
-  const matches = [];
-  while (true) {
-    const foundPath = runMatcher({ ...options2, cwd: directory });
-    if (foundPath === findUpStop) {
-      break;
-    }
-    if (foundPath) {
-      matches.push(import_node_path.default.resolve(directory, foundPath));
-    }
-    if (directory === stopAt || matches.length >= limit) {
-      break;
-    }
-    directory = import_node_path.default.dirname(directory);
+    return tryCb();
+  } catch (e) {
+    const { message, stack } = (0, import_chunk_CCQRDM7X.getWasmError)(e);
+    debug2(`Error formatting schema: ${message}`);
+    debug2(stack);
+    const panic = new import_chunk_CCQRDM7X.RustPanic(
+      /* message */
+      message,
+      /* rustStack */
+      stack,
+      /* request */
+      "@prisma/prisma-schema-wasm format",
+      "FMT_CLI",
+      /* schemaPath */
+      (0, import_chunk_YRBRUREX.debugMultipleSchemaPaths)(schemas),
+      /* schema */
+      schemas
+    );
+    throw panic;
   }
-  return matches;
 }
-function findUpSync(name, options2 = {}) {
-  const matches = findUpMultipleSync(name, { ...options2, limit: 1 });
-  return matches[0];
+function formatWasm(schema, documentFormattingParams) {
+  const formattedSchema = import_chunk_R7U45FIQ.prismaSchemaWasm.format(schema, JSON.stringify(documentFormattingParams));
+  return formattedSchema;
 }
-var readFile = (0, import_util.promisify)(import_fs3.default.readFile);
-var stat = (0, import_util.promisify)(import_fs3.default.stat);
-var debug2 = (0, import_debug3.Debug)("prisma:getSchema");
+var readFile = (0, import_util.promisify)(import_fs.default.readFile);
+var stat = (0, import_util.promisify)(import_fs.default.stat);
+var debug3 = (0, import_debug.Debug)("prisma:getSchema");
 async function getSchemaWithPath(schemaPathFromArgs, schemaPathFromConfig, { cwd = process.cwd(), argumentName = "--schema" } = {}) {
   const result = await getSchemaWithPathInternal(schemaPathFromArgs, schemaPathFromConfig, { cwd, argumentName });
   if (result.ok) {
@@ -14512,7 +14493,7 @@ async function getSchemaWithPathOptional(schemaPathFromArgs, schemaPathFromConfi
   return null;
 }
 async function readSchemaFromSingleFile(schemaPath2) {
-  debug2("Reading schema from single file", schemaPath2);
+  debug3("Reading schema from single file", schemaPath2);
   const typeError = await (0, import_schema_files_loader.ensureType)(schemaPath2, "file");
   if (typeError) {
     return { ok: false, error: typeError };
@@ -14521,23 +14502,23 @@ async function readSchemaFromSingleFile(schemaPath2) {
   const schemaTuple = [schemaPath2, file];
   return {
     ok: true,
-    schema: { schemaPath: schemaPath2, schemaRootDir: import_path2.default.dirname(schemaPath2), schemas: [schemaTuple] }
+    schema: { schemaPath: schemaPath2, schemaRootDir: import_path.default.dirname(schemaPath2), schemas: [schemaTuple] }
   };
 }
 async function readSchemaFromDirectory(schemaPath2) {
-  debug2("Reading schema from multiple files", schemaPath2);
+  debug3("Reading schema from multiple files", schemaPath2);
   const typeError = await (0, import_schema_files_loader.ensureType)(schemaPath2, "directory");
   if (typeError) {
     return { ok: false, error: typeError };
   }
   const files = await (0, import_schema_files_loader.loadSchemaFiles)(schemaPath2);
-  debug2("Loading config");
-  const config2 = await (0, import_chunk_WD2267J3.getConfig)({
+  debug3("Loading config");
+  const config = await (0, import_chunk_2VT4AM4Y.getConfig)({
     datamodel: files,
     ignoreEnvVarErrors: true
   });
-  debug2("Ok");
-  if (!(0, import_schema_files_loader.usesPrismaSchemaFolder)(config2)) {
+  debug3("Ok");
+  if (!(0, import_schema_files_loader.usesPrismaSchemaFolder)(config)) {
     return { ok: false, error: { kind: "FolderPreviewNotEnabled", path: schemaPath2 } };
   }
   return { ok: true, schema: { schemaPath: schemaPath2, schemaRootDir: schemaPath2, schemas: files } };
@@ -14562,10 +14543,10 @@ async function readSchemaFromFileOrDirectory(schemaPath2) {
 }
 async function getSchemaWithPathInternal(schemaPathFromArgs, schemaPathFromConfig, { cwd, argumentName }) {
   if (schemaPathFromArgs) {
-    const absPath = import_path2.default.resolve(cwd, schemaPathFromArgs);
+    const absPath = import_path.default.resolve(cwd, schemaPathFromArgs);
     const customSchemaResult = await readSchemaFromFileOrDirectory(absPath);
     if (!customSchemaResult.ok) {
-      const relPath = import_path2.default.relative(cwd, absPath);
+      const relPath = import_path.default.relative(cwd, absPath);
       throw new Error(
         `Could not load \`${argumentName}\` from provided path \`${relPath}\`: ${renderLookupError(
           customSchemaResult.error
@@ -14615,7 +14596,7 @@ function renderDefaultLookupError(error, cwd) {
   for (const failure of error.failures) {
     const filePath = failure.rule.schemaPath.path;
     if (!printedPaths.has(failure.rule.schemaPath.path)) {
-      parts.push(`${import_path2.default.relative(cwd, filePath)}: ${renderLookupError(failure.error)}`);
+      parts.push(`${import_path.default.relative(cwd, filePath)}: ${renderLookupError(failure.error)}`);
       printedPaths.add(filePath);
     }
   }
@@ -14640,47 +14621,47 @@ async function readSchemaFromPrismaConfigBasedLocation(schemaPathFromConfig) {
       error: { kind: "PrismaConfigNotConfigured" }
     };
   }
-  let schemaResult2;
+  let schemaResult;
   if (schemaPathFromConfig.kind === "single") {
-    schemaResult2 = await readSchemaFromSingleFile(schemaPathFromConfig.filePath);
-    if (!schemaResult2.ok) {
+    schemaResult = await readSchemaFromSingleFile(schemaPathFromConfig.filePath);
+    if (!schemaResult.ok) {
       throw new Error(
-        `Could not load schema from file \`${schemaPathFromConfig.filePath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult2.error)}`
+        `Could not load schema from file \`${schemaPathFromConfig.filePath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult.error)}`
       );
     }
   } else {
-    schemaResult2 = await readSchemaFromDirectory(schemaPathFromConfig.folderPath);
-    if (!schemaResult2.ok) {
+    schemaResult = await readSchemaFromDirectory(schemaPathFromConfig.folderPath);
+    if (!schemaResult.ok) {
       throw new Error(
-        `Could not load schema from folder \`${schemaPathFromConfig.folderPath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult2.error)}`
+        `Could not load schema from folder \`${schemaPathFromConfig.folderPath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult.error)}`
       );
     }
   }
-  return schemaResult2;
+  return schemaResult;
 }
 async function getSchemaFromPackageJson(cwd) {
   const prismaConfig = await getPrismaConfigFromPackageJson(cwd);
-  debug2("prismaConfig", prismaConfig);
+  debug3("prismaConfig", prismaConfig);
   if (!prismaConfig || !prismaConfig.data?.schema) {
     return { ok: false, error: { kind: "PackageJsonNotConfigured" } };
   }
   const schemaPathFromPkgJson = prismaConfig.data.schema;
   if (typeof schemaPathFromPkgJson !== "string") {
     throw new Error(
-      `Provided schema path \`${schemaPathFromPkgJson}\` from \`${import_path2.default.relative(
+      `Provided schema path \`${schemaPathFromPkgJson}\` from \`${import_path.default.relative(
         cwd,
         prismaConfig.packagePath
       )}\` must be of type string`
     );
   }
-  const absoluteSchemaPath = import_path2.default.isAbsolute(schemaPathFromPkgJson) ? schemaPathFromPkgJson : import_path2.default.resolve(import_path2.default.dirname(prismaConfig.packagePath), schemaPathFromPkgJson);
+  const absoluteSchemaPath = import_path.default.isAbsolute(schemaPathFromPkgJson) ? schemaPathFromPkgJson : import_path.default.resolve(import_path.default.dirname(prismaConfig.packagePath), schemaPathFromPkgJson);
   const lookupResult = await readSchemaFromFileOrDirectory(absoluteSchemaPath);
   if (!lookupResult.ok) {
     throw new Error(
-      `Could not load schema from \`${import_path2.default.relative(
+      `Could not load schema from \`${import_path.default.relative(
         cwd,
         absoluteSchemaPath
-      )}\` provided by "prisma.schema" config of \`${import_path2.default.relative(
+      )}\` provided by "prisma.schema" config of \`${import_path.default.relative(
         cwd,
         prismaConfig.packagePath
       )}\`: ${renderLookupError(lookupResult.error)}`
@@ -14691,33 +14672,33 @@ async function getSchemaFromPackageJson(cwd) {
 async function getDefaultSchema(cwd, failures = []) {
   const schemaPrisma = {
     schemaPath: {
-      path: import_path2.default.join(cwd, "schema.prisma"),
+      path: import_path.default.join(cwd, "schema.prisma"),
       kind: "file"
     }
   };
   const prismaSchemaFile = {
     schemaPath: {
-      path: import_path2.default.join(cwd, "prisma", "schema.prisma"),
+      path: import_path.default.join(cwd, "prisma", "schema.prisma"),
       kind: "file"
     },
     conflictsWith: {
-      path: import_path2.default.join(cwd, "prisma", "schema"),
+      path: import_path.default.join(cwd, "prisma", "schema"),
       kind: "directory"
     }
   };
   const prismaSchemaFolder = {
     schemaPath: {
-      path: import_path2.default.join(cwd, "prisma", "schema"),
+      path: import_path.default.join(cwd, "prisma", "schema"),
       kind: "directory"
     },
     conflictsWith: {
-      path: import_path2.default.join(cwd, "prisma", "schema.prisma"),
+      path: import_path.default.join(cwd, "prisma", "schema.prisma"),
       kind: "file"
     }
   };
   const rules = [schemaPrisma, prismaSchemaFile, prismaSchemaFolder];
   for (const rule of rules) {
-    debug2(`Checking existence of ${rule.schemaPath.path}`);
+    debug3(`Checking existence of ${rule.schemaPath.path}`);
     const schema = await loadSchemaFromDefaultLocation(rule.schemaPath);
     if (!schema.ok) {
       failures.push({ rule, error: schema.error });
@@ -14727,7 +14708,7 @@ async function getDefaultSchema(cwd, failures = []) {
       const conflictingSchema = await loadSchemaFromDefaultLocation(rule.conflictsWith);
       if (conflictingSchema.ok) {
         throw new Error(
-          `Found Prisma Schemas at both \`${import_path2.default.relative(cwd, rule.schemaPath.path)}\` and \`${import_path2.default.relative(
+          `Found Prisma Schemas at both \`${import_path.default.relative(cwd, rule.schemaPath.path)}\` and \`${import_path.default.relative(
             cwd,
             rule.conflictsWith.path
           )}\`. Please remove one.`
@@ -14754,125 +14735,18 @@ async function loadSchemaFromDefaultLocation(lookupPath) {
 }
 async function getSchemaDir(schemaPathFromArgs) {
   if (schemaPathFromArgs) {
-    return import_path2.default.resolve(import_path2.default.dirname(schemaPathFromArgs));
+    return import_path.default.resolve(import_path.default.dirname(schemaPathFromArgs));
   }
   const schemaPathResult = await getSchemaWithPath();
   if (!schemaPathResult) {
     return null;
   }
-  return import_path2.default.dirname(schemaPathResult.schemaPath);
+  return import_path.default.dirname(schemaPathResult.schemaPath);
 }
 async function getSchema(schemaPathFromArgs, schemaPathFromConfig) {
   const schemaPathResult = await getSchemaWithPath(schemaPathFromArgs, schemaPathFromConfig);
   return schemaPathResult.schemas;
 }
-var debug3 = (0, import_debug2.default)("prisma:loadEnv");
-async function getEnvPaths(schemaPath2, opts = { cwd: process.cwd() }) {
-  const rootEnvPath = getProjectRootEnvPath({ cwd: opts.cwd }) ?? null;
-  const schemaEnvPathFromArgs = schemaPathToEnvPath(schemaPath2);
-  const schemaEnvPathFromPkgJson = schemaPathToEnvPath(await readSchemaPathFromPkgJson());
-  const schemaEnvPaths = [
-    schemaEnvPathFromArgs,
-    // 1 - Check --schema directory for .env
-    schemaEnvPathFromPkgJson,
-    // 2 - Check package.json schema directory for .env
-    "./prisma/.env",
-    // 3 - Check ./prisma directory for .env
-    "./.env"
-    // 4 - Check cwd for .env
-  ];
-  const schemaEnvPath = schemaEnvPaths.find(import_chunk_ZCVVZ6U6.exists);
-  return { rootEnvPath, schemaEnvPath };
-}
-async function readSchemaPathFromPkgJson() {
-  try {
-    const pkgJsonSchema = await getSchemaFromPackageJson(process.cwd());
-    if (pkgJsonSchema.ok) {
-      pkgJsonSchema.schema.schemaPath;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getProjectRootEnvPath(opts) {
-  const pkgJsonPath = findUpSync((dir2) => {
-    const pkgPath = import_path.default.join(dir2, "package.json");
-    if (pathExistsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf8"));
-        if (pkg["name"] !== ".prisma/client") {
-          debug3(`project root found at ${pkgPath}`);
-          return pkgPath;
-        }
-      } catch (e) {
-        debug3(`skipping package.json at ${pkgPath}`);
-      }
-    }
-    return void 0;
-  }, opts);
-  if (!pkgJsonPath) {
-    return null;
-  }
-  const candidate = import_path.default.join(import_path.default.dirname(pkgJsonPath), ".env");
-  if (!import_fs2.default.existsSync(candidate)) {
-    return null;
-  }
-  return candidate;
-}
-function schemaPathToEnvPath(schemaPath2) {
-  if (!schemaPath2) return null;
-  return import_path.default.join(import_path.default.dirname(schemaPath2), ".env");
-}
-async function loadEnvFile({
-  schemaPath: schemaPath2,
-  config: config2,
-  printMessage = false
-}) {
-  if (config2.loadedFromFile) {
-    process.stdout.write(`Prisma config detected, skipping environment variable loading.
-`);
-    return;
-  }
-  const envPaths2 = await getEnvPaths(schemaPath2);
-  const envData = (0, import_chunk_ZCVVZ6U6.tryLoadEnvs)(envPaths2, { conflictCheck: "error" });
-  if (printMessage && envData && envData.message) {
-    process.stdout.write(envData.message + "\n");
-  }
-}
-var forbiddenCmdWithDataProxyFlagMessage = (command) => `
-Using an Accelerate URL is not supported for this CLI command ${(0, import_chunk_PG5FDKSF.green)(`prisma ${command}`)} yet.
-Please use a direct connection to your database via the datasource \`directUrl\` setting.
-
-More information about this limitation: ${(0, import_chunk_FNA4EAZ6.link)("https://pris.ly/d/accelerate-limitations")}
-`;
-async function checkUnsupportedDataProxyMessage(command, args, schemaPathFromConfig, implicitSchema) {
-  if (implicitSchema === true) {
-    args["--schema"] = (await getSchemaWithPath(args["--schema"], schemaPathFromConfig))?.schemaPath ?? void 0;
-  }
-  const argList = Object.entries(args);
-  for (const [argName, argValue] of argList) {
-    if (argName.includes("url") && argValue.includes("prisma://")) {
-      return forbiddenCmdWithDataProxyFlagMessage(command);
-    }
-    if (argName.includes("schema")) {
-      await loadEnvFile({ schemaPath: argValue, printMessage: false, config: (0, import_config.defaultTestConfig)() });
-      const datamodel = await import_fs.default.promises.readFile(argValue, "utf-8");
-      const config2 = await (0, import_chunk_WD2267J3.getConfig)({ datamodel, ignoreEnvVarErrors: true });
-      const url = (0, import_chunk_WD2267J3.resolveUrl)((0, import_chunk_WD2267J3.getEffectiveUrl)(config2.datasources[0]));
-      if (url?.startsWith("prisma://")) {
-        return forbiddenCmdWithDataProxyFlagMessage(command);
-      }
-    }
-  }
-  return void 0;
-}
-async function checkUnsupportedDataProxy(command, args, schemaPathFromConfig, implicitSchema) {
-  const message = await checkUnsupportedDataProxyMessage(command, args, schemaPathFromConfig, implicitSchema).catch(
-    () => void 0
-  );
-  if (message) throw new Error(message);
-}
 async function getProjectHash(schemaPathFromArgs, schemaPathFromConfig) {
   const projectPath = (await getSchemaWithPath(schemaPathFromArgs, schemaPathFromConfig))?.schemaPath ?? process.cwd();
   return import_crypto.default.createHash("sha256").update(projectPath).digest("hex").substring(0, 8);
@@ -14885,47 +14759,56 @@ async function loadSchemaContext({
   schemaPathFromArg,
   schemaPathFromConfig,
   printLoadMessage = true,
-  allowNull = false
-}) {
-  let schemaResult2 = null;
+  ignoreEnvVarErrors = false,
+  allowNull = false,
+  schemaPathArgumentName = "--schema"
+} = {}) {
+  let schemaResult = null;
   if (allowNull) {
-    schemaResult2 = await getSchemaWithPathOptional(schemaPathFromArg, schemaPathFromConfig);
-    if (!schemaResult2) return null;
+    schemaResult = await getSchemaWithPathOptional(schemaPathFromArg, schemaPathFromConfig, {
+      argumentName: schemaPathArgumentName
+    });
+    if (!schemaResult) return null;
   } else {
-    schemaResult2 = await getSchemaWithPath(schemaPathFromArg, schemaPathFromConfig);
+    schemaResult = await getSchemaWithPath(schemaPathFromArg, schemaPathFromConfig, {
+      argumentName: schemaPathArgumentName
+    });
   }
-  return processSchemaResult({ schemaResult: schemaResult2, printLoadMessage });
+  return processSchemaResult({ schemaResult, printLoadMessage, ignoreEnvVarErrors });
 }
 async function processSchemaResult({
-  schemaResult: schemaResult2,
-  printLoadMessage
+  schemaResult,
+  printLoadMessage = true,
+  ignoreEnvVarErrors = false
 }) {
   const cwd = process.cwd();
-  const loadedFromPathForLogMessages = import_path3.default.relative(cwd, schemaResult2.schemaPath);
+  const loadedFromPathForLogMessages = import_path2.default.relative(cwd, schemaResult.schemaPath);
   if (printLoadMessage) {
     process.stdout.write((0, import_chunk_PG5FDKSF.dim)(`Prisma schema loaded from ${loadedFromPathForLogMessages}`) + "\n");
   }
-  const configFromPsl = await (0, import_chunk_WD2267J3.getConfig)({ datamodel: schemaResult2.schemas });
+  const configFromPsl = await (0, import_chunk_2VT4AM4Y.getConfig)({ datamodel: schemaResult.schemas, ignoreEnvVarErrors });
   const primaryDatasource = configFromPsl.datasources.at(0);
   return {
-    schemaFiles: schemaResult2.schemas,
-    schemaPath: schemaResult2.schemaPath,
-    schemaRootDir: schemaResult2.schemaRootDir || cwd,
+    schemaFiles: schemaResult.schemas,
+    schemaPath: schemaResult.schemaPath,
+    schemaRootDir: schemaResult.schemaRootDir || cwd,
+    datasources: configFromPsl.datasources,
     generators: configFromPsl.generators,
     primaryDatasource,
-    primaryDatasourceDirectory: primaryDatasourceDirectory(primaryDatasource) || schemaResult2.schemaRootDir || cwd,
+    primaryDatasourceDirectory: primaryDatasourceDirectory(primaryDatasource) || schemaResult.schemaRootDir || cwd,
+    warnings: configFromPsl.warnings,
     loadedFromPathForLogMessages
   };
 }
 function primaryDatasourceDirectory(primaryDatasource) {
   const datasourcePath = primaryDatasource?.sourceFilePath;
   if (datasourcePath) {
-    return import_path3.default.dirname(datasourcePath);
+    return import_path2.default.dirname(datasourcePath);
   }
   return null;
 }
 var import_p_map = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_KYMYLH7F.require_p_map)());
-var debug4 = (0, import_debug6.default)("prisma:generator");
+var debug4 = (0, import_debug5.default)("prisma:generator");
 async function checkTypeScriptVersion() {
   const minVersion = "4.1.0";
   try {
@@ -14933,8 +14816,8 @@ async function checkTypeScriptVersion() {
       basedir: process.cwd()
     });
     debug4("typescriptPath", typescriptPath);
-    const typescriptPkg = typescriptPath && import_path6.default.join(typescriptPath, "package.json");
-    if (typescriptPkg && import_fs5.default.existsSync(typescriptPkg)) {
+    const typescriptPkg = typescriptPath && import_path5.default.join(typescriptPath, "package.json");
+    if (typescriptPkg && import_fs3.default.existsSync(typescriptPkg)) {
       const pjson = (0, import_chunk_2ESYSVXG.__require)(typescriptPkg);
       const currentVersion = pjson.version;
       if ((0, import_chunk_EUTJYQDW.semverLt)(currentVersion, minVersion)) {
@@ -14950,7 +14833,7 @@ async function checkTypeScriptVersion() {
   } catch (e) {
   }
 }
-var debug5 = (0, import_debug5.default)("prisma:generator");
+var debug5 = (0, import_debug4.default)("prisma:generator");
 async function prismaClientResolver(baseDir, version3) {
   let prismaClientDir = await (0, import_chunk_DGZO4GAJ.findPrismaClientDir)(baseDir);
   debug5("baseDir", baseDir);
@@ -14969,7 +14852,7 @@ async function prismaClientResolver(baseDir, version3) {
       );
       projectRoot = baseDir;
     }
-    if (!import_fs4.default.existsSync(import_path5.default.join(projectRoot, "package.json"))) {
+    if (!import_fs2.default.existsSync(import_path4.default.join(projectRoot, "package.json"))) {
       console.warn(
         (0, import_chunk_PG5FDKSF.yellow)(
           `${warningTag} Prisma could not find a ${(0, import_chunk_PG5FDKSF.bold)("package.json")} file in the inferred project root ${(0, import_chunk_PG5FDKSF.bold)(
@@ -14996,7 +14879,7 @@ async function prismaClientResolver(baseDir, version3) {
       await (0, import_chunk_ETNCBIDF.runPackageCmd)(projectRoot, "add", `prisma@${version3 ?? "latest"}`, "-D", "--silent");
     }
     await (0, import_chunk_ETNCBIDF.runPackageCmd)(projectRoot, "add", `@prisma/client@${version3 ?? "latest"}`, "--silent");
-    prismaClientDir = await (0, import_chunk_DGZO4GAJ.findPrismaClientDir)(import_path5.default.join(".", baseDir));
+    prismaClientDir = await (0, import_chunk_DGZO4GAJ.findPrismaClientDir)(import_path4.default.join(".", baseDir));
     if (!prismaClientDir) {
       throw new Error(
         `Could not resolve @prisma/client despite the installation that we just tried.
@@ -15020,14 +14903,14 @@ Please try to install it with ${(0, import_chunk_PG5FDKSF.bold)((0, import_chunk
   }
   return {
     outputPath: prismaClientDir,
-    generatorPath: import_path5.default.resolve(prismaClientDir, "generator-build/index.js"),
+    generatorPath: import_path4.default.resolve(prismaClientDir, "generator-build/index.js"),
     isNode: true
   };
 }
 var generatorResolvers = {
   "prisma-client-js": prismaClientResolver
 };
-var debug6 = (0, import_debug4.default)("prisma:getGenerators");
+var debug6 = (0, import_debug3.default)("prisma:getGenerators");
 async function getGenerators(options) {
   const {
     schemaPath,
@@ -15045,21 +14928,14 @@ async function getGenerators(options) {
     allowNoModels,
     typedSql
   } = options;
-  if (!schemaPath) {
-    throw new Error(`schemaPath for getGenerators got invalid value ${schemaPath}`);
+  const schemaContext = !options.schemaContext && schemaPath ? await loadSchemaContext({ schemaPathFromArg: schemaPath, ignoreEnvVarErrors: true }) : options.schemaContext;
+  if (!schemaContext) {
+    throw new Error(`no schema provided for getGenerators`);
   }
-  let schemaResult = null;
-  try {
-    schemaResult = await getSchemaWithPath(schemaPath);
-  } catch (_2) {
-    throw new Error(`${schemaPath} does not exist`);
-  }
-  const { schemas } = schemaResult;
   const binaryTarget = await (0, import_get_platform.getBinaryTargetForCurrentPlatform)();
   const queryEngineBinaryType = (0, import_engines.getCliQueryEngineBinaryType)();
   const queryEngineType = (0, import_chunk_RS2R7COT.binaryTypeToEngineType)(queryEngineBinaryType);
-  let prismaPath = binaryPathsOverride?.[queryEngineType];
-  if (version && !prismaPath) {
+  if (version && !binaryPathsOverride?.[queryEngineType]) {
     const potentialPath = eval(`require('path').join(__dirname, '..')`);
     if (!potentialPath.match(import_chunk_M3GBKLGE.vercelPkgPathRegex)) {
       const downloadParams = {
@@ -15071,35 +14947,25 @@ async function getGenerators(options) {
         version,
         skipDownload
       };
-      const binaryPathsWithEngineType = await (0, import_fetch_engine.download)(downloadParams);
-      prismaPath = binaryPathsWithEngineType[queryEngineBinaryType][binaryTarget];
+      await (0, import_fetch_engine.download)(downloadParams);
     }
   }
-  const config = await (0, import_chunk_WD2267J3.getConfig)({
-    datamodel: schemas,
-    datamodelPath: schemaPath,
-    prismaPath,
-    ignoreEnvVarErrors: true
-  });
-  if (config.datasources.length === 0) {
+  if (!schemaContext.primaryDatasource) {
     throw new Error(import_chunk_2ZPYYZJB.missingDatasource);
   }
-  (0, import_chunk_5FJ3MENK.printConfigWarnings)(config.warnings);
-  const previewFeatures = (0, import_chunk_TSJICM5S.extractPreviewFeatures)(config);
-  const dmmf = await (0, import_chunk_X3CLVIIZ.getDMMF)({
-    datamodel: schemas,
-    datamodelPath: schemaPath,
-    prismaPath,
+  (0, import_chunk_5FJ3MENK.printConfigWarnings)(schemaContext.warnings);
+  const previewFeatures = (0, import_chunk_CRVLHWC5.extractPreviewFeatures)(schemaContext.generators);
+  const dmmf = await (0, import_chunk_VLBKBUPL.getDMMF)({
+    datamodel: schemaContext.schemaFiles,
     previewFeatures
   });
   if (dmmf.datamodel.models.length === 0 && !allowNoModels) {
-    if (config.datasources.some((d2) => d2.provider === "mongodb")) {
+    if (schemaContext.primaryDatasource.provider === "mongodb") {
       throw new Error(import_chunk_HL5VFJX4.missingModelMessageMongoDB);
     }
     throw new Error(import_chunk_HL5VFJX4.missingModelMessage);
   }
-  (0, import_chunk_IPKE37QC.checkFeatureFlags)(config, options);
-  const generatorConfigs = filterGenerators(overrideGenerators || config.generators, generatorNames);
+  const generatorConfigs = filterGenerators(overrideGenerators || schemaContext.generators, generatorNames);
   await validateGenerators(generatorConfigs);
   const runningGenerators = [];
   try {
@@ -15108,7 +14974,7 @@ async function getGenerators(options) {
       async (generator, index2) => {
         let generatorPath = (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.provider);
         let paths2;
-        const baseDir = import_path4.default.dirname(generator.sourceFilePath ?? schemaPath);
+        const baseDir = import_path3.default.dirname(generator.sourceFilePath ?? schemaContext.schemaRootDir);
         const providerValue = (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.provider);
         if (aliases && aliases[providerValue]) {
           generatorPath = aliases[providerValue].generatorPath;
@@ -15121,7 +14987,7 @@ async function getGenerators(options) {
         await generatorInstance.init();
         if (generator.output) {
           generator.output = {
-            value: import_path4.default.resolve(baseDir, (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.output)),
+            value: import_path3.default.resolve(baseDir, (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.output)),
             fromEnvVar: null
           };
           generator.isCustomOutput = true;
@@ -15147,15 +15013,16 @@ The generator needs to either define the \`defaultOutput\` path in the manifest
             fromEnvVar: null
           };
         }
-        const datamodel = (0, import_chunk_2TQR7BKX.mergeSchemas)({ schemas });
-        const envPaths2 = await getEnvPaths(schemaPath, { cwd: generator.output.value });
+        const datamodel = (0, import_chunk_Q6VZHKYE.mergeSchemas)({ schemas: schemaContext.schemaFiles });
+        const envPaths2 = await getEnvPaths(schemaContext.schemaPath, { cwd: generator.output.value });
         const options2 = {
           datamodel,
-          datasources: config.datasources,
+          datasources: schemaContext.datasources,
           generator,
           dmmf,
           otherGenerators: skipIndex(generatorConfigs, index2),
-          schemaPath,
+          schemaPath: schemaContext.schemaPath,
+          // TODO:(schemaPath) can we get rid of schema path passing here?
           version: version || import_engines.enginesVersion,
           // this version makes no sense anymore and should be ignored
           postinstall,
@@ -15230,10 +15097,8 @@ generator gen {
         debug6({ generatorBinaryPaths });
         generator.setBinaryPaths(generatorBinaryPaths);
         if (engineVersion !== version && generator.options && generator.manifest.requiresEngines.includes(queryEngineType) && generatorBinaryPaths[queryEngineType] && generatorBinaryPaths[queryEngineType]?.[binaryTarget]) {
-          const customDmmf = await (0, import_chunk_X3CLVIIZ.getDMMF)({
-            datamodel: schemas,
-            datamodelPath: schemaPath,
-            prismaPath: generatorBinaryPaths[queryEngineType]?.[binaryTarget],
+          const customDmmf = await (0, import_chunk_VLBKBUPL.getDMMF)({
+            datamodel: schemaContext.schemaFiles,
             previewFeatures
           });
           const options2 = { ...generator.options, dmmf: customDmmf };
@@ -15361,7 +15226,7 @@ async function sendPanic({
       return {
         datasource: {
           tag: "Schema",
-          ...(0, import_chunk_JHQHVXIR.toSchemasContainer)(schema2)
+          ...(0, import_chunk_OSHZ4P3G.toSchemasContainer)(schema2)
         }
       };
     }).with({ introspectionUrl: import_chunk_XKZ6CBLA.N.not(void 0) }, ({ introspectionUrl }) => {
@@ -15429,31 +15294,31 @@ async function makeErrorZip(error) {
   if (!error.schemaPath) {
     throw new Error(`Can't make zip without schema path`);
   }
-  const schemaDir = import_path7.default.dirname(error.schemaPath);
+  const schemaDir = import_path6.default.dirname(error.schemaPath);
   const tmpFileObj = import_tmp.default.fileSync();
-  const outputFile = import_fs6.default.createWriteStream(tmpFileObj.name);
+  const outputFile = import_fs4.default.createWriteStream(tmpFileObj.name);
   const zip = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
   zip.pipe(outputFile);
-  const schemaFile = (0, import_chunk_KDHESRKE.maskSchema)(import_fs6.default.readFileSync(error.schemaPath, "utf-8"));
-  zip.append(schemaFile, { name: import_path7.default.basename(error.schemaPath) });
-  if (import_fs6.default.existsSync(schemaDir)) {
+  const schemaFile = (0, import_chunk_KDHESRKE.maskSchema)(import_fs4.default.readFileSync(error.schemaPath, "utf-8"));
+  zip.append(schemaFile, { name: import_path6.default.basename(error.schemaPath) });
+  if (import_fs4.default.existsSync(schemaDir)) {
     const filePaths = await (0, import_globby.default)("migrations/**/*", {
       // globby doesn't have it in its types but it's part of mrmlnc/fast-glob
       // @ts-ignore
       cwd: schemaDir
     });
     for (const filePath of filePaths) {
-      let file = import_fs6.default.readFileSync(import_path7.default.resolve(schemaDir, filePath), "utf-8");
-      if (filePath.endsWith("schema.prisma") || filePath.endsWith(import_path7.default.basename(error.schemaPath))) {
+      let file = import_fs4.default.readFileSync(import_path6.default.resolve(schemaDir, filePath), "utf-8");
+      if (filePath.endsWith("schema.prisma") || filePath.endsWith(import_path6.default.basename(error.schemaPath))) {
         file = (0, import_chunk_KDHESRKE.maskSchema)(file);
       }
-      zip.append(file, { name: import_path7.default.basename(filePath) });
+      zip.append(file, { name: import_path6.default.basename(filePath) });
     }
   }
   zip.finalize();
   return new Promise((resolve, reject2) => {
     outputFile.on("close", () => {
-      const buffer = import_fs6.default.readFileSync(tmpFileObj.name);
+      const buffer = import_fs4.default.readFileSync(tmpFileObj.name);
       resolve(buffer);
     });
     zip.on("error", (err) => {
@@ -15461,6 +15326,144 @@ async function makeErrorZip(error) {
     });
   });
 }
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat2) => stat2[typeMappings[type]]();
+var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
+function locatePathSync(paths2, {
+  cwd = import_node_process.default.cwd(),
+  type = "file",
+  allowSymlinks = true
+} = {}) {
+  checkType(type);
+  cwd = toPath2(cwd);
+  const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
+  for (const path_ of paths2) {
+    try {
+      const stat2 = statFunction(import_node_path2.default.resolve(cwd, path_), {
+        throwIfNoEntry: false
+      });
+      if (!stat2) {
+        continue;
+      }
+      if (matchType(type, stat2)) {
+        return path_;
+      }
+    } catch {
+    }
+  }
+}
+function pathExistsSync(path11) {
+  try {
+    import_node_fs2.default.accessSync(path11);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var findUpStop = Symbol("findUpStop");
+function findUpMultipleSync(name, options2 = {}) {
+  let directory = import_node_path.default.resolve((0, import_chunk_KYMYLH7F.toPath)(options2.cwd) ?? "");
+  const { root } = import_node_path.default.parse(directory);
+  const stopAt = import_node_path.default.resolve(directory, (0, import_chunk_KYMYLH7F.toPath)(options2.stopAt) ?? root);
+  const limit = options2.limit ?? Number.POSITIVE_INFINITY;
+  const paths2 = [name].flat();
+  const runMatcher = (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePathSync(paths2, locateOptions);
+    }
+    const foundPath = name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePathSync([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = runMatcher({ ...options2, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(import_node_path.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = import_node_path.default.dirname(directory);
+  }
+  return matches;
+}
+function findUpSync(name, options2 = {}) {
+  const matches = findUpMultipleSync(name, { ...options2, limit: 1 });
+  return matches[0];
+}
+var debug7 = (0, import_debug6.default)("prisma:loadEnv");
+async function getEnvPaths(schemaPath2, opts = { cwd: process.cwd() }) {
+  const rootEnvPath = getProjectRootEnvPath({ cwd: opts.cwd }) ?? null;
+  const schemaEnvPathFromArgs = schemaPathToEnvPath(schemaPath2);
+  const schemaEnvPathFromPkgJson = schemaPathToEnvPath(await readSchemaPathFromPkgJson());
+  const schemaEnvPaths = [
+    schemaEnvPathFromArgs,
+    // 1 - Check --schema directory for .env
+    schemaEnvPathFromPkgJson,
+    // 2 - Check package.json schema directory for .env
+    "./prisma/.env",
+    // 3 - Check ./prisma directory for .env
+    "./.env"
+    // 4 - Check cwd for .env
+  ];
+  const schemaEnvPath = schemaEnvPaths.find(import_chunk_ZCVVZ6U6.exists);
+  return { rootEnvPath, schemaEnvPath };
+}
+async function readSchemaPathFromPkgJson() {
+  try {
+    const pkgJsonSchema = await getSchemaFromPackageJson(process.cwd());
+    if (pkgJsonSchema.ok) {
+      pkgJsonSchema.schema.schemaPath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getProjectRootEnvPath(opts) {
+  const pkgJsonPath = findUpSync((dir2) => {
+    const pkgPath = import_path7.default.join(dir2, "package.json");
+    if (pathExistsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs5.default.readFileSync(pkgPath, "utf8"));
+        if (pkg["name"] !== ".prisma/client") {
+          debug7(`project root found at ${pkgPath}`);
+          return pkgPath;
+        }
+      } catch (e) {
+        debug7(`skipping package.json at ${pkgPath}`);
+      }
+    }
+    return void 0;
+  }, opts);
+  if (!pkgJsonPath) {
+    return null;
+  }
+  const candidate = import_path7.default.join(import_path7.default.dirname(pkgJsonPath), ".env");
+  if (!import_fs5.default.existsSync(candidate)) {
+    return null;
+  }
+  return candidate;
+}
+function schemaPathToEnvPath(schemaPath2) {
+  if (!schemaPath2) return null;
+  return import_path7.default.join(import_path7.default.dirname(schemaPath2), ".env");
+}
 async function handlePanic(args) {
   if (!(0, import_chunk_R3J2O23S.canPrompt)()) {
     throw args.error;
@@ -15523,68 +15526,43 @@ ${(0, import_chunk_PG5FDKSF.bold)("Thanks a lot for your help! \u{1F64F}")}`);
   });
   process.exit(1);
 }
-var debug7 = (0, import_debug.default)("prisma:format");
-async function formatSchema({ schemas: schemas2 }, inputFormattingOptions) {
-  if (process.env.FORCE_PANIC_PRISMA_SCHEMA) {
-    handleFormatPanic(
-      () => {
-        import_chunk_R7U45FIQ.prismaSchemaWasm.debug_panic();
-      },
-      { schemas: schemas2 }
-    );
+async function loadEnvFile({
+  schemaPath: schemaPath2,
+  config,
+  printMessage = false
+}) {
+  if (config.loadedFromFile) {
+    process.stdout.write(`Prisma config detected, skipping environment variable loading.
+`);
+    return;
   }
-  const defaultFormattingOptions = {
-    tabSize: 2,
-    insertSpaces: true
-  };
-  const documentFormattingParams = {
-    textDocument: { uri: "file:/dev/null" },
-    options: {
-      ...defaultFormattingOptions,
-      ...inputFormattingOptions
-    }
-  };
-  const { formattedMultipleSchemas, lintDiagnostics } = handleFormatPanic(
-    () => {
-      const formattedMultipleSchemasRaw = formatWasm(JSON.stringify(schemas2), documentFormattingParams);
-      const formattedMultipleSchemas2 = JSON.parse(formattedMultipleSchemasRaw);
-      const lintDiagnostics2 = (0, import_chunk_7CMXNYMQ.lintSchema)({ schemas: formattedMultipleSchemas2 });
-      return { formattedMultipleSchemas: formattedMultipleSchemas2, lintDiagnostics: lintDiagnostics2 };
-    },
-    { schemas: schemas2 }
-  );
-  const lintWarnings = (0, import_chunk_7CMXNYMQ.getLintWarningsAsText)(lintDiagnostics);
-  if (lintWarnings && import_chunk_MBB2KJWX.logger_exports.should.warn()) {
-    console.warn(lintWarnings);
+  const envPaths2 = await getEnvPaths(schemaPath2);
+  const envData = (0, import_chunk_ZCVVZ6U6.tryLoadEnvs)(envPaths2, { conflictCheck: "error" });
+  if (printMessage && envData && envData.message) {
+    process.stdout.write(envData.message + "\n");
   }
-  return Promise.resolve(formattedMultipleSchemas);
 }
-function handleFormatPanic(tryCb, { schemas: schemas2 }) {
-  try {
-    return tryCb();
-  } catch (e) {
-    const { message, stack } = (0, import_chunk_CCQRDM7X.getWasmError)(e);
-    debug7(`Error formatting schema: ${message}`);
-    debug7(stack);
-    const panic = new import_chunk_CCQRDM7X.RustPanic(
-      /* message */
-      message,
-      /* rustStack */
-      stack,
-      /* request */
-      "@prisma/prisma-schema-wasm format",
-      "FMT_CLI",
-      /* schemaPath */
-      (0, import_chunk_YRBRUREX.debugMultipleSchemaPaths)(schemas2),
-      /* schema */
-      schemas2
-    );
-    throw panic;
+var forbiddenCmdWithDataProxyFlagMessage = (command) => `
+Using an Accelerate URL is not supported for this CLI command ${(0, import_chunk_PG5FDKSF.green)(`prisma ${command}`)} yet.
+Please use a direct connection to your database via the datasource \`directUrl\` setting.
+
+More information about this limitation: ${(0, import_chunk_FNA4EAZ6.link)("https://pris.ly/d/accelerate-limitations")}
+`;
+function checkUnsupportedDataProxy({
+  cmd,
+  schemaContext: schemaContext2 = void 0,
+  urls = []
+}) {
+  for (const url2 of urls) {
+    if (url2 && url2.includes("prisma://")) {
+      throw new Error(forbiddenCmdWithDataProxyFlagMessage(cmd));
+    }
+  }
+  if (!schemaContext2?.primaryDatasource) return;
+  const url = (0, import_chunk_2VT4AM4Y.resolveUrl)((0, import_chunk_2VT4AM4Y.getEffectiveUrl)(schemaContext2.primaryDatasource));
+  if (url?.startsWith("prisma://")) {
+    throw new Error(forbiddenCmdWithDataProxyFlagMessage(cmd));
   }
-}
-function formatWasm(schema, documentFormattingParams) {
-  const formattedSchema = import_chunk_R7U45FIQ.prismaSchemaWasm.format(schema, JSON.stringify(documentFormattingParams));
-  return formattedSchema;
 }
 /*! Bundled license information: