@livedigital/client 3.23.1 → 3.24.1

package/dist/types/channelStateSyncronizer.d.ts

@@ -2,10 +2,16 @@ export interface ChannelStateProducer {
     id: string;
     paused: boolean;
 }
+export interface ChannelStateConsumer {
+    id: string;
+    paused: boolean;
+    producerId: string;
+}
 export interface ChannelStatePeer {
     id: string;
     appDataHash: string;
     producers: ChannelStateProducer[];
+    consumers?: ChannelStateConsumer[];
 }
 export interface ChannelState {
     peers: ChannelStatePeer[];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.23.1",
+  "version": "3.24.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/ChannelStateSynchronizer.ts

@@ -9,8 +9,10 @@ import {
 import Peer from './Peer';
 import { debounce, deepEqualObject } from '../helpers/common';
 import Engine from './index';
+import { InconsistenceType } from './handlers/ChannelStateSyncEventHandler/types';
 
 const RESTORE_STATE_DEBOUNCE_TIME_MS = 3000;
+const SYNC_CONSUMERS_DEBOUNCE_TIME_MS = 1000;
 
 export interface ChannelStateSynchronizerParams {
   engine: Engine;
@@ -24,7 +26,9 @@ class ChannelStateSynchronizer {
 
   readonly #logger: Logger;
 
-  readonly debouncedRestoreState: <U>(this: U, ...args: Parameters<() => Promise<void>>) => void;
+  readonly debouncedRestoreState: <U>(this: U, ...args: Parameters<() => Promise<void>>) => void | Promise<void>;
+
+  readonly debouncedSyncPeerState: <U>(this: U, type: InconsistenceType) => void | Promise<void>;
 
   constructor({
     engine, onLogMessage, logLevel, sendAnalytics,
@@ -38,12 +42,49 @@ class ChannelStateSynchronizer {
     });
     this.watchNetworkState();
     this.debouncedRestoreState = debounce(this.restoreState.bind(this), RESTORE_STATE_DEBOUNCE_TIME_MS);
+    this.debouncedSyncPeerState = debounce(this.syncPeerState.bind(this), SYNC_CONSUMERS_DEBOUNCE_TIME_MS);
   }
 
   private watchNetworkState(): void {
     this.#engine.clientEventEmitter.on(CLIENT_EVENTS.connectionRestored, async () => {
       await this.debouncedRestoreState();
     });
+
+    this.#engine.clientEventEmitter.on(CLIENT_EVENTS.channelStateInconsistent, async ({ type }) => {
+      if ([InconsistenceType.IncorrectConsumerState, InconsistenceType.MissingConsumers].includes(type)) {
+        await this.debouncedSyncPeerState(type);
+      }
+    });
+  }
+
+  private async syncPeerState(type: InconsistenceType): Promise<void> {
+    try {
+      if (!this.#engine.isSocketConnectionActive) {
+        this.#logger.info('Connection inactive, skipping re-syncing local peers state', {
+          case: 'restoreLocalState',
+          type,
+        });
+        return;
+      }
+
+      this.#engine.eventsQueue.pause();
+
+      this.#logger.info('Re-syncing local peers state', {
+        case: 'restoreLocalState',
+        type,
+      });
+
+      const { peers: clusterPeers } = await this.#engine.network.getChannelPeers('host');
+      this.restoreLocalPeersState(clusterPeers);
+    } catch (error) {
+      this.#logger.info('Failed to re-sync local peers state', {
+        case: 'restoreLocalState',
+        type,
+        error: serializeError(error),
+      });
+    } finally {
+      this.#engine.eventsQueue.resume();
+    }
   }
 
   private async restoreState(): Promise<void> {

package/src/engine/EventsQueue.ts

@@ -0,0 +1,114 @@
+/**
+  * Single point of events handling
+  * All events are redirected to that queue
+  * And later flushed to subscribed events handlers
+  *
+  * Has ability to postpone events processing
+  *
+  * When subscribing to event from all places: sockets, data channels
+  * All events should be sent to that queue
+  * And handlers should subscribe to events of that queue
+  */
+import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
+import { Socket } from 'socket.io-client';
+
+interface EventArgs {
+  event: string
+  args: any[]
+}
+
+export default class EventsQueue {
+  readonly #queue: EventArgs[] = [];
+
+  readonly #listeners: Map<string, ((...args: any[]) => void | Promise<void>)[]> = new Map();
+
+  readonly #connections: Set<Socket> = new Set();
+
+  #paused: boolean = false;
+
+  subscribeToSocket(emmiter: Socket) {
+    if (this.#connections.has(emmiter)) {
+      return;
+    }
+
+    emmiter.onAny((event: string, ...args: any[]) => {
+      this.push(event, args);
+    });
+
+    this.#connections.add(emmiter);
+  }
+
+  subscribeToDataChannel(dataChannel: DataConsumer) {
+    dataChannel.on('message', (...args: any[]) => {
+      this.push('message', args);
+    });
+  }
+
+  on(event: string, handler: (...args: any[]) => void | Promise<void>) {
+    if (this.#listeners.has(event)) {
+      this.#listeners.get(event)?.push(handler);
+      return;
+    }
+
+    this.#listeners.set(event, [handler]);
+  }
+
+  removeListener(event: string) {
+    this.#listeners.delete(event);
+  }
+
+  removeAllListeners(events: string[], emitter?: Socket) {
+    if (emitter && this.#connections.has(emitter)) {
+      emitter.offAny();
+      this.#connections.delete(emitter);
+    }
+
+    events.forEach((event) => {
+      this.#listeners.delete(event);
+    });
+  }
+
+  private push(event: string, args: any[]) {
+    this.#queue.push({
+      event,
+      args,
+    });
+
+    this.process();
+  }
+
+  /*
+   * Process all events accumulated in the this.#queue
+   * Should happen immediately if queue is not paused
+   *
+   * Read existing listeners/handlers and emit events to them
+   */
+  private process() {
+    if (this.#paused) {
+      return;
+    }
+
+    while (this.#queue.length > 0) {
+      const eventArgs = this.#queue.shift()!;
+
+      this.emit(eventArgs.event, eventArgs.args);
+    }
+  }
+
+  private emit(event: string, args: any[]) {
+    const handlers = this.#listeners.get(event) || [];
+
+    handlers.forEach((handler) => {
+      handler(...args);
+    });
+  }
+
+  pause() {
+    this.#paused = true;
+  }
+
+  resume() {
+    this.#paused = false;
+    this.process();
+  }
+}

package/src/engine/Peer.ts

@@ -324,6 +324,14 @@ class Peer {
     return Array.from(this.producers.values());
   }
 
+  getConsumersState(): { id: string, producerId: string, paused: boolean }[] {
+    return this.getAllConsumers().map((consumer) => ({
+      id: consumer.id,
+      paused: consumer.paused,
+      producerId: consumer.producerId,
+    }));
+  }
+
   private handleNewProducer(producerData: ProducerData): void {
     if (this.producers.get(producerData.id)) {
       return;

package/src/engine/analyticsApiClient/helper.ts

@@ -3,7 +3,7 @@ import crypto from 'crypto';
 
 let skipGettingStorage = false;
 let fallbackClientUid: string | undefined;
-const CLIENT_UID_STORAGE_KEY = 'clientUniqueId';
+const CLIENT_UID_STORAGE_KEY = 'sdk_clientUniqueId';
 
 const getLocalStorage = (): Storage | null => {
   try {
@@ -61,7 +61,7 @@ export const generateAndSetClientUniqueId = (): string => {
     return existingClientUniqueId;
   }
 
-  const clientUniqueId = crypto.randomBytes(20).toString('hex');
+  const clientUniqueId = crypto.randomBytes(12).toString('hex');
   fallbackClientUid = clientUniqueId;
   setLocalStorageItem(CLIENT_UID_STORAGE_KEY, clientUniqueId);
 

package/src/engine/handlers/ChannelEventHandler.ts

@@ -53,79 +53,83 @@ class ChannelEventHandler {
       throw new Error('Socket connection not initialized');
     }
 
-    connection.on(CHANNEL_EVENTS.channelEvent, (event: ChannelEvent) => {
+    this.engine.eventsQueue.subscribeToSocket(connection);
+
+    this.engine.eventsQueue.on(CHANNEL_EVENTS.channelEvent, (event: ChannelEvent) => {
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelEvent, event);
       this.logger.debug('New channel event', { event });
     });
 
-    connection.on(CHANNEL_EVENTS.channelJoin, (peerData: PeerResponse) => {
+    this.engine.eventsQueue.on(CHANNEL_EVENTS.channelJoin, (peerData: PeerResponse) => {
       const peer = this.engine.setPeer(peerData);
       this.logger.debug('Peer joined to the channel', { peer: logResponse(peer) });
     });
 
-    connection.on(CHANNEL_EVENTS.channelLeave, (peerId: string) => {
+    this.engine.eventsQueue.on(CHANNEL_EVENTS.channelLeave, (peerId: string) => {
       this.engine.removePeer(peerId);
       this.logger.debug('Peer left the channel', { peerId });
     });
 
-    connection.on(CHANNEL_EVENTS.activityConfirmationRequired, (event: ActivityConfirmationRequiredPayload) => {
-      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationRequired, event);
-      this.logger.info('Notify the channel that activity confirmation is required', event);
-    });
+    this.engine.eventsQueue
+      .on(CHANNEL_EVENTS.activityConfirmationRequired, (event: ActivityConfirmationRequiredPayload) => {
+        this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationRequired, event);
+        this.logger.info('Notify the channel that activity confirmation is required', event);
+      });
 
-    connection.on(CHANNEL_EVENTS.activityConfirmationExpired, (event: ChannelEvent) => {
+    this.engine.eventsQueue.on(CHANNEL_EVENTS.activityConfirmationExpired, (event: ChannelEvent) => {
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationExpired, event);
       this.logger.info('Notify the channel that it has disconnected due to the activity confirmation expiring', event);
     });
 
-    connection.on(CHANNEL_EVENTS.activityConfirmationAcquired, (event: ChannelEvent) => {
+    this.engine.eventsQueue.on(CHANNEL_EVENTS.activityConfirmationAcquired, (event: ChannelEvent) => {
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationAcquired, event);
       this.logger.info('Notify the channel that the activity has been acquired.', event);
     });
 
-    connection.on(CHANNEL_EVENTS.changeProducePermissions, (payload: ChannelChangeProducePermissionsPayload) => {
-      const { producePermissions, groups, changedProducePermissions } = payload;
-      const peers = this.engine.peers.filter((peer) => peer.groups.some((group) => groups.includes(group)));
-      peers.forEach((peer) => {
-        const newProducePermissions = Array.from(new Set([...peer.producePermissions, ...changedProducePermissions]))
-          .filter((label) => (changedProducePermissions.includes(label) ? producePermissions.includes(label) : true));
+    this.engine.eventsQueue
+      .on(CHANNEL_EVENTS.changeProducePermissions, (payload: ChannelChangeProducePermissionsPayload) => {
+        const { producePermissions, groups, changedProducePermissions } = payload;
+        const peers = this.engine.peers.filter((peer) => peer.groups.some((group) => groups.includes(group)));
+        peers.forEach((peer) => {
+          const newProducePermissions = Array.from(new Set([...peer.producePermissions, ...changedProducePermissions]))
+            .filter((label) => (changedProducePermissions.includes(label) ? producePermissions.includes(label) : true));
+
+          peer.handleProducePermissionsChange(newProducePermissions);
+        });
 
-        peer.handleProducePermissionsChange(newProducePermissions);
+        this.logger.info('Peers changed produce permissions', { groups, producePermissions });
       });
 
-      this.logger.info('Peers changed produce permissions', { groups, producePermissions });
-    });
+    this.engine.eventsQueue
+      .on(CHANNEL_EVENTS.changePeerProducePermissions, (payload: ChangePeerProducePermissionPayload) => {
+        const { peerId, producePermissions } = payload;
+        const peer = this.engine.peersRepository.get(peerId);
 
-    connection.on(CHANNEL_EVENTS.changePeerProducePermissions, (payload: ChangePeerProducePermissionPayload) => {
-      const { peerId, producePermissions } = payload;
-      const peer = this.engine.peersRepository.get(peerId);
+        if (!peer) {
+          return;
+        }
 
-      if (!peer) {
-        return;
-      }
+        peer.handleProducePermissionsChange(producePermissions);
+      });
 
-      peer.handleProducePermissionsChange(producePermissions);
-    });
+    this.engine.eventsQueue
+      .on(CHANNEL_EVENTS.deleteProducePermissions, (payload: ChannelChangeProducePermissionsPayload) => {
+        const { producePermissions, groups } = payload;
+        const peers = this.engine.peers.filter((peer) => peer.groups.some((group) => groups.includes(group)));
+        peers.forEach((peer) => {
+          const newProducePermissions = peer
+            .producePermissions
+            .filter((permission) => !producePermissions.includes(permission));
 
-    connection.on(CHANNEL_EVENTS.deleteProducePermissions, (payload: ChannelChangeProducePermissionsPayload) => {
-      const { producePermissions, groups } = payload;
-      const peers = this.engine.peers.filter((peer) => peer.groups.some((group) => groups.includes(group)));
-      peers.forEach((peer) => {
-        const newProducePermissions = peer
-          .producePermissions
-          .filter((permission) => !producePermissions.includes(permission));
+          peer.handleProducePermissionsChange(newProducePermissions);
+        });
 
-        peer.handleProducePermissionsChange(newProducePermissions);
+        this.logger.info('Peers deleted produce permissions', { groups, producePermissions });
       });
-
-      this.logger.info('Peers deleted produce permissions', { groups, producePermissions });
-    });
   }
 
   private removeEventListeners() {
-    const { connection } = this.engine.network.socket;
-
-    if (!connection) {
+    if (!this.engine.eventsQueue) {
       return;
     }
 
@@ -140,7 +144,9 @@ class ChannelEventHandler {
       CHANNEL_EVENTS.changeProducePermissions,
     ];
 
-    eventNames.forEach((x) => connection.removeAllListeners(x));
+    const { connection } = this.engine.network.socket;
+
+    this.engine.eventsQueue.removeAllListeners(eventNames, connection);
   }
 
   private handlePeerAppDataUpdate({ peerId, appData }: UpdatePeerAppDataPayload) {

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyCheckResult.ts

@@ -1,6 +1,8 @@
 interface ChannelStateConsistencyCheckResultsParams {
   missingPeers: string[];
+  missingConsumers: string[];
   missingProducers: string[];
+  consumersWithInconsistentState: string[];
   producersWithInconsistentState: string[];
   peersWithInconsistentAppData: string[];
 }
@@ -8,22 +10,30 @@ interface ChannelStateConsistencyCheckResultsParams {
 class ChannelStateConsistencyCheckResult {
   readonly missingPeers: string[];
 
+  readonly missingConsumers: string[];
+
   readonly missingProducers: string[];
 
+  readonly consumersWithInconsistentState: string[];
+
   readonly producersWithInconsistentState: string[];
 
   readonly peersWithInconsistentAppData: string[];
 
   constructor(params: ChannelStateConsistencyCheckResultsParams) {
     this.missingPeers = params.missingPeers;
+    this.missingConsumers = params.missingConsumers;
     this.missingProducers = params.missingProducers;
+    this.consumersWithInconsistentState = params.consumersWithInconsistentState;
     this.producersWithInconsistentState = params.producersWithInconsistentState;
     this.peersWithInconsistentAppData = params.peersWithInconsistentAppData;
   }
 
   hasInconsistencyCases() {
     return this.missingPeers.length > 0
+      || this.missingConsumers.length > 0
       || this.missingProducers.length > 0
+      || this.consumersWithInconsistentState.length > 0
       || this.producersWithInconsistentState.length > 0
       || this.peersWithInconsistentAppData.length > 0;
   }

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyChecker.ts

@@ -20,8 +20,12 @@ class ChannelStateConsistencyChecker {
 
   private missingPeers: string[] = [];
 
+  private missingConsumers: string[] = [];
+
   private missingProducers: string[] = [];
 
+  private consumersWithInconsistentState: string[] = [];
+
   private producersWithInconsistentState: string[] = [];
 
   private peersWithInconsistentAppData: string[] = [];
@@ -55,9 +59,21 @@ class ChannelStateConsistencyChecker {
           return;
         }
 
+        const localConsumer = this.findLocalConsumerByProducerId(localPeer, remoteProducer.id);
+        if (localConsumer && localConsumer.paused !== remoteProducer.paused) {
+          this.consumersWithInconsistentState.push(localConsumer.id);
+        }
+
         const localProducer = this.findLocalProducerById(localPeer, remoteProducer.id);
         if (!localProducer) {
           this.missingProducers.push(remoteProducer.id);
+        }
+
+        if (!localConsumer && !localProducer) {
+          this.missingConsumers.push(remoteProducer.id);
+        }
+
+        if (!localProducer) {
           return;
         }
 
@@ -70,7 +86,9 @@ class ChannelStateConsistencyChecker {
 
     const checkResults = new ChannelStateConsistencyCheckResult({
       missingPeers: this.missingPeers,
+      missingConsumers: this.missingConsumers,
       missingProducers: this.missingProducers,
+      consumersWithInconsistentState: this.consumersWithInconsistentState,
       producersWithInconsistentState: this.producersWithInconsistentState,
       peersWithInconsistentAppData: this.peersWithInconsistentAppData,
     });
@@ -82,10 +100,21 @@ class ChannelStateConsistencyChecker {
     return this.missingPeers;
   }
 
+  /**
+   * Contains list of remote producer ids for which local consumer is missing
+   */
+  getMissingConsumers(): string[] {
+    return this.missingConsumers;
+  }
+
   getMissingProducers(): string[] {
     return this.missingProducers;
   }
 
+  getConsumersWithInconsistentState(): string[] {
+    return this.consumersWithInconsistentState;
+  }
+
   getProducersWithInconsistentState(): string[] {
     return this.producersWithInconsistentState;
   }
@@ -98,13 +127,19 @@ class ChannelStateConsistencyChecker {
     return this.localState.peers.find((item) => item.id === id);
   }
 
+  private findLocalConsumerByProducerId(peer: ChannelStatePeer, producerId: string) {
+    return peer.consumers?.find((item) => item.producerId === producerId);
+  }
+
   private findLocalProducerById(peer: ChannelStatePeer, id: string): ChannelStateProducer | undefined {
     return peer.producers.find((item) => item.id === id);
   }
 
   private resetPreviousCheckResults(): void {
     this.missingPeers = [];
+    this.missingConsumers = [];
     this.missingProducers = [];
+    this.consumersWithInconsistentState = [];
     this.producersWithInconsistentState = [];
     this.peersWithInconsistentAppData = [];
   }

package/src/engine/handlers/ChannelStateSyncEventHandler/index.ts

@@ -13,7 +13,7 @@ import ChannelStateConsistencyCheckResult from './ChannelStateConsistencyCheckRe
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import { ChannelStateSyncEventHandlerParams, ClientObserverEvents } from '../../../types/engine';
 import { CLIENT_EVENTS } from '../../../constants/events';
-import { InconsistenceType } from './types';
+import { InconsistenceType, StorageKey } from './types';
 import {
   BAD_NETWORK_SCORE,
   EXCELLENT_NETWORK_SCORE,
@@ -28,11 +28,13 @@ class ChannelStateSyncEventHandler {
 
   #confirmedMissingPeers: string[] = [];
 
+  #confirmedMissingConsumers: string[] = [];
+
   #confirmedMissingProducers: string[] = [];
 
-  #confirmedProducersWithInconsistentState: string[] = [];
+  #confirmedConsumersWithInconsistentState: string[] = [];
 
-  #confirmedPeersWithInconsistentAppData: string[] = [];
+  #confirmedProducersWithInconsistentState: string[] = [];
 
   #checkResults: ChannelStateConsistencyCheckResult[] = [];
 
@@ -118,6 +120,21 @@ class ChannelStateSyncEventHandler {
         type: InconsistenceType.IncorrectProducerState,
       });
     });
+
+    if (confirmedInconsistencyResult.missingConsumers.length > 0) {
+      this.#confirmedMissingConsumers.push(...confirmedInconsistencyResult.missingConsumers);
+      this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
+        type: InconsistenceType.MissingConsumers,
+      });
+    }
+
+    if (confirmedInconsistencyResult.consumersWithInconsistentState.length > 0) {
+      this.#confirmedConsumersWithInconsistentState
+        .push(...confirmedInconsistencyResult.consumersWithInconsistentState);
+      this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelStateInconsistent, {
+        type: InconsistenceType.IncorrectConsumerState,
+      });
+    }
   }
 
   private getConfirmedInconsistencyResult(): ChannelStateConsistencyCheckResult | undefined {
@@ -128,7 +145,11 @@ class ChannelStateSyncEventHandler {
 
     const confirmedCheckResult = new ChannelStateConsistencyCheckResult({
       missingPeers: this.getConfirmedMissingPeers(lastCheckResult.missingPeers),
+      missingConsumers: this.getConfirmedMissingConsumers(lastCheckResult.missingConsumers),
       missingProducers: this.getConfirmedMissingProducers(lastCheckResult.missingProducers),
+      consumersWithInconsistentState: this.getConfirmedConsumersWithInconsistencState(
+        lastCheckResult.consumersWithInconsistentState,
+      ),
       producersWithInconsistentState: this.getConfirmedProducersWithInconsistencState(
         lastCheckResult.producersWithInconsistentState,
       ),
@@ -176,8 +197,9 @@ class ChannelStateSyncEventHandler {
   }
 
   private isReachedMaxCheckRetries(
-    storageKey: 'missingPeers' | 'missingProducers' | 'producersWithInconsistentState' | 'peersWithInconsistentAppData',
+    storageKey: StorageKey,
     id: string,
+    maxRetries = MAX_CHECK_RETRIES_BEFORE_CONFIRM,
   ) {
     let retries = 0;
     this.#checkResults.forEach((checkResults) => {
@@ -186,17 +208,33 @@ class ChannelStateSyncEventHandler {
       }
     });
 
-    return retries >= MAX_CHECK_RETRIES_BEFORE_CONFIRM;
+    return retries >= maxRetries;
   }
 
   private getConfirmedMissingPeers(peerIds: string[]): string[] {
     return peerIds.filter((peerId) => this.isReachedMaxCheckRetries('missingPeers', peerId));
   }
 
+  private getConfirmedMissingConsumers(consumersIds: string[]): string[] {
+    return consumersIds.filter((consumerId) => this.isReachedMaxCheckRetries(
+      'missingConsumers',
+      consumerId,
+      1,
+    ));
+  }
+
   private getConfirmedMissingProducers(producerIds: string[]): string[] {
     return producerIds.filter((producerId) => this.isReachedMaxCheckRetries('missingProducers', producerId));
   }
 
+  private getConfirmedConsumersWithInconsistencState(consumersIds: string[]): string[] {
+    return consumersIds.filter((consumerId) => this.isReachedMaxCheckRetries(
+      'consumersWithInconsistentState',
+      consumerId,
+      1,
+    ));
+  }
+
   private getConfirmedProducersWithInconsistencState(producerIds: string[]): string[] {
     return producerIds.filter((producerId) => this.isReachedMaxCheckRetries(
       'producersWithInconsistentState',
@@ -219,7 +257,9 @@ class ChannelStateSyncEventHandler {
   private getAllConfirmedInconsistentEntityIds(): string[] {
     return [
       ...this.#confirmedMissingPeers,
+      ...this.#confirmedMissingConsumers,
       ...this.#confirmedMissingProducers,
+      ...this.#confirmedConsumersWithInconsistentState,
       ...this.#confirmedProducersWithInconsistentState,
     ];
   }
@@ -234,6 +274,7 @@ class ChannelStateSyncEventHandler {
           id: producer.id,
           paused: producer.paused,
         })),
+        consumers: peer.getConsumersState(),
       })),
     };
   }

package/src/engine/handlers/ChannelStateSyncEventHandler/types.ts

@@ -2,6 +2,15 @@
 
 export enum InconsistenceType {
   MissingPeer = 'missing-peer',
+  MissingConsumers = 'missing-consumers',
   MissingProducer = 'missing-producer',
   IncorrectProducerState = 'incorrect-producer-state',
+  IncorrectConsumerState = 'incorrect-consumer-state',
 }
+
+export type StorageKey = 'missingPeers'
+| 'missingConsumers'
+| 'missingProducers'
+| 'consumersWithInconsistentState'
+| 'producersWithInconsistentState'
+| 'peersWithInconsistentAppData';