fix: fix build errors, simplify parallel operation

Author: jm-clius

packages/sdk/src/reliable_channel/reliable_channel.ts

@@ -42,7 +42,6 @@ const DEFAULT_MAX_RETRY_ATTEMPTS = 10;
 const DEFAULT_SWEEP_IN_BUF_INTERVAL_MS = 5 * 1000;
 const DEFAULT_SWEEP_REPAIR_INTERVAL_MS = 10 * 1000; // 10 seconds
 const DEFAULT_PROCESS_TASK_MIN_ELAPSE_MS = 1000;
-const DEFAULT_SDSR_FALLBACK_TIMEOUT_MS = 120 * 1000; // 2 minutes
 
 const IRRECOVERABLE_SENDING_ERRORS: LightPushError[] = [
   LightPushError.ENCODE_FAILED,
@@ -118,22 +117,14 @@ export type ReliableChannelOptions = MessageChannelOptions & {
 
   /**
    * Strategy for retrieving missing messages.
-   * - 'both': Use SDS-R peer repair and Store queries (default)
+   * - 'both': Use SDS-R peer repair and Store queries in parallel (default)
    * - 'sds-r-only': Only use SDS-R peer repair
    * - 'store-only': Only use Store queries (legacy behavior)
    * - 'none': No automatic retrieval
    *
    * @default 'both'
    */
   retrievalStrategy?: "both" | "sds-r-only" | "store-only" | "none";
-
-  /**
-   * How long to wait for SDS-R repair before falling back to Store.
-   * Only applies when retrievalStrategy is 'both'.
-   *
-   * @default 120,000 (2 minutes - matches SDS-R T_max)
-   */
-  sdsrFallbackTimeoutMs?: number;
 };
 
 /**
@@ -179,11 +170,6 @@ export class ReliableChannel<
     | "sds-r-only"
     | "store-only"
     | "none";
-  private readonly sdsrFallbackTimeoutMs: number;
-  private readonly missingMessageTimeouts: Map<
-    string,
-    ReturnType<typeof setTimeout>
-  >;
   private _started: boolean;
 
   private constructor(
@@ -249,9 +235,6 @@ export class ReliableChannel<
       options?.processTaskMinElapseMs ?? DEFAULT_PROCESS_TASK_MIN_ELAPSE_MS;
 
     this.retrievalStrategy = options?.retrievalStrategy ?? "both";
-    this.sdsrFallbackTimeoutMs =
-      options?.sdsrFallbackTimeoutMs ?? DEFAULT_SDSR_FALLBACK_TIMEOUT_MS;
-    this.missingMessageTimeouts = new Map();
 
     // Only enable Store retrieval based on strategy
     if (this._retrieve && this.shouldUseStore()) {
@@ -458,13 +441,7 @@ export class ReliableChannel<
     // missing messages or the status of previous outgoing messages
     this.messageChannel.pushIncomingMessage(sdsMessage, retrievalHint);
 
-    // Cancel Store fallback timeout if message was retrieved
-    const timeout = this.missingMessageTimeouts.get(sdsMessage.messageId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.missingMessageTimeouts.delete(sdsMessage.messageId);
-    }
-
+    // Remove from Store retriever if message was retrieved
     this.missingMessageRetriever?.removeMissingMessage(sdsMessage.messageId);
 
     if (sdsMessage.content && sdsMessage.content.length > 0) {
@@ -544,7 +521,6 @@ export class ReliableChannel<
     this.stopSync();
     this.stopSweepIncomingBufferLoop();
     this.stopRepairSweepLoop();
-    this.clearMissingMessageTimeouts();
     this.missingMessageRetriever?.stop();
     this.queryOnConnect?.stop();
     // TODO unsubscribe
@@ -587,13 +563,6 @@ export class ReliableChannel<
     if (this.sweepRepairInterval) clearInterval(this.sweepRepairInterval);
   }
 
-  private clearMissingMessageTimeouts(): void {
-    for (const timeout of this.missingMessageTimeouts.values()) {
-      clearTimeout(timeout);
-    }
-    this.missingMessageTimeouts.clear();
-  }
-
   private shouldUseStore(): boolean {
     return (
       this.retrievalStrategy === "both" ||
@@ -773,35 +742,28 @@ export class ReliableChannel<
       MessageChannelEvent.InMessageMissing,
       (event) => {
         for (const { messageId, retrievalHint } of event.detail) {
-          // Coordinated retrieval strategy
+          // Parallel retrieval strategy
           if (this.retrievalStrategy === "both") {
-            // SDS-R will attempt first, schedule Store fallback
-            // Note: missingMessageRetriever only exists if Store protocol is available
+            // Both SDS-R and Store work in parallel
+            // SDS-R automatically handles repair via RepairManager
+            // Store retrieval starts immediately
             if (retrievalHint && this.missingMessageRetriever) {
-              const timeout = setTimeout(() => {
-                // Still missing after SDS-R timeout, try Store
-                log.info(
-                  `Message ${messageId} not retrieved via SDS-R, falling back to Store`
-                );
-                this.missingMessageRetriever?.addMissingMessage(
-                  messageId,
-                  retrievalHint
-                );
-                this.missingMessageTimeouts.delete(messageId);
-              }, this.sdsrFallbackTimeoutMs);
-
-              this.missingMessageTimeouts.set(messageId, timeout);
+              this.missingMessageRetriever.addMissingMessage(
+                messageId,
+                retrievalHint
+              );
             }
           } else if (this.retrievalStrategy === "store-only") {
-            // Immediate Store retrieval
+            // Immediate Store retrieval only
             if (retrievalHint && this.missingMessageRetriever) {
               this.missingMessageRetriever.addMissingMessage(
                 messageId,
                 retrievalHint
               );
             }
           }
-          // For 'sds-r-only' and 'none', SDS-R handles it or nothing happens
+          // For 'sds-r-only', only SDS-R repair manager operates
+          // For 'none', nothing happens
         }
       }
     );

packages/sds/src/message_channel/events.ts

@@ -12,10 +12,8 @@ export enum MessageChannelEvent {
   InMessageLost = "sds:in:message-irretrievably-lost",
   ErrorTask = "sds:error-task",
   // SDS-R Repair Events
-  RepairRequestQueued = "sds:repair:request-queued",
   RepairRequestSent = "sds:repair:request-sent",
   RepairRequestReceived = "sds:repair:request-received",
-  RepairResponseQueued = "sds:repair:response-queued",
   RepairResponseSent = "sds:repair:response-sent"
 }
 
@@ -33,10 +31,6 @@ export type MessageChannelEvents = {
   [MessageChannelEvent.OutSyncSent]: CustomEvent<Message>;
   [MessageChannelEvent.InSyncReceived]: CustomEvent<Message>;
   [MessageChannelEvent.ErrorTask]: CustomEvent<unknown>;
-  [MessageChannelEvent.RepairRequestQueued]: CustomEvent<{
-    messageId: MessageId;
-    tReq: number;
-  }>;
   [MessageChannelEvent.RepairRequestSent]: CustomEvent<{
     messageIds: MessageId[];
     carrierMessageId: MessageId;
@@ -45,10 +39,6 @@ export type MessageChannelEvents = {
     messageIds: MessageId[];
     fromSenderId?: ParticipantId;
   }>;
-  [MessageChannelEvent.RepairResponseQueued]: CustomEvent<{
-    messageId: MessageId;
-    tResp: number;
-  }>;
   [MessageChannelEvent.RepairResponseSent]: CustomEvent<{
     messageId: MessageId;
   }>;

packages/sds/src/message_channel/message_channel.ts

@@ -128,13 +128,7 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
 
     // Only construct RepairManager if repair is enabled (default: true)
     if (options.enableRepair ?? true) {
-      this.repairManager = new RepairManager(
-        senderId,
-        options.repairConfig,
-        (event: string, detail: unknown) => {
-          this.safeSendEvent(event as MessageChannelEvent, { detail });
-        }
-      );
+      this.repairManager = new RepairManager(senderId, options.repairConfig);
     }
   }
 
@@ -147,26 +141,14 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
    * Useful for adaptive sync intervals - increase frequency when repairs pending.
    */
   public hasPendingRepairRequests(currentTime = Date.now()): boolean {
-    if (!this.repairManager.isEnabled) {
+    if (!this.repairManager) {
       return false;
     }
 
     const nextRequestTime = this.repairManager.getNextRequestTime();
     return nextRequestTime !== undefined && nextRequestTime <= currentTime;
   }
 
-  /**
-   * Get repair statistics for monitoring/debugging.
-   */
-  public getRepairStats(): {
-    pendingRequests: number;
-    pendingResponses: number;
-    nextRequestTime?: number;
-    nextResponseTime?: number;
-  } {
-    return this.repairManager.getStats();
-  }
-
   /**
    * Processes all queued tasks sequentially to ensure proper message ordering.
    *

packages/sds/src/message_channel/repair/repair.ts

@@ -20,11 +20,6 @@ const log = new Logger("sds:repair:manager");
  */
 const PARTICIPANTS_PER_RESPONSE_GROUP = 128;
 
-/**
- * Event emitter callback for repair events
- */
-export type RepairEventEmitter = (event: string, detail: unknown) => void;
-
 /**
  * Configuration for SDS-R repair protocol
  */
@@ -58,16 +53,10 @@ export class RepairManager {
   private readonly config: Required<RepairConfig>;
   private readonly outgoingBuffer: OutgoingRepairBuffer;
   private readonly incomingBuffer: IncomingRepairBuffer;
-  private readonly eventEmitter?: RepairEventEmitter;
 
-  public constructor(
-    participantId: ParticipantId,
-    config: RepairConfig = {},
-    eventEmitter?: RepairEventEmitter
-  ) {
+  public constructor(participantId: ParticipantId, config: RepairConfig = {}) {
     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);
@@ -142,19 +131,13 @@ export class RepairManager {
       // 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
+      // Add to outgoing buffer - only log if actually added
       const wasAdded = this.outgoingBuffer.add(entry, tReq);
 
       if (wasAdded) {
         log.info(
           `Added missing dependency ${entry.messageId} to repair buffer with T_req=${tReq}`
         );
-
-        // Emit event
-        this.eventEmitter?.("RepairRequestQueued", {
-          messageId: entry.messageId,
-          tReq
-        });
       }
     }
   }
@@ -238,19 +221,13 @@ export class RepairManager {
         currentTime
       );
 
-      // Add to incoming buffer - only log and emit event if actually added
+      // Add to incoming buffer - only log if actually added
       const wasAdded = this.incomingBuffer.add(request, tResp);
 
       if (wasAdded) {
         log.info(
           `Will respond to repair request for ${request.messageId} at T_resp=${tResp}`
         );
-
-        // Emit event
-        this.eventEmitter?.("RepairResponseQueued", {
-          messageId: request.messageId,
-          tResp
-        });
       }
     }
   }