@waku/sds 0.0.8-ff9c430.0 → 0.0.8

package/bundle/index.js

@@ -1045,6 +1045,12 @@ var MessageChannelEvent;
     MessageChannelEvent["InSyncReceived"] = "sds:in:sync-received";
     MessageChannelEvent["InMessageLost"] = "sds:in:message-irretrievably-lost";
     MessageChannelEvent["ErrorTask"] = "sds:error-task";
+    // SDS-R Repair Events
+    MessageChannelEvent["RepairRequestQueued"] = "sds:repair:request-queued";
+    MessageChannelEvent["RepairRequestSent"] = "sds:repair:request-sent";
+    MessageChannelEvent["RepairRequestReceived"] = "sds:repair:request-received";
+    MessageChannelEvent["RepairResponseQueued"] = "sds:repair:response-queued";
+    MessageChannelEvent["RepairResponseSent"] = "sds:repair:response-sent";
 })(MessageChannelEvent || (MessageChannelEvent = {}));
 
 /**
@@ -24056,6 +24062,10 @@ var HistoryEntry;
                     w.uint32(18);
                     w.bytes(obj.retrievalHint);
                 }
+                if (obj.senderId != null) {
+                    w.uint32(26);
+                    w.string(obj.senderId);
+                }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
@@ -24075,6 +24085,10 @@ var HistoryEntry;
                             obj.retrievalHint = reader.bytes();
                             break;
                         }
+                        case 3: {
+                            obj.senderId = reader.string();
+                            break;
+                        }
                         default: {
                             reader.skipType(tag & 7);
                             break;
@@ -24128,6 +24142,12 @@ var SdsMessage;
                     w.uint32(98);
                     w.bytes(obj.bloomFilter);
                 }
+                if (obj.repairRequest != null) {
+                    for (const value of obj.repairRequest) {
+                        w.uint32(106);
+                        HistoryEntry.codec().encode(value, w);
+                    }
+                }
                 if (obj.content != null) {
                     w.uint32(162);
                     w.bytes(obj.content);
@@ -24140,7 +24160,8 @@ var SdsMessage;
                     senderId: '',
                     messageId: '',
                     channelId: '',
-                    causalHistory: []
+                    causalHistory: [],
+                    repairRequest: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -24175,6 +24196,15 @@ var SdsMessage;
                             obj.bloomFilter = reader.bytes();
                             break;
                         }
+                        case 13: {
+                            if (opts.limits?.repairRequest != null && obj.repairRequest.length === opts.limits.repairRequest) {
+                                throw new MaxLengthError('Decode error - map field "repairRequest" had too many elements');
+                            }
+                            obj.repairRequest.push(HistoryEntry.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.repairRequest$
+                            }));
+                            break;
+                        }
                         case 20: {
                             obj.content = reader.bytes();
                             break;
@@ -24198,7 +24228,7 @@ var SdsMessage;
     };
 })(SdsMessage || (SdsMessage = {}));
 
-const log$1 = new Logger("sds:message");
+const log$3 = new Logger("sds:message");
 class Message {
     messageId;
     channelId;
@@ -24207,8 +24237,9 @@ class Message {
     lamportTimestamp;
     bloomFilter;
     content;
+    repairRequest;
     retrievalHint;
-    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, 
+    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest = [], 
     /**
      * Not encoded, set after it is sent, used to include in follow-up messages
      */
@@ -24220,6 +24251,7 @@ class Message {
         this.lamportTimestamp = lamportTimestamp;
         this.bloomFilter = bloomFilter;
         this.content = content;
+        this.repairRequest = repairRequest;
         this.retrievalHint = retrievalHint;
     }
     encode() {
@@ -24227,20 +24259,20 @@ class Message {
     }
     static decode(data) {
         try {
-            const { messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content } = SdsMessage.decode(data);
+            const { messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest } = SdsMessage.decode(data);
             if (testContentMessage({ lamportTimestamp, content })) {
-                return new ContentMessage(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content);
+                return new ContentMessage(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest);
             }
             if (testEphemeralMessage({ lamportTimestamp, content })) {
-                return new EphemeralMessage(messageId, channelId, senderId, causalHistory, undefined, bloomFilter, content);
+                return new EphemeralMessage(messageId, channelId, senderId, causalHistory, undefined, bloomFilter, content, repairRequest);
             }
             if (testSyncMessage({ lamportTimestamp, content })) {
-                return new SyncMessage(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, undefined);
+                return new SyncMessage(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, undefined, repairRequest);
             }
-            log$1.error("message received was of unknown type", lamportTimestamp, content);
+            log$3.error("message received was of unknown type", lamportTimestamp, content);
         }
         catch (err) {
-            log$1.error("failed to decode sds message", err);
+            log$3.error("failed to decode sds message", err);
         }
         return undefined;
     }
@@ -24253,13 +24285,14 @@ class SyncMessage extends Message {
     lamportTimestamp;
     bloomFilter;
     content;
+    repairRequest;
     retrievalHint;
-    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, 
+    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest = [], 
     /**
      * Not encoded, set after it is sent, used to include in follow-up messages
      */
     retrievalHint) {
-        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, retrievalHint);
+        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest, retrievalHint);
         this.messageId = messageId;
         this.channelId = channelId;
         this.senderId = senderId;
@@ -24267,6 +24300,7 @@ class SyncMessage extends Message {
         this.lamportTimestamp = lamportTimestamp;
         this.bloomFilter = bloomFilter;
         this.content = content;
+        this.repairRequest = repairRequest;
         this.retrievalHint = retrievalHint;
     }
 }
@@ -24286,8 +24320,9 @@ class EphemeralMessage extends Message {
     lamportTimestamp;
     bloomFilter;
     content;
+    repairRequest;
     retrievalHint;
-    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, 
+    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest = [], 
     /**
      * Not encoded, set after it is sent, used to include in follow-up messages
      */
@@ -24295,7 +24330,7 @@ class EphemeralMessage extends Message {
         if (!content || !content.length) {
             throw Error("Ephemeral Message must have content");
         }
-        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, retrievalHint);
+        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest, retrievalHint);
         this.messageId = messageId;
         this.channelId = channelId;
         this.senderId = senderId;
@@ -24303,6 +24338,7 @@ class EphemeralMessage extends Message {
         this.lamportTimestamp = lamportTimestamp;
         this.bloomFilter = bloomFilter;
         this.content = content;
+        this.repairRequest = repairRequest;
         this.retrievalHint = retrievalHint;
     }
 }
@@ -24323,8 +24359,9 @@ class ContentMessage extends Message {
     lamportTimestamp;
     bloomFilter;
     content;
+    repairRequest;
     retrievalHint;
-    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, 
+    constructor(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest = [], 
     /**
      * Not encoded, set after it is sent, used to include in follow-up messages
      */
@@ -24332,7 +24369,7 @@ class ContentMessage extends Message {
         if (!content.length) {
             throw Error("Content Message must have content");
         }
-        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, retrievalHint);
+        super(messageId, channelId, senderId, causalHistory, lamportTimestamp, bloomFilter, content, repairRequest, retrievalHint);
         this.messageId = messageId;
         this.channelId = channelId;
         this.senderId = senderId;
@@ -24340,6 +24377,7 @@ class ContentMessage extends Message {
         this.lamportTimestamp = lamportTimestamp;
         this.bloomFilter = bloomFilter;
         this.content = content;
+        this.repairRequest = repairRequest;
         this.retrievalHint = retrievalHint;
     }
     // `valueOf` is used by comparison operands such as `<`
@@ -24407,10 +24445,477 @@ class MemLocalHistory {
     }
 }
 
+const log$2 = new Logger("sds:repair:buffers");
+/**
+ * Buffer for outgoing repair requests (messages we need)
+ * Maintains a sorted array by T_req for efficient retrieval of eligible entries
+ */
+class OutgoingRepairBuffer {
+    // Sorted array by T_req (ascending - earliest first)
+    items = [];
+    maxSize;
+    constructor(maxSize = 1000) {
+        this.maxSize = maxSize;
+    }
+    /**
+     * Add a missing message to the outgoing repair request buffer
+     * If message already exists, it is not updated (keeps original T_req)
+     * @returns true if the entry was added, false if it already existed
+     */
+    add(entry, tReq) {
+        const messageId = entry.messageId;
+        // Check if already exists - do NOT update T_req per spec
+        if (this.has(messageId)) {
+            log$2.info(`Message ${messageId} already in outgoing buffer, keeping original T_req`);
+            return false;
+        }
+        // Check buffer size limit
+        if (this.items.length >= this.maxSize) {
+            // Evict furthest T_req entry (last in sorted array) to preserve repairs that need to be sent the soonest
+            const evicted = this.items.pop();
+            log$2.warn(`Buffer full, evicted furthest entry ${evicted.entry.messageId} with T_req ${evicted.tReq}`);
+        }
+        // Add new entry and re-sort
+        const newEntry = { entry, tReq, requested: false };
+        const combined = [...this.items, newEntry];
+        // Sort by T_req (ascending)
+        combined.sort((a, b) => a.tReq - b.tReq);
+        this.items = combined;
+        log$2.info(`Added ${messageId} to outgoing buffer with T_req: ${tReq}`);
+        return true;
+    }
+    /**
+     * Remove a message from the buffer (e.g., when received)
+     */
+    remove(messageId) {
+        this.items = this.items.filter((item) => item.entry.messageId !== messageId);
+    }
+    /**
+     * Get eligible repair requests (where T_req <= currentTime)
+     * Returns up to maxRequests entries from the front of the sorted array
+     * Marks returned entries as requested but keeps them in buffer until received
+     */
+    getEligible(currentTime = Date.now(), maxRequests = 3) {
+        const eligible = [];
+        // Iterate from front of sorted array (earliest T_req first)
+        for (const item of this.items) {
+            // Since array is sorted, once we hit an item with tReq > currentTime,
+            // all remaining items also have tReq > currentTime
+            if (item.tReq > currentTime) {
+                break;
+            }
+            // Only return items that haven't been requested yet
+            if (!item.requested && eligible.length < maxRequests) {
+                eligible.push(item.entry);
+                // Mark as requested so we don't request it again
+                item.requested = true;
+                log$2.info(`Repair request for ${item.entry.messageId} is eligible and marked as requested`);
+            }
+            // If we've found enough eligible items, exit early
+            if (eligible.length >= maxRequests) {
+                break;
+            }
+        }
+        return eligible;
+    }
+    /**
+     * Check if a message is in the buffer
+     */
+    has(messageId) {
+        return this.items.some((item) => item.entry.messageId === messageId);
+    }
+    /**
+     * Get the current buffer size
+     */
+    get size() {
+        return this.items.length;
+    }
+    /**
+     * Clear all entries
+     */
+    clear() {
+        this.items = [];
+    }
+    /**
+     * Get all entries (for testing/debugging)
+     */
+    getAll() {
+        return this.items.map((item) => item.entry);
+    }
+    /**
+     * Get items array directly (for testing)
+     */
+    getItems() {
+        return [...this.items];
+    }
+}
+/**
+ * Buffer for incoming repair requests (repairs we need to send)
+ * Maintains a sorted array by T_resp for efficient retrieval of ready entries
+ */
+class IncomingRepairBuffer {
+    // Sorted array by T_resp (ascending - earliest first)
+    items = [];
+    maxSize;
+    constructor(maxSize = 1000) {
+        this.maxSize = maxSize;
+    }
+    /**
+     * Add a repair request that we can fulfill
+     * If message already exists, it is ignored (not updated)
+     * @returns true if the entry was added, false if it already existed
+     */
+    add(entry, tResp) {
+        const messageId = entry.messageId;
+        // Check if already exists - ignore per spec
+        if (this.has(messageId)) {
+            log$2.info(`Message ${messageId} already in incoming buffer, ignoring`);
+            return false;
+        }
+        // Check buffer size limit
+        if (this.items.length >= this.maxSize) {
+            // Evict furthest T_resp entry (last in sorted array)
+            const evicted = this.items.pop();
+            log$2.warn(`Buffer full, evicted furthest entry ${evicted.entry.messageId} with T_resp ${evicted.tResp}`);
+        }
+        // Add new entry and re-sort
+        const newEntry = { entry, tResp };
+        const combined = [...this.items, newEntry];
+        // Sort by T_resp (ascending)
+        combined.sort((a, b) => a.tResp - b.tResp);
+        this.items = combined;
+        log$2.info(`Added ${messageId} to incoming buffer with T_resp: ${tResp}`);
+        return true;
+    }
+    /**
+     * Remove a message from the buffer
+     */
+    remove(messageId) {
+        this.items = this.items.filter((item) => item.entry.messageId !== messageId);
+    }
+    /**
+     * Get repairs ready to be sent (where T_resp <= currentTime)
+     * Removes and returns ready entries
+     */
+    getReady(currentTime) {
+        // Find cutoff point - first item with tResp > currentTime
+        // Since array is sorted, all items before this are ready
+        let cutoff = 0;
+        for (let i = 0; i < this.items.length; i++) {
+            if (this.items[i].tResp > currentTime) {
+                cutoff = i;
+                break;
+            }
+            // If we reach the end, all items are ready
+            cutoff = i + 1;
+        }
+        // Extract ready items and log them
+        const ready = this.items.slice(0, cutoff).map((item) => {
+            log$2.info(`Repair for ${item.entry.messageId} is ready to be sent`);
+            return item.entry;
+        });
+        // Keep only items after cutoff
+        this.items = this.items.slice(cutoff);
+        return ready;
+    }
+    /**
+     * Check if a message is in the buffer
+     */
+    has(messageId) {
+        return this.items.some((item) => item.entry.messageId === messageId);
+    }
+    /**
+     * Get the current buffer size
+     */
+    get size() {
+        return this.items.length;
+    }
+    /**
+     * Clear all entries
+     */
+    clear() {
+        this.items = [];
+    }
+    /**
+     * Get all entries (for testing/debugging)
+     */
+    getAll() {
+        return this.items.map((item) => item.entry);
+    }
+    /**
+     * Get items array directly (for testing)
+     */
+    getItems() {
+        return [...this.items];
+    }
+}
+
+/**
+ * Compute SHA256 hash and convert to integer for modulo operations
+ * Uses first 8 bytes of hash for the integer conversion
+ */
+function hashToInteger(input) {
+    const hashBytes = sha256(new TextEncoder().encode(input));
+    // Use first 8 bytes for a 64-bit integer
+    const view = new DataView(hashBytes.buffer, 0, 8);
+    return view.getBigUint64(0, false); // big-endian
+}
+/**
+ * Compute combined hash for (participantId, messageId) and convert to integer
+ * This is used for T_req calculations and response group membership
+ */
+function combinedHash(participantId, messageId) {
+    const combined = `${participantId}${messageId}`;
+    return hashToInteger(combined);
+}
+/**
+ * Convert ParticipantId to numeric representation for XOR operations
+ * TODO: Not per spec, further review needed
+ * The spec assumes participant IDs support XOR natively, but we're using
+ * SHA256 hash to ensure consistent numeric representation for string IDs
+ */
+function participantIdToNumeric(participantId) {
+    return hashToInteger(participantId);
+}
+/**
+ * Calculate XOR distance between two participant IDs
+ * Used for T_resp calculations where distance affects response timing
+ */
+function calculateXorDistance(participantId1, participantId2) {
+    const numeric1 = participantIdToNumeric(participantId1);
+    const numeric2 = participantIdToNumeric(participantId2);
+    return numeric1 ^ numeric2;
+}
+/**
+ * Helper to convert bigint to number for timing calculations
+ * Ensures the result fits in JavaScript's number range
+ */
+function bigintToNumber(value) {
+    // For timing calculations, we modulo by MAX_SAFE_INTEGER to ensure it fits
+    const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+    return Number(value % maxSafe);
+}
+/**
+ * Calculate hash for a single string (used for message_id in T_resp)
+ */
+function hashString(input) {
+    return hashToInteger(input);
+}
+
+const log$1 = new Logger("sds:repair:manager");
+/**
+ * Per SDS-R spec: One response group per 128 participants
+ */
+const PARTICIPANTS_PER_RESPONSE_GROUP = 128;
+/**
+ * Default configuration values based on spec recommendations
+ */
+const DEFAULT_REPAIR_CONFIG = {
+    tMin: 30000, // 30 seconds
+    tMax: 120000, // 120 seconds
+    numResponseGroups: 1, // Recommendation is 1 group per PARTICIPANTS_PER_RESPONSE_GROUP participants
+    bufferSize: 1000
+};
+/**
+ * Manager for SDS-R repair protocol
+ * Handles repair request/response timing and coordination
+ */
+class RepairManager {
+    participantId;
+    config;
+    outgoingBuffer;
+    incomingBuffer;
+    eventEmitter;
+    constructor(participantId, config = {}, eventEmitter) {
+        this.participantId = participantId;
+        this.config = { ...DEFAULT_REPAIR_CONFIG, ...config };
+        this.eventEmitter = eventEmitter;
+        this.outgoingBuffer = new OutgoingRepairBuffer(this.config.bufferSize);
+        this.incomingBuffer = new IncomingRepairBuffer(this.config.bufferSize);
+        log$1.info(`RepairManager initialized for participant ${participantId}`);
+    }
+    /**
+     * Calculate T_req - when to request repair for a missing message
+     * Per spec: T_req = current_time + hash(participant_id, message_id) % (T_max - T_min) + T_min
+     */
+    calculateTReq(messageId, currentTime = Date.now()) {
+        const hash = combinedHash(this.participantId, messageId);
+        const range = BigInt(this.config.tMax - this.config.tMin);
+        const offset = bigintToNumber(hash % range) + this.config.tMin;
+        return currentTime + offset;
+    }
+    /**
+     * Calculate T_resp - when to respond with a repair
+     * Per spec: T_resp = current_time + (distance * hash(message_id)) % T_max
+     * where distance = participant_id XOR sender_id
+     */
+    calculateTResp(senderId, messageId, currentTime = Date.now()) {
+        const distance = calculateXorDistance(this.participantId, senderId);
+        const messageHash = hashString(messageId);
+        const product = distance * messageHash;
+        const offset = bigintToNumber(product % BigInt(this.config.tMax));
+        return currentTime + offset;
+    }
+    /**
+     * Determine if this participant is in the response group for a message
+     * Per spec: (hash(participant_id, message_id) % num_response_groups) ==
+     *           (hash(sender_id, message_id) % num_response_groups)
+     */
+    isInResponseGroup(senderId, messageId) {
+        if (!senderId) {
+            // Cannot determine response group without sender_id
+            return false;
+        }
+        const numGroups = BigInt(this.config.numResponseGroups);
+        if (numGroups <= BigInt(1)) {
+            // Single group, everyone is in it
+            return true;
+        }
+        const participantGroup = combinedHash(this.participantId, messageId) % numGroups;
+        const senderGroup = combinedHash(senderId, messageId) % numGroups;
+        return participantGroup === senderGroup;
+    }
+    /**
+     * Handle missing dependencies by adding them to outgoing repair buffer
+     * Called when causal dependencies are detected as missing
+     */
+    markDependenciesMissing(missingEntries, currentTime = Date.now()) {
+        for (const entry of missingEntries) {
+            // Calculate when to request this repair
+            const tReq = this.calculateTReq(entry.messageId, currentTime);
+            // Add to outgoing buffer - only log and emit event if actually added
+            const wasAdded = this.outgoingBuffer.add(entry, tReq);
+            if (wasAdded) {
+                log$1.info(`Added missing dependency ${entry.messageId} to repair buffer with T_req=${tReq}`);
+                // Emit event
+                this.eventEmitter?.("RepairRequestQueued", {
+                    messageId: entry.messageId,
+                    tReq
+                });
+            }
+        }
+    }
+    /**
+     * Handle receipt of a message - remove from repair buffers
+     * Called when a message is successfully received
+     */
+    markMessageReceived(messageId) {
+        // Remove from both buffers as we no longer need to request or respond
+        const wasInOutgoing = this.outgoingBuffer.has(messageId);
+        const wasInIncoming = this.incomingBuffer.has(messageId);
+        if (wasInOutgoing) {
+            this.outgoingBuffer.remove(messageId);
+            log$1.info(`Removed ${messageId} from outgoing repair buffer after receipt`);
+        }
+        if (wasInIncoming) {
+            this.incomingBuffer.remove(messageId);
+            log$1.info(`Removed ${messageId} from incoming repair buffer after receipt`);
+        }
+    }
+    /**
+     * Get repair requests that are eligible to be sent
+     * Returns up to maxRequests entries where T_req <= currentTime
+     */
+    getRepairRequests(maxRequests = 3, currentTime = Date.now()) {
+        return this.outgoingBuffer.getEligible(currentTime, maxRequests);
+    }
+    /**
+     * Process incoming repair requests from other participants
+     * Adds to incoming buffer if we can fulfill and are in response group
+     */
+    processIncomingRepairRequests(requests, localHistory, currentTime = Date.now()) {
+        for (const request of requests) {
+            // Remove from our own outgoing buffer (someone else is requesting it)
+            this.outgoingBuffer.remove(request.messageId);
+            // Check if we have this message
+            const message = localHistory.find((m) => m.messageId === request.messageId);
+            if (!message) {
+                log$1.info(`Cannot fulfill repair for ${request.messageId} - not in local history`);
+                continue;
+            }
+            // Check if we're in the response group
+            if (!request.senderId) {
+                log$1.warn(`Cannot determine response group for ${request.messageId} - missing sender_id`);
+                continue;
+            }
+            if (!this.isInResponseGroup(request.senderId, request.messageId)) {
+                log$1.info(`Not in response group for ${request.messageId}`);
+                continue;
+            }
+            // Calculate when to respond
+            const tResp = this.calculateTResp(request.senderId, request.messageId, currentTime);
+            // Add to incoming buffer - only log and emit event if actually added
+            const wasAdded = this.incomingBuffer.add(request, tResp);
+            if (wasAdded) {
+                log$1.info(`Will respond to repair request for ${request.messageId} at T_resp=${tResp}`);
+                // Emit event
+                this.eventEmitter?.("RepairResponseQueued", {
+                    messageId: request.messageId,
+                    tResp
+                });
+            }
+        }
+    }
+    /**
+     * Sweep outgoing buffer for repairs that should be requested
+     * Returns entries where T_req <= currentTime
+     */
+    sweepOutgoingBuffer(maxRequests = 3, currentTime = Date.now()) {
+        return this.getRepairRequests(maxRequests, currentTime);
+    }
+    /**
+     * Sweep incoming buffer for repairs ready to be sent
+     * Returns messages that should be rebroadcast
+     */
+    sweepIncomingBuffer(localHistory, currentTime = Date.now()) {
+        const ready = this.incomingBuffer.getReady(currentTime);
+        const messages = [];
+        for (const entry of ready) {
+            const message = localHistory.find((m) => m.messageId === entry.messageId);
+            if (message) {
+                messages.push(message);
+                log$1.info(`Sending repair for ${entry.messageId}`);
+            }
+            else {
+                log$1.warn(`Message ${entry.messageId} no longer in local history`);
+            }
+        }
+        return messages;
+    }
+    /**
+     * Clear all buffers
+     */
+    clear() {
+        this.outgoingBuffer.clear();
+        this.incomingBuffer.clear();
+    }
+    /**
+     * Update number of response groups (e.g., when participants change)
+     */
+    updateResponseGroups(numParticipants) {
+        if (numParticipants < 0 ||
+            !Number.isFinite(numParticipants) ||
+            !Number.isInteger(numParticipants)) {
+            throw new Error(`Invalid numParticipants: ${numParticipants}. Must be a positive integer.`);
+        }
+        if (numParticipants > Number.MAX_SAFE_INTEGER) {
+            log$1.warn(`numParticipants ${numParticipants} exceeds MAX_SAFE_INTEGER, using MAX_SAFE_INTEGER`);
+            numParticipants = Number.MAX_SAFE_INTEGER;
+        }
+        // Per spec: num_response_groups = max(1, num_participants / PARTICIPANTS_PER_RESPONSE_GROUP)
+        this.config.numResponseGroups = Math.max(1, Math.floor(numParticipants / PARTICIPANTS_PER_RESPONSE_GROUP));
+        log$1.info(`Updated response groups to ${this.config.numResponseGroups} for ${numParticipants} participants`);
+    }
+}
+
 const DEFAULT_BLOOM_FILTER_OPTIONS = {
     capacity: 10000,
     errorRate: 0.001
 };
+/**
+ * Maximum number of repair requests to include in a single message
+ */
+const MAX_REPAIR_REQUESTS_PER_MESSAGE = 3;
 const DEFAULT_CAUSAL_HISTORY_SIZE = 200;
 const DEFAULT_POSSIBLE_ACKS_THRESHOLD = 2;
 const log = new Logger("sds:message-channel");
@@ -24427,6 +24932,7 @@ class MessageChannel extends TypedEventEmitter {
     causalHistorySize;
     possibleAcksThreshold;
     timeoutForLostMessagesMs;
+    repairManager;
     tasks = [];
     handlers = {
         [Command.Send]: async (params) => {
@@ -24457,6 +24963,12 @@ class MessageChannel extends TypedEventEmitter {
             options.possibleAcksThreshold ?? DEFAULT_POSSIBLE_ACKS_THRESHOLD;
         this.timeReceived = new Map();
         this.timeoutForLostMessagesMs = options.timeoutForLostMessagesMs;
+        // Only construct RepairManager if repair is enabled (default: true)
+        if (options.enableRepair ?? true) {
+            this.repairManager = new RepairManager(senderId, options.repairConfig, (event, detail) => {
+                this.safeSendEvent(event, { detail });
+            });
+        }
     }
     static getMessageId(payload) {
         return bytesToHex(sha256(payload));
@@ -24589,7 +25101,7 @@ class MessageChannel extends TypedEventEmitter {
     sweepIncomingBuffer() {
         const { buffer, missing } = this.incomingBuffer.reduce(({ buffer, missing }, message) => {
             log.info(this.senderId, "sweeping incoming buffer", message.messageId, message.causalHistory.map((ch) => ch.messageId));
-            const missingDependencies = message.causalHistory.filter((messageHistoryEntry) => !this.localHistory.some(({ messageId }) => messageId === messageHistoryEntry.messageId));
+            const missingDependencies = message.causalHistory.filter((messageHistoryEntry) => !this.isMessageAvailable(messageHistoryEntry.messageId));
             if (missingDependencies.length === 0) {
                 if (isContentMessage(message) && this.deliverMessage(message)) {
                     this.safeSendEvent(MessageChannelEvent.InMessageDelivered, {
@@ -24645,6 +25157,34 @@ class MessageChannel extends TypedEventEmitter {
             possiblyAcknowledged: new Array()
         });
     }
+    /**
+     * Sweep repair incoming buffer and rebroadcast messages ready for repair.
+     * Per SDS-R spec: periodically check for repair responses that are due.
+     *
+     * @param callback - callback to rebroadcast the message
+     * @returns Promise that resolves when all ready repairs have been sent
+     */
+    async sweepRepairIncomingBuffer(callback) {
+        const repairsToSend = this.repairManager?.sweepIncomingBuffer(this.localHistory) ?? [];
+        if (callback) {
+            for (const message of repairsToSend) {
+                try {
+                    await callback(message);
+                    log.info(this.senderId, "repair message rebroadcast", message.messageId);
+                    // Emit RepairResponseSent event
+                    this.safeSendEvent(MessageChannelEvent.RepairResponseSent, {
+                        detail: {
+                            messageId: message.messageId
+                        }
+                    });
+                }
+                catch (error) {
+                    log.error("Failed to rebroadcast repair message:", error);
+                }
+            }
+        }
+        return repairsToSend;
+    }
     /**
      * Send a sync message to the SDS channel.
      *
@@ -24657,15 +25197,19 @@ class MessageChannel extends TypedEventEmitter {
      */
     async pushOutgoingSyncMessage(callback) {
         this.lamportTimestamp = lamportTimestampIncrement(this.lamportTimestamp);
+        // Get repair requests to include in sync message (SDS-R)
+        const repairRequests = this.repairManager?.getRepairRequests(MAX_REPAIR_REQUESTS_PER_MESSAGE) ??
+            [];
         const message = new SyncMessage(
         // does not need to be secure randomness
         `sync-${Math.random().toString(36).substring(2)}`, this.channelId, this.senderId, this.localHistory
             .slice(-this.causalHistorySize)
-            .map(({ messageId, retrievalHint }) => {
-            return { messageId, retrievalHint };
-        }), this.lamportTimestamp, this.filter.toBytes(), undefined);
-        if (!message.causalHistory || message.causalHistory.length === 0) {
-            log.info(this.senderId, "no causal history in sync message, aborting sending");
+            .map(({ messageId, retrievalHint, senderId }) => {
+            return { messageId, retrievalHint, senderId };
+        }), this.lamportTimestamp, this.filter.toBytes(), undefined, repairRequests);
+        if ((!message.causalHistory || message.causalHistory.length === 0) &&
+            repairRequests.length === 0) {
+            log.info(this.senderId, "no causal history and no repair requests in sync message, aborting sending");
             return false;
         }
         if (callback) {
@@ -24675,6 +25219,15 @@ class MessageChannel extends TypedEventEmitter {
                 this.safeSendEvent(MessageChannelEvent.OutSyncSent, {
                     detail: message
                 });
+                // Emit RepairRequestSent event if repair requests were included
+                if (repairRequests.length > 0) {
+                    this.safeSendEvent(MessageChannelEvent.RepairRequestSent, {
+                        detail: {
+                            messageIds: repairRequests.map((r) => r.messageId),
+                            carrierMessageId: message.messageId
+                        }
+                    });
+                }
                 return true;
             }
             catch (error) {
@@ -24722,15 +25275,30 @@ class MessageChannel extends TypedEventEmitter {
                 detail: message
             });
         }
+        // SDS-R: Handle received message in repair manager
+        this.repairManager?.markMessageReceived(message.messageId);
+        // SDS-R: Process incoming repair requests
+        if (message.repairRequest && message.repairRequest.length > 0) {
+            // Emit RepairRequestReceived event
+            this.safeSendEvent(MessageChannelEvent.RepairRequestReceived, {
+                detail: {
+                    messageIds: message.repairRequest.map((r) => r.messageId),
+                    fromSenderId: message.senderId
+                }
+            });
+            this.repairManager?.processIncomingRepairRequests(message.repairRequest, this.localHistory);
+        }
         this.reviewAckStatus(message);
         if (isContentMessage(message)) {
             this.filter.insert(message.messageId);
         }
-        const missingDependencies = message.causalHistory.filter((messageHistoryEntry) => !this.localHistory.some(({ messageId }) => messageId === messageHistoryEntry.messageId));
+        const missingDependencies = message.causalHistory.filter((messageHistoryEntry) => !this.isMessageAvailable(messageHistoryEntry.messageId));
         if (missingDependencies.length > 0) {
             this.incomingBuffer.push(message);
             this.timeReceived.set(message.messageId, Date.now());
             log.info(this.senderId, "new incoming message", message.messageId, "is missing dependencies", missingDependencies.map((ch) => ch.messageId));
+            // SDS-R: Track missing dependencies in repair manager
+            this.repairManager?.markDependenciesMissing(missingDependencies);
             this.safeSendEvent(MessageChannelEvent.InMessageMissing, {
                 detail: Array.from(missingDependencies)
             });
@@ -24776,11 +25344,13 @@ class MessageChannel extends TypedEventEmitter {
         // It's a new message
         if (!message) {
             log.info(this.senderId, "sending new message", messageId);
+            // Get repair requests to include in the message (SDS-R)
+            const repairRequests = this.repairManager?.getRepairRequests(MAX_REPAIR_REQUESTS_PER_MESSAGE) ?? [];
             message = new ContentMessage(messageId, this.channelId, this.senderId, this.localHistory
                 .slice(-this.causalHistorySize)
-                .map(({ messageId, retrievalHint }) => {
-                return { messageId, retrievalHint };
-            }), this.lamportTimestamp, this.filter.toBytes(), payload);
+                .map(({ messageId, retrievalHint, senderId }) => {
+                return { messageId, retrievalHint, senderId };
+            }), this.lamportTimestamp, this.filter.toBytes(), payload, repairRequests);
             this.outgoingBuffer.push(message);
         }
         else {
@@ -24819,6 +25389,25 @@ class MessageChannel extends TypedEventEmitter {
             }
         }
     }
+    /**
+     * Check if a message is available (either in localHistory or incomingBuffer)
+     * This prevents treating messages as "missing" when they've already been received
+     * but are waiting in the incoming buffer for their dependencies.
+     *
+     * @param messageId - The ID of the message to check
+     * @private
+     */
+    isMessageAvailable(messageId) {
+        // Check if in local history
+        if (this.localHistory.some((m) => m.messageId === messageId)) {
+            return true;
+        }
+        // Check if in incoming buffer (already received, waiting for dependencies)
+        if (this.incomingBuffer.some((m) => m.messageId === messageId)) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Return true if the message was "delivered"
      *