@private.me/xbind 3.0.1 → 3.0.2

package/dist-standalone/cjs/progress-callbacks.js

@@ -1 +1,583 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.EncryptionProgressTracker=exports.ShareDistributionTracker=exports.TransferProgressTracker=exports.OperationProgressTracker=void 0;const ux_helpers_1=require("../_deps/ux-helpers/index.js");class OperationProgressTracker{callback;throttleMs;lastUpdateTime=0;currentStage="";currentStageWeight=0;currentStageProgress=0;completedWeight=0;metadata={};constructor(t,e){this.callback=t,this.throttleMs=e?.throttleMs??100}startStage(t,e,s){this.currentStage=t,this.currentStageWeight=Math.max(0,Math.min(100,e)),this.currentStageProgress=0,this.reportProgress(s??`Starting ${t}...`)}updateStageProgress(t,e,s){this.currentStageProgress=Math.max(0,Math.min(100,t)),s&&(this.metadata={...this.metadata,...s});const r=e??`${this.currentStage} (${Math.round(t)}%)`;this.reportProgress(r)}completeStage(){this.currentStageProgress=100,this.completedWeight+=this.currentStageWeight,this.reportProgress(`${this.currentStage} complete`),this.currentStage="",this.currentStageWeight=0,this.currentStageProgress=0}complete(){this.completedWeight=100,this.currentStageProgress=100,this.reportProgress("Complete")}getProgress(){const t=this.currentStageWeight*this.currentStageProgress/100;return Math.min(100,this.completedWeight+t)}updateMetadata(t){this.metadata={...this.metadata,...t}}reportProgress(t){if(!this.callback)return;const e=Date.now();if(e-this.lastUpdateTime<this.throttleMs){if(this.getProgress()<100)return}this.lastUpdateTime=e;const s=this.getProgress();if(this.isEnhancedCallback(this.callback)){const e={stage:this.currentStage,progress:s,stageProgress:this.currentStageProgress,status:t,metadata:Object.keys(this.metadata).length>0?this.metadata:void 0};this.callback(e)}else this.callback(t,s)}isEnhancedCallback(t){return 1===t.length}}exports.OperationProgressTracker=OperationProgressTracker;class TransferProgressTracker{totalBytes;callback;reporter;throttleMs;bytesTransferred=0;startTime=Date.now();lastUpdateTime=0;samples=[];maxSamples=10;constructor(t,e,s=100){this.totalBytes=t,this.callback=e,this.throttleMs=s,this.reporter=new ux_helpers_1.ProgressReporter("function"==typeof e&&2===e.length?e:void 0)}addTransferred(t){this.bytesTransferred+=t;const e=Date.now();this.samples.push({time:e,bytes:this.bytesTransferred}),this.samples.length>this.maxSamples&&this.samples.shift(),e-this.lastUpdateTime<this.throttleMs||(this.lastUpdateTime=e,this.reportProgress())}complete(){this.bytesTransferred=this.totalBytes,this.reportProgress()}getProgress(){return 0===this.totalBytes?100:Math.min(100,this.bytesTransferred/this.totalBytes*100)}calculateBytesPerSecond(){if(this.samples.length<2){const t=(Date.now()-this.startTime)/1e3;return t>0?this.bytesTransferred/t:0}const t=this.samples[0],e=this.samples[this.samples.length-1];if(!t||!e)return 0;const s=(e.time-t.time)/1e3,r=e.bytes-t.bytes;return s>0?r/s:0}estimateTimeRemaining(){const t=this.calculateBytesPerSecond();if(0===t)return 0;return(this.totalBytes-this.bytesTransferred)/t*1e3}reportProgress(){if(!this.callback)return;const t=this.getProgress(),e=this.calculateBytesPerSecond(),s=this.estimateTimeRemaining(),r=this.formatStatus(t,e,s);if(this.isEnhancedCallback(this.callback)){const a={stage:"transfer",progress:t,stageProgress:t,status:r,metadata:{bytesTransferred:this.bytesTransferred,totalBytes:this.totalBytes,bytesPerSecond:e,estimatedTimeRemaining:s}};this.callback(a)}else this.reporter.report(r,t)}formatStatus(t,e,s){const r=this.formatBytes(this.bytesTransferred),a=this.formatBytes(this.totalBytes),i=this.formatBytes(e),o=this.formatTime(s);return`Transferring ${r} / ${a} (${Math.round(t)}%) - ${i}/s - ${o} remaining`}formatBytes(t){const e=["B","KB","MB","GB","TB"];let s=t,r=0;for(;s>=1024&&r<e.length-1;)s/=1024,r++;return`${s.toFixed(1)} ${e[r]}`}formatTime(t){const e=Math.floor(t/1e3);if(e<60)return`${e}s`;const s=Math.floor(e/60);if(s<60)return`${s}m ${e%60}s`;return`${Math.floor(s/60)}h ${s%60}m`}isEnhancedCallback(t){return 1===t.length}}exports.TransferProgressTracker=TransferProgressTracker;class ShareDistributionTracker{totalShares;callback;reporter;distributedShares=new Set;constructor(t,e){this.totalShares=t,this.callback=e,this.reporter=new ux_helpers_1.ProgressReporter("function"==typeof e&&2===e.length?e:void 0)}markShareDistributed(t){this.distributedShares.add(t),this.reportProgress()}complete(){for(let t=0;t<this.totalShares;t++)this.distributedShares.add(t);this.reportProgress()}getProgress(){return 0===this.totalShares?100:this.distributedShares.size/this.totalShares*100}reportProgress(){if(!this.callback)return;const t=this.getProgress(),e=`Distributed ${this.distributedShares.size} / ${this.totalShares} shares`;if(this.isEnhancedCallback(this.callback)){const s={stage:"distribution",progress:t,stageProgress:t,status:e,metadata:{sharesDistributed:this.distributedShares.size,totalShares:this.totalShares}};this.callback(s)}else this.reporter.report(e,t)}isEnhancedCallback(t){return 1===t.length}}exports.ShareDistributionTracker=ShareDistributionTracker;class EncryptionProgressTracker{operation;totalItems;callback;reporter;itemsProcessed=0;constructor(t,e,s){this.operation=t,this.totalItems=e,this.callback=s,this.reporter=new ux_helpers_1.ProgressReporter("function"==typeof s&&2===s.length?s:void 0)}incrementProcessed(t=1){this.itemsProcessed+=t,this.reportProgress()}complete(){this.itemsProcessed=this.totalItems,this.reportProgress()}getProgress(){return 0===this.totalItems?100:Math.min(100,this.itemsProcessed/this.totalItems*100)}reportProgress(){if(!this.callback)return;const t=this.getProgress(),e=`${this.operation.charAt(0).toUpperCase()+this.operation.slice(1)}ing: ${this.itemsProcessed} / ${this.totalItems} items`;if(this.isEnhancedCallback(this.callback)){const s={stage:this.operation,progress:t,stageProgress:t,status:e,metadata:{cryptoOperation:this.operation,itemsProcessed:this.itemsProcessed,totalItems:this.totalItems}};this.callback(s)}else this.reporter.report(e,t)}isEnhancedCallback(t){return 1===t.length}}exports.EncryptionProgressTracker=EncryptionProgressTracker;
+"use strict";
+/**
+ * @module progress-callbacks
+ * Enhanced progress tracking for xBind operations
+ *
+ * Provides domain-specific progress callbacks for long-running operations:
+ * - Upload/download progress with bandwidth estimation
+ * - Share distribution progress (XorIDA multi-channel delivery)
+ * - Encryption/decryption progress
+ * - Multi-stage operation tracking
+ *
+ * @example
+ * ```typescript
+ * const tracker = new OperationProgressTracker(onProgress);
+ * tracker.startStage('encryption', 40); // 40% of total operation
+ * // ... encryption work
+ * tracker.updateStageProgress(50); // 50% of encryption stage
+ * tracker.completeStage();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionProgressTracker = exports.ShareDistributionTracker = exports.TransferProgressTracker = exports.OperationProgressTracker = void 0;
+const ux_helpers_1 = require("../_deps/ux-helpers/index.js");
+/**
+ * Multi-stage operation progress tracker.
+ *
+ * Manages progress across multiple stages with weighted contributions
+ * to overall progress. Useful for complex operations like:
+ * - Message send: resolve DID (10%) → encrypt (30%) → split shares (20%) → distribute (40%)
+ * - File transfer: prepare (5%) → encrypt (25%) → upload (70%)
+ *
+ * @example
+ * ```typescript
+ * const tracker = new OperationProgressTracker(onProgress);
+ *
+ * tracker.startStage('preparation', 10);
+ * // ... prep work
+ * tracker.completeStage();
+ *
+ * tracker.startStage('encryption', 40);
+ * tracker.updateStageProgress(50); // Halfway through encryption
+ * tracker.completeStage();
+ *
+ * tracker.startStage('distribution', 50);
+ * // ... distribution work
+ * tracker.complete();
+ * ```
+ */
+class OperationProgressTracker {
+    callback;
+    throttleMs;
+    lastUpdateTime = 0;
+    currentStage = '';
+    currentStageWeight = 0;
+    currentStageProgress = 0;
+    completedWeight = 0;
+    metadata = {};
+    /**
+     * Create a new operation progress tracker.
+     *
+     * @param onProgress Progress callback (standard or enhanced)
+     * @param options Tracking options
+     */
+    constructor(onProgress, options) {
+        this.callback = onProgress;
+        this.throttleMs = options?.throttleMs ?? 100; // Default 100ms throttle
+    }
+    /**
+     * Start a new stage.
+     *
+     * @param name Stage identifier
+     * @param weight Weight of this stage (percentage of total, 0-100)
+     * @param description Human-readable description
+     */
+    startStage(name, weight, description) {
+        this.currentStage = name;
+        this.currentStageWeight = Math.max(0, Math.min(100, weight));
+        this.currentStageProgress = 0;
+        this.reportProgress(description ?? `Starting ${name}...`);
+    }
+    /**
+     * Update progress within the current stage.
+     *
+     * @param stagePercent Progress percentage within current stage (0-100)
+     * @param status Optional status message
+     * @param metadata Optional progress metadata
+     */
+    updateStageProgress(stagePercent, status, metadata) {
+        this.currentStageProgress = Math.max(0, Math.min(100, stagePercent));
+        if (metadata) {
+            this.metadata = { ...this.metadata, ...metadata };
+        }
+        const message = status ?? `${this.currentStage} (${Math.round(stagePercent)}%)`;
+        this.reportProgress(message);
+    }
+    /**
+     * Complete the current stage and advance overall progress.
+     */
+    completeStage() {
+        this.currentStageProgress = 100;
+        this.completedWeight += this.currentStageWeight;
+        this.reportProgress(`${this.currentStage} complete`);
+        // Reset for next stage
+        this.currentStage = '';
+        this.currentStageWeight = 0;
+        this.currentStageProgress = 0;
+    }
+    /**
+     * Mark the entire operation as complete.
+     */
+    complete() {
+        this.completedWeight = 100;
+        this.currentStageProgress = 100;
+        this.reportProgress('Complete');
+    }
+    /**
+     * Get current overall progress percentage.
+     *
+     * @returns Progress percentage (0-100)
+     */
+    getProgress() {
+        const stageContribution = (this.currentStageWeight * this.currentStageProgress) / 100;
+        return Math.min(100, this.completedWeight + stageContribution);
+    }
+    /**
+     * Update metadata without changing progress.
+     *
+     * @param metadata Metadata to merge
+     */
+    updateMetadata(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+    }
+    /**
+     * Report progress to callback (with throttling).
+     *
+     * @param status Status message
+     */
+    reportProgress(status) {
+        if (!this.callback)
+            return;
+        const now = Date.now();
+        if (now - this.lastUpdateTime < this.throttleMs) {
+            // Throttle updates unless complete
+            const progress = this.getProgress();
+            if (progress < 100)
+                return;
+        }
+        this.lastUpdateTime = now;
+        const progress = this.getProgress();
+        // Check if callback expects enhanced events
+        if (this.isEnhancedCallback(this.callback)) {
+            const event = {
+                stage: this.currentStage,
+                progress,
+                stageProgress: this.currentStageProgress,
+                status,
+                metadata: Object.keys(this.metadata).length > 0 ? this.metadata : undefined,
+            };
+            this.callback(event);
+        }
+        else {
+            // Standard callback
+            this.callback(status, progress);
+        }
+    }
+    /**
+     * Check if callback expects enhanced events.
+     *
+     * @param callback Callback to check
+     * @returns True if enhanced callback
+     */
+    isEnhancedCallback(callback) {
+        // Enhanced callbacks accept 1 parameter (event object)
+        // Standard callbacks accept 2 parameters (status, percent)
+        return callback.length === 1;
+    }
+}
+exports.OperationProgressTracker = OperationProgressTracker;
+/**
+ * Transfer progress tracker with bandwidth estimation.
+ *
+ * Tracks upload/download progress with automatic bandwidth calculation
+ * and estimated time remaining.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new TransferProgressTracker(totalBytes, onProgress);
+ *
+ * for (const chunk of chunks) {
+ *   await uploadChunk(chunk);
+ *   tracker.addTransferred(chunk.length);
+ * }
+ *
+ * tracker.complete();
+ * ```
+ */
+class TransferProgressTracker {
+    totalBytes;
+    callback;
+    reporter;
+    throttleMs;
+    bytesTransferred = 0;
+    startTime = Date.now();
+    lastUpdateTime = 0;
+    samples = [];
+    maxSamples = 10;
+    /**
+     * Create a new transfer progress tracker.
+     *
+     * @param totalBytes Total bytes to transfer
+     * @param onProgress Progress callback
+     * @param throttleMs Minimum interval between updates (default: 100ms)
+     */
+    constructor(totalBytes, onProgress, throttleMs = 100) {
+        this.totalBytes = totalBytes;
+        this.callback = onProgress;
+        this.throttleMs = throttleMs;
+        // Create standard progress reporter for fallback
+        this.reporter = new ux_helpers_1.ProgressReporter(typeof onProgress === 'function' && onProgress.length === 2
+            ? onProgress
+            : undefined);
+    }
+    /**
+     * Add transferred bytes and update progress.
+     *
+     * @param bytes Number of bytes transferred
+     */
+    addTransferred(bytes) {
+        this.bytesTransferred += bytes;
+        const now = Date.now();
+        // Add sample for bandwidth estimation
+        this.samples.push({ time: now, bytes: this.bytesTransferred });
+        if (this.samples.length > this.maxSamples) {
+            this.samples.shift();
+        }
+        // Throttle updates
+        if (now - this.lastUpdateTime < this.throttleMs) {
+            return;
+        }
+        this.lastUpdateTime = now;
+        this.reportProgress();
+    }
+    /**
+     * Mark transfer as complete.
+     */
+    complete() {
+        this.bytesTransferred = this.totalBytes;
+        this.reportProgress();
+    }
+    /**
+     * Get current progress percentage.
+     *
+     * @returns Progress percentage (0-100)
+     */
+    getProgress() {
+        if (this.totalBytes === 0)
+            return 100;
+        return Math.min(100, (this.bytesTransferred / this.totalBytes) * 100);
+    }
+    /**
+     * Calculate current transfer rate.
+     *
+     * @returns Bytes per second
+     */
+    calculateBytesPerSecond() {
+        if (this.samples.length < 2) {
+            const elapsed = (Date.now() - this.startTime) / 1000;
+            return elapsed > 0 ? this.bytesTransferred / elapsed : 0;
+        }
+        const oldest = this.samples[0];
+        const newest = this.samples[this.samples.length - 1];
+        if (!oldest || !newest)
+            return 0;
+        const timeDiff = (newest.time - oldest.time) / 1000; // seconds
+        const bytesDiff = newest.bytes - oldest.bytes;
+        return timeDiff > 0 ? bytesDiff / timeDiff : 0;
+    }
+    /**
+     * Estimate time remaining.
+     *
+     * @returns Estimated milliseconds remaining
+     */
+    estimateTimeRemaining() {
+        const bytesPerSecond = this.calculateBytesPerSecond();
+        if (bytesPerSecond === 0)
+            return 0;
+        const bytesRemaining = this.totalBytes - this.bytesTransferred;
+        return (bytesRemaining / bytesPerSecond) * 1000; // milliseconds
+    }
+    /**
+     * Report progress to callback.
+     */
+    reportProgress() {
+        if (!this.callback)
+            return;
+        const progress = this.getProgress();
+        const bytesPerSecond = this.calculateBytesPerSecond();
+        const estimatedTimeRemaining = this.estimateTimeRemaining();
+        const status = this.formatStatus(progress, bytesPerSecond, estimatedTimeRemaining);
+        if (this.isEnhancedCallback(this.callback)) {
+            const event = {
+                stage: 'transfer',
+                progress,
+                stageProgress: progress,
+                status,
+                metadata: {
+                    bytesTransferred: this.bytesTransferred,
+                    totalBytes: this.totalBytes,
+                    bytesPerSecond,
+                    estimatedTimeRemaining,
+                },
+            };
+            this.callback(event);
+        }
+        else {
+            this.reporter.report(status, progress);
+        }
+    }
+    /**
+     * Format status message with transfer details.
+     *
+     * @param progress Progress percentage
+     * @param bytesPerSecond Transfer rate
+     * @param estimatedTimeRemaining Time remaining in ms
+     * @returns Formatted status string
+     */
+    formatStatus(progress, bytesPerSecond, estimatedTimeRemaining) {
+        const transferred = this.formatBytes(this.bytesTransferred);
+        const total = this.formatBytes(this.totalBytes);
+        const rate = this.formatBytes(bytesPerSecond);
+        const remaining = this.formatTime(estimatedTimeRemaining);
+        return `Transferring ${transferred} / ${total} (${Math.round(progress)}%) - ${rate}/s - ${remaining} remaining`;
+    }
+    /**
+     * Format bytes for display.
+     *
+     * @param bytes Number of bytes
+     * @returns Formatted string (e.g., "1.5 MB")
+     */
+    formatBytes(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let value = bytes;
+        let unitIndex = 0;
+        while (value >= 1024 && unitIndex < units.length - 1) {
+            value /= 1024;
+            unitIndex++;
+        }
+        return `${value.toFixed(1)} ${units[unitIndex]}`;
+    }
+    /**
+     * Format time for display.
+     *
+     * @param ms Milliseconds
+     * @returns Formatted string (e.g., "2m 30s")
+     */
+    formatTime(ms) {
+        const seconds = Math.floor(ms / 1000);
+        if (seconds < 60)
+            return `${seconds}s`;
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        if (minutes < 60)
+            return `${minutes}m ${remainingSeconds}s`;
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        return `${hours}h ${remainingMinutes}m`;
+    }
+    /**
+     * Check if callback expects enhanced events.
+     *
+     * @param callback Callback to check
+     * @returns True if enhanced callback
+     */
+    isEnhancedCallback(callback) {
+        return callback.length === 1;
+    }
+}
+exports.TransferProgressTracker = TransferProgressTracker;
+/**
+ * Share distribution progress tracker for XorIDA operations.
+ *
+ * Tracks progress of distributing shares across multiple channels.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new ShareDistributionTracker(3, onProgress);
+ *
+ * await distributeShare(0);
+ * tracker.markShareDistributed(0);
+ *
+ * await distributeShare(1);
+ * tracker.markShareDistributed(1);
+ *
+ * await distributeShare(2);
+ * tracker.markShareDistributed(2);
+ *
+ * tracker.complete();
+ * ```
+ */
+class ShareDistributionTracker {
+    totalShares;
+    callback;
+    reporter;
+    distributedShares = new Set();
+    /**
+     * Create a new share distribution tracker.
+     *
+     * @param totalShares Total number of shares to distribute
+     * @param onProgress Progress callback
+     */
+    constructor(totalShares, onProgress) {
+        this.totalShares = totalShares;
+        this.callback = onProgress;
+        this.reporter = new ux_helpers_1.ProgressReporter(typeof onProgress === 'function' && onProgress.length === 2
+            ? onProgress
+            : undefined);
+    }
+    /**
+     * Mark a share as successfully distributed.
+     *
+     * @param shareIndex Zero-based share index
+     */
+    markShareDistributed(shareIndex) {
+        this.distributedShares.add(shareIndex);
+        this.reportProgress();
+    }
+    /**
+     * Mark all shares as distributed and complete.
+     */
+    complete() {
+        for (let i = 0; i < this.totalShares; i++) {
+            this.distributedShares.add(i);
+        }
+        this.reportProgress();
+    }
+    /**
+     * Get current progress percentage.
+     *
+     * @returns Progress percentage (0-100)
+     */
+    getProgress() {
+        if (this.totalShares === 0)
+            return 100;
+        return (this.distributedShares.size / this.totalShares) * 100;
+    }
+    /**
+     * Report progress to callback.
+     */
+    reportProgress() {
+        if (!this.callback)
+            return;
+        const progress = this.getProgress();
+        const status = `Distributed ${this.distributedShares.size} / ${this.totalShares} shares`;
+        if (this.isEnhancedCallback(this.callback)) {
+            const event = {
+                stage: 'distribution',
+                progress,
+                stageProgress: progress,
+                status,
+                metadata: {
+                    sharesDistributed: this.distributedShares.size,
+                    totalShares: this.totalShares,
+                },
+            };
+            this.callback(event);
+        }
+        else {
+            this.reporter.report(status, progress);
+        }
+    }
+    /**
+     * Check if callback expects enhanced events.
+     *
+     * @param callback Callback to check
+     * @returns True if enhanced callback
+     */
+    isEnhancedCallback(callback) {
+        return callback.length === 1;
+    }
+}
+exports.ShareDistributionTracker = ShareDistributionTracker;
+/**
+ * Encryption progress tracker.
+ *
+ * Tracks progress of encryption/decryption operations on large data.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new EncryptionProgressTracker('encrypt', totalChunks, onProgress);
+ *
+ * for (const chunk of chunks) {
+ *   await encryptChunk(chunk);
+ *   tracker.incrementProcessed();
+ * }
+ *
+ * tracker.complete();
+ * ```
+ */
+class EncryptionProgressTracker {
+    operation;
+    totalItems;
+    callback;
+    reporter;
+    itemsProcessed = 0;
+    /**
+     * Create a new encryption progress tracker.
+     *
+     * @param operation Cryptographic operation type
+     * @param totalItems Total number of items to process
+     * @param onProgress Progress callback
+     */
+    constructor(operation, totalItems, onProgress) {
+        this.operation = operation;
+        this.totalItems = totalItems;
+        this.callback = onProgress;
+        this.reporter = new ux_helpers_1.ProgressReporter(typeof onProgress === 'function' && onProgress.length === 2
+            ? onProgress
+            : undefined);
+    }
+    /**
+     * Increment the number of processed items.
+     *
+     * @param count Number of items to add (default: 1)
+     */
+    incrementProcessed(count = 1) {
+        this.itemsProcessed += count;
+        this.reportProgress();
+    }
+    /**
+     * Mark operation as complete.
+     */
+    complete() {
+        this.itemsProcessed = this.totalItems;
+        this.reportProgress();
+    }
+    /**
+     * Get current progress percentage.
+     *
+     * @returns Progress percentage (0-100)
+     */
+    getProgress() {
+        if (this.totalItems === 0)
+            return 100;
+        return Math.min(100, (this.itemsProcessed / this.totalItems) * 100);
+    }
+    /**
+     * Report progress to callback.
+     */
+    reportProgress() {
+        if (!this.callback)
+            return;
+        const progress = this.getProgress();
+        const operationName = this.operation.charAt(0).toUpperCase() + this.operation.slice(1);
+        const status = `${operationName}ing: ${this.itemsProcessed} / ${this.totalItems} items`;
+        if (this.isEnhancedCallback(this.callback)) {
+            const event = {
+                stage: this.operation,
+                progress,
+                stageProgress: progress,
+                status,
+                metadata: {
+                    cryptoOperation: this.operation,
+                    itemsProcessed: this.itemsProcessed,
+                    totalItems: this.totalItems,
+                },
+            };
+            this.callback(event);
+        }
+        else {
+            this.reporter.report(status, progress);
+        }
+    }
+    /**
+     * Check if callback expects enhanced events.
+     *
+     * @param callback Callback to check
+     * @returns True if enhanced callback
+     */
+    isEnhancedCallback(callback) {
+        return callback.length === 1;
+    }
+}
+exports.EncryptionProgressTracker = EncryptionProgressTracker;

package/dist-standalone/cjs/redis-nonce-store.js

@@ -1 +1,76 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.RedisNonceStore=void 0;const DEFAULT_TTL_SECONDS=600,DEFAULT_KEY_PREFIX="nonce:";class RedisNonceStore{client;ttlSeconds;keyPrefix;constructor(e){this.client=e.client,this.ttlSeconds=e.ttlSeconds??600,this.keyPrefix=e.keyPrefix??"nonce:"}async check(e,t){const s=`${this.keyPrefix}${t}:${e}`;return"OK"===await this.client.setNX(s,"1",this.ttlSeconds)}cleanup(){}dispose(){this.client.quit()}}exports.RedisNonceStore=RedisNonceStore;
+"use strict";
+/* -- RedisNonceStore -- Cross-Node Replay Prevention -- */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisNonceStore = void 0;
+/** Default TTL for nonce entries: 600 seconds (10 minutes). */
+const DEFAULT_TTL_SECONDS = 600;
+/** Default key prefix for Redis nonce keys. */
+const DEFAULT_KEY_PREFIX = 'nonce:';
+/**
+ * Redis-backed nonce store for multi-node deployments.
+ *
+ * Uses Redis SET NX with TTL for atomic, distributed nonce deduplication.
+ * Nonce expiry is handled by Redis TTL -- no manual cleanup needed.
+ * Zero npm dependencies: users provide their own RedisClient implementation.
+ *
+ * @example
+ * ```typescript
+ * import { RedisNonceStore } from '@private.me/xbind';
+ * import Redis from 'ioredis';
+ *
+ * const redis = new Redis();
+ * const store = new RedisNonceStore({
+ *   client: {
+ *     setNX: (key, value, ttl) =>
+ *       redis.set(key, value, 'EX', ttl, 'NX'),
+ *     del: (key) => redis.del(key),
+ *     quit: () => redis.quit(),
+ *   },
+ * });
+ * ```
+ */
+class RedisNonceStore {
+    client;
+    ttlSeconds;
+    keyPrefix;
+    constructor(opts) {
+        this.client = opts.client;
+        this.ttlSeconds = opts.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+        this.keyPrefix = opts.keyPrefix ?? DEFAULT_KEY_PREFIX;
+    }
+    /**
+     * Check if a nonce is fresh and record it atomically via Redis SET NX.
+     *
+     * Uses Redis SET with NX (set-if-not-exists) and EX (TTL in seconds)
+     * for atomic, distributed deduplication. If the key already exists in
+     * any Redis-connected node, the nonce is rejected as a duplicate.
+     *
+     * @param nonce - The nonce string to check.
+     * @param senderDid - The DID of the sender.
+     * @returns true if the nonce is new (accepted), false if duplicate (rejected).
+     */
+    async check(nonce, senderDid) {
+        const key = `${this.keyPrefix}${senderDid}:${nonce}`;
+        const result = await this.client.setNX(key, '1', this.ttlSeconds);
+        return result === 'OK';
+    }
+    /**
+     * No-op for Redis store -- TTL-based expiry is handled automatically.
+     *
+     * This method exists to satisfy the NonceStore interface. Redis keys
+     * expire based on the TTL set during setNX, so no manual cleanup is needed.
+     */
+    cleanup() {
+        // No-op: Redis TTL handles expiry automatically
+    }
+    /**
+     * Disconnect from Redis gracefully.
+     *
+     * Calls the underlying RedisClient quit() method to close the connection.
+     * After calling dispose(), the store should not be used.
+     */
+    dispose() {
+        void this.client.quit();
+    }
+}
+exports.RedisNonceStore = RedisNonceStore;