@originals/sdk 1.2.0 → 1.4.3

package/dist/utils/MetricsCollector.js

@@ -1,264 +0,0 @@
-/**
- * Metrics Collector for Originals SDK
- *
- * Features:
- * - Track operation counts and performance
- * - Asset lifecycle metrics (created, migrated, transferred)
- * - Error tracking by error code
- * - Cache statistics (optional)
- * - Export in JSON and Prometheus formats
- * - Memory-efficient storage
- */
-/**
- * MetricsCollector class
- */
-export class MetricsCollector {
-    constructor() {
-        this.assetsCreatedCount = 0;
-        this.assetsMigratedMap = new Map();
-        this.assetsTransferredCount = 0;
-        this.operationMetrics = new Map();
-        this.errorCounts = new Map();
-        this.cacheHits = 0;
-        this.cacheMisses = 0;
-        this.startTime = new Date().toISOString();
-    }
-    /**
-     * Record an operation with timing and success status
-     */
-    recordOperation(operation, duration, success) {
-        if (!this.operationMetrics.has(operation)) {
-            this.operationMetrics.set(operation, {
-                count: 0,
-                totalTime: 0,
-                minTime: Infinity,
-                maxTime: -Infinity,
-                errorCount: 0
-            });
-        }
-        const metrics = this.operationMetrics.get(operation);
-        metrics.count++;
-        metrics.totalTime += duration;
-        metrics.minTime = Math.min(metrics.minTime, duration);
-        metrics.maxTime = Math.max(metrics.maxTime, duration);
-        if (!success) {
-            metrics.errorCount++;
-        }
-    }
-    /**
-     * Start tracking an operation, returns completion function
-     */
-    startOperation(operation) {
-        const startTime = performance.now();
-        return (success = true) => {
-            const duration = performance.now() - startTime;
-            this.recordOperation(operation, duration, success);
-        };
-    }
-    /**
-     * Record an asset creation
-     */
-    recordAssetCreated() {
-        this.assetsCreatedCount++;
-    }
-    /**
-     * Record an asset migration between layers
-     */
-    recordMigration(from, to) {
-        // Create transition key
-        const fromShort = from.split(':')[1]; // "peer", "webvh", "btco"
-        const toShort = to.split(':')[1];
-        const transitionKey = `${fromShort}→${toShort}`;
-        const current = this.assetsMigratedMap.get(transitionKey) || 0;
-        this.assetsMigratedMap.set(transitionKey, current + 1);
-    }
-    /**
-     * Record an asset transfer
-     */
-    recordTransfer() {
-        this.assetsTransferredCount++;
-    }
-    /**
-     * Record an error by error code
-     */
-    recordError(code, operation) {
-        // Track error by code
-        const current = this.errorCounts.get(code) || 0;
-        this.errorCounts.set(code, current + 1);
-        // If operation is provided, increment its error count
-        if (operation && this.operationMetrics.has(operation)) {
-            this.operationMetrics.get(operation).errorCount++;
-        }
-    }
-    /**
-     * Record a cache hit
-     */
-    recordCacheHit() {
-        this.cacheHits++;
-    }
-    /**
-     * Record a cache miss
-     */
-    recordCacheMiss() {
-        this.cacheMisses++;
-    }
-    /**
-     * Get a snapshot of all metrics
-     */
-    getMetrics() {
-        const operationTimes = {};
-        for (const [operation, metrics] of this.operationMetrics.entries()) {
-            operationTimes[operation] = {
-                count: metrics.count,
-                totalTime: metrics.totalTime,
-                avgTime: metrics.count > 0 ? metrics.totalTime / metrics.count : 0,
-                minTime: metrics.minTime === Infinity ? 0 : metrics.minTime,
-                maxTime: metrics.maxTime === -Infinity ? 0 : metrics.maxTime,
-                errorCount: metrics.errorCount
-            };
-        }
-        const assetsMigrated = {};
-        for (const [key, count] of this.assetsMigratedMap.entries()) {
-            assetsMigrated[key] = count;
-        }
-        const errors = {};
-        for (const [code, count] of this.errorCounts.entries()) {
-            errors[code] = count;
-        }
-        const totalCacheRequests = this.cacheHits + this.cacheMisses;
-        const cacheStats = totalCacheRequests > 0 ? {
-            hits: this.cacheHits,
-            misses: this.cacheMisses,
-            hitRate: this.cacheHits / totalCacheRequests
-        } : undefined;
-        return {
-            assetsCreated: this.assetsCreatedCount,
-            assetsMigrated,
-            assetsTransferred: this.assetsTransferredCount,
-            operationTimes,
-            errors,
-            cacheStats,
-            startTime: this.startTime,
-            uptime: Date.now() - new Date(this.startTime).getTime()
-        };
-    }
-    /**
-     * Get metrics for a specific operation
-     */
-    getOperationMetrics(operation) {
-        const metrics = this.operationMetrics.get(operation);
-        if (!metrics) {
-            return null;
-        }
-        return {
-            count: metrics.count,
-            totalTime: metrics.totalTime,
-            avgTime: metrics.count > 0 ? metrics.totalTime / metrics.count : 0,
-            minTime: metrics.minTime === Infinity ? 0 : metrics.minTime,
-            maxTime: metrics.maxTime === -Infinity ? 0 : metrics.maxTime,
-            errorCount: metrics.errorCount
-        };
-    }
-    /**
-     * Reset all metrics
-     */
-    reset() {
-        this.assetsCreatedCount = 0;
-        this.assetsMigratedMap.clear();
-        this.assetsTransferredCount = 0;
-        this.operationMetrics.clear();
-        this.errorCounts.clear();
-        this.cacheHits = 0;
-        this.cacheMisses = 0;
-    }
-    /**
-     * Export metrics in the specified format
-     */
-    export(format) {
-        if (format === 'json') {
-            return this.exportJSON();
-        }
-        else if (format === 'prometheus') {
-            return this.exportPrometheus();
-        }
-        throw new Error(`Unsupported export format: ${format}`);
-    }
-    /**
-     * Export metrics as JSON
-     */
-    exportJSON() {
-        return JSON.stringify(this.getMetrics(), null, 2);
-    }
-    /**
-     * Export metrics in Prometheus format
-     */
-    exportPrometheus() {
-        const lines = [];
-        const metrics = this.getMetrics();
-        // Asset metrics
-        lines.push('# HELP originals_assets_created_total Total number of assets created');
-        lines.push('# TYPE originals_assets_created_total counter');
-        lines.push(`originals_assets_created_total ${metrics.assetsCreated}`);
-        lines.push('');
-        lines.push('# HELP originals_assets_transferred_total Total number of assets transferred');
-        lines.push('# TYPE originals_assets_transferred_total counter');
-        lines.push(`originals_assets_transferred_total ${metrics.assetsTransferred}`);
-        lines.push('');
-        // Migration metrics
-        lines.push('# HELP originals_assets_migrated_total Total number of assets migrated by layer transition');
-        lines.push('# TYPE originals_assets_migrated_total counter');
-        for (const [transition, count] of Object.entries(metrics.assetsMigrated)) {
-            const [from, to] = transition.split('→');
-            lines.push(`originals_assets_migrated_total{from="${from}",to="${to}"} ${count}`);
-        }
-        lines.push('');
-        // Operation metrics
-        for (const [operation, opMetrics] of Object.entries(metrics.operationTimes)) {
-            const safeOpName = operation.replace(/[^a-zA-Z0-9_]/g, '_');
-            lines.push(`# HELP originals_operation_${safeOpName}_total Total number of ${operation} operations`);
-            lines.push(`# TYPE originals_operation_${safeOpName}_total counter`);
-            lines.push(`originals_operation_${safeOpName}_total ${opMetrics.count}`);
-            lines.push('');
-            lines.push(`# HELP originals_operation_${safeOpName}_duration_milliseconds Duration of ${operation} operations`);
-            lines.push(`# TYPE originals_operation_${safeOpName}_duration_milliseconds summary`);
-            lines.push(`originals_operation_${safeOpName}_duration_milliseconds{quantile="0.0"} ${opMetrics.minTime}`);
-            lines.push(`originals_operation_${safeOpName}_duration_milliseconds{quantile="0.5"} ${opMetrics.avgTime}`);
-            lines.push(`originals_operation_${safeOpName}_duration_milliseconds{quantile="1.0"} ${opMetrics.maxTime}`);
-            lines.push(`originals_operation_${safeOpName}_duration_milliseconds_sum ${opMetrics.totalTime}`);
-            lines.push(`originals_operation_${safeOpName}_duration_milliseconds_count ${opMetrics.count}`);
-            lines.push('');
-            lines.push(`# HELP originals_operation_${safeOpName}_errors_total Total number of errors in ${operation} operations`);
-            lines.push(`# TYPE originals_operation_${safeOpName}_errors_total counter`);
-            lines.push(`originals_operation_${safeOpName}_errors_total ${opMetrics.errorCount}`);
-            lines.push('');
-        }
-        // Error metrics
-        lines.push('# HELP originals_errors_total Total number of errors by code');
-        lines.push('# TYPE originals_errors_total counter');
-        for (const [code, count] of Object.entries(metrics.errors)) {
-            lines.push(`originals_errors_total{code="${code}"} ${count}`);
-        }
-        lines.push('');
-        // Cache metrics
-        if (metrics.cacheStats) {
-            lines.push('# HELP originals_cache_hits_total Total number of cache hits');
-            lines.push('# TYPE originals_cache_hits_total counter');
-            lines.push(`originals_cache_hits_total ${metrics.cacheStats.hits}`);
-            lines.push('');
-            lines.push('# HELP originals_cache_misses_total Total number of cache misses');
-            lines.push('# TYPE originals_cache_misses_total counter');
-            lines.push(`originals_cache_misses_total ${metrics.cacheStats.misses}`);
-            lines.push('');
-            lines.push('# HELP originals_cache_hit_rate Cache hit rate');
-            lines.push('# TYPE originals_cache_hit_rate gauge');
-            lines.push(`originals_cache_hit_rate ${metrics.cacheStats.hitRate}`);
-            lines.push('');
-        }
-        // System metrics
-        lines.push('# HELP originals_uptime_milliseconds SDK uptime in milliseconds');
-        lines.push('# TYPE originals_uptime_milliseconds gauge');
-        lines.push(`originals_uptime_milliseconds ${metrics.uptime}`);
-        lines.push('');
-        return lines.join('\n');
-    }
-}

package/dist/utils/bitcoin-address.d.ts

@@ -1,38 +0,0 @@
-/**
- * Bitcoin network types supported by the validation
- */
-export type BitcoinNetwork = 'mainnet' | 'regtest' | 'signet';
-/**
- * Validates a Bitcoin address format and checksum for the given network.
- *
- * This function uses bitcoinjs-lib's address.toOutputScript() which performs:
- * - Format validation (bech32, base58check)
- * - Checksum verification
- * - Network prefix validation
- *
- * @param address - The Bitcoin address to validate
- * @param network - The network to validate against ('mainnet', 'regtest', 'signet')
- * @returns true if the address is valid for the network
- * @throws Error with descriptive message if validation fails
- *
- * @example
- * ```typescript
- * // Valid mainnet address
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'mainnet'); // true
- *
- * // Invalid checksum
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdd', 'mainnet'); // throws
- *
- * // Wrong network
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'testnet'); // throws
- * ```
- */
-export declare function validateBitcoinAddress(address: string, network: BitcoinNetwork): boolean;
-/**
- * Validates a Bitcoin address and returns a boolean instead of throwing
- *
- * @param address - The Bitcoin address to validate
- * @param network - The network to validate against
- * @returns true if valid, false otherwise
- */
-export declare function isValidBitcoinAddress(address: string, network: BitcoinNetwork): boolean;

package/dist/utils/bitcoin-address.js

@@ -1,113 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-/**
- * Maps our network names to bitcoinjs-lib network configurations
- */
-const getNetwork = (network) => {
-    switch (network) {
-        case 'mainnet':
-            return bitcoin.networks.bitcoin;
-        case 'regtest':
-            // Regtest uses testnet parameters but with bcrt prefix
-            // However, since many regtest addresses in tests use testnet format,
-            // we accept both testnet and regtest addresses for regtest network
-            return bitcoin.networks.regtest;
-        case 'signet':
-            // Signet uses the same bech32 prefix as testnet (tb1)
-            return bitcoin.networks.testnet;
-        default:
-            throw new Error(`Unsupported network: ${network}`);
-    }
-};
-/**
- * Validates a Bitcoin address format and checksum for the given network.
- *
- * This function uses bitcoinjs-lib's address.toOutputScript() which performs:
- * - Format validation (bech32, base58check)
- * - Checksum verification
- * - Network prefix validation
- *
- * @param address - The Bitcoin address to validate
- * @param network - The network to validate against ('mainnet', 'regtest', 'signet')
- * @returns true if the address is valid for the network
- * @throws Error with descriptive message if validation fails
- *
- * @example
- * ```typescript
- * // Valid mainnet address
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'mainnet'); // true
- *
- * // Invalid checksum
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdd', 'mainnet'); // throws
- *
- * // Wrong network
- * validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'testnet'); // throws
- * ```
- */
-export function validateBitcoinAddress(address, network) {
-    // Input validation
-    if (!address || typeof address !== 'string') {
-        throw new Error('Address must be a non-empty string');
-    }
-    const trimmedAddress = address.trim();
-    if (trimmedAddress.length === 0) {
-        throw new Error('Address cannot be empty');
-    }
-    // Check for mock/test addresses that should not be allowed in production
-    if (/^(mock-|test-)/i.test(trimmedAddress)) {
-        throw new Error('Mock or test addresses are not valid Bitcoin addresses');
-    }
-    // Validate address length (Bitcoin addresses are typically 26-90 characters)
-    if (trimmedAddress.length < 26 || trimmedAddress.length > 90) {
-        throw new Error(`Invalid address length: ${trimmedAddress.length} characters (expected 26-90)`);
-    }
-    try {
-        // Get the appropriate network configuration
-        const networkConfig = getNetwork(network);
-        // Use bitcoinjs-lib to validate the address format and checksum
-        // This will throw if the address is invalid
-        bitcoin.address.toOutputScript(trimmedAddress, networkConfig);
-        return true;
-    }
-    catch (error) {
-        // For regtest, also try testnet network as many tools use testnet addresses for regtest
-        if (network === 'regtest') {
-            try {
-                bitcoin.address.toOutputScript(trimmedAddress, bitcoin.networks.testnet);
-                return true;
-            }
-            catch {
-                // Fall through to error handling below
-            }
-        }
-        // Parse the error to provide more specific feedback
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Check for common error patterns and provide helpful messages
-        if (errorMessage.includes('Invalid checksum') || errorMessage.includes('checksum')) {
-            throw new Error(`Invalid Bitcoin address checksum for address: ${trimmedAddress}`);
-        }
-        if (errorMessage.includes('Invalid prefix') || errorMessage.includes('prefix')) {
-            throw new Error(`Invalid address prefix for ${network} network: ${trimmedAddress}`);
-        }
-        if (errorMessage.includes('too short') || errorMessage.includes('too long')) {
-            throw new Error(`Invalid address length for ${network}: ${trimmedAddress}`);
-        }
-        // Generic invalid address error
-        throw new Error(`Invalid Bitcoin address for ${network} network: ${trimmedAddress} (${errorMessage})`);
-    }
-}
-/**
- * Validates a Bitcoin address and returns a boolean instead of throwing
- *
- * @param address - The Bitcoin address to validate
- * @param network - The network to validate against
- * @returns true if valid, false otherwise
- */
-export function isValidBitcoinAddress(address, network) {
-    try {
-        validateBitcoinAddress(address, network);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/utils/cbor.d.ts

@@ -1,2 +0,0 @@
-export declare function encode(input: unknown): Uint8Array;
-export declare function decode<T = unknown>(bytes: Uint8Array | ArrayBuffer | Buffer): T;

package/dist/utils/cbor.js

@@ -1,9 +0,0 @@
-import * as cbor from 'cbor-js';
-export function encode(input) {
-    const encoded = cbor.encode(input);
-    return new Uint8Array(encoded);
-}
-export function decode(bytes) {
-    const view = new Uint8Array(bytes);
-    return cbor.decode(view.buffer);
-}

package/dist/utils/encoding.d.ts

@@ -1,37 +0,0 @@
-export declare function encodeBase64UrlMultibase(bytes: Uint8Array): string;
-export declare function decodeBase64UrlMultibase(s: string): Uint8Array;
-export declare function hexToBytes(hex: string): Uint8Array;
-export declare const MULTIBASE_BASE58BTC_HEADER = "z";
-export declare const MULTIBASE_BASE64URL_HEADER = "u";
-export declare const MULTICODEC_ED25519_PUB_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_ED25519_PRIV_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_X25519_PUB_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_X25519_PRIV_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_SECP256K1_PUB_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_SECP256K1_PRIV_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_BLS12381_G2_PUB_HEADER: Uint8Array<ArrayBuffer>;
-export declare const MULTICODEC_BLS12381_G2_PRIV_HEADER: Uint8Array<ArrayBuffer>;
-export declare const base64: {
-    encode: (unencoded: any) => string;
-    decode: (encoded: any) => Uint8Array;
-};
-export declare const utf8: {
-    encode: (unencoded: string) => Uint8Array;
-    decode: (encoded: Uint8Array) => string;
-};
-export declare const base64url: {
-    encode: (unencoded: any) => string;
-    decode: (encoded: any) => Uint8Array;
-};
-export declare const base58: {
-    encode: (unencoded: Uint8Array) => string;
-    decode: (encoded: string) => Uint8Array;
-};
-export declare const multibase: {
-    encode: (val: Uint8Array, encoding: "base58btc" | "base64url") => string;
-    decode: (val: string) => Uint8Array;
-};
-export declare const multikey: {
-    encode: (header: Uint8Array, val: Uint8Array) => string;
-    decode: (header: Uint8Array, val: string) => Uint8Array;
-};

package/dist/utils/encoding.js

@@ -1,120 +0,0 @@
-import b58 from 'b58';
-export function encodeBase64UrlMultibase(bytes) {
-    return 'z' + Buffer.from(bytes).toString('base64url');
-}
-export function decodeBase64UrlMultibase(s) {
-    if (!s || s[0] !== 'z') {
-        throw new Error('Invalid Multibase encoding');
-    }
-    return Buffer.from(s.slice(1), 'base64url');
-}
-export function hexToBytes(hex) {
-    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-    if (clean.length % 2 !== 0) {
-        throw new Error('Invalid hex string length');
-    }
-    const out = new Uint8Array(clean.length / 2);
-    for (let i = 0; i < clean.length; i += 2) {
-        const byteStr = clean.substring(i, i + 2);
-        const value = parseInt(byteStr, 16);
-        if (Number.isNaN(value)) {
-            throw new Error('Invalid hex string');
-        }
-        out[i / 2] = value;
-    }
-    return out;
-}
-// multibase base58-btc header
-export const MULTIBASE_BASE58BTC_HEADER = 'z';
-// multibase base64url header
-export const MULTIBASE_BASE64URL_HEADER = 'u';
-// multicodec ed25519-pub header as varint
-export const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
-// multicodec ed25519-priv header as varint
-export const MULTICODEC_ED25519_PRIV_HEADER = new Uint8Array([0x80, 0x26]);
-// multicodec x25519-pub header as varint
-export const MULTICODEC_X25519_PUB_HEADER = new Uint8Array([0xec, 0x01]);
-// multicodec x25519-priv header as varint
-export const MULTICODEC_X25519_PRIV_HEADER = new Uint8Array([0x82, 0x26]);
-// multicode secp256k1-pub header as varint
-export const MULTICODEC_SECP256K1_PUB_HEADER = new Uint8Array([0xe7, 0x01]);
-// multicode secp256k1-priv header as varint
-export const MULTICODEC_SECP256K1_PRIV_HEADER = new Uint8Array([0x13, 0x01]);
-// multicodec bls12381g2-pub header as varint
-export const MULTICODEC_BLS12381_G2_PUB_HEADER = new Uint8Array([0xeb, 0x01]);
-// multicodec bls12381g2-priv header as varint
-export const MULTICODEC_BLS12381_G2_PRIV_HEADER = new Uint8Array([0x8a, 0x26]);
-export const base64 = {
-    encode: (unencoded) => {
-        return Buffer.from(unencoded || '').toString('base64');
-    },
-    decode: (encoded) => {
-        return new Uint8Array(Buffer.from(encoded || '', 'base64').buffer);
-    }
-};
-export const utf8 = {
-    encode: (unencoded) => {
-        return new TextEncoder().encode(unencoded);
-    },
-    decode: (encoded) => {
-        return new TextDecoder().decode(encoded);
-    }
-};
-export const base64url = {
-    encode: (unencoded) => {
-        const encoded = base64.encode(unencoded);
-        return encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
-    },
-    decode: (encoded) => {
-        encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
-        while (encoded.length % 4)
-            encoded += '=';
-        return base64.decode(encoded);
-    }
-};
-export const base58 = {
-    encode: (unencoded) => {
-        return b58.encode(unencoded);
-    },
-    decode: (encoded) => {
-        return b58.decode(encoded);
-    }
-};
-export const multibase = {
-    encode: (val, encoding) => {
-        if (encoding === 'base58btc') {
-            const baseEncoded = base58.encode(val);
-            return MULTIBASE_BASE58BTC_HEADER + baseEncoded;
-        }
-        else if (encoding === 'base64url') {
-            return MULTIBASE_BASE64URL_HEADER + base64url.encode(val);
-        }
-        throw new Error('Invalid multibase encoding.');
-    },
-    decode: (val) => {
-        if (val.startsWith(MULTIBASE_BASE58BTC_HEADER)) {
-            return base58.decode(val.substring(1));
-        }
-        else if (val.startsWith(MULTIBASE_BASE64URL_HEADER)) {
-            return base64url.decode(val.substring(1));
-        }
-        throw new Error('Multibase value does not have expected header.');
-    }
-};
-export const multikey = {
-    encode: (header, val) => {
-        const mcBytes = new Uint8Array(header.length + val.length);
-        mcBytes.set(header);
-        mcBytes.set(val, header.length);
-        return multibase.encode(mcBytes, 'base58btc');
-    },
-    decode: (header, val) => {
-        const mcValue = multibase.decode(val);
-        for (let i = 0; i < header.length; i++) {
-            if (mcValue[i] !== header[i]) {
-                throw new Error('Multikey value does not have expected header.');
-            }
-        }
-        return mcValue.slice(header.length);
-    }
-};

package/dist/utils/hash.d.ts

@@ -1 +0,0 @@
-export declare function sha256Bytes(input: string | Uint8Array): Promise<Uint8Array>;

package/dist/utils/hash.js

@@ -1,5 +0,0 @@
-export async function sha256Bytes(input) {
-    const data = typeof input === 'string' ? new TextEncoder().encode(input) : input;
-    const digest = await globalThis.crypto.subtle.digest('SHA-256', data);
-    return new Uint8Array(digest);
-}

package/dist/utils/retry.d.ts

@@ -1,10 +0,0 @@
-export interface RetryOptions {
-    maxRetries?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    backoffFactor?: number;
-    jitterFactor?: number;
-    isRetriable?: (error: unknown) => boolean;
-    onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
-}
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/utils/retry.js

@@ -1,35 +0,0 @@
-const DEFAULTS = {
-    maxRetries: 3,
-    baseDelayMs: 300,
-    maxDelayMs: 10000,
-    backoffFactor: 2,
-    jitterFactor: 0.1,
-    isRetriable: () => true,
-    onRetry: () => { }
-};
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-function computeDelay(attempt, opts) {
-    const exp = opts.baseDelayMs * Math.pow(opts.backoffFactor, attempt);
-    const withJitter = exp + ((Math.random() * 2 - 1) * opts.jitterFactor * exp);
-    return Math.min(Math.max(0, Math.floor(withJitter)), opts.maxDelayMs);
-}
-export async function withRetry(fn, options = {}) {
-    const opts = { ...DEFAULTS, ...options };
-    let lastError;
-    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastError = err;
-            if (attempt >= opts.maxRetries || !opts.isRetriable(err))
-                break;
-            const delay = computeDelay(attempt, opts);
-            opts.onRetry(attempt + 1, delay, err);
-            await sleep(delay);
-        }
-    }
-    throw lastError;
-}