fullstacked 0.12.0-1273 → 0.12.0-1290

package/fullstacked_modules/zod/src/v4/core/to-json-schema.ts

@@ -10,9 +10,8 @@ interface JSONSchemaGeneratorParams {
   metadata?: $ZodRegistry<Record<string, any>>;
   /** The JSON Schema version to target.
    * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
-   * - `"draft-7"` — JSON Schema Draft 7
-   * - `"draft-4"` — JSON Schema Draft 4 */
-  target?: "draft-4" | "draft-7" | "draft-2020-12";
+   * - `"draft-7"` — JSON Schema Draft 7 */
+  target?: "draft-7" | "draft-2020-12";
   /** How to handle unrepresentable types.
    * - `"throw"` — Default. Unrepresentable types throw an error
    * - `"any"` — Unrepresentable types become `{}` */
@@ -72,7 +71,7 @@ interface Seen {
 
 export class JSONSchemaGenerator {
   metadataRegistry: $ZodRegistry<Record<string, any>>;
-  target: "draft-4" | "draft-7" | "draft-2020-12";
+  target: "draft-7" | "draft-2020-12";
   unrepresentable: "throw" | "any";
   override: (ctx: {
     zodSchema: schemas.$ZodTypes;
@@ -164,7 +163,7 @@ export class JSONSchemaGenerator {
               else if (regexes.length > 1) {
                 result.schema.allOf = [
                   ...regexes.map((regex) => ({
-                    ...(this.target === "draft-7" || this.target === "draft-4" ? ({ type: "string" } as const) : {}),
+                    ...(this.target === "draft-7" ? ({ type: "string" } as const) : {}),
                     pattern: regex.source,
                   })),
                 ];
@@ -179,33 +178,19 @@ export class JSONSchemaGenerator {
             if (typeof format === "string" && format.includes("int")) json.type = "integer";
             else json.type = "number";
 
-            if (typeof exclusiveMinimum === "number") {
-              if (this.target === "draft-4") {
-                json.minimum = exclusiveMinimum;
-                json.exclusiveMinimum = true;
-              } else {
-                json.exclusiveMinimum = exclusiveMinimum;
-              }
-            }
+            if (typeof exclusiveMinimum === "number") json.exclusiveMinimum = exclusiveMinimum;
             if (typeof minimum === "number") {
               json.minimum = minimum;
-              if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
+              if (typeof exclusiveMinimum === "number") {
                 if (exclusiveMinimum >= minimum) delete json.minimum;
                 else delete json.exclusiveMinimum;
               }
             }
 
-            if (typeof exclusiveMaximum === "number") {
-              if (this.target === "draft-4") {
-                json.maximum = exclusiveMaximum;
-                json.exclusiveMaximum = true;
-              } else {
-                json.exclusiveMaximum = exclusiveMaximum;
-              }
-            }
+            if (typeof exclusiveMaximum === "number") json.exclusiveMaximum = exclusiveMaximum;
             if (typeof maximum === "number") {
               json.maximum = maximum;
-              if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
+              if (typeof exclusiveMaximum === "number") {
                 if (exclusiveMaximum <= maximum) delete json.maximum;
                 else delete json.exclusiveMaximum;
               }
@@ -394,12 +379,7 @@ export class JSONSchemaGenerator {
           case "record": {
             const json: JSONSchema.ObjectSchema = _json as any;
             json.type = "object";
-            if (this.target !== "draft-4") {
-              json.propertyNames = this.process(def.keyType, {
-                ...params,
-                path: [...params.path, "propertyNames"],
-              });
-            }
+            json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
             json.additionalProperties = this.process(def.valueType, {
               ...params,
               path: [...params.path, "additionalProperties"],
@@ -452,11 +432,7 @@ export class JSONSchemaGenerator {
             } else if (vals.length === 1) {
               const val = vals[0]!;
               json.type = val === null ? ("null" as const) : (typeof val as any);
-              if (this.target === "draft-4") {
-                json.enum = [val];
-              } else {
-                json.const = val;
-              }
+              json.const = val;
             } else {
               if (vals.every((v) => typeof v === "number")) json.type = "number";
               if (vals.every((v) => typeof v === "string")) json.type = "string";
@@ -773,7 +749,7 @@ export class JSONSchemaGenerator {
 
         // merge referenced schema into current
         const refSchema = this.seen.get(ref)!.schema;
-        if (refSchema.$ref && (params.target === "draft-7" || params.target === "draft-4")) {
+        if (refSchema.$ref && params.target === "draft-7") {
           schema.allOf = schema.allOf ?? [];
           schema.allOf.push(refSchema);
         } else {
@@ -800,10 +776,7 @@ export class JSONSchemaGenerator {
       result.$schema = "https://json-schema.org/draft/2020-12/schema";
     } else if (this.target === "draft-7") {
       result.$schema = "http://json-schema.org/draft-07/schema#";
-    } else if (this.target === "draft-4") {
-      result.$schema = "http://json-schema.org/draft-04/schema#";
     } else {
-      // @ts-ignore
       console.warn(`Invalid target: ${this.target}`);
     }
 

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

@@ -123,7 +123,6 @@ export type Identity<T> = T;
 export type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
 export type Mapped<T> = { [k in keyof T]: T[k] };
 export type Prettify<T> = {
-  // @ts-ignore
   [K in keyof T]: T[K];
 } & {};
 
@@ -242,36 +241,23 @@ export function cleanRegex(source: string): string {
 
 export function floatSafeRemainder(val: number, step: number): number {
   const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepString = step.toString();
-  let stepDecCount = (stepString.split(".")[1] || "").length;
-  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-    const match = stepString.match(/\d?e-(\d?)/);
-    if (match?.[1]) {
-      stepDecCount = Number.parseInt(match[1]);
-    }
-  }
-
+  const stepDecCount = (step.toString().split(".")[1] || "").length;
   const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
   const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return (valInt % stepInt) / 10 ** decCount;
 }
 
-const EVALUATING = Symbol("evaluating");
-
 export function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void {
-  let value: T[K] | typeof EVALUATING | undefined = undefined;
+  const set = false;
   Object.defineProperty(object, key, {
     get() {
-      if (value === EVALUATING) {
-        // Circular reference detected, return undefined to break the cycle
-        return undefined as T[K];
-      }
-      if (value === undefined) {
-        value = EVALUATING;
-        value = getter();
+      if (!set) {
+        const value = getter();
+        object[key] = value;
+        return value;
       }
-      return value;
+      throw new Error("cached value already set");
     },
     set(v) {
       Object.defineProperty(object, key, {
@@ -297,21 +283,6 @@ export function assignProp<T extends object, K extends PropertyKey>(
   });
 }
 
-export function mergeDefs(...defs: Record<string, any>[]): any {
-  const mergedDescriptors: Record<string, PropertyDescriptor> = {};
-
-  for (const def of defs) {
-    const descriptors = Object.getOwnPropertyDescriptors(def);
-    Object.assign(mergedDescriptors, descriptors);
-  }
-
-  return Object.defineProperties({}, mergedDescriptors);
-}
-
-export function cloneDef(schema: schemas.$ZodType): any {
-  return mergeDefs(schema._zod.def);
-}
-
 export function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any {
   if (!path) return obj;
   return path.reduce((acc, key) => acc?.[key], obj);
@@ -343,16 +314,15 @@ export function esc(str: string): string {
   return JSON.stringify(str);
 }
 
-export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = (
-  "captureStackTrace" in Error ? Error.captureStackTrace : (..._args: any[]) => {}
-) as any;
+export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = Error.captureStackTrace
+  ? Error.captureStackTrace
+  : (..._args) => {};
 
 export function isObject(data: any): data is Record<PropertyKey, unknown> {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 
 export const allowsEval: { value: boolean } = cached(() => {
-  // @ts-ignore
   if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
     return false;
   }
@@ -439,7 +409,6 @@ export const getParsedType = (data: any): ParsedTypes => {
       if (typeof Date !== "undefined" && data instanceof Date) {
         return "date";
       }
-      // @ts-ignore
       if (typeof File !== "undefined" && data instanceof File) {
         return "file";
       }
@@ -566,81 +535,71 @@ export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, big
 };
 
 export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
-  const currDef = schema._zod.def;
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  const currDef = schema._zod.def; //.shape;
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape: Writeable<schemas.$ZodShape> = {};
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
-        }
-        if (!mask[key]) continue;
-        newShape[key] = currDef.shape[key]!;
-      }
+  for (const key in mask) {
+    if (!(key in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key}"`);
+    }
+    if (!mask[key]) continue;
 
-      assignProp(this, "shape", newShape); // self-caching
-      return newShape;
-    },
-    checks: [],
-  });
+    // pick key
+    newShape[key] = currDef.shape[key]!;
+  }
 
-  return clone(schema, def) as any;
+  return clone(schema, {
+    ...schema._zod.def,
+    shape: newShape,
+    checks: [],
+  }) as any;
 }
 
 export function omit(schema: schemas.$ZodObject, mask: object): any {
-  const currDef = schema._zod.def;
+  const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
+  const currDef = schema._zod.def; //.shape;
+  for (const key in mask) {
+    if (!(key in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key}"`);
+    }
+    if (!(mask as any)[key]) continue;
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
-        }
-        if (!(mask as any)[key]) continue;
-
-        delete newShape[key];
-      }
-      assignProp(this, "shape", newShape); // self-caching
-      return newShape;
-    },
+    delete newShape[key];
+  }
+  return clone(schema, {
+    ...schema._zod.def,
+    shape: newShape,
     checks: [],
   });
-
-  return clone(schema, def);
 }
 
 export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-
-  const def = mergeDefs(schema._zod.def, {
+  const def = {
+    ...schema._zod.def,
     get shape() {
       const _shape = { ...schema._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape); // self-caching
       return _shape;
     },
-    checks: [],
-  });
+    checks: [], // delete existing checks
+  } as any;
   return clone(schema, def) as any;
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
-  const def = mergeDefs(a._zod.def, {
+  return clone(a, {
+    ...a._zod.def,
     get shape() {
       const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
       assignProp(this, "shape", _shape); // self-caching
       return _shape;
     },
-    get catchall() {
-      return b._zod.def.catchall;
-    },
+    catchall: b._zod.def.catchall,
     checks: [], // delete existing checks
-  });
-
-  return clone(a, def) as any;
+  }) as any;
 }
 
 export function partial(
@@ -648,44 +607,40 @@ export function partial(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-      if (mask) {
-        for (const key in mask) {
-          if (!(key in oldShape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
-          }
-          if (!(mask as any)[key]) continue;
-          // if (oldShape[key]!._zod.optin === "optional") continue;
-          shape[key] = Class
-            ? new Class({
-                type: "optional",
-                innerType: oldShape[key]!,
-              })
-            : oldShape[key]!;
-        }
-      } else {
-        for (const key in oldShape) {
-          // if (oldShape[key]!._zod.optin === "optional") continue;
-          shape[key] = Class
-            ? new Class({
-                type: "optional",
-                innerType: oldShape[key]!,
-              })
-            : oldShape[key]!;
-        }
+  const oldShape = schema._zod.def.shape;
+  const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+  if (mask) {
+    for (const key in mask) {
+      if (!(key in oldShape)) {
+        throw new Error(`Unrecognized key: "${key}"`);
       }
+      if (!(mask as any)[key]) continue;
+      // if (oldShape[key]!._zod.optin === "optional") continue;
+      shape[key] = Class
+        ? new Class({
+            type: "optional",
+            innerType: oldShape[key]!,
+          })
+        : oldShape[key]!;
+    }
+  } else {
+    for (const key in oldShape) {
+      // if (oldShape[key]!._zod.optin === "optional") continue;
+      shape[key] = Class
+        ? new Class({
+            type: "optional",
+            innerType: oldShape[key]!,
+          })
+        : oldShape[key]!;
+    }
+  }
 
-      assignProp(this, "shape", shape); // self-caching
-      return shape;
-    },
+  return clone(schema, {
+    ...schema._zod.def,
+    shape,
     checks: [],
-  });
-
-  return clone(schema, def) as any;
+  }) as any;
 }
 
 export function required(
@@ -693,50 +648,44 @@ export function required(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-      if (mask) {
-        for (const key in mask) {
-          if (!(key in shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
-          }
-          if (!(mask as any)[key]) continue;
-          // overwrite with non-optional
-          shape[key] = new Class({
-            type: "nonoptional",
-            innerType: oldShape[key]!,
-          });
-        }
-      } else {
-        for (const key in oldShape) {
-          // overwrite with non-optional
-          shape[key] = new Class({
-            type: "nonoptional",
-            innerType: oldShape[key]!,
-          });
-        }
+  const oldShape = schema._zod.def.shape;
+  const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+  if (mask) {
+    for (const key in mask) {
+      if (!(key in shape)) {
+        throw new Error(`Unrecognized key: "${key}"`);
       }
+      if (!(mask as any)[key]) continue;
+      // overwrite with non-optional
+      shape[key] = new Class({
+        type: "nonoptional",
+        innerType: oldShape[key]!,
+      });
+    }
+  } else {
+    for (const key in oldShape) {
+      // overwrite with non-optional
+      shape[key] = new Class({
+        type: "nonoptional",
+        innerType: oldShape[key]!,
+      });
+    }
+  }
 
-      assignProp(this, "shape", shape); // self-caching
-      return shape;
-    },
+  return clone(schema, {
+    ...schema._zod.def,
+    shape,
+    // optional: [],
     checks: [],
-  });
-
-  return clone(schema, def) as any;
+  }) as any;
 }
 
 export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
 
-// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
 export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
   for (let i = startIndex; i < x.issues.length; i++) {
-    if (x.issues[i]?.continue !== true) {
-      return true;
-    }
+    if (x.issues[i]?.continue !== true) return true;
   }
   return false;
 }
@@ -784,7 +733,6 @@ export function finalizeIssue(
 export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" {
   if (input instanceof Set) return "set";
   if (input instanceof Map) return "map";
-  // @ts-ignore
   if (input instanceof File) return "file";
   return "unknown";
 }

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

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 0,
-  patch: 14 as number,
+  patch: 0 as number,
 } as const;

package/fullstacked_modules/zod/src/v4/locales/index.ts

@@ -3,7 +3,6 @@ export { default as az } from "./az.js";
 export { default as be } from "./be.js";
 export { default as ca } from "./ca.js";
 export { default as cs } from "./cs.js";
-export { default as da } from "./da.js";
 export { default as de } from "./de.js";
 export { default as en } from "./en.js";
 export { default as eo } from "./eo.js";
@@ -15,7 +14,6 @@ export { default as frCA } from "./fr-CA.js";
 export { default as he } from "./he.js";
 export { default as hu } from "./hu.js";
 export { default as id } from "./id.js";
-export { default as is } from "./is.js";
 export { default as it } from "./it.js";
 export { default as ja } from "./ja.js";
 export { default as kh } from "./kh.js";
@@ -39,4 +37,3 @@ export { default as ur } from "./ur.js";
 export { default as vi } from "./vi.js";
 export { default as zhCN } from "./zh-CN.js";
 export { default as zhTW } from "./zh-TW.js";
-export { default as yo } from "./yo.js";

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

@@ -436,10 +436,6 @@ export function stringFormat<Format extends string>(
   return core._stringFormat(ZodMiniCustomStringFormat, format, fnOrRegex, _params) as any;
 }
 
-export function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname"> {
-  return core._stringFormat(ZodMiniCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
-}
-
 // ZodMiniNumber
 interface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>>
   extends _ZodMiniType<T>,
@@ -1028,11 +1024,9 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends Some
   valueType: Value,
   params?: string | core.$ZodRecordParams
 ): ZodMiniRecord<Key & core.$partial, Value> {
-  const k = core.clone(keyType);
-  k._zod.values = undefined;
   return new ZodMiniRecord({
     type: "record",
-    keyType: k,
+    keyType: union([keyType, never()]),
     valueType: valueType as any,
     ...util.normalizeParams(params),
   }) as any;
@@ -1524,13 +1518,6 @@ export function refine<T>(
   return core._refine(ZodMiniCustom, fn, _params);
 }
 
-// superRefine
-export function superRefine<T>(
-  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>
-): core.$ZodCheck<T> {
-  return core._superRefine(fn);
-}
-
 // instanceof
 abstract class Class {
   constructor(..._args: any[]) {}

package/fullstacked_modules/zod/src/v4/mini/tests/assignability.test.ts

@@ -1,6 +1,6 @@
 import { test } from "vitest";
 
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 test("assignability", () => {
   // $ZodString

package/fullstacked_modules/zod/src/v4/mini/tests/computed.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 import { util as zc } from "zod/v4/core";
 
 test("min/max", () => {

package/fullstacked_modules/zod/src/v4/mini/tests/error.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 test("no locale by default", () => {
   const result = z.safeParse(z.string(), 12);

package/fullstacked_modules/zod/src/v4/mini/tests/index.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 import type { util } from "zod/v4/core";
 
 test("z.boolean", () => {

package/fullstacked_modules/zod/src/v4/mini/tests/number.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 test("z.number", () => {
   const a = z.number();

package/fullstacked_modules/zod/src/v4/mini/tests/object.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 test("z.object", () => {
   const a = z.object({

package/fullstacked_modules/zod/src/v4/mini/tests/prototypes.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 declare module "zod/v4/core" {
   interface $ZodType {

package/fullstacked_modules/zod/src/v4/mini/tests/recursive-types.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/mini";
+import { z } from "zod/v4-mini";
 
 test("recursion with z.lazy", () => {
   const data = {

package/fullstacked_modules/zod/src/v4/mini/tests/string.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
+import * as z from "zod/v4-mini";
 
 const FAIL = { success: false };
 

package/fullstacked_modules/zod/v3/ZodError.d.cts

@@ -10,21 +10,21 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
-    unrecognized_keys: "unrecognized_keys";
-    too_big: "too_big";
-    too_small: "too_small";
-    not_multiple_of: "not_multiple_of";
-    invalid_union: "invalid_union";
     invalid_literal: "invalid_literal";
+    custom: "custom";
+    invalid_union: "invalid_union";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";
+    unrecognized_keys: "unrecognized_keys";
     invalid_arguments: "invalid_arguments";
     invalid_return_type: "invalid_return_type";
     invalid_date: "invalid_date";
     invalid_string: "invalid_string";
+    too_small: "too_small";
+    too_big: "too_big";
     invalid_intersection_types: "invalid_intersection_types";
+    not_multiple_of: "not_multiple_of";
     not_finite: "not_finite";
 };
 export type ZodIssueCode = keyof typeof ZodIssueCode;