@webex/plugin-meetings 3.12.0-next.3 → 3.12.0-next.30

package/dist/types/hashTree/hashTreeParser.d.ts

@@ -45,9 +45,13 @@ export declare const LocusInfoUpdateType: {
     readonly MEETING_ENDED: "MEETING_ENDED";
 };
 export type LocusInfoUpdateType = Enum<typeof LocusInfoUpdateType>;
-export type LocusInfoUpdateCallback = (updateType: LocusInfoUpdateType, data?: {
+export type LocusInfoUpdate = {
+    updateType: typeof LocusInfoUpdateType.OBJECTS_UPDATED;
     updatedObjects: HashTreeObject[];
-}) => void;
+} | {
+    updateType: typeof LocusInfoUpdateType.MEETING_ENDED;
+};
+export type LocusInfoUpdateCallback = (update: LocusInfoUpdate) => void;
 /**
  * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
  * It's handled internally by HashTreeParser and results in MEETING_ENDED being sent up.
@@ -67,6 +71,10 @@ declare class HashTreeParser {
     heartbeatIntervalMs?: number;
     private excludedDataSets;
     state: 'active' | 'stopped';
+    private syncQueue;
+    private isSyncInProgress;
+    private isSyncAllInProgress;
+    private syncQueueProcessingPromise;
     /**
      * Constructor for HashTreeParser
      * @param {Object} options
@@ -120,14 +128,6 @@ declare class HashTreeParser {
      * @returns {Promise}
      */
     private initializeNewVisibleDataSet;
-    /**
-     * Sends a special sync request to Locus with all leaves empty - this is a way to get all the data for a given dataset.
-     *
-     * @param {string} datasetName - name of the dataset for which to send the request
-     * @param {string} debugText - text to include in logs
-     * @returns {Promise}
-     */
-    private sendInitializationSyncRequestToLocus;
     /**
      * Queries Locus for all up-to-date information about all visible data sets
      *
@@ -298,11 +298,35 @@ declare class HashTreeParser {
      * Performs a sync for the given data set.
      *
      * @param {InternalDataSet} dataSet - The data set to sync
-     * @param {string} rootHash - Our current root hash for this data set
      * @param {string} reason - The reason for the sync (used for logging)
+     * @param {boolean} [isInitialization] - Whether this is an initialization sync (sends empty leaves data instead of comparing hashes)
      * @returns {Promise<void>}
      */
     private performSync;
+    /**
+     * Enqueues a sync for the given data set. If the data set is already in the queue, the request is ignored.
+     * This ensures that all syncs are executed sequentially and no more than 1 sync runs at a time.
+     *
+     * @param {string} dataSetName - The name of the data set to sync
+     * @param {string} reason - The reason for the sync (used for logging)
+     * @param {boolean} [isInitialization=false] - Whether this is an initialization sync (uses empty leaves data instead of hash comparison)
+     * @returns {void}
+     */
+    private enqueueSyncForDataset;
+    /**
+     * Processes the sync queue sequentially. Only one instance of this method runs at a time.
+     *
+     * @returns {Promise<void>}
+     */
+    private processSyncQueue;
+    /**
+     * Syncs all data sets that have hash trees, one by one in sequence, using the priority order
+     * provided by sortByInitPriority(). Does nothing if the parser is stopped or if a syncAllDatasets
+     * call is already in progress.
+     *
+     * @returns {Promise<void>}
+     */
+    syncAllDatasets(): Promise<void>;
     /**
      * Runs the sync algorithm for the given data set.
      *
@@ -333,24 +357,38 @@ declare class HashTreeParser {
      */
     stop(): void;
     /**
-     * Resumes the HashTreeParser that was previously stopped.
+     * Cleans up the HashTreeParser, stopping all timers and clearing all internal state.
+     * After calling this, the parser should not be used anymore.
+     * @returns {void}
+     */
+    cleanUp(): void;
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a hash tree message.
      * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
      * @returns {void}
      */
-    resume(message: HashTreeMessage): void;
+    resumeFromMessage(message: HashTreeMessage): void;
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a Locus API response.
+     * Unlike resumeFromMessage(), this does not require metadata/dataSets in the input,
+     * as it fetches all necessary information from Locus via initializeFromGetLociResponse.
+     * @param {LocusDTO} locus - locus object from an API response
+     * @returns {Promise}
+     */
+    resumeFromApiResponse(locus: LocusDTO): Promise<void>;
     private checkForSentinelHttpResponse;
     /**
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
      * @param {string} currentRootHash
-     * @returns {string[]}
+     * @returns {Object|null} An object containing the hashes and leaf count, or null if the hashes match and no sync is needed
      */
     private getHashesFromLocus;
     /**
      * Sends a sync request to Locus for the specified data set.
      *
      * @param {InternalDataSet} dataSet The data set to sync.
-     * @param {Record<number, LeafDataItem[]>} mismatchedLeavesData The mismatched leaves data to include in the sync request.
+     * @param {Object} options Either `{ isInitialization: true }` for init syncs (uses leafCount=1 with empty leaf data) or `{ mismatchedLeavesData }` for normal syncs.
      * @returns {Promise<HashTreeMessage|null>}
      */
     private sendSyncRequestToLocus;

package/dist/types/hashTree/utils.d.ts

@@ -20,3 +20,14 @@ export declare function isMetadata(object: HashTreeObject): boolean;
  * @returns {void}
  */
 export declare const deleteNestedObjectsWithHtMeta: (currentLocusPart: any, parent?: any, currentKey?: string | number) => void;
+/**
+ * Reorders items so that those matching the given priority list come first (in priority order),
+ * followed by everything else in their original order.
+ *
+ * @param {Array<T>} items - The items to reorder
+ * @param {string[]} priority - Ordered list of names that should come first
+ * @returns {Array<T>} A new array with prioritized items first
+ */
+export declare function sortByInitPriority<T extends {
+    name: string;
+}>(items: T[], priority: string[]): T[];

package/dist/types/interceptors/locusRetry.d.ts

@@ -11,11 +11,11 @@ export default class LocusRetryStatusInterceptor extends Interceptor {
      */
     static create(): LocusRetryStatusInterceptor;
     /**
-     * Handle response errors
-     * @param {Object} options
-     * @param {WebexHttpError} reason
-     * @returns {Promise<WebexHttpError>}
+     * Check whether a URI is a Locus /hashtree or /sync endpoint.
+     * @param {string} uri
+     * @returns {boolean}
      */
+    private static isLocusHashtreeOrSync;
     onResponseError(options: any, reason: any): Promise<unknown>;
     /**
      * Handle retries for locus service unavailable errors

package/dist/types/locus-info/index.d.ts

@@ -25,10 +25,9 @@ export type HashTreeParserEntry = {
  *
  * @param {HashTreeMessage} message - The hash tree message to find the meeting for
  * @param {MeetingCollection} meetingCollection - The collection of meetings to search
- * @param {string} deviceUrl - The URL of the user's device
  * @returns {any} The meeting if found, otherwise undefined
  */
-export declare function findMeetingForHashTreeMessage(message: HashTreeMessage, meetingCollection: MeetingCollection, deviceUrl: string): any;
+export declare function findMeetingForHashTreeMessage(message: HashTreeMessage | undefined, meetingCollection: MeetingCollection): any;
 /**
  * Creates a locus object from the objects received in a hash tree message. It usually will be
  * incomplete, because hash tree messages only contain the parts of locus that have changed,
@@ -167,6 +166,28 @@ export default class LocusInfo extends EventsScope {
      * @returns {void}
      */
     sendClassicVsHashTreeMismatchMetric(meeting: any, message: string): void;
+    /**
+     * Helper that handles the common logic for reactivating a stopped HashTreeParser when
+     * a newer "replaces" is detected. Used by both the message and API response parser switch methods.
+     *
+     * @param {string} callerName - name of the calling method, used in log messages
+     * @param {string} locusUrl - the locus URL of the stopped parser
+     * @param {HashTreeParserEntry} stoppedEntry - the stopped parser entry
+     * @param {ReplacesInfo} replaces - replacement info extracted from self
+     * @param {Function} resumeCallback - callback to invoke after reactivation to resume the parser
+     * @returns {void}
+     */
+    private resumeStoppedParser;
+    /**
+     * Handles an API response whose locusUrl doesn't match any active HashTreeParser
+     * (either no entry exists, or the existing entry is stopped).
+     * Creates a new parser or reactivates a stopped one using initializeFromGetLociResponse.
+     *
+     * @param {string} locusUrl - the locus URL from the API response
+     * @param {LocusDTO} locus - the locus DTO from the API response
+     * @returns {void}
+     */
+    private handleHashTreeParserSwitchForAPIResponse;
     /**
      * Checks if the hash tree message should trigger a switch to a different HashTreeParser
      *
@@ -183,13 +204,19 @@ export default class LocusInfo extends EventsScope {
      * @returns {void}
      */
     private handleHashTreeMessage;
+    /**
+     * Triggers a sync of all hash tree datasets for all hash tree parsers associated with this meeting.
+     * The syncs are executed sequentially within each parser.
+     *
+     * @returns {Promise<void>}
+     */
+    syncAllHashTreeDatasets(): Promise<void>;
     /**
      * Callback registered with HashTreeParser to receive locus info updates.
      * Updates our locus info based on the data parsed by the hash tree parser.
      *
      * @param {string} locusUrl - the locus URL for which the update is received
-     * @param {LocusInfoUpdateType} updateType - The type of update received.
-     * @param {Object} [data] - Additional data for the update, if applicable.
+     * @param {LocusInfoUpdate} update - Details about the update.
      * @returns {void}
      */
     private updateFromHashTree;
@@ -214,8 +241,8 @@ export default class LocusInfo extends EventsScope {
      * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
      * @param {object} metadata locus hash trees metadata
-     * @param {string} eventType locus event
      * @param {DataSet[]} dataSets
+     * @param {string} eventType locus event
      * @returns {void}
      */
     private onFullLocusWithHashTrees;
@@ -444,4 +471,10 @@ export default class LocusInfo extends EventsScope {
      * @memberof LocusInfo
      */
     clearMainSessionLocusCache(): void;
+    /**
+     * Cleans up all hash tree parsers and clears internal maps.
+     * @returns {void}
+     * @memberof LocusInfo
+     */
+    cleanUp(): void;
 }

package/dist/types/meeting/index.d.ts

@@ -1318,6 +1318,11 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns{void}
      */
     private triggerStopReceivingTranscriptionEvent;
+    /**
+     * Restores LLM subchannel subscriptions after reconnect when captions are active.
+     * @returns {void}
+     */
+    private restoreLLMSubscriptionsIfNeeded;
     /**
      * This is a callback for the LLM event that is triggered when it comes online
      * This method in turn will trigger an event to the developers that the LLM is connected
@@ -1372,6 +1377,12 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     saveDataChannelToken(join: any): void;
+    /**
+     * Ensures default-session data channel token exists after lobby admission.
+     * Some lobby users do not receive a token until they are admitted.
+     * @returns {Promise<boolean>} true when a new token is fetched and cached
+     */
+    private ensureDefaultDatachannelTokenAfterAdmit;
     /**
      * Connects to low latency mercury and reconnects if the address has changed
      * It will also disconnect if called when the meeting has ended

package/dist/types/metrics/constants.d.ts

@@ -88,5 +88,9 @@ declare const BEHAVIORAL_METRICS: {
     LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: string;
     LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: string;
     MEDIA_STILL_NOT_CONNECTED: string;
+    DEPRECATED_SET_CODEC_PARAMETERS_USED: string;
+    DEPRECATED_DELETE_CODEC_PARAMETERS_USED: string;
+    SET_CUSTOM_CODEC_PARAMETERS_USED: string;
+    MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED: string;
 };
 export { BEHAVIORAL_METRICS as default };

package/dist/types/multistream/sendSlotManager.d.ts

@@ -1,4 +1,4 @@
-import { SendSlot, MediaType, LocalStream, MultistreamRoapMediaConnection, NamedMediaGroup, StreamState } from '@webex/internal-media-core';
+import { SendSlot, MediaType, LocalStream, MultistreamRoapMediaConnection, NamedMediaGroup, StreamState, MediaCodecMimeType, CodecParameters } from '@webex/internal-media-core';
 /**
  * This class is used to manage the sendSlots for the given media types.
  */
@@ -69,6 +69,8 @@ export default class SendSlotManager {
      */
     setActive(mediaType: MediaType, active?: boolean): void;
     /**
+     * @deprecated Use {@link setCustomCodecParameters} instead, which requires specifying the codec MIME type.
+     *
      * This method is used to set the codec parameters for the sendSlot of the given mediaType
      * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
      * @param {Object} codecParameters
@@ -78,12 +80,32 @@ export default class SendSlotManager {
         [key: string]: string | undefined;
     }): Promise<void>;
     /**
+     * @deprecated Use {@link markCustomCodecParametersForDeletion} instead, which requires specifying the codec MIME type.
+     *
      * This method is used to delete the codec parameters for the sendSlot of the given mediaType
      * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
      * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
      * @returns {Promise<void>}
      */
     deleteCodecParameters(mediaType: MediaType, parameters: string[]): Promise<void>;
+    /**
+     * Sets custom codec parameters for the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+     * Delegates to WCME's setCustomCodecParameters API.
+     * @param {MediaType} mediaType MediaType of the sendSlot
+     * @param {MediaCodecMimeType} codecMimeType The codec MIME type to apply parameters to (e.g. OPUS, H264, AV1)
+     * @param {CodecParameters} parameters Key-value pairs of codec parameters to set
+     * @returns {Promise<void>}
+     */
+    setCustomCodecParameters(mediaType: MediaType, codecMimeType: MediaCodecMimeType, parameters: CodecParameters): Promise<void>;
+    /**
+     * Marks custom codec parameters for deletion on the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+     * Delegates to WCME's markCustomCodecParametersForDeletion API.
+     * @param {MediaType} mediaType MediaType of the sendSlot
+     * @param {MediaCodecMimeType} codecMimeType The codec MIME type whose parameters should be deleted (e.g. OPUS, H264, AV1)
+     * @param {string[]} parameters Array of parameter keys to delete
+     * @returns {Promise<void>}
+     */
+    markCustomCodecParametersForDeletion(mediaType: MediaType, codecMimeType: MediaCodecMimeType, parameters: string[]): Promise<void>;
     /**
      * This method is used to reset the SendSlotsManager by deleting all the sendSlots
      * @returns {undefined}