@prisma/cli-init 0.0.0-dev.202506200250 → 0.0.0-dev.202506210310

package/dist/{_-RME2YFJI.js → _-4N6R32AT.js}

@@ -15,7 +15,7 @@ import {
   platformParameters,
   poll,
   printPpgInitOutput
-} from "./chunk-CHQHEPYP.js";
+} from "./chunk-YE6OKIGR.js";
 import "./chunk-YX4UTTNJ.js";
 export {
   __exports as Accelerate,

package/dist/{accelerate-GABM6I4V.js → accelerate-TY7QIZCU.js}

@@ -16,7 +16,7 @@ import {
   safeParse,
   string,
   union
-} from "./chunk-ASMCGOOW.js";
+} from "./chunk-XE2LPBET.js";
 import "./chunk-YX4UTTNJ.js";
 
 // ../../dev/server/src/accelerate.ts

package/dist/{chunk-ASMCGOOW.js → chunk-XE2LPBET.js}

@@ -756,8 +756,8 @@ import { setTimeout } from "timers/promises";
 // ../../common/stuff/with-resolvers.ts
 function withResolvers(options) {
   let succeed, fail;
-  const promise = new Promise((resolve, reject) => {
-    succeed = resolve;
+  const promise = new Promise((resolve2, reject) => {
+    succeed = resolve2;
     fail = reject;
   });
   let failOnce = (reason) => {
@@ -856,7 +856,7 @@ var K = P?.name || "";
 
 // ../../dev/server/src/filesystem.ts
 import { createWriteStream, WriteStream } from "fs";
-import { access, chmod, constants, mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { access, chmod, constants, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { promisify } from "util";
 import { unzip } from "zlib";
 
@@ -916,6 +916,483 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
   return linux(name);
 }
 
+// ../../node_modules/.pnpm/grammex@3.1.10/node_modules/grammex/dist/utils.js
+var isArray = (value) => {
+  return Array.isArray(value);
+};
+var isFunction = (value) => {
+  return typeof value === "function";
+};
+var isFunctionNullary = (value) => {
+  return value.length === 0;
+};
+var isFunctionStrictlyNullaryOrUnary = (() => {
+  const { toString } = Function.prototype;
+  const re = /(?:^\(\s*(?:[^,.()]|\.(?!\.\.))*\s*\)\s*=>|^\s*[a-zA-Z$_][a-zA-Z0-9$_]*\s*=>)/;
+  return (value) => {
+    return (value.length === 0 || value.length === 1) && re.test(toString.call(value));
+  };
+})();
+var isNumber = (value) => {
+  return typeof value === "number";
+};
+var isObject = (value) => {
+  return typeof value === "object" && value !== null;
+};
+var isRegExp = (value) => {
+  return value instanceof RegExp;
+};
+var isRegExpCapturing = /* @__PURE__ */ (() => {
+  const sourceRe = /\\\(|\((?!\?(?::|=|!|<=|<!))/;
+  return (re) => {
+    return sourceRe.test(re.source);
+  };
+})();
+var isRegExpStatic = /* @__PURE__ */ (() => {
+  const sourceRe = /^[a-zA-Z0-9_-]+$/;
+  return (re) => {
+    return sourceRe.test(re.source) && !re.flags.includes("i");
+  };
+})();
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isUndefined = (value) => {
+  return value === void 0;
+};
+var memoize = (fn) => {
+  const cache = /* @__PURE__ */ new Map();
+  return (arg) => {
+    const cached = cache.get(arg);
+    if (cached !== void 0)
+      return cached;
+    const value = fn(arg);
+    cache.set(arg, value);
+    return value;
+  };
+};
+
+// ../../node_modules/.pnpm/grammex@3.1.10/node_modules/grammex/dist/index.js
+var parse = (input, rule, options = {}) => {
+  const state = { cache: {}, input, index: 0, indexBacktrackMax: 0, options, output: [] };
+  const matched = resolve(rule)(state);
+  const indexMax = Math.max(state.index, state.indexBacktrackMax);
+  if (matched && state.index === input.length) {
+    return state.output;
+  } else {
+    throw new Error(`Failed to parse at index ${indexMax}`);
+  }
+};
+var match = (target, handler) => {
+  if (isArray(target)) {
+    return chars(target, handler);
+  } else if (isString(target)) {
+    return string2(target, handler);
+  } else {
+    return regex2(target, handler);
+  }
+};
+var chars = (target, handler) => {
+  const charCodes = {};
+  for (const char of target) {
+    if (char.length !== 1)
+      throw new Error(`Invalid character: "${char}"`);
+    const charCode = char.charCodeAt(0);
+    charCodes[charCode] = true;
+  }
+  return (state) => {
+    const input = state.input;
+    let indexStart = state.index;
+    let indexEnd = indexStart;
+    while (indexEnd < input.length) {
+      const charCode = input.charCodeAt(indexEnd);
+      if (!(charCode in charCodes))
+        break;
+      indexEnd += 1;
+    }
+    if (indexEnd > indexStart) {
+      if (!isUndefined(handler) && !state.options.silent) {
+        const target2 = input.slice(indexStart, indexEnd);
+        const output = isFunction(handler) ? handler(target2, input, `${indexStart}`) : handler;
+        if (!isUndefined(output)) {
+          state.output.push(output);
+        }
+      }
+      state.index = indexEnd;
+    }
+    return true;
+  };
+};
+var regex2 = (target, handler) => {
+  if (isRegExpStatic(target)) {
+    return string2(target.source, handler);
+  } else {
+    const source = target.source;
+    const flags = target.flags.replace(/y|$/, "y");
+    const re = new RegExp(source, flags);
+    if (isRegExpCapturing(target) && isFunction(handler) && !isFunctionStrictlyNullaryOrUnary(handler)) {
+      return regexCapturing(re, handler);
+    } else {
+      return regexNonCapturing(re, handler);
+    }
+  }
+};
+var regexCapturing = (re, handler) => {
+  return (state) => {
+    const indexStart = state.index;
+    const input = state.input;
+    re.lastIndex = indexStart;
+    const match2 = re.exec(input);
+    if (match2) {
+      const indexEnd = re.lastIndex;
+      if (!state.options.silent) {
+        const output = handler(...match2, input, `${indexStart}`);
+        if (!isUndefined(output)) {
+          state.output.push(output);
+        }
+      }
+      state.index = indexEnd;
+      return true;
+    } else {
+      return false;
+    }
+  };
+};
+var regexNonCapturing = (re, handler) => {
+  return (state) => {
+    const indexStart = state.index;
+    const input = state.input;
+    re.lastIndex = indexStart;
+    const matched = re.test(input);
+    if (matched) {
+      const indexEnd = re.lastIndex;
+      if (!isUndefined(handler) && !state.options.silent) {
+        const output = isFunction(handler) ? handler(input.slice(indexStart, indexEnd), input, `${indexStart}`) : handler;
+        if (!isUndefined(output)) {
+          state.output.push(output);
+        }
+      }
+      state.index = indexEnd;
+      return true;
+    } else {
+      return false;
+    }
+  };
+};
+var string2 = (target, handler) => {
+  return (state) => {
+    const indexStart = state.index;
+    const input = state.input;
+    const matched = input.startsWith(target, indexStart);
+    if (matched) {
+      if (!isUndefined(handler) && !state.options.silent) {
+        const output = isFunction(handler) ? handler(target, input, `${indexStart}`) : handler;
+        if (!isUndefined(output)) {
+          state.output.push(output);
+        }
+      }
+      state.index += target.length;
+      return true;
+    } else {
+      return false;
+    }
+  };
+};
+var repeat = (rule, min, max, handler) => {
+  const erule = resolve(rule);
+  const isBacktrackable = min > 1;
+  return memoizable(handleable(backtrackable((state) => {
+    let repetitions = 0;
+    while (repetitions < max) {
+      const index = state.index;
+      const matched = erule(state);
+      if (!matched)
+        break;
+      repetitions += 1;
+      if (state.index === index)
+        break;
+    }
+    return repetitions >= min;
+  }, isBacktrackable), handler));
+};
+var optional2 = (rule, handler) => {
+  return repeat(rule, 0, 1, handler);
+};
+var star = (rule, handler) => {
+  return repeat(rule, 0, Infinity, handler);
+};
+var and = (rules, handler) => {
+  const erules = rules.map(resolve);
+  return memoizable(handleable(backtrackable((state) => {
+    for (let i2 = 0, l2 = erules.length; i2 < l2; i2++) {
+      if (!erules[i2](state))
+        return false;
+    }
+    return true;
+  }), handler));
+};
+var or = (rules, handler) => {
+  const erules = rules.map(resolve);
+  return memoizable(handleable((state) => {
+    for (let i2 = 0, l2 = erules.length; i2 < l2; i2++) {
+      if (erules[i2](state))
+        return true;
+    }
+    return false;
+  }, handler));
+};
+var backtrackable = (rule, enabled = true, force = false) => {
+  const erule = resolve(rule);
+  if (!enabled)
+    return erule;
+  return (state) => {
+    const index = state.index;
+    const length = state.output.length;
+    const matched = erule(state);
+    if (!matched && !force) {
+      state.indexBacktrackMax = Math.max(state.indexBacktrackMax, state.index);
+    }
+    if (!matched || force) {
+      state.index = index;
+      if (state.output.length !== length) {
+        state.output.length = length;
+      }
+    }
+    return matched;
+  };
+};
+var handleable = (rule, handler) => {
+  const erule = resolve(rule);
+  if (!handler)
+    return erule;
+  return (state) => {
+    if (state.options.silent)
+      return erule(state);
+    const length = state.output.length;
+    const matched = erule(state);
+    if (matched) {
+      const outputs = state.output.splice(length, Infinity);
+      const output = handler(outputs);
+      if (!isUndefined(output)) {
+        state.output.push(output);
+      }
+      return true;
+    } else {
+      return false;
+    }
+  };
+};
+var memoizable = /* @__PURE__ */ (() => {
+  let RULE_ID = 0;
+  return (rule) => {
+    const erule = resolve(rule);
+    const ruleId = RULE_ID += 1;
+    return (state) => {
+      var _a;
+      if (state.options.memoization === false)
+        return erule(state);
+      const indexStart = state.index;
+      const cache = (_a = state.cache)[ruleId] || (_a[ruleId] = { indexMax: -1, queue: [] });
+      const cacheQueue = cache.queue;
+      const isPotentiallyCached = indexStart <= cache.indexMax;
+      if (isPotentiallyCached) {
+        const cacheStore = cache.store || (cache.store = /* @__PURE__ */ new Map());
+        if (cacheQueue.length) {
+          for (let i2 = 0, l2 = cacheQueue.length; i2 < l2; i2 += 2) {
+            const key = cacheQueue[i2 * 2];
+            const value = cacheQueue[i2 * 2 + 1];
+            cacheStore.set(key, value);
+          }
+          cacheQueue.length = 0;
+        }
+        const cached = cacheStore.get(indexStart);
+        if (cached === false) {
+          return false;
+        } else if (isNumber(cached)) {
+          state.index = cached;
+          return true;
+        } else if (cached) {
+          state.index = cached.index;
+          if (cached.output?.length) {
+            state.output.push(...cached.output);
+          }
+          return true;
+        }
+      }
+      const lengthStart = state.output.length;
+      const matched = erule(state);
+      cache.indexMax = Math.max(cache.indexMax, indexStart);
+      if (matched) {
+        const indexEnd = state.index;
+        const lengthEnd = state.output.length;
+        if (lengthEnd > lengthStart) {
+          const output = state.output.slice(lengthStart, lengthEnd);
+          cacheQueue.push(indexStart, { index: indexEnd, output });
+        } else {
+          cacheQueue.push(indexStart, indexEnd);
+        }
+        return true;
+      } else {
+        cacheQueue.push(indexStart, false);
+        return false;
+      }
+    };
+  };
+})();
+var lazy = (getter) => {
+  let erule;
+  return (state) => {
+    erule || (erule = resolve(getter()));
+    return erule(state);
+  };
+};
+var resolve = memoize((rule) => {
+  if (isFunction(rule)) {
+    if (isFunctionNullary(rule)) {
+      return lazy(rule);
+    } else {
+      return rule;
+    }
+  }
+  if (isString(rule) || isRegExp(rule)) {
+    return match(rule);
+  }
+  if (isArray(rule)) {
+    return and(rule);
+  }
+  if (isObject(rule)) {
+    return or(Object.values(rule));
+  }
+  throw new Error("Invalid rule");
+});
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/utils.js
+var identity = (value) => {
+  return value;
+};
+var makeParser = (grammar) => {
+  return (input) => {
+    return parse(input, grammar, { memoization: false }).join("");
+  };
+};
+var memoize2 = (fn) => {
+  const cache = {};
+  return (arg) => {
+    return cache[arg] ?? (cache[arg] = fn(arg));
+  };
+};
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/range.js
+var ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+var int2alpha = (int) => {
+  let alpha = "";
+  while (int > 0) {
+    const reminder = (int - 1) % 26;
+    alpha = ALPHABET[reminder] + alpha;
+    int = Math.floor((int - 1) / 26);
+  }
+  return alpha;
+};
+var alpha2int = (str) => {
+  let int = 0;
+  for (let i2 = 0, l2 = str.length; i2 < l2; i2++) {
+    int = int * 26 + ALPHABET.indexOf(str[i2]) + 1;
+  }
+  return int;
+};
+var makeRangeInt = (start, end) => {
+  if (end < start)
+    return makeRangeInt(end, start);
+  const range = [];
+  while (start <= end) {
+    range.push(start++);
+  }
+  return range;
+};
+var makeRangePaddedInt = (start, end, paddingLength) => {
+  return makeRangeInt(start, end).map((int) => String(int).padStart(paddingLength, "0"));
+};
+var makeRangeAlpha = (start, end) => {
+  return makeRangeInt(alpha2int(start), alpha2int(end)).map(int2alpha);
+};
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/convert/grammar.js
+var Escaped = match(/\\./, identity);
+var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => `\\${char}`);
+var Slash = match(/[\\/]/, "[\\\\/]");
+var Passthrough = match(/./, identity);
+var NegationOdd = match(/^(?:!!)*!(.*)$/, (_2, glob) => `(?!^${parser_default(glob)}$).*?`);
+var NegationEven = match(/^(!!)+/, "");
+var Negation = or([NegationOdd, NegationEven]);
+var StarStarBetween = match(/\/(\*\*\/)+/, "(?:[\\\\/].+[\\\\/]|[\\\\/])");
+var StarStarStart = match(/^(\*\*\/)+/, "(?:^|.*[\\\\/])");
+var StarStarEnd = match(/\/(\*\*)$/, "(?:[\\\\/].*|$)");
+var StarStarNone = match(/\*\*/, ".*");
+var StarStar = or([StarStarBetween, StarStarStart, StarStarEnd, StarStarNone]);
+var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, "[^\\\\/]*[\\\\/]");
+var StarSingle = match(/\*/, "[^\\\\/]*");
+var Star = or([StarDouble, StarSingle]);
+var Question = match("?", "[^\\\\/]");
+var ClassOpen = match("[", identity);
+var ClassClose = match("]", identity);
+var ClassNegation = match(/[!^]/, "^\\\\/");
+var ClassRange = match(/[a-z]-[a-z]|[0-9]-[0-9]/i, identity);
+var ClassEscape = match(/[$.*+?^(){}[\|]/, (char) => `\\${char}`);
+var ClassPassthrough = match(/[^\]]/, identity);
+var ClassValue = or([Escaped, ClassEscape, ClassRange, ClassPassthrough]);
+var Class = and([ClassOpen, optional2(ClassNegation), star(ClassValue), ClassClose]);
+var RangeOpen = match("{", "(?:");
+var RangeClose = match("}", ")");
+var RangeNumeric = match(/(\d+)\.\.(\d+)/, (_2, $1, $2) => makeRangePaddedInt(+$1, +$2, Math.min($1.length, $2.length)).join("|"));
+var RangeAlphaLower = match(/([a-z]+)\.\.([a-z]+)/, (_2, $1, $2) => makeRangeAlpha($1, $2).join("|"));
+var RangeAlphaUpper = match(/([A-Z]+)\.\.([A-Z]+)/, (_2, $1, $2) => makeRangeAlpha($1.toLowerCase(), $2.toLowerCase()).join("|").toUpperCase());
+var RangeValue = or([RangeNumeric, RangeAlphaLower, RangeAlphaUpper]);
+var Range = and([RangeOpen, RangeValue, RangeClose]);
+var BracesOpen = match("{", "(?:");
+var BracesClose = match("}", ")");
+var BracesComma = match(",", "|");
+var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => `\\${char}`);
+var BracesPassthrough = match(/[^}]/, identity);
+var BracesNested = lazy(() => Braces);
+var BracesValue = or([StarStar, Star, Question, Class, Range, BracesNested, Escaped, BracesEscape, BracesComma, BracesPassthrough]);
+var Braces = and([BracesOpen, star(BracesValue), BracesClose]);
+var Grammar = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped, Escape, Slash, Passthrough]));
+var grammar_default = Grammar;
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/convert/parser.js
+var parser = makeParser(grammar_default);
+var parser_default = parser;
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/normalize/grammar.js
+var Escaped2 = match(/\\./, identity);
+var Passthrough2 = match(/./, identity);
+var StarStarStar = match(/\*\*\*+/, "*");
+var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_2, $1) => `${$1}*`);
+var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_2, $1) => `${$1}*`);
+var Grammar2 = star(or([Escaped2, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough2]));
+var grammar_default2 = Grammar2;
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/normalize/parser.js
+var parser2 = makeParser(grammar_default2);
+var parser_default2 = parser2;
+
+// ../../node_modules/.pnpm/zeptomatch@2.0.2/node_modules/zeptomatch/dist/index.js
+var zeptomatch = (glob, path2) => {
+  if (Array.isArray(glob)) {
+    const res = glob.map(zeptomatch.compile);
+    const isMatch = res.some((re) => re.test(path2));
+    return isMatch;
+  } else {
+    const re = zeptomatch.compile(glob);
+    const isMatch = re.test(path2);
+    return isMatch;
+  }
+};
+zeptomatch.compile = memoize2((glob) => {
+  return new RegExp(`^${parser_default(parser_default2(glob))}[\\\\/]?$`, "s");
+});
+var dist_default = zeptomatch;
+
 // ../../dev/server/src/filesystem.ts
 var GLOBAL_DIR_ROOT_PATH = envPaths("prisma-dev");
 var unzipAsync = promisify(unzip);
@@ -960,11 +1437,11 @@ async function readFileAsText(path2) {
 async function ensureDirectory(path2) {
   await mkdir(path2, { recursive: true });
 }
-async function readDirectoryNames(path2) {
+async function readDirectoryNames(path2, globs) {
   try {
     const dirents = await readdir(path2, { withFileTypes: true });
     return dirents.reduce((names, dirent) => {
-      if (dirent.isDirectory() && !dirent.name.startsWith(".")) {
+      if (dirent.isDirectory() && !dirent.name.startsWith(".") && (!globs || dist_default(globs, dirent.name))) {
         names.push(dirent.name);
       }
       return names;
@@ -1064,7 +1541,7 @@ var Engine = class _Engine {
     if (this.#session != null) {
       return await this.#session;
     }
-    const { promise: session, reject, resolve } = withResolvers();
+    const { promise: session, reject, resolve: resolve2 } = withResolvers();
     this.#session = session;
     const engineBinaryPath = PRISMA_DEV_FORCE_ENGINE_BINARY_PATH || await this.#getEngineBinaryPath();
     if (this.#options.debug) {
@@ -1108,7 +1585,7 @@ Received data: ${data}`
           )
         );
       }
-      resolve({ childProcess, url: `http://${ip}:${port}` });
+      resolve2({ childProcess, url: `http://${ip}:${port}` });
     };
     const errorListener = (error) => {
       this.#session = null;

package/dist/{chunk-CHQHEPYP.js → chunk-YE6OKIGR.js}

@@ -344,7 +344,7 @@ import internals5 from "@prisma/internals";
 import * as Checkpoint from "checkpoint-client";
 
 // package.json
-var version = "0.0.0-dev.202506200250";
+var version = "0.0.0-dev.202506210310";
 
 // src/platform/_lib/userAgent.ts
 var debug = Debug("prisma:cli:platform:_lib:userAgent");

package/dist/index.js

@@ -21,14 +21,14 @@ import {
   url,
   withResolvers,
   y
-} from "./chunk-ASMCGOOW.js";
+} from "./chunk-XE2LPBET.js";
 import {
   credentialsFile,
   poll,
   printPpgInitOutput,
   requestOrThrow,
   successMessage
-} from "./chunk-CHQHEPYP.js";
+} from "./chunk-YE6OKIGR.js";
 import {
   __commonJS,
   __require,
@@ -2645,7 +2645,7 @@ async function getApp(port, dbServer, serverState) {
   const { debug } = serverState;
   const [{ Hono }, { accelerateRoute }, { utilityRoute }] = await Promise.all([
     import("hono/tiny"),
-    import("./accelerate-GABM6I4V.js"),
+    import("./accelerate-TY7QIZCU.js"),
     import("./utility-W6LOZZIT.js")
   ]);
   const app = new Hono();
@@ -2787,12 +2787,12 @@ ${JSON.stringify(issues, null, 2)}`);
     });
   }
   static async scan(options) {
-    const { debug } = options ?? {};
+    const { debug, globs } = options ?? {};
     const dataDirsPath = join(getDataDirPath(DEFAULT_NAME), "..");
     if (debug) {
       console.debug(`[State] scanning for server states in: ${dataDirsPath}`);
     }
-    const names = await readDirectoryNames(dataDirsPath);
+    const names = await readDirectoryNames(dataDirsPath, globs);
     if (debug) {
       console.debug(`[State] found server names: ${JSON.stringify(names)}`);
     }
@@ -2905,6 +2905,13 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
       throw error;
     }
   }
+  async killProcess() {
+    const { pid, status } = await getServerStatus(this, { debug: this.debug });
+    if (pid == null || status !== "running" && status !== "starting_up") {
+      return false;
+    }
+    return y.kill?.(pid, "SIGTERM") || false;
+  }
   async writeServerDump(exports) {
     this.#serverDump = {
       name: this.name,
@@ -2919,19 +2926,21 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
 `, { encoding: "utf-8" });
   }
 };
-async function getServerStatus(name, options) {
+async function getServerStatus(nameOrState, options) {
   const { debug, onlyMetadata } = options || {};
+  const name = typeof nameOrState === "string" ? nameOrState : nameOrState.name;
+  const givenState = typeof nameOrState !== "string" ? nameOrState : void 0;
   const baseResult = {
-    databasePort: -1,
-    exports: void 0,
+    databasePort: givenState?.databasePort ?? -1,
+    exports: givenState?.exports,
     name,
-    pid: void 0,
-    port: -1,
-    shadowDatabasePort: -1,
+    pid: givenState?.pid,
+    port: givenState?.port ?? -1,
+    shadowDatabasePort: givenState?.shadowDatabasePort ?? -1,
     version: "1"
   };
   try {
-    const serverState = await ServerState.fromServerDump({ debug, name });
+    const serverState = givenState || await ServerState.fromServerDump({ debug, name });
     if (!serverState) {
       if (debug) {
         console.debug(`[State] no server state found for name: ${name}`);
@@ -2979,14 +2988,14 @@ async function getServerStatus(name, options) {
       return { ...baseResult, status: "not_running" };
     }
     const health = await healthResponse.json();
-    if (health.name !== name) {
+    if (health.name !== nameOrState) {
       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)}`);
+      console.debug(`[State] server state for "${nameOrState}" is live: ${JSON.stringify(health)}`);
     }
     return { ...baseResult, status: "running" };
   } catch (error) {
@@ -3399,7 +3408,7 @@ var Init = class _Init {
     let generatedSchema;
     let generatedName;
     if (isPpgCommand) {
-      const PlatformCommands = await import("./_-RME2YFJI.js");
+      const PlatformCommands = await import("./_-4N6R32AT.js");
       const credentials = await credentialsFile.load();
       if (internals.isError(credentials))
         throw credentials;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli-init",
-  "version": "0.0.0-dev.202506200250",
+  "version": "0.0.0-dev.202506210310",
   "description": "Init CLI for Prisma",
   "type": "module",
   "sideEffects": false,