@shipers-dev/multi 0.8.0 → 0.8.1

package/dist/index.js

@@ -604,20 +604,20 @@ var makeIssue = (params) => {
   };
 };
 var EMPTY_PATH = [];
-function addIssueToContext(ctx2, issueData) {
+function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
     issueData,
-    data: ctx2.data,
-    path: ctx2.path,
+    data: ctx.data,
+    path: ctx.path,
     errorMaps: [
-      ctx2.common.contextualErrorMap,
-      ctx2.schemaErrorMap,
+      ctx.common.contextualErrorMap,
+      ctx.schemaErrorMap,
       overrideMap,
       overrideMap === en_default ? undefined : en_default
     ].filter((x) => !!x)
   });
-  ctx2.common.issues.push(issue);
+  ctx.common.issues.push(issue);
 }
 
 class ParseStatus {
@@ -710,11 +710,11 @@ class ParseInputLazyPath {
     return this._cachedPath;
   }
 }
-var handleResult = (ctx2, result) => {
+var handleResult = (ctx, result) => {
   if (isValid(result)) {
     return { success: true, data: result.value };
   } else {
-    if (!ctx2.common.issues.length) {
+    if (!ctx.common.issues.length) {
       throw new Error("Validation failed but no issues detected.");
     }
     return {
@@ -722,7 +722,7 @@ var handleResult = (ctx2, result) => {
       get error() {
         if (this._error)
           return this._error;
-        const error = new ZodError(ctx2.common.issues);
+        const error = new ZodError(ctx.common.issues);
         this._error = error;
         return this._error;
       }
@@ -738,17 +738,17 @@ function processCreateParams(params) {
   }
   if (errorMap2)
     return { errorMap: errorMap2, description };
-  const customMap = (iss, ctx2) => {
+  const customMap = (iss, ctx) => {
     const { message } = params;
     if (iss.code === "invalid_enum_value") {
-      return { message: message ?? ctx2.defaultError };
+      return { message: message ?? ctx.defaultError };
     }
-    if (typeof ctx2.data === "undefined") {
-      return { message: message ?? required_error ?? ctx2.defaultError };
+    if (typeof ctx.data === "undefined") {
+      return { message: message ?? required_error ?? ctx.defaultError };
     }
     if (iss.code !== "invalid_type")
-      return { message: ctx2.defaultError };
-    return { message: message ?? invalid_type_error ?? ctx2.defaultError };
+      return { message: ctx.defaultError };
+    return { message: message ?? invalid_type_error ?? ctx.defaultError };
   };
   return { errorMap: customMap, description };
 }
@@ -760,8 +760,8 @@ class ZodType {
   _getType(input) {
     return getParsedType(input.data);
   }
-  _getOrReturnCtx(input, ctx2) {
-    return ctx2 || {
+  _getOrReturnCtx(input, ctx) {
+    return ctx || {
       common: input.parent.common,
       data: input.data,
       parsedType: getParsedType(input.data),
@@ -801,7 +801,7 @@ class ZodType {
     throw result.error;
   }
   safeParse(data, params) {
-    const ctx2 = {
+    const ctx = {
       common: {
         issues: [],
         async: params?.async ?? false,
@@ -813,11 +813,11 @@ class ZodType {
       data,
       parsedType: getParsedType(data)
     };
-    const result = this._parseSync({ data, path: ctx2.path, parent: ctx2 });
-    return handleResult(ctx2, result);
+    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+    return handleResult(ctx, result);
   }
   "~validate"(data) {
-    const ctx2 = {
+    const ctx = {
       common: {
         issues: [],
         async: !!this["~standard"].async
@@ -830,26 +830,26 @@ class ZodType {
     };
     if (!this["~standard"].async) {
       try {
-        const result = this._parseSync({ data, path: [], parent: ctx2 });
+        const result = this._parseSync({ data, path: [], parent: ctx });
         return isValid(result) ? {
           value: result.value
         } : {
-          issues: ctx2.common.issues
+          issues: ctx.common.issues
         };
       } catch (err) {
         if (err?.message?.toLowerCase()?.includes("encountered")) {
           this["~standard"].async = true;
         }
-        ctx2.common = {
+        ctx.common = {
           issues: [],
           async: true
         };
       }
     }
-    return this._parseAsync({ data, path: [], parent: ctx2 }).then((result) => isValid(result) ? {
+    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
       value: result.value
     } : {
-      issues: ctx2.common.issues
+      issues: ctx.common.issues
     });
   }
   async parseAsync(data, params) {
@@ -859,7 +859,7 @@ class ZodType {
     throw result.error;
   }
   async safeParseAsync(data, params) {
-    const ctx2 = {
+    const ctx = {
       common: {
         issues: [],
         contextualErrorMap: params?.errorMap,
@@ -871,9 +871,9 @@ class ZodType {
       data,
       parsedType: getParsedType(data)
     };
-    const maybeAsyncResult = this._parse({ data, path: ctx2.path, parent: ctx2 });
+    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
     const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
-    return handleResult(ctx2, result);
+    return handleResult(ctx, result);
   }
   refine(check, message) {
     const getIssueProperties = (val) => {
@@ -885,9 +885,9 @@ class ZodType {
         return message;
       }
     };
-    return this._refinement((val, ctx2) => {
+    return this._refinement((val, ctx) => {
       const result = check(val);
-      const setError = () => ctx2.addIssue({
+      const setError = () => ctx.addIssue({
         code: ZodIssueCode.custom,
         ...getIssueProperties(val)
       });
@@ -910,9 +910,9 @@ class ZodType {
     });
   }
   refinement(check, refinementData) {
-    return this._refinement((val, ctx2) => {
+    return this._refinement((val, ctx) => {
       if (!check(val)) {
-        ctx2.addIssue(typeof refinementData === "function" ? refinementData(val, ctx2) : refinementData);
+        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
         return false;
       } else {
         return true;
@@ -1124,21 +1124,21 @@ class ZodString extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
-      const ctx3 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx3, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
-        received: ctx3.parsedType
+        received: ctx2.parsedType
       });
       return INVALID;
     }
     const status = new ParseStatus;
-    let ctx2 = undefined;
+    let ctx = undefined;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
         if (input.data.length < check.value) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
             type: "string",
@@ -1150,8 +1150,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "max") {
         if (input.data.length > check.value) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
             type: "string",
@@ -1165,9 +1165,9 @@ class ZodString extends ZodType {
         const tooBig = input.data.length > check.value;
         const tooSmall = input.data.length < check.value;
         if (tooBig || tooSmall) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
+          ctx = this._getOrReturnCtx(input, ctx);
           if (tooBig) {
-            addIssueToContext(ctx2, {
+            addIssueToContext(ctx, {
               code: ZodIssueCode.too_big,
               maximum: check.value,
               type: "string",
@@ -1176,7 +1176,7 @@ class ZodString extends ZodType {
               message: check.message
             });
           } else if (tooSmall) {
-            addIssueToContext(ctx2, {
+            addIssueToContext(ctx, {
               code: ZodIssueCode.too_small,
               minimum: check.value,
               type: "string",
@@ -1189,8 +1189,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "email") {
         if (!emailRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "email",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1202,8 +1202,8 @@ class ZodString extends ZodType {
           emojiRegex = new RegExp(_emojiRegex, "u");
         }
         if (!emojiRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "emoji",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1212,8 +1212,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "uuid") {
         if (!uuidRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "uuid",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1222,8 +1222,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "nanoid") {
         if (!nanoidRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "nanoid",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1232,8 +1232,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "cuid") {
         if (!cuidRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "cuid",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1242,8 +1242,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "cuid2") {
         if (!cuid2Regex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "cuid2",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1252,8 +1252,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "ulid") {
         if (!ulidRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "ulid",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1264,8 +1264,8 @@ class ZodString extends ZodType {
         try {
           new URL(input.data);
         } catch {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "url",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1276,8 +1276,8 @@ class ZodString extends ZodType {
         check.regex.lastIndex = 0;
         const testResult = check.regex.test(input.data);
         if (!testResult) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "regex",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1288,8 +1288,8 @@ class ZodString extends ZodType {
         input.data = input.data.trim();
       } else if (check.kind === "includes") {
         if (!input.data.includes(check.value, check.position)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { includes: check.value, position: check.position },
             message: check.message
@@ -1302,8 +1302,8 @@ class ZodString extends ZodType {
         input.data = input.data.toUpperCase();
       } else if (check.kind === "startsWith") {
         if (!input.data.startsWith(check.value)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { startsWith: check.value },
             message: check.message
@@ -1312,8 +1312,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "endsWith") {
         if (!input.data.endsWith(check.value)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { endsWith: check.value },
             message: check.message
@@ -1323,8 +1323,8 @@ class ZodString extends ZodType {
       } else if (check.kind === "datetime") {
         const regex = datetimeRegex(check);
         if (!regex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "datetime",
             message: check.message
@@ -1334,8 +1334,8 @@ class ZodString extends ZodType {
       } else if (check.kind === "date") {
         const regex = dateRegex;
         if (!regex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "date",
             message: check.message
@@ -1345,8 +1345,8 @@ class ZodString extends ZodType {
       } else if (check.kind === "time") {
         const regex = timeRegex(check);
         if (!regex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "time",
             message: check.message
@@ -1355,8 +1355,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "duration") {
         if (!durationRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "duration",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1365,8 +1365,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "ip") {
         if (!isValidIP(input.data, check.version)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "ip",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1375,8 +1375,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "jwt") {
         if (!isValidJWT(input.data, check.alg)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "jwt",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1385,8 +1385,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "cidr") {
         if (!isValidCidr(input.data, check.version)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "cidr",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1395,8 +1395,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "base64") {
         if (!base64Regex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "base64",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1405,8 +1405,8 @@ class ZodString extends ZodType {
         }
       } else if (check.kind === "base64url") {
         if (!base64urlRegex.test(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             validation: "base64url",
             code: ZodIssueCode.invalid_string,
             message: check.message
@@ -1682,21 +1682,21 @@ class ZodNumber extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
-      const ctx3 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx3, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
-        received: ctx3.parsedType
+        received: ctx2.parsedType
       });
       return INVALID;
     }
-    let ctx2 = undefined;
+    let ctx = undefined;
     const status = new ParseStatus;
     for (const check of this._def.checks) {
       if (check.kind === "int") {
         if (!util.isInteger(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: "integer",
             received: "float",
@@ -1707,8 +1707,8 @@ class ZodNumber extends ZodType {
       } else if (check.kind === "min") {
         const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
         if (tooSmall) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
             type: "number",
@@ -1721,8 +1721,8 @@ class ZodNumber extends ZodType {
       } else if (check.kind === "max") {
         const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
         if (tooBig) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
             type: "number",
@@ -1734,8 +1734,8 @@ class ZodNumber extends ZodType {
         }
       } else if (check.kind === "multipleOf") {
         if (floatSafeRemainder(input.data, check.value) !== 0) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
             message: check.message
@@ -1744,8 +1744,8 @@ class ZodNumber extends ZodType {
         }
       } else if (check.kind === "finite") {
         if (!Number.isFinite(input.data)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.not_finite,
             message: check.message
           });
@@ -1920,14 +1920,14 @@ class ZodBigInt extends ZodType {
     if (parsedType !== ZodParsedType.bigint) {
       return this._getInvalidInput(input);
     }
-    let ctx2 = undefined;
+    let ctx = undefined;
     const status = new ParseStatus;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
         const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
         if (tooSmall) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             type: "bigint",
             minimum: check.value,
@@ -1939,8 +1939,8 @@ class ZodBigInt extends ZodType {
       } else if (check.kind === "max") {
         const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
         if (tooBig) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             type: "bigint",
             maximum: check.value,
@@ -1951,8 +1951,8 @@ class ZodBigInt extends ZodType {
         }
       } else if (check.kind === "multipleOf") {
         if (input.data % check.value !== BigInt(0)) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
             message: check.message
@@ -1966,11 +1966,11 @@ class ZodBigInt extends ZodType {
     return { status: status.value, value: input.data };
   }
   _getInvalidInput(input) {
-    const ctx2 = this._getOrReturnCtx(input);
-    addIssueToContext(ctx2, {
+    const ctx = this._getOrReturnCtx(input);
+    addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.bigint,
-      received: ctx2.parsedType
+      received: ctx.parsedType
     });
     return INVALID;
   }
@@ -2082,11 +2082,11 @@ class ZodBoolean extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.boolean) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.boolean,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2108,28 +2108,28 @@ class ZodDate extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
-      const ctx3 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx3, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
-        received: ctx3.parsedType
+        received: ctx2.parsedType
       });
       return INVALID;
     }
     if (Number.isNaN(input.data.getTime())) {
-      const ctx3 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx3, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_date
       });
       return INVALID;
     }
     const status = new ParseStatus;
-    let ctx2 = undefined;
+    let ctx = undefined;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
         if (input.data.getTime() < check.value) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             message: check.message,
             inclusive: true,
@@ -2141,8 +2141,8 @@ class ZodDate extends ZodType {
         }
       } else if (check.kind === "max") {
         if (input.data.getTime() > check.value) {
-          ctx2 = this._getOrReturnCtx(input, ctx2);
-          addIssueToContext(ctx2, {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             message: check.message,
             inclusive: true,
@@ -2215,11 +2215,11 @@ class ZodSymbol extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.symbol) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.symbol,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2237,11 +2237,11 @@ class ZodUndefined extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.undefined,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2259,11 +2259,11 @@ class ZodNull extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.null) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.null,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2311,11 +2311,11 @@ ZodUnknown.create = (params) => {
 
 class ZodNever extends ZodType {
   _parse(input) {
-    const ctx2 = this._getOrReturnCtx(input);
-    addIssueToContext(ctx2, {
+    const ctx = this._getOrReturnCtx(input);
+    addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.never,
-      received: ctx2.parsedType
+      received: ctx.parsedType
     });
     return INVALID;
   }
@@ -2331,11 +2331,11 @@ class ZodVoid extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.void,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2351,21 +2351,21 @@ ZodVoid.create = (params) => {
 
 class ZodArray extends ZodType {
   _parse(input) {
-    const { ctx: ctx2, status } = this._processInputParams(input);
+    const { ctx, status } = this._processInputParams(input);
     const def = this._def;
-    if (ctx2.parsedType !== ZodParsedType.array) {
-      addIssueToContext(ctx2, {
+    if (ctx.parsedType !== ZodParsedType.array) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.array,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     if (def.exactLength !== null) {
-      const tooBig = ctx2.data.length > def.exactLength.value;
-      const tooSmall = ctx2.data.length < def.exactLength.value;
+      const tooBig = ctx.data.length > def.exactLength.value;
+      const tooSmall = ctx.data.length < def.exactLength.value;
       if (tooBig || tooSmall) {
-        addIssueToContext(ctx2, {
+        addIssueToContext(ctx, {
           code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
           minimum: tooSmall ? def.exactLength.value : undefined,
           maximum: tooBig ? def.exactLength.value : undefined,
@@ -2378,8 +2378,8 @@ class ZodArray extends ZodType {
       }
     }
     if (def.minLength !== null) {
-      if (ctx2.data.length < def.minLength.value) {
-        addIssueToContext(ctx2, {
+      if (ctx.data.length < def.minLength.value) {
+        addIssueToContext(ctx, {
           code: ZodIssueCode.too_small,
           minimum: def.minLength.value,
           type: "array",
@@ -2391,8 +2391,8 @@ class ZodArray extends ZodType {
       }
     }
     if (def.maxLength !== null) {
-      if (ctx2.data.length > def.maxLength.value) {
-        addIssueToContext(ctx2, {
+      if (ctx.data.length > def.maxLength.value) {
+        addIssueToContext(ctx, {
           code: ZodIssueCode.too_big,
           maximum: def.maxLength.value,
           type: "array",
@@ -2403,15 +2403,15 @@ class ZodArray extends ZodType {
         status.dirty();
       }
     }
-    if (ctx2.common.async) {
-      return Promise.all([...ctx2.data].map((item, i) => {
-        return def.type._parseAsync(new ParseInputLazyPath(ctx2, item, ctx2.path, i));
+    if (ctx.common.async) {
+      return Promise.all([...ctx.data].map((item, i) => {
+        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       })).then((result2) => {
         return ParseStatus.mergeArray(status, result2);
       });
     }
-    const result = [...ctx2.data].map((item, i) => {
-      return def.type._parseSync(new ParseInputLazyPath(ctx2, item, ctx2.path, i));
+    const result = [...ctx.data].map((item, i) => {
+      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
     return ParseStatus.mergeArray(status, result);
   }
@@ -2495,19 +2495,19 @@ class ZodObject extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.object) {
-      const ctx3 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx3, {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
-        received: ctx3.parsedType
+        received: ctx2.parsedType
       });
       return INVALID;
     }
-    const { status, ctx: ctx2 } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
-      for (const key in ctx2.data) {
+      for (const key in ctx.data) {
         if (!shapeKeys.includes(key)) {
           extraKeys.push(key);
         }
@@ -2516,11 +2516,11 @@ class ZodObject extends ZodType {
     const pairs = [];
     for (const key of shapeKeys) {
       const keyValidator = shape[key];
-      const value = ctx2.data[key];
+      const value = ctx.data[key];
       pairs.push({
         key: { status: "valid", value: key },
-        value: keyValidator._parse(new ParseInputLazyPath(ctx2, value, ctx2.path, key)),
-        alwaysSet: key in ctx2.data
+        value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+        alwaysSet: key in ctx.data
       });
     }
     if (this._def.catchall instanceof ZodNever) {
@@ -2529,12 +2529,12 @@ class ZodObject extends ZodType {
         for (const key of extraKeys) {
           pairs.push({
             key: { status: "valid", value: key },
-            value: { status: "valid", value: ctx2.data[key] }
+            value: { status: "valid", value: ctx.data[key] }
           });
         }
       } else if (unknownKeys === "strict") {
         if (extraKeys.length > 0) {
-          addIssueToContext(ctx2, {
+          addIssueToContext(ctx, {
             code: ZodIssueCode.unrecognized_keys,
             keys: extraKeys
           });
@@ -2546,15 +2546,15 @@ class ZodObject extends ZodType {
     } else {
       const catchall = this._def.catchall;
       for (const key of extraKeys) {
-        const value = ctx2.data[key];
+        const value = ctx.data[key];
         pairs.push({
           key: { status: "valid", value: key },
-          value: catchall._parse(new ParseInputLazyPath(ctx2, value, ctx2.path, key)),
-          alwaysSet: key in ctx2.data
+          value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+          alwaysSet: key in ctx.data
         });
       }
     }
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return Promise.resolve().then(async () => {
         const syncPairs = [];
         for (const pair of pairs) {
@@ -2583,8 +2583,8 @@ class ZodObject extends ZodType {
       ...this._def,
       unknownKeys: "strict",
       ...message !== undefined ? {
-        errorMap: (issue, ctx2) => {
-          const defaultError = this._def.errorMap?.(issue, ctx2).message ?? ctx2.defaultError;
+        errorMap: (issue, ctx) => {
+          const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
           if (issue.code === "unrecognized_keys")
             return {
               message: errorUtil.errToObj(message).message ?? defaultError
@@ -2733,7 +2733,7 @@ ZodObject.lazycreate = (shape, params) => {
 
 class ZodUnion extends ZodType {
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
+    const { ctx } = this._processInputParams(input);
     const options = this._def.options;
     function handleResults(results) {
       for (const result of results) {
@@ -2743,31 +2743,31 @@ class ZodUnion extends ZodType {
       }
       for (const result of results) {
         if (result.result.status === "dirty") {
-          ctx2.common.issues.push(...result.ctx.common.issues);
+          ctx.common.issues.push(...result.ctx.common.issues);
           return result.result;
         }
       }
       const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
-      addIssueToContext(ctx2, {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union,
         unionErrors
       });
       return INVALID;
     }
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return Promise.all(options.map(async (option) => {
         const childCtx = {
-          ...ctx2,
+          ...ctx,
           common: {
-            ...ctx2.common,
+            ...ctx.common,
             issues: []
           },
           parent: null
         };
         return {
           result: await option._parseAsync({
-            data: ctx2.data,
-            path: ctx2.path,
+            data: ctx.data,
+            path: ctx.path,
             parent: childCtx
           }),
           ctx: childCtx
@@ -2778,16 +2778,16 @@ class ZodUnion extends ZodType {
       const issues = [];
       for (const option of options) {
         const childCtx = {
-          ...ctx2,
+          ...ctx,
           common: {
-            ...ctx2.common,
+            ...ctx.common,
             issues: []
           },
           parent: null
         };
         const result = option._parseSync({
-          data: ctx2.data,
-          path: ctx2.path,
+          data: ctx.data,
+          path: ctx.path,
           parent: childCtx
         });
         if (result.status === "valid") {
@@ -2800,11 +2800,11 @@ class ZodUnion extends ZodType {
         }
       }
       if (dirty) {
-        ctx2.common.issues.push(...dirty.ctx.common.issues);
+        ctx.common.issues.push(...dirty.ctx.common.issues);
         return dirty.result;
       }
       const unionErrors = issues.map((issues2) => new ZodError(issues2));
-      addIssueToContext(ctx2, {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union,
         unionErrors
       });
@@ -2856,37 +2856,37 @@ var getDiscriminator = (type) => {
 
 class ZodDiscriminatedUnion extends ZodType {
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.object) {
-      addIssueToContext(ctx2, {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.object) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     const discriminator = this.discriminator;
-    const discriminatorValue = ctx2.data[discriminator];
+    const discriminatorValue = ctx.data[discriminator];
     const option = this.optionsMap.get(discriminatorValue);
     if (!option) {
-      addIssueToContext(ctx2, {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
         options: Array.from(this.optionsMap.keys()),
         path: [discriminator]
       });
       return INVALID;
     }
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return option._parseAsync({
-        data: ctx2.data,
-        path: ctx2.path,
-        parent: ctx2
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
       });
     } else {
       return option._parseSync({
-        data: ctx2.data,
-        path: ctx2.path,
-        parent: ctx2
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
       });
     }
   }
@@ -2963,14 +2963,14 @@ function mergeValues(a, b) {
 
 class ZodIntersection extends ZodType {
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
       }
       const merged = mergeValues(parsedLeft.value, parsedRight.value);
       if (!merged.valid) {
-        addIssueToContext(ctx2, {
+        addIssueToContext(ctx, {
           code: ZodIssueCode.invalid_intersection_types
         });
         return INVALID;
@@ -2980,28 +2980,28 @@ class ZodIntersection extends ZodType {
       }
       return { status: status.value, value: merged.data };
     };
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return Promise.all([
         this._def.left._parseAsync({
-          data: ctx2.data,
-          path: ctx2.path,
-          parent: ctx2
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
         }),
         this._def.right._parseAsync({
-          data: ctx2.data,
-          path: ctx2.path,
-          parent: ctx2
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
         })
       ]).then(([left, right]) => handleParsed(left, right));
     } else {
       return handleParsed(this._def.left._parseSync({
-        data: ctx2.data,
-        path: ctx2.path,
-        parent: ctx2
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
       }), this._def.right._parseSync({
-        data: ctx2.data,
-        path: ctx2.path,
-        parent: ctx2
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
       }));
     }
   }
@@ -3017,17 +3017,17 @@ ZodIntersection.create = (left, right, params) => {
 
 class ZodTuple extends ZodType {
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.array) {
-      addIssueToContext(ctx2, {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.array) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.array,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
-    if (ctx2.data.length < this._def.items.length) {
-      addIssueToContext(ctx2, {
+    if (ctx.data.length < this._def.items.length) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.too_small,
         minimum: this._def.items.length,
         inclusive: true,
@@ -3037,8 +3037,8 @@ class ZodTuple extends ZodType {
       return INVALID;
     }
     const rest = this._def.rest;
-    if (!rest && ctx2.data.length > this._def.items.length) {
-      addIssueToContext(ctx2, {
+    if (!rest && ctx.data.length > this._def.items.length) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.too_big,
         maximum: this._def.items.length,
         inclusive: true,
@@ -3047,13 +3047,13 @@ class ZodTuple extends ZodType {
       });
       status.dirty();
     }
-    const items = [...ctx2.data].map((item, itemIndex) => {
+    const items = [...ctx.data].map((item, itemIndex) => {
       const schema = this._def.items[itemIndex] || this._def.rest;
       if (!schema)
         return null;
-      return schema._parse(new ParseInputLazyPath(ctx2, item, ctx2.path, itemIndex));
+      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
     }).filter((x) => !!x);
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return Promise.all(items).then((results) => {
         return ParseStatus.mergeArray(status, results);
       });
@@ -3091,26 +3091,26 @@ class ZodRecord extends ZodType {
     return this._def.valueType;
   }
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.object) {
-      addIssueToContext(ctx2, {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.object) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     const pairs = [];
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    for (const key in ctx2.data) {
+    for (const key in ctx.data) {
       pairs.push({
-        key: keyType._parse(new ParseInputLazyPath(ctx2, key, ctx2.path, key)),
-        value: valueType._parse(new ParseInputLazyPath(ctx2, ctx2.data[key], ctx2.path, key)),
-        alwaysSet: key in ctx2.data
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
+        alwaysSet: key in ctx.data
       });
     }
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       return ParseStatus.mergeObjectAsync(status, pairs);
     } else {
       return ParseStatus.mergeObjectSync(status, pairs);
@@ -3145,24 +3145,24 @@ class ZodMap extends ZodType {
     return this._def.valueType;
   }
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.map) {
-      addIssueToContext(ctx2, {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.map) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.map,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx2.data.entries()].map(([key, value], index) => {
+    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
       return {
-        key: keyType._parse(new ParseInputLazyPath(ctx2, key, ctx2.path, [index, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx2, value, ctx2.path, [index, "value"]))
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
       };
     });
-    if (ctx2.common.async) {
+    if (ctx.common.async) {
       const finalMap = new Map;
       return Promise.resolve().then(async () => {
         for (const pair of pairs) {
@@ -3206,19 +3206,19 @@ ZodMap.create = (keyType, valueType, params) => {
 
 class ZodSet extends ZodType {
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.set) {
-      addIssueToContext(ctx2, {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.set) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.set,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     const def = this._def;
     if (def.minSize !== null) {
-      if (ctx2.data.size < def.minSize.value) {
-        addIssueToContext(ctx2, {
+      if (ctx.data.size < def.minSize.value) {
+        addIssueToContext(ctx, {
           code: ZodIssueCode.too_small,
           minimum: def.minSize.value,
           type: "set",
@@ -3230,8 +3230,8 @@ class ZodSet extends ZodType {
       }
     }
     if (def.maxSize !== null) {
-      if (ctx2.data.size > def.maxSize.value) {
-        addIssueToContext(ctx2, {
+      if (ctx.data.size > def.maxSize.value) {
+        addIssueToContext(ctx, {
           code: ZodIssueCode.too_big,
           maximum: def.maxSize.value,
           type: "set",
@@ -3254,8 +3254,8 @@ class ZodSet extends ZodType {
       }
       return { status: status.value, value: parsedSet };
     }
-    const elements = [...ctx2.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx2, item, ctx2.path, i)));
-    if (ctx2.common.async) {
+    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+    if (ctx.common.async) {
       return Promise.all(elements).then((elements2) => finalizeSet(elements2));
     } else {
       return finalizeSet(elements);
@@ -3296,20 +3296,20 @@ class ZodFunction extends ZodType {
     this.validate = this.implement;
   }
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.function) {
-      addIssueToContext(ctx2, {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.function) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.function,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     function makeArgsIssue(args, error) {
       return makeIssue({
         data: args,
-        path: ctx2.path,
-        errorMaps: [ctx2.common.contextualErrorMap, ctx2.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode.invalid_arguments,
           argumentsError: error
@@ -3319,16 +3319,16 @@ class ZodFunction extends ZodType {
     function makeReturnsIssue(returns, error) {
       return makeIssue({
         data: returns,
-        path: ctx2.path,
-        errorMaps: [ctx2.common.contextualErrorMap, ctx2.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode.invalid_return_type,
           returnTypeError: error
         }
       });
     }
-    const params = { errorMap: ctx2.common.contextualErrorMap };
-    const fn = ctx2.data;
+    const params = { errorMap: ctx.common.contextualErrorMap };
+    const fn = ctx.data;
     if (this._def.returns instanceof ZodPromise) {
       const me = this;
       return OK(async function(...args) {
@@ -3401,9 +3401,9 @@ class ZodLazy extends ZodType {
     return this._def.getter();
   }
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
+    const { ctx } = this._processInputParams(input);
     const lazySchema = this._def.getter();
-    return lazySchema._parse({ data: ctx2.data, path: ctx2.path, parent: ctx2 });
+    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
 }
 ZodLazy.create = (getter, params) => {
@@ -3417,9 +3417,9 @@ ZodLazy.create = (getter, params) => {
 class ZodLiteral extends ZodType {
   _parse(input) {
     if (input.data !== this._def.value) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
-        received: ctx2.data,
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        received: ctx.data,
         code: ZodIssueCode.invalid_literal,
         expected: this._def.value
       });
@@ -3449,11 +3449,11 @@ function createZodEnum(values, params) {
 class ZodEnum extends ZodType {
   _parse(input) {
     if (typeof input.data !== "string") {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input);
       const expectedValues = this._def.values;
-      addIssueToContext(ctx2, {
+      addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
-        received: ctx2.parsedType,
+        received: ctx.parsedType,
         code: ZodIssueCode.invalid_type
       });
       return INVALID;
@@ -3462,10 +3462,10 @@ class ZodEnum extends ZodType {
       this._cache = new Set(this._def.values);
     }
     if (!this._cache.has(input.data)) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input);
       const expectedValues = this._def.values;
-      addIssueToContext(ctx2, {
-        received: ctx2.data,
+      addIssueToContext(ctx, {
+        received: ctx.data,
         code: ZodIssueCode.invalid_enum_value,
         options: expectedValues
       });
@@ -3515,12 +3515,12 @@ ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
   _parse(input) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx2 = this._getOrReturnCtx(input);
-    if (ctx2.parsedType !== ZodParsedType.string && ctx2.parsedType !== ZodParsedType.number) {
+    const ctx = this._getOrReturnCtx(input);
+    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
       const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx2, {
+      addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
-        received: ctx2.parsedType,
+        received: ctx.parsedType,
         code: ZodIssueCode.invalid_type
       });
       return INVALID;
@@ -3530,8 +3530,8 @@ class ZodNativeEnum extends ZodType {
     }
     if (!this._cache.has(input.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx2, {
-        received: ctx2.data,
+      addIssueToContext(ctx, {
+        received: ctx.data,
         code: ZodIssueCode.invalid_enum_value,
         options: expectedValues
       });
@@ -3556,20 +3556,20 @@ class ZodPromise extends ZodType {
     return this._def.type;
   }
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.parsedType !== ZodParsedType.promise && ctx2.common.async === false) {
-      addIssueToContext(ctx2, {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.promise,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
-    const promisified = ctx2.parsedType === ZodParsedType.promise ? ctx2.data : Promise.resolve(ctx2.data);
+    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
     return OK(promisified.then((data) => {
       return this._def.type.parseAsync(data, {
-        path: ctx2.path,
-        errorMap: ctx2.common.contextualErrorMap
+        path: ctx.path,
+        errorMap: ctx.common.contextualErrorMap
       });
     }));
   }
@@ -3590,11 +3590,11 @@ class ZodEffects extends ZodType {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
-        addIssueToContext(ctx2, arg);
+        addIssueToContext(ctx, arg);
         if (arg.fatal) {
           status.abort();
         } else {
@@ -3602,20 +3602,20 @@ class ZodEffects extends ZodType {
         }
       },
       get path() {
-        return ctx2.path;
+        return ctx.path;
       }
     };
     checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
     if (effect.type === "preprocess") {
-      const processed = effect.transform(ctx2.data, checkCtx);
-      if (ctx2.common.async) {
+      const processed = effect.transform(ctx.data, checkCtx);
+      if (ctx.common.async) {
         return Promise.resolve(processed).then(async (processed2) => {
           if (status.value === "aborted")
             return INVALID;
           const result = await this._def.schema._parseAsync({
             data: processed2,
-            path: ctx2.path,
-            parent: ctx2
+            path: ctx.path,
+            parent: ctx
           });
           if (result.status === "aborted")
             return INVALID;
@@ -3630,8 +3630,8 @@ class ZodEffects extends ZodType {
           return INVALID;
         const result = this._def.schema._parseSync({
           data: processed,
-          path: ctx2.path,
-          parent: ctx2
+          path: ctx.path,
+          parent: ctx
         });
         if (result.status === "aborted")
           return INVALID;
@@ -3645,7 +3645,7 @@ class ZodEffects extends ZodType {
     if (effect.type === "refinement") {
       const executeRefinement = (acc) => {
         const result = effect.refinement(acc, checkCtx);
-        if (ctx2.common.async) {
+        if (ctx.common.async) {
           return Promise.resolve(result);
         }
         if (result instanceof Promise) {
@@ -3653,11 +3653,11 @@ class ZodEffects extends ZodType {
         }
         return acc;
       };
-      if (ctx2.common.async === false) {
+      if (ctx.common.async === false) {
         const inner = this._def.schema._parseSync({
-          data: ctx2.data,
-          path: ctx2.path,
-          parent: ctx2
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
         });
         if (inner.status === "aborted")
           return INVALID;
@@ -3666,7 +3666,7 @@ class ZodEffects extends ZodType {
         executeRefinement(inner.value);
         return { status: status.value, value: inner.value };
       } else {
-        return this._def.schema._parseAsync({ data: ctx2.data, path: ctx2.path, parent: ctx2 }).then((inner) => {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
           if (inner.status === "aborted")
             return INVALID;
           if (inner.status === "dirty")
@@ -3678,11 +3678,11 @@ class ZodEffects extends ZodType {
       }
     }
     if (effect.type === "transform") {
-      if (ctx2.common.async === false) {
+      if (ctx.common.async === false) {
         const base = this._def.schema._parseSync({
-          data: ctx2.data,
-          path: ctx2.path,
-          parent: ctx2
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
         });
         if (!isValid(base))
           return INVALID;
@@ -3692,7 +3692,7 @@ class ZodEffects extends ZodType {
         }
         return { status: status.value, value: result };
       } else {
-        return this._def.schema._parseAsync({ data: ctx2.data, path: ctx2.path, parent: ctx2 }).then((base) => {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
           if (!isValid(base))
             return INVALID;
           return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
@@ -3763,15 +3763,15 @@ ZodNullable.create = (type, params) => {
 
 class ZodDefault extends ZodType {
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
-    let data = ctx2.data;
-    if (ctx2.parsedType === ZodParsedType.undefined) {
+    const { ctx } = this._processInputParams(input);
+    let data = ctx.data;
+    if (ctx.parsedType === ZodParsedType.undefined) {
       data = this._def.defaultValue();
     }
     return this._def.innerType._parse({
       data,
-      path: ctx2.path,
-      parent: ctx2
+      path: ctx.path,
+      parent: ctx
     });
   }
   removeDefault() {
@@ -3789,11 +3789,11 @@ ZodDefault.create = (type, params) => {
 
 class ZodCatch extends ZodType {
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
+    const { ctx } = this._processInputParams(input);
     const newCtx = {
-      ...ctx2,
+      ...ctx,
       common: {
-        ...ctx2.common,
+        ...ctx.common,
         issues: []
       }
     };
@@ -3845,11 +3845,11 @@ class ZodNaN extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.nan) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.nan,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -3866,12 +3866,12 @@ var BRAND = Symbol("zod_brand");
 
 class ZodBranded extends ZodType {
   _parse(input) {
-    const { ctx: ctx2 } = this._processInputParams(input);
-    const data = ctx2.data;
+    const { ctx } = this._processInputParams(input);
+    const data = ctx.data;
     return this._def.type._parse({
       data,
-      path: ctx2.path,
-      parent: ctx2
+      path: ctx.path,
+      parent: ctx
     });
   }
   unwrap() {
@@ -3881,13 +3881,13 @@ class ZodBranded extends ZodType {
 
 class ZodPipeline extends ZodType {
   _parse(input) {
-    const { status, ctx: ctx2 } = this._processInputParams(input);
-    if (ctx2.common.async) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
-          data: ctx2.data,
-          path: ctx2.path,
-          parent: ctx2
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
         });
         if (inResult.status === "aborted")
           return INVALID;
@@ -3897,17 +3897,17 @@ class ZodPipeline extends ZodType {
         } else {
           return this._def.out._parseAsync({
             data: inResult.value,
-            path: ctx2.path,
-            parent: ctx2
+            path: ctx.path,
+            parent: ctx
           });
         }
       };
       return handleAsync();
     } else {
       const inResult = this._def.in._parseSync({
-        data: ctx2.data,
-        path: ctx2.path,
-        parent: ctx2
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
       });
       if (inResult.status === "aborted")
         return INVALID;
@@ -3920,8 +3920,8 @@ class ZodPipeline extends ZodType {
       } else {
         return this._def.out._parseSync({
           data: inResult.value,
-          path: ctx2.path,
-          parent: ctx2
+          path: ctx.path,
+          parent: ctx
         });
       }
     }
@@ -3964,21 +3964,21 @@ function cleanParams(params, data) {
 }
 function custom(check, _params = {}, fatal) {
   if (check)
-    return ZodAny.create().superRefine((data, ctx2) => {
+    return ZodAny.create().superRefine((data, ctx) => {
       const r = check(data);
       if (r instanceof Promise) {
         return r.then((r2) => {
           if (!r2) {
             const params = cleanParams(_params, data);
             const _fatal = params.fatal ?? fatal ?? true;
-            ctx2.addIssue({ code: "custom", ...params, fatal: _fatal });
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
           }
         });
       }
       if (!r) {
         const params = cleanParams(_params, data);
         const _fatal = params.fatal ?? fatal ?? true;
-        ctx2.addIssue({ code: "custom", ...params, fatal: _fatal });
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
       }
       return;
     });
@@ -6002,7 +6002,7 @@ async function parseTunnelUrl(stream2) {
   }
   return null;
 }
-async function handleRunTask(apiUrl, deviceId, task, detected, ctx2) {
+async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   const issueId = task.issue_id;
   const isFollowup = !!task.followup;
   const workingDir = task.working_dir && existsSync2(task.working_dir) ? task.working_dir : undefined;
@@ -6424,12 +6424,12 @@ ${userPart}` : userPart;
       if (n > 0)
         log(`  \uD83D\uDCCE uploaded ${n} output file(s)`);
     }
-    if (ctx2) {
+    if (ctx) {
       const fullText = turn.blocks.filter((b) => b.kind === "text").map((b) => b.text).join(`
 `);
       const actions = extractPlanActions(fullText);
       if (actions.length) {
-        const summary = await executePlanActions(apiUrl, task, actions, ctx2);
+        const summary = await executePlanActions(apiUrl, task, actions, ctx);
         if (summary) {
           try {
             await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, { author_type: "agent", author_id: task.agent_id, author_name: "agent", body: summary });
@@ -6531,7 +6531,7 @@ function extractPlanActions(text) {
   return out;
 }
 var PLAN_ACTION_LIMIT = 10;
-async function executePlanActions(apiUrl, parentTask, actions, _ctx) {
+async function executePlanActions(apiUrl, parentTask, actions, ctx) {
   const lines = [];
   let truncated = false;
   if (actions.length > PLAN_ACTION_LIMIT) {