@chainfuse/helpers 4.0.1 → 4.0.3

package/dist/buffers.d.mts

@@ -5,12 +5,19 @@ import type { Version8Options } from './uuid8.mjs';
 export type UuidExportBlobInput = Buffer | UuidExport['blob'];
 export declare class BufferHelpers {
     static bigintToBuffer(number: bigint): Promise<ArrayBuffer>;
-    static bigintToHex(number: bigint): string;
+    static bigintToBufferSync(number: bigint): ArrayBuffer;
+    static bigintToHex(number: bigint): Promise<string>;
+    static bigintToHexSync(number: bigint): string;
     static bufferToBigint(buffer: UuidExportBlobInput): Promise<bigint>;
+    static bufferToBigintSync(buffer: UuidExportBlobInput): bigint;
     static hexToBuffer(hex: UuidExport['hex']): Promise<ArrayBuffer>;
+    static hexToBufferSync(hex: UuidExport['hex']): ArrayBuffer;
     static bufferToHex(buffer: UuidExportBlobInput): Promise<string>;
+    static bufferToHexSync(buffer: UuidExportBlobInput): string;
     static base64ToBuffer(rawBase64: string): Promise<ArrayBuffer>;
+    static base64ToBufferSync(rawBase64: string): ArrayBuffer;
     static bufferToBase64(buffer: UuidExportBlobInput, urlSafe: boolean): Promise<string>;
+    static bufferToBase64Sync(buffer: UuidExportBlobInput, urlSafe: boolean): string;
     static v7OptionsBase: z.ZodMiniObject<{
         /**
          * RFC "timestamp" field
@@ -22,7 +29,9 @@ export declare class BufferHelpers {
         seq: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
     }, z.core.$strip>;
     static generateUuid7(_options?: z.input<Awaited<typeof this.v7OptionsBase>>): Promise<UuidExport>;
+    static generateUuid7Sync(_options?: z.input<Awaited<typeof this.v7OptionsBase>>): UuidExport;
     static generateUuid8(options?: Omit<Version8Options, 'random' | 'rng'>): Promise<UuidExport>;
+    static generateUuid8Sync(options?: Omit<Version8Options, 'random' | 'rng'>): UuidExport;
     static uuidConvert(input: undefined): Promise<UndefinedProperties<UuidExport>>;
     static uuidConvert(prefixedUtf: PrefixedUuid): Promise<UuidExport>;
     static uuidConvert(input: UuidExport['utf8']): Promise<UuidExport>;
@@ -30,6 +39,13 @@ 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 uuidConvertSync(input: undefined): UndefinedProperties<UuidExport>;
+    static uuidConvertSync(prefixedUtf: PrefixedUuid): UuidExport;
+    static uuidConvertSync(input: UuidExport['utf8']): UuidExport;
+    static uuidConvertSync(input: UuidExport['hex']): UuidExport;
+    static uuidConvertSync(input: UuidExportBlobInput): UuidExport;
+    static uuidConvertSync(input: UuidExport['base64']): UuidExport;
+    static uuidConvertSync(input: UuidExport['base64url']): UuidExport;
     static uuidExtractor(input: undefined): Promise<UUIDExtract>;
     static uuidExtractor(prefixedUtf: PrefixedUuid): Promise<UUIDExtract>;
     static uuidExtractor(input: UuidExport['utf8']): Promise<UUIDExtract>;
@@ -37,4 +53,11 @@ export declare class BufferHelpers {
     static uuidExtractor(input: UuidExportBlobInput): Promise<UUIDExtract>;
     static uuidExtractor(input: UuidExport['base64']): Promise<UUIDExtract>;
     static uuidExtractor(input: UuidExport['base64url']): Promise<UUIDExtract>;
+    static uuidExtractorSync(input: undefined): UUIDExtract;
+    static uuidExtractorSync(prefixedUtf: PrefixedUuid): UUIDExtract;
+    static uuidExtractorSync(input: UuidExport['utf8']): UUIDExtract;
+    static uuidExtractorSync(input: UuidExport['hex']): UUIDExtract;
+    static uuidExtractorSync(input: UuidExportBlobInput): UUIDExtract;
+    static uuidExtractorSync(input: UuidExport['base64']): UUIDExtract;
+    static uuidExtractorSync(input: UuidExport['base64url']): UUIDExtract;
 }

package/dist/buffers.mjs

@@ -1,24 +1,44 @@
 import { UUIDExtract7, UUIDExtract8 } from '@chainfuse/types/d1';
+import { PrefixedUuidRaw } from '@chainfuse/types/zod';
+import { v7 as uuidv7 } from 'uuid';
 import * as z from 'zod/mini';
 import { BufferHelpersInternals } from "./bufferInternals.mjs";
 import { CryptoHelpers } from './crypto.mjs';
+import { v8 as uuidv8 } from './uuid8.mjs';
 export class BufferHelpers {
     static bigintToBuffer(number) {
         const hexString = number.toString(16);
         return this.hexToBuffer(hexString.length % 2 === 0 ? hexString : `0${hexString}`);
     }
-    static bigintToHex(number) {
+    static bigintToBufferSync(number) {
+        const hexString = number.toString(16);
+        return this.hexToBufferSync(hexString.length % 2 === 0 ? hexString : `0${hexString}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async bigintToHex(number) {
+        return number.toString(16).length % 2 === 0 ? number.toString(16) : `0${number.toString(16)}`;
+    }
+    static bigintToHexSync(number) {
         return number.toString(16).length % 2 === 0 ? number.toString(16) : `0${number.toString(16)}`;
     }
     static bufferToBigint(buffer) {
         return this.bufferToHex(buffer).then((hex) => BigInt(`0x${hex}`));
     }
+    static bufferToBigintSync(buffer) {
+        return BigInt(`0x${this.bufferToHexSync(buffer)}`);
+    }
     static hexToBuffer(hex) {
         return BufferHelpersInternals.node_hexToBuffer(hex).catch(() => BufferHelpersInternals.browser_hexToBuffer(hex));
     }
+    static hexToBufferSync(hex) {
+        return BufferHelpersInternals.browser_hexToBuffer(hex);
+    }
     static bufferToHex(buffer) {
         return BufferHelpersInternals.node_bufferToHex(buffer).catch(() => BufferHelpersInternals.browser_bufferToHex(buffer));
     }
+    static bufferToHexSync(buffer) {
+        return BufferHelpersInternals.browser_bufferToHex(buffer);
+    }
     static base64ToBuffer(rawBase64) {
         return Promise.any([
             z
@@ -33,9 +53,22 @@ export class BufferHelpers {
                 .then((base64url) => BufferHelpersInternals.node_base64ToBuffer(base64url, true).catch(() => BufferHelpersInternals.browser_base64UrlToBuffer(base64url))),
         ]);
     }
+    static base64ToBufferSync(rawBase64) {
+        try {
+            const base64 = z.base64().check(z.trim(), z.minLength(1)).parse(rawBase64);
+            return BufferHelpersInternals.browser_base64ToBuffer(base64);
+        }
+        catch {
+            const base64url = z.base64url().check(z.trim(), z.minLength(1)).parse(rawBase64);
+            return BufferHelpersInternals.browser_base64UrlToBuffer(base64url);
+        }
+    }
     static bufferToBase64(buffer, urlSafe) {
         return BufferHelpersInternals.node_bufferToBase64(buffer, urlSafe).catch(() => BufferHelpersInternals.browser_bufferToBase64(buffer, urlSafe));
     }
+    static bufferToBase64Sync(buffer, urlSafe) {
+        return BufferHelpersInternals.browser_bufferToBase64(buffer, urlSafe);
+    }
     static v7OptionsBase = z.object({
         /**
          * RFC "timestamp" field
@@ -53,10 +86,9 @@ export class BufferHelpers {
     static generateUuid7(_options) {
         return Promise.all([
             //
-            import('uuid'),
             this.v7OptionsBase.parseAsync(_options ?? {}),
             CryptoHelpers.secretBytes(16),
-        ]).then(([{ v7: uuidv7 }, options, random]) => {
+        ]).then(([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]) => ({
@@ -68,6 +100,22 @@ export class BufferHelpers {
             })));
         });
     }
+    static generateUuid7Sync(_options) {
+        const options = this.v7OptionsBase.parse(_options ?? {});
+        const random = CryptoHelpers.secretBytesSync(16);
+        const uuid = uuidv7({ msecs: options.msecs, random, seq: options.seq });
+        const uuidHex = uuid.replaceAll('-', '');
+        const blob = this.hexToBufferSync(uuidHex);
+        const base64 = this.bufferToBase64Sync(blob, false);
+        const base64url = this.bufferToBase64Sync(blob, true);
+        return {
+            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({
@@ -85,18 +133,35 @@ export class BufferHelpers {
             })));
         });
     }
+    static generateUuid8Sync(options) {
+        const random = CryptoHelpers.secretBytesSync(16);
+        const uuid = uuidv8({
+            // @ts-expect-error they're the exact same
+            random,
+            ...options,
+        });
+        const uuidHex = uuid.replaceAll('-', '');
+        const blob = this.hexToBufferSync(uuidHex);
+        const base64 = this.bufferToBase64Sync(blob, false);
+        const base64url = this.bufferToBase64Sync(blob, true);
+        return {
+            utf8: uuid,
+            hex: uuidHex,
+            blob,
+            base64,
+            base64url,
+        };
+    }
     // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static uuidConvert(input) {
         if (input) {
             if (typeof input === 'string') {
-                return import('zod/v4').then(({ z }) => Promise.any([
-                    //
-                    import('@chainfuse/types/zod').then(({ PrefixedUuidRaw }) => z
-                        .union([
+                return Promise.any([
+                    z
+                        .pipe(z.union([
                         z.pipe(PrefixedUuidRaw, z.transform((prefixedUtf8) => prefixedUtf8.split('_')[1])),
-                        z.uuid().trim().nonempty().toLowerCase(),
-                    ])
-                        .transform((value) => value)
+                        z.uuid().check(z.trim(), z.minLength(1), z.toLowerCase()),
+                    ]), z.transform((value) => value))
                         .parseAsync(input)
                         .then((utf8) => {
                         const hex = utf8.replaceAll('-', '');
@@ -107,13 +172,10 @@ export class BufferHelpers {
                             base64,
                             base64url,
                         })));
-                    })),
+                    }),
                     z
-                        .string()
-                        .trim()
-                        .toLowerCase()
-                        .length(32)
-                        .refine((value) => import('validator/es/lib/isHexadecimal').then(({ default: isHexadecimal }) => isHexadecimal(value)).catch(() => import('validator').then(({ default: validator }) => validator.isHexadecimal(value))))
+                        .hex()
+                        .check(z.trim(), z.toLowerCase(), z.length(32))
                         .parseAsync(input)
                         .then((hex) => this.hexToBuffer(hex).then((blob) => Promise.all([this.bufferToBase64(blob, false), this.bufferToBase64(blob, true)]).then(([base64, base64url]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
@@ -125,8 +187,7 @@ export class BufferHelpers {
                 ]).catch(() => Promise.any([
                     z
                         .base64()
-                        .trim()
-                        .nonempty()
+                        .check(z.trim(), z.minLength(1))
                         .parseAsync(input)
                         .then((base64) => this.base64ToBuffer(base64).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, true)]).then(([hex, base64url]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
@@ -137,8 +198,7 @@ export class BufferHelpers {
                     })))),
                     z
                         .base64url()
-                        .trim()
-                        .nonempty()
+                        .check(z.trim(), z.minLength(1))
                         .parseAsync(input)
                         .then((base64url) => this.base64ToBuffer(base64url).then((blob) => Promise.all([this.bufferToHex(blob), this.bufferToBase64(blob, false)]).then(([hex, base64]) => ({
                         utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
@@ -147,7 +207,7 @@ export class BufferHelpers {
                         base64,
                         base64url,
                     })))),
-                ])));
+                ]));
             }
             else {
                 return Promise.all([this.bufferToHex(input), this.bufferToBase64(input, false), this.bufferToBase64(input, true)]).then(([hex, base64, base64url]) => ({
@@ -170,14 +230,105 @@ export class BufferHelpers {
         }))();
     }
     // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static uuidConvertSync(input) {
+        if (input) {
+            if (typeof input === 'string') {
+                try {
+                    const utf8 = z
+                        .pipe(z.union([
+                        z.pipe(PrefixedUuidRaw, z.transform((prefixedUtf8) => prefixedUtf8.split('_')[1])),
+                        z.uuid().check(z.trim(), z.minLength(1), z.toLowerCase()),
+                    ]), z.transform((value) => value))
+                        .parse(input);
+                    const hex = utf8.replaceAll('-', '');
+                    const blob = this.hexToBufferSync(hex);
+                    const base64 = this.bufferToBase64Sync(blob, false);
+                    const base64url = this.bufferToBase64Sync(blob, true);
+                    return {
+                        utf8,
+                        hex,
+                        blob,
+                        base64,
+                        base64url,
+                    };
+                }
+                catch {
+                    try {
+                        const hex = z.hex().check(z.trim(), z.toLowerCase(), z.length(32)).parse(input);
+                        const blob = this.hexToBufferSync(hex);
+                        const base64 = this.bufferToBase64Sync(blob, false);
+                        const base64url = this.bufferToBase64Sync(blob, true);
+                        return {
+                            utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
+                            hex,
+                            blob,
+                            base64,
+                            base64url,
+                        };
+                    }
+                    catch {
+                        try {
+                            const base64 = z.base64().check(z.trim(), z.minLength(1)).parse(input);
+                            const blob = this.base64ToBufferSync(base64);
+                            const hex = this.bufferToHexSync(blob);
+                            const base64url = this.bufferToBase64Sync(blob, true);
+                            return {
+                                utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
+                                hex,
+                                blob,
+                                base64,
+                                base64url,
+                            };
+                        }
+                        catch {
+                            const base64url = z.base64url().check(z.trim(), z.minLength(1)).parse(input);
+                            const blob = this.base64ToBufferSync(base64url);
+                            const hex = this.bufferToHexSync(blob);
+                            const base64 = this.bufferToBase64Sync(blob, false);
+                            return {
+                                utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
+                                hex,
+                                blob,
+                                base64,
+                                base64url,
+                            };
+                        }
+                    }
+                }
+            }
+            else {
+                const hex = this.bufferToHexSync(input);
+                const base64 = this.bufferToBase64Sync(input, false);
+                const base64url = this.bufferToBase64Sync(input, true);
+                return {
+                    utf8: `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`,
+                    hex,
+                    // @ts-expect-error `ArrayBufferLike` is actually accepted and fine
+                    blob: new Uint8Array(input).buffer,
+                    base64,
+                    base64url,
+                };
+            }
+        }
+        return {
+            utf8: undefined,
+            hex: undefined,
+            blob: undefined,
+            base64: undefined,
+            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);
+        input).then(async ({ utf8, hex: _hex }) => z
+            .hex()
+            .check(z.length(32))
+            .safeParseAsync(_hex)
+            .then(async ({ success: hexSuccess, data: hex }) => {
             if (hexSuccess) {
-                const { success: utf8v7Success } = z.uuid({ version: 'v7' }).safeParse(utf8);
-                const { success: utf8v8Success } = z.uuid({ version: 'v8' }).safeParse(utf8);
+                const [{ success: utf8v7Success }, { success: utf8v8Success }] = await Promise.all([z.uuid({ version: 'v7' }).safeParseAsync(utf8), z.uuid({ version: 'v8' }).safeParseAsync(utf8)]);
                 if (utf8v7Success || utf8v8Success) {
                     if (utf8v8Success) {
                         const suffix_hex = hex.substring(13, 16);
@@ -208,6 +359,46 @@ export class BufferHelpers {
             else {
                 throw new Error('Invalid UUID provided');
             }
-        });
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static uuidExtractorSync(input) {
+        const { utf8, hex: _hex } = this.uuidConvertSync(
+        // @ts-expect-error it's the same type
+        input);
+        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 = BufferHelpers.hexToBufferSync(suffix_hex);
+                    return UUIDExtract8.parse({
+                        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: BufferHelpers.bufferToBase64Sync(suffix_buffer, false),
+                                base64url: BufferHelpers.bufferToBase64Sync(suffix_buffer, true),
+                            },
+                    });
+                }
+                else {
+                    return UUIDExtract7.parse({
+                        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.d.mts

@@ -1,5 +1,6 @@
 export declare class CryptoHelpers {
     static secretBytes(byteSize: number): Promise<Uint8Array<ArrayBufferLike>>;
+    static secretBytesSync(byteSize: number): Uint8Array<ArrayBufferLike>;
     static base16secret(secretLength: number): Promise<string>;
     static base62secret(secretLength: number): Promise<string>;
     static getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;

package/dist/crypto.mjs

@@ -4,6 +4,9 @@ export class CryptoHelpers {
     static secretBytes(byteSize) {
         return CryptoHelpersInternals.node_secretBytes(byteSize).catch(() => CryptoHelpersInternals.browser_secretBytes(byteSize));
     }
+    static secretBytesSync(byteSize) {
+        return CryptoHelpersInternals.browser_secretBytes(byteSize);
+    }
     static base16secret(secretLength) {
         return this.secretBytes(Math.ceil(secretLength / 2))
             .then((bytes) => BufferHelpers.bufferToHex(bytes.buffer))

package/dist/db.d.mts

@@ -34,8 +34,8 @@ export declare class SQLCache<C extends CacheStorageLike> extends DrizzleCache {
         cacheTTL: z.ZodMiniDefault<z.ZodMiniNumberFormat>;
         cachePurge: z.ZodMiniDefault<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniDate<Date>]>>;
         strategy: z.ZodMiniDefault<z.ZodMiniEnum<{
-            all: "all";
             explicit: "explicit";
+            all: "all";
         }>>;
     }, z.core.$strip>;
     /**
@@ -56,7 +56,7 @@ export declare class SQLCache<C extends CacheStorageLike> extends DrizzleCache {
      * - `all`: All queries are cached globally.
      * @default 'explicit'
      */
-    strategy(): "all" | "explicit";
+    strategy(): "explicit" | "all";
     /**
      * Generates a cache key as a `Request` object based on the provided tag or key.
      *

package/dist/discord.d.mts

@@ -1,6 +1,6 @@
 import type { ExecutionContext } from '@cloudflare/workers-types/experimental';
 import { CDN, type RESTOptions } from '@discordjs/rest';
-import type { z } from 'zod/v3';
+import * as z from 'zod/mini';
 export declare class DiscordHelpers {
     /**
      * Discord Epoch, the first second of 2015 or 1420070400000
@@ -17,23 +17,13 @@ export declare class DiscordHelpers {
      * @link https://discord.com/developers/docs/reference#snowflakes-snowflake-id-format-structure-left-to-right
      */
     static discordSnowflakeToDate(snowflakeRaw?: bigint | string): Date;
-    static disordRestLogging(): Promise<z.ZodDefault<z.ZodObject<{
-        level: z.ZodDefault<z.ZodNumber>;
-        error: z.ZodDefault<z.ZodNumber>;
-        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, {
-        error: number;
-        level: number;
-        color: boolean;
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-    }, {
-        custom?: ((...args: unknown[]) => void | Promise<void>) | undefined;
-        error?: number | undefined;
-        level?: number | undefined;
-        color?: boolean | 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 disordRestLogging: 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.ZodMiniUnknown, z.ZodMiniTransform<(...args: any[]) => void | Promise<void>, unknown>>>;
+    }, z.core.$strip>>;
+    static discordRest(apiKey: string, _logging: z.input<typeof this.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;
     static guildIcon(guildId: bigint | string, iconHash: Parameters<CDN['icon']>[1], options?: Parameters<CDN['icon']>[2]): string;
 }

package/dist/discord.mjs

@@ -1,4 +1,7 @@
 import { CDN } from '@discordjs/rest';
+import * as z from 'zod/mini';
+import { CryptoHelpers } from './crypto.mjs';
+import { Methods, NetHelpers } from './net.mjs';
 export class DiscordHelpers {
     /**
      * Discord Epoch, the first second of 2015 or 1420070400000
@@ -28,31 +31,22 @@ export class DiscordHelpers {
         const snowflake = BigInt(snowflakeRaw);
         return new Date(Number((snowflake >> BigInt(22)) + this.discordEpoch));
     }
-    static disordRestLogging() {
-        return import('zod/v3').then(({ z: z3 }) => z3
-            .object({
-            level: z3.coerce.number().int().min(0).max(4).default(0),
-            error: z3.coerce.number().int().min(0).max(4).default(1),
-            color: z3.boolean().default(true),
-            custom: z3
-                .function()
-                .args()
-                .returns(z3.union([z3.void(), z3.promise(z3.void())]))
-                .optional(),
-        })
-            .default({}));
-    }
-    static discordRest(apiKey, logging, cacheTtl = 24 * 60 * 60, forceCache = false, executionContext, restOptions) {
+    static disordRestLogging = 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(z.unknown(), z.transform((fn) => fn))),
+    }), {
+        level: 0,
+        error: 1,
+        color: true,
+    });
+    static discordRest(apiKey, _logging, cacheTtl = 24 * 60 * 60, forceCache = false, executionContext, restOptions) {
         return Promise.all([import('@discordjs/rest'), import('./crypto.mjs').then(({ CryptoHelpers }) => CryptoHelpers.base62secret(8))]).then(([{ REST }, potentialId]) => new REST({
             ...restOptions,
             agent: null,
             authPrefix: 'Bot',
-            makeRequest: (url, rawInit) => Promise.all([
-                //
-                DiscordHelpers.disordRestLogging().then((parser) => parser.parseAsync(logging)),
-                import('./net.mjs'),
-                import('./crypto.mjs'),
-            ]).then(async ([logging, { NetHelpers, Methods }, { CryptoHelpers }]) => {
+            makeRequest: (url, rawInit) => DiscordHelpers.disordRestLogging.parseAsync(_logging).then(async (logging) => {
                 // Extra safety to make sure the string really is a URL
                 const info = new URL(url);
                 // CF's implementation of `RequestInit` is functionally the same as w3c `RequestInit` but TS doesn't know that
@@ -70,10 +64,18 @@ export class DiscordHelpers {
                                 const customUrl = new URL(url);
                                 if ('custom' in logging && logging.custom) {
                                     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                                    return logging.custom(...args);
+                                    return logging.custom(...args.slice(0, -1));
                                 }
                                 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 }]) => {
                                         if (logging.level > 0) {
                                             console.info('Discord Rest', 
                                             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -83,7 +85,7 @@ export class DiscordHelpers {
                                                 .map((value) => (value instanceof Date && !isNaN(value.getTime()) ? value.toISOString() : value))
                                                 // Wrap id in brackets
                                                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                                                .map((value) => (value === id ? chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(`[${stripAnsi(id)}]`) : value))
+                                                .map((value) => (value === id ? chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(`[${ansiStripper(id)}]`) : value))
                                                 // Strip out redundant parts of url
                                                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                                                 .map((value) => (value === url ? `${customUrl.pathname}${customUrl.search}${customUrl.hash}` : value)));
@@ -97,7 +99,7 @@ export class DiscordHelpers {
                                                 .map((value) => (value instanceof Date && !isNaN(value.getTime()) ? value.toISOString() : value))
                                                 // Wrap id in brackets
                                                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                                                .map((value) => (value === id ? chalk.rgb(...Helpers.uniqueIdColor(stripAnsi(id)))(`[${stripAnsi(id)}]`) : value))
+                                                .map((value) => (value === id ? chalk.rgb(...Helpers.uniqueIdColor(ansiStripper(id)))(`[${ansiStripper(id)}]`) : value))
                                                 // Strip out redundant parts of url
                                                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                                                 .map((value) => (value === url ? `${customUrl.pathname}${customUrl.search}${customUrl.hash}` : value)));

package/dist/net.d.mts

@@ -17,13 +17,12 @@ export declare enum Methods {
     'PATCH' = "PATCH"
 }
 export declare class NetHelpers {
-    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]>>>>>;
+            custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<(...args: any[]) => void | Promise<void>, unknown>>>;
         }, z.core.$strip>>;
         cf: z.ZodMiniDefault<z.ZodMiniObject<{
             /**
@@ -67,9 +66,9 @@ export declare class NetHelpers {
              * @link https://blog.cloudflare.com/introducing-polish-automatic-image-optimizati/
              */
             polish: z.ZodMiniOptional<z.ZodMiniEnum<{
-                off: "off";
                 lossy: "lossy";
                 lossless: "lossless";
+                off: "off";
             }>>;
             /**
              * Whether ScrapeShield should be enabled for this request, if otherwise configured for this zone.
@@ -102,19 +101,23 @@ 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?: z.input<typeof NetHelpers.cfApiConfig>): Promise<import("cloudflare").Cloudflare>;
+    static cfApi(apiKey: string, config?: z.input<typeof NetHelpers.cfApiConfig> & {
+        logging?: {
+            custom?: (...args: any[]) => void | Promise<void>;
+        };
+    }): 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]>>>>>;
+        custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<(...args: any[]) => void | Promise<void>, unknown>>>;
     }, 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]>>>>>;
+            custom: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<(...args: any[]) => void | Promise<void>, unknown>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     /**
@@ -151,7 +154,11 @@ export declare class NetHelpers {
      * - Allows for colorized output using the `chalk` library.
      * - Provides hooks for custom logging implementations.
      */
-    static loggingFetch<RI extends RequestInit = RequestInit>(info: Parameters<typeof fetch>[0], init?: LoggingFetchInitType<RI>): Promise<Response>;
+    static loggingFetch<RI extends RequestInit = RequestInit>(info: Parameters<typeof fetch>[0], _init?: LoggingFetchInitType<RI> & {
+        logging?: {
+            custom?: (...args: any[]) => void | Promise<void>;
+        };
+    }): Promise<Response>;
     /**
      * Removes sensitive headers from the provided `Headers` object. Specifically, it deletes the `Set-Cookie` and `Authorization` headers.
      *

package/dist/net.mjs

@@ -17,18 +17,12 @@ export var Methods;
     Methods["PATCH"] = "PATCH";
 })(Methods || (Methods = {}));
 export class NetHelpers {
-    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))),
+            custom: z.optional(z.pipe(z.unknown(), z.transform((fn) => fn))),
         }), {
             level: 0,
             error: 1,
@@ -145,9 +139,7 @@ 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: this.customLogging.implementAsync(async (args_0, ...args_x) => {
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            const args = [args_0, ...args_x];
+                        custom: async (...args) => {
                             const [, id, , url, headers] = args;
                             const customUrl = new URL(url);
                             const customHeaders = new Headers(headers);
@@ -165,16 +157,12 @@ 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(argsFirst, ...argsRest);
+                                    return void config.logging.custom(...args.slice(0, -1));
                                 }
                                 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(argsFirst, ...argsRest);
+                                    return void config.logging.custom(...args);
                                 }
                             }
                             else {
@@ -300,7 +288,7 @@ export class NetHelpers {
                                     }
                                 });
                             }
-                        }),
+                        },
                     }),
                 },
             }),
@@ -310,9 +298,7 @@ export class NetHelpers {
         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))),
+        custom: z.optional(z.pipe(z.unknown(), z.transform((fn) => fn))),
     }), {
         level: 0,
         error: 1,
@@ -355,7 +341,7 @@ export class NetHelpers {
      * - Allows for colorized output using the `chalk` library.
      * - Provides hooks for custom logging implementations.
      */
-    static loggingFetch(info, init) {
+    static loggingFetch(info, _init) {
         return Promise.all([
             z
                 .pipe(z._default(z.looseObject(this.loggingFetchInit.def.shape), {
@@ -365,7 +351,7 @@ export class NetHelpers {
                     color: true,
                 },
             }), z.transform((parsed) => parsed))
-                .parseAsync(init),
+                .parseAsync(_init),
             import("./crypto.mjs").then(({ CryptoHelpers }) => CryptoHelpers.base62secret(8)),
         ]).then(async ([init, id]) => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -421,10 +407,8 @@ 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(requestLoggingItemsFirst, ...requestLoggingItemsRest);
+                    await init.logging.custom(...requestLoggingItems);
                 }
                 else if (init.logging.level > 0) {
                     console.info(
@@ -489,21 +473,15 @@ 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(responseLoggingItemsFirst, ...responseLoggingItemsRest);
+                        await init.logging.custom(...responseLoggingItems);
                     }
                     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(requestErrorItemsFirst, ...requestErrorItemsRest);
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                        const [responseErrorItemsFirst, ...responseErrorItemsRest] = responseErrorItems;
+                        await init.logging.custom(...requestErrorItems);
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        await init.logging.custom(responseErrorItemsFirst, ...responseErrorItemsRest);
+                        await init.logging.custom(...responseErrorItems);
                     }
                     else if (init.logging.level > 0) {
                         console.info(

package/dist/uuid8.d.mts

@@ -14,7 +14,7 @@ export declare const v8Options: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     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>>>>;
+    rng: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<() => Uint8Array, unknown>>>;
 }, z.core.$strip>]>;
 export type Version8Options = z.input<typeof v8Options>;
 /**

package/dist/uuid8.mjs

@@ -43,10 +43,7 @@ export const v8Options = z.union([
         /**
          * 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' })),
-        })),
+        rng: z.optional(z.pipe(z.unknown(), z.transform((fn) => fn))),
     }),
 ]);
 function replaceByIndex(input, start, end, replacement) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "4.0.1",
+	"version": "4.0.3",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -80,18 +80,18 @@
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
-		"@chainfuse/types": "^3.0.1",
+		"@chainfuse/types": "^3.0.5",
 		"@discordjs/rest": "^2.6.0",
 		"chalk": "^5.6.2",
 		"cloudflare": "^5.0.0",
 		"drizzle-orm": "^0.44.5",
 		"strip-ansi": "^7.1.2",
 		"uuid": "^13.0.0",
-		"zod": "^4.1.5"
+		"zod": "^4.1.8"
 	},
 	"devDependencies": {
 		"@cloudflare/workers-types": "^4.20250910.0",
 		"@types/node": "^22.18.1"
 	},
-	"gitHead": "4ac5a49456f61c637bb377d69ef8f97225a28d06"
+	"gitHead": "e75fc2917aab88ac2d51deb1a278a3ce0ec1e63b"
 }