fullstacked 0.12.0-1272 → 0.12.0-1290

package/fullstacked_modules/esbuild/sass.ts

@@ -71,7 +71,7 @@ export async function buildSASS(
                         contents
                     };
                 },
-                canonicalize: (path) => new URL(path, window.location.href)
+                canonicalize: (path) => new URL(path, "http://localhost")
             }
         });
     } catch (e) {

package/fullstacked_modules/fetch/index.ts

@@ -154,7 +154,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 +182,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/sass/index.js

@@ -32517,7 +32517,7 @@ _cliPkgExports.load = function(_cliPkgRequires, _cliPkgExportParam) {
         J.set$deprecations$x(self2.exports, A.jsify($.$get$deprecations()));
         J.set$Version$x(self2.exports, $.$get$versionClass());
         J.set$loadParserExports_$x(self2.exports, A.allowInterop(A.parser0__loadParserExports$closure()));
-        J.set$info$x(self2.exports, "dart-sass	1.93.0	(Sass Compiler)	[Dart]\ndart2js	3.9.3	(Dart Compiler)	[Dart]");
+        J.set$info$x(self2.exports, "dart-sass	1.93.2	(Sass Compiler)	[Dart]\ndart2js	3.9.3	(Dart Compiler)	[Dart]");
         A.updateCanonicalizeContextPrototype();
         A.updateSourceSpanPrototype();
         J.set$render$x(self2.exports, A.allowInteropNamed("sass.render", A.legacy__render$closure()));
@@ -37488,7 +37488,7 @@ _cliPkgExports.load = function(_cliPkgRequires, _cliPkgExportParam) {
           while (true)
             switch ($async$goto) {
               case 0:
-                $async$returnValue = "1.93.0 compiled with dart2js 3.9.3";
+                $async$returnValue = "1.93.2 compiled with dart2js 3.9.3";
                 $async$goto = 1;
                 break;
               case 1:
@@ -55146,7 +55146,7 @@ _cliPkgExports.load = function(_cliPkgRequires, _cliPkgExportParam) {
           }
           try {
             argVersion = A.Version_Version$parse(id);
-            sassVersion = A.Version_Version$parse("1.93.0");
+            sassVersion = A.Version_Version$parse("1.93.2");
             if (J.compareTo$1$ns(argVersion, sassVersion) > 0)
               A.ExecutableOptions__fail("Invalid version " + A.S(argVersion) + ". --fatal-deprecation requires a version less than or equal to the current Dart Sass version.");
             J.addAll$1$ax(deprecations2, A.Deprecation_forVersion(argVersion));

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);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/error-utils.test.ts

@@ -321,7 +321,7 @@ test("all errors", () => {
 });
 
 const schema = z.strictObject({
-  username: z.string().brand<"username">(),
+  username: z.string(),
   favoriteNumbers: z.array(z.number()),
   nesting: z.object({
     a: z.string(),
@@ -336,33 +336,8 @@ const result = schema.safeParse({
   extra: 1234,
 });
 
-const tree = z.treeifyError(result.error!);
-
-expectTypeOf(tree).toEqualTypeOf<{
-  errors: string[];
-  properties?: {
-    username?: {
-      errors: string[];
-    };
-    favoriteNumbers?: {
-      errors: string[];
-      items?: {
-        errors: string[];
-      }[];
-    };
-    nesting?: {
-      errors: string[];
-      properties?: {
-        a?: {
-          errors: string[];
-        };
-      };
-    };
-  };
-}>();
-
 test("z.treeifyError", () => {
-  expect(tree).toMatchInlineSnapshot(`
+  expect(z.treeifyError(result.error!)).toMatchInlineSnapshot(`
     {
       "errors": [
         "Unrecognized key: "extra"",
@@ -550,46 +525,3 @@ test("disc union treeify/format", () => {
     }
   `);
 });
-
-test("update message after adding issues", () => {
-  const e = new z.ZodError([]);
-  e.addIssue({
-    code: "custom",
-    message: "message",
-    input: "asdf",
-    path: [],
-  });
-  expect(e.message).toMatchInlineSnapshot(`
-    "[
-      {
-        "code": "custom",
-        "message": "message",
-        "input": "asdf",
-        "path": []
-      }
-    ]"
-  `);
-
-  e.addIssue({
-    code: "custom",
-    message: "message",
-    input: "asdf",
-    path: [],
-  });
-  expect(e.message).toMatchInlineSnapshot(`
-    "[
-      {
-        "code": "custom",
-        "message": "message",
-        "input": "asdf",
-        "path": []
-      },
-      {
-        "code": "custom",
-        "message": "message",
-        "input": "asdf",
-        "path": []
-      }
-    ]"
-  `);
-});

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

@@ -1,6 +1,7 @@
+// @ts-ignore
 import { File as WebFile } from "@web-std/file";
 
-import { afterEach, beforeEach, expect, expectTypeOf, test } from "vitest";
+import { afterEach, beforeEach, expect, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -26,10 +27,6 @@ test("passing validations", () => {
   expect(() => mimeCheck.parse(new File([""], "test.txt", { type: "text/csv" }))).toThrow();
 });
 
-test("types", () => {
-  expectTypeOf(z.file().parse(new File([], "test.txt"))).toEqualTypeOf(new File([], "test.txt"));
-});
-
 test("failing validations", () => {
   expect(minCheck.safeParse(new File(["1234"], "test.txt"))).toMatchInlineSnapshot(`
     {