fullstacked 0.12.0-1273 → 0.12.0-1291

package/fullstacked_modules/zod/src/v4/core/schemas.ts

@@ -121,9 +121,6 @@ export interface _$ZodTypeInternals {
    */
   values?: util.PrimitiveSet | undefined;
 
-  /** Default value bubbled up from  */
-  // default?: unknown | undefined;
-
   /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
   propValues?: util.PropValues | undefined;
 
@@ -319,7 +316,6 @@ export const $ZodString: core.$constructor<$ZodString> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "string",
       code: "invalid_type",
-
       input: payload.value,
       inst,
     });
@@ -418,7 +414,6 @@ export const $ZodEmail: core.$constructor<$ZodEmail> = /*@__PURE__*/ core.$const
 export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
   hostname?: RegExp | undefined;
   protocol?: RegExp | undefined;
-  normalize?: boolean | undefined;
 }
 export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
   def: $ZodURLDef;
@@ -432,10 +427,9 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
     try {
-      // Trim whitespace from input
-      const trimmed = payload.value.trim();
-      // @ts-ignore
-      const url = new URL(trimmed);
+      const orig = payload.value;
+      const url = new URL(orig);
+      const href = url.href;
 
       if (def.hostname) {
         def.hostname.lastIndex = 0;
@@ -467,13 +461,11 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
         }
       }
 
-      // Set the output value based on normalize flag
-      if (def.normalize) {
-        // Use normalized URL
-        payload.value = url.href;
+      // payload.value = url.href;
+      if (!orig.endsWith("/") && href.endsWith("/")) {
+        payload.value = href.slice(0, -1);
       } else {
-        // Preserve the original input (trimmed)
-        payload.value = trimmed;
+        payload.value = href;
       }
 
       return;
@@ -727,7 +719,6 @@ export const $ZodIPv6: core.$constructor<$ZodIPv6> = /*@__PURE__*/ core.$constru
 
   inst._zod.check = (payload) => {
     try {
-      // @ts-ignore
       new URL(`http://[${payload.value}]`);
       // return;
     } catch {
@@ -791,7 +782,6 @@ export const $ZodCIDRv6: core.$constructor<$ZodCIDRv6> = /*@__PURE__*/ core.$con
         const prefixNum = Number(prefix);
         if (`${prefixNum}` !== prefix) throw new Error();
         if (prefixNum < 0 || prefixNum > 128) throw new Error();
-        // @ts-ignore
         new URL(`http://[${address}]`);
       } catch {
         payload.issues.push({
@@ -811,7 +801,6 @@ export function isValidBase64(data: string): boolean {
   if (data === "") return true;
   if (data.length % 4 !== 0) return false;
   try {
-    // @ts-ignore
     atob(data);
     return true;
   } catch {
@@ -911,7 +900,6 @@ export function isValidJWT(token: string, algorithm: util.JWTAlgorithm | null =
     if (tokensParts.length !== 3) return false;
     const [header] = tokensParts;
     if (!header) return false;
-    // @ts-ignore
     const parsedHeader = JSON.parse(atob(header));
     if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
     if (!parsedHeader.alg) return false;
@@ -1042,7 +1030,6 @@ export const $ZodNumber: core.$constructor<$ZodNumber> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "number",
       code: "invalid_type",
-
       input,
       inst,
       ...(received ? { received } : {}),
@@ -1113,7 +1100,6 @@ export const $ZodBoolean: core.$constructor<$ZodBoolean> = /*@__PURE__*/ core.$c
       payload.issues.push({
         expected: "boolean",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -1166,7 +1152,6 @@ export const $ZodBigInt: core.$constructor<$ZodBigInt> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "bigint",
       code: "invalid_type",
-
       input: payload.value,
       inst,
     });
@@ -1226,7 +1211,6 @@ export const $ZodSymbol: core.$constructor<$ZodSymbol> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "symbol",
       code: "invalid_type",
-
       input,
       inst,
     });
@@ -1271,7 +1255,6 @@ export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ cor
       payload.issues.push({
         expected: "undefined",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -1314,7 +1297,6 @@ export const $ZodNull: core.$constructor<$ZodNull> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "null",
       code: "invalid_type",
-
       input,
       inst,
     });
@@ -1406,7 +1388,6 @@ export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$const
     payload.issues.push({
       expected: "never",
       code: "invalid_type",
-
       input: payload.value,
       inst,
     });
@@ -1444,7 +1425,6 @@ export const $ZodVoid: core.$constructor<$ZodVoid> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "void",
       code: "invalid_type",
-
       input,
       inst,
     });
@@ -1495,7 +1475,6 @@ export const $ZodDate: core.$constructor<$ZodDate> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
-
       input,
       ...(isDate ? { received: "Invalid Date" } : {}),
       inst,
@@ -1545,7 +1524,6 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
       payload.issues.push({
         expected: "array",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -1604,36 +1582,6 @@ export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<st
         } & Extra
       >;
 
-// experimental
-// export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = keyof (T &
-//   Extra) extends never
-//   ? Record<string, never>
-//   : string extends keyof T
-//     ? util.Prettify<
-//         {
-//           [k: string]: util.IsAny<T[string]["_zod"]["output"]> extends true ? unknown : T[string]["_zod"]["output"];
-//         } & $InferObjectOutputNoIndex<util.OmitIndexSignature<T>, Extra>
-//       >
-//     : util.Prettify<$InferObjectOutputNoIndex<T, Extra>>;
-
-// export type $InferObjectOutputNoIndex<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = {
-//   [k in keyof T as string extends k
-//     ? never
-//     : k extends string
-//       ? T[k] extends OptionalOutSchema
-//         ? never
-//         : k
-//       : never]: T[k]["_zod"]["output"];
-// } & {
-//   [k in keyof T as string extends k
-//     ? never
-//     : k extends string
-//       ? T[k] extends OptionalOutSchema
-//         ? k
-//         : never
-//       : never]?: T[k]["_zod"]["output"];
-// } & Extra;
-
 export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
   ? util.IsAny<T[keyof T]> extends true
     ? Record<string, unknown>
@@ -1648,16 +1596,33 @@ export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<str
         } & Extra
       >;
 
-function handlePropertyResult(result: ParsePayload, final: ParsePayload, key: PropertyKey, input: any) {
+function handleObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey) {
+  // if(isOptional)
   if (result.issues.length) {
     final.issues.push(...util.prefixIssues(key, result.issues));
   }
 
-  if (result.value === undefined) {
-    if (key in input) {
-      (final.value as any)[key] = undefined;
+  (final.value as any)[key] = result.value;
+}
+
+function handleOptionalObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey, input: any) {
+  if (result.issues.length) {
+    // validation failed against value schema
+    if (input[key] === undefined) {
+      // if input was undefined, ignore the error
+      if (key in input) {
+        (final.value as any)[key] = undefined;
+      } else {
+        (final.value as any)[key] = result.value;
+      }
+    } else {
+      final.issues.push(...util.prefixIssues(key, result.issues));
     }
+  } else if (result.value === undefined) {
+    // validation returned `undefined`
+    if (key in input) (final.value as any)[key] = undefined;
   } else {
+    // non-undefined value
     (final.value as any)[key] = result.value;
   }
 }
@@ -1701,8 +1666,6 @@ export interface $ZodObjectInternals<
   propValues: util.PropValues;
   output: $InferObjectOutput<Shape, Config["out"]>;
   input: $InferObjectInput<Shape, Config["in"]>;
-  optin?: "optional" | undefined;
-  optout?: "optional" | undefined;
 }
 export type $ZodLooseShape = Record<string, any>;
 
@@ -1769,25 +1732,41 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
     // A: preserve key order {
     doc.write(`const newResult = {}`);
     for (const key of normalized.keys) {
-      const id = ids[key];
-      const k = util.esc(key);
-      doc.write(`const ${id} = ${parseStr(key)};`);
-      doc.write(`
+      if (normalized.optionalKeys.has(key)) {
+        const id = ids[key];
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        const k = util.esc(key);
+        doc.write(`
         if (${id}.issues.length) {
-          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
-            ...iss,
-            path: iss.path ? [${k}, ...iss.path] : [${k}]
-          })));
-        }
-        
-        if (${id}.value === undefined) {
-          if (${k} in input) {
-            newResult[${k}] = undefined;
+          if (input[${k}] === undefined) {
+            if (${k} in input) {
+              newResult[${k}] = undefined;
+            }
+          } else {
+            payload.issues = payload.issues.concat(
+              ${id}.issues.map((iss) => ({
+                ...iss,
+                path: iss.path ? [${k}, ...iss.path] : [${k}],
+              }))
+            );
           }
+        } else if (${id}.value === undefined) {
+          if (${k} in input) newResult[${k}] = undefined;
         } else {
           newResult[${k}] = ${id}.value;
         }
-      `);
+        `);
+      } else {
+        const id = ids[key];
+        //  const id = ids[key];
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        doc.write(`
+          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${util.esc(key)}, ...iss.path] : [${util.esc(key)}]
+          })));`);
+        doc.write(`newResult[${util.esc(key)}] = ${id}.value`);
+      }
     }
 
     doc.write(`payload.value = newResult;`);
@@ -1814,7 +1793,6 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -1833,16 +1811,39 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
       const shape = value.shape;
       for (const key of value.keys) {
         const el = shape[key]!;
+
+        // do not add omitted optional keys
+        // if (!(key in input)) {
+        //   if (optionalKeys.has(key)) continue;
+        //   payload.issues.push({
+        //     code: "invalid_type",
+        //     path: [key],
+        //     expected: "nonoptional",
+        //     note: `Missing required key: "${key}"`,
+        //     input,
+        //     inst,
+        //   });
+        // }
+
         const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+        const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
+
         if (r instanceof Promise) {
-          proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+          proms.push(
+            r.then((r) =>
+              isOptional ? handleOptionalObjectResult(r, payload, key, input) : handleObjectResult(r, payload, key)
+            )
+          );
+        } else if (isOptional) {
+          handleOptionalObjectResult(r, payload, key, input);
         } else {
-          handlePropertyResult(r, payload, key, input);
+          handleObjectResult(r, payload, key);
         }
       }
     }
 
     if (!catchall) {
+      // return payload;
       return proms.length ? Promise.all(proms).then(() => payload) : payload;
     }
     const unrecognized: string[] = [];
@@ -1859,16 +1860,15 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
       const r = _catchall.run({ value: input[key], issues: [] }, ctx);
 
       if (r instanceof Promise) {
-        proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+        proms.push(r.then((r) => handleObjectResult(r, payload, key)));
       } else {
-        handlePropertyResult(r, payload, key, input);
+        handleObjectResult(r, payload, key);
       }
     }
 
     if (unrecognized.length) {
       payload.issues.push({
         code: "unrecognized_keys",
-
         keys: unrecognized,
         input,
         inst,
@@ -1925,15 +1925,8 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
     }
   }
 
-  const nonaborted = results.filter((r) => !util.aborted(r));
-  if (nonaborted.length === 1) {
-    final.value = nonaborted[0].value;
-    return nonaborted[0];
-  }
-
   final.issues.push({
     code: "invalid_union",
-
     input: final.value,
     inst,
     errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
@@ -1968,13 +1961,7 @@ export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$const
     return undefined;
   });
 
-  const single = def.options.length === 1;
-  const first = def.options[0]._zod.run;
-
   inst._zod.parse = (payload, ctx) => {
-    if (single) {
-      return first(payload, ctx);
-    }
     let async = false;
 
     const results: util.MaybeAsync<ParsePayload>[] = [];
@@ -2052,7 +2039,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       const opts = def.options as $ZodTypeDiscriminable[];
       const map: Map<util.Primitive, $ZodType> = new Map();
       for (const o of opts) {
-        const values = o._zod.propValues?.[def.discriminator];
+        const values = o._zod.propValues[def.discriminator];
         if (!values || values.size === 0)
           throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
         for (const v of values) {
@@ -2070,7 +2057,6 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       if (!util.isObject(input)) {
         payload.issues.push({
           code: "invalid_type",
-
           expected: "object",
           input,
           inst,
@@ -2090,10 +2076,8 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       // no matching discriminator
       payload.issues.push({
         code: "invalid_union",
-
         errors: [],
         note: "No matching discriminator",
-        discriminator: def.discriminator,
         input,
         path: [def.discriminator],
         inst,
@@ -2119,14 +2103,11 @@ export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right ext
 }
 
 export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType>
-  extends _$ZodTypeInternals {
-  // $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>>
+  extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
   def: $ZodIntersectionDef<A, B>;
   isst: never;
   optin: A["_zod"]["optin"] | B["_zod"]["optin"];
   optout: A["_zod"]["optout"] | B["_zod"]["optout"];
-  output: core.output<A> & core.output<B>;
-  input: core.input<A> & core.input<B>;
 }
 
 export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
@@ -2284,12 +2265,9 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
 export interface $ZodTupleInternals<
   T extends util.TupleItems = readonly $ZodType[],
   Rest extends SomeType | null = $ZodType | null,
-> extends _$ZodTypeInternals {
+> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
   def: $ZodTupleDef<T, Rest>;
   isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
-  // $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>>
-  output: $InferTupleOutputType<T, Rest>;
-  input: $InferTupleInputType<T, Rest>;
 }
 
 export interface $ZodTuple<
@@ -2324,11 +2302,10 @@ export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$const
       const tooSmall = input.length < optStart - 1;
       if (tooBig || tooSmall) {
         payload.issues.push({
-          ...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
-
           input,
           inst,
           origin: "array" as const,
+          ...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
         });
         return payload;
       }
@@ -2463,7 +2440,6 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -2507,7 +2483,6 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
       if (unrecognized && unrecognized.length > 0) {
         payload.issues.push({
           code: "unrecognized_keys",
-
           input,
           inst,
           keys: unrecognized,
@@ -2525,9 +2500,8 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
 
         if (keyResult.issues.length) {
           payload.issues.push({
-            code: "invalid_key",
-
             origin: "record",
+            code: "invalid_key",
             issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
             input: key,
             path: [key],
@@ -2598,7 +2572,6 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
       payload.issues.push({
         expected: "map",
         code: "invalid_type",
-
         input,
         inst,
       });
@@ -2642,9 +2615,8 @@ function handleMapResult(
       final.issues.push(...util.prefixIssues(key as PropertyKey, keyResult.issues));
     } else {
       final.issues.push({
-        code: "invalid_key",
-
         origin: "map",
+        code: "invalid_key",
         input,
         inst,
         issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
@@ -2658,7 +2630,6 @@ function handleMapResult(
       final.issues.push({
         origin: "map",
         code: "invalid_element",
-
         input,
         inst,
         key: key,
@@ -2766,8 +2737,8 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
   $ZodType.init(inst, def);
 
   const values = util.getEnumValues(def.entries);
-  const valuesSet = new Set<util.Primitive>(values);
-  inst._zod.values = valuesSet;
+
+  inst._zod.values = new Set<util.Primitive>(values);
 
   inst._zod.pattern = new RegExp(
     `^(${values
@@ -2778,12 +2749,11 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
 
   inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
-    if (valuesSet.has(input)) {
+    if (inst._zod.values.has(input)) {
       return payload;
     }
     payload.issues.push({
       code: "invalid_value",
-
       values,
       input,
       inst,
@@ -2820,15 +2790,12 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
   "$ZodLiteral",
   (inst, def) => {
     $ZodType.init(inst, def);
-    if (def.values.length === 0) {
-      throw new Error("Cannot create literal schema with no valid values");
-    }
 
     inst._zod.values = new Set<util.Literal>(def.values);
     inst._zod.pattern = new RegExp(
       `^(${def.values
 
-        .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))
+        .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? o.toString() : String(o)))
         .join("|")})$`
     );
 
@@ -2839,7 +2806,6 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
       }
       payload.issues.push({
         code: "invalid_value",
-
         values: def.values,
         input,
         inst,
@@ -2899,11 +2865,8 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
 //////////////////////////////////////////
 
 // provide a fallback in case the File interface isn't provided in the environment
-type _File = typeof globalThis extends { File: infer F extends new (...args: any[]) => any } ? InstanceType<F> : {};
-/** Do not reference this directly. */
-export interface File extends _File {
-  readonly type: string;
-  readonly size: number;
+declare global {
+  interface File {}
 }
 
 export interface $ZodFileDef extends $ZodTypeDef {
@@ -2929,12 +2892,10 @@ export const $ZodFile: core.$constructor<$ZodFile> = /*@__PURE__*/ core.$constru
 
   inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
-    // @ts-ignore
     if (input instanceof File) return payload;
     payload.issues.push({
       expected: "file",
       code: "invalid_type",
-
       input,
       inst,
     });
@@ -3012,13 +2973,6 @@ export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodOptionalInternals<T>;
 }
 
-function handleOptionalResult(result: ParsePayload, input: unknown) {
-  if (result.issues.length && input === undefined) {
-    return { issues: [], value: undefined };
-  }
-  return result;
-}
-
 export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.$constructor(
   "$ZodOptional",
   (inst, def) => {
@@ -3036,9 +2990,7 @@ export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.
 
     inst._zod.parse = (payload, ctx) => {
       if (def.innerType._zod.optin === "optional") {
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
-        return handleOptionalResult(result, payload.value);
+        return def.innerType._zod.run(payload, ctx);
       }
       if (payload.value === undefined) {
         return payload;
@@ -3252,7 +3204,6 @@ function handleNonOptionalResult(payload: ParsePayload, inst: $ZodNonOptional) {
   if (!payload.issues.length && payload.value === undefined) {
     payload.issues.push({
       code: "invalid_type",
-
       expected: "nonoptional",
       input: payload.value,
       inst,
@@ -3363,8 +3314,11 @@ export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef
 }
 
 export interface $ZodCatchInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<T>, core.input<T>> {
+  extends $ZodTypeInternals<core.output<T>, core.input<T> | util.Whatever> {
   def: $ZodCatchDef<T>;
+  // qin: T["_zod"]["qin"];
+  // qout: T["_zod"]["qout"];
+
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
   isst: never;
@@ -3377,7 +3331,7 @@ export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
 
 export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
   $ZodType.init(inst, def);
-  util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  inst._zod.optin = "optional";
   util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 
@@ -3410,7 +3364,6 @@ export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$const
         },
         input: payload.value,
       });
-
       payload.issues = [];
     }
 
@@ -3475,7 +3428,6 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
   values: A["_zod"]["values"];
   optin: A["_zod"]["optin"];
   optout: B["_zod"]["optout"];
-  propValues: A["_zod"]["propValues"];
 }
 
 export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
@@ -3487,7 +3439,6 @@ export const $ZodPipe: core.$constructor<$ZodPipe> = /*@__PURE__*/ core.$constru
   util.defineLazy(inst._zod, "values", () => def.in._zod.values);
   util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
   util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
-  util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
 
   inst._zod.parse = (payload, ctx) => {
     const left = def.in._zod.run(payload, ctx);
@@ -3499,7 +3450,7 @@ export const $ZodPipe: core.$constructor<$ZodPipe> = /*@__PURE__*/ core.$constru
 });
 
 function handlePipeResult(left: ParsePayload, def: $ZodPipeDef, ctx: ParseContext) {
-  if (left.issues.length) {
+  if (util.aborted(left)) {
     return left;
   }
   return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
@@ -3567,7 +3518,6 @@ function handleReadonlyResult(payload: ParsePayload): ParsePayload {
 export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
   type: "template_literal";
   parts: $ZodTemplateLiteralPart[];
-  format?: string | undefined;
 }
 export interface $ZodTemplateLiteralInternals<Template extends string = string>
   extends $ZodTypeInternals<Template, Template> {
@@ -3673,9 +3623,8 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
         payload.issues.push({
           input: payload.value,
           inst,
-
           code: "invalid_format",
-          format: def.format ?? "template_literal",
+          format: "template_literal",
           pattern: inst._zod.pattern.source,
         });
         return payload;
@@ -3751,18 +3700,11 @@ export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
 export const $ZodLazy: core.$constructor<$ZodLazy> = /*@__PURE__*/ core.$constructor("$ZodLazy", (inst, def) => {
   $ZodType.init(inst, def);
 
-  // let _innerType!: any;
-  // util.defineLazy(def, "getter", () => {
-  //   if (!_innerType) {
-  //     _innerType = def.getter();
-  //   }
-  //   return () => _innerType;
-  // });
   util.defineLazy(inst._zod, "innerType", () => def.getter() as $ZodType);
   util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
   util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
-  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
+  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
+  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
   inst._zod.parse = (payload, ctx) => {
     const inner = inst._zod.innerType;
     return inner._zod.run(payload, ctx);