@xylabs/zod 5.1.5 → 6.0.0

package/dist/neutral/index.mjs

@@ -1,8 +1,9 @@
 // src/zodAsFactory.ts
 import { assertError } from "@xylabs/error";
+import * as z from "zod/v4/core";
 function zodAsFactory(zod, name) {
   function asFunc(value, assert) {
-    const result = zod.safeParse(value);
+    const result = z.safeParse(zod, value);
     if (result.success) {
       return value;
     }
@@ -33,8 +34,9 @@ function zodAsFactory(zod, name) {
 }
 
 // src/zodIsFactory.ts
+import * as z2 from "zod/v4/core";
 function zodIsFactory(zod) {
-  return (value) => zod.safeParse(value).success;
+  return (value) => z2.safeParse(zod, value).success;
 }
 
 // src/zodToFactory.ts
@@ -61,9 +63,10 @@ function zodAllFactory(zod, name) {
 
 // src/zodAsAsyncFactory.ts
 import { assertError as assertError2 } from "@xylabs/error";
+import * as z3 from "zod/v4/core";
 function zodAsAsyncFactory(zod, name) {
   async function asFunc(value, assert) {
-    const result = await zod.safeParseAsync(value);
+    const result = await z3.safeParseAsync(zod, value);
     if (result.success) {
       return value;
     }

package/dist/neutral/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/zodAsFactory.ts", "../../src/zodIsFactory.ts", "../../src/zodToFactory.ts", "../../src/zodAllFactory.ts", "../../src/zodAsAsyncFactory.ts", "../../src/zodToAsyncFactory.ts"],
-  "sourcesContent": ["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type * as z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\n/**\n * Creates a function that validates a value against a zod schema and returns it with a narrowed type.\n * When called without an assert config, returns undefined on failure. When called with an assert config, throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and narrows the type of a value\n */\nexport function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): (T & TZod) | undefined\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    const result = zod.safeParse(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n", "import type * as z from 'zod'\n\n/**\n * Creates a type guard function that checks if a value matches a zod schema.\n * @param zod - The zod schema to validate against\n * @returns A type guard function that returns true if the value passes validation\n */\nexport function zodIsFactory<TZod>(zod: z.ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => zod.safeParse(value).success\n}\n", "import { isDefined } from '@xylabs/typeof'\nimport type * as z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsFactory } from './zodAsFactory.ts'\n\n/**\n * Creates a function that converts a value to the zod schema type, delegating to `zodAsFactory` internally.\n * Provides overloads for optional assertion: without assert config returns undefined on failure, with assert config throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and converts a value to the schema type\n */\nexport function zodToFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  const as = zodAsFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): (T & TZod) | undefined\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    if (isDefined(assert)) {\n      return as(value, assert)\n    }\n    return as(value)\n  }\n  return toFunc\n}\n", "import type * as z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType, TName extends string>\n  = Record<`is${TName}`, ReturnType<typeof zodIsFactory<TType>>>\n    & Record<`as${TName}`, ReturnType<typeof zodAsFactory<TType>>>\n    & Record<`to${TName}`, ReturnType<typeof zodToFactory<TType>>>\n\n/**\n * Creates a bundle of `is`, `as`, and `to` factory functions for a given zod schema.\n * @alpha\n * @param zod - The zod schema to validate against\n * @param name - The name used to suffix the generated function names (e.g. 'Address' produces `isAddress`, `asAddress`, `toAddress`)\n * @returns An object containing `is<Name>`, `as<Name>`, and `to<Name>` functions\n */\nexport function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<T>(zod),\n    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),\n  }\n}\n", "import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type * as z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\n/**\n * Creates an async function that validates a value against a zod schema and returns it with a narrowed type.\n * Uses `safeParseAsync` for schemas with async refinements. When called without an assert config, returns undefined on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns An async function that validates and narrows the type of a value\n */\nexport function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    const result = await zod.safeParseAsync(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n", "import { isDefined } from '@xylabs/typeof'\nimport type * as z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'\n\n/**\n * Creates an async function that converts a value to the zod schema type, delegating to `zodAsAsyncFactory` internally.\n * Provides overloads for optional assertion: without assert config resolves to undefined on failure, with assert config throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns An async function that validates and converts a value to the schema type\n */\nexport function zodToAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  const as = zodAsAsyncFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    if (isDefined(assert)) {\n      return await as(value, assert)\n    }\n    return await as(value)\n  }\n  return toFunc\n}\n"],
-  "mappings": ";AACA,SAAS,mBAAmB;AAYrB,SAAS,aAAmB,KAAsB,MAAc;AAGrE,WAAS,OAAU,OAAU,QAAmD;AAC9E,UAAM,SAAS,IAAI,UAAU,KAAK;AAClC,QAAI,OAAO,SAAS;AAClB,aAAO;AAAA,IACT;AACA,QAAI,WAAW,QAAW;AACxB,UAAI;AACJ,cAAQ,OAAO,QAAQ;AAAA,QACrB,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM;AAC5C;AAAA,QACF;AAAA,QACA,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1E;AAAA,QACF;AAAA,QACA,KAAK,WAAW;AACd,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1D;AAAA,QACF;AAAA,QACA,KAAK,YAAY;AACf,yBAAe,OAAO,OAAO,OAAO,MAAM,OAAO;AACjD;AAAA,QACF;AAAA,MACF;AACA,aAAO,YAAY,OAAO,cAAc,OAAO,MAAM,OAAO;AAAA,IAC9D;AAAA,EACF;AAEA,SAAO;AACT;;;ACvCO,SAAS,aAAmB,KAAsB;AACvD,SAAO,CAAI,UAAgC,IAAI,UAAU,KAAK,EAAE;AAClE;;;ACTA,SAAS,iBAAiB;AAanB,SAAS,aAAmB,KAAsB,MAAc;AACrE,QAAM,KAAK,aAAmB,KAAK,IAAI;AAGvC,WAAS,OAAU,OAAU,QAAmD;AAC9E,QAAI,UAAU,MAAM,GAAG;AACrB,aAAO,GAAG,OAAO,MAAM;AAAA,IACzB;AACA,WAAO,GAAG,KAAK;AAAA,EACjB;AACA,SAAO;AACT;;;ACLO,SAAS,cAAuC,KAAmB,MAAa;AACrF,SAAO;AAAA,IACL,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,GAAG;AAAA,IAClC,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,IAC/C,CAAC,KAAK,IAAI,EAAE,GAAG,aAAgB,KAAK,KAAK,IAAI,EAAE;AAAA,EACjD;AACF;;;ACxBA,SAAS,eAAAA,oBAAmB;AAYrB,SAAS,kBAAwB,KAAsB,MAAc;AAG1E,iBAAe,OAAU,OAAU,QAA4D;AAC7F,UAAM,SAAS,MAAM,IAAI,eAAe,KAAK;AAC7C,QAAI,OAAO,SAAS;AAClB,aAAO;AAAA,IACT;AACA,QAAI,WAAW,QAAW;AACxB,UAAI;AACJ,cAAQ,OAAO,QAAQ;AAAA,QACrB,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM;AAC5C;AAAA,QACF;AAAA,QACA,KAAK,UAAU;AACb,yBAAe,IAAI,IAAI,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1E;AAAA,QACF;AAAA,QACA,KAAK,WAAW;AACd,yBAAe,IAAI,IAAI,KAAK,KAAK,KAAK,OAAO,MAAM,OAAO;AAC1D;AAAA,QACF;AAAA,QACA,KAAK,YAAY;AACf,yBAAe,OAAO,OAAO,OAAO,MAAM,OAAO;AACjD;AAAA,QACF;AAAA,MACF;AACA,aAAOA,aAAY,OAAO,cAAc,OAAO,MAAM,OAAO;AAAA,IAC9D;AAAA,EACF;AAEA,SAAO;AACT;;;AC9CA,SAAS,aAAAC,kBAAiB;AAanB,SAAS,kBAAwB,KAAsB,MAAc;AAC1E,QAAM,KAAK,kBAAwB,KAAK,IAAI;AAG5C,iBAAe,OAAU,OAAU,QAA4D;AAC7F,QAAIC,WAAU,MAAM,GAAG;AACrB,aAAO,MAAM,GAAG,OAAO,MAAM;AAAA,IAC/B;AACA,WAAO,MAAM,GAAG,KAAK;AAAA,EACvB;AACA,SAAO;AACT;",
-  "names": ["assertError", "isDefined", "isDefined"]
+  "sourcesContent": ["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport * as z from 'zod/v4/core'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\n/**\n * Creates a function that validates a value against a zod schema and returns it with a narrowed type.\n * When called without an assert config, returns undefined on failure. When called with an assert config, throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and narrows the type of a value\n */\nexport function zodAsFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): (T & TZod) | undefined\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    const result = z.safeParse(zod, value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n", "import * as z from 'zod/v4/core'\n\n/**\n * Creates a type guard function that checks if a value matches a zod schema.\n * @param zod - The zod schema to validate against\n * @returns A type guard function that returns true if the value passes validation\n */\nexport function zodIsFactory<TZod>(zod: z.$ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => z.safeParse(zod, value).success\n}\n", "import { isDefined } from '@xylabs/typeof'\nimport type * as z from 'zod/v4/core'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsFactory } from './zodAsFactory.ts'\n\n/**\n * Creates a function that converts a value to the zod schema type, delegating to `zodAsFactory` internally.\n * Provides overloads for optional assertion: without assert config returns undefined on failure, with assert config throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and converts a value to the schema type\n */\nexport function zodToFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  const as = zodAsFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): (T & TZod) | undefined\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    if (isDefined(assert)) {\n      return as(value, assert)\n    }\n    return as(value)\n  }\n  return toFunc\n}\n", "import type * as z from 'zod/v4/core'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType, TName extends string>\n  = Record<`is${TName}`, ReturnType<typeof zodIsFactory<TType>>>\n    & Record<`as${TName}`, ReturnType<typeof zodAsFactory<TType>>>\n    & Record<`to${TName}`, ReturnType<typeof zodToFactory<TType>>>\n\n/**\n * Creates a bundle of `is`, `as`, and `to` factory functions for a given zod schema.\n * @alpha\n * @param zod - The zod schema to validate against\n * @param name - The name used to suffix the generated function names (e.g. 'Address' produces `isAddress`, `asAddress`, `toAddress`)\n * @returns An object containing `is<Name>`, `as<Name>`, and `to<Name>` functions\n */\nexport function zodAllFactory<T, TName extends string>(zod: z.$ZodType<T>, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<T>(zod),\n    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),\n  }\n}\n", "import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport * as z from 'zod/v4/core'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\n/**\n * Creates an async function that validates a value against a zod schema and returns it with a narrowed type.\n * Uses `safeParseAsync` for schemas with async refinements. When called without an assert config, returns undefined on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns An async function that validates and narrows the type of a value\n */\nexport function zodAsAsyncFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    const result = await z.safeParseAsync(zod, value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n", "import { isDefined } from '@xylabs/typeof'\nimport type * as z from 'zod/v4/core'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'\n\n/**\n * Creates an async function that converts a value to the zod schema type, delegating to `zodAsAsyncFactory` internally.\n * Provides overloads for optional assertion: without assert config resolves to undefined on failure, with assert config throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns An async function that validates and converts a value to the schema type\n */\nexport function zodToAsyncFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  const as = zodAsAsyncFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    if (isDefined(assert)) {\n      return await as(value, assert)\n    }\n    return await as(value)\n  }\n  return toFunc\n}\n"],
+  "mappings": "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",
+  "names": ["z", "assertError", "z", "isDefined", "isDefined"]
 }

package/dist/neutral/zodAllFactory.d.ts

@@ -1,4 +1,4 @@
-import type * as z from 'zod';
+import type * as z from 'zod/v4/core';
 import { zodAsFactory } from './zodAsFactory.ts';
 import { zodIsFactory } from './zodIsFactory.ts';
 import { zodToFactory } from './zodToFactory.ts';
@@ -11,7 +11,7 @@ export type AllZodFactories<TType, TName extends string> = Record<`is${TName}`,
  * @param name - The name used to suffix the generated function names (e.g. 'Address' produces `isAddress`, `asAddress`, `toAddress`)
  * @returns An object containing `is<Name>`, `as<Name>`, and `to<Name>` functions
  */
-export declare function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName): {
+export declare function zodAllFactory<T, TName extends string>(zod: z.$ZodType<T>, name: TName): {
     [x: string]: {
         <T_1>(value: T_1): (T_1 & T) | undefined;
         <T_1>(value: T_1, assert: import("./Config.ts").ZodFactoryConfig): T_1 & T;

package/dist/neutral/zodAllFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAllFactory.d.ts","sourceRoot":"","sources":["../../src/zodAllFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,aAAa;AACb,MAAM,MAAM,eAAe,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IACnD,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,GAC1D,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,GAC5D,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAElE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK;;;;;EAMpF"}
+{"version":3,"file":"zodAllFactory.d.ts","sourceRoot":"","sources":["../../src/zodAllFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,aAAa,CAAA;AAErC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,aAAa;AACb,MAAM,MAAM,eAAe,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IACnD,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,GAC1D,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,GAC5D,MAAM,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAElE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK;;;;;EAMrF"}

package/dist/neutral/zodAsAsyncFactory.d.ts

@@ -1,4 +1,4 @@
-import type * as z from 'zod';
+import * as z from 'zod/v4/core';
 import type { ZodFactoryConfig } from './Config.ts';
 /**
  * Creates an async function that validates a value against a zod schema and returns it with a narrowed type.
@@ -7,7 +7,7 @@ import type { ZodFactoryConfig } from './Config.ts';
  * @param name - A name used in error messages for identification
  * @returns An async function that validates and narrows the type of a value
  */
-export declare function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+export declare function zodAsAsyncFactory<TZod>(zod: z.$ZodType<TZod>, name: string): {
     <T>(value: T): Promise<(T & TZod) | undefined>;
     <T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>;
 };

package/dist/neutral/zodAsAsyncFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAsAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsAsyncFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACxD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EA+B5E"}
+{"version":3,"file":"zodAsAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsAsyncFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACzD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EA+B5E"}

package/dist/neutral/zodAsFactory.d.ts

@@ -1,4 +1,4 @@
-import type * as z from 'zod';
+import * as z from 'zod/v4/core';
 import type { ZodFactoryConfig } from './Config.ts';
 /**
  * Creates a function that validates a value against a zod schema and returns it with a narrowed type.
@@ -7,7 +7,7 @@ import type { ZodFactoryConfig } from './Config.ts';
  * @param name - A name used in error messages for identification
  * @returns A function that validates and narrows the type of a value
  */
-export declare function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+export declare function zodAsFactory<TZod>(zod: z.$ZodType<TZod>, name: string): {
     <T>(value: T): (T & TZod) | undefined;
     <T>(value: T, assert: ZodFactoryConfig): (T & TZod);
 };

package/dist/neutral/zodAsFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACnD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EA+BnE"}
+{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACpD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EA+BnE"}

package/dist/neutral/zodIsFactory.d.ts

@@ -1,8 +1,8 @@
-import type * as z from 'zod';
+import * as z from 'zod/v4/core';
 /**
  * Creates a type guard function that checks if a value matches a zod schema.
  * @param zod - The zod schema to validate against
  * @returns A type guard function that returns true if the value passes validation
  */
-export declare function zodIsFactory<TZod>(zod: z.ZodType<TZod>): <T>(value: T) => value is T & TZod;
+export declare function zodIsFactory<TZod>(zod: z.$ZodType<TZod>): <T>(value: T) => value is T & TZod;
 //# sourceMappingURL=zodIsFactory.d.ts.map

package/dist/neutral/zodIsFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodIsFactory.d.ts","sourceRoot":"","sources":["../../src/zodIsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,IAC7C,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CACxC"}
+{"version":3,"file":"zodIsFactory.d.ts","sourceRoot":"","sources":["../../src/zodIsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAC9C,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CACxC"}

package/dist/neutral/zodToAsyncFactory.d.ts

@@ -1,4 +1,4 @@
-import type * as z from 'zod';
+import type * as z from 'zod/v4/core';
 import type { ZodFactoryConfig } from './Config.ts';
 /**
  * Creates an async function that converts a value to the zod schema type, delegating to `zodAsAsyncFactory` internally.
@@ -7,7 +7,7 @@ import type { ZodFactoryConfig } from './Config.ts';
  * @param name - A name used in error messages for identification
  * @returns An async function that validates and converts a value to the schema type
  */
-export declare function zodToAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+export declare function zodToAsyncFactory<TZod>(zod: z.$ZodType<TZod>, name: string): {
     <T>(value: T): Promise<(T & TZod) | undefined>;
     <T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>;
 };

package/dist/neutral/zodToAsyncFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodToAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodToAsyncFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAExD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EAQ5E"}
+{"version":3,"file":"zodToAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodToAsyncFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAEzD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EAQ5E"}

package/dist/neutral/zodToFactory.d.ts

@@ -1,4 +1,4 @@
-import type * as z from 'zod';
+import type * as z from 'zod/v4/core';
 import type { ZodFactoryConfig } from './Config.ts';
 /**
  * Creates a function that converts a value to the zod schema type, delegating to `zodAsFactory` internally.
@@ -7,7 +7,7 @@ import type { ZodFactoryConfig } from './Config.ts';
  * @param name - A name used in error messages for identification
  * @returns A function that validates and converts a value to the schema type
  */
-export declare function zodToFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
+export declare function zodToFactory<TZod>(zod: z.$ZodType<TZod>, name: string): {
     <T>(value: T): (T & TZod) | undefined;
     <T>(value: T, assert: ZodFactoryConfig): (T & TZod);
 };

package/dist/neutral/zodToFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodToFactory.d.ts","sourceRoot":"","sources":["../../src/zodToFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAEnD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EAQnE"}
+{"version":3,"file":"zodToFactory.d.ts","sourceRoot":"","sources":["../../src/zodToFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAEpD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EAQnE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/zod",
-  "version": "5.1.5",
+  "version": "6.0.0",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -34,8 +34,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@xylabs/error": "~5.1.5",
-    "@xylabs/typeof": "~5.1.5"
+    "@xylabs/error": "~6.0.0",
+    "@xylabs/typeof": "~6.0.0"
   },
   "devDependencies": {
     "@xylabs/toolchain": "^8.0.8",