@storm-software/eslint 0.162.1 → 0.163.0

package/dist/preset.js

@@ -5,16 +5,16 @@ import {
   isPackageInScope,
   parserPlain,
   renameRules
-} from "./chunk-2ASHINGN.js";
+} from "./chunk-D7COKLND.js";
 import {
   getTsConfigPath
-} from "./chunk-WSRPN4A5.js";
+} from "./chunk-ROE6YWPJ.js";
 import {
   banner_plugin_default
-} from "./chunk-URESQVUQ.js";
+} from "./chunk-BBKL5SSX.js";
 import {
   getFileBanner
-} from "./chunk-2PBILQLV.js";
+} from "./chunk-HMONPZQV.js";
 import {
   GLOB_ASTRO,
   GLOB_ASTRO_TS,
@@ -41,18 +41,19 @@ import {
   GLOB_TSX,
   GLOB_XML,
   GLOB_YAML
-} from "./chunk-FYHJSIQT.js";
+} from "./chunk-NVCVBDX5.js";
 import {
   findWorkspaceRoot
-} from "./chunk-CP5TACRD.js";
+} from "./chunk-TJ47LVUP.js";
 import {
   joinPaths
-} from "./chunk-LFKAEEDN.js";
+} from "./chunk-4T2VGUKQ.js";
 import {
   __commonJS,
+  __export,
   __toESM,
   init_esm_shims
-} from "./chunk-ECVSHAMX.js";
+} from "./chunk-VQHWUYQL.js";
 
 // ../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=de009a33a0a628f48c96f1a59298fb264fe3e5f5a0a221b7fda5cc52d4c890de/node_modules/eslint-plugin-tsdoc/lib/Debug.js
 var require_Debug = __commonJS({
@@ -652,7 +653,7 @@ async function stylistic(options = {}) {
   const pluginStylistic = await interopDefault(
     import("@stylistic/eslint-plugin")
   );
-  const config2 = pluginStylistic.configs.customize({
+  const config3 = pluginStylistic.configs.customize({
     indent,
     jsx: jsx2,
     pluginName: "style",
@@ -666,7 +667,7 @@ async function stylistic(options = {}) {
         style: pluginStylistic
       },
       rules: {
-        ...config2.rules,
+        ...config3.rules,
         "style/lines-around-comment": "off",
         "style/linebreak-style": ["error", lineEndings],
         "style/comma-dangle": ["error", "never"],
@@ -1144,9 +1145,10 @@ init_esm_shims();
 import { default as default2 } from "@cspell/eslint-plugin";
 import { default as default3 } from "@nx/eslint-plugin/nx.js";
 import * as pluginImport from "eslint-plugin-import-x";
-import { default as default4 } from "eslint-plugin-n";
-import { default as default5 } from "eslint-plugin-no-secrets";
-import { default as default6 } from "eslint-plugin-perfectionist";
+import { default as default4 } from "eslint-plugin-import-zod";
+import { default as default5 } from "eslint-plugin-n";
+import { default as default6 } from "eslint-plugin-no-secrets";
+import { default as default7 } from "eslint-plugin-perfectionist";
 
 // ../../node_modules/.pnpm/eslint-plugin-pnpm@0.3.0_patch_hash=72dcde755c336eeca3e6170de1106fd85ecb66171e060788f80_a52766881145434b16cf7b4f340819e2/node_modules/eslint-plugin-pnpm/dist/index.mjs
 init_esm_shims();
@@ -1262,9 +1264,9 @@ function readPnpmWorkspace() {
       clearTimeout(queueTimer);
     queueTimer = setTimeout(() => {
       queueTimer = void 0;
-      const clone = [...queue];
+      const clone2 = [...queue];
       queue.length = 0;
-      for (const fn2 of clone)
+      for (const fn2 of clone2)
         fn2(workspace2);
       if (workspace2.hasChanged())
         write();
@@ -1838,9 +1840,9 @@ var configs = {
 plugin.configs = configs;
 
 // src/plugins.ts
-import { default as default7 } from "eslint-plugin-prettier";
-import { default as default8 } from "eslint-plugin-unicorn";
-import { default as default9 } from "eslint-plugin-unused-imports";
+import { default as default8 } from "eslint-plugin-prettier";
+import { default as default9 } from "eslint-plugin-unicorn";
+import { default as default10 } from "eslint-plugin-unused-imports";
 
 // src/configs/imports.ts
 async function imports(options = {}) {
@@ -2004,8 +2006,8 @@ var CONSOLE_ICONS = {
 
 // ../config-tools/src/logger/format-timestamp.ts
 init_esm_shims();
-var formatTimestamp = (date = /* @__PURE__ */ new Date()) => {
-  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+var formatTimestamp = (date2 = /* @__PURE__ */ new Date()) => {
+  return `${date2.toLocaleDateString()} ${date2.toLocaleTimeString()}`;
 };
 
 // ../config-tools/src/logger/get-log-level.ts
@@ -2061,9 +2063,9 @@ var getLogLevelLabel = (logLevel = LogLevel.INFO) => {
 };
 
 // ../config-tools/src/logger/console.ts
-var getLogFn = (logLevel = LogLevel.INFO, config2 = {}, _chalk = getChalk()) => {
-  const colors = !config2.colors?.dark && !config2.colors?.["base"] && !config2.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config2.colors?.dark && typeof config2.colors.dark === "string" ? config2.colors : config2.colors?.["base"]?.dark && typeof config2.colors["base"].dark === "string" ? config2.colors["base"].dark : config2.colors?.["base"] ? config2.colors?.["base"] : DEFAULT_COLOR_CONFIG;
-  const configLogLevel = config2.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
+var getLogFn = (logLevel = LogLevel.INFO, config3 = {}, _chalk = getChalk()) => {
+  const colors = !config3.colors?.dark && !config3.colors?.["base"] && !config3.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config3.colors?.dark && typeof config3.colors.dark === "string" ? config3.colors : config3.colors?.["base"]?.dark && typeof config3.colors["base"].dark === "string" ? config3.colors["base"].dark : config3.colors?.["base"] ? config3.colors?.["base"] : DEFAULT_COLOR_CONFIG;
+  const configLogLevel = config3.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
   if (logLevel > getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT || getLogLevel(configLogLevel) <= LogLevel.SILENT) {
     return (_) => {
     };
@@ -2139,8 +2141,8 @@ ${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.brand ?? DEFAULT_COLOR_CON
     );
   };
 };
-var writeWarning = (message, config2) => getLogFn(LogLevel.WARN, config2)(message);
-var writeTrace = (message, config2) => getLogFn(LogLevel.TRACE, config2)(message);
+var writeWarning = (message, config3) => getLogFn(LogLevel.WARN, config3)(message);
+var writeTrace = (message, config3) => getLogFn(LogLevel.TRACE, config3)(message);
 var MAX_DEPTH = 4;
 var formatLogMessage = (message, options = {}, depth2 = 0) => {
   if (depth2 > MAX_DEPTH) {
@@ -2420,78 +2422,1845 @@ init_esm_shims();
 
 // ../config/src/schema.ts
 init_esm_shims();
-import * as z from "zod/mini";
-var schemaRegistry = z.registry();
-var colorSchema = z.string().check(
-  z.length(7),
-  z.toLowerCase(),
-  z.regex(/^#([0-9a-f]{3}){1,2}$/i),
-  z.trim()
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/mini/external.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/index.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/core.js
+init_esm_shims();
+var NEVER = Object.freeze({
+  status: "aborted"
+});
+// @__NO_SIDE_EFFECTS__
+function $constructor(name2, initializer2, params) {
+  function init(inst, def) {
+    var _a;
+    Object.defineProperty(inst, "_zod", {
+      value: inst._zod ?? {},
+      enumerable: false
+    });
+    (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
+    inst._zod.traits.add(name2);
+    initializer2(inst, def);
+    for (const k in _.prototype) {
+      if (!(k in inst))
+        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    }
+    inst._zod.constr = _;
+    inst._zod.def = def;
+  }
+  const Parent = params?.Parent ?? Object;
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name2 });
+  function _(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition() : this;
+    init(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name2);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name2 });
+  return _;
+}
+var $brand = Symbol("zod_brand");
+var $ZodAsyncError = class extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+};
+var globalConfig = {};
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/parse.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/errors.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/util.js
+var util_exports = {};
+__export(util_exports, {
+  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
+  Class: () => Class,
+  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  aborted: () => aborted,
+  allowsEval: () => allowsEval,
+  assert: () => assert,
+  assertEqual: () => assertEqual,
+  assertIs: () => assertIs,
+  assertNever: () => assertNever,
+  assertNotEqual: () => assertNotEqual,
+  assignProp: () => assignProp,
+  cached: () => cached,
+  captureStackTrace: () => captureStackTrace,
+  cleanEnum: () => cleanEnum,
+  cleanRegex: () => cleanRegex,
+  clone: () => clone,
+  createTransparentProxy: () => createTransparentProxy,
+  defineLazy: () => defineLazy,
+  esc: () => esc,
+  escapeRegex: () => escapeRegex,
+  extend: () => extend,
+  finalizeIssue: () => finalizeIssue,
+  floatSafeRemainder: () => floatSafeRemainder,
+  getElementAtPath: () => getElementAtPath,
+  getEnumValues: () => getEnumValues,
+  getLengthableOrigin: () => getLengthableOrigin,
+  getParsedType: () => getParsedType,
+  getSizableOrigin: () => getSizableOrigin,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  issue: () => issue,
+  joinValues: () => joinValues,
+  jsonStringifyReplacer: () => jsonStringifyReplacer,
+  merge: () => merge,
+  normalizeParams: () => normalizeParams,
+  nullish: () => nullish,
+  numKeys: () => numKeys,
+  omit: () => omit,
+  optionalKeys: () => optionalKeys,
+  partial: () => partial,
+  pick: () => pick,
+  prefixIssues: () => prefixIssues,
+  primitiveTypes: () => primitiveTypes,
+  promiseAllObject: () => promiseAllObject,
+  propertyKeyTypes: () => propertyKeyTypes,
+  randomString: () => randomString,
+  required: () => required,
+  stringifyPrimitive: () => stringifyPrimitive,
+  unwrapMessage: () => unwrapMessage
+});
+init_esm_shims();
+function assertEqual(val) {
+  return val;
+}
+function assertNotEqual(val) {
+  return val;
+}
+function assertIs(_arg) {
+}
+function assertNever(_x) {
+  throw new Error();
+}
+function assert(_) {
+}
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values;
+}
+function joinValues(array2, separator = "|") {
+  return array2.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === void 0;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+  return valInt % stepInt / 10 ** decCount;
+}
+function defineLazy(object2, key, getter) {
+  const set = false;
+  Object.defineProperty(object2, key, {
+    get() {
+      if (!set) {
+        const value = getter();
+        object2[key] = value;
+        return value;
+      }
+      throw new Error("cached value already set");
+    },
+    set(v) {
+      Object.defineProperty(object2, key, {
+        value: v
+        // configurable: true,
+      });
+    },
+    configurable: true
+  });
+}
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function getElementAtPath(obj, path) {
+  if (!path)
+    return obj;
+  return path.reduce((acc, key) => acc?.[key], obj);
+}
+function promiseAllObject(promisesObj) {
+  const keys = Object.keys(promisesObj);
+  const promises = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises).then((results) => {
+    const resolvedObj = {};
+    for (let i = 0; i < keys.length; i++) {
+      resolvedObj[keys[i]] = results[i];
+    }
+    return resolvedObj;
+  });
+}
+function randomString(length = 10) {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return str;
+}
+function esc(str) {
+  return JSON.stringify(str);
+}
+var captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {
+};
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+var allowsEval = cached(() => {
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+function isPlainObject(o) {
+  if (isObject(o) === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === void 0)
+    return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+function numKeys(data) {
+  let keyCount = 0;
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      keyCount++;
+    }
+  }
+  return keyCount;
+}
+var getParsedType = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return "string";
+    case "number":
+      return Number.isNaN(data) ? "nan" : "number";
+    case "boolean":
+      return "boolean";
+    case "function":
+      return "function";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "object":
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return "promise";
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return "map";
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return "set";
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return "date";
+      }
+      if (typeof File !== "undefined" && data instanceof File) {
+        return "file";
+      }
+      return "object";
+    default:
+      throw new Error(`Unknown data type: ${t}`);
+  }
+};
+var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== void 0) {
+    if (params?.error !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
+}
+function createTransparentProxy(getter) {
+  let target;
+  return new Proxy({}, {
+    get(_, prop, receiver) {
+      target ?? (target = getter());
+      return Reflect.get(target, prop, receiver);
+    },
+    set(_, prop, value, receiver) {
+      target ?? (target = getter());
+      return Reflect.set(target, prop, value, receiver);
+    },
+    has(_, prop) {
+      target ?? (target = getter());
+      return Reflect.has(target, prop);
+    },
+    deleteProperty(_, prop) {
+      target ?? (target = getter());
+      return Reflect.deleteProperty(target, prop);
+    },
+    ownKeys(_) {
+      target ?? (target = getter());
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      target ?? (target = getter());
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+    defineProperty(_, prop, descriptor) {
+      target ?? (target = getter());
+      return Reflect.defineProperty(target, prop, descriptor);
+    }
+  });
+}
+function stringifyPrimitive(value) {
+  if (typeof value === "bigint")
+    return value.toString() + "n";
+  if (typeof value === "string")
+    return `"${value}"`;
+  return `${value}`;
+}
+function optionalKeys(shape) {
+  return Object.keys(shape).filter((k) => {
+    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  });
+}
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-34028234663852886e22, 34028234663852886e22],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+var BIGINT_FORMAT_RANGES = {
+  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
+  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
+};
+function pick(schema, mask) {
+  const newShape = {};
+  const currDef = schema._zod.def;
+  for (const key in mask) {
+    if (!(key in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key}"`);
+    }
+    if (!mask[key])
+      continue;
+    newShape[key] = currDef.shape[key];
+  }
+  return clone(schema, {
+    ...schema._zod.def,
+    shape: newShape,
+    checks: []
+  });
+}
+function omit(schema, mask) {
+  const newShape = { ...schema._zod.def.shape };
+  const currDef = schema._zod.def;
+  for (const key in mask) {
+    if (!(key in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key}"`);
+    }
+    if (!mask[key])
+      continue;
+    delete newShape[key];
+  }
+  return clone(schema, {
+    ...schema._zod.def,
+    shape: newShape,
+    checks: []
+  });
+}
+function extend(schema, shape) {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to extend: expected a plain object");
+  }
+  const def = {
+    ...schema._zod.def,
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    checks: []
+    // delete existing checks
+  };
+  return clone(schema, def);
+}
+function merge(a, b) {
+  return clone(a, {
+    ...a._zod.def,
+    get shape() {
+      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    catchall: b._zod.def.catchall,
+    checks: []
+    // delete existing checks
+  });
+}
+function partial(Class2, schema, mask) {
+  const oldShape = schema._zod.def.shape;
+  const shape = { ...oldShape };
+  if (mask) {
+    for (const key in mask) {
+      if (!(key in oldShape)) {
+        throw new Error(`Unrecognized key: "${key}"`);
+      }
+      if (!mask[key])
+        continue;
+      shape[key] = Class2 ? new Class2({
+        type: "optional",
+        innerType: oldShape[key]
+      }) : oldShape[key];
+    }
+  } else {
+    for (const key in oldShape) {
+      shape[key] = Class2 ? new Class2({
+        type: "optional",
+        innerType: oldShape[key]
+      }) : oldShape[key];
+    }
+  }
+  return clone(schema, {
+    ...schema._zod.def,
+    shape,
+    checks: []
+  });
+}
+function required(Class2, schema, mask) {
+  const oldShape = schema._zod.def.shape;
+  const shape = { ...oldShape };
+  if (mask) {
+    for (const key in mask) {
+      if (!(key in shape)) {
+        throw new Error(`Unrecognized key: "${key}"`);
+      }
+      if (!mask[key])
+        continue;
+      shape[key] = new Class2({
+        type: "nonoptional",
+        innerType: oldShape[key]
+      });
+    }
+  } else {
+    for (const key in oldShape) {
+      shape[key] = new Class2({
+        type: "nonoptional",
+        innerType: oldShape[key]
+      });
+    }
+  }
+  return clone(schema, {
+    ...schema._zod.def,
+    shape,
+    // optional: [],
+    checks: []
+  });
+}
+function aborted(x, startIndex = 0) {
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true)
+      return true;
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config3) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config3.customError?.(iss)) ?? unwrapMessage(config3.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  return full;
+}
+function getSizableOrigin(input) {
+  if (input instanceof Set)
+    return "set";
+  if (input instanceof Map)
+    return "map";
+  if (input instanceof File)
+    return "file";
+  return "unknown";
+}
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
+    return "array";
+  if (typeof input === "string")
+    return "string";
+  return "unknown";
+}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
+  }
+  return { ...iss };
+}
+function cleanEnum(obj) {
+  return Object.entries(obj).filter(([k, _]) => {
+    return Number.isNaN(Number.parseInt(k, 10));
+  }).map((el) => el[1]);
+}
+var Class = class {
+  constructor(..._args) {
+  }
+};
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/errors.js
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "message", {
+    get() {
+      return JSON.stringify(def, jsonStringifyReplacer, 2);
+    },
+    enumerable: true
+    // configurable: false,
+  });
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/parse.js
+var _parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  if (result.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var parse = /* @__PURE__ */ _parse($ZodRealError);
+var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/schemas.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/checks.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/regexes.js
+init_esm_shims();
+var hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+var string = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+var boolean = /true|false/i;
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/checks.js
+var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a;
+  inst._zod ?? (inst._zod = {});
+  inst._zod.def = def;
+  (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  });
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length === def.length)
+      return;
+    const origin = getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push({
+      origin,
+      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+  var _a, _b;
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    bag.format = def.format;
+    if (def.pattern) {
+      bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+      bag.patterns.add(def.pattern);
+    }
+  });
+  if (def.pattern)
+    (_a = inst._zod).check ?? (_a.check = (payload) => {
+      def.pattern.lastIndex = 0;
+      if (def.pattern.test(payload.value))
+        return;
+      payload.issues.push({
+        origin: "string",
+        code: "invalid_format",
+        format: def.format,
+        input: payload.value,
+        ...def.pattern ? { pattern: def.pattern.toString() } : {},
+        inst,
+        continue: !def.abort
+      });
+    });
+  else
+    (_b = inst._zod).check ?? (_b.check = () => {
+    });
+});
+var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    def.pattern.lastIndex = 0;
+    if (def.pattern.test(payload.value))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: payload.value,
+      pattern: def.pattern.toString(),
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.check = (payload) => {
+    payload.value = def.tx(payload.value);
+  };
+});
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/doc.js
+init_esm_shims();
+var Doc = class {
+  constructor(args = []) {
+    this.content = [];
+    this.indent = 0;
+    if (this)
+      this.args = args;
+  }
+  indented(fn) {
+    this.indent += 1;
+    fn(this);
+    this.indent -= 1;
+  }
+  write(arg) {
+    if (typeof arg === "function") {
+      arg(this, { execution: "sync" });
+      arg(this, { execution: "async" });
+      return;
+    }
+    const content = arg;
+    const lines = content.split("\n").filter((x) => x);
+    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+    for (const line of dedented) {
+      this.content.push(line);
+    }
+  }
+  compile() {
+    const F = Function;
+    const args = this?.args;
+    const content = this?.content ?? [``];
+    const lines = [...content.map((x) => `  ${x}`)];
+    return new F(...args, lines.join("\n"));
+  }
+};
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/versions.js
+init_esm_shims();
+var version2 = {
+  major: 4,
+  minor: 0,
+  patch: 5
+};
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/schemas.js
+var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+  var _a;
+  inst ?? (inst = {});
+  inst._zod.def = def;
+  inst._zod.bag = inst._zod.bag || {};
+  inst._zod.version = version2;
+  const checks = [...inst._zod.def.checks ?? []];
+  if (inst._zod.traits.has("$ZodCheck")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    for (const fn of ch._zod.onattach) {
+      fn(inst);
+    }
+  }
+  if (checks.length === 0) {
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    inst._zod.deferred?.push(() => {
+      inst._zod.run = inst._zod.parse;
+    });
+  } else {
+    const runChecks = (payload, checks2, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks2) {
+        if (ch._zod.def.when) {
+          const shouldRun = ch._zod.def.when(payload);
+          if (!shouldRun)
+            continue;
+        } else if (isAborted) {
+          continue;
+        }
+        const currLen = payload.issues.length;
+        const _ = ch._zod.check(payload);
+        if (_ instanceof Promise && ctx?.async === false) {
+          throw new $ZodAsyncError();
+        }
+        if (asyncResult || _ instanceof Promise) {
+          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+            await _;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    inst._zod.run = (payload, ctx) => {
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return result.then((result2) => runChecks(result2, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  inst["~standard"] = {
+    validate: (value) => {
+      try {
+        const r = safeParse(inst, value);
+        return r.success ? { value: r.data } : { issues: r.error?.issues };
+      } catch (_) {
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  };
+});
+var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+  inst._zod.parse = (payload, _) => {
+    if (def.coerce)
+      try {
+        payload.value = String(payload.value);
+      } catch (_2) {
+      }
+    if (typeof payload.value === "string")
+      return payload;
+    payload.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  $ZodString.init(inst, def);
+});
+var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
+  $ZodStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    try {
+      const orig = payload.value;
+      const url2 = new URL(orig);
+      const href = url2.href;
+      if (def.hostname) {
+        def.hostname.lastIndex = 0;
+        if (!def.hostname.test(url2.hostname)) {
+          payload.issues.push({
+            code: "invalid_format",
+            format: "url",
+            note: "Invalid hostname",
+            pattern: hostname.source,
+            input: payload.value,
+            inst,
+            continue: !def.abort
+          });
+        }
+      }
+      if (def.protocol) {
+        def.protocol.lastIndex = 0;
+        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
+          payload.issues.push({
+            code: "invalid_format",
+            format: "url",
+            note: "Invalid protocol",
+            pattern: def.protocol.source,
+            input: payload.value,
+            inst,
+            continue: !def.abort
+          });
+        }
+      }
+      if (!orig.endsWith("/") && href.endsWith("/")) {
+        payload.value = href.slice(0, -1);
+      } else {
+        payload.value = href;
+      }
+      return;
+    } catch (_) {
+      payload.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: payload.value,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = boolean;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Boolean(payload.value);
+      } catch (_) {
+      }
+    const input = payload.value;
+    if (typeof input === "boolean")
+      return payload;
+    payload.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload) => payload;
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+      } else {
+        handleArrayResult(result, payload, i);
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+function handleObjectResult(result, final, key) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(key, result.issues));
+  }
+  final.value[key] = result.value;
+}
+function handleOptionalObjectResult(result, final, key, input) {
+  if (result.issues.length) {
+    if (input[key] === void 0) {
+      if (key in input) {
+        final.value[key] = void 0;
+      } else {
+        final.value[key] = result.value;
+      }
+    } else {
+      final.issues.push(...prefixIssues(key, result.issues));
+    }
+  } else if (result.value === void 0) {
+    if (key in input)
+      final.value[key] = void 0;
+  } else {
+    final.value[key] = result.value;
+  }
+}
+var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+  $ZodType.init(inst, def);
+  const _normalized = cached(() => {
+    const keys = Object.keys(def.shape);
+    for (const k of keys) {
+      if (!(def.shape[k] instanceof $ZodType)) {
+        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+      }
+    }
+    const okeys = optionalKeys(def.shape);
+    return {
+      shape: def.shape,
+      keys,
+      keySet: new Set(keys),
+      numKeys: keys.length,
+      optionalKeys: new Set(okeys)
+    };
+  });
+  defineLazy(inst._zod, "propValues", () => {
+    const shape = def.shape;
+    const propValues = {};
+    for (const key in shape) {
+      const field = shape[key]._zod;
+      if (field.values) {
+        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        for (const v of field.values)
+          propValues[key].add(v);
+      }
+    }
+    return propValues;
+  });
+  const generateFastpass = (shape) => {
+    const doc = new Doc(["shape", "payload", "ctx"]);
+    const normalized = _normalized.value;
+    const parseStr = (key) => {
+      const k = esc(key);
+      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+    };
+    doc.write(`const input = payload.value;`);
+    const ids = /* @__PURE__ */ Object.create(null);
+    let counter = 0;
+    for (const key of normalized.keys) {
+      ids[key] = `key_${counter++}`;
+    }
+    doc.write(`const newResult = {}`);
+    for (const key of normalized.keys) {
+      if (normalized.optionalKeys.has(key)) {
+        const id = ids[key];
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        const k = esc(key);
+        doc.write(`
+        if (${id}.issues.length) {
+          if (input[${k}] === undefined) {
+            if (${k} in input) {
+              newResult[${k}] = undefined;
+            }
+          } else {
+            payload.issues = payload.issues.concat(
+              ${id}.issues.map((iss) => ({
+                ...iss,
+                path: iss.path ? [${k}, ...iss.path] : [${k}],
+              }))
+            );
+          }
+        } else if (${id}.value === undefined) {
+          if (${k} in input) newResult[${k}] = undefined;
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        `);
+      } else {
+        const id = ids[key];
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        doc.write(`
+          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
+          })));`);
+        doc.write(`newResult[${esc(key)}] = ${id}.value`);
+      }
+    }
+    doc.write(`payload.value = newResult;`);
+    doc.write(`return payload;`);
+    const fn = doc.compile();
+    return (payload, ctx) => fn(shape, payload, ctx);
+  };
+  let fastpass;
+  const isObject2 = isObject;
+  const jit = !globalConfig.jitless;
+  const allowsEval2 = allowsEval;
+  const fastEnabled = jit && allowsEval2.value;
+  const catchall = def.catchall;
+  let value;
+  inst._zod.parse = (payload, ctx) => {
+    value ?? (value = _normalized.value);
+    const input = payload.value;
+    if (!isObject2(input)) {
+      payload.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+      if (!fastpass)
+        fastpass = generateFastpass(def.shape);
+      payload = fastpass(payload, ctx);
+    } else {
+      payload.value = {};
+      const shape = value.shape;
+      for (const key of value.keys) {
+        const el = shape[key];
+        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+        const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
+        if (r instanceof Promise) {
+          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
+        } else if (isOptional) {
+          handleOptionalObjectResult(r, payload, key, input);
+        } else {
+          handleObjectResult(r, payload, key);
+        }
+      }
+    }
+    if (!catchall) {
+      return proms.length ? Promise.all(proms).then(() => payload) : payload;
+    }
+    const unrecognized = [];
+    const keySet = value.keySet;
+    const _catchall = catchall._zod;
+    const t = _catchall.def.type;
+    for (const key of Object.keys(input)) {
+      if (keySet.has(key))
+        continue;
+      if (t === "never") {
+        unrecognized.push(key);
+        continue;
+      }
+      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
+      } else {
+        handleObjectResult(r, payload, key);
+      }
+    }
+    if (unrecognized.length) {
+      payload.issues.push({
+        code: "unrecognized_keys",
+        keys: unrecognized,
+        input,
+        inst
+      });
+    }
+    if (!proms.length)
+      return payload;
+    return Promise.all(proms).then(() => {
+      return payload;
+    });
+  };
+});
+function handleUnionResults(results, final, inst, ctx) {
+  for (const result of results) {
+    if (result.issues.length === 0) {
+      final.value = result.value;
+      return final;
+    }
+  }
+  final.issues.push({
+    code: "invalid_union",
+    input: final.value,
+    inst,
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  });
+  return final;
+}
+var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "values", () => {
+    if (def.options.every((o) => o._zod.values)) {
+      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+    }
+    return void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    if (def.options.every((o) => o._zod.pattern)) {
+      const patterns = def.options.map((o) => o._zod.pattern);
+      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+    }
+    return void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    let async = false;
+    const results = [];
+    for (const option of def.options) {
+      const result = option._zod.run({
+        value: payload.value,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        results.push(result);
+        async = true;
+      } else {
+        if (result.issues.length === 0)
+          return result;
+        results.push(result);
+      }
+    }
+    if (!async)
+      return handleUnionResults(results, payload, inst, ctx);
+    return Promise.all(results).then((results2) => {
+      return handleUnionResults(results2, payload, inst, ctx);
+    });
+  };
+});
+var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isPlainObject(input)) {
+      payload.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    if (def.keyType._zod.values) {
+      const values = def.keyType._zod.values;
+      payload.value = {};
+      for (const key of values) {
+        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[key] = result2.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[key] = result.value;
+          }
+        }
+      }
+      let unrecognized;
+      for (const key in input) {
+        if (!values.has(key)) {
+          unrecognized = unrecognized ?? [];
+          unrecognized.push(key);
+        }
+      }
+      if (unrecognized && unrecognized.length > 0) {
+        payload.issues.push({
+          code: "unrecognized_keys",
+          input,
+          inst,
+          keys: unrecognized
+        });
+      }
+    } else {
+      payload.value = {};
+      for (const key of Reflect.ownKeys(input)) {
+        if (key === "__proto__")
+          continue;
+        const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        if (keyResult instanceof Promise) {
+          throw new Error("Async schemas not supported in object keys currently");
+        }
+        if (keyResult.issues.length) {
+          payload.issues.push({
+            origin: "record",
+            code: "invalid_key",
+            issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+            input: key,
+            path: [key],
+            inst
+          });
+          payload.value[keyResult.value] = keyResult.value;
+          continue;
+        }
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => {
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
+            }
+            payload.value[keyResult.value] = result2.value;
+          }));
+        } else {
+          if (result.issues.length) {
+            payload.issues.push(...prefixIssues(key, result.issues));
+          }
+          payload.value[keyResult.value] = result.value;
+        }
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+  $ZodType.init(inst, def);
+  const values = getEnumValues(def.entries);
+  inst._zod.values = new Set(values);
+  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (inst._zod.values.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.values = new Set(def.values);
+  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (inst._zod.values.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values: def.values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (def.innerType._zod.optin === "optional") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    if (payload.value === void 0) {
+      return payload;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+  });
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (payload.value === null)
+      return payload;
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (payload.value === void 0) {
+      payload.value = def.defaultValue;
+      return payload;
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => handleDefaultResult(result2, def));
+    }
+    return handleDefaultResult(result, def);
+  };
+});
+function handleDefaultResult(payload, def) {
+  if (payload.value === void 0) {
+    payload.value = def.defaultValue;
+  }
+  return payload;
+}
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/registries.js
+init_esm_shims();
+var $output = Symbol("ZodOutput");
+var $input = Symbol("ZodInput");
+var $ZodRegistry = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(schema, ..._meta) {
+    const meta = _meta[0];
+    this._map.set(schema, meta);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      if (this._idmap.has(meta.id)) {
+        throw new Error(`ID ${meta.id} already exists in the registry`);
+      }
+      this._idmap.set(meta.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ new Map();
+    return this;
+  }
+  remove(schema) {
+    const meta = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ...this.get(p) ?? {} };
+      delete pm.id;
+      return { ...pm, ...this._map.get(schema) };
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+};
+function registry() {
+  return new $ZodRegistry();
+}
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/core/api.js
+init_esm_shims();
+function _string(Class2, params) {
+  return new Class2({
+    type: "string",
+    ...normalizeParams(params)
+  });
+}
+function _url(Class2, params) {
+  return new Class2({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _boolean(Class2, params) {
+  return new Class2({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
+function _any(Class2) {
+  return new Class2({
+    type: "any"
+  });
+}
+function _length(length, params) {
+  return new $ZodCheckLengthEquals({
+    check: "length_equals",
+    ...normalizeParams(params),
+    length
+  });
+}
+function _regex(pattern, params) {
+  return new $ZodCheckRegex({
+    check: "string_format",
+    format: "regex",
+    ...normalizeParams(params),
+    pattern
+  });
+}
+function _overwrite(tx) {
+  return new $ZodCheckOverwrite({
+    check: "overwrite",
+    tx
+  });
+}
+function _trim() {
+  return _overwrite((input) => input.trim());
+}
+function _toLowerCase() {
+  return _overwrite((input) => input.toLowerCase());
+}
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/mini/parse.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/mini/schemas.js
+init_esm_shims();
+var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+  if (!inst._zod)
+    throw new Error("Uninitialized schema in ZodMiniType.");
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+  inst.check = (...checks) => {
+    return inst.clone(
+      {
+        ...def,
+        checks: [
+          ...def.checks ?? [],
+          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+        ]
+      }
+      // { parent: true }
+    );
+  };
+  inst.clone = (_def, params) => clone(inst, _def, params);
+  inst.brand = () => inst;
+  inst.register = (reg, meta) => {
+    reg.add(inst, meta);
+    return inst;
+  };
+});
+var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function string2(params) {
+  return _string(ZodMiniString, params);
+}
+var ZodMiniStringFormat = /* @__PURE__ */ $constructor("ZodMiniStringFormat", (inst, def) => {
+  $ZodStringFormat.init(inst, def);
+  ZodMiniString.init(inst, def);
+});
+var ZodMiniURL = /* @__PURE__ */ $constructor("ZodMiniURL", (inst, def) => {
+  $ZodURL.init(inst, def);
+  ZodMiniStringFormat.init(inst, def);
+});
+function url(params) {
+  return _url(ZodMiniURL, params);
+}
+var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+  $ZodBoolean.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function boolean2(params) {
+  return _boolean(ZodMiniBoolean, params);
+}
+var ZodMiniAny = /* @__PURE__ */ $constructor("ZodMiniAny", (inst, def) => {
+  $ZodAny.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function any() {
+  return _any(ZodMiniAny);
+}
+var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function array(element, params) {
+  return new ZodMiniArray({
+    type: "array",
+    element,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+  $ZodObject.init(inst, def);
+  ZodMiniType.init(inst, def);
+  util_exports.defineLazy(inst, "shape", () => def.shape);
+});
+function object(shape, params) {
+  const def = {
+    type: "object",
+    get shape() {
+      util_exports.assignProp(this, "shape", { ...shape });
+      return this.shape;
+    },
+    ...util_exports.normalizeParams(params)
+  };
+  return new ZodMiniObject(def);
+}
+var ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function union(options, params) {
+  return new ZodMiniUnion({
+    type: "union",
+    options,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+  $ZodRecord.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function record(keyType, valueType, params) {
+  return new ZodMiniRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+  $ZodEnum.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function _enum(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  return new ZodMiniEnum({
+    type: "enum",
+    entries,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+  $ZodLiteral.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function literal(value, params) {
+  return new ZodMiniLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function optional(innerType) {
+  return new ZodMiniOptional({
+    type: "optional",
+    innerType
+  });
+}
+var ZodMiniNullable = /* @__PURE__ */ $constructor("ZodMiniNullable", (inst, def) => {
+  $ZodNullable.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function nullable(innerType) {
+  return new ZodMiniNullable({
+    type: "nullable",
+    innerType
+  });
+}
+var ZodMiniDefault = /* @__PURE__ */ $constructor("ZodMiniDefault", (inst, def) => {
+  $ZodDefault.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function _default(innerType, defaultValue) {
+  return new ZodMiniDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/zod@4.0.5/node_modules/zod/v4/mini/checks.js
+init_esm_shims();
+
+// ../config/src/schema.ts
+var schemaRegistry = registry();
+var colorSchema = string2().check(
+  _length(7),
+  _toLowerCase(),
+  _regex(/^#([0-9a-f]{3}){1,2}$/i),
+  _trim()
 );
 schemaRegistry.add(colorSchema, {
   description: "A base schema for describing the format of colors"
 });
-var darkColorSchema = z._default(colorSchema, "#151718");
+var darkColorSchema = _default(colorSchema, "#151718");
 schemaRegistry.add(darkColorSchema, {
   description: "The dark background color of the workspace"
 });
-var lightColorSchema = z._default(colorSchema, "#cbd5e1");
+var lightColorSchema = _default(colorSchema, "#cbd5e1");
 schemaRegistry.add(lightColorSchema, {
   description: "The light background color of the workspace"
 });
-var brandColorSchema = z._default(colorSchema, "#1fb2a6");
+var brandColorSchema = _default(colorSchema, "#1fb2a6");
 schemaRegistry.add(brandColorSchema, {
   description: "The primary brand specific color of the workspace"
 });
-var alternateColorSchema = z.optional(colorSchema);
+var alternateColorSchema = optional(colorSchema);
 schemaRegistry.add(alternateColorSchema, {
   description: "The alternate brand specific color of the workspace"
 });
-var accentColorSchema = z.optional(colorSchema);
+var accentColorSchema = optional(colorSchema);
 schemaRegistry.add(accentColorSchema, {
   description: "The secondary brand specific color of the workspace"
 });
-var linkColorSchema = z._default(colorSchema, "#3fa6ff");
+var linkColorSchema = _default(colorSchema, "#3fa6ff");
 schemaRegistry.add(linkColorSchema, {
   description: "The color used to display hyperlink text"
 });
-var helpColorSchema = z._default(colorSchema, "#818cf8");
+var helpColorSchema = _default(colorSchema, "#818cf8");
 schemaRegistry.add(helpColorSchema, {
   description: "The second brand specific color of the workspace"
 });
-var successColorSchema = z._default(colorSchema, "#45b27e");
+var successColorSchema = _default(colorSchema, "#45b27e");
 schemaRegistry.add(successColorSchema, {
   description: "The success color of the workspace"
 });
-var infoColorSchema = z._default(colorSchema, "#38bdf8");
+var infoColorSchema = _default(colorSchema, "#38bdf8");
 schemaRegistry.add(infoColorSchema, {
   description: "The informational color of the workspace"
 });
-var warningColorSchema = z._default(colorSchema, "#f3d371");
+var warningColorSchema = _default(colorSchema, "#f3d371");
 schemaRegistry.add(warningColorSchema, {
   description: "The warning color of the workspace"
 });
-var dangerColorSchema = z._default(colorSchema, "#d8314a");
+var dangerColorSchema = _default(colorSchema, "#d8314a");
 schemaRegistry.add(dangerColorSchema, {
   description: "The danger color of the workspace"
 });
-var fatalColorSchema = z.optional(colorSchema);
+var fatalColorSchema = optional(colorSchema);
 schemaRegistry.add(fatalColorSchema, {
   description: "The fatal color of the workspace"
 });
-var positiveColorSchema = z._default(colorSchema, "#4ade80");
+var positiveColorSchema = _default(colorSchema, "#4ade80");
 schemaRegistry.add(positiveColorSchema, {
   description: "The positive number color of the workspace"
 });
-var negativeColorSchema = z._default(colorSchema, "#ef4444");
+var negativeColorSchema = _default(colorSchema, "#ef4444");
 schemaRegistry.add(negativeColorSchema, {
   description: "The negative number color of the workspace"
 });
-var gradientStopsSchema = z.optional(z.array(colorSchema));
+var gradientStopsSchema = optional(array(colorSchema));
 schemaRegistry.add(gradientStopsSchema, {
   description: "The color stops for the base gradient color pattern used in the workspace"
 });
-var darkColorsSchema = z.object({
+var darkColorsSchema = object({
   foreground: lightColorSchema,
   background: darkColorSchema,
   brand: brandColorSchema,
@@ -2508,7 +4277,7 @@ var darkColorsSchema = z.object({
   negative: negativeColorSchema,
   gradient: gradientStopsSchema
 });
-var lightColorsSchema = z.object({
+var lightColorsSchema = object({
   foreground: darkColorSchema,
   background: lightColorSchema,
   brand: brandColorSchema,
@@ -2525,11 +4294,11 @@ var lightColorsSchema = z.object({
   negative: negativeColorSchema,
   gradient: gradientStopsSchema
 });
-var multiColorsSchema = z.object({
+var multiColorsSchema = object({
   dark: darkColorsSchema,
   light: lightColorsSchema
 });
-var singleColorsSchema = z.object({
+var singleColorsSchema = object({
   dark: darkColorSchema,
   light: lightColorSchema,
   brand: brandColorSchema,
@@ -2546,12 +4315,12 @@ var singleColorsSchema = z.object({
   negative: negativeColorSchema,
   gradient: gradientStopsSchema
 });
-var registryUrlConfigSchema = z.optional(z.url());
+var registryUrlConfigSchema = optional(url());
 schemaRegistry.add(registryUrlConfigSchema, {
   description: "A remote registry URL used to publish distributable packages"
 });
-var registrySchema = z._default(
-  z.object({
+var registrySchema = _default(
+  object({
     github: registryUrlConfigSchema,
     npm: registryUrlConfigSchema,
     cargo: registryUrlConfigSchema,
@@ -2563,74 +4332,74 @@ var registrySchema = z._default(
 schemaRegistry.add(registrySchema, {
   description: "A list of remote registry URLs used by Storm Software"
 });
-var colorsSchema = z.union([singleColorsSchema, multiColorsSchema]);
+var colorsSchema = union([singleColorsSchema, multiColorsSchema]);
 schemaRegistry.add(colorsSchema, {
   description: "Colors used for various workspace elements"
 });
-var themeColorsSchema = z.record(
-  z.union([z.union([z.literal("base"), z.string()]), z.string()]),
+var themeColorsSchema = record(
+  union([union([literal("base"), string2()]), string2()]),
   colorsSchema
 );
 schemaRegistry.add(themeColorsSchema, {
   description: "Storm theme config values used for styling various package elements"
 });
-var extendsSchema = z.optional(
-  z.union([z.string().check(z.trim()), z.array(z.string().check(z.trim()))])
+var extendsSchema = optional(
+  union([string2().check(_trim()), array(string2().check(_trim()))])
 );
 schemaRegistry.add(extendsSchema, {
   description: "The path to a base config file to use as a configuration preset file. Documentation can be found at https://github.com/unjs/c12#extending-configuration."
 });
-var workspaceBotNameSchema = z.string().check(z.trim());
+var workspaceBotNameSchema = string2().check(_trim());
 schemaRegistry.add(workspaceBotNameSchema, {
   description: "The workspace bot user's name (this is the bot that will be used to perform various tasks)"
 });
-var workspaceBotEmailSchema = z.string().check(z.trim());
+var workspaceBotEmailSchema = string2().check(_trim());
 schemaRegistry.add(workspaceBotEmailSchema, {
   description: "The email of the workspace bot"
 });
-var workspaceBotSchema = z.object({
+var workspaceBotSchema = object({
   name: workspaceBotNameSchema,
   email: workspaceBotEmailSchema
 });
 schemaRegistry.add(workspaceBotSchema, {
   description: "The workspace's bot user's config used to automated various operations tasks"
 });
-var workspaceReleaseBannerUrlSchema = z.optional(
-  z.string().check(z.trim(), z.url())
+var workspaceReleaseBannerUrlSchema = optional(
+  string2().check(_trim(), url())
 );
 schemaRegistry.add(workspaceReleaseBannerUrlSchema, {
   description: "A URL to a banner image used to display the workspace's release"
 });
-var workspaceReleaseBannerAltSchema = z._default(
-  z.string().check(z.trim()),
+var workspaceReleaseBannerAltSchema = _default(
+  string2().check(_trim()),
   STORM_DEFAULT_BANNER_ALT
 );
 schemaRegistry.add(workspaceReleaseBannerAltSchema, {
   description: "The alt text for the workspace's release banner image"
 });
-var workspaceReleaseBannerSchema = z.object({
+var workspaceReleaseBannerSchema = object({
   url: workspaceReleaseBannerUrlSchema,
   alt: workspaceReleaseBannerAltSchema
 });
 schemaRegistry.add(workspaceReleaseBannerSchema, {
   description: "The workspace's banner image used during the release process"
 });
-var workspaceReleaseHeaderSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceReleaseHeaderSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceReleaseHeaderSchema, {
   description: "A header message appended to the start of the workspace's release notes"
 });
-var workspaceReleaseFooterSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceReleaseFooterSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceReleaseFooterSchema, {
   description: "A footer message appended to the end of the workspace's release notes"
 });
-var workspaceReleaseSchema = z.object({
-  banner: z.union([
+var workspaceReleaseSchema = object({
+  banner: union([
     workspaceReleaseBannerSchema,
-    z.string().check(z.trim(), z.url())
+    string2().check(_trim(), url())
   ]),
   header: workspaceReleaseHeaderSchema,
   footer: workspaceReleaseFooterSchema
@@ -2638,43 +4407,43 @@ var workspaceReleaseSchema = z.object({
 schemaRegistry.add(workspaceReleaseSchema, {
   description: "The workspace's release config used during the release process"
 });
-var workspaceSocialsTwitterSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsTwitterSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsTwitterSchema, {
   description: "A Twitter/X account associated with the organization/project"
 });
-var workspaceSocialsDiscordSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsDiscordSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsDiscordSchema, {
   description: "A Discord account associated with the organization/project"
 });
-var workspaceSocialsTelegramSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsTelegramSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsTelegramSchema, {
   description: "A Telegram account associated with the organization/project"
 });
-var workspaceSocialsSlackSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsSlackSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsSlackSchema, {
   description: "A Slack account associated with the organization/project"
 });
-var workspaceSocialsMediumSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsMediumSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsMediumSchema, {
   description: "A Medium account associated with the organization/project"
 });
-var workspaceSocialsGithubSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceSocialsGithubSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceSocialsGithubSchema, {
   description: "A GitHub account associated with the organization/project"
 });
-var workspaceSocialsSchema = z.object({
+var workspaceSocialsSchema = object({
   twitter: workspaceSocialsTwitterSchema,
   discord: workspaceSocialsDiscordSchema,
   telegram: workspaceSocialsTelegramSchema,
@@ -2685,44 +4454,44 @@ var workspaceSocialsSchema = z.object({
 schemaRegistry.add(workspaceSocialsSchema, {
   description: "The workspace's account config used to store various social media links"
 });
-var workspaceDirectoryCacheSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceDirectoryCacheSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceDirectoryCacheSchema, {
   description: "The directory used to store the environment's cached file data"
 });
-var workspaceDirectoryDataSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceDirectoryDataSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceDirectoryDataSchema, {
   description: "The directory used to store the environment's data files"
 });
-var workspaceDirectoryConfigSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceDirectoryConfigSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceDirectoryConfigSchema, {
   description: "The directory used to store the environment's configuration files"
 });
-var workspaceDirectoryTempSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceDirectoryTempSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceDirectoryTempSchema, {
   description: "The directory used to store the environment's temp files"
 });
-var workspaceDirectoryLogSchema = z.optional(
-  z.string().check(z.trim())
+var workspaceDirectoryLogSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(workspaceDirectoryLogSchema, {
   description: "The directory used to store the environment's log files"
 });
-var workspaceDirectoryBuildSchema = z._default(
-  z.string().check(z.trim()),
+var workspaceDirectoryBuildSchema = _default(
+  string2().check(_trim()),
   "dist"
 );
 schemaRegistry.add(workspaceDirectoryBuildSchema, {
   description: "The directory used to store the workspace's distributable files after a build (relative to the workspace root)"
 });
-var workspaceDirectorySchema = z.object({
+var workspaceDirectorySchema = object({
   cache: workspaceDirectoryCacheSchema,
   data: workspaceDirectoryDataSchema,
   config: workspaceDirectoryConfigSchema,
@@ -2733,49 +4502,49 @@ var workspaceDirectorySchema = z.object({
 schemaRegistry.add(workspaceDirectorySchema, {
   description: "Various directories used by the workspace to store data, cache, and configuration files"
 });
-var errorCodesFileSchema = z._default(
-  z.string().check(z.trim()),
+var errorCodesFileSchema = _default(
+  string2().check(_trim()),
   STORM_DEFAULT_ERROR_CODES_FILE
 );
 schemaRegistry.add(errorCodesFileSchema, {
   description: "The path to the workspace's error codes JSON file"
 });
-var errorUrlSchema = z.optional(z.url());
+var errorUrlSchema = optional(url());
 schemaRegistry.add(errorUrlSchema, {
   description: "A URL to a page that looks up the workspace's error messages given a specific error code"
 });
-var errorSchema = z.object({
+var errorSchema = object({
   codesFile: errorCodesFileSchema,
   url: errorUrlSchema
 });
 schemaRegistry.add(errorSchema, {
   description: "The workspace's error config used when creating error details during a system error"
 });
-var organizationNameSchema = z.optional(
-  z.string().check(z.trim(), z.toLowerCase())
+var organizationNameSchema = optional(
+  string2().check(_trim(), _toLowerCase())
 );
 schemaRegistry.add(organizationNameSchema, {
   description: "The name of the organization"
 });
-var organizationDescriptionSchema = z.optional(
-  z.string().check(z.trim())
+var organizationDescriptionSchema = optional(
+  string2().check(_trim())
 );
 schemaRegistry.add(organizationDescriptionSchema, {
   description: "A description of the organization"
 });
-var organizationLogoSchema = z.optional(z.url());
+var organizationLogoSchema = optional(url());
 schemaRegistry.add(organizationLogoSchema, {
   description: "A URL to the organization's logo image"
 });
-var organizationIconSchema = z.optional(z.url());
+var organizationIconSchema = optional(url());
 schemaRegistry.add(organizationIconSchema, {
   description: "A URL to the organization's icon image"
 });
-var organizationUrlSchema = z.optional(z.url());
+var organizationUrlSchema = optional(url());
 schemaRegistry.add(organizationUrlSchema, {
   description: "A URL to a page that provides more information about the organization"
 });
-var organizationSchema = z.object({
+var organizationSchema = object({
   name: organizationNameSchema,
   description: organizationDescriptionSchema,
   logo: organizationLogoSchema,
@@ -2785,120 +4554,120 @@ var organizationSchema = z.object({
 schemaRegistry.add(organizationSchema, {
   description: "The workspace's organization details"
 });
-var schemaNameSchema = z._default(
-  z.string().check(z.trim(), z.toLowerCase()),
+var schemaNameSchema = _default(
+  string2().check(_trim(), _toLowerCase()),
   "https://public.storm-cdn.com/schemas/storm-workspace.schema.json"
 );
 schemaRegistry.add(schemaNameSchema, {
   description: "The URL or file path to the JSON schema file that describes the Storm configuration file"
 });
-var nameSchema = z.string().check(z.trim(), z.toLowerCase());
+var nameSchema = string2().check(_trim(), _toLowerCase());
 schemaRegistry.add(nameSchema, {
   description: "The name of the workspace/project/service/package/scope using this configuration"
 });
-var namespaceSchema = z.string().check(z.trim(), z.toLowerCase());
+var namespaceSchema = string2().check(_trim(), _toLowerCase());
 schemaRegistry.add(namespaceSchema, {
   description: "The namespace of the workspace/project/service/package/scope using this configuration"
 });
-var orgSchema = z.union([
+var orgSchema = union([
   organizationSchema,
-  z.string().check(z.trim(), z.toLowerCase())
+  string2().check(_trim(), _toLowerCase())
 ]);
 schemaRegistry.add(orgSchema, {
   description: "The organization of the workspace. This can be a string or an object containing the organization's details"
 });
-var repositorySchema = z.string().check(z.trim(), z.toLowerCase());
+var repositorySchema = string2().check(_trim(), _toLowerCase());
 schemaRegistry.add(repositorySchema, {
   description: "The repo URL of the workspace (i.e. the GitHub repository URL)"
 });
-var licenseSchema = z._default(
-  z.string().check(z.trim()),
+var licenseSchema = _default(
+  string2().check(_trim()),
   "Apache-2.0"
 );
 schemaRegistry.add(licenseSchema, {
   description: "The license type of the package"
 });
-var homepageSchema = z.optional(z.url());
+var homepageSchema = optional(url());
 schemaRegistry.add(homepageSchema, {
   description: "The homepage of the workspace"
 });
-var docsSchema = z.optional(z.url());
+var docsSchema = optional(url());
 schemaRegistry.add(docsSchema, {
   description: "The documentation site for the workspace"
 });
-var portalSchema = z.optional(z.url());
+var portalSchema = optional(url());
 schemaRegistry.add(portalSchema, {
   description: "The development portal site for the workspace"
 });
-var licensingSchema = z.optional(z.url());
+var licensingSchema = optional(url());
 schemaRegistry.add(licensingSchema, {
   description: "The licensing site for the workspace"
 });
-var contactSchema = z.optional(z.url());
+var contactSchema = optional(url());
 schemaRegistry.add(contactSchema, {
   description: "The contact site for the workspace"
 });
-var supportSchema = z.optional(z.url());
+var supportSchema = optional(url());
 schemaRegistry.add(supportSchema, {
   description: "The support site for the workspace. If not provided, this is defaulted to the `contact` config value"
 });
-var branchSchema = z._default(
-  z.string().check(z.trim(), z.toLowerCase()),
+var branchSchema = _default(
+  string2().check(_trim(), _toLowerCase()),
   "main"
 );
 schemaRegistry.add(branchSchema, {
   description: "The branch of the workspace"
 });
-var preidSchema = z.optional(
-  z.string().check(z.trim(), z.toLowerCase())
+var preidSchema = optional(
+  string2().check(_trim(), _toLowerCase())
 );
 schemaRegistry.add(preidSchema, {
   description: "A tag specifying the version pre-release identifier"
 });
-var ownerSchema = z.optional(
-  z.string().check(z.trim(), z.toLowerCase())
+var ownerSchema = optional(
+  string2().check(_trim(), _toLowerCase())
 );
 schemaRegistry.add(ownerSchema, {
   description: "The owner of the package"
 });
-var modeSchema = z._default(
-  z.enum(["development", "staging", "production"]).check(z.trim(), z.toLowerCase()),
+var modeSchema = _default(
+  _enum(["development", "staging", "production"]).check(_trim(), _toLowerCase()),
   "production"
 );
 schemaRegistry.add(modeSchema, {
   description: "The current runtime environment mode for the package"
 });
-var workspaceRootSchema = z.string().check(z.trim(), z.toLowerCase());
+var workspaceRootSchema = string2().check(_trim(), _toLowerCase());
 schemaRegistry.add(workspaceRootSchema, {
   description: "The root directory of the workspace"
 });
-var skipCacheSchema = z._default(z.boolean(), false);
+var skipCacheSchema = _default(boolean2(), false);
 schemaRegistry.add(skipCacheSchema, {
   description: "Should all known types of workspace caching be skipped?"
 });
-var packageManagerSchema = z._default(
-  z.enum(["npm", "yarn", "pnpm", "bun"]),
+var packageManagerSchema = _default(
+  _enum(["npm", "yarn", "pnpm", "bun"]),
   "npm"
 );
 schemaRegistry.add(packageManagerSchema, {
   description: "The JavaScript/TypeScript package manager used by the repository"
 });
-var timezoneSchema = z._default(
-  z.string().check(z.trim(), z.toLowerCase()),
+var timezoneSchema = _default(
+  string2().check(_trim(), _toLowerCase()),
   "America/New_York"
 );
 schemaRegistry.add(timezoneSchema, {
   description: "The default timezone of the workspace"
 });
-var localeSchema = z._default(
-  z.string().check(z.trim(), z.toLowerCase()),
+var localeSchema = _default(
+  string2().check(_trim(), _toLowerCase()),
   "en-US"
 );
 schemaRegistry.add(localeSchema, {
   description: "The default locale of the workspace"
 });
-var logLevelSchema = z._default(
-  z.enum([
+var logLevelSchema = _default(
+  _enum([
     "silent",
     "fatal",
     "error",
@@ -2914,22 +4683,22 @@ var logLevelSchema = z._default(
 schemaRegistry.add(logLevelSchema, {
   description: "The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."
 });
-var skipConfigLoggingSchema = z._default(z.boolean(), true);
+var skipConfigLoggingSchema = _default(boolean2(), true);
 schemaRegistry.add(skipConfigLoggingSchema, {
   description: "Should the logging of the current Storm Workspace configuration be skipped?"
 });
-var configFileSchema = z._default(
-  z.nullable(z.string().check(z.trim())),
+var configFileSchema = _default(
+  nullable(string2().check(_trim())),
   null
 );
 schemaRegistry.add(configFileSchema, {
   description: "The filepath of the Storm config. When this field is null, no config file was found in the current workspace."
 });
-var extensionsSchema = z._default(z.record(z.string(), z.any()), {});
+var extensionsSchema = _default(record(string2(), any()), {});
 schemaRegistry.add(extensionsSchema, {
   description: "Configuration of each used extension"
 });
-var workspaceConfigSchema = z.object({
+var workspaceConfigSchema = object({
   $schema: schemaNameSchema,
   extends: extendsSchema,
   name: nameSchema,
@@ -2961,7 +4730,7 @@ var workspaceConfigSchema = z.object({
   skipConfigLogging: skipConfigLoggingSchema,
   registry: registrySchema,
   configFile: configFileSchema,
-  colors: z.union([colorsSchema, themeColorsSchema]),
+  colors: union([colorsSchema, themeColorsSchema]),
   extensions: extensionsSchema
 });
 schemaRegistry.add(extensionsSchema, {
@@ -3045,34 +4814,34 @@ async function getPackageJsonConfig(root) {
     support
   };
 }
-function applyDefaultConfig(config2) {
-  if (!config2.support && config2.contact) {
-    config2.support = config2.contact;
+function applyDefaultConfig(config3) {
+  if (!config3.support && config3.contact) {
+    config3.support = config3.contact;
   }
-  if (!config2.contact && config2.support) {
-    config2.contact = config2.support;
+  if (!config3.contact && config3.support) {
+    config3.contact = config3.support;
   }
-  if (config2.homepage) {
-    if (!config2.docs) {
-      config2.docs = `${config2.homepage}/docs`;
+  if (config3.homepage) {
+    if (!config3.docs) {
+      config3.docs = `${config3.homepage}/docs`;
     }
-    if (!config2.license) {
-      config2.license = `${config2.homepage}/license`;
+    if (!config3.license) {
+      config3.license = `${config3.homepage}/license`;
     }
-    if (!config2.support) {
-      config2.support = `${config2.homepage}/support`;
+    if (!config3.support) {
+      config3.support = `${config3.homepage}/support`;
     }
-    if (!config2.contact) {
-      config2.contact = `${config2.homepage}/contact`;
+    if (!config3.contact) {
+      config3.contact = `${config3.homepage}/contact`;
     }
-    if (!config2.error?.codesFile || !config2?.error?.url) {
-      config2.error ??= { codesFile: STORM_DEFAULT_ERROR_CODES_FILE };
-      if (config2.homepage) {
-        config2.error.url ??= `${config2.homepage}/errors`;
+    if (!config3.error?.codesFile || !config3?.error?.url) {
+      config3.error ??= { codesFile: STORM_DEFAULT_ERROR_CODES_FILE };
+      if (config3.homepage) {
+        config3.error.url ??= `${config3.homepage}/errors`;
       }
     }
   }
-  return config2;
+  return config3;
 }
 
 // ../config-tools/src/config-file/get-config-file.ts
@@ -3114,9 +4883,9 @@ var getConfigFileByName = async (fileName, filePath, options = {}) => {
 var getConfigFile = async (filePath, additionalFileNames = []) => {
   const workspacePath = filePath ? filePath : findWorkspaceRoot2(filePath);
   const result = await getConfigFileByName("storm-workspace", workspacePath);
-  let config2 = result.config;
+  let config3 = result.config;
   const configFile = result.configFile;
-  if (config2 && configFile && Object.keys(config2).length > 0 && !config2.skipConfigLogging) {
+  if (config3 && configFile && Object.keys(config3).length > 0 && !config3.skipConfigLogging) {
     writeTrace(
       `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`,
       {
@@ -3132,7 +4901,7 @@ var getConfigFile = async (filePath, additionalFileNames = []) => {
     );
     for (const result2 of results) {
       if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
-        if (!config2.skipConfigLogging && !result2.config.skipConfigLogging) {
+        if (!config3.skipConfigLogging && !result2.config.skipConfigLogging) {
           writeTrace(
             `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`,
             {
@@ -3140,15 +4909,15 @@ var getConfigFile = async (filePath, additionalFileNames = []) => {
             }
           );
         }
-        config2 = defu2(result2.config ?? {}, config2 ?? {});
+        config3 = defu2(result2.config ?? {}, config3 ?? {});
       }
     }
   }
-  if (!config2 || Object.keys(config2).length === 0) {
+  if (!config3 || Object.keys(config3).length === 0) {
     return void 0;
   }
-  config2.configFile = configFile;
-  return config2;
+  config3.configFile = configFile;
+  return config3;
 };
 
 // ../config-tools/src/create-storm-config.ts
@@ -3171,7 +4940,7 @@ var getExtensionEnv = (extensionName) => {
 };
 var getConfigEnv = () => {
   const prefix = "STORM_";
-  let config2 = {
+  let config3 = {
     extends: process.env[`${prefix}EXTENDS`] || void 0,
     name: process.env[`${prefix}NAME`] || void 0,
     namespace: process.env[`${prefix}NAMESPACE`] || void 0,
@@ -3259,38 +5028,38 @@ var getConfigEnv = () => {
       (colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)
     )
   );
-  config2.colors = themeNames.length > 0 ? themeNames.reduce(
+  config3.colors = themeNames.length > 0 ? themeNames.reduce(
     (ret, themeName) => {
       ret[themeName] = getThemeColorsEnv(prefix, themeName);
       return ret;
     },
     {}
   ) : getThemeColorsEnv(prefix);
-  if (config2.docs === STORM_DEFAULT_DOCS) {
-    if (config2.homepage === STORM_DEFAULT_HOMEPAGE) {
-      config2.docs = `${STORM_DEFAULT_HOMEPAGE}/projects/${config2.name}/docs`;
+  if (config3.docs === STORM_DEFAULT_DOCS) {
+    if (config3.homepage === STORM_DEFAULT_HOMEPAGE) {
+      config3.docs = `${STORM_DEFAULT_HOMEPAGE}/projects/${config3.name}/docs`;
     } else {
-      config2.docs = `${config2.homepage}/docs`;
+      config3.docs = `${config3.homepage}/docs`;
     }
   }
-  if (config2.licensing === STORM_DEFAULT_LICENSING) {
-    if (config2.homepage === STORM_DEFAULT_HOMEPAGE) {
-      config2.licensing = `${STORM_DEFAULT_HOMEPAGE}/projects/${config2.name}/licensing`;
+  if (config3.licensing === STORM_DEFAULT_LICENSING) {
+    if (config3.homepage === STORM_DEFAULT_HOMEPAGE) {
+      config3.licensing = `${STORM_DEFAULT_HOMEPAGE}/projects/${config3.name}/licensing`;
     } else {
-      config2.licensing = `${config2.homepage}/docs`;
+      config3.licensing = `${config3.homepage}/docs`;
     }
   }
   const serializedConfig = process.env[`${prefix}CONFIG`];
   if (serializedConfig) {
     const parsed = JSON.parse(serializedConfig);
-    config2 = {
-      ...config2,
+    config3 = {
+      ...config3,
       ...parsed,
-      colors: { ...config2.colors, ...parsed.colors },
-      extensions: { ...config2.extensions, ...parsed.extensions }
+      colors: { ...config3.colors, ...parsed.colors },
+      extensions: { ...config3.extensions, ...parsed.extensions }
     };
   }
-  return config2;
+  return config3;
 };
 var getThemeColorsEnv = (prefix, theme) => {
   const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
@@ -3391,343 +5160,343 @@ var setExtensionEnv = (extensionName, extension) => {
     }
   }
 };
-var setConfigEnv = (config2) => {
+var setConfigEnv = (config3) => {
   const prefix = "STORM_";
-  if (config2.extends) {
-    process.env[`${prefix}EXTENDS`] = Array.isArray(config2.extends) ? JSON.stringify(config2.extends) : config2.extends;
+  if (config3.extends) {
+    process.env[`${prefix}EXTENDS`] = Array.isArray(config3.extends) ? JSON.stringify(config3.extends) : config3.extends;
   }
-  if (config2.name) {
-    process.env[`${prefix}NAME`] = config2.name;
+  if (config3.name) {
+    process.env[`${prefix}NAME`] = config3.name;
   }
-  if (config2.namespace) {
-    process.env[`${prefix}NAMESPACE`] = config2.namespace;
+  if (config3.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config3.namespace;
   }
-  if (config2.owner) {
-    process.env[`${prefix}OWNER`] = config2.owner;
+  if (config3.owner) {
+    process.env[`${prefix}OWNER`] = config3.owner;
   }
-  if (config2.bot) {
-    process.env[`${prefix}BOT_NAME`] = config2.bot.name;
-    process.env[`${prefix}BOT_EMAIL`] = config2.bot.email;
+  if (config3.bot) {
+    process.env[`${prefix}BOT_NAME`] = config3.bot.name;
+    process.env[`${prefix}BOT_EMAIL`] = config3.bot.email;
   }
-  if (config2.error) {
-    process.env[`${prefix}ERROR_CODES_FILE`] = config2.error.codesFile;
-    process.env[`${prefix}ERROR_URL`] = config2.error.url;
+  if (config3.error) {
+    process.env[`${prefix}ERROR_CODES_FILE`] = config3.error.codesFile;
+    process.env[`${prefix}ERROR_URL`] = config3.error.url;
   }
-  if (config2.release) {
-    if (config2.release.banner) {
-      if (typeof config2.release.banner === "string") {
-        process.env[`${prefix}RELEASE_BANNER`] = config2.release.banner;
-        process.env[`${prefix}RELEASE_BANNER_URL`] = config2.release.banner;
+  if (config3.release) {
+    if (config3.release.banner) {
+      if (typeof config3.release.banner === "string") {
+        process.env[`${prefix}RELEASE_BANNER`] = config3.release.banner;
+        process.env[`${prefix}RELEASE_BANNER_URL`] = config3.release.banner;
       } else {
-        process.env[`${prefix}RELEASE_BANNER`] = config2.release.banner.url;
-        process.env[`${prefix}RELEASE_BANNER_URL`] = config2.release.banner.url;
-        process.env[`${prefix}RELEASE_BANNER_ALT`] = config2.release.banner.alt;
+        process.env[`${prefix}RELEASE_BANNER`] = config3.release.banner.url;
+        process.env[`${prefix}RELEASE_BANNER_URL`] = config3.release.banner.url;
+        process.env[`${prefix}RELEASE_BANNER_ALT`] = config3.release.banner.alt;
       }
     }
-    process.env[`${prefix}RELEASE_HEADER`] = config2.release.header;
-    process.env[`${prefix}RELEASE_FOOTER`] = config2.release.footer;
+    process.env[`${prefix}RELEASE_HEADER`] = config3.release.header;
+    process.env[`${prefix}RELEASE_FOOTER`] = config3.release.footer;
   }
-  if (config2.socials) {
-    if (config2.socials.twitter) {
-      process.env[`${prefix}SOCIAL_TWITTER`] = config2.socials.twitter;
+  if (config3.socials) {
+    if (config3.socials.twitter) {
+      process.env[`${prefix}SOCIAL_TWITTER`] = config3.socials.twitter;
     }
-    if (config2.socials.discord) {
-      process.env[`${prefix}SOCIAL_DISCORD`] = config2.socials.discord;
+    if (config3.socials.discord) {
+      process.env[`${prefix}SOCIAL_DISCORD`] = config3.socials.discord;
     }
-    if (config2.socials.telegram) {
-      process.env[`${prefix}SOCIAL_TELEGRAM`] = config2.socials.telegram;
+    if (config3.socials.telegram) {
+      process.env[`${prefix}SOCIAL_TELEGRAM`] = config3.socials.telegram;
     }
-    if (config2.socials.slack) {
-      process.env[`${prefix}SOCIAL_SLACK`] = config2.socials.slack;
+    if (config3.socials.slack) {
+      process.env[`${prefix}SOCIAL_SLACK`] = config3.socials.slack;
     }
-    if (config2.socials.medium) {
-      process.env[`${prefix}SOCIAL_MEDIUM`] = config2.socials.medium;
+    if (config3.socials.medium) {
+      process.env[`${prefix}SOCIAL_MEDIUM`] = config3.socials.medium;
     }
-    if (config2.socials.github) {
-      process.env[`${prefix}SOCIAL_GITHUB`] = config2.socials.github;
+    if (config3.socials.github) {
+      process.env[`${prefix}SOCIAL_GITHUB`] = config3.socials.github;
     }
   }
-  if (config2.organization) {
-    if (typeof config2.organization === "string") {
-      process.env[`${prefix}ORG`] = config2.organization;
-      process.env[`${prefix}ORG_NAME`] = config2.organization;
-      process.env[`${prefix}ORGANIZATION`] = config2.organization;
-      process.env[`${prefix}ORGANIZATION_NAME`] = config2.organization;
+  if (config3.organization) {
+    if (typeof config3.organization === "string") {
+      process.env[`${prefix}ORG`] = config3.organization;
+      process.env[`${prefix}ORG_NAME`] = config3.organization;
+      process.env[`${prefix}ORGANIZATION`] = config3.organization;
+      process.env[`${prefix}ORGANIZATION_NAME`] = config3.organization;
     } else {
-      process.env[`${prefix}ORG`] = config2.organization.name;
-      process.env[`${prefix}ORG_NAME`] = config2.organization.name;
-      process.env[`${prefix}ORGANIZATION`] = config2.organization.name;
-      process.env[`${prefix}ORGANIZATION_NAME`] = config2.organization.name;
-      if (config2.organization.url) {
-        process.env[`${prefix}ORG_URL`] = config2.organization.url;
-        process.env[`${prefix}ORGANIZATION_URL`] = config2.organization.url;
+      process.env[`${prefix}ORG`] = config3.organization.name;
+      process.env[`${prefix}ORG_NAME`] = config3.organization.name;
+      process.env[`${prefix}ORGANIZATION`] = config3.organization.name;
+      process.env[`${prefix}ORGANIZATION_NAME`] = config3.organization.name;
+      if (config3.organization.url) {
+        process.env[`${prefix}ORG_URL`] = config3.organization.url;
+        process.env[`${prefix}ORGANIZATION_URL`] = config3.organization.url;
       }
-      if (config2.organization.description) {
-        process.env[`${prefix}ORG_DESCRIPTION`] = config2.organization.description;
-        process.env[`${prefix}ORGANIZATION_DESCRIPTION`] = config2.organization.description;
+      if (config3.organization.description) {
+        process.env[`${prefix}ORG_DESCRIPTION`] = config3.organization.description;
+        process.env[`${prefix}ORGANIZATION_DESCRIPTION`] = config3.organization.description;
       }
-      if (config2.organization.logo) {
-        process.env[`${prefix}ORG_LOGO`] = config2.organization.logo;
-        process.env[`${prefix}ORGANIZATION_LOGO`] = config2.organization.logo;
+      if (config3.organization.logo) {
+        process.env[`${prefix}ORG_LOGO`] = config3.organization.logo;
+        process.env[`${prefix}ORGANIZATION_LOGO`] = config3.organization.logo;
       }
-      if (config2.organization.icon) {
-        process.env[`${prefix}ORG_ICON`] = config2.organization.icon;
-        process.env[`${prefix}ORGANIZATION_ICON`] = config2.organization.icon;
+      if (config3.organization.icon) {
+        process.env[`${prefix}ORG_ICON`] = config3.organization.icon;
+        process.env[`${prefix}ORGANIZATION_ICON`] = config3.organization.icon;
       }
     }
   }
-  if (config2.packageManager) {
-    process.env[`${prefix}PACKAGE_MANAGER`] = config2.packageManager;
+  if (config3.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config3.packageManager;
   }
-  if (config2.license) {
-    process.env[`${prefix}LICENSE`] = config2.license;
+  if (config3.license) {
+    process.env[`${prefix}LICENSE`] = config3.license;
   }
-  if (config2.homepage) {
-    process.env[`${prefix}HOMEPAGE`] = config2.homepage;
+  if (config3.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config3.homepage;
   }
-  if (config2.docs) {
-    process.env[`${prefix}DOCS`] = config2.docs;
+  if (config3.docs) {
+    process.env[`${prefix}DOCS`] = config3.docs;
   }
-  if (config2.portal) {
-    process.env[`${prefix}PORTAL`] = config2.portal;
+  if (config3.portal) {
+    process.env[`${prefix}PORTAL`] = config3.portal;
   }
-  if (config2.licensing) {
-    process.env[`${prefix}LICENSING`] = config2.licensing;
+  if (config3.licensing) {
+    process.env[`${prefix}LICENSING`] = config3.licensing;
   }
-  if (config2.contact) {
-    process.env[`${prefix}CONTACT`] = config2.contact;
+  if (config3.contact) {
+    process.env[`${prefix}CONTACT`] = config3.contact;
   }
-  if (config2.support) {
-    process.env[`${prefix}SUPPORT`] = config2.support;
+  if (config3.support) {
+    process.env[`${prefix}SUPPORT`] = config3.support;
   }
-  if (config2.timezone) {
-    process.env[`${prefix}TIMEZONE`] = config2.timezone;
-    process.env.TZ = config2.timezone;
-    process.env.DEFAULT_TIMEZONE = config2.timezone;
-    process.env.TIMEZONE = config2.timezone;
+  if (config3.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config3.timezone;
+    process.env.TZ = config3.timezone;
+    process.env.DEFAULT_TIMEZONE = config3.timezone;
+    process.env.TIMEZONE = config3.timezone;
   }
-  if (config2.locale) {
-    process.env[`${prefix}LOCALE`] = config2.locale;
-    process.env.DEFAULT_LOCALE = config2.locale;
-    process.env.LOCALE = config2.locale;
-    process.env.LANG = config2.locale ? `${config2.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  if (config3.locale) {
+    process.env[`${prefix}LOCALE`] = config3.locale;
+    process.env.DEFAULT_LOCALE = config3.locale;
+    process.env.LOCALE = config3.locale;
+    process.env.LANG = config3.locale ? `${config3.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
   }
-  if (config2.configFile) {
-    process.env[`${prefix}CONFIG_FILE`] = correctPaths(config2.configFile);
+  if (config3.configFile) {
+    process.env[`${prefix}CONFIG_FILE`] = correctPaths(config3.configFile);
   }
-  if (config2.workspaceRoot) {
-    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config2.workspaceRoot);
-    process.env.NX_WORKSPACE_ROOT = correctPaths(config2.workspaceRoot);
-    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config2.workspaceRoot);
+  if (config3.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config3.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = correctPaths(config3.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config3.workspaceRoot);
   }
-  if (config2.directories) {
-    if (!config2.skipCache && config2.directories.cache) {
+  if (config3.directories) {
+    if (!config3.skipCache && config3.directories.cache) {
       process.env[`${prefix}CACHE_DIR`] = correctPaths(
-        config2.directories.cache
+        config3.directories.cache
       );
       process.env[`${prefix}CACHE_DIRECTORY`] = process.env[`${prefix}CACHE_DIR`];
     }
-    if (config2.directories.data) {
-      process.env[`${prefix}DATA_DIR`] = correctPaths(config2.directories.data);
+    if (config3.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = correctPaths(config3.directories.data);
       process.env[`${prefix}DATA_DIRECTORY`] = process.env[`${prefix}DATA_DIR`];
     }
-    if (config2.directories.config) {
+    if (config3.directories.config) {
       process.env[`${prefix}CONFIG_DIR`] = correctPaths(
-        config2.directories.config
+        config3.directories.config
       );
       process.env[`${prefix}CONFIG_DIRECTORY`] = process.env[`${prefix}CONFIG_DIR`];
     }
-    if (config2.directories.temp) {
-      process.env[`${prefix}TEMP_DIR`] = correctPaths(config2.directories.temp);
+    if (config3.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = correctPaths(config3.directories.temp);
       process.env[`${prefix}TEMP_DIRECTORY`] = process.env[`${prefix}TEMP_DIR`];
     }
-    if (config2.directories.log) {
-      process.env[`${prefix}LOG_DIR`] = correctPaths(config2.directories.log);
+    if (config3.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = correctPaths(config3.directories.log);
       process.env[`${prefix}LOG_DIRECTORY`] = process.env[`${prefix}LOG_DIR`];
     }
-    if (config2.directories.build) {
+    if (config3.directories.build) {
       process.env[`${prefix}BUILD_DIR`] = correctPaths(
-        config2.directories.build
+        config3.directories.build
       );
       process.env[`${prefix}BUILD_DIRECTORY`] = process.env[`${prefix}BUILD_DIR`];
     }
   }
-  if (config2.skipCache !== void 0) {
-    process.env[`${prefix}SKIP_CACHE`] = String(config2.skipCache);
-    if (config2.skipCache) {
-      process.env.NX_SKIP_NX_CACHE ??= String(config2.skipCache);
-      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config2.skipCache);
+  if (config3.skipCache !== void 0) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config3.skipCache);
+    if (config3.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config3.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config3.skipCache);
     }
   }
-  if (config2.mode) {
-    process.env[`${prefix}MODE`] = config2.mode;
-    process.env.NODE_ENV = config2.mode;
-    process.env.ENVIRONMENT = config2.mode;
+  if (config3.mode) {
+    process.env[`${prefix}MODE`] = config3.mode;
+    process.env.NODE_ENV = config3.mode;
+    process.env.ENVIRONMENT = config3.mode;
   }
-  if (config2.colors?.base?.light || config2.colors?.base?.dark) {
-    for (const key of Object.keys(config2.colors)) {
-      setThemeColorsEnv(`${prefix}COLOR_${key}_`, config2.colors[key]);
+  if (config3.colors?.base?.light || config3.colors?.base?.dark) {
+    for (const key of Object.keys(config3.colors)) {
+      setThemeColorsEnv(`${prefix}COLOR_${key}_`, config3.colors[key]);
     }
   } else {
     setThemeColorsEnv(
       `${prefix}COLOR_`,
-      config2.colors
+      config3.colors
     );
   }
-  if (config2.repository) {
-    process.env[`${prefix}REPOSITORY`] = config2.repository;
+  if (config3.repository) {
+    process.env[`${prefix}REPOSITORY`] = config3.repository;
   }
-  if (config2.branch) {
-    process.env[`${prefix}BRANCH`] = config2.branch;
+  if (config3.branch) {
+    process.env[`${prefix}BRANCH`] = config3.branch;
   }
-  if (config2.preid) {
-    process.env[`${prefix}PRE_ID`] = String(config2.preid);
+  if (config3.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config3.preid);
   }
-  if (config2.registry) {
-    if (config2.registry.github) {
-      process.env[`${prefix}REGISTRY_GITHUB`] = String(config2.registry.github);
+  if (config3.registry) {
+    if (config3.registry.github) {
+      process.env[`${prefix}REGISTRY_GITHUB`] = String(config3.registry.github);
     }
-    if (config2.registry.npm) {
-      process.env[`${prefix}REGISTRY_NPM`] = String(config2.registry.npm);
+    if (config3.registry.npm) {
+      process.env[`${prefix}REGISTRY_NPM`] = String(config3.registry.npm);
     }
-    if (config2.registry.cargo) {
-      process.env[`${prefix}REGISTRY_CARGO`] = String(config2.registry.cargo);
+    if (config3.registry.cargo) {
+      process.env[`${prefix}REGISTRY_CARGO`] = String(config3.registry.cargo);
     }
-    if (config2.registry.cyclone) {
+    if (config3.registry.cyclone) {
       process.env[`${prefix}REGISTRY_CYCLONE`] = String(
-        config2.registry.cyclone
+        config3.registry.cyclone
       );
     }
-    if (config2.registry.container) {
+    if (config3.registry.container) {
       process.env[`${prefix}REGISTRY_CONTAINER`] = String(
-        config2.registry.container
+        config3.registry.container
       );
     }
   }
-  if (config2.logLevel) {
-    process.env[`${prefix}LOG_LEVEL`] = String(config2.logLevel);
-    process.env.LOG_LEVEL = String(config2.logLevel);
+  if (config3.logLevel) {
+    process.env[`${prefix}LOG_LEVEL`] = String(config3.logLevel);
+    process.env.LOG_LEVEL = String(config3.logLevel);
     process.env.NX_VERBOSE_LOGGING = String(
-      getLogLevel(config2.logLevel) >= LogLevel.DEBUG ? true : false
+      getLogLevel(config3.logLevel) >= LogLevel.DEBUG ? true : false
     );
-    process.env.RUST_BACKTRACE = getLogLevel(config2.logLevel) >= LogLevel.DEBUG ? "full" : "none";
+    process.env.RUST_BACKTRACE = getLogLevel(config3.logLevel) >= LogLevel.DEBUG ? "full" : "none";
   }
-  if (config2.skipConfigLogging !== void 0) {
+  if (config3.skipConfigLogging !== void 0) {
     process.env[`${prefix}SKIP_CONFIG_LOGGING`] = String(
-      config2.skipConfigLogging
+      config3.skipConfigLogging
     );
   }
-  process.env[`${prefix}CONFIG`] = JSON.stringify(config2);
-  for (const key of Object.keys(config2.extensions ?? {})) {
-    if (config2.extensions[key] && Object.keys(config2.extensions[key])) {
-      setExtensionEnv(key, config2.extensions[key]);
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config3);
+  for (const key of Object.keys(config3.extensions ?? {})) {
+    if (config3.extensions[key] && Object.keys(config3.extensions[key])) {
+      setExtensionEnv(key, config3.extensions[key]);
     }
   }
 };
-var setThemeColorsEnv = (prefix, config2) => {
-  return config2?.light?.brand || config2?.dark?.brand ? setMultiThemeColorsEnv(prefix, config2) : setSingleThemeColorsEnv(prefix, config2);
+var setThemeColorsEnv = (prefix, config3) => {
+  return config3?.light?.brand || config3?.dark?.brand ? setMultiThemeColorsEnv(prefix, config3) : setSingleThemeColorsEnv(prefix, config3);
 };
-var setSingleThemeColorsEnv = (prefix, config2) => {
-  if (config2.dark) {
-    process.env[`${prefix}DARK`] = config2.dark;
+var setSingleThemeColorsEnv = (prefix, config3) => {
+  if (config3.dark) {
+    process.env[`${prefix}DARK`] = config3.dark;
   }
-  if (config2.light) {
-    process.env[`${prefix}LIGHT`] = config2.light;
+  if (config3.light) {
+    process.env[`${prefix}LIGHT`] = config3.light;
   }
-  if (config2.brand) {
-    process.env[`${prefix}BRAND`] = config2.brand;
+  if (config3.brand) {
+    process.env[`${prefix}BRAND`] = config3.brand;
   }
-  if (config2.alternate) {
-    process.env[`${prefix}ALTERNATE`] = config2.alternate;
+  if (config3.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config3.alternate;
   }
-  if (config2.accent) {
-    process.env[`${prefix}ACCENT`] = config2.accent;
+  if (config3.accent) {
+    process.env[`${prefix}ACCENT`] = config3.accent;
   }
-  if (config2.link) {
-    process.env[`${prefix}LINK`] = config2.link;
+  if (config3.link) {
+    process.env[`${prefix}LINK`] = config3.link;
   }
-  if (config2.help) {
-    process.env[`${prefix}HELP`] = config2.help;
+  if (config3.help) {
+    process.env[`${prefix}HELP`] = config3.help;
   }
-  if (config2.success) {
-    process.env[`${prefix}SUCCESS`] = config2.success;
+  if (config3.success) {
+    process.env[`${prefix}SUCCESS`] = config3.success;
   }
-  if (config2.info) {
-    process.env[`${prefix}INFO`] = config2.info;
+  if (config3.info) {
+    process.env[`${prefix}INFO`] = config3.info;
   }
-  if (config2.warning) {
-    process.env[`${prefix}WARNING`] = config2.warning;
+  if (config3.warning) {
+    process.env[`${prefix}WARNING`] = config3.warning;
   }
-  if (config2.danger) {
-    process.env[`${prefix}DANGER`] = config2.danger;
+  if (config3.danger) {
+    process.env[`${prefix}DANGER`] = config3.danger;
   }
-  if (config2.fatal) {
-    process.env[`${prefix}FATAL`] = config2.fatal;
+  if (config3.fatal) {
+    process.env[`${prefix}FATAL`] = config3.fatal;
   }
-  if (config2.positive) {
-    process.env[`${prefix}POSITIVE`] = config2.positive;
+  if (config3.positive) {
+    process.env[`${prefix}POSITIVE`] = config3.positive;
   }
-  if (config2.negative) {
-    process.env[`${prefix}NEGATIVE`] = config2.negative;
+  if (config3.negative) {
+    process.env[`${prefix}NEGATIVE`] = config3.negative;
   }
-  if (config2.gradient) {
-    for (let i = 0; i < config2.gradient.length; i++) {
-      process.env[`${prefix}GRADIENT_${i}`] = config2.gradient[i];
+  if (config3.gradient) {
+    for (let i = 0; i < config3.gradient.length; i++) {
+      process.env[`${prefix}GRADIENT_${i}`] = config3.gradient[i];
     }
   }
 };
-var setMultiThemeColorsEnv = (prefix, config2) => {
+var setMultiThemeColorsEnv = (prefix, config3) => {
   return {
-    light: setBaseThemeColorsEnv(`${prefix}LIGHT_`, config2.light),
-    dark: setBaseThemeColorsEnv(`${prefix}DARK_`, config2.dark)
+    light: setBaseThemeColorsEnv(`${prefix}LIGHT_`, config3.light),
+    dark: setBaseThemeColorsEnv(`${prefix}DARK_`, config3.dark)
   };
 };
-var setBaseThemeColorsEnv = (prefix, config2) => {
-  if (config2.foreground) {
-    process.env[`${prefix}FOREGROUND`] = config2.foreground;
+var setBaseThemeColorsEnv = (prefix, config3) => {
+  if (config3.foreground) {
+    process.env[`${prefix}FOREGROUND`] = config3.foreground;
   }
-  if (config2.background) {
-    process.env[`${prefix}BACKGROUND`] = config2.background;
+  if (config3.background) {
+    process.env[`${prefix}BACKGROUND`] = config3.background;
   }
-  if (config2.brand) {
-    process.env[`${prefix}BRAND`] = config2.brand;
+  if (config3.brand) {
+    process.env[`${prefix}BRAND`] = config3.brand;
   }
-  if (config2.alternate) {
-    process.env[`${prefix}ALTERNATE`] = config2.alternate;
+  if (config3.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config3.alternate;
   }
-  if (config2.accent) {
-    process.env[`${prefix}ACCENT`] = config2.accent;
+  if (config3.accent) {
+    process.env[`${prefix}ACCENT`] = config3.accent;
   }
-  if (config2.link) {
-    process.env[`${prefix}LINK`] = config2.link;
+  if (config3.link) {
+    process.env[`${prefix}LINK`] = config3.link;
   }
-  if (config2.help) {
-    process.env[`${prefix}HELP`] = config2.help;
+  if (config3.help) {
+    process.env[`${prefix}HELP`] = config3.help;
   }
-  if (config2.success) {
-    process.env[`${prefix}SUCCESS`] = config2.success;
+  if (config3.success) {
+    process.env[`${prefix}SUCCESS`] = config3.success;
   }
-  if (config2.info) {
-    process.env[`${prefix}INFO`] = config2.info;
+  if (config3.info) {
+    process.env[`${prefix}INFO`] = config3.info;
   }
-  if (config2.warning) {
-    process.env[`${prefix}WARNING`] = config2.warning;
+  if (config3.warning) {
+    process.env[`${prefix}WARNING`] = config3.warning;
   }
-  if (config2.danger) {
-    process.env[`${prefix}DANGER`] = config2.danger;
+  if (config3.danger) {
+    process.env[`${prefix}DANGER`] = config3.danger;
   }
-  if (config2.fatal) {
-    process.env[`${prefix}FATAL`] = config2.fatal;
+  if (config3.fatal) {
+    process.env[`${prefix}FATAL`] = config3.fatal;
   }
-  if (config2.positive) {
-    process.env[`${prefix}POSITIVE`] = config2.positive;
+  if (config3.positive) {
+    process.env[`${prefix}POSITIVE`] = config3.positive;
   }
-  if (config2.negative) {
-    process.env[`${prefix}NEGATIVE`] = config2.negative;
+  if (config3.negative) {
+    process.env[`${prefix}NEGATIVE`] = config3.negative;
   }
-  if (config2.gradient) {
-    for (let i = 0; i < config2.gradient.length; i++) {
-      process.env[`${prefix}GRADIENT_${i}`] = config2.gradient[i];
+  if (config3.gradient) {
+    for (let i = 0; i < config3.gradient.length; i++) {
+      process.env[`${prefix}GRADIENT_${i}`] = config3.gradient[i];
     }
   }
 };
@@ -3807,25 +5576,25 @@ var createConfigExtension = (extensionName, schema) => {
 };
 var tryLoadStormWorkspaceConfig = async (workspaceRoot, skipLogs = true, useDefault = false) => {
   try {
-    const config2 = await createStormWorkspaceConfig(
+    const config3 = await createStormWorkspaceConfig(
       void 0,
       void 0,
       workspaceRoot,
       skipLogs,
       useDefault
     );
-    if (!config2) {
+    if (!config3) {
       return void 0;
     }
-    setConfigEnv(config2);
-    if (!skipLogs && !config2.skipConfigLogging) {
+    setConfigEnv(config3);
+    if (!skipLogs && !config3.skipConfigLogging) {
       writeTrace(
         `\u2699\uFE0F  Using Storm Workspace configuration: 
-${formatLogMessage(config2)}`,
-        config2
+${formatLogMessage(config3)}`,
+        config3
       );
     }
-    return config2;
+    return config3;
   } catch (error) {
     if (!skipLogs) {
       writeWarning(
@@ -3906,7 +5675,7 @@ async function javascript(options = {}) {
     {
       name: "storm/javascript/rules",
       plugins: {
-        "unused-imports": default9
+        "unused-imports": default10
       },
       rules: {
         // disallow use of console
@@ -5211,7 +6980,7 @@ async function node() {
     {
       name: "storm/node/rules",
       plugins: {
-        node: default4
+        node: default5
       },
       rules: {
         "node/handle-callback-err": ["error", "^(err|error)$"],
@@ -5302,7 +7071,7 @@ async function perfectionist() {
     {
       name: "storm/perfectionist/rules",
       plugins: {
-        perfectionist: default6
+        perfectionist: default7
       },
       rules: {
         "perfectionist/sort-exports": [
@@ -5452,18 +7221,18 @@ async function pnpm(options = {}) {
 
 // src/configs/prettier.ts
 init_esm_shims();
-import config from "eslint-config-prettier";
+import config2 from "eslint-config-prettier";
 async function prettier() {
   return [
     {
-      ...config,
+      ...config2,
       name: "storm/prettier/rules",
       plugins: {
-        ...config.plugins,
-        prettier: default7
+        ...config2.plugins,
+        prettier: default8
       },
       rules: {
-        ...config.rules,
+        ...config2.rules,
         "prettier/prettier": "error",
         "arrow-body-style": "off",
         "prefer-arrow-callback": "off"
@@ -5674,9 +7443,9 @@ async function reactNative(options = {}) {
 init_esm_shims();
 import { configs as configs2 } from "eslint-plugin-regexp";
 async function regexp(options = {}) {
-  const config2 = configs2["flat/recommended"];
+  const config3 = configs2["flat/recommended"];
   const rules2 = {
-    ...config2.rules
+    ...config3.rules
   };
   if (options.level === "warn") {
     for (const key in rules2) {
@@ -5685,7 +7454,7 @@ async function regexp(options = {}) {
   }
   return [
     {
-      ...config2,
+      ...config3,
       name: "storm/regexp/rules",
       rules: {
         ...rules2,
@@ -5714,7 +7483,7 @@ async function secrets(options) {
       name: "storm/secrets/rules",
       files: [`**/*.{js,ts,jsx,tsx${json ? ",json,jsonc" : ""}`],
       plugins: {
-        "no-secrets": default5
+        "no-secrets": default6
       },
       rules: {
         "no-secrets/no-secrets": [
@@ -6412,10 +8181,10 @@ async function unicorn(options = {}) {
     {
       name: "storm/unicorn/rules",
       plugins: {
-        unicorn: default8
+        unicorn: default9
       },
       rules: {
-        ...options.allRecommended ? default8.configs["recommended"].rules : {
+        ...options.allRecommended ? default9.configs["recommended"].rules : {
           "unicorn/consistent-empty-array-spread": "error",
           "unicorn/error-message": "error",
           "unicorn/escape-case": "error",
@@ -6542,6 +8311,26 @@ async function yaml(options = {}) {
   ];
 }
 
+// src/configs/zod.ts
+init_esm_shims();
+async function zod(options = {}) {
+  const { overrides = {} } = options;
+  await ensurePackages(["eslint-plugin-import-zod"]);
+  return [
+    {
+      name: "storm/zod/rules",
+      files: [GLOB_SRC],
+      plugins: {
+        "import-zod": default4
+      },
+      rules: {
+        "import-zod/prefer-zod-namespace": "error"
+      },
+      ...overrides
+    }
+  ];
+}
+
 // src/preset.ts
 var flatConfigProps = [
   "name",
@@ -6591,7 +8380,8 @@ function getStormConfig(options, ...userConfigs) {
     typescript: enableTypeScript = isPackageExists2("typescript"),
     unicorn: enableUnicorn = true,
     tsdoc: enableTSDoc = true,
-    unocss: enableUnoCSS = false
+    unocss: enableUnoCSS = false,
+    zod: enableZod = true
   } = options;
   let isInEditor = options.isInEditor;
   if (isInEditor == null) {
@@ -6681,6 +8471,13 @@ function getStormConfig(options, ...userConfigs) {
       })
     );
   }
+  if (enableZod) {
+    configs3.push(
+      zod({
+        overrides: getOverrides(options, "zod")
+      })
+    );
+  }
   if (stylisticOptions) {
     configs3.push(
       stylistic({