fullstacked 0.12.0-1272 → 0.12.0-1290

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

@@ -1,7 +1,6 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type { StandardSchemaV1 } from "./standard-schema.js";
 import * as util from "./util.js";
 
 ///////////////////////////
@@ -12,6 +11,7 @@ export interface $ZodIssueBase {
   readonly input?: unknown;
   readonly path: PropertyKey[];
   readonly message: string;
+  // [k: string]: unknown;
 }
 
 ////////////////////////////////
@@ -20,7 +20,7 @@ export interface $ZodIssueBase {
 export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_type";
   readonly expected: $ZodType["_zod"]["def"]["type"];
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
@@ -29,7 +29,7 @@ export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
   readonly maximum: number | bigint;
   readonly inclusive?: boolean;
   readonly exact?: boolean;
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
@@ -40,40 +40,39 @@ export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
   readonly inclusive?: boolean;
   /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
   readonly exact?: boolean;
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
   readonly code: "invalid_format";
   readonly format: $ZodStringFormats | (string & {});
   readonly pattern?: string;
-  readonly input?: string;
+  readonly input: string;
 }
 
 export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
   readonly code: "not_multiple_of";
   readonly divisor: number;
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly code: "unrecognized_keys";
   readonly keys: string[];
-  readonly input?: Record<string, unknown>;
+  readonly input: Record<string, unknown>;
 }
 
 export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
   readonly code: "invalid_union";
   readonly errors: $ZodIssue[][];
-  readonly input?: unknown;
-  readonly discriminator?: string | undefined;
+  readonly input: unknown;
 }
 
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";
   readonly issues: $ZodIssue[];
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
@@ -81,19 +80,19 @@ export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase
   readonly origin: "map" | "set";
   readonly key: unknown;
   readonly issues: $ZodIssue[];
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_value";
   readonly values: util.Primitive[];
-  readonly input?: Input;
+  readonly input: Input;
 }
 
 export interface $ZodIssueCustom extends $ZodIssueBase {
   readonly code: "custom";
   readonly params?: Record<string, any> | undefined;
-  readonly input?: unknown;
+  readonly input: unknown;
 }
 
 ////////////////////////////////////////////
@@ -156,21 +155,17 @@ export type $ZodIssue =
 
 export type $ZodIssueCode = $ZodIssue["code"];
 
-export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any
-  ? util.Flatten<
-      util.MakePartial<T, "message" | "path"> & {
-        /** The input data */
-        readonly input: unknown;
-        /** The schema or check that originated this issue. */
-        readonly inst?: $ZodType | $ZodCheck;
-        /** If `true`, Zod will continue executing checks/refinements after this issue. */
-        readonly continue?: boolean | undefined;
-      } & Record<string, unknown>
-    >
-  : never;
-
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = util.Flatten<
+  util.MakePartial<T, "message" | "path"> & {
+    /** The input data */
+    readonly input?: unknown;
+    /** The schema or check that originated this issue. */
+    readonly inst?: $ZodType | $ZodCheck;
+    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
+    readonly continue?: boolean | undefined;
+  } & Record<string, any>
+>;
 
 export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
   // biome-ignore lint:
@@ -201,8 +196,13 @@ const initializer = (inst: $ZodError, def: $ZodIssue[]): void => {
     value: def,
     enumerable: false,
   });
-  inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
-
+  Object.defineProperty(inst, "message", {
+    get() {
+      return JSON.stringify(def, util.jsonStringifyReplacer, 2);
+    },
+    enumerable: true,
+    // configurable: false,
+  });
   Object.defineProperty(inst, "toString", {
     value: () => inst.message,
     enumerable: false,
@@ -295,15 +295,13 @@ export function formatError<T>(error: $ZodError, _mapper?: any) {
   return fieldErrors;
 }
 
-export type $ZodErrorTree<T, U = string> = T extends util.Primitive
-  ? { errors: U[] }
-  : T extends [any, ...any[]]
-    ? { errors: U[]; items?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
-    : T extends any[]
-      ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
-      : T extends object
-        ? { errors: U[]; properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
-        : { errors: U[] };
+export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]]
+  ? { errors: U[]; items?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
+  : T extends any[]
+    ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
+    : T extends object
+      ? { errors: U[]; properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
+      : { errors: U[] };
 
 export function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
 export function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
@@ -391,9 +389,8 @@ export function treeifyError<T>(error: $ZodError, _mapper?: any) {
  *   ✖ Invalid input: expected number
  * ```
  */
-export function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string {
+export function toDotPath(path: (string | number | symbol)[]): string {
   const segs: string[] = [];
-  const path: PropertyKey[] = _path.map((seg: any) => (typeof seg === "object" ? seg.key : seg));
   for (const seg of path) {
     if (typeof seg === "number") segs.push(`[${seg}]`);
     else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
@@ -407,10 +404,14 @@ export function toDotPath(_path: readonly (string | number | symbol | StandardSc
   return segs.join("");
 }
 
-export function prettifyError(error: StandardSchemaV1.FailureResult): string {
+interface BaseError {
+  issues: $ZodIssueBase[];
+}
+
+export function prettifyError(error: BaseError): string {
   const lines: string[] = [];
   // sort by path length
-  const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+  const issues = [...error.issues].sort((a, b) => a.path.length - b.path.length);
 
   // Process each issue
   for (const issue of issues) {

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

@@ -45,10 +45,7 @@ export type Schema =
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
   [k: string]: unknown;
-  $schema?:
-    | "https://json-schema.org/draft/2020-12/schema"
-    | "http://json-schema.org/draft-07/schema#"
-    | "http://json-schema.org/draft-04/schema#";
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
   $id?: string;
   $anchor?: string;
   $ref?: string;
@@ -78,9 +75,9 @@ export type JSONSchema = {
   not?: _JSONSchema;
   multipleOf?: number;
   maximum?: number;
-  exclusiveMaximum?: number | boolean;
+  exclusiveMaximum?: number;
   minimum?: number;
-  exclusiveMinimum?: number | boolean;
+  exclusiveMinimum?: number;
   maxLength?: number;
   minLength?: number;
   pattern?: string;

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

@@ -16,7 +16,7 @@ export const extendedDuration: RegExp =
 /** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
 export const guid: RegExp = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
 
-/** Returns a regex for validating an RFC 9562/4122 UUID.
+/** Returns a regex for validating an RFC 4122 UUID.
  *
  * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
 export const uuid = (version?: number | undefined): RegExp => {
@@ -44,13 +44,12 @@ export const rfc5322Email =
 
 /** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
 export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
-export const idnEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
 
 export const browserEmail: RegExp =
   /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
 
-const _emoji: string = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+export const _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
 export function emoji(): RegExp {
   return new RegExp(_emoji, "u");
 }
@@ -70,10 +69,9 @@ export const base64: RegExp = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==
 export const base64url: RegExp = /^[A-Za-z0-9_-]*$/;
 
 // based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-export const hostname: RegExp =
-  /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
-
+// export const hostname: RegExp =
+//   /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
+export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
 export const domain: RegExp = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
@@ -111,8 +109,7 @@ export function datetime(args: {
   const time = timeSource({ precision: args.precision });
   const opts = ["Z"];
   if (args.local) opts.push("");
-  // if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
-  if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+  if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
   const timeRegex = `${time}(?:${opts.join("|")})`;
 
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);

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

@@ -23,7 +23,7 @@ export type $replace<Meta, S extends $ZodType> = Meta extends $output
           ? { [K in keyof Meta]: $replace<Meta[K], S> }
           : Meta;
 
-type MetadataType = object | undefined;
+type MetadataType = Record<string, unknown> | undefined;
 export class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
   _meta!: Meta;
   _schema!: Schema;
@@ -68,8 +68,7 @@ export class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema exten
     if (p) {
       const pm: any = { ...(this.get(p) ?? {}) };
       delete pm.id; // do not inherit id
-      const f = { ...pm, ...this._map.get(schema) } as any;
-      return Object.keys(f).length ? f : undefined;
+      return { ...pm, ...this._map.get(schema) } as any;
     }
     return this._map.get(schema) as any;
   }