@chainfuse/helpers 3.6.0 → 3.6.1

package/dist/buffers.d.mts

@@ -1,6 +1,6 @@
 import type { UndefinedProperties } from '@chainfuse/types';
-import type { PrefixedUuid, UuidExport, UUIDExtract } from '@chainfuse/types/d1';
-import type { z } from 'zod/v4';
+import { type PrefixedUuid, type UuidExport, type UUIDExtract } from '@chainfuse/types/d1';
+import * as z from 'zod/mini';
 import type { Version8Options } from './uuid8.mjs';
 export type UuidExportBlobInput = Buffer | UuidExport['blob'];
 export declare class BufferHelpers {
@@ -15,10 +15,16 @@ export declare class BufferHelpers {
      * @deprecated Use `BufferHelpers.generateUuid7` instead
      */
     static get generateUuid(): Promise<UuidExport>;
-    static get v7OptionsBase(): Promise<z.ZodObject<{
-        msecs: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodPipe<z.ZodDate, z.ZodTransform<number, Date>>]>>;
-        seq: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strip>>;
+    static v7OptionsBase: z.ZodMiniObject<{
+        /**
+         * RFC "timestamp" field
+         */
+        msecs: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniNumberFormat, z.ZodMiniPipe<z.ZodMiniDate<Date>, z.ZodMiniTransform<number, Date>>]>>;
+        /**
+         * 32-bit sequence Number between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value.
+         */
+        seq: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    }, z.core.$strip>;
     static generateUuid7(_options?: z.input<Awaited<typeof this.v7OptionsBase>>): Promise<UuidExport>;
     static generateUuid8(options?: Omit<Version8Options, 'random' | 'rng'>): Promise<UuidExport>;
     static uuidConvert(input: undefined): Promise<UndefinedProperties<UuidExport>>;

package/dist/buffers.mjs

@@ -1,3 +1,5 @@
+import { UUIDExtract7, UUIDExtract8 } from '@chainfuse/types/d1';
+import * as z from 'zod/mini';
 import { BufferHelpersInternals } from "./bufferInternals.mjs";
 import { CryptoHelpers } from './crypto.mjs';
 export class BufferHelpers {
@@ -18,20 +20,18 @@ export class BufferHelpers {
         return BufferHelpersInternals.node_bufferToHex(buffer).catch(() => BufferHelpersInternals.browser_bufferToHex(buffer));
     }
     static base64ToBuffer(rawBase64) {
-        return import('zod/v4').then(({ z }) => Promise.any([
+        return Promise.any([
             z
                 .base64()
-                .trim()
-                .nonempty()
+                .check(z.trim(), z.minLength(1))
                 .parseAsync(rawBase64)
                 .then((base64) => BufferHelpersInternals.node_base64ToBuffer(base64, false).catch(() => BufferHelpersInternals.browser_base64ToBuffer(base64))),
             z
                 .base64url()
-                .trim()
-                .nonempty()
+                .check(z.trim(), z.minLength(1))
                 .parseAsync(rawBase64)
                 .then((base64url) => BufferHelpersInternals.node_base64ToBuffer(base64url, true).catch(() => BufferHelpersInternals.browser_base64UrlToBuffer(base64url))),
-        ]));
+        ]);
     }
     static bufferToBase64(buffer, urlSafe) {
         return BufferHelpersInternals.node_bufferToBase64(buffer, urlSafe).catch(() => BufferHelpersInternals.browser_bufferToBase64(buffer, urlSafe));
@@ -42,29 +42,25 @@ export class BufferHelpers {
     static get generateUuid() {
         return this.generateUuid7();
     }
-    static get v7OptionsBase() {
-        return import('zod/v4').then(({ z }) => z.object({
-            /**
-             * RFC "timestamp" field
-             */
-            msecs: z
-                .union([
-                z.int().nonnegative(),
-                // Allow converting from Date object
-                z.date().transform((date) => date.getTime()),
-            ])
-                .optional(),
-            /**
-             * 32-bit sequence Number between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value.
-             */
-            seq: z.int().min(0).max(0xffffffff).optional(),
-        }));
-    }
+    static v7OptionsBase = z.object({
+        /**
+         * RFC "timestamp" field
+         */
+        msecs: z.optional(z.union([
+            z.int().check(z.nonnegative()),
+            // Allow converting from Date object
+            z.pipe(z.date(), z.transform((date) => date.getTime())),
+        ])),
+        /**
+         * 32-bit sequence Number between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value.
+         */
+        seq: z.optional(z.int().check(z.minimum(0), z.maximum(0xffffffff))),
+    });
     static generateUuid7(_options) {
         return Promise.all([
             //
             import('uuid'),
-            this.v7OptionsBase.then((schema) => schema.parseAsync(_options ?? {})),
+            this.v7OptionsBase.parseAsync(_options ?? {}),
             CryptoHelpers.secretBytes(16),
         ]).then(([{ v7: uuidv7 }, options, random]) => {
             const uuid = uuidv7({ msecs: options.msecs, random, seq: options.seq });
@@ -182,23 +178,19 @@ export class BufferHelpers {
     }
     // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static uuidExtractor(input) {
-        return Promise.all([
-            import('zod/v4'),
-            this.uuidConvert(
-            // @ts-expect-error it's the same type
-            input),
-        ]).then(async ([{ z }, { utf8, hex: _hex }]) => {
-            const { success: hexSuccess, data: hex } = z.hex().length(32).safeParse(_hex);
+        return this.uuidConvert(
+        // @ts-expect-error it's the same type
+        input).then(async ({ utf8, hex: _hex }) => {
+            const { success: hexSuccess, data: hex } = z.hex().check(z.length(32)).safeParse(_hex);
             if (hexSuccess) {
                 const { success: utf8v7Success } = z.uuid({ version: 'v7' }).safeParse(utf8);
                 const { success: utf8v8Success } = z.uuid({ version: 'v8' }).safeParse(utf8);
                 if (utf8v7Success || utf8v8Success) {
-                    const date = new Date(Number(BigInt(`0x${hex.substring(0, 12)}`)));
                     if (utf8v8Success) {
                         const suffix_hex = hex.substring(13, 16);
                         const suffix_buffer = await BufferHelpers.hexToBuffer(suffix_hex);
-                        return {
-                            date,
+                        return UUIDExtract8.parseAsync({
+                            date: Number(BigInt(`0x${hex.substring(0, 12)}`)),
                             location: parseInt(hex.slice(17, 19), 16),
                             shardType: parseInt(hex.slice(19, 20), 16),
                             suffix: suffix_hex === '000'
@@ -208,12 +200,12 @@ export class BufferHelpers {
                                     base64: await BufferHelpers.bufferToBase64(suffix_buffer, false),
                                     base64url: await BufferHelpers.bufferToBase64(suffix_buffer, true),
                                 },
-                        };
+                        });
                     }
                     else {
-                        return {
-                            date,
-                        };
+                        return UUIDExtract7.parseAsync({
+                            date: Number(BigInt(`0x${hex.substring(0, 12)}`)),
+                        });
                     }
                 }
                 else {

package/dist/db.d.mts

@@ -1,6 +1,6 @@
 import { Cache as DrizzleCache, type MutationOption } from 'drizzle-orm/cache/core';
 import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import { z } from 'zod/v4';
+import * as z from 'zod/mini';
 /**
  * Interface for CacheStorage-like objects that can be used as drop-in replacements.
  * This interface ensures compatibility with the Web API CacheStorage while allowing for custom implementations that provide the same core functionality.
@@ -28,12 +28,12 @@ export declare class SQLCache<C extends CacheStorageLike> extends DrizzleCache {
     private ttlCutoff;
     private _strategy;
     private usedTablesPerKey;
-    static constructorArgs(): z.ZodObject<{
-        dbName: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        dbType: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        cacheTTL: z.ZodDefault<z.ZodInt>;
-        cachePurge: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodDate]>>;
-        strategy: z.ZodDefault<z.ZodEnum<{
+    static constructorArgs: z.ZodMiniObject<{
+        dbName: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<string, string>>;
+        dbType: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<string, string>>;
+        cacheTTL: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        cachePurge: z.ZodMiniDefault<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniDate<Date>]>>;
+        strategy: z.ZodMiniDefault<z.ZodMiniEnum<{
             explicit: "explicit";
             all: "all";
         }>>;
@@ -49,7 +49,7 @@ export declare class SQLCache<C extends CacheStorageLike> extends DrizzleCache {
      * - `all`: All queries are cached globally.
      * @param cacheStore - The cache store to use. Can be a CacheStorage or CacheStorage-like object that atleast contains the `open()` function
      */
-    constructor(args: z.input<ReturnType<(typeof SQLCache)['constructorArgs']>>, cacheStore?: C);
+    constructor(args: z.input<(typeof SQLCache)['constructorArgs']>, cacheStore?: C);
     /**
      * For the strategy, we have two options:
      * - `explicit`: The cache is used only when .$withCache() is added to a query.

package/dist/db.mjs

@@ -1,7 +1,7 @@
 import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
 import { is } from 'drizzle-orm/entity';
 import { getTableName, Table } from 'drizzle-orm/table';
-import { z } from 'zod/v4';
+import * as z from 'zod/mini';
 import { CryptoHelpers } from "./crypto.mjs";
 /**
  * SQLCache is a cache implementation for SQL query results, using Web CacheStorage (supports drop in replacements).
@@ -23,24 +23,13 @@ export class SQLCache extends DrizzleCache {
     _strategy;
     // This object will be used to store which query keys were used for a specific table, so we can later use it for invalidation.
     usedTablesPerKey = {};
-    static constructorArgs() {
-        return z.object({
-            dbName: z
-                .string()
-                .nonempty()
-                .transform((val) => encodeURIComponent(val)),
-            dbType: z
-                .string()
-                .nonempty()
-                .transform((val) => encodeURIComponent(val)),
-            cacheTTL: z
-                .int()
-                .nonnegative()
-                .default(5 * 60),
-            cachePurge: z.union([z.boolean(), z.date()]).default(false),
-            strategy: z.enum(['explicit', 'all']).default('explicit'),
-        });
-    }
+    static constructorArgs = z.object({
+        dbName: z.pipe(z.string().check(z.minLength(1)), z.transform((val) => encodeURIComponent(val))),
+        dbType: z.pipe(z.string().check(z.minLength(1)), z.transform((val) => encodeURIComponent(val))),
+        cacheTTL: z._default(z.int().check(z.nonnegative()), 5 * 60),
+        cachePurge: z._default(z.union([z.boolean(), z.date()]), false),
+        strategy: z._default(z.enum(['explicit', 'all']), 'explicit'),
+    });
     /**
      * Creates an instance of the class with the specified database name, type, and cache TTL.
      *
@@ -54,7 +43,7 @@ export class SQLCache extends DrizzleCache {
      */
     constructor(args, cacheStore) {
         super();
-        const { dbName, dbType, cacheTTL, cachePurge, strategy } = SQLCache.constructorArgs().parse(args);
+        const { dbName, dbType, cacheTTL, cachePurge, strategy } = SQLCache.constructorArgs.parse(args);
         this.dbName = dbName;
         this.dbType = dbType;
         cacheStore ??= globalThis.caches;

package/dist/discord.d.mts

@@ -28,8 +28,8 @@ export declare class DiscordHelpers {
         color: boolean;
         custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
     }, {
-        error?: number | undefined;
         custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
+        error?: number | undefined;
         level?: number | undefined;
         color?: boolean | undefined;
     }>>>;

package/dist/net.d.mts

@@ -1,6 +1,5 @@
-import type { z as z3 } from 'zod/v3';
-import type { z as z4 } from 'zod/v4';
-export type LoggingFetchInitType<RI extends RequestInit = RequestInit> = RI & z3.input<Awaited<ReturnType<typeof NetHelpers.loggingFetchInit>>>;
+import * as z from 'zod/mini';
+export type LoggingFetchInitType<RI extends RequestInit = RequestInit> = RI & z.input<typeof NetHelpers.loggingFetchInit>;
 /**
  * Enum representing HTTP request methods.
  *
@@ -18,138 +17,73 @@ export declare enum Methods {
     'PATCH' = "PATCH"
 }
 export declare class NetHelpers {
-    static cfApiConfig(): Promise<z3.ZodDefault<z3.ZodObject<{
-        logging: z3.ZodDefault<z3.ZodObject<{
-            level: z3.ZodDefault<z3.ZodNumber>;
-            error: z3.ZodDefault<z3.ZodNumber>;
-            color: z3.ZodDefault<z3.ZodBoolean>;
-            custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
-        }, "strip", z3.ZodTypeAny, {
-            error: number;
-            level: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        }, {
-            error?: number | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-            level?: number | undefined;
-            color?: boolean | undefined;
-        }>>;
-        cf: z3.ZodDefault<z3.ZodObject<{
+    static customLogging: z.ZodMiniFunction<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>;
+    static cfApiConfig: z.ZodMiniDefault<z.ZodMiniObject<{
+        logging: z.ZodMiniDefault<z.ZodMiniObject<{
+            level: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+            error: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+            color: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+            custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniFunction<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>, z.ZodMiniTransform<(args_0: any, ...args: any[]) => void | Promise<void>, z.core.$InferOuterFunctionType<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>>>>;
+        }, z.core.$strip>>;
+        cf: z.ZodMiniDefault<z.ZodMiniObject<{
             /**
              * Whether Cloudflare Apps should be enabled for this request
              * @link https://www.cloudflare.com/apps/
              * @default true
              */
-            apps: z3.ZodDefault<z3.ZodBoolean>;
+            apps: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
             /**
              * Treats all content as static and caches all file types beyond the Cloudflare default cached content. Respects cache headers from the origin web server. This is equivalent to setting the Page Rule Cache Level (to Cache Everything).
              * @default false
              * @note This option applies to GET and HEAD request methods only
              */
-            cacheEverything: z3.ZodDefault<z3.ZodBoolean>;
+            cacheEverything: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
             /**
-             * A request’s cache key is what determines if two requests are the same for caching purposes. If a request has the same cache key as some previous request, then Cloudflare can serve the same cached response for both.
+             * A request's cache key is what determines if two requests are the same for caching purposes. If a request has the same cache key as some previous request, then Cloudflare can serve the same cached response for both.
              */
-            cacheKey: z3.ZodOptional<z3.ZodString>;
+            cacheKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
             /**
              * This option appends additional Cache-Tag headers to the response from the origin server. This allows for purges of cached content based on tags provided by the Worker, without modifications to the origin server. This is performed using the Purge by Tag feature.
              */
-            cacheTags: z3.ZodOptional<z3.ZodArray<z3.ZodString, "atleastone">>;
+            cacheTags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
             /**
              * This option forces Cloudflare to cache the response for this request, regardless of what headers are seen on the response. This is equivalent to setting two Page Rules: Edge Cache TTL and Cache Level (to Cache Everything). The value must be zero or a positive number. A value of 0 indicates that the cache asset expires immediately.
              * @note This option applies to GET and HEAD request methods only.
              */
-            cacheTtl: z3.ZodOptional<z3.ZodNumber>;
+            cacheTtl: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
             /**
-             * This option is a version of the cacheTtl feature which chooses a TTL based on the response’s status code. If the response to this request has a status code that matches, Cloudflare will cache for the instructed time and override cache instructives sent by the origin. For example: { "200-299": 86400, "404": 1, "500-599": 0 }. The value can be any integer, including zero and negative integers. A value of 0 indicates that the cache asset expires immediately. Any negative value instructs Cloudflare not to cache at all.
+             * This option is a version of the cacheTtl feature which chooses a TTL based on the response's status code. If the response to this request has a status code that matches, Cloudflare will cache for the instructed time and override cache instructives sent by the origin. For example: { "200-299": 86400, "404": 1, "500-599": 0 }. The value can be any integer, including zero and negative integers. A value of 0 indicates that the cache asset expires immediately. Any negative value instructs Cloudflare not to cache at all.
              * @note This option applies to GET and HEAD request methods only.
              */
-            cacheTtlByStatus: z3.ZodOptional<z3.ZodRecord<z3.ZodString, z3.ZodNumber>>;
+            cacheTtlByStatus: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumberFormat>>;
             /**
              * Whether Mirage should be enabled for this request, if otherwise configured for this zone.
              * @link https://www.cloudflare.com/website-optimization/mirage/
              * @default true
              */
-            mirage: z3.ZodDefault<z3.ZodBoolean>;
+            mirage: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
             /**
              * Sets Polish mode. The possible values are lossy, lossless or off.
              * @link https://blog.cloudflare.com/introducing-polish-automatic-image-optimizati/
              */
-            polish: z3.ZodOptional<z3.ZodEnum<["lossy", "lossless", "off"]>>;
+            polish: z.ZodMiniOptional<z.ZodMiniEnum<{
+                lossy: "lossy";
+                lossless: "lossless";
+                off: "off";
+            }>>;
             /**
              * Whether ScrapeShield should be enabled for this request, if otherwise configured for this zone.
              * @link https://blog.cloudflare.com/introducing-scrapeshield-discover-defend-dete/
              * @default true
              */
-            scrapeShield: z3.ZodDefault<z3.ZodBoolean>;
+            scrapeShield: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
             /**
              * Enables or disables WebP image format in Polish.
              * @link https://blog.cloudflare.com/a-very-webp-new-year-from-cloudflare/
              */
-            webp: z3.ZodOptional<z3.ZodBoolean>;
-        }, "strip", z3.ZodTypeAny, {
-            cacheEverything: boolean;
-            scrapeShield: boolean;
-            apps: boolean;
-            mirage: boolean;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            polish?: "off" | "lossy" | "lossless" | undefined;
-            webp?: boolean | undefined;
-        }, {
-            cacheEverything?: boolean | undefined;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            scrapeShield?: boolean | undefined;
-            apps?: boolean | undefined;
-            mirage?: boolean | undefined;
-            polish?: "off" | "lossy" | "lossless" | undefined;
-            webp?: boolean | undefined;
-        }>>;
-    }, "strip", z3.ZodTypeAny, {
-        logging: {
-            error: number;
-            level: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        };
-        cf: {
-            cacheEverything: boolean;
-            scrapeShield: boolean;
-            apps: boolean;
-            mirage: boolean;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            polish?: "off" | "lossy" | "lossless" | undefined;
-            webp?: boolean | undefined;
-        };
-    }, {
-        logging?: {
-            error?: number | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-            level?: number | undefined;
-            color?: boolean | undefined;
-        } | undefined;
-        cf?: {
-            cacheEverything?: boolean | undefined;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            scrapeShield?: boolean | undefined;
-            apps?: boolean | undefined;
-            mirage?: boolean | undefined;
-            polish?: "off" | "lossy" | "lossless" | undefined;
-            webp?: boolean | undefined;
-        } | undefined;
-    }>>>;
+            webp: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     /**
      * Creates an instance of the Cloudflare API client with enhanced logging capabilities.
      *
@@ -168,55 +102,21 @@ export declare class NetHelpers {
      * - Formatting and coloring log output for better readability.
      * - Stripping redundant parts of URLs and wrapping unique IDs in brackets with color coding.
      */
-    static cfApi(apiKey: string, config?: z3.input<Awaited<ReturnType<typeof NetHelpers.cfApiConfig>>>): Promise<import("cloudflare").Cloudflare>;
-    static loggingFetchInit(): Promise<z3.ZodObject<{
-        logging: z3.ZodDefault<z3.ZodObject<{
-            level: z3.ZodDefault<z3.ZodNumber>;
-            error: z3.ZodDefault<z3.ZodNumber>;
-            color: z3.ZodDefault<z3.ZodBoolean>;
-            custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
-        }, "strip", z3.ZodTypeAny, {
-            error: number;
-            level: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        }, {
-            error?: number | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-            level?: number | undefined;
-            color?: boolean | undefined;
-        }>>;
-    }, "strip", z3.ZodTypeAny, {
-        logging: {
-            error: number;
-            level: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        };
-    }, {
-        logging?: {
-            error?: number | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-            level?: number | undefined;
-            color?: boolean | undefined;
-        } | undefined;
-    }>>;
-    static loggingFetchInitLogging(): Promise<z3.ZodDefault<z3.ZodObject<{
-        level: z3.ZodDefault<z3.ZodNumber>;
-        error: z3.ZodDefault<z3.ZodNumber>;
-        color: z3.ZodDefault<z3.ZodBoolean>;
-        custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
-    }, "strip", z3.ZodTypeAny, {
-        error: number;
-        level: number;
-        color: boolean;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-    }, {
-        error?: number | undefined;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        level?: number | undefined;
-        color?: boolean | undefined;
-    }>>>;
+    static cfApi(apiKey: string, config?: z.input<typeof NetHelpers.cfApiConfig>): Promise<import("cloudflare").Cloudflare>;
+    static loggingFetchInitLogging: z.ZodMiniDefault<z.ZodMiniObject<{
+        level: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        error: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        color: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+        custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniFunction<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>, z.ZodMiniTransform<(args_0: any, ...args: any[]) => void | Promise<void>, z.core.$InferOuterFunctionType<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>>>>;
+    }, z.core.$strip>>;
+    static loggingFetchInit: z.ZodMiniObject<{
+        logging: z.ZodMiniDefault<z.ZodMiniObject<{
+            level: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+            error: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+            color: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+            custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniFunction<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>, z.ZodMiniTransform<(args_0: any, ...args: any[]) => void | Promise<void>, z.core.$InferOuterFunctionType<z.ZodMiniTuple<readonly [z.ZodMiniAny], z.ZodMiniAny>, z.ZodMiniUnion<readonly [z.ZodMiniPromise<z.ZodMiniVoid>, z.ZodMiniVoid]>>>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     /**
      * A utility function that wraps the native `fetch` API with enhanced capabilities.
      * This function allows for customizable logging of request and response details, including headers, body, and status, with support for colorized output and custom logging handlers.
@@ -288,12 +188,12 @@ export declare class NetHelpers {
      * @returns {Record<string, number | null>} An object where keys are metric names (with optional descriptions) and values are the durations in milliseconds or null.
      */
     static serverTiming(serverTimingHeader?: string): Record<string, number | null>;
-    static withRetryInit(): Promise<z4.ZodDefault<z4.ZodObject<{
-        maxRetries: z4.ZodDefault<z4.ZodInt>;
-        initialDelay: z4.ZodDefault<z4.ZodInt>;
-        maxDelay: z4.ZodDefault<z4.ZodInt>;
-        backoffFactor: z4.ZodDefault<z4.ZodInt>;
-    }, z4.core.$strip>>>;
+    static withRetryInit: z.ZodMiniDefault<z.ZodMiniObject<{
+        maxRetries: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        initialDelay: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        maxDelay: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+        backoffFactor: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
+    }, z.core.$strip>>;
     /**
      * Executes an asynchronous operation with configurable retry logic.
      *
@@ -319,5 +219,5 @@ export declare class NetHelpers {
      * // With custom retry configuration
      * await NetHelpers.withRetry(() => apiCall(), { maxRetries: 5, initialDelay: 200 })
      */
-    static withRetry<T>(operation: () => Promise<T>, config?: z4.input<Awaited<ReturnType<typeof NetHelpers.withRetryInit>>>): Promise<T>;
+    static withRetry<T>(operation: () => Promise<T>, config?: z.input<typeof NetHelpers.withRetryInit>): Promise<T>;
 }

package/dist/net.mjs

@@ -1,3 +1,4 @@
+import * as z from 'zod/mini';
 /**
  * Enum representing HTTP request methods.
  *
@@ -16,87 +17,97 @@ export var Methods;
     Methods["PATCH"] = "PATCH";
 })(Methods || (Methods = {}));
 export class NetHelpers {
-    static cfApiConfig() {
-        return import('zod/v3').then(({ z: z3 }) => z3
-            .object({
-            logging: z3
-                .object({
-                level: z3.coerce.number().int().min(0).max(3).default(0),
-                error: z3.coerce.number().int().min(0).max(3).default(1),
-                color: z3.boolean().default(true),
-                custom: z3
-                    .function()
-                    .args()
-                    .returns(z3.union([z3.void(), z3.promise(z3.void())]))
-                    .optional(),
-            })
-                .default({}),
-            cf: z3
-                .object({
-                /**
-                 * Whether Cloudflare Apps should be enabled for this request
-                 * @link https://www.cloudflare.com/apps/
-                 * @default true
-                 */
-                apps: z3.boolean().default(true),
-                /**
-                 * Treats all content as static and caches all file types beyond the Cloudflare default cached content. Respects cache headers from the origin web server. This is equivalent to setting the Page Rule Cache Level (to Cache Everything).
-                 * @default false
-                 * @note This option applies to GET and HEAD request methods only
-                 */
-                cacheEverything: z3.boolean().default(false),
-                /**
-                 * A request’s cache key is what determines if two requests are the same for caching purposes. If a request has the same cache key as some previous request, then Cloudflare can serve the same cached response for both.
-                 */
-                cacheKey: z3.string().nonempty().optional(),
-                /**
-                 * This option appends additional Cache-Tag headers to the response from the origin server. This allows for purges of cached content based on tags provided by the Worker, without modifications to the origin server. This is performed using the Purge by Tag feature.
-                 */
-                cacheTags: z3.array(z3.string().nonempty()).nonempty().optional(),
-                /**
-                 * This option forces Cloudflare to cache the response for this request, regardless of what headers are seen on the response. This is equivalent to setting two Page Rules: Edge Cache TTL and Cache Level (to Cache Everything). The value must be zero or a positive number. A value of 0 indicates that the cache asset expires immediately.
-                 * @note This option applies to GET and HEAD request methods only.
-                 */
-                cacheTtl: z3.coerce.number().int().nonnegative().optional(),
-                /**
-                 * This option is a version of the cacheTtl feature which chooses a TTL based on the response’s status code. If the response to this request has a status code that matches, Cloudflare will cache for the instructed time and override cache instructives sent by the origin. For example: { "200-299": 86400, "404": 1, "500-599": 0 }. The value can be any integer, including zero and negative integers. A value of 0 indicates that the cache asset expires immediately. Any negative value instructs Cloudflare not to cache at all.
-                 * @note This option applies to GET and HEAD request methods only.
-                 */
-                cacheTtlByStatus: z3
-                    .record(z3
-                    .string()
-                    .nonempty()
-                    .regex(/^(1|2|3|4|5)\d{2}(-(1|2|3|4|5)\d{2})?$/), z3.coerce.number().int())
-                    .optional(),
-                // image:
-                /**
-                 * Whether Mirage should be enabled for this request, if otherwise configured for this zone.
-                 * @link https://www.cloudflare.com/website-optimization/mirage/
-                 * @default true
-                 */
-                mirage: z3.boolean().default(true),
-                /**
-                 * Sets Polish mode. The possible values are lossy, lossless or off.
-                 * @link https://blog.cloudflare.com/introducing-polish-automatic-image-optimizati/
-                 */
-                polish: z3.enum(['lossy', 'lossless', 'off']).optional(),
-                // resolveOverride:
-                /**
-                 * Whether ScrapeShield should be enabled for this request, if otherwise configured for this zone.
-                 * @link https://blog.cloudflare.com/introducing-scrapeshield-discover-defend-dete/
-                 * @default true
-                 */
-                scrapeShield: z3.boolean().default(true),
-                /**
-                 * Enables or disables WebP image format in Polish.
-                 * @link https://blog.cloudflare.com/a-very-webp-new-year-from-cloudflare/
-                 */
-                webp: z3.boolean().optional(),
-            })
-                .default({}),
-        })
-            .default({}));
-    }
+    static customLogging = z.function({
+        input: z.tuple([z.any()], z.any()),
+        output: z.union([z.promise(z.void()), z.void()]),
+    });
+    static cfApiConfig = z._default(z.object({
+        logging: z._default(z.object({
+            level: z._default(z.int().check(z.minimum(0), z.maximum(3)), 0),
+            error: z._default(z.int().check(z.minimum(0), z.maximum(3)), 1),
+            color: z._default(z.boolean(), true),
+            custom: z.optional(z.pipe(this.customLogging, 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            z.transform((fn) => fn))),
+        }), {
+            level: 0,
+            error: 1,
+            color: true,
+        }),
+        cf: z._default(z.object({
+            /**
+             * Whether Cloudflare Apps should be enabled for this request
+             * @link https://www.cloudflare.com/apps/
+             * @default true
+             */
+            apps: z._default(z.boolean(), true),
+            /**
+             * Treats all content as static and caches all file types beyond the Cloudflare default cached content. Respects cache headers from the origin web server. This is equivalent to setting the Page Rule Cache Level (to Cache Everything).
+             * @default false
+             * @note This option applies to GET and HEAD request methods only
+             */
+            cacheEverything: z._default(z.boolean(), false),
+            /**
+             * A request's cache key is what determines if two requests are the same for caching purposes. If a request has the same cache key as some previous request, then Cloudflare can serve the same cached response for both.
+             */
+            cacheKey: z.optional(z.string().check(z.minLength(1))),
+            /**
+             * This option appends additional Cache-Tag headers to the response from the origin server. This allows for purges of cached content based on tags provided by the Worker, without modifications to the origin server. This is performed using the Purge by Tag feature.
+             */
+            cacheTags: z.optional(z.array(z.string().check(z.minLength(1))).check(z.minLength(1))),
+            /**
+             * This option forces Cloudflare to cache the response for this request, regardless of what headers are seen on the response. This is equivalent to setting two Page Rules: Edge Cache TTL and Cache Level (to Cache Everything). The value must be zero or a positive number. A value of 0 indicates that the cache asset expires immediately.
+             * @note This option applies to GET and HEAD request methods only.
+             */
+            cacheTtl: z.optional(z.int().check(z.nonnegative())),
+            /**
+             * This option is a version of the cacheTtl feature which chooses a TTL based on the response's status code. If the response to this request has a status code that matches, Cloudflare will cache for the instructed time and override cache instructives sent by the origin. For example: { "200-299": 86400, "404": 1, "500-599": 0 }. The value can be any integer, including zero and negative integers. A value of 0 indicates that the cache asset expires immediately. Any negative value instructs Cloudflare not to cache at all.
+             * @note This option applies to GET and HEAD request methods only.
+             */
+            cacheTtlByStatus: z.optional(z.record(z.string().check(z.minLength(1), z.regex(/^(1|2|3|4|5)\d{2}(-(1|2|3|4|5)\d{2})?$/)), z.int())),
+            // image:
+            /**
+             * Whether Mirage should be enabled for this request, if otherwise configured for this zone.
+             * @link https://www.cloudflare.com/website-optimization/mirage/
+             * @default true
+             */
+            mirage: z._default(z.boolean(), true),
+            /**
+             * Sets Polish mode. The possible values are lossy, lossless or off.
+             * @link https://blog.cloudflare.com/introducing-polish-automatic-image-optimizati/
+             */
+            polish: z.optional(z.enum(['lossy', 'lossless', 'off'])),
+            // resolveOverride:
+            /**
+             * Whether ScrapeShield should be enabled for this request, if otherwise configured for this zone.
+             * @link https://blog.cloudflare.com/introducing-scrapeshield-discover-defend-dete/
+             * @default true
+             */
+            scrapeShield: z._default(z.boolean(), true),
+            /**
+             * Enables or disables WebP image format in Polish.
+             * @link https://blog.cloudflare.com/a-very-webp-new-year-from-cloudflare/
+             */
+            webp: z.optional(z.boolean()),
+        }), {
+            apps: true,
+            cacheEverything: false,
+            mirage: true,
+            scrapeShield: true,
+        }),
+    }), {
+        logging: {
+            level: 0,
+            error: 1,
+            color: true,
+        },
+        cf: {
+            apps: true,
+            cacheEverything: false,
+            mirage: true,
+            scrapeShield: true,
+        },
+    });
     /**
      * Creates an instance of the Cloudflare API client with enhanced logging capabilities.
      *
@@ -119,7 +130,7 @@ export class NetHelpers {
         return Promise.all([
             //
             import('cloudflare'),
-            NetHelpers.cfApiConfig().then((parser) => parser.parseAsync(config)),
+            NetHelpers.cfApiConfig.parseAsync(config),
         ]).then(([{ Cloudflare }, config]) => new Cloudflare({
             apiToken: apiKey,
             fetch: (info, init) => this.loggingFetch(info, {
@@ -134,7 +145,9 @@ export class NetHelpers {
                     error: config.logging.error === 1 ? 2 : config.logging.error,
                     ...('color' in config.logging && { color: config.logging.color }),
                     ...((config.logging.level > 0 || config.logging.error > 0) && {
-                        custom: async (...args) => {
+                        custom: this.customLogging.implementAsync(async (args_0, ...args_x) => {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            const args = [args_0, ...args_x];
                             const [, id, , url, headers] = args;
                             const customUrl = new URL(url);
                             const customHeaders = new Headers(headers);
@@ -152,16 +165,28 @@ export class NetHelpers {
                             if ('custom' in config && config.logging.custom) {
                                 // We faked level 1 as 2 to get headers for ray-id
                                 if (config.logging.level === 1 || config.logging.error === 1) {
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                    const [argsFirst, ...argsRest] = args.slice(0, -1);
                                     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                                    return config.logging.custom(...args.slice(0, -1));
+                                    return config.logging.custom(argsFirst, ...argsRest);
                                 }
                                 else {
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                    const [argsFirst, ...argsRest] = args;
                                     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                                    return config.logging.custom(...args);
+                                    return config.logging.custom(argsFirst, ...argsRest);
                                 }
                             }
                             else {
-                                await Promise.all([import('strip-ansi'), import('chalk').then(({ Chalk }) => new Chalk({ level: 2 })), import("./index.mjs")]).then(([{ default: stripAnsi }, chalk, { Helpers }]) => {
+                                await Promise.all([
+                                    // Try the new native one
+                                    import('node:util')
+                                        .then(({ stripVTControlCharacters }) => stripVTControlCharacters)
+                                        // For web or unavailable node in general
+                                        .catch(() => import('strip-ansi').then(({ default: stripAnsi }) => stripAnsi)),
+                                    import('chalk').then(({ Chalk }) => new Chalk({ level: 2 })),
+                                    import("./index.mjs"),
+                                ]).then(([ansiStripper, chalk, { Helpers }]) => {
                                     // We faked level 1 as 2 to get headers for ray-id
                                     if (config.logging.level === 1) {
                                         console.info('CF Rest', 
@@ -174,9 +199,9 @@ export class NetHelpers {
                                             // Wrap id in brackets
                                             .map((value) => {
                                             if (value === id) {
-                                                const wrappedString = `[${stripAnsi(id)}]`;
+                                                const wrappedString = `[${ansiStripper(id)}]`;
                                                 if (config.logging.color) {
-                                                    return chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(wrappedString);
+                                                    return chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(wrappedString);
                                                 }
                                                 else {
                                                     return wrappedString;
@@ -202,9 +227,9 @@ export class NetHelpers {
                                             // Wrap id in brackets
                                             .map((value) => {
                                             if (value === id) {
-                                                const wrappedString = `[${stripAnsi(id)}]`;
+                                                const wrappedString = `[${ansiStripper(id)}]`;
                                                 if (config.logging.color) {
-                                                    return chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(wrappedString);
+                                                    return chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(wrappedString);
                                                 }
                                                 else {
                                                     return wrappedString;
@@ -229,9 +254,9 @@ export class NetHelpers {
                                             // Wrap id in brackets
                                             .map((value) => {
                                             if (value === id) {
-                                                const wrappedString = `[${stripAnsi(id)}]`;
+                                                const wrappedString = `[${ansiStripper(id)}]`;
                                                 if (config.logging.color) {
-                                                    return chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(wrappedString);
+                                                    return chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(wrappedString);
                                                 }
                                                 else {
                                                     return wrappedString;
@@ -256,9 +281,9 @@ export class NetHelpers {
                                             // Wrap id in brackets
                                             .map((value) => {
                                             if (value === id) {
-                                                const wrappedString = `[${stripAnsi(id)}]`;
+                                                const wrappedString = `[${ansiStripper(id)}]`;
                                                 if (config.logging.color) {
-                                                    return chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(wrappedString);
+                                                    return chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(wrappedString);
                                                 }
                                                 else {
                                                     return wrappedString;
@@ -275,30 +300,27 @@ export class NetHelpers {
                                     }
                                 });
                             }
-                        },
+                        }),
                     }),
                 },
             }),
         }));
     }
-    static loggingFetchInit() {
-        return Promise.all([import('zod/v3'), this.loggingFetchInitLogging()]).then(([{ z: z3 }, logging]) => z3.object({
-            logging,
-        }));
-    }
-    static loggingFetchInitLogging() {
-        return import('zod/v3').then(({ z: z3 }) => z3
-            .object({
-            level: z3.coerce.number().int().min(0).max(3).default(0),
-            error: z3.coerce.number().int().min(0).max(3).default(1),
-            color: z3.boolean().default(true),
-            custom: z3
-                .function()
-                .returns(z3.union([z3.void(), z3.promise(z3.void())]))
-                .optional(),
-        })
-            .default({}));
-    }
+    static loggingFetchInitLogging = z._default(z.object({
+        level: z._default(z.int().check(z.minimum(0), z.maximum(3)), 0),
+        error: z._default(z.int().check(z.minimum(0), z.maximum(3)), 1),
+        color: z._default(z.boolean(), true),
+        custom: z.optional(z.pipe(this.customLogging, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        z.transform((fn) => fn))),
+    }), {
+        level: 0,
+        error: 1,
+        color: true,
+    });
+    static loggingFetchInit = z.object({
+        logging: this.loggingFetchInitLogging,
+    });
     /**
      * A utility function that wraps the native `fetch` API with enhanced capabilities.
      * This function allows for customizable logging of request and response details, including headers, body, and status, with support for colorized output and custom logging handlers.
@@ -335,9 +357,15 @@ export class NetHelpers {
      */
     static loggingFetch(info, init) {
         return Promise.all([
-            NetHelpers.loggingFetchInit()
-                .then((parser) => parser.passthrough().parseAsync(init))
-                .then((parsed) => parsed),
+            z
+                .pipe(z._default(z.looseObject(this.loggingFetchInit.def.shape), {
+                logging: {
+                    level: 0,
+                    error: 1,
+                    color: true,
+                },
+            }), z.transform((parsed) => parsed))
+                .parseAsync(init),
             import("./crypto.mjs").then(({ CryptoHelpers }) => CryptoHelpers.base62secret(8)),
         ]).then(async ([init, id]) => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -393,8 +421,10 @@ export class NetHelpers {
                     ]).catch(() => { });
                 }
                 if (init.logging.level > 0 && 'custom' in init.logging && init.logging.custom) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const [requestLoggingItemsFirst, ...requestLoggingItemsRest] = requestLoggingItems;
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    await init.logging.custom(...requestLoggingItems);
+                    await init.logging.custom(requestLoggingItemsFirst, ...requestLoggingItemsRest);
                 }
                 else if (init.logging.level > 0) {
                     console.info(
@@ -459,15 +489,21 @@ export class NetHelpers {
                             .catch(() => { });
                     }
                     if (init.logging.level > 0 && 'custom' in init.logging && init.logging.custom) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const [responseLoggingItemsFirst, ...responseLoggingItemsRest] = responseLoggingItems;
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        await init.logging.custom(...responseLoggingItems);
+                        await init.logging.custom(responseLoggingItemsFirst, ...responseLoggingItemsRest);
                     }
                     else if (init.logging.error > 0 && !response.ok && 'custom' in init.logging && init.logging.custom) {
                         // Send request errors too (since we barely now know if error or not)
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const [requestErrorItemsFirst, ...requestErrorItemsRest] = requestErrorItems;
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        await init.logging.custom(...requestErrorItems);
+                        await init.logging.custom(requestErrorItemsFirst, ...requestErrorItemsRest);
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const [responseErrorItemsFirst, ...responseErrorItemsRest] = responseErrorItems;
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        await init.logging.custom(...responseErrorItems);
+                        await init.logging.custom(responseErrorItemsFirst, ...responseErrorItemsRest);
                     }
                     else if (init.logging.level > 0) {
                         console.info(
@@ -621,21 +657,17 @@ export class NetHelpers {
         }
         return result;
     }
-    static withRetryInit() {
-        return import('zod/v4').then(({ z: z4 }) => z4
-            .object({
-            maxRetries: z4.int().nonnegative().default(3),
-            initialDelay: z4.int().nonnegative().default(100),
-            maxDelay: z4.int().nonnegative().default(1000),
-            backoffFactor: z4.int().nonnegative().default(2),
-        })
-            .default({
-            maxRetries: 3,
-            initialDelay: 100,
-            maxDelay: 1000,
-            backoffFactor: 2,
-        }));
-    }
+    static withRetryInit = z._default(z.object({
+        maxRetries: z._default(z.int().check(z.nonnegative()), 3),
+        initialDelay: z._default(z.int().check(z.nonnegative()), 100),
+        maxDelay: z._default(z.int().check(z.nonnegative()), 1000),
+        backoffFactor: z._default(z.int().check(z.nonnegative()), 2),
+    }), {
+        maxRetries: 3,
+        initialDelay: 100,
+        maxDelay: 1000,
+        backoffFactor: 2,
+    });
     /**
      * Executes an asynchronous operation with configurable retry logic.
      *
@@ -662,7 +694,7 @@ export class NetHelpers {
      * await NetHelpers.withRetry(() => apiCall(), { maxRetries: 5, initialDelay: 200 })
      */
     static withRetry(operation, config) {
-        return Promise.all([NetHelpers.withRetryInit().then((parser) => parser.parseAsync(config)), import('./common.mjs')]).then(async ([config, { Helpers }]) => {
+        return Promise.all([NetHelpers.withRetryInit.parseAsync(config), import('./common.mjs')]).then(async ([config, { Helpers }]) => {
             let lastError;
             let delay = config.initialDelay;
             for (let attempt = 0; attempt <= config.maxRetries; attempt++) {

package/dist/uuid8.d.mts

@@ -1,20 +1,20 @@
 import { DOCombinedLocations } from '@chainfuse/types';
 import { ShardType } from '@chainfuse/types/d0';
-import { z } from 'zod/v4';
-export declare const v8Options: z.ZodUnion<readonly [z.ZodObject<{
-    msecs: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodPipe<z.ZodDate, z.ZodTransform<number, Date>>]>>;
-    seq: z.ZodOptional<z.ZodInt>;
-    location: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodEnum<typeof DOCombinedLocations>>, z.ZodTransform<string, DOCombinedLocations>>]>;
-    shardType: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodEnum<typeof ShardType>>, z.ZodTransform<string, ShardType>>]>;
-    suffix: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, z.ZodTransform<string, Uint8Array<ArrayBuffer>>>]>;
-    random: z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
-}, z.core.$strip>, z.ZodObject<{
-    msecs: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodPipe<z.ZodDate, z.ZodTransform<number, Date>>]>>;
-    seq: z.ZodOptional<z.ZodInt>;
-    location: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodEnum<typeof DOCombinedLocations>>, z.ZodTransform<string, DOCombinedLocations>>]>;
-    shardType: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodEnum<typeof ShardType>>, z.ZodTransform<string, ShardType>>]>;
-    suffix: z.ZodUnion<readonly [z.ZodDefault<z.ZodCustomStringFormat<"hex">>, z.ZodPipe<z.ZodDefault<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, z.ZodTransform<string, Uint8Array<ArrayBuffer>>>]>;
-    rng: z.ZodOptional<z.ZodFunction<z.ZodTuple<readonly [], null>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+import * as z from 'zod/mini';
+export declare const v8Options: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    msecs: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniNumberFormat, z.ZodMiniPipe<z.ZodMiniDate<Date>, z.ZodMiniTransform<number, Date>>]>>;
+    seq: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    location: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniEnum<typeof DOCombinedLocations>>, z.ZodMiniTransform<string, DOCombinedLocations>>]>;
+    shardType: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniEnum<typeof ShardType>>, z.ZodMiniTransform<string, ShardType>>]>;
+    suffix: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, z.ZodMiniTransform<string, Uint8Array<ArrayBuffer>>>]>;
+    random: z.ZodMiniOptional<z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    msecs: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniNumberFormat, z.ZodMiniPipe<z.ZodMiniDate<Date>, z.ZodMiniTransform<number, Date>>]>>;
+    seq: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    location: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniEnum<typeof DOCombinedLocations>>, z.ZodMiniTransform<string, DOCombinedLocations>>]>;
+    shardType: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniEnum<typeof ShardType>>, z.ZodMiniTransform<string, ShardType>>]>;
+    suffix: z.ZodMiniUnion<readonly [z.ZodMiniDefault<z.ZodMiniCustomStringFormat<"hex">>, z.ZodMiniPipe<z.ZodMiniDefault<z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, z.ZodMiniTransform<string, Uint8Array<ArrayBuffer>>>]>;
+    rng: z.ZodMiniOptional<z.ZodMiniFunction<z.ZodMiniTuple<[], null>, z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
 }, z.core.$strip>]>;
 export type Version8Options = z.input<typeof v8Options>;
 /**

package/dist/uuid8.mjs

@@ -1,69 +1,52 @@
 import { DOCombinedLocations } from '@chainfuse/types';
 import { ShardType } from '@chainfuse/types/d0';
 import { v7 } from 'uuid';
-import { z } from 'zod/v4';
+import * as z from 'zod/mini';
 import { BufferHelpersInternals } from "./bufferInternals.mjs";
 const v8OptionsBase = z.object({
     /**
      * RFC "timestamp" field
      */
-    msecs: z
-        .union([
-        z.int().nonnegative(),
+    msecs: z.optional(z.union([
+        z.int().check(z.nonnegative()),
         // Allow converting from Date object
-        z.date().transform((date) => date.getTime()),
-    ])
-        .optional(),
+        z.pipe(z.date(), z.transform((date) => date.getTime())),
+    ])),
     /**
      * 32-bit sequence Number between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value.
      */
-    seq: z.int().min(0).max(0xffffffff).optional(),
+    seq: z.optional(z.int().check(z.minimum(0), z.maximum(0xffffffff))),
     location: z.union([
         //
-        z.hex().length(2).default('00'),
-        z
-            .enum(DOCombinedLocations)
-            .default(DOCombinedLocations.none)
-            .transform((r) => r.toString(16).padStart(2, '0').slice(-2)),
+        z._default(z.hex().check(z.length(2)), '00'),
+        z.pipe(z._default(z.enum(DOCombinedLocations), DOCombinedLocations.none), z.transform((l) => l.toString(16).padStart(2, '0').slice(-2))),
     ]),
     shardType: z.union([
         //
-        z.hex().length(1).default('0'),
-        z
-            .enum(ShardType)
-            .default(ShardType.Director)
-            .transform((st) => st.toString(16).padStart(1, '0')),
+        z._default(z.hex().check(z.length(1)), '0'),
+        z.pipe(z._default(z.enum(ShardType), ShardType.Director), z.transform((st) => st.toString(16).padStart(1, '0'))),
     ]),
     suffix: z.union([
-        z.hex().length(3).default('000'),
+        z._default(z.hex().check(z.length(3)), '000'),
         // It's technically 1.5 bytes, but we round up to nearest integer
-        z
-            .instanceof(Uint8Array)
-            .refine((arr) => arr.byteLength === 2, { message: 'suffix must be a Uint8Array of 2 bytes' })
-            .default(new Uint8Array(2))
-            .transform((arr) => BufferHelpersInternals.browser_bufferToHex(arr.buffer).padStart(3, '0').slice(-3)),
+        z.pipe(z._default(z.instanceof(Uint8Array).check(z.refine((arr) => arr.byteLength === 2, { message: 'suffix must be a Uint8Array of 2 bytes' })), new Uint8Array(2)), z.transform((arr) => BufferHelpersInternals.browser_bufferToHex(arr.buffer).padStart(3, '0').slice(-3))),
     ]),
 });
 export const v8Options = z.union([
-    v8OptionsBase.extend({
+    z.extend(v8OptionsBase, {
         /**
          * Array of 16 random bytes (0-255) used to generate other fields
          */
-        random: z
-            .instanceof(Uint8Array)
-            .refine((arr) => arr.byteLength === 16, { message: '`random` must be a Uint8Array of 16 random bytes' })
-            .optional(),
+        random: z.optional(z.instanceof(Uint8Array).check(z.refine((arr) => arr.byteLength === 16, { message: '`random` must be a Uint8Array of 16 random bytes' }))),
     }),
-    v8OptionsBase.extend({
+    z.extend(v8OptionsBase, {
         /**
          * Alternative to options.random, a Function that returns an Array of 16 random bytes (0-255)
          */
-        rng: z
-            .function({
+        rng: z.optional(z.function({
             input: [],
-            output: z.instanceof(Uint8Array).refine((arr) => arr.byteLength === 16, { message: '`random` must be a Uint8Array of 16 random bytes' }),
-        })
-            .optional(),
+            output: z.instanceof(Uint8Array).check(z.refine((arr) => arr.byteLength === 16, { message: '`random` must be a Uint8Array of 16 random bytes' })),
+        })),
     }),
 ]);
 function replaceByIndex(input, start, end, replacement) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "3.6.0",
+	"version": "3.6.1",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -80,7 +80,7 @@
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
-		"@chainfuse/types": "^2.12.0",
+		"@chainfuse/types": "^2.12.1",
 		"@discordjs/rest": "^2.6.0",
 		"chalk": "^5.6.2",
 		"cloudflare": "^5.0.0",
@@ -93,5 +93,5 @@
 		"@cloudflare/workers-types": "^4.20250909.0",
 		"@types/node": "^22.18.1"
 	},
-	"gitHead": "fe95f7c82786f19dda1e465f38b19be98613f981"
+	"gitHead": "4259cf9c169a4aced88159526927fe52bde6d658"
 }