@chainfuse/helpers 3.5.6 → 3.6.1

package/README.md

@@ -15,3 +15,13 @@ import helpers from '@chainfuse/helpers';
 
 // TODO: DEMONSTRATE API
 ```
+
+## UUIDv8
+
+Based on UUIDv7 but with added values to prevent unnecessary lookups
+
+`01f3ffff-fc18-8bb7-9120-cabc55668d92`
+
+| 01f3ffff-fc18                             | 8            | bb7                               | 9                                | 12                                       | 0           | cabc55668d92   |
+| ----------------------------------------- | ------------ | --------------------------------- | -------------------------------- | ---------------------------------------- | ----------- | -------------- |
+| 48bit Timestamp (Unix epoch milliseconds) | UUID Version | Suffix random (`000` if director) | variant (2 bits) + 2 random bits | `DOCombinedLocations` (`00` if anywhere) | `ShardType` | 48 random bits |

package/dist/buffers.d.mts

@@ -1,5 +1,7 @@
 import type { UndefinedProperties } from '@chainfuse/types';
-import type { PrefixedUuid, UuidExport } from '@chainfuse/types/d1';
+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 {
     static bigintToBuffer(number: bigint): Promise<ArrayBuffer>;
@@ -9,7 +11,22 @@ export declare class BufferHelpers {
     static bufferToHex(buffer: UuidExportBlobInput): Promise<string>;
     static base64ToBuffer(rawBase64: string): Promise<ArrayBuffer>;
     static bufferToBase64(buffer: UuidExportBlobInput, urlSafe: boolean): Promise<string>;
+    /**
+     * @deprecated Use `BufferHelpers.generateUuid7` instead
+     */
     static get generateUuid(): Promise<UuidExport>;
+    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>>;
     static uuidConvert(prefixedUtf: PrefixedUuid): Promise<UuidExport>;
     static uuidConvert(input: UuidExport['utf8']): Promise<UuidExport>;
@@ -17,4 +34,11 @@ export declare class BufferHelpers {
     static uuidConvert(input: UuidExportBlobInput): Promise<UuidExport>;
     static uuidConvert(input: UuidExport['base64']): Promise<UuidExport>;
     static uuidConvert(input: UuidExport['base64url']): Promise<UuidExport>;
+    static uuidExtractor(input: undefined): Promise<UUIDExtract>;
+    static uuidExtractor(prefixedUtf: PrefixedUuid): Promise<UUIDExtract>;
+    static uuidExtractor(input: UuidExport['utf8']): Promise<UUIDExtract>;
+    static uuidExtractor(input: UuidExport['hex']): Promise<UUIDExtract>;
+    static uuidExtractor(input: UuidExportBlobInput): Promise<UUIDExtract>;
+    static uuidExtractor(input: UuidExport['base64']): Promise<UUIDExtract>;
+    static uuidExtractor(input: UuidExport['base64url']): Promise<UUIDExtract>;
 }

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,27 +20,67 @@ 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));
     }
+    /**
+     * @deprecated Use `BufferHelpers.generateUuid7` instead
+     */
     static get generateUuid() {
-        return Promise.all([CryptoHelpers.secretBytes(16), import('uuid')]).then(([random, { v7: uuidv7 }]) => {
-            const uuid = uuidv7({ random });
+        return this.generateUuid7();
+    }
+    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.parseAsync(_options ?? {}),
+            CryptoHelpers.secretBytes(16),
+        ]).then(([{ v7: uuidv7 }, options, random]) => {
+            const uuid = uuidv7({ msecs: options.msecs, random, seq: options.seq });
+            const uuidHex = uuid.replaceAll('-', '');
+            return this.hexToBuffer(uuidHex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
+                utf8: uuid,
+                hex: uuidHex,
+                blob,
+                base64,
+                base64url,
+            })));
+        });
+    }
+    static generateUuid8(options) {
+        return Promise.all([import('./uuid8.mjs'), CryptoHelpers.secretBytes(16)]).then(([{ v8: uuidv8 }, random]) => {
+            const uuid = uuidv8({
+                // @ts-expect-error they're the exact same
+                random,
+                ...options,
+            });
             const uuidHex = uuid.replaceAll('-', '');
             return this.hexToBuffer(uuidHex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
                 utf8: uuid,
@@ -134,4 +176,45 @@ export class BufferHelpers {
             base64url: undefined,
         }))();
     }
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static uuidExtractor(input) {
+        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) {
+                    if (utf8v8Success) {
+                        const suffix_hex = hex.substring(13, 16);
+                        const suffix_buffer = await BufferHelpers.hexToBuffer(suffix_hex);
+                        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'
+                                ? undefined
+                                : {
+                                    hex: suffix_hex,
+                                    base64: await BufferHelpers.bufferToBase64(suffix_buffer, false),
+                                    base64url: await BufferHelpers.bufferToBase64(suffix_buffer, true),
+                                },
+                        });
+                    }
+                    else {
+                        return UUIDExtract7.parseAsync({
+                            date: Number(BigInt(`0x${hex.substring(0, 12)}`)),
+                        });
+                    }
+                }
+                else {
+                    throw new Error('Unsupported UUID version provided');
+                }
+            }
+            else {
+                throw new Error('Invalid UUID provided');
+            }
+        });
+    }
 }

package/dist/crypto.mjs

@@ -5,7 +5,9 @@ export class CryptoHelpers {
         return CryptoHelpersInternals.node_secretBytes(byteSize).catch(() => CryptoHelpersInternals.browser_secretBytes(byteSize));
     }
     static base16secret(secretLength) {
-        return this.secretBytes(secretLength / 2).then((bytes) => BufferHelpers.bufferToHex(bytes.buffer));
+        return this.secretBytes(Math.ceil(secretLength / 2))
+            .then((bytes) => BufferHelpers.bufferToHex(bytes.buffer))
+            .then((hex) => hex.substring(0, secretLength));
     }
     static base62secret(secretLength) {
         const LOWER_CHAR_SET = 'abcdefghijklmnopqrstuvwxyz';

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

@@ -23,15 +23,15 @@ export declare class DiscordHelpers {
         color: z.ZodDefault<z.ZodBoolean>;
         custom: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodVoid, z.ZodPromise<z.ZodVoid>]>>>;
     }, "strip", z.ZodTypeAny, {
-        level: number;
         error: number;
+        level: number;
         color: boolean;
         custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
     }, {
-        level?: number | undefined;
+        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
         error?: number | undefined;
+        level?: number | undefined;
         color?: boolean | undefined;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
     }>>>;
     static discordRest(apiKey: string, logging: z.input<Awaited<ReturnType<typeof DiscordHelpers.disordRestLogging>>>, cacheTtl?: number, forceCache?: boolean, executionContext?: ExecutionContext, restOptions?: Partial<Omit<RESTOptions, 'agent' | 'authPrefix' | 'makeRequest'>>): Promise<import("@discordjs/rest").REST>;
     static userIcon(userId: bigint | string, userIconHash?: Parameters<CDN['avatar']>[1] | null, guildId?: bigint | string, memberIconHash?: Parameters<CDN['avatar']>[1] | null, options?: Parameters<CDN['avatar']>[2]): string;

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, {
-            level: number;
-            error: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        }, {
-            level?: number | undefined;
-            error?: number | undefined;
-            color?: boolean | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | 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, {
-            apps: boolean;
-            cacheEverything: boolean;
-            mirage: boolean;
-            scrapeShield: boolean;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            polish?: "lossy" | "lossless" | "off" | undefined;
-            webp?: boolean | undefined;
-        }, {
-            apps?: boolean | undefined;
-            cacheEverything?: boolean | undefined;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            mirage?: boolean | undefined;
-            polish?: "lossy" | "lossless" | "off" | undefined;
-            scrapeShield?: boolean | undefined;
-            webp?: boolean | undefined;
-        }>>;
-    }, "strip", z3.ZodTypeAny, {
-        logging: {
-            level: number;
-            error: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        };
-        cf: {
-            apps: boolean;
-            cacheEverything: boolean;
-            mirage: boolean;
-            scrapeShield: boolean;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            polish?: "lossy" | "lossless" | "off" | undefined;
-            webp?: boolean | undefined;
-        };
-    }, {
-        logging?: {
-            level?: number | undefined;
-            error?: number | undefined;
-            color?: boolean | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        } | undefined;
-        cf?: {
-            apps?: boolean | undefined;
-            cacheEverything?: boolean | undefined;
-            cacheKey?: string | undefined;
-            cacheTags?: [string, ...string[]] | undefined;
-            cacheTtl?: number | undefined;
-            cacheTtlByStatus?: Record<string, number> | undefined;
-            mirage?: boolean | undefined;
-            polish?: "lossy" | "lossless" | "off" | undefined;
-            scrapeShield?: boolean | 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, {
-            level: number;
-            error: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        }, {
-            level?: number | undefined;
-            error?: number | undefined;
-            color?: boolean | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        }>>;
-    }, "strip", z3.ZodTypeAny, {
-        logging: {
-            level: number;
-            error: number;
-            color: boolean;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        };
-    }, {
-        logging?: {
-            level?: number | undefined;
-            error?: number | undefined;
-            color?: boolean | undefined;
-            custom?: ((...args: unknown[]) => void | Promise<void>) | 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, {
-        level: number;
-        error: number;
-        color: boolean;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-    }, {
-        level?: number | undefined;
-        error?: number | undefined;
-        color?: boolean | undefined;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | 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

@@ -0,0 +1,37 @@
+import { DOCombinedLocations } from '@chainfuse/types';
+import { ShardType } from '@chainfuse/types/d0';
+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>;
+/**
+ * Generates a UUID version 8 with custom fields for location, shard type, and suffix.
+ *
+ * This function creates a UUID v8 by starting with a UUID v7 and then injecting custom fields into specific positions to encode regional information, shard types, and additional suffixes for distributed system identification.
+ *
+ * @param options - Configuration options for UUID generation
+ * @param options.msecs - RFC "timestamp" field - milliseconds since epoch or Date object
+ * @param options.seq - 32-bit sequence number (0 - 0xffffffff) for uniqueness within same millisecond
+ * @param options.location - Location identifier as hex string or DOCombinedLocations enum
+ * @param options.shardType - Shard type as hex string or ShardType enum
+ * @param options.suffix - Custom suffix as hex string or Uint8Array of 2 bytes
+ * @param options.random - Array of 16 random bytes for UUID generation
+ * @param options.rng - Alternative random number generator function
+ *
+ * @returns A UUID v8 string with embedded location, shard type, and suffix information
+ */
+export declare function v8(_options?: Version8Options): string;
+export default v8;

package/dist/uuid8.mjs

@@ -0,0 +1,83 @@
+import { DOCombinedLocations } from '@chainfuse/types';
+import { ShardType } from '@chainfuse/types/d0';
+import { v7 } from 'uuid';
+import * as z from 'zod/mini';
+import { BufferHelpersInternals } from "./bufferInternals.mjs";
+const v8OptionsBase = 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))),
+    location: z.union([
+        //
+        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._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._default(z.hex().check(z.length(3)), '000'),
+        // It's technically 1.5 bytes, but we round up to nearest integer
+        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([
+    z.extend(v8OptionsBase, {
+        /**
+         * Array of 16 random bytes (0-255) used to generate other fields
+         */
+        random: z.optional(z.instanceof(Uint8Array).check(z.refine((arr) => arr.byteLength === 16, { message: '`random` must be a Uint8Array of 16 random bytes' }))),
+    }),
+    z.extend(v8OptionsBase, {
+        /**
+         * Alternative to options.random, a Function that returns an Array of 16 random bytes (0-255)
+         */
+        rng: z.optional(z.function({
+            input: [],
+            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) {
+    return input.slice(0, start) + replacement + input.slice(end);
+}
+/**
+ * Generates a UUID version 8 with custom fields for location, shard type, and suffix.
+ *
+ * This function creates a UUID v8 by starting with a UUID v7 and then injecting custom fields into specific positions to encode regional information, shard types, and additional suffixes for distributed system identification.
+ *
+ * @param options - Configuration options for UUID generation
+ * @param options.msecs - RFC "timestamp" field - milliseconds since epoch or Date object
+ * @param options.seq - 32-bit sequence number (0 - 0xffffffff) for uniqueness within same millisecond
+ * @param options.location - Location identifier as hex string or DOCombinedLocations enum
+ * @param options.shardType - Shard type as hex string or ShardType enum
+ * @param options.suffix - Custom suffix as hex string or Uint8Array of 2 bytes
+ * @param options.random - Array of 16 random bytes for UUID generation
+ * @param options.rng - Alternative random number generator function
+ *
+ * @returns A UUID v8 string with embedded location, shard type, and suffix information
+ */
+export function v8(_options) {
+    const options = v8Options.parse(_options ?? {});
+    // 36 character string including hyphens
+    const uuid7 = v7(options);
+    // Swap version
+    const uuid8 = replaceByIndex(uuid7, 14, 15, '8');
+    // Inject
+    const uuid8Suffix = replaceByIndex(uuid8, 15, 18, options.suffix);
+    const uuid8SuffixLocation = replaceByIndex(uuid8Suffix, 20, 22, options.location);
+    const uuid8SuffixLocationShard = replaceByIndex(uuid8SuffixLocation, 22, 23, options.shardType);
+    return uuid8SuffixLocationShard;
+}
+export default v8;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "3.5.6",
+	"version": "3.6.1",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -72,11 +72,15 @@
 		"./net": {
 			"import": "./dist/net.mjs",
 			"types": "./dist/net.d.mts"
+		},
+		"./uuid8": {
+			"import": "./dist/uuid8.mjs",
+			"types": "./dist/uuid8.d.mts"
 		}
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
-		"@chainfuse/types": "^2.11.9",
+		"@chainfuse/types": "^2.12.1",
 		"@discordjs/rest": "^2.6.0",
 		"chalk": "^5.6.2",
 		"cloudflare": "^5.0.0",
@@ -86,8 +90,8 @@
 		"zod": "^4.1.5"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20250906.0",
+		"@cloudflare/workers-types": "^4.20250909.0",
 		"@types/node": "^22.18.1"
 	},
-	"gitHead": "cf7960f52cb435d5d305007caaf725f29c3e46b4"
+	"gitHead": "4259cf9c169a4aced88159526927fe52bde6d658"
 }