recker 1.0.26 → 1.0.27-next.1cb21f8

package/dist/browser/browser/cache.d.ts

@@ -0,0 +1,40 @@
+export interface CacheEntry<T = unknown> {
+    key: string;
+    value: T;
+    createdAt: number;
+    expiresAt?: number;
+    etag?: string;
+    lastModified?: string;
+}
+export interface BrowserCacheOptions {
+    dbName?: string;
+    storeName?: string;
+    defaultTTL?: number;
+    maxEntries?: number;
+}
+export declare class IndexedDBStorage {
+    private dbName;
+    private storeName;
+    private defaultTTL;
+    private maxEntries;
+    private db;
+    private initPromise;
+    constructor(options?: BrowserCacheOptions);
+    init(): Promise<void>;
+    get<T = unknown>(key: string): Promise<CacheEntry<T> | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number, metadata?: {
+        etag?: string;
+        lastModified?: string;
+    }): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    cleanup(): Promise<number>;
+    private enforceMaxEntries;
+    close(): void;
+    destroy(): Promise<void>;
+}
+export declare function isIndexedDBAvailable(): boolean;
+export declare function getBrowserCacheStorage(options?: BrowserCacheOptions): IndexedDBStorage | null;

package/dist/browser/browser/cache.js

@@ -0,0 +1,199 @@
+export class IndexedDBStorage {
+    dbName;
+    storeName;
+    defaultTTL;
+    maxEntries;
+    db = null;
+    initPromise = null;
+    constructor(options = {}) {
+        this.dbName = options.dbName ?? 'recker-cache';
+        this.storeName = options.storeName ?? 'responses';
+        this.defaultTTL = options.defaultTTL ?? 5 * 60 * 1000;
+        this.maxEntries = options.maxEntries ?? 1000;
+    }
+    async init() {
+        if (this.db)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 1);
+            request.onerror = () => {
+                reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
+                    store.createIndex('expiresAt', 'expiresAt', { unique: false });
+                }
+            };
+        });
+        return this.initPromise;
+    }
+    async get(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(key);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const entry = request.result;
+                if (!entry) {
+                    resolve(null);
+                    return;
+                }
+                if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                    this.delete(key).catch(() => { });
+                    resolve(null);
+                    return;
+                }
+                resolve(entry);
+            };
+        });
+    }
+    async set(key, value, ttl, metadata) {
+        await this.init();
+        const entry = {
+            key,
+            value,
+            createdAt: Date.now(),
+            expiresAt: ttl !== undefined ? Date.now() + ttl : undefined,
+            etag: metadata?.etag,
+            lastModified: metadata?.lastModified,
+        };
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.put(entry);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+            transaction.oncomplete = () => {
+                this.enforceMaxEntries().catch(() => { });
+            };
+        });
+    }
+    async delete(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.delete(key);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(true);
+        });
+    }
+    async has(key) {
+        const entry = await this.get(key);
+        return entry !== null;
+    }
+    async clear() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+        });
+    }
+    async keys() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.getAllKeys();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async size() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.count();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async cleanup() {
+        await this.init();
+        const now = Date.now();
+        let removed = 0;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index('expiresAt');
+            const range = IDBKeyRange.upperBound(now);
+            const request = index.openCursor(range);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor) {
+                    cursor.delete();
+                    removed++;
+                    cursor.continue();
+                }
+            };
+            transaction.oncomplete = () => resolve(removed);
+        });
+    }
+    async enforceMaxEntries() {
+        const currentSize = await this.size();
+        if (currentSize <= this.maxEntries)
+            return;
+        const toRemove = currentSize - this.maxEntries;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(this.storeName, 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index('expiresAt');
+            let removed = 0;
+            const request = index.openCursor();
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor && removed < toRemove) {
+                    cursor.delete();
+                    removed++;
+                    cursor.continue();
+                }
+            };
+            transaction.oncomplete = () => resolve();
+        });
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initPromise = null;
+        }
+    }
+    async destroy() {
+        this.close();
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.deleteDatabase(this.dbName);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve();
+        });
+    }
+}
+export function isIndexedDBAvailable() {
+    try {
+        return typeof indexedDB !== 'undefined' && indexedDB !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export function getBrowserCacheStorage(options) {
+    if (isIndexedDBAvailable()) {
+        return new IndexedDBStorage(options);
+    }
+    return null;
+}

package/dist/browser/browser/crypto.d.ts

@@ -0,0 +1,24 @@
+export type HashAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA-1';
+export type HmacAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA-1';
+export declare class BrowserCrypto {
+    private encoder;
+    hash(algorithm: HashAlgorithm, data: string): Promise<string>;
+    hashBuffer(algorithm: HashAlgorithm, data: ArrayBuffer | Uint8Array): Promise<string>;
+    hmac(algorithm: HmacAlgorithm, key: string, data: string): Promise<string>;
+    hmacBuffer(algorithm: HmacAlgorithm, key: ArrayBuffer | Uint8Array, data: string | ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+    randomUUID(): string;
+    randomBytes(length: number): Uint8Array;
+    randomHex(length: number): string;
+    bufferToHex(buffer: ArrayBuffer | Uint8Array): string;
+    hexToBuffer(hex: string): Uint8Array;
+    base64Encode(data: string): string;
+    base64Decode(data: string): string;
+    base64UrlEncode(data: string): string;
+    base64UrlDecode(data: string): string;
+}
+export declare const browserCrypto: BrowserCrypto;
+export declare const sha256: (data: string) => Promise<string>;
+export declare const sha1: (data: string) => Promise<string>;
+export declare const hmacSha256: (key: string, data: string) => Promise<string>;
+export declare const randomUUID: () => string;
+export declare const randomBytes: (length: number) => Uint8Array<ArrayBufferLike>;

package/dist/browser/browser/crypto.js

@@ -0,0 +1,80 @@
+export class BrowserCrypto {
+    encoder = new TextEncoder();
+    async hash(algorithm, data) {
+        const dataBuffer = this.encoder.encode(data);
+        const hashBuffer = await crypto.subtle.digest(algorithm, dataBuffer);
+        return this.bufferToHex(hashBuffer);
+    }
+    async hashBuffer(algorithm, data) {
+        const buffer = data instanceof Uint8Array ? data.buffer : data;
+        const hashBuffer = await crypto.subtle.digest(algorithm, buffer);
+        return this.bufferToHex(hashBuffer);
+    }
+    async hmac(algorithm, key, data) {
+        const keyData = this.encoder.encode(key);
+        const cryptoKey = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: algorithm }, false, ['sign']);
+        const signature = await crypto.subtle.sign('HMAC', cryptoKey, this.encoder.encode(data));
+        return this.bufferToHex(signature);
+    }
+    async hmacBuffer(algorithm, key, data) {
+        const keyBuffer = key instanceof Uint8Array ? key.buffer : key;
+        const cryptoKey = await crypto.subtle.importKey('raw', keyBuffer, { name: 'HMAC', hash: algorithm }, false, ['sign']);
+        let dataBuffer;
+        if (typeof data === 'string') {
+            dataBuffer = this.encoder.encode(data).buffer;
+        }
+        else if (data instanceof Uint8Array) {
+            dataBuffer = data.buffer;
+        }
+        else {
+            dataBuffer = data;
+        }
+        return crypto.subtle.sign('HMAC', cryptoKey, dataBuffer);
+    }
+    randomUUID() {
+        return crypto.randomUUID();
+    }
+    randomBytes(length) {
+        const bytes = new Uint8Array(length);
+        crypto.getRandomValues(bytes);
+        return bytes;
+    }
+    randomHex(length) {
+        return this.bufferToHex(this.randomBytes(length));
+    }
+    bufferToHex(buffer) {
+        const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    hexToBuffer(hex) {
+        const matches = hex.match(/.{1,2}/g) || [];
+        return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
+    }
+    base64Encode(data) {
+        const bytes = this.encoder.encode(data);
+        const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
+        return btoa(binString);
+    }
+    base64Decode(data) {
+        const binString = atob(data);
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    base64UrlEncode(data) {
+        return this.base64Encode(data)
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    base64UrlDecode(data) {
+        const padded = data + '='.repeat((4 - (data.length % 4)) % 4);
+        const base64 = padded.replace(/-/g, '+').replace(/_/g, '/');
+        return this.base64Decode(base64);
+    }
+}
+export const browserCrypto = new BrowserCrypto();
+export const sha256 = (data) => browserCrypto.hash('SHA-256', data);
+export const sha1 = (data) => browserCrypto.hash('SHA-1', data);
+export const hmacSha256 = (key, data) => browserCrypto.hmac('SHA-256', key, data);
+export const randomUUID = () => browserCrypto.randomUUID();
+export const randomBytes = (length) => browserCrypto.randomBytes(length);

package/dist/browser/browser/index.d.ts

@@ -0,0 +1,31 @@
+export * from '../core/request-promise.js';
+export * from '../core/errors.js';
+export * from '../core/client.js';
+export * from '../core/request.js';
+export * from '../core/response.js';
+export * from '../transport/fetch.js';
+export * from '../plugins/retry.js';
+export * from '../plugins/rate-limit.js';
+export * from '../plugins/dedup.js';
+export * from '../plugins/logger.js';
+export * from '../plugins/circuit-breaker.js';
+export * from '../plugins/cookie-jar.js';
+export * from '../plugins/xsrf.js';
+export * from '../plugins/graphql.js';
+export * from '../plugins/xml.js';
+export * from '../plugins/server-timing.js';
+export * from '../plugins/jsonrpc.js';
+export * from '../plugins/grpc-web.js';
+export * from '../plugins/soap.js';
+export * from '../plugins/odata.js';
+export * from '../plugins/auth.js';
+export * from '../cache/memory-storage.js';
+export * from '../utils/body.js';
+export * from '../utils/header-parser.js';
+export * from '../utils/link-header.js';
+export * from '../utils/charset.js';
+export * from '../constants/http-status.js';
+export * from './crypto.js';
+export * from './cache.js';
+export * from './recker.js';
+export { Client as Recker } from '../core/client.js';

package/dist/browser/browser/index.js

@@ -0,0 +1,31 @@
+export * from '../core/request-promise.js';
+export * from '../core/errors.js';
+export * from '../core/client.js';
+export * from '../core/request.js';
+export * from '../core/response.js';
+export * from '../transport/fetch.js';
+export * from '../plugins/retry.js';
+export * from '../plugins/rate-limit.js';
+export * from '../plugins/dedup.js';
+export * from '../plugins/logger.js';
+export * from '../plugins/circuit-breaker.js';
+export * from '../plugins/cookie-jar.js';
+export * from '../plugins/xsrf.js';
+export * from '../plugins/graphql.js';
+export * from '../plugins/xml.js';
+export * from '../plugins/server-timing.js';
+export * from '../plugins/jsonrpc.js';
+export * from '../plugins/grpc-web.js';
+export * from '../plugins/soap.js';
+export * from '../plugins/odata.js';
+export * from '../plugins/auth.js';
+export * from '../cache/memory-storage.js';
+export * from '../utils/body.js';
+export * from '../utils/header-parser.js';
+export * from '../utils/link-header.js';
+export * from '../utils/charset.js';
+export * from '../constants/http-status.js';
+export * from './crypto.js';
+export * from './cache.js';
+export * from './recker.js';
+export { Client as Recker } from '../core/client.js';

package/dist/browser/browser/recker.d.ts

@@ -0,0 +1,26 @@
+import { Client, type ExtendedClientOptions } from '../core/client.js';
+import { type RequestPromise } from '../core/request-promise.js';
+import type { RequestOptions } from '../types/index.js';
+export declare function get(url: string, options?: RequestOptions): RequestPromise;
+export declare function post(url: string, options?: RequestOptions): RequestPromise;
+export declare function put(url: string, options?: RequestOptions): RequestPromise;
+export declare function patch(url: string, options?: RequestOptions): RequestPromise;
+export declare function del(url: string, options?: RequestOptions): RequestPromise;
+export declare function head(url: string, options?: RequestOptions): RequestPromise;
+export declare function options(url: string, options?: RequestOptions): RequestPromise;
+export declare function ws(url: string, protocols?: string | string[]): WebSocket;
+export declare const recker: {
+    get: typeof get;
+    post: typeof post;
+    put: typeof put;
+    patch: typeof patch;
+    delete: typeof del;
+    head: typeof head;
+    options: typeof options;
+    ws: typeof ws;
+    client: (opts?: ExtendedClientOptions) => Client;
+    reset: () => void;
+    isBrowser: true;
+    unavailable: readonly ["whois", "whoisAvailable", "dns", "dnsSecurity", "dnsClient", "whoisClient", "ai", "aiClient"];
+};
+export default recker;

package/dist/browser/browser/recker.js

@@ -0,0 +1,61 @@
+import { createClient } from '../core/client.js';
+import { FetchTransport } from '../transport/fetch.js';
+let _defaultClient = null;
+function getDefaultClient() {
+    if (!_defaultClient) {
+        _defaultClient = createClient({
+            transport: new FetchTransport(),
+        });
+    }
+    return _defaultClient;
+}
+export function get(url, options) {
+    return getDefaultClient().get(url, options);
+}
+export function post(url, options) {
+    return getDefaultClient().post(url, options);
+}
+export function put(url, options) {
+    return getDefaultClient().put(url, options);
+}
+export function patch(url, options) {
+    return getDefaultClient().patch(url, options);
+}
+export function del(url, options) {
+    return getDefaultClient().delete(url, options);
+}
+export function head(url, options) {
+    return getDefaultClient().head(url, options);
+}
+export function options(url, options) {
+    return getDefaultClient().options(url, options);
+}
+export function ws(url, protocols) {
+    return new WebSocket(url, protocols);
+}
+export const recker = {
+    get,
+    post,
+    put,
+    patch,
+    delete: del,
+    head,
+    options,
+    ws,
+    client: (opts) => createClient({ ...opts, transport: new FetchTransport() }),
+    reset: () => {
+        _defaultClient = null;
+    },
+    isBrowser: true,
+    unavailable: [
+        'whois',
+        'whoisAvailable',
+        'dns',
+        'dnsSecurity',
+        'dnsClient',
+        'whoisClient',
+        'ai',
+        'aiClient',
+    ],
+};
+export default recker;

package/dist/browser/cache/basic-file-storage.d.ts

@@ -0,0 +1,12 @@
+import { CacheEntry, CacheStorage } from '../types/index.js';
+export declare class FileStorage implements CacheStorage {
+    private dir;
+    constructor(baseDir?: string);
+    private getHash;
+    private getPath;
+    private ensureDir;
+    get(key: string): Promise<CacheEntry | undefined>;
+    set(key: string, entry: CacheEntry, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/browser/cache/basic-file-storage.js

@@ -0,0 +1,50 @@
+import { mkdir, readFile, writeFile, unlink, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+export class FileStorage {
+    dir;
+    constructor(baseDir = '.recker/cache') {
+        this.dir = baseDir;
+    }
+    getHash(key) {
+        return createHash('md5').update(key).digest('hex');
+    }
+    getPath(key) {
+        return join(this.dir, `${this.getHash(key)}.json`);
+    }
+    async ensureDir() {
+        if (!existsSync(this.dir)) {
+            await mkdir(this.dir, { recursive: true });
+        }
+    }
+    async get(key) {
+        try {
+            const path = this.getPath(key);
+            if (!existsSync(path))
+                return undefined;
+            const content = await readFile(path, 'utf-8');
+            const data = JSON.parse(content);
+            return data;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async set(key, entry, ttl) {
+        await this.ensureDir();
+        const path = this.getPath(key);
+        await writeFile(path, JSON.stringify(entry), 'utf-8');
+    }
+    async delete(key) {
+        const path = this.getPath(key);
+        if (existsSync(path)) {
+            await unlink(path);
+        }
+    }
+    async clear() {
+        if (existsSync(this.dir)) {
+            await rm(this.dir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/browser/cache/memory-limits.d.ts

@@ -0,0 +1,20 @@
+export declare function getEffectiveTotalMemoryBytes(): number;
+export interface ResolvedMemoryLimit {
+    maxMemoryBytes: number;
+    derivedFromPercent: boolean;
+    effectiveTotal: number;
+    heapLimit: number;
+    inferredPercent: number | null;
+}
+export interface MemoryLimitOptions {
+    maxMemoryBytes?: number;
+    maxMemoryPercent?: number;
+    safetyPercent?: number;
+}
+export declare function resolveCacheMemoryLimit(options?: MemoryLimitOptions): ResolvedMemoryLimit;
+export declare function formatBytes(bytes: number): string;
+export declare function getHeapStats(): {
+    heapUsed: number;
+    heapLimit: number;
+    heapRatio: number;
+};

package/dist/browser/cache/memory-limits.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import v8 from 'node:v8';
+const DEFAULT_TOTAL_PERCENT = 0.5;
+const DEFAULT_HEAP_PERCENT = 0.6;
+function readCgroupLimit() {
+    const candidates = [
+        '/sys/fs/cgroup/memory.max',
+        '/sys/fs/cgroup/memory/memory.limit_in_bytes',
+    ];
+    for (const file of candidates) {
+        try {
+            if (fs.existsSync(file)) {
+                const raw = fs.readFileSync(file, 'utf8').trim();
+                if (!raw || raw === 'max')
+                    continue;
+                const value = Number.parseInt(raw, 10);
+                if (Number.isFinite(value) && value > 0) {
+                    return value;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function getEffectiveTotalMemoryBytes() {
+    const cgroupLimit = readCgroupLimit();
+    if (cgroupLimit && Number.isFinite(cgroupLimit) && cgroupLimit > 0) {
+        return cgroupLimit;
+    }
+    return os.totalmem();
+}
+export function resolveCacheMemoryLimit(options = {}) {
+    const { maxMemoryBytes, maxMemoryPercent, safetyPercent } = options;
+    const heapStats = v8.getHeapStatistics();
+    const heapLimit = heapStats?.heap_size_limit ?? 0;
+    const effectiveTotal = getEffectiveTotalMemoryBytes();
+    let resolvedBytes = 0;
+    let derivedFromPercent = false;
+    if (typeof maxMemoryBytes === 'number' && maxMemoryBytes > 0) {
+        resolvedBytes = maxMemoryBytes;
+    }
+    else if (typeof maxMemoryPercent === 'number' && maxMemoryPercent > 0) {
+        const percent = Math.max(0, Math.min(maxMemoryPercent, 1));
+        resolvedBytes = Math.floor(effectiveTotal * percent);
+        derivedFromPercent = true;
+    }
+    const safeTotalPercent = typeof safetyPercent === 'number' && safetyPercent > 0 && safetyPercent <= 1
+        ? safetyPercent
+        : DEFAULT_TOTAL_PERCENT;
+    const totalCap = Math.floor(effectiveTotal * safeTotalPercent);
+    if (resolvedBytes === 0 || totalCap < resolvedBytes) {
+        resolvedBytes = totalCap;
+        derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+    }
+    if (heapLimit > 0) {
+        const heapCap = Math.floor(heapLimit * DEFAULT_HEAP_PERCENT);
+        if (resolvedBytes === 0 || heapCap < resolvedBytes) {
+            resolvedBytes = heapCap;
+            derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+        }
+    }
+    if (!Number.isFinite(resolvedBytes) || resolvedBytes <= 0) {
+        resolvedBytes = Math.floor(effectiveTotal * DEFAULT_TOTAL_PERCENT);
+        derivedFromPercent = true;
+    }
+    const inferredPercent = effectiveTotal > 0 ? resolvedBytes / effectiveTotal : null;
+    return {
+        maxMemoryBytes: resolvedBytes,
+        derivedFromPercent,
+        effectiveTotal,
+        heapLimit,
+        inferredPercent,
+    };
+}
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+export function getHeapStats() {
+    const heapStats = v8.getHeapStatistics();
+    const { heapUsed } = process.memoryUsage();
+    const heapLimit = heapStats?.heap_size_limit ?? 0;
+    const heapRatio = heapLimit > 0 ? heapUsed / heapLimit : 0;
+    return {
+        heapUsed,
+        heapLimit,
+        heapRatio,
+    };
+}