@covro/covro 0.6.1-dev.3 → 0.6.1-dev.5

package/dist/update-worker.cjs

@@ -36,7 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
-    var constants3 = require("constants");
+    var constants4 = require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -60,7 +60,7 @@ var require_polyfills = __commonJS({
     var chdir;
     module2.exports = patch;
     function patch(fs) {
-      if (constants3.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants4.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs);
       }
       if (!fs.lutimes) {
@@ -162,7 +162,7 @@ var require_polyfills = __commonJS({
         fs2.lchmod = function(path, mode, callback) {
           fs2.open(
             path,
-            constants3.O_WRONLY | constants3.O_SYMLINK,
+            constants4.O_WRONLY | constants4.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -178,7 +178,7 @@ var require_polyfills = __commonJS({
           );
         };
         fs2.lchmodSync = function(path, mode) {
-          var fd = fs2.openSync(path, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
+          var fd = fs2.openSync(path, constants4.O_WRONLY | constants4.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -198,9 +198,9 @@ var require_polyfills = __commonJS({
         };
       }
       function patchLutimes(fs2) {
-        if (constants3.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
+        if (constants4.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
           fs2.lutimes = function(path, at, mt, cb) {
-            fs2.open(path, constants3.O_SYMLINK, function(er, fd) {
+            fs2.open(path, constants4.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -213,7 +213,7 @@ var require_polyfills = __commonJS({
             });
           };
           fs2.lutimesSync = function(path, at, mt) {
-            var fd = fs2.openSync(path, constants3.O_SYMLINK);
+            var fd = fs2.openSync(path, constants4.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -525,8 +525,8 @@ var require_graceful_fs = __commonJS({
       fs2.createReadStream = createReadStream2;
       fs2.createWriteStream = createWriteStream;
       var fs$readFile = fs2.readFile;
-      fs2.readFile = readFile3;
-      function readFile3(path, options, cb) {
+      fs2.readFile = readFile5;
+      function readFile5(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path, options, cb);
@@ -542,8 +542,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs2.writeFile;
-      fs2.writeFile = writeFile2;
-      function writeFile2(path, data, options, cb) {
+      fs2.writeFile = writeFile3;
+      function writeFile3(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path, data, options, cb);
@@ -1235,7 +1235,7 @@ var require_mtime_precision = __commonJS({
   "node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports2, module2) {
     "use strict";
     var cacheSymbol = /* @__PURE__ */ Symbol();
-    function probe(file2, fs, callback) {
+    function probe2(file2, fs, callback) {
       const cachedPrecision = fs[cacheSymbol];
       if (cachedPrecision) {
         return fs.stat(file2, (err, stat) => {
@@ -1267,7 +1267,7 @@ var require_mtime_precision = __commonJS({
       }
       return new Date(now);
     }
-    module2.exports.probe = probe;
+    module2.exports.probe = probe2;
     module2.exports.getMtime = getMtime;
   }
 });
@@ -1532,12 +1532,12 @@ var require_adapter = __commonJS({
       return newFs;
     }
     function toPromise(method) {
-      return (...args) => new Promise((resolve3, reject) => {
+      return (...args) => new Promise((resolve4, reject) => {
         args.push((err, result) => {
           if (err) {
             reject(err);
           } else {
-            resolve3(result);
+            resolve4(result);
           }
         });
         method(...args);
@@ -2277,7 +2277,7 @@ function assertNotEqual(val) {
   return val;
 }
 function toZod() {
-  return (schema) => schema;
+  return (schema2) => schema2;
 }
 function assertIs(_arg) {
 }
@@ -2370,8 +2370,8 @@ function rawShape(def) {
   const desc = Object.getOwnPropertyDescriptor(def, "shape");
   return desc?.get ? desc.get.raw : desc?.value;
 }
-function sourceShape(schema) {
-  return rawShape(schema._zod.def) ?? schema._zod.def.shape;
+function sourceShape(schema2) {
+  return rawShape(schema2._zod.def) ?? schema2._zod.def.shape;
 }
 function deferProp(target, key, getter) {
   Object.defineProperty(target, key, {
@@ -2424,8 +2424,8 @@ function mergeDefs(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef(schema) {
-  return mergeDefs(schema._zod.def);
+function cloneDef(schema2) {
+  return mergeDefs(schema2._zod.def);
 }
 function getElementAtPath(obj, path) {
   if (!path)
@@ -2647,19 +2647,19 @@ var BIGINT_FORMAT_RANGES = {
   int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
   uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
 };
-function pick(schema, mask) {
-  const currDef = schema._zod.def;
+function pick(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
   const newShape = {};
-  mirrorShape(newShape, schema, maskedKeys(schema, mask));
-  return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
+  mirrorShape(newShape, schema2, maskedKeys(schema2, mask));
+  return clone(schema2, mergeDefs(currDef, { shape: newShape, checks: [] }));
 }
-function maskedKeys(schema, mask) {
-  const raw = sourceShape(schema);
+function maskedKeys(schema2, mask) {
+  const raw = sourceShape(schema2);
   const keys = [];
   for (const key of Reflect.ownKeys(mask)) {
     if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
@@ -2670,45 +2670,45 @@ function maskedKeys(schema, mask) {
   }
   return keys;
 }
-function omit(schema, mask) {
-  const currDef = schema._zod.def;
+function omit(schema2, mask) {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const omitted = new Set(maskedKeys(schema, mask));
+  const omitted = new Set(maskedKeys(schema2, mask));
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
-  return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
+  mirrorShape(newShape, schema2, Reflect.ownKeys(sourceShape(schema2)).filter((key) => !omitted.has(key)));
+  return clone(schema2, mergeDefs(currDef, { shape: newShape, checks: [] }));
 }
-function extend(schema, shape) {
+function extend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema._zod.def.checks;
+  const checks = schema2._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = sourceShape(schema);
+    const existingShape = sourceShape(schema2);
     for (const key of Reflect.ownKeys(shape)) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
+  return clone(schema2, mergeDefs(schema2._zod.def, { shape: extended(schema2, shape) }));
 }
-function extended(schema, shape) {
+function extended(schema2, shape) {
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
+  mirrorShape(newShape, schema2, Reflect.ownKeys(sourceShape(schema2)));
   mirrorProps(newShape, shape);
   return newShape;
 }
-function safeExtend(schema, shape) {
+function safeExtend(schema2, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
+  return clone(schema2, mergeDefs(schema2._zod.def, { shape: extended(schema2, shape) }));
 }
 function merge(a, b) {
   if (!b?._zod?.def) {
@@ -2729,26 +2729,26 @@ function merge(a, b) {
   });
   return clone(a, def);
 }
-function partial(Class2, schema, mask, name = "partial") {
-  const currDef = schema._zod.def;
+function partial(Class2, schema2, mask, name = "partial") {
+  const currDef = schema2._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
   }
-  const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
+  const selected = mask ? new Set(maskedKeys(schema2, mask)) : void 0;
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class2 && ((value, key) => selected && !selected.has(key) ? value : new Class2({ type: "optional", innerType: value })));
-  return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] }));
+  mirrorShape(newShape, schema2, Reflect.ownKeys(sourceShape(schema2)), Class2 && ((value, key) => selected && !selected.has(key) ? value : new Class2({ type: "optional", innerType: value })));
+  return clone(schema2, mergeDefs(schema2._zod.def, { shape: newShape, checks: [] }));
 }
-function required(Class2, schema, mask) {
-  const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
+function required(Class2, schema2, mask) {
+  const selected = mask ? new Set(maskedKeys(schema2, mask)) : void 0;
   const newShape = {};
-  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => (
+  mirrorShape(newShape, schema2, Reflect.ownKeys(sourceShape(schema2)), (value, key) => (
     // overwrite with non-optional
     selected && !selected.has(key) ? value : new Class2({ type: "nonoptional", innerType: value })
   ));
-  return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
+  return clone(schema2, mergeDefs(schema2._zod.def, { shape: newShape }));
 }
 function aborted(x, startIndex = 0) {
   if (x.aborted === true)
@@ -3365,9 +3365,9 @@ function finalizeParams(callee, params) {
   return { callee: params?.callee ?? callee, Err: params?.Err };
 }
 var _parse = (_Err) => {
-  const fn = (schema, value, _ctx, _params) => {
+  const fn = (schema2, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-    const result = schema._zod.run({ value, issues: [] }, ctx);
+    const result = schema2._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise) {
       throw new $ZodAsyncError();
     }
@@ -3382,9 +3382,9 @@ var _parse = (_Err) => {
 };
 var parse = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => {
-  const fn = async (schema, value, _ctx, params) => {
+  const fn = async (schema2, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-    let result = schema._zod.run({ value, issues: [] }, ctx);
+    let result = schema2._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
     if (result.issues.length) {
@@ -3397,9 +3397,9 @@ var _parseAsync = (_Err) => {
   return fn;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-var _safeParse = (_Err) => (schema, value, _ctx) => {
+var _safeParse = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
+  const result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
@@ -3425,9 +3425,9 @@ function failure(Err, issues, ctx) {
     }
   };
 }
-var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+var _safeParseAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
@@ -3435,88 +3435,88 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
 var COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
 var COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
-var validate = ((schema, value, _ctx) => {
-  const validator = schema._zod.bag.validator;
+var validate = ((schema2, value, _ctx) => {
+  const validator = schema2._zod.bag.validator;
   if (validator !== void 0) {
     if (validator(value) !== COMPILE_INVALID)
       return true;
     if (validator.definite === true && _ctx === void 0)
       return false;
   }
-  return validateFallback(schema, value, _ctx);
+  return validateFallback(schema2, value, _ctx);
 });
-function validateFallback(schema, value, _ctx) {
+function validateFallback(schema2, value, _ctx) {
   const ctx = _ctx ? { ..._ctx, async: false, abortEarly: true } : { async: false, abortEarly: true };
-  const fallbackRun = schema._zod.bag.fallbackRun;
+  const fallbackRun = schema2._zod.bag.fallbackRun;
   let result;
   if (fallbackRun) {
     ctx[COMPILE_FALLBACK] = true;
     result = fallbackRun({ value, issues: [] }, ctx);
   } else {
-    result = schema._zod.run({ value, issues: [] }, ctx);
+    result = schema2._zod.run({ value, issues: [] }, ctx);
   }
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
   }
   return result.issues.length === 0;
 }
-var validateAsync = async (schema, value, _ctx) => {
+var validateAsync = async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true, abortEarly: true } : { async: true, abortEarly: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
+  let result = schema2._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length === 0;
 };
 var _encode = (_Err) => {
   const parse3 = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
+  const fn = (schema2, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse3(schema, value, ctx, finalizeParams(fn, _params));
+    return parse3(schema2, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
   const parse3 = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
-    return parse3(schema, value, _ctx, finalizeParams(fn, _params));
+  const fn = (schema2, value, _ctx, _params) => {
+    return parse3(schema2, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var decode = /* @__PURE__ */ _decode($ZodRealError);
 var _encodeAsync = (_Err) => {
   const parseAsync3 = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
+  const fn = async (schema2, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return await parseAsync3(schema, value, ctx, finalizeParams(fn, _params));
+    return await parseAsync3(schema2, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
 var _decodeAsync = (_Err) => {
   const parseAsync3 = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
-    return await parseAsync3(schema, value, _ctx, finalizeParams(fn, _params));
+  const fn = async (schema2, value, _ctx, _params) => {
+    return await parseAsync3(schema2, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-var _safeEncode = (_Err) => (schema, value, _ctx) => {
+var _safeEncode = (_Err) => (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse(_Err)(schema, value, ctx);
+  return _safeParse(_Err)(schema2, value, ctx);
 };
 var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-var _safeDecode = (_Err) => (schema, value, _ctx) => {
-  return _safeParse(_Err)(schema, value, _ctx);
+var _safeDecode = (_Err) => (schema2, value, _ctx) => {
+  return _safeParse(_Err)(schema2, value, _ctx);
 };
 var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+var _safeEncodeAsync = (_Err) => async (schema2, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync(_Err)(schema, value, ctx);
+  return _safeParseAsync(_Err)(schema2, value, ctx);
 };
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _safeParseAsync(_Err)(schema, value, _ctx);
+var _safeDecodeAsync = (_Err) => async (schema2, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema2, value, _ctx);
 };
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
@@ -3620,8 +3620,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter) => {
-  const escapedDelim = escapeRegex(delimiter ?? ":");
+var mac = (delimiter2) => {
+  const escapedDelim = escapeRegex(delimiter2 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -4132,8 +4132,8 @@ var $ZodCheckProperties = /* @__PURE__ */ $constructor("$ZodCheckProperties", (i
     entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
     const input2 = payload.value;
     let proms;
-    for (const [key, schema] of entries) {
-      const result = schema._zod.run({ value: input2[key], issues: [] }, {});
+    for (const [key, schema2] of entries) {
+      const result = schema2._zod.run({ value: input2[key], issues: [] }, {});
       if (result instanceof Promise) {
         proms ?? (proms = []);
         proms.push(result.then((result2) => handleCheckPropertyResult(result2, payload, key)));
@@ -5253,10 +5253,10 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
       const id = ids[key];
       const k = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc(key);
       const isPresent = `${k} in input`;
-      const schema = shape[key];
-      const optin = schema?._zod?.optin;
+      const schema2 = shape[key];
+      const optin = schema2?._zod?.optin;
       const isOptionalIn = optin !== void 0;
-      const isOptionalOut = schema?._zod?.optout === "optional";
+      const isOptionalOut = schema2?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(k)};`);
       if (isOptionalIn && isOptionalOut) {
         const assign = optin === "optional" ? `${id}_present` : `${id}.value !== undefined || ${id}_present`;
@@ -6437,8 +6437,8 @@ function handleReadonlyResult(payload) {
     payload.value = Object.freeze(payload.value);
   return payload;
 }
-function leafPattern(schema) {
-  const def = schema._zod.def;
+function leafPattern(schema2) {
+  const def = schema2._zod.def;
   let pattern = def.pattern;
   let isInt = !!def.format?.includes("int");
   let minimum;
@@ -6461,13 +6461,13 @@ function leafPattern(schema) {
     return "(?!)";
   if (minimum !== void 0 || maximum !== void 0)
     return string({ minimum, maximum }).source;
-  const own2 = schema._zod.pattern;
+  const own2 = schema2._zod.pattern;
   return (isInt && own2 === number ? integer : own2)?.source;
 }
-function partPattern(schema) {
-  const def = schema._zod.def;
-  const own2 = schema._zod.pattern?.source;
-  const inner = def.innerType ?? schema._zod.innerType;
+function partPattern(schema2) {
+  const def = schema2._zod.def;
+  const own2 = schema2._zod.pattern?.source;
+  const inner = def.innerType ?? schema2._zod.innerType;
   if (inner) {
     const before = inner._zod.pattern?.source;
     const after = partPattern(inner);
@@ -6481,7 +6481,7 @@ function partPattern(schema) {
     if (sources2.every(Boolean))
       return `^(${sources2.map((s) => cleanRegex(s)).join("|")})$`;
   }
-  return leafPattern(schema);
+  return leafPattern(schema2);
 }
 var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
   $ZodType.init(inst, def);
@@ -6677,7 +6677,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve3) {
+function isRecursive(inst, stack, resolve4) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -6687,7 +6687,7 @@ function isRecursive(inst, stack, resolve3) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve3);
+      const answer = isRecursive(child, stack, resolve4);
       if (answer > result)
         result = answer;
     }
@@ -6698,7 +6698,7 @@ function isRecursive(inst, stack, resolve3) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve4) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -6762,7 +6762,7 @@ function isRecursive(inst, stack, resolve3) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve4 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -14511,11 +14511,11 @@ var $ZodRegistry = class {
     this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
   }
-  add(schema, ..._meta) {
+  add(schema2, ..._meta) {
     const meta3 = _meta[0];
-    this._map.set(schema, meta3);
+    this._map.set(schema2, meta3);
     if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-      this._idmap.set(meta3.id, schema);
+      this._idmap.set(meta3.id, schema2);
     }
     return this;
   }
@@ -14524,26 +14524,26 @@ var $ZodRegistry = class {
     this._idmap = /* @__PURE__ */ new Map();
     return this;
   }
-  remove(schema) {
-    const meta3 = this._map.get(schema);
+  remove(schema2) {
+    const meta3 = this._map.get(schema2);
     if (meta3 && typeof meta3 === "object" && "id" in meta3) {
       this._idmap.delete(meta3.id);
     }
-    this._map.delete(schema);
+    this._map.delete(schema2);
     return this;
   }
-  get(schema) {
-    const p = schema._zod.parent;
+  get(schema2) {
+    const p = schema2._zod.parent;
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema) };
+      const f = { ...pm, ...this._map.get(schema2) };
       return Object.keys(f).length ? f : void 0;
     }
-    return this._map.get(schema);
+    return this._map.get(schema2);
   }
-  has(schema) {
-    return this._map.has(schema);
+  has(schema2) {
+    return this._map.has(schema2);
   }
 };
 function registry() {
@@ -14568,31 +14568,31 @@ var ZodCompileUnsupportedError = class extends Error {
     this.islandable = islandable;
   }
 };
-function compileValidator(schema, parser) {
+function compileValidator(schema2, parser) {
   try {
-    return compileFn(schema, { assertOnly: true });
+    return compileFn(schema2, { assertOnly: true });
   } catch {
     return parser;
   }
 }
-function compile(schema, options) {
+function compile(schema2, options) {
   try {
-    const parser = compileFn(schema);
-    const clone2 = withParser(schema, parser);
-    clone2._zod.bag.validator = compileValidator(schema, parser);
+    const parser = compileFn(schema2);
+    const clone2 = withParser(schema2, parser);
+    clone2._zod.bag.validator = compileValidator(schema2, parser);
     return clone2;
   } catch (err) {
     if (options?.strict)
       throw err;
-    return schema;
+    return schema2;
   }
 }
-function withParser(schema, parser) {
-  if (isRecursiveSchema(schema)) {
+function withParser(schema2, parser) {
+  if (isRecursiveSchema(schema2)) {
     throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
   }
-  const clone2 = clone(schema);
-  const liveRun = schema._zod.run;
+  const clone2 = clone(schema2);
+  const liveRun = schema2._zod.run;
   const originalRun = liveRun.__originalRun ?? liveRun;
   const wrapped = (payload, ctx) => {
     if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks || ctx?.[FALLBACK_FLAG]) {
@@ -14615,7 +14615,7 @@ function withParser(schema, parser) {
   clone2._zod.bag.validator = parser;
   clone2._zod.run = wrapped;
   if (!liveRun.__originalRun)
-    installCompiledUserMethods(clone2, schema, parser);
+    installCompiledUserMethods(clone2, schema2, parser);
   return clone2;
 }
 function installCompiledUserMethods(target, source, parser) {
@@ -14642,10 +14642,10 @@ function installCompiledUserMethods(target, source, parser) {
     };
   }
 }
-function compileFn(schema, options) {
+function compileFn(schema2, options) {
   let recursive2 = true;
   try {
-    recursive2 = isRecursiveSchema(schema);
+    recursive2 = isRecursiveSchema(schema2);
   } catch {
   }
   if (recursive2) {
@@ -14658,7 +14658,7 @@ function compileFn(schema, options) {
     definite: true
   };
   const doc = new Doc(["input"]);
-  const outputAccessor = generateCheck(doc, ctx, schema, "input", !options?.assertOnly);
+  const outputAccessor = generateCheck(doc, ctx, schema2, "input", !options?.assertOnly);
   doc.write(outputAccessor === null ? `return true;` : `return ${outputAccessor};`);
   const constantNames = ["INVALID", ...ctx.constants.keys()];
   const constantValues = [INVALID, ...ctx.constants.values()];
@@ -14698,20 +14698,20 @@ function addUserConstant(ctx, fn) {
 function newVar(ctx) {
   return `v${ctx.varCounter++}`;
 }
-function runtimeRun(schema, value) {
-  const result = schema._zod.run({ value, issues: [] }, {});
+function runtimeRun(schema2, value) {
+  const result = schema2._zod.run({ value, issues: [] }, {});
   if (result && typeof result.then === "function")
     return INVALID;
   const r = result;
   return r.issues.length === 0 ? r.value : INVALID;
 }
-function compileChild(doc, ctx, schema, accessor, needsValue = true) {
+function compileChild(doc, ctx, schema2, accessor, needsValue = true) {
   const contentLen = doc.content.length;
   const constantCount = ctx.constants.size;
   const constantCounter = ctx.constantCounter;
   const varCounter = ctx.varCounter;
   try {
-    return generateCheck(doc, ctx, schema, accessor, needsValue);
+    return generateCheck(doc, ctx, schema2, accessor, needsValue);
   } catch (err) {
     if (!(err instanceof ZodCompileUnsupportedError) || !err.islandable)
       throw err;
@@ -14723,12 +14723,12 @@ function compileChild(doc, ctx, schema, accessor, needsValue = true) {
     }
     ctx.constantCounter = constantCounter;
     ctx.varCounter = varCounter;
-    return emitRuntimeIsland(doc, ctx, schema, accessor);
+    return emitRuntimeIsland(doc, ctx, schema2, accessor);
   }
 }
-function emitRuntimeIsland(doc, ctx, schema, accessor) {
+function emitRuntimeIsland(doc, ctx, schema2, accessor) {
   ctx.definite = false;
-  const schemaConst = addConstant(ctx, schema);
+  const schemaConst = addConstant(ctx, schema2);
   const runConst = addConstant(ctx, runtimeRun);
   const outVar = newVar(ctx);
   doc.write(`const ${outVar} = ${runConst}(${schemaConst}, ${accessor});`);
@@ -14743,8 +14743,8 @@ var WHEN_DEFAULTED_CHECKS = /* @__PURE__ */ new Set([
   "min_length",
   "length_equals"
 ]);
-function generateChecks(doc, ctx, schema, accessor) {
-  const schemaChecks = schema._zod.def.checks;
+function generateChecks(doc, ctx, schema2, accessor) {
+  const schemaChecks = schema2._zod.def.checks;
   if (!schemaChecks || schemaChecks.length === 0)
     return accessor;
   let currentAccessor = accessor;
@@ -15119,8 +15119,8 @@ function generateStringFormatCheck(doc, ctx, def, accessor, needsValue = true) {
   }
   return accessor;
 }
-function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
-  const def = schema._zod.def;
+function generateCheck(doc, ctx, schema2, accessor, needsValue = true) {
+  const def = schema2._zod.def;
   const type = def.type;
   if (def.coerce) {
     throw new ZodCompileUnsupportedError(`coercion (z.coerce.${type}())`);
@@ -15129,16 +15129,16 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
   let typeAccessor;
   switch (type) {
     case "string":
-      typeAccessor = generateStringCheck(doc, ctx, schema, accessor, buildsValue);
+      typeAccessor = generateStringCheck(doc, ctx, schema2, accessor, buildsValue);
       break;
     case "number":
-      typeAccessor = generateNumberCheck(doc, schema, accessor);
+      typeAccessor = generateNumberCheck(doc, schema2, accessor);
       break;
     case "boolean":
       typeAccessor = generateBooleanCheck(doc, accessor);
       break;
     case "bigint":
-      typeAccessor = generateBigIntCheck(doc, schema, accessor);
+      typeAccessor = generateBigIntCheck(doc, schema2, accessor);
       break;
     case "symbol":
       typeAccessor = generateSymbolCheck(doc, accessor);
@@ -15167,79 +15167,79 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
       typeAccessor = generateDateCheck(doc, accessor);
       break;
     case "object":
-      typeAccessor = generateObjectCheck(doc, ctx, schema, accessor, buildsValue);
+      typeAccessor = generateObjectCheck(doc, ctx, schema2, accessor, buildsValue);
       break;
     case "optional":
-      typeAccessor = generateOptionalCheck(doc, ctx, schema, accessor, buildsValue);
+      typeAccessor = generateOptionalCheck(doc, ctx, schema2, accessor, buildsValue);
       break;
     case "nullable":
-      typeAccessor = generateNullableCheck(doc, ctx, schema, accessor, buildsValue);
+      typeAccessor = generateNullableCheck(doc, ctx, schema2, accessor, buildsValue);
       break;
     case "array":
-      typeAccessor = generateArrayCheck(doc, ctx, schema, accessor, buildsValue);
+      typeAccessor = generateArrayCheck(doc, ctx, schema2, accessor, buildsValue);
       break;
     case "literal":
-      typeAccessor = generateLiteralCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateLiteralCheck(doc, ctx, schema2, accessor);
       break;
     case "enum":
-      typeAccessor = generateEnumCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateEnumCheck(doc, ctx, schema2, accessor);
       break;
     case "readonly": {
-      const innerOut = generateWrapperCheck(doc, ctx, schema, accessor);
+      const innerOut = generateWrapperCheck(doc, ctx, schema2, accessor);
       const frozenVar = newVar(ctx);
       doc.write(`const ${frozenVar} = Object.freeze(${innerOut});`);
       typeAccessor = frozenVar;
       break;
     }
     case "success":
-      generateWrapperCheck(doc, ctx, schema, accessor);
+      generateWrapperCheck(doc, ctx, schema2, accessor);
       typeAccessor = "true";
       break;
     case "default":
     case "prefault":
-      typeAccessor = generateDefaultCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateDefaultCheck(doc, ctx, schema2, accessor);
       break;
     case "nonoptional":
-      typeAccessor = generateNonOptionalCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateNonOptionalCheck(doc, ctx, schema2, accessor);
       break;
     case "tuple":
-      typeAccessor = generateTupleCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateTupleCheck(doc, ctx, schema2, accessor);
       break;
     case "union":
-      typeAccessor = generateUnionCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateUnionCheck(doc, ctx, schema2, accessor);
       break;
     case "intersection":
-      typeAccessor = generateIntersectionCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateIntersectionCheck(doc, ctx, schema2, accessor);
       break;
     case "record":
-      typeAccessor = generateRecordCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateRecordCheck(doc, ctx, schema2, accessor);
       break;
     case "map":
-      typeAccessor = generateMapCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateMapCheck(doc, ctx, schema2, accessor);
       break;
     case "set":
-      typeAccessor = generateSetCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateSetCheck(doc, ctx, schema2, accessor);
       break;
     case "file":
       typeAccessor = generateFileCheck(doc, accessor);
       break;
     case "template_literal":
-      typeAccessor = generateTemplateLiteralCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateTemplateLiteralCheck(doc, ctx, schema2, accessor);
       break;
     case "lazy":
-      typeAccessor = generateLazyCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateLazyCheck(doc, ctx, schema2, accessor);
       break;
     case "pipe":
-      typeAccessor = generatePipeCheck(doc, ctx, schema, accessor);
+      typeAccessor = generatePipeCheck(doc, ctx, schema2, accessor);
       break;
     case "custom":
-      typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateCustomCheck(doc, ctx, schema2, accessor);
       break;
     case "transform":
-      typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateTransformCheck(doc, ctx, schema2, accessor);
       break;
     case "catch":
-      typeAccessor = generateCatchCheck(doc, ctx, schema, accessor);
+      typeAccessor = generateCatchCheck(doc, ctx, schema2, accessor);
       break;
     default: {
       void type;
@@ -15248,18 +15248,18 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
   }
   if (typeAccessor === null)
     return null;
-  return generateChecks(doc, ctx, schema, typeAccessor);
+  return generateChecks(doc, ctx, schema2, typeAccessor);
 }
-function generateStringCheck(doc, ctx, schema, accessor, needsValue = true) {
+function generateStringCheck(doc, ctx, schema2, accessor, needsValue = true) {
   doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   if (def.format === void 0)
     return accessor;
   return generateStringFormatCheck(doc, ctx, def, accessor, needsValue);
 }
-function generateNumberCheck(doc, schema, accessor) {
+function generateNumberCheck(doc, schema2, accessor) {
   doc.write(`if (typeof ${accessor} !== "number" || !Number.isFinite(${accessor})) return INVALID;`);
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   if (def.check === "number_format" && def.format) {
     generateNumberFormatCheck(doc, { format: def.format }, accessor);
   }
@@ -15269,9 +15269,9 @@ function generateBooleanCheck(doc, accessor) {
   doc.write(`if (typeof ${accessor} !== "boolean") return INVALID;`);
   return accessor;
 }
-function generateBigIntCheck(doc, schema, accessor) {
+function generateBigIntCheck(doc, schema2, accessor) {
   doc.write(`if (typeof ${accessor} !== "bigint") return INVALID;`);
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   if (def.format) {
     switch (def.format) {
       case "int64":
@@ -15308,8 +15308,8 @@ function generateDateCheck(doc, accessor) {
   doc.write(`if (!(${accessor} instanceof Date) || Number.isNaN(${accessor}.getTime())) return INVALID;`);
   return accessor;
 }
-function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
-  const def = schema._zod.def;
+function generateObjectCheck(doc, ctx, schema2, accessor, buildsValue = true) {
+  const def = schema2._zod.def;
   doc.write(`if (typeof ${accessor} !== "object" || ${accessor} === null || Array.isArray(${accessor})) return INVALID;`);
   const shape = def.shape;
   const keys = Object.keys(shape);
@@ -15427,9 +15427,9 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
   }
   return outputVar;
 }
-function generateOptionalCheck(doc, ctx, schema, accessor, buildsValue = true) {
-  const def = schema._zod.def;
-  if (isExactOptional(schema)) {
+function generateOptionalCheck(doc, ctx, schema2, accessor, buildsValue = true) {
+  const def = schema2._zod.def;
+  if (isExactOptional(schema2)) {
     return generateCheck(doc, ctx, def.innerType, accessor, buildsValue);
   }
   if (def.innerType._zod.optin === "defaulted") {
@@ -15466,16 +15466,16 @@ function generateOptionalCheck(doc, ctx, schema, accessor, buildsValue = true) {
   doc.write(`}`);
   return outputVar;
 }
-function isExactOptional(schema) {
-  return schema._zod.traits?.has("$ZodExactOptional") === true;
+function isExactOptional(schema2) {
+  return schema2._zod.traits?.has("$ZodExactOptional") === true;
 }
-function requiresPresenceCheck(schema) {
-  return schema._zod.optin === void 0 && fastPathAcceptsAbsence(schema);
+function requiresPresenceCheck(schema2) {
+  return schema2._zod.optin === void 0 && fastPathAcceptsAbsence(schema2);
 }
-function fastPathAcceptsAbsence(schema) {
-  if (schema._zod.def.coerce)
+function fastPathAcceptsAbsence(schema2) {
+  if (schema2._zod.def.coerce)
     return true;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   switch (def.type) {
     case "any":
     case "unknown":
@@ -15510,7 +15510,7 @@ function fastPathAcceptsAbsence(schema) {
     case "literal":
       return !!def.values?.includes(void 0);
     case "enum":
-      return !!schema._zod.values?.has(void 0);
+      return !!schema2._zod.values?.has(void 0);
     case "optional":
     case "nullable":
     case "readonly":
@@ -15530,14 +15530,14 @@ function fastPathAcceptsAbsence(schema) {
       return true;
   }
 }
-function dropsWhenAbsent(schema) {
-  return schema._zod.optin === "optional" && schema._zod.optout === "optional";
+function dropsWhenAbsent(schema2) {
+  return schema2._zod.optin === "optional" && schema2._zod.optout === "optional";
 }
-function mayOmitUndefined(schema) {
-  return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+function mayOmitUndefined(schema2) {
+  return (schema2._zod.optin !== "defaulted" || schema2._zod.optout === "optional") && mayOutputUndefined(schema2);
 }
-function mayOutputUndefined(schema) {
-  const def = schema._zod.def;
+function mayOutputUndefined(schema2) {
+  const def = schema2._zod.def;
   switch (def.type) {
     case "string":
     case "number":
@@ -15561,7 +15561,7 @@ function mayOutputUndefined(schema) {
     case "literal":
       return !!def.values?.includes(void 0);
     case "enum":
-      return !!schema._zod.values?.has(void 0);
+      return !!schema2._zod.values?.has(void 0);
     case "optional":
       return true;
     case "nullable":
@@ -15578,8 +15578,8 @@ function mayOutputUndefined(schema) {
       return true;
   }
 }
-function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
-  const def = schema._zod.def;
+function generateNullableCheck(doc, ctx, schema2, accessor, buildsValue = true) {
+  const def = schema2._zod.def;
   const outputVar = buildsValue ? newVar(ctx) : null;
   if (outputVar)
     doc.write(`let ${outputVar} = null;`);
@@ -15592,15 +15592,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
   doc.write(`}`);
   return outputVar;
 }
-function generateSizeGate(doc, schema, size) {
-  for (const [max, check2] of sizeCaps(schema._zod.def.checks)) {
+function generateSizeGate(doc, schema2, size) {
+  for (const [max, check2] of sizeCaps(schema2._zod.def.checks)) {
     doc.write(`if (${size} > ${numericOperand(max, check2._zod.def.check)}) return INVALID;`);
   }
 }
-function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
-  const def = schema._zod.def;
+function generateArrayCheck(doc, ctx, schema2, accessor, buildsValue = true) {
+  const def = schema2._zod.def;
   doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
-  generateSizeGate(doc, schema, `${accessor}.length`);
+  generateSizeGate(doc, schema2, `${accessor}.length`);
   const outputVar = buildsValue ? newVar(ctx) : null;
   const iVar = newVar(ctx);
   const elemVar = newVar(ctx);
@@ -15616,8 +15616,8 @@ function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
   doc.write(`}`);
   return outputVar;
 }
-function generateLiteralCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateLiteralCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const values = def.values;
   if (values.length !== 1) {
     const literalSet = addConstant(ctx, new Set(values));
@@ -15645,8 +15645,8 @@ function generateLiteralCheck(doc, ctx, schema, accessor) {
   }
   return accessor;
 }
-function generateEnumCheck(doc, ctx, schema, accessor) {
-  const values = schema._zod.values;
+function generateEnumCheck(doc, ctx, schema2, accessor) {
+  const values = schema2._zod.values;
   if (!values) {
     throw new ZodCompileUnsupportedError("enum schema without enumerated values");
   }
@@ -15654,15 +15654,15 @@ function generateEnumCheck(doc, ctx, schema, accessor) {
   doc.write(`if (!${enumSet}.has(${accessor})) return INVALID;`);
   return accessor;
 }
-function generateWrapperCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateWrapperCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   return generateCheck(doc, ctx, def.innerType, accessor);
 }
-function generateDefaultCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
-  const descriptor = Object.getOwnPropertyDescriptor(schema._zod.def, "defaultValue");
-  const defaultGetter = descriptor ? () => schema._zod.def.defaultValue : void 0;
-  if (schema._zod.def.type === "prefault") {
+function generateDefaultCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
+  const descriptor = Object.getOwnPropertyDescriptor(schema2._zod.def, "defaultValue");
+  const defaultGetter = descriptor ? () => schema2._zod.def.defaultValue : void 0;
+  if (schema2._zod.def.type === "prefault") {
     if (!defaultGetter) {
       return generateCheck(doc, ctx, def.innerType, accessor);
     }
@@ -15698,16 +15698,16 @@ function generateDefaultCheck(doc, ctx, schema, accessor) {
   }
   return outputVar;
 }
-function generateNonOptionalCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateNonOptionalCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const innerOutput = generateCheck(doc, ctx, def.innerType, accessor);
   const outputVar = newVar(ctx);
   doc.write(`const ${outputVar} = ${innerOutput};`);
   doc.write(`if (${outputVar} === undefined) return INVALID;`);
   return outputVar;
 }
-function generateTupleCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateTupleCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const items = def.items;
   const rest = def.rest;
   doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
@@ -15781,8 +15781,8 @@ function getTupleOptStart2(items, key) {
   }
   return 0;
 }
-function generateUnionCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateUnionCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const options = def.options;
   if (def.discriminator) {
     return generateDiscriminatedUnionCheck(doc, ctx, def, accessor);
@@ -15882,8 +15882,8 @@ function literalEquality(ctx, accessor, value) {
   }
   throw new ZodCompileUnsupportedError(`literal discriminator value ${String(value)}`);
 }
-function generateIntersectionCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateIntersectionCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   ctx.definite = false;
   const leftOutput = compileChild(doc, ctx, def.left, accessor);
   const rightOutput = compileChild(doc, ctx, def.right, accessor);
@@ -15893,8 +15893,8 @@ function generateIntersectionCheck(doc, ctx, schema, accessor) {
   doc.write(`if (!${mergedVar}.valid) return INVALID;`);
   return `${mergedVar}.data`;
 }
-function generateRecordCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateRecordCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const isPlainObjectConst = addConstant(ctx, isPlainObject);
   doc.write(`if (!${isPlainObjectConst}(${accessor})) return INVALID;`);
   const outputVar = newVar(ctx);
@@ -15997,10 +15997,10 @@ function literalPropertyKey(ctx, key) {
     return esc(key);
   return addConstant(ctx, key);
 }
-function generateMapCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateMapCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
-  generateSizeGate(doc, schema, `${accessor}.size`);
+  generateSizeGate(doc, schema2, `${accessor}.size`);
   const outputVar = newVar(ctx);
   const kVar = newVar(ctx);
   const valVar = newVar(ctx);
@@ -16014,10 +16014,10 @@ function generateMapCheck(doc, ctx, schema, accessor) {
   doc.write(`}`);
   return outputVar;
 }
-function generateSetCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateSetCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
-  generateSizeGate(doc, schema, `${accessor}.size`);
+  generateSizeGate(doc, schema2, `${accessor}.size`);
   const outputVar = newVar(ctx);
   const valVar = newVar(ctx);
   doc.write(`const ${outputVar} = new Set();`);
@@ -16033,9 +16033,9 @@ function generateFileCheck(doc, accessor) {
   doc.write(`if (!(${accessor} instanceof File)) return INVALID;`);
   return accessor;
 }
-function generateTemplateLiteralCheck(doc, ctx, schema, accessor) {
+function generateTemplateLiteralCheck(doc, ctx, schema2, accessor) {
   doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
-  const pattern = schema._zod.pattern;
+  const pattern = schema2._zod.pattern;
   if (pattern) {
     const patternConst = addConstant(ctx, pattern);
     doc.write(`${patternConst}.lastIndex = 0;`);
@@ -16043,8 +16043,8 @@ function generateTemplateLiteralCheck(doc, ctx, schema, accessor) {
   }
   return accessor;
 }
-function generateLazyCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateLazyCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const getterConst = addUserConstant(ctx, def.getter);
   const cacheConst = addConstant(ctx, { parser: null });
   doc.write(`if (!${cacheConst}.parser) {`);
@@ -16063,8 +16063,8 @@ function generateLazyCheck(doc, ctx, schema, accessor) {
   doc.write(`if (${outputVar} === INVALID) return INVALID;`);
   return outputVar;
 }
-function generatePipeCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generatePipeCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   const inputOutput = generateCheck(doc, ctx, def.in, accessor);
   if (def.transform) {
     if (isAsyncFunction(def.transform)) {
@@ -16090,8 +16090,8 @@ function generatePipeCheck(doc, ctx, schema, accessor) {
 function isAsyncFunction(fn) {
   return typeof fn === "function" && (fn.constructor.name === "AsyncFunction" || fn[Symbol.toStringTag] === "AsyncFunction");
 }
-function generateCustomCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateCustomCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   if (def.fn) {
     if (isAsyncFunction(def.fn)) {
       throw new ZodCompileAsyncError("z.compile: async custom predicates are not supported");
@@ -16116,8 +16116,8 @@ function runtimeCatch(innerSchema, catchValue, value) {
     return r.value;
   return catchValue();
 }
-function generateCatchCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateCatchCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   if (!def.catchValue[CONSTANT_CATCH]) {
     throw new ZodCompileUnsupportedError("catch with a callback (only a constant catch value compiles)", false);
   }
@@ -16139,8 +16139,8 @@ function generateCatchCheck(doc, ctx, schema, accessor) {
   doc.write(`}`);
   return outputVar;
 }
-function generateTransformCheck(doc, ctx, schema, accessor) {
-  const def = schema._zod.def;
+function generateTransformCheck(doc, ctx, schema2, accessor) {
+  const def = schema2._zod.def;
   if (def.transform) {
     if (isAsyncFunction(def.transform)) {
       throw new ZodCompileAsyncError("z.compile: async transforms are not supported");
@@ -16815,11 +16815,11 @@ function _endsWith(suffix, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _property(property, schema, params) {
+function _property(property, schema2, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema,
+    schema: schema2,
     ...normalizeParams(params)
   });
 }
@@ -17075,23 +17075,23 @@ function _promise(Class2, innerType) {
 function _custom(Class2, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema = new Class2({
+  const schema2 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _refine(Class2, fn, _params) {
-  const schema = new Class2({
+  const schema2 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema;
+  return schema2;
 }
 // @__NO_SIDE_EFFECTS__
 function _superRefine(fn, params) {
@@ -17257,8 +17257,8 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function handleUnrepresentable(schema, ctx, json2, params, message2) {
-  const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message: message2 }) : ctx.unrepresentable;
+function handleUnrepresentable(schema2, ctx, json2, params, message2) {
+  const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema2, path: params.path, message: message2 }) : ctx.unrepresentable;
   if (result === "any")
     return false;
   if (result === void 0 || result === "throw")
@@ -17266,42 +17266,42 @@ function handleUnrepresentable(schema, ctx, json2, params, message2) {
   Object.assign(json2, result);
   return true;
 }
-function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function processSchema(schema2, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
-  const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
+  const def = schema2._zod.def;
+  const seen = ctx.seen.get(schema2);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema);
+    const isCycle = _params.schemaPath.includes(schema2);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
+  ctx.seen.set(schema2, result);
   ctx.sharedDefsExtractedFor = void 0;
   ctx.sharedEmitDoneFor = void 0;
-  const overrideSchema = schema._zod.toJSONSchema?.();
+  const overrideSchema = schema2._zod.toJSONSchema?.();
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema],
+      schemaPath: [..._params.schemaPath, schema2],
       path: _params.path
     };
-    if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+    if (schema2._zod.processJSONSchema) {
+      schema2._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema, ctx, _json, params);
+      processor(schema2, ctx, _json, params);
     }
-    const parent = schema._zod.parent;
+    const parent = schema2._zod.parent;
     if (parent) {
       if (!result.ref)
         result.ref = parent;
@@ -17309,24 +17309,24 @@ function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta3 = ctx.metadataRegistry.get(schema);
+  const meta3 = ctx.metadataRegistry.get(schema2);
   if (meta3)
     assignProps(result.schema, meta3);
-  if (ctx.io === "input" && isTransforming(schema)) {
+  if (ctx.io === "input" && isTransforming(schema2)) {
     delete result.schema.examples;
     delete result.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result.schema)
     (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
   delete result.schema._prefault;
-  const _result = ctx.seen.get(schema);
+  const _result = ctx.seen.get(schema2);
   return _result.schema;
 }
 function encodeJSONPointerSegment(segment) {
   return segment.replace(/~/g, "~0").replace(/\//g, "~1");
 }
-function extractDefs(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function extractDefs(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external)
@@ -17371,11 +17371,11 @@ function extractDefs(ctx, schema) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    const schema3 = seen.schema;
+    for (const key in schema3) {
+      delete schema3[key];
     }
-    schema2.$ref = ref;
+    schema3.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -17389,13 +17389,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
-    if (schema === entry[0]) {
+    if (schema2 === entry[0]) {
       extractToDef(entry);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
+      if (schema2 !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -17418,9 +17418,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   if (ctx.external)
     ctx.sharedDefsExtractedFor = ctx.external;
 }
-function compactTypeUnion(schema) {
-  const options = schema.anyOf;
-  if (!Array.isArray(options) || options.length === 0 || schema.type !== void 0)
+function compactTypeUnion(schema2) {
+  const options = schema2.anyOf;
+  if (!Array.isArray(options) || options.length === 0 || schema2.type !== void 0)
     return;
   const types = [];
   for (const option of options) {
@@ -17438,8 +17438,8 @@ function compactTypeUnion(schema) {
         types.push(member);
     }
   }
-  delete schema.anyOf;
-  schema.type = types.length === 1 ? types[0] : types;
+  delete schema2.anyOf;
+  schema2.type = types.length === 1 ? types[0] : types;
 }
 var FOLDABLE_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties"]);
 var UNION_KEYS = ["oneOf", "anyOf"];
@@ -17526,16 +17526,16 @@ function foldIntersection(json2) {
   delete json2.allOf;
   assignProps(json2, folded);
 }
-function finalize(ctx, schema) {
-  const root = ctx.seen.get(schema);
+function finalize(ctx, schema2) {
+  const root = ctx.seen.get(schema2);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
-    const _cached = { ...schema2 };
+    const schema3 = seen.def ?? seen.schema;
+    const _cached = { ...schema3 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -17543,28 +17543,28 @@ function finalize(ctx, schema) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema2.allOf = schema2.allOf ?? [];
-        schema2.allOf.push(refSchema);
+        schema3.allOf = schema3.allOf ?? [];
+        schema3.allOf.push(refSchema);
       } else {
-        assignProps(schema2, refSchema);
+        assignProps(schema3, refSchema);
       }
-      assignProps(schema2, _cached);
+      assignProps(schema3, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema2[key];
+            delete schema3[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
+        for (const key in schema3) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key in refSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema3[key];
           }
         }
       }
@@ -17574,13 +17574,13 @@ function finalize(ctx, schema) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema2.$ref = parentSeen.schema.$ref;
+        schema3.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
+          for (const key in schema3) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key in parentSeen.def && JSON.stringify(schema3[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema3[key];
             }
           }
         }
@@ -17588,7 +17588,7 @@ function finalize(ctx, schema) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema2,
+      jsonSchema: schema3,
       path: seen.path ?? []
     });
   };
@@ -17634,13 +17634,13 @@ function finalize(ctx, schema) {
   } else {
   }
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema)?.id;
+    const id = ctx.external.registry.get(schema2)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
   assignProps(result, root.defId ? root.schema : root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema2)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
@@ -17670,10 +17670,10 @@ function finalize(ctx, schema) {
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema["~standard"],
+        ...schema2["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema2, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema2, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -17737,18 +17737,18 @@ function isTransforming(_schema, _ctx) {
   }
   return false;
 }
-var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+var createToJSONSchemaMethod = (schema2, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  processSchema(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  processSchema(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
-var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+var createStandardJSONSchemaMethod = (schema2, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  processSchema(schema, ctx);
-  extractDefs(ctx, schema);
-  return finalize(ctx, schema);
+  processSchema(schema2, ctx);
+  extractDefs(ctx, schema2);
+  return finalize(ctx, schema2);
 };
 
 // node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/json-schema-processors.js
@@ -17812,13 +17812,13 @@ var contributors = {
   },
   mime_type: (agg, def) => intersectMime(agg, def.mime)
 };
-function aggregateChecks(schema) {
+function aggregateChecks(schema2) {
   const agg = {};
-  const def = schema._zod.def;
-  const list = schema._zod.traits.has("$ZodCheck") ? [schema, ...def.checks ?? []] : def.checks ?? [];
+  const def = schema2._zod.def;
+  const list = schema2._zod.traits.has("$ZodCheck") ? [schema2, ...def.checks ?? []] : def.checks ?? [];
   for (const ch of list)
     contributors[ch._zod.def.check]?.(agg, ch._zod.def);
-  const bag = schema._zod.bag;
+  const bag = schema2._zod.bag;
   if (bag.minimum !== void 0)
     narrowMin(agg, "minimum", bag.minimum);
   if (bag.exclusiveMinimum !== void 0)
@@ -17853,10 +17853,10 @@ var exactPatterns = /* @__PURE__ */ new Map([
   [base64urlCharset, base64url]
 ]);
 var exactPattern = (p) => exactPatterns.get(p) ?? p;
-var stringProcessor = (schema, ctx, _json, _params) => {
+var stringProcessor = (schema2, ctx, _json, _params) => {
   const json2 = _json;
   json2.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
+  const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema2);
   if (typeof minimum === "number")
     json2.minLength = minimum;
   if (typeof maximum === "number")
@@ -17885,9 +17885,9 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
-var numberProcessor = (schema, ctx, _json, params) => {
+var numberProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
+  const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema2);
   json2.type = isInt ? "integer" : "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
@@ -17918,7 +17918,7 @@ var numberProcessor = (schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema2, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
@@ -17930,11 +17930,11 @@ var numberProcessor = (schema, ctx, _json, params) => {
 var booleanProcessor = (_schema, _ctx, json2, _params) => {
   json2.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
 };
-var symbolProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
+var symbolProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
 };
 var nullProcessor = (_schema, ctx, json2, _params) => {
   if (ctx.target === "openapi-3.0") {
@@ -17945,11 +17945,11 @@ var nullProcessor = (_schema, ctx, json2, _params) => {
     json2.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
 };
-var voidProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Void cannot be represented in JSON Schema");
+var voidProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Void cannot be represented in JSON Schema");
 };
 var neverProcessor = (_schema, _ctx, json2, _params) => {
   json2.not = {};
@@ -17958,11 +17958,11 @@ var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
 var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
-var dateProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Date cannot be represented in JSON Schema");
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
-  const def = schema._zod.def;
+var enumProcessor = (schema2, _ctx, json2, _params) => {
+  const def = schema2._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
     json2.not = {};
@@ -17974,8 +17974,8 @@ var enumProcessor = (schema, _ctx, json2, _params) => {
     json2.type = "string";
   json2.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var literalProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   if (def.values.length === 0) {
     json2.not = {};
     return;
@@ -17983,10 +17983,10 @@ var literalProcessor = (schema, ctx, json2, params) => {
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema2, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema2, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -18014,23 +18014,23 @@ var literalProcessor = (schema, ctx, json2, params) => {
     json2.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "NaN cannot be represented in JSON Schema");
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
+var templateLiteralProcessor = (schema2, _ctx, json2, _params) => {
   const _json = json2;
-  const pattern = schema._zod.pattern;
+  const pattern = schema2._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json2, _params) => {
+var fileProcessor = (schema2, _ctx, json2, _params) => {
   const _json = json2;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
-  const { minimum, maximum, mime } = aggregateChecks(schema);
+  const { minimum, maximum, mime } = aggregateChecks(schema2);
   if (minimum !== void 0)
     _json.minLength = minimum;
   if (maximum !== void 0)
@@ -18047,25 +18047,25 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
 var successProcessor = (_schema, _ctx, json2, _params) => {
   json2.type = "boolean";
 };
-var customProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Function types cannot be represented in JSON Schema");
+var functionProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Function types cannot be represented in JSON Schema");
 };
-var transformProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
+var transformProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
 };
-var mapProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Map cannot be represented in JSON Schema");
+var mapProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Map cannot be represented in JSON Schema");
 };
-var setProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Set cannot be represented in JSON Schema");
+var setProcessor = (schema2, ctx, json2, params) => {
+  handleUnrepresentable(schema2, ctx, json2, params, "Set cannot be represented in JSON Schema");
 };
-var arrayProcessor = (schema, ctx, _json, params) => {
+var arrayProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
-  const { minimum, maximum } = aggregateChecks(schema);
+  const def = schema2._zod.def;
+  const { minimum, maximum } = aggregateChecks(schema2);
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
@@ -18076,22 +18076,22 @@ var arrayProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, "items"]
   });
 };
-function inputOptin(schema) {
-  const def = schema._zod.def;
+function inputOptin(schema2) {
+  const def = schema2._zod.def;
   if (def.type === "pipe" && def.in._zod.traits.has("$ZodTransform")) {
     return inputOptin(def.out);
   }
   if (def.type === "catch") {
     return inputOptin(def.innerType);
   }
-  return schema._zod.optin;
+  return schema2._zod.optin;
 }
-var objectProcessor = (schema, ctx, _json, params) => {
+var objectProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema2, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
   json2.type = "object";
@@ -18124,8 +18124,8 @@ var objectProcessor = (schema, ctx, _json, params) => {
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var unionProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => processSchema(x, ctx, {
     ...params,
@@ -18137,8 +18137,8 @@ var unionProcessor = (schema, ctx, json2, params) => {
     json2.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var intersectionProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
@@ -18155,9 +18155,9 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
   json2.allOf = allOf;
   ctx.intersections.push(allOf);
 };
-var tupleProcessor = (schema, ctx, _json, params) => {
+var tupleProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
@@ -18213,7 +18213,7 @@ var tupleProcessor = (schema, ctx, _json, params) => {
     if (isClosed)
       json2.maxItems = maxItems;
   }
-  const { minimum, maximum } = aggregateChecks(schema);
+  const { minimum, maximum } = aggregateChecks(schema2);
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
@@ -18282,9 +18282,9 @@ function rewriteKeyNames(ctx) {
     }
   }
 }
-var recordProcessor = (schema, ctx, _json, params) => {
+var recordProcessor = (schema2, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema._zod.def;
+  const def = schema2._zod.def;
   json2.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
@@ -18309,7 +18309,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
         pendingRecords.set(ctx, pending);
         ctx.deferred.push(() => rewriteKeyNames(ctx));
       }
-      pending.push(schema);
+      pending.push(schema2);
     }
     json2.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
@@ -18325,10 +18325,10 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var nullableProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
     json2.nullable = true;
@@ -18336,14 +18336,14 @@ var nullableProcessor = (schema, ctx, json2, params) => {
     json2.anyOf = [inner, { type: "null" }];
   }
 };
-var nonoptionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var nonoptionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
-function serializeDefaultValue(value, schema, ctx, json2, params) {
+function serializeDefaultValue(value, schema2, ctx, json2, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
@@ -18353,74 +18353,74 @@ function serializeDefaultValue(value, schema, ctx, json2, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema2, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
-var defaultProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var defaultProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema2, ctx, json2, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
     json2.default = value;
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var prefaultProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   if (ctx.io !== "input")
     return;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema2, ctx, json2, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
     json2._prefault = value;
 };
-var catchProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var catchProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   let catchValue;
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema2, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
   json2.default = catchValue;
 };
-var pipeProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var pipeProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
   processSchema(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
-  const def = schema._zod.def;
+var readonlyProcessor = (schema2, ctx, json2, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
-var promiseProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var promiseProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var optionalProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
+var optionalProcessor = (schema2, ctx, _json, params) => {
+  const def = schema2._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = def.innerType;
 };
-var lazyProcessor = (schema, ctx, _json, params) => {
-  const innerType = schema._zod.innerType;
+var lazyProcessor = (schema2, ctx, _json, params) => {
+  const innerType = schema2._zod.innerType;
   processSchema(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema2);
   seen.ref = innerType;
 };
 var allProcessors = {
@@ -18470,8 +18470,8 @@ function toJSONSchema(input2, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry3._idmap.entries()) {
-      const [_, schema] = entry;
-      processSchema(schema, ctx2);
+      const [_, schema2] = entry;
+      processSchema(schema2, ctx2);
     }
     const schemas = {};
     const external = {
@@ -18481,9 +18481,9 @@ function toJSONSchema(input2, params) {
     };
     ctx2.external = external;
     for (const entry of registry3._idmap.entries()) {
-      const [key, schema] = entry;
-      extractDefs(ctx2, schema);
-      assignProp(schemas, key, finalize(ctx2, schema));
+      const [key, schema2] = entry;
+      extractDefs(ctx2, schema2);
+      assignProp(schemas, key, finalize(ctx2, schema2));
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -18552,14 +18552,14 @@ var JSONSchemaGenerator = class {
    * Process a schema to prepare it for JSON Schema generation.
    * This must be called before emit().
    */
-  process(schema, _params = { path: [], schemaPath: [] }) {
-    return processSchema(schema, this.ctx, _params);
+  process(schema2, _params = { path: [], schemaPath: [] }) {
+    return processSchema(schema2, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
    * Must call process() first.
    */
-  emit(schema, _params) {
+  emit(schema2, _params) {
     if (_params) {
       if (_params.cycles)
         this.ctx.cycles = _params.cycles;
@@ -18570,8 +18570,8 @@ var JSONSchemaGenerator = class {
     }
     this.ctx.sharedDefsExtractedFor = void 0;
     this.ctx.sharedEmitDoneFor = void 0;
-    extractDefs(this.ctx, schema);
-    const result = finalize(this.ctx, schema);
+    extractDefs(this.ctx, schema2);
+    const result = finalize(this.ctx, schema2);
     const { "~standard": _, ...plainResult } = result;
     return plainResult;
   }
@@ -19664,8 +19664,8 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 function array(element, params) {
   return _array(ZodArray, element, params);
 }
-function keyof(schema) {
-  const shape = schema._zod.def.shape;
+function keyof(schema2) {
+  const shape = schema2._zod.def.shape;
   return _enum2(Object.keys(shape));
 }
 var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
@@ -20313,11 +20313,11 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema) {
+function preprocess(fn, schema2) {
   return new ZodPreprocess({
     type: "pipe",
     in: transform(fn),
-    out: schema
+    out: schema2
   });
 }
 
@@ -20449,8 +20449,8 @@ var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
   "nullable",
   "readOnly"
 ]);
-function detectVersion(schema, defaultTarget) {
-  const $schema = schema.$schema;
+function detectVersion(schema2, defaultTarget) {
+  const $schema = schema2.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -20678,27 +20678,27 @@ function getTupleRest(restSchema, ctx) {
   return convertSchema(restSchema, ctx);
 }
 var fullTime = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
-function convertBaseSchema(schema, ctx) {
-  if (schema.not !== void 0) {
-    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+function convertBaseSchema(schema2, ctx) {
+  if (schema2.not !== void 0) {
+    if (typeof schema2.not === "object" && Object.keys(schema2.not).length === 0) {
       return z.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema.unevaluatedItems !== void 0) {
+  if (schema2.unevaluatedItems !== void 0) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema.unevaluatedProperties !== void 0) {
+  if (schema2.unevaluatedProperties !== void 0) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
+  if (schema2.if !== void 0 || schema2.then !== void 0 || schema2.else !== void 0) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
+  if (schema2.dependentSchemas !== void 0 || schema2.dependentRequired !== void 0) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema.$ref) {
-    const refPath = schema.$ref;
+  if (schema2.$ref) {
+    const refPath = schema2.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -20717,9 +20717,9 @@ function convertBaseSchema(schema, ctx) {
     ctx.processing.delete(refPath);
     return zodSchema2;
   }
-  if (schema.enum !== void 0) {
-    const enumValues = schema.enum;
-    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+  if (schema2.enum !== void 0) {
+    const enumValues = schema2.enum;
+    if (ctx.version === "openapi-3.0" && schema2.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -20737,13 +20737,13 @@ function convertBaseSchema(schema, ctx) {
     }
     return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema.const !== void 0) {
-    return z.literal(schema.const);
+  if (schema2.const !== void 0) {
+    return z.literal(schema2.const);
   }
-  const type = schema.type;
+  const type = schema2.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema, type: t };
+      const typeSchema = { ...schema2, type: t };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -20761,8 +20761,8 @@ function convertBaseSchema(schema, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z.string();
-      if (schema.format) {
-        const format = schema.format;
+      if (schema2.format) {
+        const format = schema2.format;
         if (format === "email") {
           stringSchema = stringSchema.check(z.email());
         } else if (format === "uri" || format === "uri-reference") {
@@ -20817,14 +20817,14 @@ function convertBaseSchema(schema, ctx) {
           stringSchema = stringSchema.check(z.ksuid());
         }
       }
-      if (typeof schema.minLength === "number") {
-        stringSchema = stringSchema.min(schema.minLength);
+      if (typeof schema2.minLength === "number") {
+        stringSchema = stringSchema.min(schema2.minLength);
       }
-      if (typeof schema.maxLength === "number") {
-        stringSchema = stringSchema.max(schema.maxLength);
+      if (typeof schema2.maxLength === "number") {
+        stringSchema = stringSchema.max(schema2.maxLength);
       }
-      if (schema.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      if (schema2.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema2.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -20832,24 +20832,24 @@ function convertBaseSchema(schema, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema.minimum === "number" && schema.exclusiveMinimum !== true) {
-        numberSchema = numberSchema.min(schema.minimum);
+      if (typeof schema2.minimum === "number" && schema2.exclusiveMinimum !== true) {
+        numberSchema = numberSchema.min(schema2.minimum);
       }
-      if (typeof schema.maximum === "number" && schema.exclusiveMaximum !== true) {
-        numberSchema = numberSchema.max(schema.maximum);
+      if (typeof schema2.maximum === "number" && schema2.exclusiveMaximum !== true) {
+        numberSchema = numberSchema.max(schema2.maximum);
       }
-      if (typeof schema.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-        numberSchema = numberSchema.gt(schema.minimum);
+      if (typeof schema2.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema2.exclusiveMinimum);
+      } else if (schema2.exclusiveMinimum === true && typeof schema2.minimum === "number") {
+        numberSchema = numberSchema.gt(schema2.minimum);
       }
-      if (typeof schema.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-        numberSchema = numberSchema.lt(schema.maximum);
+      if (typeof schema2.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema2.exclusiveMaximum);
+      } else if (schema2.exclusiveMaximum === true && typeof schema2.maximum === "number") {
+        numberSchema = numberSchema.lt(schema2.maximum);
       }
-      if (typeof schema.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema.multipleOf);
+      if (typeof schema2.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema2.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -20864,15 +20864,15 @@ function convertBaseSchema(schema, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema.properties || {};
-      const requiredSet = new Set(schema.required || []);
-      const additionalSchema = typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : void 0;
+      const properties = schema2.properties || {};
+      const requiredSet = new Set(schema2.required || []);
+      const additionalSchema = typeof schema2.additionalProperties === "object" ? convertSchema(schema2.additionalProperties, ctx) : void 0;
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
         assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
       }
-      if (schema.patternProperties) {
-        const patternProps = schema.patternProperties;
+      if (schema2.patternProperties) {
+        const patternProps = schema2.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -20896,7 +20896,7 @@ function convertBaseSchema(schema, ctx) {
           }
           zodSchema = result;
         }
-        if (schema.additionalProperties === false) {
+        if (schema2.additionalProperties === false) {
           const propertyKeys = Object.keys(shape);
           const patterns = patternKeys.map((p) => new RegExp(p));
           const basePatternSchema = zodSchema;
@@ -20923,7 +20923,7 @@ function convertBaseSchema(schema, ctx) {
         }
       } else {
         const objectSchema = z.object(shape);
-        if (schema.additionalProperties === false) {
+        if (schema2.additionalProperties === false) {
           zodSchema = objectSchema.strict();
         } else if (additionalSchema) {
           zodSchema = objectSchema.catchall(additionalSchema);
@@ -20931,13 +20931,13 @@ function convertBaseSchema(schema, ctx) {
           zodSchema = objectSchema.passthrough();
         }
       }
-      const hasKeyGuard = schema.propertyNames !== void 0 && schema.propertyNames !== true;
-      const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : void 0;
-      const maxProperties = typeof schema.maxProperties === "number" ? schema.maxProperties : void 0;
+      const hasKeyGuard = schema2.propertyNames !== void 0 && schema2.propertyNames !== true;
+      const minProperties = typeof schema2.minProperties === "number" ? schema2.minProperties : void 0;
+      const maxProperties = typeof schema2.maxProperties === "number" ? schema2.maxProperties : void 0;
       if (hasKeyGuard || minProperties !== void 0 || maxProperties !== void 0) {
         let keySchema;
         if (hasKeyGuard) {
-          const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === void 0 ? { type: "string", ...schema.propertyNames } : schema.propertyNames;
+          const keyJSONSchema = typeof schema2.propertyNames === "object" && schema2.propertyNames.type === void 0 ? { type: "string", ...schema2.propertyNames } : schema2.propertyNames;
           keySchema = convertSchema(keyJSONSchema, ctx);
         }
         zodSchema = checkObjectGuards(zodSchema, { keySchema, minProperties, maxProperties });
@@ -20945,53 +20945,53 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
+      const prefixItems = schema2.prefixItems;
+      const items = schema2.items;
       if (prefixItems && Array.isArray(prefixItems)) {
-        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
+        const minItems = typeof schema2.minItems === "number" ? schema2.minItems : 0;
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const positionalItems = applyMinItems(tupleItems, minItems);
         const rest = !Array.isArray(items) ? getTupleRest(items, ctx) : void 0;
         const tupleSchema = z.tuple(positionalItems);
         zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema2.maxItems));
         }
       } else if (Array.isArray(items)) {
-        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
+        const minItems = typeof schema2.minItems === "number" ? schema2.minItems : 0;
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const positionalItems = applyMinItems(tupleItems, minItems);
-        const rest = getTupleRest(schema.additionalItems, ctx);
+        const rest = getTupleRest(schema2.additionalItems, ctx);
         const tupleSchema = z.tuple(positionalItems);
         zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        if (typeof schema2.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema2.minItems));
         }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        if (typeof schema2.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema2.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
         let arraySchema = z.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
+        if (typeof schema2.minItems === "number") {
+          arraySchema = arraySchema.min(schema2.minItems);
         }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
+        if (typeof schema2.maxItems === "number") {
+          arraySchema = arraySchema.max(schema2.maxItems);
         }
         zodSchema = arraySchema;
       } else {
         zodSchema = z.array(z.any());
       }
-      if (schema.uniqueItems === true || schema.contains !== void 0) {
+      if (schema2.uniqueItems === true || schema2.contains !== void 0) {
         zodSchema = checkArrayGuards(zodSchema, {
-          uniqueItems: schema.uniqueItems === true,
-          containsSchema: schema.contains !== void 0 ? convertSchema(schema.contains, ctx) : void 0,
-          minContains: typeof schema.minContains === "number" ? schema.minContains : void 0,
-          maxContains: typeof schema.maxContains === "number" ? schema.maxContains : void 0
+          uniqueItems: schema2.uniqueItems === true,
+          containsSchema: schema2.contains !== void 0 ? convertSchema(schema2.contains, ctx) : void 0,
+          minContains: typeof schema2.minContains === "number" ? schema2.minContains : void 0,
+          maxContains: typeof schema2.maxContains === "number" ? schema2.maxContains : void 0
         });
       }
       break;
@@ -21001,94 +21001,94 @@ function convertBaseSchema(schema, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+function convertSchema(schema2, ctx) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+  let baseSchema = convertBaseSchema(schema2, ctx);
+  const hasExplicitType = schema2.type || schema2.enum !== void 0 || schema2.const !== void 0;
+  if (schema2.anyOf && Array.isArray(schema2.anyOf)) {
+    const options = schema2.anyOf.map((s) => convertSchema(s, ctx));
     const anyOfUnion = z.union(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+  if (schema2.oneOf && Array.isArray(schema2.oneOf)) {
+    const options = schema2.oneOf.map((s) => convertSchema(s, ctx));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
+  if (schema2.allOf && Array.isArray(schema2.allOf)) {
+    if (schema2.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      let result = hasExplicitType ? baseSchema : convertSchema(schema2.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      for (let i = startIdx; i < schema2.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema2.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema2.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
-  if (schema.readOnly === true) {
+  if (schema2.readOnly === true) {
     baseSchema = z.readonly(baseSchema);
   }
-  if (schema.default !== void 0) {
-    baseSchema = baseSchema.default(schema.default);
+  if (schema2.default !== void 0) {
+    baseSchema = baseSchema.default(schema2.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+    if (key in schema2) {
+      extraMeta[key] = schema2[key];
     }
   }
-  if (schema.type === "object" && schema.$ref === void 0) {
-    if (schema.propertyNames !== void 0 && !containsRef(schema.propertyNames)) {
-      extraMeta.propertyNames = schema.propertyNames;
+  if (schema2.type === "object" && schema2.$ref === void 0) {
+    if (schema2.propertyNames !== void 0 && !containsRef(schema2.propertyNames)) {
+      extraMeta.propertyNames = schema2.propertyNames;
     }
     for (const key of ["minProperties", "maxProperties"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
+      if (schema2[key] !== void 0)
+        extraMeta[key] = schema2[key];
     }
   }
-  if (schema.type === "array" && schema.$ref === void 0) {
-    if (schema.contains !== void 0 && !containsRef(schema.contains)) {
-      extraMeta.contains = schema.contains;
+  if (schema2.type === "array" && schema2.$ref === void 0) {
+    if (schema2.contains !== void 0 && !containsRef(schema2.contains)) {
+      extraMeta.contains = schema2.contains;
     }
     for (const key of ["uniqueItems", "minContains", "maxContains"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
+      if (schema2[key] !== void 0)
+        extraMeta[key] = schema2[key];
     }
   }
-  for (const key of Object.keys(schema)) {
+  for (const key of Object.keys(schema2)) {
     if (!RECOGNIZED_KEYS.has(key)) {
-      assignProp(extraMeta, key, schema[key]);
+      assignProp(extraMeta, key, schema2[key]);
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema.description) {
-    baseSchema = baseSchema.describe(schema.description);
+  if (schema2.description) {
+    baseSchema = baseSchema.describe(schema2.description);
   }
   return baseSchema;
 }
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+function fromJSONSchema(schema2, params) {
+  if (typeof schema2 === "boolean") {
+    return schema2 ? z.any() : z.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema));
+    normalized = JSON.parse(JSON.stringify(schema2));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -21107,13 +21107,13 @@ function fromJSONSchema(schema, params) {
 
 // node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/visit.js
 var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
-function visit(schema, fnOrHandlers) {
+function visit(schema2, fnOrHandlers) {
   const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
     const h = fnOrHandlers[node2._zod.def.type];
     return h ? h(node2, rewritten) : node2;
   };
   const cache = /* @__PURE__ */ new Map();
-  function run2(s) {
+  function run(s) {
     const cached2 = cache.get(s);
     if (cached2 === RESOLVING) {
       return new $ZodLazy({
@@ -21139,21 +21139,21 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newShape = {};
         for (const k of keys) {
-          const mapped = run2(oldShape[k]);
+          const mapped = run(oldShape[k]);
           if (mapped !== oldShape[k])
             changed = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
-          newCatchall = run2(def.catchall);
+          newCatchall = run(def.catchall);
           if (newCatchall !== def.catchall)
             changed = true;
         }
         return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
       }
       case "array": {
-        const mapped = run2(def.element);
+        const mapped = run(def.element);
         return mapped === def.element ? s : clone(s, { ...def, element: mapped });
       }
       case "tuple": {
@@ -21161,14 +21161,14 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newItems = [];
         for (const item of oldItems) {
-          const mapped = run2(item);
+          const mapped = run(item);
           if (mapped !== item)
             changed = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
-          newRest = run2(def.rest);
+          newRest = run(def.rest);
           if (newRest !== def.rest)
             changed = true;
         }
@@ -21176,12 +21176,12 @@ function visit(schema, fnOrHandlers) {
       }
       case "record":
       case "map": {
-        const newKey = run2(def.keyType);
-        const newVal = run2(def.valueType);
+        const newKey = run(def.keyType);
+        const newVal = run(def.valueType);
         return newKey === def.keyType && newVal === def.valueType ? s : clone(s, { ...def, keyType: newKey, valueType: newVal });
       }
       case "set": {
-        const newVal = run2(def.valueType);
+        const newVal = run(def.valueType);
         return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
       }
       case "union": {
@@ -21189,7 +21189,7 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newOptions = [];
         for (const opt of oldOptions) {
-          const mapped = run2(opt);
+          const mapped = run(opt);
           if (mapped !== opt)
             changed = true;
           newOptions.push(mapped);
@@ -21197,8 +21197,8 @@ function visit(schema, fnOrHandlers) {
         return changed ? clone(s, { ...def, options: newOptions }) : s;
       }
       case "intersection": {
-        const newLeft = run2(def.left);
-        const newRight = run2(def.right);
+        const newLeft = run(def.left);
+        const newRight = run(def.right);
         return newLeft === def.left && newRight === def.right ? s : clone(s, { ...def, left: newLeft, right: newRight });
       }
       case "optional":
@@ -21210,23 +21210,23 @@ function visit(schema, fnOrHandlers) {
       case "nonoptional":
       case "promise":
       case "success": {
-        const newInner = run2(def.innerType);
+        const newInner = run(def.innerType);
         return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
       }
       case "pipe": {
-        const newIn = run2(def.in);
-        const newOut = run2(def.out);
+        const newIn = run(def.in);
+        const newOut = run(def.out);
         return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
       }
       case "function": {
-        const newInput = run2(def.input);
-        const newOutput = run2(def.output);
+        const newInput = run(def.input);
+        const newOutput = run(def.output);
         return newInput === def.input && newOutput === def.output ? s : clone(s, { ...def, input: newInput, output: newOutput });
       }
       case "lazy": {
         const original = def.getter;
         const { _cachedInner, ...rest } = def;
-        return clone(s, { ...rest, getter: () => run2(original()) });
+        return clone(s, { ...rest, getter: () => run(original()) });
       }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
@@ -21257,12 +21257,12 @@ function visit(schema, fnOrHandlers) {
       }
     }
   }
-  return run2(schema);
+  return run(schema2);
 }
 
 // node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/deep-partial.js
-function deepPartial(schema) {
-  return visit(schema, {
+function deepPartial(schema2) {
+  return visit(schema2, {
     object: (s) => s.partial(),
     // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
     union: (s) => {
@@ -21285,8 +21285,8 @@ function outSide(def) {
 function inSide(def) {
   return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
 }
-function input(schema) {
-  return visit(schema, {
+function input(schema2) {
+  return visit(schema2, {
     pipe: (s) => inSide(s._zod.def),
     // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
     default: (s, rewritten) => rewritten ? optional(s._zod.def.innerType) : s,
@@ -21294,8 +21294,8 @@ function input(schema) {
     catch: (s, rewritten) => rewritten ? s._zod.def.innerType : s
   });
 }
-function output(schema) {
-  return visit(schema, {
+function output(schema2) {
+  return visit(schema2, {
     pipe: (s) => outSide(s._zod.def),
     // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
     prefault: (s, rewritten) => rewritten ? s._zod.def.innerType : s
@@ -21913,6 +21913,30 @@ function validVersion(version3) {
     match && (!match[4] || match[4].split(".").every((part) => !/^\d+$/.test(part) || part === "0" || !part.startsWith("0")))
   );
 }
+function compareVersions(left, right) {
+  if (!validVersion(left) || !validVersion(right)) throw new Error("Invalid release version");
+  const a = versionPattern.exec(left);
+  const b = versionPattern.exec(right);
+  for (let i = 1; i <= 3; i++) {
+    const difference = BigInt(a[i]) - BigInt(b[i]);
+    if (difference) return difference > 0 ? 1 : -1;
+  }
+  if (!a[4] || !b[4]) return a[4] === b[4] ? 0 : a[4] ? -1 : 1;
+  const ap = a[4].split(".");
+  const bp = b[4].split(".");
+  for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
+    const x = ap[i];
+    const y = bp[i];
+    if (x === y) continue;
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    const xn = /^\d+$/.test(x);
+    const yn = /^\d+$/.test(y);
+    if (xn && yn) return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (xn !== yn) return xn ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
 
 // src/shared/codex-compatibility.ts
 var version2 = external_exports.string().max(128).refine(validVersion);
@@ -21965,13 +21989,13 @@ function requireCodexCompatibility(metadata, running, confirmed = false) {
 }
 
 // src/updates/worker.ts
-var import_node_child_process4 = require("node:child_process");
-var import_node_util4 = require("node:util");
+var import_node_child_process5 = require("node:child_process");
+var import_node_util5 = require("node:util");
 var import_node_module = require("node:module");
-var import_promises12 = require("node:fs/promises");
-var import_node_fs4 = require("node:fs");
-var import_node_path11 = require("node:path");
-var import_promises13 = require("node:timers/promises");
+var import_promises14 = require("node:fs/promises");
+var import_node_fs5 = require("node:fs");
+var import_node_path13 = require("node:path");
+var import_promises15 = require("node:timers/promises");
 var import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
 
 // src/cli/control.ts
@@ -21979,7 +22003,7 @@ var import_node_http = require("node:http");
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
 var import_promises5 = require("node:timers/promises");
 function control(location, action, input2 = {}) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const requestBody = JSON.stringify(input2);
     const outgoing = (0, import_node_http.request)(
       {
@@ -22003,7 +22027,7 @@ function control(location, action, input2 = {}) {
             const result = JSON.parse(body);
             if (incoming.statusCode !== 200)
               reject(new Error(result.error ?? "Control request failed"));
-            else resolve3(result);
+            else resolve4(result);
           } catch (error62) {
             reject(error62);
           }
@@ -22037,11 +22061,11 @@ async function stopAndWait(location) {
 }
 
 // src/cli/background.ts
-var import_node_child_process2 = require("node:child_process");
-var import_promises8 = require("node:fs/promises");
-var import_node_path8 = require("node:path");
-var import_node_util2 = require("node:util");
-var import_promises9 = require("node:timers/promises");
+var import_node_child_process3 = require("node:child_process");
+var import_promises9 = require("node:fs/promises");
+var import_node_path9 = require("node:path");
+var import_node_util3 = require("node:util");
+var import_promises10 = require("node:timers/promises");
 var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
 
 // src/cli/launchd.ts
@@ -22057,14 +22081,17 @@ var import_node_net = require("node:net");
 var import_promises6 = require("node:fs/promises");
 var import_node_crypto4 = require("node:crypto");
 var import_node_path6 = require("node:path");
-async function environmentBridge(home) {
+async function environmentBridge(home, runtimePath = process.env.PATH) {
   const path = (0, import_node_path6.join)(home, `e-${(0, import_node_crypto4.randomBytes)(6).toString("hex")}.sock`);
   const clients = /* @__PURE__ */ new Set();
   let accept;
-  const consumed = new Promise((resolve3) => {
-    accept = resolve3;
+  const consumed = new Promise((resolve4) => {
+    accept = resolve4;
+  });
+  const payload = JSON.stringify({
+    env: { ...process.env, PATH: runtimePath, COVRO_HOME: home },
+    cwd: process.cwd()
   });
-  const payload = JSON.stringify({ env: { ...process.env, COVRO_HOME: home }, cwd: process.cwd() });
   const server = (0, import_node_net.createServer)((socket) => {
     clients.add(socket);
     socket.setTimeout(5e3, () => socket.destroy());
@@ -22074,9 +22101,9 @@ async function environmentBridge(home) {
     socket.end(payload, () => accept?.());
   });
   try {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       server.once("error", reject);
-      server.listen(path, resolve3);
+      server.listen(path, resolve4);
     });
     await (0, import_promises6.chmod)(path, 384);
     return {
@@ -22100,7 +22127,7 @@ async function environmentBridge(home) {
       async close() {
         for (const socket of clients) socket.destroy();
         await new Promise(
-          (resolve3, reject) => server.close((error62) => error62 ? reject(error62) : resolve3())
+          (resolve4, reject) => server.close((error62) => error62 ? reject(error62) : resolve4())
         );
         await (0, import_promises6.rm)(path, { force: true });
       }
@@ -22181,10 +22208,10 @@ async function loginRegistration(location) {
     throw new Error("\u767B\u5F55\u670D\u52A1\u8EAB\u4EFD\u4E0E\u5F53\u524D\u914D\u7F6E\u4E0D\u5339\u914D");
   return installed;
 }
-function launchdPlist(location, args, login) {
+function launchdPlist(location, args, login, path = process.env.PATH ?? "/usr/bin:/bin") {
   const { label } = launchdPaths(location, login ? `dev.covro.${location.key}` : void 0);
   const environment = {
-    PATH: process.env.PATH ?? "/usr/bin:/bin",
+    PATH: path,
     COVRO_HOME: location.home,
     ...process.env.CODEX_HOME ? { CODEX_HOME: process.env.CODEX_HOME } : {}
   };
@@ -22220,7 +22247,7 @@ async function unloadLaunchd(location) {
   }
   await (0, import_promises7.rm)(temporary, { force: true });
 }
-async function startLaunchd(location, entry) {
+async function startLaunchd(location, entry, runtime) {
   const installed = await loginRegistration(location);
   const { domain: domain2, target, temporary, login } = launchdPaths(location, installed?.label);
   if (!await guiSessionAvailable(location)) {
@@ -22233,7 +22260,7 @@ async function startLaunchd(location, entry) {
     await launchctl(["bootstrap", domain2, login]);
     return true;
   }
-  const bridge = await environmentBridge(location.home);
+  const bridge = await environmentBridge(location.home, runtime?.path);
   try {
     const runner = (0, import_node_path7.join)(location.state, "launch-runner.mjs");
     await (0, import_promises7.writeFile)(runner, launchRunner, { mode: 384 });
@@ -22241,8 +22268,9 @@ async function startLaunchd(location, entry) {
       temporary,
       launchdPlist(
         location,
-        [process.execPath, runner, bridge.path, entry, location.config],
-        false
+        [runtime?.node ?? process.execPath, runner, bridge.path, entry, location.config],
+        false,
+        runtime?.path
       ),
       { mode: 384 }
     );
@@ -22266,12 +22294,110 @@ async function startLaunchd(location, entry) {
   }
 }
 
-// src/cli/background.ts
+// src/cli/runtime-launch.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_util2 = require("node:util");
+var import_promises8 = require("node:fs/promises");
+var import_node_os2 = require("node:os");
+var import_node_path8 = require("node:path");
 var exec2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var schema = external_exports.object({ node: external_exports.string().startsWith("/"), entry: external_exports.string().startsWith("/"), path: external_exports.string() }).strict();
+var runtimeFile = (location) => (0, import_node_path8.join)(location.state, "runtime.json");
+async function launchRuntime(location, entry, override) {
+  const saved = override ?? await readJson(runtimeFile(location));
+  return saved ? schema.parse(saved) : { node: process.execPath, entry, path: process.env.PATH ?? "/usr/bin:/bin" };
+}
+var systemdQuote = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", () => "$$")}"`;
+var xml2 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+function serviceContent(location, runtime, service) {
+  const { content, platform } = service;
+  const args = [runtime.node, runtime.entry, "run", "--config", location.config];
+  return platform === "darwin" ? content.replace(
+    /<key>ProgramArguments<\/key><array>.*?<\/array>/s,
+    () => `<key>ProgramArguments</key><array>${args.map((arg) => `<string>${xml2(arg)}</string>`).join("")}</array>`
+  ).replace(
+    /<key>PATH<\/key><string>[^<]*<\/string>/,
+    () => `<key>PATH</key><string>${xml2(runtime.path)}</string>`
+  ) : content.replace(/^ExecStart=.*$/m, () => `ExecStart=${args.map(systemdQuote).join(" ")}`).replace(/"PATH=(?:\\.|[^"\\])*"/, () => systemdQuote(`PATH=${runtime.path}`));
+}
+async function snapshotLaunch(location, current) {
+  const runtime = await readJson(runtimeFile(location));
+  const installed = await readJson(
+    (0, import_node_path8.join)(location.state, "service.json")
+  );
+  if (!installed) {
+    if (process.env.INVOCATION_ID || process.env.PM2_HOME || process.env.SUPERVISOR_ENABLED)
+      throw new Error("\u68C0\u6D4B\u5230\u5916\u90E8\u8FDB\u7A0B\u7BA1\u7406\u5668\uFF1B\u8BF7\u4F7F\u7528\u539F\u7BA1\u7406\u5668\u4FEE\u6539 Node \u548C Covro \u542F\u52A8\u8DEF\u5F84\u540E\u91CD\u542F\u3002");
+    return { runtime };
+  }
+  if (installed.platform !== process.platform || installed.label !== `dev.covro.${location.key}`)
+    throw new Error("\u767B\u5F55\u670D\u52A1\u8EAB\u4EFD\u4E0D\u5339\u914D\uFF1B\u8BF7\u7528\u76EE\u6807 Node \u91CD\u65B0\u5B89\u88C5 Covro \u767B\u5F55\u670D\u52A1\u3002");
+  const filename = installed.platform === "darwin" ? launchdPaths(location, installed.label).login : (0, import_node_path8.join)((0, import_node_os2.homedir)(), ".config/systemd/user", `${installed.label}.service`);
+  const content = await (0, import_promises8.readFile)(filename, "utf8");
+  const expected = installed.platform === "darwin" ? `<key>ProgramArguments</key><array>${[current.node, current.entry, "run", "--config", location.config].map((arg) => `<string>${xml2(arg)}</string>`).join("")}</array>` : `ExecStart=${[current.node, current.entry, "run", "--config", location.config].map(systemdQuote).join(" ")}`;
+  if (!content.includes(expected))
+    throw new Error(
+      `\u670D\u52A1\u542F\u52A8\u6765\u6E90\u4E0E\u8FD0\u884C\u5B9E\u4F8B\u4E0D\u5339\u914D\uFF1A${filename}\uFF1B\u8BF7\u6838\u5BF9\u81EA\u5B9A\u4E49\u670D\u52A1\u914D\u7F6E\uFF0C\u5F53\u524D\u670D\u52A1\u4FDD\u6301\u8FD0\u884C\u3002`
+    );
+  if (installed.platform === "linux") {
+    const { stdout } = await exec2(
+      "systemctl",
+      ["--user", "show", `${installed.label}.service`, "--property=FragmentPath,DropInPaths"],
+      { timeout: 5e3 }
+    );
+    const properties = Object.fromEntries(
+      stdout.trim().split("\n").map((line) => {
+        const i = line.indexOf("=");
+        return [line.slice(0, i), line.slice(i + 1)];
+      })
+    );
+    if (properties.FragmentPath !== filename || properties.DropInPaths !== "")
+      throw new Error(
+        "systemd \u5B9E\u9645\u52A0\u8F7D\u6765\u6E90\u4E0E Covro \u670D\u52A1\u6587\u4EF6\u4E0D\u5339\u914D\u6216\u5B58\u5728\u81EA\u5B9A\u4E49 drop-in\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002"
+      );
+  }
+  return { runtime, service: { filename, content, platform: installed.platform } };
+}
+async function switchLaunch(location, runtime, snapshot) {
+  schema.parse(runtime);
+  if (/[\r\n]/.test([runtime.node, runtime.entry, runtime.path].join("")))
+    throw new Error("\u8FD0\u884C\u73AF\u5883\u8DEF\u5F84\u4E0D\u80FD\u5305\u542B\u6362\u884C");
+  snapshot.target = runtime;
+  if (snapshot.service) {
+    const { filename, content, platform } = snapshot.service;
+    if (await (0, import_promises8.readFile)(filename, "utf8") !== content)
+      throw new Error("\u670D\u52A1\u6587\u4EF6\u5728\u5347\u7EA7\u671F\u95F4\u88AB\u4FEE\u6539\uFF0C\u62D2\u7EDD\u8986\u76D6\u3002");
+    const updated = serviceContent(location, runtime, snapshot.service);
+    await (0, import_promises8.writeFile)(filename, updated, { mode: 384 });
+    if (platform === "linux")
+      await exec2("systemctl", ["--user", "daemon-reload"], { timeout: 5e3 });
+  }
+  await saveJson(runtimeFile(location), runtime);
+}
+async function restoreLaunch(location, snapshot) {
+  if (snapshot.service) {
+    const current2 = await (0, import_promises8.readFile)(snapshot.service.filename, "utf8");
+    if (current2 !== snapshot.service.content && (!snapshot.target || current2 !== serviceContent(location, snapshot.target, snapshot.service)))
+      throw new Error("\u670D\u52A1\u6587\u4EF6\u5DF2\u88AB\u5916\u90E8\u4FEE\u6539\uFF0C\u62D2\u7EDD\u5728\u6062\u590D\u65F6\u8986\u76D6\uFF1B\u8BF7\u4FDD\u7559\u73B0\u573A\u5E76\u6838\u5BF9\u542F\u52A8\u6765\u6E90\u3002");
+    await (0, import_promises8.writeFile)(snapshot.service.filename, snapshot.service.content, { mode: 384 });
+    if (snapshot.service.platform === "linux")
+      await exec2("systemctl", ["--user", "daemon-reload"], { timeout: 5e3 });
+  }
+  const current = await readJson(runtimeFile(location));
+  if (current && snapshot.target && ![snapshot.runtime, snapshot.target].some(
+    (value) => value && value.node === current.node && value.entry === current.entry && value.path === current.path
+  ))
+    throw new Error("\u5B9E\u4F8B\u542F\u52A8\u6765\u6E90\u5DF2\u88AB\u5916\u90E8\u4FEE\u6539\uFF0C\u62D2\u7EDD\u8986\u76D6\u3002");
+  if (snapshot.runtime) await saveJson(runtimeFile(location), snapshot.runtime);
+  else await (0, import_promises8.rm)(runtimeFile(location), { force: true });
+}
+
+// src/cli/background.ts
+var exec3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
 async function lifecycle(location, action) {
-  await (0, import_promises8.mkdir)(location.state, { recursive: true, mode: 448 });
+  await (0, import_promises9.mkdir)(location.state, { recursive: true, mode: 448 });
   const release = await import_proper_lockfile6.default.lock(location.state, {
-    lockfilePath: (0, import_node_path8.join)(location.state, "lifecycle.lock"),
+    lockfilePath: (0, import_node_path9.join)(location.state, "lifecycle.lock"),
     stale: 1e4,
     update: 2e3,
     retries: { retries: 280, minTimeout: 250, maxTimeout: 250 }
@@ -22282,34 +22408,35 @@ async function lifecycle(location, action) {
     await release();
   }
 }
-async function start(location, entry) {
+async function start(location, entry, override) {
   try {
     return await control(location, "status");
   } catch (error62) {
     if (!isNotRunning(error62)) throw error62;
   }
   let child;
+  const runtime = await launchRuntime(location, entry, override);
   const installed = await readJson(
-    (0, import_node_path8.join)(location.state, "service.json")
+    (0, import_node_path9.join)(location.state, "service.json")
   );
-  if (process.platform === "darwin" && await startLaunchd(location, entry)) {
+  if (process.platform === "darwin" && await startLaunchd(location, runtime.entry, runtime)) {
   } else if (installed?.platform === "linux") {
-    await exec2("systemctl", ["--user", "start", `${installed.label}.service`]);
+    await exec3("systemctl", ["--user", "start", `${installed.label}.service`]);
   } else {
     if (process.platform === "darwin")
       console.warn(
         "\u5F53\u524D\u6CA1\u6709 macOS \u684C\u9762\u767B\u5F55\u4F1A\u8BDD\uFF0C\u4F7F\u7528 headless \u540E\u53F0\u542F\u52A8\uFF1B\u7CFB\u7EDF\u94A5\u5319\u4E32\u51ED\u8BC1\u53EF\u80FD\u4E0D\u53EF\u7528\u3002"
       );
-    const log = await (0, import_promises8.open)(location.log, "a", 384);
+    const log = await (0, import_promises9.open)(location.log, "a", 384);
     try {
-      child = (0, import_node_child_process2.spawn)(process.execPath, [entry, "run", "--config", location.config], {
+      child = (0, import_node_child_process3.spawn)(runtime.node, [runtime.entry, "run", "--config", location.config], {
         detached: true,
         stdio: ["ignore", log.fd, log.fd],
         windowsHide: true,
-        env: { ...process.env, COVRO_HOME: location.home }
+        env: { ...process.env, PATH: runtime.path, COVRO_HOME: location.home }
       });
-      await new Promise((resolve3, reject) => {
-        child.once("spawn", resolve3);
+      await new Promise((resolve4, reject) => {
+        child.once("spawn", resolve4);
         child.once("error", reject);
       });
       child.unref();
@@ -22324,7 +22451,7 @@ async function start(location, entry) {
       if (!isNotRunning(error62)) throw error62;
     }
     if (child && child.exitCode !== null) throw new Error(`Covro \u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u67E5\u770B ${location.log}`);
-    await (0, import_promises9.setTimeout)(250);
+    await (0, import_promises10.setTimeout)(250);
   }
   throw new Error(`Covro \u5C1A\u672A\u786E\u8BA4\u542F\u52A8\uFF0C\u8BF7\u8FD0\u884C covro status \u5E76\u67E5\u770B ${location.log}`);
 }
@@ -22333,19 +22460,19 @@ async function stop(location) {
   if (process.platform === "darwin") await unloadLaunchd(location);
   else {
     const installed = await readJson(
-      (0, import_node_path8.join)(location.state, "service.json")
+      (0, import_node_path9.join)(location.state, "service.json")
     );
     if (installed?.platform === "linux")
-      await exec2("systemctl", ["--user", "stop", `${installed.label}.service`]);
+      await exec3("systemctl", ["--user", "stop", `${installed.label}.service`]);
   }
 }
-var startBackground = (location, entry) => lifecycle(location, () => start(location, entry));
+var startBackground = (location, entry, runtime) => lifecycle(location, () => start(location, entry, runtime));
 var stopBackground = (location) => lifecycle(location, () => stop(location));
 
 // src/updates/transaction.ts
-var import_promises10 = require("node:fs/promises");
-var import_node_path9 = require("node:path");
-async function activateUpdate(paths, effects) {
+var import_promises11 = require("node:fs/promises");
+var import_node_path10 = require("node:path");
+async function activateUpdate(paths, effects, reuseTarget = false) {
   let stopped = false;
   let moved = false;
   let backedUp = false;
@@ -22358,9 +22485,12 @@ async function activateUpdate(paths, effects) {
     await effects.stop();
     await effects.backup();
     backedUp = true;
-    await (0, import_promises10.rename)(paths.root, paths.previous);
-    moved = true;
-    await (0, import_promises10.rename)(paths.candidate, paths.root);
+    if (!reuseTarget) {
+      await (0, import_promises11.rename)(paths.root, paths.previous);
+      moved = true;
+      await (0, import_promises11.rename)(paths.candidate, paths.root);
+    }
+    await effects.switchLaunch?.();
     await effects.phase("verifying", "\u6B63\u5728\u542F\u52A8\u65B0\u7248\u3001\u8FC1\u79FB\u6570\u636E\u5E93\u5E76\u9A8C\u8BC1\uFF1B\u4E1A\u52A1\u5199\u5165\u4FDD\u6301\u6682\u505C");
     await effects.start(true);
     await effects.verify();
@@ -22377,10 +22507,11 @@ async function activateUpdate(paths, effects) {
     try {
       await effects.stop();
       if (moved) {
-        await (0, import_promises10.rm)(paths.root, { recursive: true, force: true });
-        await (0, import_promises10.rename)(paths.previous, paths.root);
+        await (0, import_promises11.rm)(paths.root, { recursive: true, force: true });
+        await (0, import_promises11.rename)(paths.previous, paths.root);
       }
       if (backedUp) await effects.restore();
+      await effects.restoreLaunch?.();
       await effects.phase(
         "rolledBack",
         `\u65B0\u7248\u542F\u52A8\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u65E7\u7248\uFF1A${error62 instanceof Error ? error62.message : String(error62)}`
@@ -22397,16 +22528,16 @@ async function activateUpdate(paths, effects) {
   }
 }
 function transactionPaths(root, id, dataDir, config2, backup) {
-  const prefix = (0, import_node_path9.join)((0, import_node_path9.dirname)(root), `.covro-stage-${id}`);
+  const prefix = (0, import_node_path10.join)((0, import_node_path10.dirname)(root), `.covro-stage-${id}`);
   return {
     root,
     prefix,
-    candidate: (0, import_node_path9.join)(
+    candidate: (0, import_node_path10.join)(
       prefix,
       process.platform === "win32" ? "node_modules" : "lib/node_modules",
       npmPackageName
     ),
-    previous: (0, import_node_path9.join)((0, import_node_path9.dirname)(root), `.covro-previous-${id}`),
+    previous: (0, import_node_path10.join)((0, import_node_path10.dirname)(root), `.covro-previous-${id}`),
     backup,
     dataDir,
     config: config2
@@ -22414,12 +22545,9 @@ function transactionPaths(root, id, dataDir, config2, backup) {
 }
 
 // src/updates/registry.ts
-var import_node_child_process3 = require("node:child_process");
-var import_node_util3 = require("node:util");
-var import_promises11 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var import_node_fs3 = require("node:fs");
-var import_node_path10 = require("node:path");
-var run = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var import_node_path11 = require("node:path");
 var registry2 = "https://registry.npmjs.org";
 var releaseSchema = external_exports.object({
   name: external_exports.literal(npmPackageName),
@@ -22430,31 +22558,211 @@ var releaseSchema = external_exports.object({
 });
 async function inspectInstallation(root) {
   try {
-    const { stdout } = await run("npm", ["root", "--global"], { timeout: 15e3 });
-    return await inspectPackageDirectory(root, stdout.trim());
+    const globalRoot = (0, import_node_path11.dirname)((0, import_node_path11.dirname)((0, import_node_path11.resolve)(root)));
+    if (!globalRoot.endsWith("/lib/node_modules"))
+      return "\u5F53\u524D\u4E3A\u975E npm \u5168\u5C40\u5B89\u88C5\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
+    if (await (0, import_promises12.realpath)((0, import_node_path11.join)((0, import_node_path11.dirname)((0, import_node_path11.dirname)(globalRoot)), "bin/covro")) !== (0, import_node_path11.join)((0, import_node_path11.resolve)(root), "bin/covro.mjs"))
+      return "\u5F53\u524D Covro \u5165\u53E3\u4E0E npm \u5168\u5C40\u5B89\u88C5\u6765\u6E90\u4E0D\u5339\u914D\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
+    return await inspectPackageDirectory(root, globalRoot);
   } catch {
     return "\u65E0\u6CD5\u786E\u8BA4\u53EF\u5199\u7684 npm \u5168\u5C40\u5B89\u88C5\uFF1B\u8BF7\u68C0\u67E5 npm\u3001\u5B89\u88C5\u76EE\u5F55\u6743\u9650\u53CA\u540E\u53F0 PATH\u3002";
   }
 }
 async function inspectPackageDirectory(root, globalRoot) {
-  const expected = (0, import_node_path10.join)(await (0, import_promises11.realpath)(globalRoot), npmPackageName);
-  if ((await (0, import_promises11.lstat)(expected)).isSymbolicLink() || await (0, import_promises11.realpath)(root) !== expected)
+  const expected = (0, import_node_path11.join)(await (0, import_promises12.realpath)(globalRoot), npmPackageName);
+  if ((await (0, import_promises12.lstat)(expected)).isSymbolicLink() || await (0, import_promises12.realpath)(root) !== expected)
     return "\u5F53\u524D\u4E3A\u6E90\u7801\u3001\u94FE\u63A5\u6216\u975E npm \u5168\u5C40\u5B89\u88C5\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
   try {
-    await (0, import_promises11.lstat)((0, import_node_path10.join)(expected, ".git"));
+    await (0, import_promises12.lstat)((0, import_node_path11.join)(expected, ".git"));
     return "\u5F53\u524D\u5B89\u88C5\u5305\u542B Git \u5DE5\u4F5C\u533A\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
   } catch (error62) {
     if (error62.code !== "ENOENT") throw error62;
   }
-  await (0, import_promises11.access)(root, import_node_fs3.constants.W_OK);
+  await (0, import_promises12.access)(root, import_node_fs3.constants.W_OK);
   return void 0;
 }
 
+// src/updates/runtime.ts
+var import_node_child_process4 = require("node:child_process");
+var import_node_util4 = require("node:util");
+var import_node_os3 = require("node:os");
+var import_promises13 = require("node:fs/promises");
+var import_node_fs4 = require("node:fs");
+var import_node_path12 = require("node:path");
+var exec4 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+function assertRuntime(actual, expected) {
+  if (!actual || actual.node !== expected.node || actual.nodeVersion !== expected.nodeVersion || actual.root !== expected.root || actual.entry !== expected.entry)
+    throw new Error(
+      "\u5B9E\u9645 Node \u6216 Covro \u5B89\u88C5\u6765\u6E90\u4E0E\u76EE\u6807\u4E0D\u5339\u914D\uFF1B\u62D2\u7EDD\u6FC0\u6D3B\uFF0C\u8BF7\u67E5\u770B\u5347\u7EA7\u65E5\u5FD7\u5E76\u8FD0\u884C covro update repair\u3002"
+    );
+}
+async function verifyRuntimeExecutable(runtime) {
+  const { stdout } = await exec4(
+    runtime.node,
+    ["-p", "JSON.stringify({node:process.execPath,nodeVersion:process.versions.node})"],
+    { env: targetNpmEnvironment(process.env.PATH ?? "/usr/bin:/bin"), timeout: 15e3 }
+  );
+  const actual = JSON.parse(stdout);
+  if (actual.node !== runtime.node || actual.nodeVersion !== runtime.nodeVersion)
+    throw new Error(
+      "\u65E7 Node \u7684\u78C1\u76D8\u8DEF\u5F84\u5DF2\u88AB\u66FF\u6362\uFF0C\u65E0\u6CD5\u4FDD\u8BC1\u56DE\u6EDA\uFF1B\u8BF7\u4FDD\u7559\u65E7 Node \u5B89\u88C5\u5E76\u6838\u5BF9\u542F\u52A8\u6765\u6E90\u540E\u91CD\u8BD5\u3002"
+    );
+}
+var probeSchema = external_exports.object({
+  node: external_exports.string(),
+  nodeVersion: external_exports.string(),
+  path: external_exports.string(),
+  npmConfig: external_exports.record(external_exports.string(), external_exports.string()).optional()
+});
+var marker = "COVRO_RUNTIME_281=";
+var npmConfigKeys = ["prefix", "userconfig", "globalconfig"];
+var probe = `process.stdout.write('${marker}'+JSON.stringify({node:process.execPath,nodeVersion:process.versions.node,path:process.env.PATH,npmConfig:Object.fromEntries(${JSON.stringify(npmConfigKeys)}.flatMap(k=>{const v=process.env['npm_config_'+k]??process.env['NPM_CONFIG_'+k.toUpperCase()];return v===undefined?[]:[[k,v]]}))})+'\\n')`;
+function targetNpmEnvironment(path, config2 = {}) {
+  const env = { ...process.env, PATH: path, NODE_OPTIONS: "", NODE_PATH: "" };
+  for (const key of npmConfigKeys) {
+    delete env[`NPM_CONFIG_${key.toUpperCase()}`];
+    delete env[`npm_config_${key}`];
+    if (config2[key]) env[`npm_config_${key}`] = config2[key];
+  }
+  return env;
+}
+var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+async function defaultNodeEnvironment() {
+  const shell = (0, import_node_os3.userInfo)().shell;
+  if (!shell || !["bash", "zsh", "sh", "dash", "fish"].includes((0, import_node_path12.basename)(shell)))
+    throw new Error(
+      "\u65E0\u6CD5\u8BC6\u522B\u9ED8\u8BA4\u767B\u5F55 shell\uFF1B\u8BF7\u5728\u76EE\u6807 Node \u7684\u7EC8\u7AEF\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u5E76\u91CD\u65B0\u5B89\u88C5\u767B\u5F55\u670D\u52A1\u3002"
+    );
+  const oldBin = (0, import_node_path12.dirname)(process.execPath);
+  const path = (process.env.PATH ?? "").split(import_node_path12.delimiter).filter(
+    (part) => part && part !== oldBin && !/fnm_multishells|\/node-versions\/|\/\.nvm\/versions\/node\//.test(part)
+  );
+  const env = {
+    ...process.env,
+    PATH: [.../* @__PURE__ */ new Set([...path, "/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin"])].join(
+      import_node_path12.delimiter
+    )
+  };
+  for (const key of ["FNM_MULTISHELL_PATH", "NVM_BIN", "NVM_INC", "NODE_OPTIONS", "NODE_PATH"])
+    delete env[key];
+  for (const key of npmConfigKeys) {
+    delete env[`npm_config_${key}`];
+    delete env[`NPM_CONFIG_${key.toUpperCase()}`];
+  }
+  const { stdout } = await exec4(shell, ["-ilc", `node -e ${quote(probe)}`], {
+    cwd: (0, import_node_os3.homedir)(),
+    env,
+    timeout: 15e3,
+    maxBuffer: 256 * 1024
+  });
+  const lines = stdout.split(/\r?\n/).filter((line) => line.startsWith(marker));
+  if (lines.length !== 1)
+    throw new Error("\u767B\u5F55 shell \u672A\u8FD4\u56DE\u552F\u4E00\u7684\u9ED8\u8BA4 Node\uFF1B\u8BF7\u68C0\u67E5 shell \u542F\u52A8\u914D\u7F6E\u540E\u91CD\u8BD5\u3002");
+  return probeSchema.parse(JSON.parse(lines[0].slice(marker.length)));
+}
+async function executable(name, path) {
+  for (const directory of path.split(import_node_path12.delimiter)) {
+    if (!(0, import_node_path12.isAbsolute)(directory)) continue;
+    const filename = (0, import_node_path12.join)(directory, name);
+    try {
+      await (0, import_promises13.access)(filename, import_node_fs4.constants.X_OK);
+      return await (0, import_promises13.realpath)(filename);
+    } catch (error62) {
+      if (!["ENOENT", "EACCES", "ENOTDIR"].includes(error62.code ?? ""))
+        throw error62;
+    }
+  }
+  throw new Error(
+    `\u76EE\u6807 Node \u73AF\u5883\u4E2D\u627E\u4E0D\u5230 ${name}\uFF1B\u8BF7\u5728\u65B0\u7EC8\u7AEF\u68C0\u67E5 node\u3001npm \u548C npm install -g ${npmPackageName}\u3002`
+  );
+}
+async function resolveRuntimeTarget(environment = defaultNodeEnvironment) {
+  const found = await environment();
+  const node2 = await (0, import_promises13.realpath)(found.node);
+  await (0, import_promises13.access)(node2, import_node_fs4.constants.X_OK);
+  const { stdout } = await exec4(node2, ["-p", "process.versions.node"], {
+    env: targetNpmEnvironment(found.path, found.npmConfig),
+    timeout: 15e3
+  });
+  const nodeVersion = stdout.trim();
+  if (nodeVersion !== found.nodeVersion || !validVersion(nodeVersion) || compareVersions(nodeVersion, "24.19.0") < 0 || compareVersions(nodeVersion, "25.0.0") >= 0)
+    throw new Error(
+      `\u76EE\u6807 Node ${nodeVersion} \u4E0D\u53D7\u652F\u6301\uFF1B\u9700\u8981 >=24.19.0 <25\uFF0C\u8BF7\u8C03\u6574\u9ED8\u8BA4 Node \u540E\u91CD\u8BD5\u3002`
+    );
+  const npm = await executable("npm", found.path);
+  if (await (0, import_promises13.realpath)((0, import_node_path12.join)((0, import_node_path12.dirname)(node2), "npm")).catch(() => void 0) !== npm)
+    throw new Error("\u9ED8\u8BA4 Node \u548C npm \u6765\u81EA\u4E0D\u540C\u5B89\u88C5\uFF1B\u8BF7\u4FEE\u590D\u767B\u5F55 shell \u7684 PATH \u540E\u91CD\u65B0\u68C0\u67E5\u3002");
+  const npmInfo = JSON.parse(await (0, import_promises13.readFile)((0, import_node_path12.join)((0, import_node_path12.dirname)(npm), "../package.json"), "utf8"));
+  if ((0, import_node_path12.basename)(npm) !== "npm-cli.js" || npmInfo.name !== "npm")
+    throw new Error(
+      "\u76EE\u6807 npm \u662F\u65E0\u6CD5\u786E\u8BA4\u7684 shim\uFF1B\u8BF7\u8BA9\u767B\u5F55 shell \u7684 PATH \u6307\u5411\u76EE\u6807 Node \u81EA\u5E26\u7684 npm \u540E\u91CD\u8BD5\u3002"
+    );
+  const directories = await Promise.all(
+    found.path.split(import_node_path12.delimiter).filter(import_node_path12.isAbsolute).map((part) => (0, import_promises13.realpath)(part).catch(() => void 0))
+  );
+  const path = [
+    .../* @__PURE__ */ new Set([(0, import_node_path12.dirname)(node2), ...directories.filter((part) => Boolean(part))])
+  ].join(import_node_path12.delimiter);
+  const options = {
+    env: targetNpmEnvironment(path, found.npmConfig),
+    cwd: (0, import_node_os3.homedir)(),
+    timeout: 15e3
+  };
+  const [prefixResult, rootResult, npmVersionResult] = await Promise.all([
+    exec4(node2, [npm, "prefix", "--global"], options),
+    exec4(node2, [npm, "root", "--global"], options),
+    exec4(node2, [npm, "--version"], options)
+  ]);
+  const prefix = await (0, import_promises13.realpath)(prefixResult.stdout.trim());
+  const globalRoot = await (0, import_promises13.realpath)(rootResult.stdout.trim());
+  if (globalRoot !== (0, import_node_path12.join)(prefix, "lib/node_modules"))
+    throw new Error("\u76EE\u6807 npm \u5168\u5C40\u76EE\u5F55\u5E03\u5C40\u4E0D\u53D7\u652F\u6301\u3002");
+  const root = (0, import_node_path12.join)(globalRoot, npmPackageName);
+  const npmVersion = npmVersionResult.stdout.trim();
+  if (!validVersion(npmVersion))
+    throw new Error("\u76EE\u6807 npm \u672A\u8FD4\u56DE\u6709\u6548\u7248\u672C\uFF0C\u8BF7\u68C0\u67E5 npm \u5B89\u88C5\u540E\u91CD\u8BD5\u3002");
+  try {
+    const reason = await inspectPackageDirectory(root, globalRoot);
+    if (reason) throw new Error(reason);
+    const entry = (0, import_node_path12.join)(root, "bin/covro.mjs");
+    if ((await (0, import_promises13.lstat)(entry)).isSymbolicLink() || await (0, import_promises13.realpath)((0, import_node_path12.join)(prefix, "bin/covro")) !== entry)
+      throw new Error("\u5168\u5C40 covro \u5165\u53E3\u4E0E npm \u5B89\u88C5\u76EE\u5F55\u4E0D\u5339\u914D");
+    const metadata = JSON.parse(await (0, import_promises13.readFile)((0, import_node_path12.join)(root, "package.json"), "utf8"));
+    if (metadata.name !== npmPackageName || !validVersion(metadata.version))
+      throw new Error("Covro \u5305\u8EAB\u4EFD\u65E0\u6548");
+    return {
+      node: node2,
+      nodeVersion,
+      npm,
+      npmVersion,
+      prefix,
+      globalRoot,
+      root,
+      entry,
+      path,
+      version: metadata.version,
+      covroCodex: metadata.covroCodex,
+      covroCommit: metadata.covroCommit ?? metadata.gitHead,
+      npmConfig: found.npmConfig
+    };
+  } catch (error62) {
+    throw new Error(
+      `\u76EE\u6807 Node ${nodeVersion} \u7684\u5168\u5C40 Covro \u4E0D\u53EF\u7528\uFF1A${error62.message}\u3002\u8BF7\u5728\u65B0\u7EC8\u7AEF\u6267\u884C npm install -g ${npmPackageName} \u540E\u91CD\u8BD5\uFF1B\u5F53\u524D\u670D\u52A1\u4FDD\u6301\u8FD0\u884C\u3002`,
+      { cause: error62 }
+    );
+  }
+}
+
 // src/updates/worker.ts
-var exec3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+var exec5 = (0, import_node_util5.promisify)(import_node_child_process5.execFile);
 var message = (error62) => error62 instanceof Error ? error62.message : String(error62);
-async function startService(context) {
-  await startBackground(context.location, (0, import_node_path11.join)(context.root, "bin/covro.mjs"));
+async function startService(context, candidate = false) {
+  const target = candidate ? context.target : void 0;
+  await startBackground(
+    context.location,
+    (0, import_node_path13.join)(context.root, "bin/covro.mjs"),
+    target ? { node: target.node, entry: target.entry, path: target.path } : context.source
+  );
 }
 async function stopService(context) {
   await stopBackground(context.location);
@@ -22465,27 +22773,29 @@ async function verifyRestoredService(context, version3) {
       const restored = await control(context.location, "status");
       if (restored.version !== version3 || restored.maintenance)
         throw new Error("\u65E7\u7248\u6062\u590D\u8EAB\u4EFD\u4E0D\u5339\u914D");
+      const record2 = await readJson((0, import_node_path13.join)(context.directory, "run.json"));
+      if (record2?.runtime) assertRuntime(restored.runtime, record2.runtime.from);
       return;
     } catch (error62) {
       if (attempt === 239) throw error62;
     }
-    await (0, import_promises13.setTimeout)(250);
+    await (0, import_promises15.setTimeout)(250);
   }
 }
 async function verifyMigrations(context, candidate) {
-  const require2 = (0, import_node_module.createRequire)((0, import_node_path11.join)(context.root, "package.json"));
+  const require2 = (0, import_node_module.createRequire)((0, import_node_path13.join)(context.root, "package.json"));
   const Sqlite = require2("better-sqlite3");
-  const filename = (0, import_node_path11.join)(context.dataDir, "app.sqlite");
+  const filename = (0, import_node_path13.join)(context.dataDir, "app.sqlite");
   try {
-    await (0, import_promises12.access)(filename);
+    await (0, import_promises14.access)(filename);
   } catch (error62) {
     if (error62.code === "ENOENT") return;
     throw error62;
   }
   const db = new Sqlite(filename, { readonly: true, fileMustExist: true });
   try {
-    const migrations = readMigrations((0, import_node_path11.join)(candidate, "dist/drizzle"));
-    const metadata = await readJson((0, import_node_path11.join)(candidate, "package.json"));
+    const migrations = readMigrations((0, import_node_path13.join)(candidate, "dist/drizzle"));
+    const metadata = await readJson((0, import_node_path13.join)(candidate, "package.json"));
     if (metadata?.covroDatabase) {
       const contract = databaseCompatibilitySchema.parse(metadata.covroDatabase);
       if (contract.schemaVersion !== migrations.length)
@@ -22497,61 +22807,63 @@ async function verifyMigrations(context, candidate) {
   }
 }
 async function worker(directory) {
-  await (0, import_promises12.mkdir)(directory, { recursive: true, mode: 448 });
+  await (0, import_promises14.mkdir)(directory, { recursive: true, mode: 448 });
   const release = await import_proper_lockfile7.default.lock(directory, {
     stale: 1e4,
     update: 2e3,
     retries: { retries: 30, minTimeout: 100, maxTimeout: 500 }
   });
-  let record2 = await readJson((0, import_node_path11.join)(directory, "run.json"));
-  const context = await readJson((0, import_node_path11.join)(directory, "context.json"));
+  let record2 = await readJson((0, import_node_path13.join)(directory, "run.json"));
+  const context = await readJson((0, import_node_path13.join)(directory, "context.json"));
   if (!record2 || !context) {
     await release();
     throw new Error("\u7F3A\u5C11\u5347\u7EA7\u8BB0\u5F55");
   }
   const update = async (phase, detail) => {
     record2 = { ...record2, phase, message: detail, updatedAt: Date.now() };
-    await saveJson((0, import_node_path11.join)(directory, "run.json"), record2);
+    await saveJson((0, import_node_path13.join)(directory, "run.json"), record2);
   };
   const paths = transactionPaths(
-    context.root,
+    context.target?.root ?? context.root,
     record2.id,
     context.dataDir,
     context.location.config,
-    (0, import_node_path11.join)(backupDirectory(context.location.home, context.dataDir), record2.id)
+    (0, import_node_path13.join)(backupDirectory(context.location.home, context.dataDir), record2.id)
   );
   let releaseMaintenance;
   let releaseData;
-  const previousMetadata = await readJson(
-    (0, import_node_path11.join)(paths.previous, "package.json")
-  );
-  const originalRoot = previousMetadata?.version === record2.from ? paths.previous : context.root;
-  const originalMetadata = await readJson((0, import_node_path11.join)(originalRoot, "package.json"));
-  const Sqlite = (0, import_node_module.createRequire)((0, import_node_path11.join)(originalRoot, "package.json"))(
-    "better-sqlite3"
-  );
-  const migrations = readMigrations((0, import_node_path11.join)(originalRoot, "dist/drizzle"));
-  const backups = new BackupStore({
-    directory: backupDirectory(context.location.home, context.dataDir),
-    config: paths.config,
-    dataDir: paths.dataDir,
-    appVersion: record2.from,
-    commit: originalMetadata?.covroCommit,
-    contract: databaseCompatibilitySchema.parse(
-      originalMetadata?.covroDatabase ?? {
-        schemaVersion: migrations.length,
-        minRestorableSchemaVersion: 1,
-        backupFormatVersion: 1
-      }
-    ),
-    Sqlite,
-    migrations
-  });
   try {
+    if (record2.runtime) await verifyRuntimeExecutable(record2.runtime.from);
+    const previousMetadata = await readJson(
+      (0, import_node_path13.join)(paths.previous, "package.json")
+    );
+    const sameRoot = paths.root.replace(/\/$/, "") === context.root.replace(/\/$/, "");
+    const originalRoot = sameRoot && previousMetadata?.version === record2.from ? paths.previous : context.root;
+    const originalMetadata = await readJson((0, import_node_path13.join)(originalRoot, "package.json"));
+    const Sqlite = (0, import_node_module.createRequire)((0, import_node_path13.join)(originalRoot, "package.json"))(
+      "better-sqlite3"
+    );
+    const migrations = readMigrations((0, import_node_path13.join)(originalRoot, "dist/drizzle"));
+    const backups = new BackupStore({
+      directory: backupDirectory(context.location.home, context.dataDir),
+      config: paths.config,
+      dataDir: paths.dataDir,
+      appVersion: record2.from,
+      commit: originalMetadata?.covroCommit,
+      contract: databaseCompatibilitySchema.parse(
+        originalMetadata?.covroDatabase ?? {
+          schemaVersion: migrations.length,
+          minRestorableSchemaVersion: 1,
+          backupFormatVersion: 1
+        }
+      ),
+      Sqlite,
+      migrations
+    });
     if (process.argv[3] === "--repair") {
       releaseMaintenance = await acquireMaintenanceLock(context.dataDir);
-      if (!await readJson((0, import_node_path11.join)(paths.backup, "snapshot.json")))
-        paths.backup = (0, import_node_path11.join)(directory, `backup-${record2.id}`);
+      if (!await readJson((0, import_node_path13.join)(paths.backup, "snapshot.json")))
+        paths.backup = (0, import_node_path13.join)(directory, `backup-${record2.id}`);
       const active = await control(context.location, "status").catch(
         (error62) => {
           if (isNotRunning(error62)) return void 0;
@@ -22562,24 +22874,24 @@ async function worker(directory) {
       if (active && !active.maintenance && active.version !== record2.from)
         throw new Error("\u5F53\u524D\u670D\u52A1\u53EF\u80FD\u5DF2\u63A5\u53D7\u65B0\u7248\u4E1A\u52A1\u6570\u636E\uFF1B\u62D2\u7EDD\u6062\u590D\u65E7\u5FEB\u7167\uFF0C\u8BF7\u4F7F\u7528\u517C\u5BB9\u7248\u672C\u68C0\u67E5\u3002");
       const previous = await readJson(
-        (0, import_node_path11.join)(paths.previous, "package.json")
+        (0, import_node_path13.join)(paths.previous, "package.json")
       );
-      if (previous) {
+      if (previous || context.reuseTarget) {
         if (active && !active.maintenance)
           throw new Error("\u65E7\u670D\u52A1\u5DF2\u6062\u590D\u4E1A\u52A1\u5199\u5165\uFF1B\u62D2\u7EDD\u7528\u5347\u7EA7\u524D\u5FEB\u7167\u8986\u76D6\u73B0\u6709\u6570\u636E\uFF0C\u8BF7\u4FDD\u7559\u73B0\u573A\u68C0\u67E5\u3002");
-        if (previous.name !== npmPackageName || previous.version !== record2.from)
+        if (previous && (previous.name !== npmPackageName || previous.version !== (context.target?.version ?? record2.from)))
           throw new Error("\u65E7\u7248\u5907\u4EFD\u8EAB\u4EFD\u4E0D\u5339\u914D");
         const snapshot = await readJson(
-          (0, import_node_path11.join)(paths.backup, "snapshot.json")
+          (0, import_node_path13.join)(paths.backup, "snapshot.json")
         );
         if (snapshot?.formatVersion === 1) {
           const verified = await backups.verify(record2.id);
           if (verified.appVersion !== record2.from || verified.protectedBy !== record2.id || verified.configPath !== paths.config || verified.dataDir !== paths.dataDir)
             throw new Error("\u5907\u4EFD\u8EAB\u4EFD\u4E0D\u5339\u914D");
-        } else await verifyLegacySnapshot(paths.backup, Sqlite, (0, import_node_path11.join)(originalRoot, "dist/drizzle"));
-      } else {
+        } else await verifyLegacySnapshot(paths.backup, Sqlite, (0, import_node_path13.join)(originalRoot, "dist/drizzle"));
+      } else if (sameRoot) {
         const original = await readJson(
-          (0, import_node_path11.join)(paths.root, "package.json")
+          (0, import_node_path13.join)(paths.root, "package.json")
         );
         if (original?.name !== npmPackageName || original.version !== record2.from)
           throw new Error("\u672A\u627E\u5230\u5B8C\u6574\u7684\u4E0A\u4E00\u7248\u672C\u5B89\u88C5");
@@ -22591,20 +22903,24 @@ async function worker(directory) {
       await stopService(context);
       releaseData = await acquireInstanceLock(context.dataDir);
       if (previous) {
-        await (0, import_promises12.rm)(paths.root, { recursive: true, force: true });
-        await (0, import_promises12.rename)(paths.previous, paths.root);
+        await (0, import_promises14.rm)(paths.root, { recursive: true, force: true });
+        await (0, import_promises14.rename)(paths.previous, paths.root);
+      }
+      if (previous || context.reuseTarget) {
         for (const name of ["app.sqlite", "app.sqlite-wal", "app.sqlite-shm"]) {
-          await (0, import_promises12.rm)((0, import_node_path11.join)(paths.dataDir, name), { force: true });
+          await (0, import_promises14.rm)((0, import_node_path13.join)(paths.dataDir, name), { force: true });
           try {
-            await copyDurable((0, import_node_path11.join)(paths.backup, name), (0, import_node_path11.join)(paths.dataDir, name));
+            await copyDurable((0, import_node_path13.join)(paths.backup, name), (0, import_node_path13.join)(paths.dataDir, name));
           } catch (error62) {
             if (error62.code !== "ENOENT") throw error62;
           }
         }
-        await copyDurable((0, import_node_path11.join)(paths.backup, "config.json"), paths.config);
+        await copyDurable((0, import_node_path13.join)(paths.backup, "config.json"), paths.config);
       }
+      const launch2 = await readJson((0, import_node_path13.join)(directory, `launch-${record2.id}.json`));
+      if (launch2) await restoreLaunch(context.location, launch2);
       const restored = await readJson(
-        (0, import_node_path11.join)(paths.root, "package.json")
+        (0, import_node_path13.join)(context.root, "package.json")
       );
       if (restored?.name !== npmPackageName || restored.version !== record2.from)
         throw new Error("\u672A\u627E\u5230\u5B8C\u6574\u7684\u4E0A\u4E00\u7248\u672C\u5B89\u88C5");
@@ -22623,12 +22939,13 @@ async function worker(directory) {
     }
     const reason = await inspectInstallation(context.root);
     if (reason) throw new Error(reason);
-    for (const key of await (0, import_promises12.readdir)((0, import_node_path11.join)(context.location.home, "instances"))) {
+    for (const key of await (0, import_promises14.readdir)((0, import_node_path13.join)(context.location.home, "instances"))) {
       if (key === context.location.key) continue;
       const instance = await readJson(
-        (0, import_node_path11.join)(context.location.home, "instances", key, "instance.json")
+        (0, import_node_path13.join)(context.location.home, "instances", key, "instance.json")
       );
-      if (instance?.root !== context.root) continue;
+      if (!instance || ![context.root.replace(/\/$/, ""), paths.root].includes(instance.root.replace(/\/$/, "")))
+        continue;
       try {
         await control({ ...context.location, socket: instance.socket }, "status");
         throw new Error("\u540C\u4E00 npm \u5B89\u88C5\u8FD8\u6709\u5176\u4ED6 Covro \u5B9E\u4F8B\uFF0C\u8BF7\u5148\u505C\u6B62\u5176\u4ED6\u5B9E\u4F8B\u518D\u5347\u7EA7\u3002");
@@ -22636,24 +22953,39 @@ async function worker(directory) {
         if (!isNotRunning(error62)) throw error62;
       }
     }
-    await (0, import_promises12.access)((0, import_node_path11.dirname)(context.root), import_node_fs4.constants.W_OK);
-    await exec3(
-      "npm",
-      [
-        "install",
-        "--global",
-        "--prefix",
-        paths.prefix,
-        "--omit=dev",
-        "--no-audit",
-        "--no-fund",
-        `--registry=${registry2}`,
-        "--allow-scripts=better-sqlite3",
-        `${npmPackageName}@${record2.target}`
-      ],
-      { timeout: 10 * 6e4, maxBuffer: 2 * 1024 * 1024 }
+    await (0, import_promises14.access)((0, import_node_path13.dirname)(context.root), import_node_fs5.constants.W_OK);
+    await (0, import_promises14.access)((0, import_node_path13.dirname)(paths.root), import_node_fs5.constants.W_OK);
+    if (context.target) {
+      const target = await resolveRuntimeTarget();
+      assertRuntime(target, context.target);
+      if (target.npm !== context.target.npm || target.npmVersion !== context.target.npmVersion || target.prefix !== context.target.prefix || target.path !== context.target.path || target.version !== context.target.version)
+        throw new Error("\u76EE\u6807 Node/npm \u73AF\u5883\u5728\u68C0\u67E5\u540E\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u68C0\u67E5\u66F4\u65B0\u3002");
+    }
+    const candidateRoot = context.reuseTarget ? paths.root : paths.candidate;
+    const node2 = context.target?.node ?? process.execPath;
+    const env = targetNpmEnvironment(
+      context.target?.path ?? process.env.PATH ?? "/usr/bin:/bin",
+      context.target?.npmConfig
     );
-    const candidate = await readJson((0, import_node_path11.join)(paths.candidate, "package.json"));
+    if (!context.reuseTarget)
+      await exec5(
+        context.target?.node ?? "npm",
+        [
+          ...context.target ? [context.target.npm] : [],
+          "install",
+          "--global",
+          "--prefix",
+          paths.prefix,
+          "--omit=dev",
+          "--no-audit",
+          "--no-fund",
+          `--registry=${registry2}`,
+          "--allow-scripts=better-sqlite3",
+          `${npmPackageName}@${record2.target}`
+        ],
+        { env, timeout: 10 * 6e4, maxBuffer: 2 * 1024 * 1024 }
+      );
+    const candidate = await readJson((0, import_node_path13.join)(candidateRoot, "package.json"));
     if (candidate?.name !== npmPackageName || candidate.version !== record2.target)
       throw new Error("\u5019\u9009\u5305\u8EAB\u4EFD\u6216\u7248\u672C\u4E0D\u5339\u914D");
     if (record2.commit && (candidate.covroCommit ?? candidate.gitHead) !== record2.commit)
@@ -22673,81 +23005,106 @@ async function worker(directory) {
       );
     };
     await checkCodex();
-    await exec3(process.execPath, [(0, import_node_path11.join)(paths.candidate, "bin/covro.mjs"), "--version"], {
-      timeout: 3e4
+    const versionProbe = await exec5(node2, [(0, import_node_path13.join)(candidateRoot, "bin/covro.mjs"), "--version"], {
+      timeout: 3e4,
+      env
     });
+    if (versionProbe.stdout.trim() !== record2.target)
+      throw new Error("\u76EE\u6807 Node \u6267\u884C Covro \u5165\u53E3\u540E\u8FD4\u56DE\u7684\u7248\u672C\u4E0D\u5339\u914D");
     const nativeProbe = 'const {createRequire}=await import("node:module"); const r=createRequire(process.argv[1]); const DB=r("better-sqlite3"); const db=new DB(":memory:"); db.close();';
-    await exec3(
-      process.execPath,
-      ["--input-type=module", "-e", nativeProbe, (0, import_node_path11.join)(paths.candidate, "package.json")],
-      { timeout: 3e4 }
+    await exec5(
+      node2,
+      ["--input-type=module", "-e", nativeProbe, (0, import_node_path13.join)(candidateRoot, "package.json")],
+      { env, timeout: 3e4 }
+    );
+    await verifyMigrations(context, candidateRoot);
+    const launch = await snapshotLaunch(
+      context.location,
+      context.source ?? {
+        node: process.execPath,
+        entry: (0, import_node_path13.join)(context.root, "bin/covro.mjs"),
+        path: process.env.PATH ?? "/usr/bin:/bin"
+      }
     );
-    await verifyMigrations(context, paths.candidate);
+    if (context.target)
+      launch.target = { node: node2, entry: context.target.entry, path: context.target.path };
+    await saveJson((0, import_node_path13.join)(directory, `launch-${record2.id}.json`), launch);
     releaseMaintenance = await acquireMaintenanceLock(context.dataDir);
-    await activateUpdate(paths, {
-      backup: async () => {
-        releaseData = await acquireInstanceLock(context.dataDir);
-        await backups.create({ id: record2.id, trigger: "preUpgrade", protectedBy: record2.id });
-      },
-      restore: async () => {
-        releaseData ??= await acquireInstanceLock(context.dataDir);
-        await backups.restoreFiles(record2.id);
-      },
-      phase: update,
-      waitForIdle: async () => {
-        for (; ; ) {
-          await checkCodex();
-          const result = await control(
-            context.location,
-            "prepare-update"
-          );
-          if (result.ready) {
+    await activateUpdate(
+      paths,
+      {
+        backup: async () => {
+          releaseData = await acquireInstanceLock(context.dataDir);
+          await backups.create({ id: record2.id, trigger: "preUpgrade", protectedBy: record2.id });
+        },
+        restore: async () => {
+          releaseData ??= await acquireInstanceLock(context.dataDir);
+          await backups.restoreFiles(record2.id);
+        },
+        switchLaunch: context.target ? () => switchLaunch(
+          context.location,
+          { node: node2, entry: context.target.entry, path: context.target.path },
+          launch
+        ) : void 0,
+        restoreLaunch: () => restoreLaunch(context.location, launch),
+        phase: update,
+        waitForIdle: async () => {
+          for (; ; ) {
             await checkCodex();
-            return;
+            const result = await control(
+              context.location,
+              "prepare-update"
+            );
+            if (result.ready) {
+              await checkCodex();
+              return;
+            }
+            await update("waiting", result.reason ?? "\u7B49\u5F85\u6240\u6709\u4EFB\u52A1\u7ED3\u675F");
+            await (0, import_promises15.setTimeout)(2e3);
           }
-          await update("waiting", result.reason ?? "\u7B49\u5F85\u6240\u6709\u4EFB\u52A1\u7ED3\u675F");
-          await (0, import_promises13.setTimeout)(2e3);
-        }
-      },
-      stop: () => stopService(context),
-      start: async (candidate2) => {
-        await releaseData?.();
-        releaseData = void 0;
-        await startService(context);
-        if (!candidate2) await verifyRestoredService(context, record2.from);
-      },
-      verify: async () => {
-        for (let attempt = 0; attempt < 240; attempt++) {
-          const current = await control(context.location, "status").catch(
-            () => void 0
-          );
-          if (current) {
-            if (current.version !== record2.target || !current.maintenance)
-              throw new Error("\u65B0\u7248\u670D\u52A1\u8EAB\u4EFD\u6216\u7EF4\u62A4\u72B6\u6001\u4E0D\u5339\u914D");
-            await checkCodex(current);
-            if (current.codexReady) return;
+        },
+        stop: () => stopService(context),
+        start: async (candidate2) => {
+          await releaseData?.();
+          releaseData = void 0;
+          await startService(context, candidate2);
+          if (!candidate2) await verifyRestoredService(context, record2.from);
+        },
+        verify: async () => {
+          for (let attempt = 0; attempt < 240; attempt++) {
+            const current = await control(context.location, "status").catch(
+              () => void 0
+            );
+            if (current) {
+              if (current.version !== record2.target || !current.maintenance)
+                throw new Error("\u65B0\u7248\u670D\u52A1\u8EAB\u4EFD\u6216\u7EF4\u62A4\u72B6\u6001\u4E0D\u5339\u914D");
+              if (record2.runtime) assertRuntime(current.runtime, record2.runtime.target);
+              await checkCodex(current);
+              if (current.codexReady) return;
+            }
+            await (0, import_promises15.setTimeout)(250);
           }
-          await (0, import_promises13.setTimeout)(250);
+          throw new Error("\u65B0\u7248\u670D\u52A1\u6216 Codex \u8FDE\u63A5\u672A\u5C31\u7EEA\uFF0C\u62D2\u7EDD\u6FC0\u6D3B");
+        },
+        commit: async () => {
+          await control(context.location, "activate-update", {
+            id: record2.id,
+            channel: record2.channel
+          });
+          const final = await readJson((0, import_node_path13.join)(directory, "run.json"));
+          if (!final?.committed) throw new Error("\u65B0\u7248\u5C1A\u672A\u786E\u8BA4\u5347\u7EA7\u63D0\u4EA4");
+          record2 = final;
+        },
+        hasCommitted: async () => Boolean((await readJson((0, import_node_path13.join)(directory, "run.json")))?.committed),
+        resume: async () => {
+          await control(context.location, "cancel-update").catch(() => {
+          });
         }
-        throw new Error("\u65B0\u7248\u670D\u52A1\u6216 Codex \u8FDE\u63A5\u672A\u5C31\u7EEA\uFF0C\u62D2\u7EDD\u6FC0\u6D3B");
-      },
-      commit: async () => {
-        await control(context.location, "activate-update", {
-          id: record2.id,
-          channel: record2.channel
-        });
-        const final = await readJson((0, import_node_path11.join)(directory, "run.json"));
-        if (!final?.committed) throw new Error("\u65B0\u7248\u5C1A\u672A\u786E\u8BA4\u5347\u7EA7\u63D0\u4EA4");
-        record2 = final;
       },
-      hasCommitted: async () => Boolean((await readJson((0, import_node_path11.join)(directory, "run.json")))?.committed),
-      resume: async () => {
-        await control(context.location, "cancel-update").catch(() => {
-        });
-      }
-    });
+      context.reuseTarget
+    );
   } catch (error62) {
-    const latest = await readJson((0, import_node_path11.join)(directory, "run.json"));
+    const latest = await readJson((0, import_node_path13.join)(directory, "run.json"));
     if (latest?.committed) {
       record2 = latest;
     } else if (!["rolledBack", "failed"].includes(record2.phase))
@@ -22759,7 +23116,7 @@ async function worker(directory) {
     await releaseMaintenance?.();
     await release();
     if (record2.phase === "succeeded" || record2.phase === "rolledBack") {
-      await (0, import_promises12.rm)(paths.prefix, { recursive: true, force: true });
+      await (0, import_promises14.rm)(paths.prefix, { recursive: true, force: true });
     }
   }
 }