fullstacked 0.12.0-1273 → 0.12.0-1291

package/fullstacked_modules/ai/tools/fs.ts

@@ -25,7 +25,12 @@ export function createToolFS(opts?: Partial<ToolFSOptions>) {
             schema: z.object({
                 path: z.string()
             }),
-            fn: ({ path }) => fs.mkdir(fixPath(path)),
+            fn: async ({ path }) => {
+                const success = await fs.mkdir(fixPath(path));
+                return success
+                    ? `Successfully created directory ${path}.`
+                    : `Failed to create directory ${path}.`;
+            },
             message: ({ path }) => `Creating directory \`${path}\``
         }),
         createTool({
@@ -53,7 +58,12 @@ export function createToolFS(opts?: Partial<ToolFSOptions>) {
                 path: z.string(),
                 contents: z.string()
             }),
-            fn: ({ path, contents }) => fs.writeFile(fixPath(path), contents),
+            fn: async ({ path, contents }) => {
+                const success = await fs.writeFile(fixPath(path), contents);
+                return success
+                    ? `Successfully written ${contents.length} characters to ${path}.`
+                    : `Failed to write to ${path}.`;
+            },
             message: ({ path }) => `Writing to \`${path}\``
         })
     ];

package/fullstacked_modules/fetch/index.ts

@@ -7,6 +7,7 @@ import {
 } from "../bridge/serialization";
 import core_message from "../core_message";
 import { ar } from "zod/v4/locales";
+import platform, { Platform } from "../platform";
 
 const te = new TextEncoder();
 
@@ -122,14 +123,44 @@ export default function core_fetch(
     });
 }
 
-const activeFetch2Requests = new Map<
-    number,
-    {
-        url: string;
-        resolveResponse(response: Response): void;
-        resolveStream?(param: { done: boolean; chunk: Uint8Array }): void;
-    }
->();
+type ActiveRequest = {
+    url: string;
+    resolveResponse(response: Response): void;
+    resolveStream?: (param: { done: boolean; chunk: Uint8Array }) => void;
+};
+
+const activeFetch2Requests = new Map<number, ActiveRequest>();
+
+// in WASM everything in synchronous and calling
+// resolveStream on the next event loop assures the promise is well set
+//
+// this is call at a very high pace, so it's better to avoid the "if" at every streamed bit
+const processStream =
+    platform === Platform.WASM
+        ? function (
+              id: number,
+              request: ActiveRequest,
+              done: boolean,
+              chunk: Uint8Array
+          ) {
+              setTimeout(() => {
+                  request.resolveStream({ done, chunk });
+                  if (done) {
+                      activeFetch2Requests.delete(id);
+                  }
+              });
+          }
+        : function (
+              id: number,
+              request: ActiveRequest,
+              done: boolean,
+              chunk: Uint8Array
+          ) {
+              request.resolveStream({ done, chunk });
+              if (done) {
+                  activeFetch2Requests.delete(id);
+              }
+          };
 
 let addedListener2 = false;
 function receivedResponse2(base64Data: string) {
@@ -143,10 +174,7 @@ function receivedResponse2(base64Data: string) {
 
     if (request.resolveStream) {
         const [done, chunk] = args.slice(1);
-        request.resolveStream({ done, chunk });
-        if (done) {
-            activeFetch2Requests.delete(id);
-        }
+        processStream(id, request, done, chunk);
         return;
     }
 
@@ -154,7 +182,7 @@ function receivedResponse2(base64Data: string) {
 
     const ok = status <= 299;
 
-    let finished = false;
+    let finished = statusText === "Failed fetch";
     const read = async () => {
         if (finished) {
             return { done: true };
@@ -182,9 +210,6 @@ function receivedResponse2(base64Data: string) {
     };
 
     const readBody = async () => {
-        if (!ok) {
-            return te.encode(statusText) as Uint8Array<ArrayBuffer>;
-        }
         let body = new Uint8Array();
         for await (const chunk of responseIterator) {
             const buffer = new Uint8Array(body.byteLength + chunk.byteLength);

package/fullstacked_modules/fs/fs.ts

@@ -32,7 +32,7 @@ export function writeFile(
 
     const payload = new Uint8Array([3, ...serializeArgs([path, data, origin])]);
 
-    return bridge(payload, ([success]) => success);
+    return bridge(payload, ([errMessage]) => !errMessage);
 }
 
 // 4

package/fullstacked_modules/zod/README.md

@@ -10,7 +10,7 @@
 <br/>
 
 <p align="center">
-<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amain"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Zod CI status" /></a>
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amaster"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
 <a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
 <a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
 <a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
@@ -58,7 +58,7 @@
 Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
 
 ```ts
-import * as z from "zod";
+import * as z from "zod/v4";
 
 const User = z.object({
   name: z.string(),
@@ -104,7 +104,7 @@ npm install zod
 Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
 
 ```ts
-import * as z from "zod";
+import * as z from "zod/v4";
 
 const Player = z.object({
   username: z.string(),

package/fullstacked_modules/zod/index.d.cts

@@ -1,4 +1,4 @@
-import * as z from "./v4/classic/external.cjs";
-export * from "./v4/classic/external.cjs";
+import * as z from "./v3/external.cjs";
+export * from "./v3/external.cjs";
 export { z };
 export default z;

package/fullstacked_modules/zod/index.d.ts

@@ -1,4 +1,4 @@
-import * as z from "./v4/classic/external.js";
-export * from "./v4/classic/external.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/fullstacked_modules/zod/package.json

@@ -1,16 +1,9 @@
 {
   "name": "zod",
-  "version": "4.0.14",
+  "version": "3.25.76",
   "type": "module",
-  "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
-  "homepage": "https://zod.dev",
-  "llms": "https://zod.dev/llms.txt",
-  "llmsFull": "https://zod.dev/llms-full.txt",
-  "mcpServer": "https://mcp.inkeep.com/zod/mcp",
-  "funding": "https://github.com/sponsors/colinhacks",
-  "sideEffects": false,
   "files": [
     "src",
     "**/*.js",
@@ -20,6 +13,8 @@
     "**/*.d.mts",
     "**/*.d.cts"
   ],
+  "funding": "https://github.com/sponsors/colinhacks",
+  "homepage": "https://zod.dev",
   "keywords": [
     "typescript",
     "schema",
@@ -27,6 +22,8 @@
     "type",
     "inference"
   ],
+  "license": "MIT",
+  "sideEffects": false,
   "main": "./index.cjs",
   "types": "./index.d.cts",
   "module": "./index.js",
@@ -34,8 +31,6 @@
     "exports": {
       "./package.json": "./package.json",
       ".": "./src/index.ts",
-      "./mini": "./src/mini/index.ts",
-      "./locales": "./src/locales/index.ts",
       "./v3": "./src/v3/index.ts",
       "./v4": "./src/v4/index.ts",
       "./v4-mini": "./src/v4-mini/index.ts",
@@ -44,9 +39,9 @@
       "./v4/locales": "./src/v4/locales/index.ts",
       "./v4/locales/*": "./src/v4/locales/*"
     },
-    "conditions": {
-      "@zod/source": "src"
-    }
+    "sourceDialects": [
+      "@zod/source"
+    ]
   },
   "exports": {
     "./package.json": "./package.json",
@@ -56,18 +51,6 @@
       "import": "./index.js",
       "require": "./index.cjs"
     },
-    "./mini": {
-      "@zod/source": "./src/mini/index.ts",
-      "types": "./mini/index.d.cts",
-      "import": "./mini/index.js",
-      "require": "./mini/index.cjs"
-    },
-    "./locales": {
-      "@zod/source": "./src/locales/index.ts",
-      "types": "./locales/index.d.cts",
-      "import": "./locales/index.js",
-      "require": "./locales/index.cjs"
-    },
     "./v3": {
       "@zod/source": "./src/v3/index.ts",
       "types": "./v3/index.d.cts",
@@ -129,6 +112,7 @@
     "postbuild": "pnpm biome check --write .",
     "test:watch": "pnpm vitest",
     "test": "pnpm vitest run",
-    "prepublishOnly": "tsx ../../scripts/check-versions.ts"
+    "bump:beta": "pnpm version \"v$(pnpm pkg get version | jq -r)-beta.$(date +%Y%m%dT%H%M%S)\"",
+    "pub:beta": "pnpm bump:beta && pnpm publish --tag next --publish-branch v4 --no-git-checks --dry-run"
   }
 }

package/fullstacked_modules/zod/src/index.ts

@@ -1,4 +1,4 @@
-import * as z from "./v4/classic/external.js";
-export * from "./v4/classic/external.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/fullstacked_modules/zod/src/v3/tests/string.test.ts

@@ -342,8 +342,8 @@ test("uuid", () => {
   uuid.parse("9491d710-3185-4e06-bea0-6a2f275345e0");
   uuid.parse("d89e7b01-7598-ed11-9d7a-0022489382fd"); // new sequential id
   uuid.parse("00000000-0000-0000-0000-000000000000");
-  uuid.parse("b3ce60f8-e8b9-40f5-1150-172ede56ff74"); // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
-  uuid.parse("92e76bf9-28b3-4730-cd7f-cb6bc51f8c09"); // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
+  uuid.parse("b3ce60f8-e8b9-40f5-1150-172ede56ff74"); // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
+  uuid.parse("92e76bf9-28b3-4730-cd7f-cb6bc51f8c09"); // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
   const result = uuid.safeParse("9491d710-3185-4e06-bea0-6a2f275345e0X");
   expect(result.success).toEqual(false);
   if (!result.success) {

package/fullstacked_modules/zod/src/v3/types.ts

@@ -705,7 +705,6 @@ function isValidJWT(jwt: string, alg?: string): boolean {
       .replace(/-/g, "+")
       .replace(/_/g, "/")
       .padEnd(header.length + ((4 - (header.length % 4)) % 4), "=");
-    // @ts-ignore
     const decoded = JSON.parse(atob(base64));
     if (typeof decoded !== "object" || decoded === null) return false;
     if ("typ" in decoded && decoded?.typ !== "JWT") return false;
@@ -876,7 +875,6 @@ export class ZodString extends ZodType<string, ZodStringDef, string> {
         }
       } else if (check.kind === "url") {
         try {
-          // @ts-ignore
           new URL(input.data);
         } catch {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -2456,7 +2454,7 @@ export class ZodObject<
   Output = objectOutputType<T, Catchall, UnknownKeys>,
   Input = objectInputType<T, Catchall, UnknownKeys>,
 > extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-  _cached: { shape: T; keys: string[] } | null = null;
+  private _cached: { shape: T; keys: string[] } | null = null;
 
   _getCached(): { shape: T; keys: string[] } {
     if (this._cached !== null) return this._cached;

package/fullstacked_modules/zod/src/v4/classic/checks.ts

@@ -27,5 +27,4 @@ export {
   _trim as trim,
   _toLowerCase as toLowerCase,
   _toUpperCase as toUpperCase,
-  type $RefinementCtx as RefinementCtx,
 } from "../core/index.js";

package/fullstacked_modules/zod/src/v4/classic/compat.ts

@@ -63,8 +63,4 @@ export type {
   ZodType as Schema,
 };
 
-/** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
-
-/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
-export enum ZodFirstPartyTypeKind {}

package/fullstacked_modules/zod/src/v4/classic/errors.ts

@@ -1,6 +1,5 @@
 import * as core from "../core/index.js";
 import { $ZodError } from "../core/index.js";
-import * as util from "../core/util.js";
 
 /** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
 export type ZodIssue = core.$ZodIssue;
@@ -35,17 +34,11 @@ const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
       // enumerable: false,
     },
     addIssue: {
-      value: (issue: any) => {
-        inst.issues.push(issue);
-        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
-      },
+      value: (issue: any) => inst.issues.push(issue),
       // enumerable: false,
     },
     addIssues: {
-      value: (issues: any) => {
-        inst.issues.push(...issues);
-        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
-      },
+      value: (issues: any) => inst.issues.push(...issues),
       // enumerable: false,
     },
     isEmpty: {

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

@@ -13,6 +13,10 @@ import * as parse from "./parse.js";
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 
+export interface RefinementCtx<T = unknown> extends core.ParsePayload<T> {
+  addIssue(arg: string | core.$ZodRawIssue | Partial<core.$ZodIssueCustom>): void;
+}
+
 export interface ZodType<
   out Output = unknown,
   out Input = unknown,
@@ -57,8 +61,9 @@ export interface ZodType<
 
   // refinements
   refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
+  /** @deprecated Use `.check()` instead. */
   superRefine(
-    refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>
+    refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>
   ): this;
   overwrite(fn: (x: core.output<this>) => core.output<this>): this;
 
@@ -75,7 +80,7 @@ export interface ZodType<
   or<T extends core.SomeType>(option: T): ZodUnion<[this, T]>;
   and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;
   transform<NewOut>(
-    transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
+    transform: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
   ): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
   catch(def: core.output<this>): ZodCatch<this>;
   catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;
@@ -693,10 +698,6 @@ export function stringFormat<Format extends string>(
   return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params) as any;
 }
 
-export function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname"> {
-  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
-}
-
 // ZodNumber
 export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals>
   extends _ZodType<Internals> {
@@ -1068,10 +1069,22 @@ export interface ZodObject<
   /** This is the default behavior. This method call is likely unnecessary. */
   strip(): ZodObject<Shape, core.$strip>;
 
-  extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
+  extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(
+    shape: U
+  ): ZodObject<util.Extend<Shape, U>, Config>;
 
   /**
-   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+   * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
+   *
+   * ```ts
+   * const A = z.object({ a: z.string() });
+   * const B = z.object({ b: z.number() });
+   *
+   * const C = z.object({
+   *    ...A.shape,
+   *    ...B.shape
+   * });
+   * ```
    */
   merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
 
@@ -1128,6 +1141,7 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
   inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)) as any;
   inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall as any as core.$ZodType }) as any;
   inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+  // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() });
   inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
   inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
   inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
@@ -1219,7 +1233,6 @@ export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[]
   extends ZodUnion<Options>,
     core.$ZodDiscriminatedUnion<Options> {
   _zod: core.$ZodDiscriminatedUnionInternals<Options>;
-  def: core.$ZodDiscriminatedUnionDef<Options>;
 }
 export const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(
   "ZodDiscriminatedUnion",
@@ -1347,11 +1360,9 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends core
   valueType: Value,
   params?: string | core.$ZodRecordParams
 ): ZodRecord<Key & core.$partial, Value> {
-  const k = core.clone(keyType);
-  k._zod.values = undefined;
   return new ZodRecord({
     type: "record",
-    keyType: k,
+    keyType: union([keyType, never()]),
     valueType: valueType as any,
     ...util.normalizeParams(params),
   }) as any;
@@ -1572,7 +1583,7 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
     ZodType.init(inst, def);
 
     inst._zod.parse = (payload, _ctx) => {
-      (payload as core.$RefinementCtx).addIssue = (issue) => {
+      (payload as RefinementCtx).addIssue = (issue) => {
         if (typeof issue === "string") {
           payload.issues.push(util.issue(issue, payload.value, def));
         } else {
@@ -1583,7 +1594,7 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
           _issue.code ??= "custom";
           _issue.input ??= payload.value;
           _issue.inst ??= inst;
-          // _issue.continue ??= true;
+          _issue.continue ??= true;
           payload.issues.push(util.issue(_issue));
         }
       };
@@ -1837,16 +1848,12 @@ export function pipe(in_: core.SomeType, out: core.SomeType) {
 // ZodReadonly
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType>
   extends _ZodType<core.$ZodReadonlyInternals<T>>,
-    core.$ZodReadonly<T> {
-  unwrap(): T;
-}
+    core.$ZodReadonly<T> {}
 export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$constructor(
   "ZodReadonly",
   (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
-
-    inst.unwrap = () => inst._zod.def.innerType;
   }
 );
 
@@ -1955,10 +1962,26 @@ export function refine<T>(
 }
 
 // superRefine
-export function superRefine<T>(
-  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>
-): core.$ZodCheck<T> {
-  return core._superRefine(fn);
+export function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T> {
+  const ch = check<T>((payload) => {
+    (payload as RefinementCtx).addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
+      } else {
+        // for Zod 3 backwards compatibility
+        const _issue: any = issue;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ??= "custom";
+        _issue.input ??= payload.value;
+        _issue.inst ??= ch;
+        _issue.continue ??= !ch._zod.def.abort;
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+
+    return fn(payload.value, payload as RefinementCtx<T>);
+  });
+  return ch;
 }
 
 type ZodInstanceOfParams = core.Params<
@@ -2024,7 +2047,7 @@ export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
 
 // /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
 export function preprocess<A, U extends core.SomeType, B = unknown>(
-  fn: (arg: B, ctx: core.$RefinementCtx) => A,
+  fn: (arg: B, ctx: RefinementCtx) => A,
   schema: U
 ): ZodPipe<ZodTransform<A, B>, U> {
   return pipe(transform(fn as any), schema as any) as any;

package/fullstacked_modules/zod/src/v4/classic/tests/catch.test.ts

@@ -1,5 +1,6 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
+import type { util } from "zod/v4/core";
 
 test("basic catch", () => {
   expect(z.string().catch("default").parse(undefined)).toBe("default");
@@ -44,7 +45,7 @@ test("catch with transform", () => {
   expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string>();
+  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string>();
 });
@@ -58,7 +59,7 @@ test("catch on existing optional", () => {
   expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<inp>().toEqualTypeOf<string | undefined | util.Whatever>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string | undefined>();
 });
@@ -67,7 +68,7 @@ test("optional on catch", () => {
   const stringWithDefault = z.string().catch("asdf").optional();
 
   type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
   type out = z.output<typeof stringWithDefault>;
   expectTypeOf<out>().toEqualTypeOf<string | undefined>();
 });
@@ -101,7 +102,7 @@ test("nested", () => {
     inner: "asdf",
   });
   type input = z.input<typeof outer>;
-  expectTypeOf<input>().toEqualTypeOf<{ inner: string }>();
+  expectTypeOf<input>().toEqualTypeOf<{ inner: string | util.Whatever } | util.Whatever>();
   type out = z.output<typeof outer>;
 
   expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();

package/fullstacked_modules/zod/src/v4/classic/tests/datetime.test.ts

@@ -62,12 +62,6 @@ test("datetime parsing with offset", () => {
   expect(() => datetimeOffset.parse("2020-10-14T17:42:29+03")).toThrow();
   expect(() => datetimeOffset.parse("tuna")).toThrow();
   expect(() => datetimeOffset.parse("2022-10-13T09:52:31.Z")).toThrow();
-
-  // Invalid offset tests
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+24:00")).toThrow(); // out of range hours
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:60")).toThrow(); // out of range minutes
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+1:30")).toThrow(); // single digit hours
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:")).toThrow(); // incomplete offset
 });
 
 test("datetime parsing with offset and precision 0", () => {

package/fullstacked_modules/zod/src/v4/classic/tests/discriminated-unions.test.ts

@@ -157,7 +157,6 @@ test("invalid discriminator value", () => {
         "code": "invalid_union",
         "errors": [],
         "note": "No matching discriminator",
-        "discriminator": "type",
         "path": [
           "type"
         ],
@@ -618,44 +617,3 @@ test("readonly literal discriminator", () => {
     discUnion.parse({ type: "c", a: "hello" });
   }).toThrow();
 });
-
-test("pipes", () => {
-  const schema = z
-    .object({
-      type: z.literal("foo"),
-    })
-    .transform((s) => ({ ...s, v: 2 }));
-
-  expect(schema._zod.propValues).toMatchInlineSnapshot(`
-    {
-      "type": Set {
-        "foo",
-      },
-    }
-  `);
-
-  const schema2 = z.object({
-    type: z.literal("bar"),
-  });
-
-  const combinedSchema = z.discriminatedUnion("type", [schema, schema2], {
-    unionFallback: false,
-  });
-
-  combinedSchema.parse({
-    type: "foo",
-    v: 2,
-  });
-});
-
-test("def", () => {
-  const schema = z.discriminatedUnion(
-    "type",
-    [z.object({ type: z.literal("play") }), z.object({ type: z.literal("pause") })],
-    { unionFallback: true }
-  );
-
-  expect(schema.def).toBeDefined();
-  expect(schema.def.discriminator).toEqual("type");
-  expect(schema.def.unionFallback).toEqual(true);
-});