@prisma-next/sql-runtime 0.1.0-dev.15 → 0.1.0-dev.17

package/dist/chunk-XPLNMXQV.js

@@ -0,0 +1,1537 @@
+// ../../../node_modules/.pnpm/@prisma+dev@0.19.1_typescript@5.9.3/node_modules/@prisma/dev/dist/chunk-ITQ6ILGR.js
+import { createWriteStream as w, WriteStream as A } from "fs";
+import { access as D, chmod as x, constants as P, mkdir as T, readdir as E, readFile as _, rm as F, writeFile as O } from "fs/promises";
+import { promisify as v } from "util";
+import { unzip as C } from "zlib";
+import o from "path";
+import g from "os";
+import c from "process";
+
+// ../../../node_modules/.pnpm/graphmatch@1.1.0/node_modules/graphmatch/dist/utils.js
+var getNodes = (node) => {
+  const nodes = /* @__PURE__ */ new Set();
+  const queue = [node];
+  for (let i2 = 0; i2 < queue.length; i2++) {
+    const node2 = queue[i2];
+    if (nodes.has(node2))
+      continue;
+    nodes.add(node2);
+    const { children } = node2;
+    if (!children?.length)
+      continue;
+    for (let ci = 0, cl = children.length; ci < cl; ci++) {
+      queue.push(children[ci]);
+    }
+  }
+  return Array.from(nodes);
+};
+var getNodeFlags = (node) => {
+  let flags = "";
+  const nodes = getNodes(node);
+  for (let i2 = 0, l3 = nodes.length; i2 < l3; i2++) {
+    const node2 = nodes[i2];
+    if (!node2.regex)
+      continue;
+    const nodeFlags = node2.regex.flags;
+    flags || (flags = nodeFlags);
+    if (flags === nodeFlags)
+      continue;
+    throw new Error(`Inconsistent RegExp flags used: "${flags}" and "${nodeFlags}"`);
+  }
+  return flags;
+};
+var getNodeSourceWithCache = (node, partial, cache) => {
+  const cached = cache.get(node);
+  if (cached !== void 0)
+    return cached;
+  const isNodePartial = node.partial ?? partial;
+  let source = "";
+  if (node.regex) {
+    source += isNodePartial ? "(?:$|" : "";
+    source += node.regex.source;
+  }
+  if (node.children?.length) {
+    const children = uniq(node.children.map((node2) => getNodeSourceWithCache(node2, partial, cache)).filter(Boolean));
+    if (children?.length) {
+      const isSomeChildNonPartial = node.children.some((child) => !child.regex || !(child.partial ?? partial));
+      const needsWrapperGroup = children.length > 1 || isNodePartial && (!source.length || isSomeChildNonPartial);
+      source += needsWrapperGroup ? isNodePartial ? "(?:$|" : "(?:" : "";
+      source += children.join("|");
+      source += needsWrapperGroup ? ")" : "";
+    }
+  }
+  if (node.regex) {
+    source += isNodePartial ? ")" : "";
+  }
+  cache.set(node, source);
+  return source;
+};
+var getNodeSource = (node, partial) => {
+  const cache = /* @__PURE__ */ new Map();
+  const nodes = getNodes(node);
+  for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+    const source = getNodeSourceWithCache(nodes[i2], partial, cache);
+    if (i2 > 0)
+      continue;
+    return source;
+  }
+  return "";
+};
+var uniq = (values) => {
+  return Array.from(new Set(values));
+};
+
+// ../../../node_modules/.pnpm/graphmatch@1.1.0/node_modules/graphmatch/dist/index.js
+var graphmatch = (node, input, options) => {
+  return graphmatch.compile(node, options).test(input);
+};
+graphmatch.compile = (node, options) => {
+  const partial = options?.partial ?? false;
+  const source = getNodeSource(node, partial);
+  const flags = getNodeFlags(node);
+  return new RegExp(`^(?:${source})$`, flags);
+};
+var dist_default = graphmatch;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/compile/index.js
+var compile = (node, options) => {
+  const re = dist_default.compile(node, options);
+  const source = `${re.source.slice(0, -1)}[\\\\/]?$`;
+  const flags = re.flags;
+  return new RegExp(source, flags);
+};
+var compile_default = compile;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/merge/index.js
+var merge = (res) => {
+  const source = res.map((re) => re.source).join("|") || "$^";
+  const flags = res[0]?.flags;
+  return new RegExp(source, flags);
+};
+var merge_default = merge;
+
+// ../../../node_modules/.pnpm/grammex@3.1.12/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.12/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 string(target, handler);
+  } else {
+    return regex(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 regex = (target, handler) => {
+  if (isRegExpStatic(target)) {
+    return string(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 string = (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 optional = (rule, handler) => {
+  return repeat(rule, 0, 1, handler);
+};
+var star = (rule, handler) => {
+  return repeat(rule, 0, Infinity, handler);
+};
+var plus = (rule, handler) => {
+  return repeat(rule, 1, Infinity, handler);
+};
+var and = (rules, handler) => {
+  const erules = rules.map(resolve);
+  return memoizable(handleable(backtrackable((state) => {
+    for (let i2 = 0, l3 = erules.length; i2 < l3; 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, l3 = erules.length; i2 < l3; 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, l3 = cacheQueue.length; i2 < l3; 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.1.0/node_modules/zeptomatch/dist/utils.js
+var identity = (value) => {
+  return value;
+};
+var isString2 = (value) => {
+  return typeof value === "string";
+};
+var memoizeByObject = (fn) => {
+  const cacheFull = /* @__PURE__ */ new WeakMap();
+  const cachePartial = /* @__PURE__ */ new WeakMap();
+  return (globs, options) => {
+    const cache = options?.partial ? cachePartial : cacheFull;
+    const cached = cache.get(globs);
+    if (cached !== void 0)
+      return cached;
+    const result = fn(globs, options);
+    cache.set(globs, result);
+    return result;
+  };
+};
+var memoizeByPrimitive = (fn) => {
+  const cacheFull = {};
+  const cachePartial = {};
+  return (glob, options) => {
+    const cache = options?.partial ? cachePartial : cacheFull;
+    return cache[glob] ?? (cache[glob] = fn(glob, options));
+  };
+};
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/normalize/grammar.js
+var Escaped = match(/\\./, identity);
+var Passthrough = match(/./, identity);
+var StarStarStar = match(/\*\*\*+/, "*");
+var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_3, $1) => `${$1}*`);
+var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_3, $1) => `${$1}*`);
+var Grammar = star(or([Escaped, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough]));
+var grammar_default = Grammar;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/normalize/index.js
+var normalize = (glob) => {
+  return parse(glob, grammar_default, { memoization: false }).join("");
+};
+var normalize_default = normalize;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/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, l3 = str.length; i2 < l3; 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.1.0/node_modules/zeptomatch/dist/parse/utils.js
+var regex2 = (source) => {
+  const regex4 = new RegExp(source, "s");
+  return { partial: false, regex: regex4, children: [] };
+};
+var alternation = (children) => {
+  return { children };
+};
+var sequence = /* @__PURE__ */ (() => {
+  const pushToLeaves = (parent, child, handled) => {
+    if (handled.has(parent))
+      return;
+    handled.add(parent);
+    const { children } = parent;
+    if (!children.length) {
+      children.push(child);
+    } else {
+      for (let i2 = 0, l3 = children.length; i2 < l3; i2++) {
+        pushToLeaves(children[i2], child, handled);
+      }
+    }
+  };
+  return (nodes) => {
+    if (!nodes.length) {
+      return alternation([]);
+    }
+    for (let i2 = nodes.length - 1; i2 >= 1; i2--) {
+      const handled = /* @__PURE__ */ new Set();
+      const parent = nodes[i2 - 1];
+      const child = nodes[i2];
+      pushToLeaves(parent, child, handled);
+    }
+    return nodes[0];
+  };
+})();
+var slash = () => {
+  const regex4 = new RegExp("[\\\\/]", "s");
+  return { regex: regex4, children: [] };
+};
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/parse/grammar.js
+var Escaped2 = match(/\\./, regex2);
+var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => regex2(`\\${char}`));
+var Slash = match(/[\\\/]/, slash);
+var Passthrough2 = match(/[^$.*+?^(){}[\]\|\\\/]+/, regex2);
+var NegationOdd = match(/^(?:!!)*!(.*)$/, (_3, glob) => regex2(`(?!^${dist_default2.compile(glob).source}$).*?`));
+var NegationEven = match(/^(!!)+/);
+var Negation = or([NegationOdd, NegationEven]);
+var StarStarBetween = match(/\/(\*\*\/)+/, () => alternation([sequence([slash(), regex2(".+?"), slash()]), slash()]));
+var StarStarStart = match(/^(\*\*\/)+/, () => alternation([regex2("^"), sequence([regex2(".*?"), slash()])]));
+var StarStarEnd = match(/\/(\*\*)$/, () => alternation([sequence([slash(), regex2(".*?")]), regex2("$")]));
+var StarStarNone = match(/\*\*/, () => regex2(".*?"));
+var StarStar = or([StarStarBetween, StarStarStart, StarStarEnd, StarStarNone]);
+var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, () => sequence([regex2("[^\\\\/]*?"), slash()]));
+var StarSingle = match(/\*/, () => regex2("[^\\\\/]*"));
+var Star = or([StarDouble, StarSingle]);
+var Question = match("?", () => regex2("[^\\\\/]"));
+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 ClassEscaped = match(/\\./, identity);
+var ClassEscape = match(/[$.*+?^(){}[\|]/, (char) => `\\${char}`);
+var ClassSlash = match(/[\\\/]/, "\\\\/");
+var ClassPassthrough = match(/[^$.*+?^(){}[\]\|\\\/]+/, identity);
+var ClassValue = or([ClassEscaped, ClassEscape, ClassSlash, ClassRange, ClassPassthrough]);
+var Class = and([ClassOpen, optional(ClassNegation), star(ClassValue), ClassClose], (_3) => regex2(_3.join("")));
+var RangeOpen = match("{", "(?:");
+var RangeClose = match("}", ")");
+var RangeNumeric = match(/(\d+)\.\.(\d+)/, (_3, $1, $2) => makeRangePaddedInt(+$1, +$2, Math.min($1.length, $2.length)).join("|"));
+var RangeAlphaLower = match(/([a-z]+)\.\.([a-z]+)/, (_3, $1, $2) => makeRangeAlpha($1, $2).join("|"));
+var RangeAlphaUpper = match(/([A-Z]+)\.\.([A-Z]+)/, (_3, $1, $2) => makeRangeAlpha($1.toLowerCase(), $2.toLowerCase()).join("|").toUpperCase());
+var RangeValue = or([RangeNumeric, RangeAlphaLower, RangeAlphaUpper]);
+var Range = and([RangeOpen, RangeValue, RangeClose], (_3) => regex2(_3.join("")));
+var BracesOpen = match("{");
+var BracesClose = match("}");
+var BracesComma = match(",");
+var BracesEscaped = match(/\\./, regex2);
+var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => regex2(`\\${char}`));
+var BracesSlash = match(/[\\\/]/, slash);
+var BracesPassthrough = match(/[^$.*+?^(){}[\]\|\\\/,]+/, regex2);
+var BracesNested = lazy(() => Braces);
+var BracesEmptyValue = match("", () => regex2("(?:)"));
+var BracesFullValue = plus(or([StarStar, Star, Question, Class, Range, BracesNested, BracesEscaped, BracesEscape, BracesSlash, BracesPassthrough]), sequence);
+var BracesValue = or([BracesFullValue, BracesEmptyValue]);
+var Braces = and([BracesOpen, optional(and([BracesValue, star(and([BracesComma, BracesValue]))])), BracesClose], alternation);
+var Grammar2 = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped2, Escape, Slash, Passthrough2]), sequence);
+var grammar_default2 = Grammar2;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/parse/index.js
+var _parse = (glob) => {
+  return parse(glob, grammar_default2, { memoization: false })[0];
+};
+var parse_default = _parse;
+
+// ../../../node_modules/.pnpm/zeptomatch@2.1.0/node_modules/zeptomatch/dist/index.js
+var zeptomatch = (glob, path, options) => {
+  return zeptomatch.compile(glob, options).test(path);
+};
+zeptomatch.compile = (() => {
+  const compileGlob = memoizeByPrimitive((glob, options) => {
+    return compile_default(parse_default(normalize_default(glob)), options);
+  });
+  const compileGlobs = memoizeByObject((globs, options) => {
+    return merge_default(globs.map((glob) => compileGlob(glob, options)));
+  });
+  return (glob, options) => {
+    if (isString2(glob)) {
+      return compileGlob(glob, options);
+    } else {
+      return compileGlobs(glob, options);
+    }
+  };
+})();
+var dist_default2 = zeptomatch;
+
+// ../../../node_modules/.pnpm/@prisma+dev@0.19.1_typescript@5.9.3/node_modules/@prisma/dev/dist/chunk-ITQ6ILGR.js
+var n = g.homedir();
+var a = g.tmpdir();
+var { env: e } = c;
+var h = (t2) => {
+  let r4 = o.join(n, "Library");
+  return { data: o.join(r4, "Application Support", t2), config: o.join(r4, "Preferences", t2), cache: o.join(r4, "Caches", t2), log: o.join(r4, "Logs", t2), temp: o.join(a, t2) };
+};
+var y = (t2) => {
+  let r4 = e.APPDATA || o.join(n, "AppData", "Roaming"), i2 = e.LOCALAPPDATA || o.join(n, "AppData", "Local");
+  return { data: o.join(i2, t2, "Data"), config: o.join(r4, t2, "Config"), cache: o.join(i2, t2, "Cache"), log: o.join(i2, t2, "Log"), temp: o.join(a, t2) };
+};
+var j = (t2) => {
+  let r4 = o.basename(n);
+  return { data: o.join(e.XDG_DATA_HOME || o.join(n, ".local", "share"), t2), config: o.join(e.XDG_CONFIG_HOME || o.join(n, ".config"), t2), cache: o.join(e.XDG_CACHE_HOME || o.join(n, ".cache"), t2), log: o.join(e.XDG_STATE_HOME || o.join(n, ".local", "state"), t2), temp: o.join(a, r4, t2) };
+};
+function p(t2, { suffix: r4 = "nodejs" } = {}) {
+  if (typeof t2 != "string") throw new TypeError(`Expected a string, got ${typeof t2}`);
+  return r4 && (t2 += `-${r4}`), c.platform === "darwin" ? h(t2) : c.platform === "win32" ? y(t2) : j(t2);
+}
+var l = p("prisma-dev");
+var G = v(C);
+function z(t2, r4) {
+  return `${l.cache}/engine/${t2}/${r4}`;
+}
+function B(t2) {
+  return `${l.data}/${t2}`;
+}
+async function J(t2) {
+  try {
+    return await D(t2, P.F_OK), true;
+  } catch (r4) {
+    if (u(r4)) return false;
+    throw r4;
+  }
+}
+async function K(t2, r4) {
+  let i2 = await G(t2);
+  await O(r4, i2), await x(r4, "755");
+}
+async function q(t2, r4) {
+  await t2.stream().pipeTo(A.toWeb(w(r4, { encoding: "utf8" })));
+}
+function u(t2) {
+  return t2 != null && typeof t2 == "object" && "code" in t2 && t2.code === "ENOENT";
+}
+async function Q(t2) {
+  try {
+    return await _(t2, { encoding: "utf-8" });
+  } catch (r4) {
+    if (u(r4)) return null;
+    throw r4;
+  }
+}
+async function U(t2) {
+  await T(t2, { recursive: true });
+}
+async function V(t2, r4) {
+  try {
+    return (await E(t2, { withFileTypes: true })).reduce((f2, s) => (s.isDirectory() && !s.name.startsWith(".") && (!r4 || dist_default2(r4, s.name)) && f2.push(s.name), f2), []);
+  } catch (i2) {
+    if (u(i2)) return [];
+    throw i2;
+  }
+}
+
+// ../../../node_modules/.pnpm/valibot@1.2.0_typescript@5.9.3/node_modules/valibot/dist/index.mjs
+var store$4;
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config$1) {
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema) dataset.typed = false;
+  if (dataset.issues) dataset.issues.push(issue);
+  else dataset.issues = [issue];
+}
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value$1) {
+      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object$1, key) {
+  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+// @__NO_SIDE_EFFECTS__
+function integer(message$1) {
+  return {
+    kind: "validation",
+    type: "integer",
+    reference: integer,
+    async: false,
+    expects: null,
+    requirement: Number.isInteger,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_length",
+    reference: minLength,
+    async: false,
+    expects: `>=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function parseJson(config$1, message$1) {
+  return {
+    kind: "transformation",
+    type: "parse_json",
+    reference: parseJson,
+    config: config$1,
+    message: message$1,
+    async: false,
+    "~run"(dataset, config$2) {
+      try {
+        dataset.value = JSON.parse(dataset.value, this.config?.reviver);
+      } catch (error) {
+        if (error instanceof Error) {
+          _addIssue(this, "JSON", dataset, config$2, { received: `"${error.message}"` });
+          dataset.typed = false;
+        } else throw error;
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function regex3(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "regex",
+    reference: regex3,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function url(message$1) {
+  return {
+    kind: "validation",
+    type: "url",
+    reference: url,
+    async: false,
+    expects: null,
+    requirement(input) {
+      try {
+        new URL(input);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "URL", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message$1) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal(literal_, message$1) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === this.literal) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function looseObject(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "loose_object",
+    reference: looseObject,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional2(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional2,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string2(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string2,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+  else issues = dataset.issues;
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message$1) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+        else typedDatasets = [optionDataset];
+        else {
+          validDataset = optionDataset;
+          break;
+        }
+        else if (untypedDatasets) untypedDatasets.push(optionDataset);
+        else untypedDatasets = [optionDataset];
+      }
+      if (validDataset) return validDataset;
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) return typedDatasets[0];
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1) if (item.kind !== "metadata") {
+        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+          dataset.typed = false;
+          break;
+        }
+        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// ../../../node_modules/.pnpm/@prisma+dev@0.19.1_typescript@5.9.3/node_modules/@prisma/dev/dist/chunk-7NDL3ECU.js
+import { spawn as U2 } from "child_process";
+import { once as F3 } from "events";
+import { mkdir as V3 } from "fs/promises";
+import { join as q2 } from "path";
+import { setTimeout as z2 } from "timers/promises";
+
+// ../../../node_modules/.pnpm/std-env@3.10.0/node_modules/std-env/dist/index.mjs
+var r = /* @__PURE__ */ Object.create(null);
+var i = (e2) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e2 ? r : globalThis);
+var o2 = new Proxy(r, { get(e2, s) {
+  return i()[s] ?? r[s];
+}, has(e2, s) {
+  const E2 = i();
+  return s in E2 || s in r;
+}, set(e2, s, E2) {
+  const B2 = i(true);
+  return B2[s] = E2, true;
+}, deleteProperty(e2, s) {
+  if (!s) return false;
+  const E2 = i(true);
+  return delete E2[s], true;
+}, ownKeys() {
+  const e2 = i(true);
+  return Object.keys(e2);
+} });
+var t = typeof process < "u" && process.env && process.env.NODE_ENV || "";
+var f = [["APPVEYOR"], ["AWS_AMPLIFY", "AWS_APP_ID", { ci: true }], ["AZURE_PIPELINES", "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"], ["AZURE_STATIC", "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"], ["APPCIRCLE", "AC_APPCIRCLE"], ["BAMBOO", "bamboo_planKey"], ["BITBUCKET", "BITBUCKET_COMMIT"], ["BITRISE", "BITRISE_IO"], ["BUDDY", "BUDDY_WORKSPACE_ID"], ["BUILDKITE"], ["CIRCLE", "CIRCLECI"], ["CIRRUS", "CIRRUS_CI"], ["CLOUDFLARE_PAGES", "CF_PAGES", { ci: true }], ["CLOUDFLARE_WORKERS", "WORKERS_CI", { ci: true }], ["CODEBUILD", "CODEBUILD_BUILD_ARN"], ["CODEFRESH", "CF_BUILD_ID"], ["DRONE"], ["DRONE", "DRONE_BUILD_EVENT"], ["DSARI"], ["GITHUB_ACTIONS"], ["GITLAB", "GITLAB_CI"], ["GITLAB", "CI_MERGE_REQUEST_ID"], ["GOCD", "GO_PIPELINE_LABEL"], ["LAYERCI"], ["HUDSON", "HUDSON_URL"], ["JENKINS", "JENKINS_URL"], ["MAGNUM"], ["NETLIFY"], ["NETLIFY", "NETLIFY_LOCAL", { ci: false }], ["NEVERCODE"], ["RENDER"], ["SAIL", "SAILCI"], ["SEMAPHORE"], ["SCREWDRIVER"], ["SHIPPABLE"], ["SOLANO", "TDDIUM"], ["STRIDER"], ["TEAMCITY", "TEAMCITY_VERSION"], ["TRAVIS"], ["VERCEL", "NOW_BUILDER"], ["VERCEL", "VERCEL", { ci: false }], ["VERCEL", "VERCEL_ENV", { ci: false }], ["APPCENTER", "APPCENTER_BUILD_ID"], ["CODESANDBOX", "CODESANDBOX_SSE", { ci: false }], ["CODESANDBOX", "CODESANDBOX_HOST", { ci: false }], ["STACKBLITZ"], ["STORMKIT"], ["CLEAVR"], ["ZEABUR"], ["CODESPHERE", "CODESPHERE_APP_ID", { ci: true }], ["RAILWAY", "RAILWAY_PROJECT_ID"], ["RAILWAY", "RAILWAY_SERVICE_ID"], ["DENO-DEPLOY", "DENO_DEPLOYMENT_ID"], ["FIREBASE_APP_HOSTING", "FIREBASE_APP_HOSTING", { ci: true }]];
+function b() {
+  if (globalThis.process?.env) for (const e2 of f) {
+    const s = e2[1] || e2[0];
+    if (globalThis.process?.env[s]) return { name: e2[0].toLowerCase(), ...e2[2] };
+  }
+  return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? { name: "stackblitz", ci: false } : { name: "", ci: false };
+}
+var l2 = b();
+var p2 = l2.name;
+function n2(e2) {
+  return e2 ? e2 !== "false" : false;
+}
+var I = globalThis.process?.platform || "";
+var T2 = n2(o2.CI) || l2.ci !== false;
+var R = n2(globalThis.process?.stdout && globalThis.process?.stdout.isTTY);
+var d = n2(o2.DEBUG);
+var a2 = t === "test" || n2(o2.TEST);
+var v2 = n2(o2.MINIMAL) || T2 || a2 || !R;
+var A2 = /^win/i.test(I);
+var M = /^linux/i.test(I);
+var m = /^darwin/i.test(I);
+var Y = !n2(o2.NO_COLOR) && (n2(o2.FORCE_COLOR) || (R || A2) && o2.TERM !== "dumb" || T2);
+var C2 = (globalThis.process?.versions?.node || "").replace(/^v/, "") || null;
+var V2 = Number(C2?.split(".")[0]) || null;
+var W = globalThis.process || /* @__PURE__ */ Object.create(null);
+var _2 = { versions: {} };
+var y2 = new Proxy(W, { get(e2, s) {
+  if (s === "env") return o2;
+  if (s in e2) return e2[s];
+  if (s in _2) return _2[s];
+} });
+var O2 = globalThis.process?.release?.name === "node";
+var c2 = !!globalThis.Bun || !!globalThis.process?.versions?.bun;
+var D2 = !!globalThis.Deno;
+var L = !!globalThis.fastly;
+var S = !!globalThis.Netlify;
+var u2 = !!globalThis.EdgeRuntime;
+var N = globalThis.navigator?.userAgent === "Cloudflare-Workers";
+var F2 = [[S, "netlify"], [u2, "edge-light"], [N, "workerd"], [L, "fastly"], [D2, "deno"], [c2, "bun"], [O2, "node"]];
+function G2() {
+  const e2 = F2.find((s) => s[0]);
+  if (e2) return { name: e2[1] };
+}
+var P2 = G2();
+var K2 = P2?.name || "";
+
+// ../../../node_modules/.pnpm/@prisma+dev@0.19.1_typescript@5.9.3/node_modules/@prisma/dev/dist/chunk-7NDL3ECU.js
+var S2 = /^(postgres|postgresql):\/\//;
+var N2 = pipe(string2(), parseJson(), object({ databaseUrl: pipe(string2(), url(), regex3(S2)), name: optional2(pipe(string2(), minLength(1))), shadowDatabaseUrl: pipe(string2(), url(), regex3(S2)) }));
+function Y2(r4) {
+  return Buffer.from(JSON.stringify(Object.fromEntries(Object.entries(r4).sort(([[e2], [n3]]) => e2.localeCompare(n3)))), "utf8").toString("base64url");
+}
+function Q2(r4) {
+  let e2 = Buffer.from(r4, "base64url").toString("utf8"), { issues: n3, output: s, success: t2 } = safeParse(N2, e2, { abortEarly: true });
+  return t2 ? [null, s] : [n3];
+}
+var X = async (r4, e2) => {
+  let { authorization: n3 } = r4, { HTTPException: s } = await import("./http-exception-FZY2H4OF.js");
+  if (!n3) throw new s(401, { message: "Missing API Key" });
+  let [t2, o3 = "", i2] = n3.split(" ");
+  if (t2 !== "Bearer" || i2) throw new s(401, { message: "Invalid API Key" });
+  let [a3, m2] = Q2(o3);
+  if (a3) throw new s(401, { message: "Invalid API Key", cause: a3.join(", ") });
+  let { databaseUrl: h2, name: c3, shadowDatabaseUrl: d2 } = m2, l3 = e2.get("name"), g2 = new URL(e2.req.url).port;
+  if (!c3) throw new s(401, { message: `Wrong API Key; The Prisma Dev server running at port ${g2} requires an API Key from a newer version of \`prisma dev\`. Check the "${l3}" server's output for the updated \`DATABASE_URL\` value.` });
+  if (c3 !== l3) throw new s(401, { message: `Wrong API Key; The Prisma Dev server running at port ${g2} is named "${l3}", but the API Key is for "${c3}"` });
+  let { hostname: f2, port: E2 } = new URL(h2), { port: $ } = e2.get("db"), { hostname: C3, port: D3 } = new URL(d2), H = e2.get("shadowDBPort");
+  if (f2 !== "localhost" || Number(E2) !== $ || C3 !== "localhost" || Number(D3) !== H) throw new s(401, { message: "Wrong API Key; Check your Prisma schema's `provider.url` value (probably defined in `.env`'s `DATABASE_URL` environment variable) is aligned with `prisma dev`'s output" });
+  return { decodedAPIKey: m2 };
+};
+function O3(r4) {
+  let e2, n3, s = new Promise((i2, a3) => {
+    e2 = i2, n3 = a3;
+  }), t2 = (i2) => {
+    t2 = o3 = null, n3(i2), r4?.onRejected?.(i2), r4?.onFulfilled?.();
+  }, o3 = (i2) => {
+    o3 = t2 = null, e2(i2), r4?.onResolved?.(i2), r4?.onFulfilled?.();
+  };
+  return { isFulfilled: () => o3 === t2, promise: s, reject: (i2) => t2?.(i2), resolve: (i2) => o3?.(i2) };
+}
+var { PRISMA_DEV_FORCE_ENGINE_BINARY_DOWNLOAD: J2, PRISMA_DEV_FORCE_ENGINE_BINARY_PATH: G3, PRISMA_DEV_FORCE_NETWORK_DELAY_MS: I2 } = y2.env;
+var x2 = class r2 {
+  static #t = /* @__PURE__ */ new Map();
+  #e;
+  #n;
+  constructor(e2) {
+    this.#e = e2, this.#n = null;
+  }
+  static async get(e2) {
+    let { debug: n3 } = e2, s = `${e2.schemaHash}:${e2.clientVersion}`;
+    try {
+      let t2 = r2.#t.get(s);
+      if (t2) return t2;
+      let o3 = new r2(e2);
+      return r2.#t.set(s, o3), n3 && console.debug("[Query Engine] starting...", e2), await o3.start(), n3 && console.debug("[Query Engine] started!"), o3;
+    } finally {
+      r2.stopAll(s);
+    }
+  }
+  static async stopAll(e2) {
+    let s = (await Promise.allSettled(Array.from(r2.#t.entries()).filter(([t2]) => t2 !== e2).map(async ([t2, o3]) => {
+      try {
+        await o3.stop();
+      } finally {
+        r2.#t.delete(t2);
+      }
+    }))).filter((t2) => t2.status === "rejected").map((t2) => t2.reason);
+    if (s.length > 0) throw new AggregateError(s, "Failed to stop engines");
+  }
+  async commitTransaction(e2, n3) {
+    return await this.#i(e2, n3, "commit");
+  }
+  async request(e2, n3) {
+    let { url: s } = await this.start(), t2 = this.#s(n3), o3 = await fetch(s, { body: typeof e2 == "string" ? e2 : JSON.stringify(e2), headers: { ...t2, "Content-Type": "application/json" }, method: "POST" });
+    if (!o3.ok) throw await u3.fromResponse(o3);
+    return await o3.text();
+  }
+  async rollbackTransaction(e2, n3) {
+    return await this.#i(e2, n3, "rollback");
+  }
+  async startTransaction(e2, n3) {
+    let { url: s } = await this.start(), t2 = this.#s(n3), o3 = await fetch(`${s}/transaction/start`, { body: JSON.stringify(e2), headers: { ...t2, "Content-Type": "application/json" }, method: "POST" });
+    if (!o3.ok) throw await u3.fromResponse(o3);
+    return await o3.json();
+  }
+  async start() {
+    if (this.#n != null) return await this.#n;
+    let { promise: e2, reject: n3, resolve: s } = O3();
+    this.#n = e2;
+    let t2 = G3 || await this.#o();
+    this.#e.debug && console.debug("[Query Engine] spinning up at path...", t2);
+    let { proxySignals: o3 } = await import("./proxy-signals-GUDAMDHV.js"), i2 = U2(t2, ["--enable-raw-queries", "--enable-telemetry-in-response", "--port", "0"], { env: { LOG_QUERIES: "y", PRISMA_DML: this.#e.base64Schema, QE_LOG_LEVEL: "TRACE", RUST_BACKTRACE: "1", RUST_LOG: "info" }, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    o3(i2), i2.stderr.setEncoding("utf8"), i2.stdout.setEncoding("utf8");
+    let a3 = (c3) => {
+      let d2 = c3.split(`
+`).find((E2) => E2.includes("Started query engine http server"));
+      if (!d2) return;
+      i2.stdout.removeListener("data", a3);
+      let { fields: l3 } = JSON.parse(d2);
+      if (l3 == null) return n3(new Error(`Unexpected data during initialization, "fields" are missing: ${c3}`));
+      let { ip: g2, port: f2 } = l3;
+      if (g2 == null || f2 == null) return n3(new Error(`This version of query-engine is not compatible with minippg, "ip" and "port" are missing in the startup log entry.
+Received data: ${c3}`));
+      s({ childProcess: i2, url: `http://${g2}:${f2}` });
+    }, m2 = (c3) => {
+      this.#n = null, n3(new p3(String(c3))), i2.removeListener("exit", h2), i2.kill();
+    };
+    i2.once("error", m2);
+    let h2 = (c3, d2) => {
+      this.#n = null, n3(new p3(`Query Engine exited with code ${c3} and signal ${d2}`));
+    };
+    return i2.once("exit", h2), i2.stdout.on("data", a3), this.#e.debug && (i2.stderr.on("data", console.error.bind(console, "[Query Engine]")), i2.stdout.on("data", console.debug.bind(console, "[Query Engine]"))), await this.#n;
+  }
+  async stop() {
+    if (this.#n == null) return;
+    let { childProcess: e2 } = await this.#n;
+    e2.exitCode == null && e2.signalCode == null && (this.#n = null, e2.kill(), await F3(e2, "exit"));
+  }
+  async #o() {
+    this.#e.debug && console.debug("[Query Engine] getting engine commit hash...");
+    let e2 = await this.#r();
+    this.#e.debug && console.debug("[Query Engine] got engine commit hash", e2);
+    let n3 = z(this.#e.clientVersion, e2);
+    this.#e.debug && console.debug("[Query Engine] cache directory path", n3), await V3(n3, { recursive: true });
+    let { binaryTarget: s } = this.#e.platform, t2 = s === "windows" ? ".exe" : "", o3 = q2(n3, `query-engine-${s}${t2}`);
+    return this.#e.debug && console.debug("[Query Engine] binary path", o3), (J2 === "1" || await J(o3) === false) && await this.#a({ commitHash: e2, extension: t2, engineBinaryPath: o3 }), o3;
+  }
+  async #r() {
+    let e2 = await fetch(`https://registry.npmjs.org/@prisma/client/${this.#e.clientVersion}`);
+    if (!e2.ok) throw new Error(`Couldn't fetch package.json from npm registry, status code: ${e2.status}`);
+    let s = (await e2.json()).devDependencies?.["@prisma/engines-version"];
+    if (!s) throw new Error("Couldn't find engines version in package.json");
+    let t2 = s.split(".").at(-1);
+    if (!t2) throw new Error("Couldn't find commit hash in engines version");
+    return t2;
+  }
+  async #a(e2) {
+    let { commitHash: n3, extension: s, engineBinaryPath: t2 } = e2, { binaryTarget: o3 } = this.#e.platform, i2 = `https://binaries.prisma.sh/all_commits/${n3}/${o3}/query-engine${s}.gz`;
+    this.#e.debug && console.debug("[Query Engine] downloading engine from url", i2);
+    let a3 = await fetch(i2);
+    if (!a3.ok) throw new Error(`Couldn't download engine. URL: ${i2}, status code: ${a3.status}`);
+    I2 && await z2(Number(I2)), await K(await a3.arrayBuffer(), t2), this.#e.debug && console.debug("[Query Engine] downloaded and saved at", t2);
+  }
+  #s(e2) {
+    let n3 = {};
+    for (let [s, t2] of Object.entries(e2)) t2 != null && (n3[s] = t2);
+    return n3;
+  }
+  async #i(e2, n3, s) {
+    let { url: t2 } = await this.#n, o3 = this.#s(n3), i2 = await fetch(`${t2}/transaction/${e2}/${s}`, { headers: { ...o3, "Content-Type": "application/json" }, method: "POST" });
+    if (!i2.ok) throw await u3.fromResponse(i2);
+    try {
+      return await i2.json();
+    } catch {
+      return {};
+    }
+  }
+};
+function ue(r4, e2) {
+  return console.error(r4), r4 instanceof p3 ? e2.json({ EngineNotStarted: { reason: { EngineStartupError: { logs: [], msg: r4.message } } } }, 500) : r4 instanceof u3 ? e2.text(r4.responseBody, r4.statusCode) : e2.body(null, 500);
+}
+var p3 = class extends Error {
+  name = "EngineStartError";
+};
+var u3 = class r3 extends Error {
+  constructor(n3, s, t2) {
+    super(`${n3}: Query Engine response status ${s}, body: ${t2}`);
+    this.action = n3;
+    this.statusCode = s;
+    this.responseBody = t2;
+  }
+  name = "EngineHttpError";
+  static async fromResponse(n3) {
+    let s = new URL(n3.url), t2 = await n3.text();
+    return new r3(s.pathname, n3.status, t2);
+  }
+};
+
+export {
+  B,
+  q,
+  Q,
+  U,
+  V,
+  y2 as y,
+  integer,
+  minLength,
+  minValue,
+  parseJson,
+  url,
+  array,
+  literal,
+  looseObject,
+  number,
+  object,
+  optional2 as optional,
+  string2 as string,
+  union,
+  pipe,
+  safeParse,
+  Y2 as Y,
+  X,
+  O3 as O,
+  x2 as x,
+  ue
+};
+//# sourceMappingURL=chunk-XPLNMXQV.js.map