@matter/protocol 0.13.1-alpha.0-20250509-28e1567e1 → 0.13.1-alpha.0-20250511-74ef153aa

package/src/events/OccurrenceManager.ts

@@ -9,20 +9,14 @@ import {
     Construction,
     Diagnostic,
     ImplementationError,
+    InternalError,
     isObject,
     Logger,
     MatterAggregateError,
     MaybePromise,
+    Observable,
 } from "#general";
-import {
-    EventNumber,
-    EventPriority,
-    FabricIndex,
-    resolveEventName,
-    TlvEventFilter,
-    TlvEventPath,
-    TypeFromSchema,
-} from "#types";
+import { EventNumber, FabricIndex, resolveEventName, TlvEventFilter, TlvEventPath, TypeFromSchema } from "#types";
 import { EventStore, OccurrenceSummary } from "./EventStore.js";
 import { NumberedOccurrence, Occurrence } from "./Occurrence.js";
 
@@ -50,14 +44,12 @@ export class OccurrenceManager {
     #storedEventCount = 0;
     #bufferConfig: OccurrenceManager.BufferConfig;
     #cull?: Promise<void>;
+    #iteratingValuesInProgress = false;
+    #added = new Observable<[occurrence: NumberedOccurrence]>();
 
     // As we don't (yet) have storage with secondary indices we currently maintain indices in memory regardless of
     // whether underlying store is volatile
-    readonly #occurrences = {
-        [EventPriority.Critical]: new Array<OccurrenceSummary>(),
-        [EventPriority.Info]: new Array<OccurrenceSummary>(),
-        [EventPriority.Debug]: new Array<OccurrenceSummary>(),
-    };
+    readonly #occurrences = new Array<OccurrenceSummary>();
 
     #construction: Construction<OccurrenceManager>;
 
@@ -82,70 +74,105 @@ export class OccurrenceManager {
             );
         }
 
-        const totalPriorityAllowance = Object.values(bufferConfig.minPriorityEventAllowance).reduce(
-            (sum, value) => sum + value,
-            0,
-        );
-        if (totalPriorityAllowance > minEventAllowance) {
-            throw new ImplementationError(
-                `Total priority allowance ${totalPriorityAllowance} is greater than minimum allowance of ${minEventAllowance}`,
-            );
-        }
-
         this.#store = store;
         this.#bufferConfig = bufferConfig;
 
         this.#construction = Construction(this, () => {
             return MaybePromise.then(this.#store.load(), index => {
                 this.#storedEventCount = index.length;
-                for (const entry of index) {
-                    this.#occurrences[entry.priority].push(entry);
+                // To be sure, sort the entries by number
+                index.sort(
+                    // sort that way because Bigint & Number mix
+                    ({ number: numberA }, { number: numberB }) => (numberA < numberB ? -1 : numberA > numberB ? 1 : 0),
+                );
+                this.#occurrences.push(...index);
+                if (this.#occurrences.length > this.#bufferConfig.minEventAllowance) {
+                    this.#startCull();
                 }
             });
         });
     }
 
+    get added() {
+        return this.#added;
+    }
+
     async clear() {
         await this.construction;
         await this.#store.clear();
         this.#storedEventCount = 0;
-        for (const list of Object.values(this.#occurrences)) {
-            list.length = 0;
+        this.#occurrences.length = 0;
+    }
+
+    /**
+     * Find the index of the first event number in the list that is greater than or equal to eventMin to optimize
+     * searching.
+     */
+    #findMinEventNumberIndex(eventMin: EventNumber) {
+        // if the list is empty or the eventMin is less than the last event number, no entry is relevant
+
+        if (this.#occurrences.length === 0 || eventMin > this.#occurrences[this.#occurrences.length - 1].number) {
+            return -1;
+        }
+        if (eventMin <= this.#occurrences[0].number) {
+            return 0; // The first event number is greater than or equal to eventMin, so all entries are relevant
+        }
+
+        let low = this.#occurrences.length - 1;
+        let high = low;
+        let step = 1;
+
+        // Because it is more likely that events we want are in the upper ranges we first fine a starting point from there
+        while (low > 0 && this.#occurrences[low].number >= eventMin) {
+            high = low;
+            low = Math.max(0, low - step);
+            step *= 2; // increase the step size to skip more entries
+        }
+
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            if (this.#occurrences[mid].number < eventMin) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
         }
+
+        return low; // The index of the first event number that is greater than or equal to eventMin
     }
 
+    /**
+     * Query the event store for events matching the given path and filters.
+     * @deprecated
+     */
     query(
         eventPath: TypeFromSchema<typeof TlvEventPath>,
         filters?: TypeFromSchema<typeof TlvEventFilter>[],
         filterForFabricIndex?: FabricIndex,
     ): MaybePromise<NumberedOccurrence[]> {
-        const entryFilter =
-            filters !== undefined && filters.length > 0
-                ? (event: OccurrenceSummary) =>
-                      filters.some(
-                          filter => filter.eventMin !== undefined && event.number >= EventNumber(filter.eventMin),
-                      )
-                : undefined; // TODO - filter on node ID too?
-
+        if (filters !== undefined && filters.length > 1) {
+            throw new InternalError("Multiple filters not supported");
+        }
         // Search the index and load applicable events
+        const startIndex = filters?.length ? this.#findMinEventNumberIndex(EventNumber(filters[0].eventMin)) : 0;
+        if (startIndex === -1) {
+            return []; // No entry matches the filter
+        }
+
         let isAsyncLoad = false;
-        const occurrences = new Array<MaybePromise<NumberedOccurrence>>();
         const { endpointId, clusterId, eventId } = eventPath;
-        for (const priority of [EventPriority.Critical, EventPriority.Info, EventPriority.Debug]) {
-            const entriesToCheck = this.#occurrences[priority];
-            for (const entry of entriesToCheck) {
-                if (endpointId === entry.endpointId && clusterId === entry.clusterId && eventId === entry.eventId) {
-                    if (entryFilter?.(entry) !== false) {
-                        let occurrence = this.#store.get(entry.number) as MaybePromise<NumberedOccurrence>;
-                        occurrence = MaybePromise.then(occurrence, occurrence => {
-                            occurrence.number = entry.number;
-                            return occurrence;
-                        });
-                        occurrences.push(occurrence);
-                        if (MaybePromise.is(occurrence)) {
-                            isAsyncLoad = true;
-                        }
-                    }
+        const occurrences = new Array<MaybePromise<NumberedOccurrence>>();
+        for (let i = startIndex; i < this.#occurrences.length; i++) {
+            const entry = this.#occurrences[i];
+            if (endpointId === entry.endpointId && clusterId === entry.clusterId && eventId === entry.eventId) {
+                let occurrence = this.#store.get(entry.number) as MaybePromise<NumberedOccurrence>;
+                occurrence = MaybePromise.then(occurrence, occurrence => {
+                    occurrence.number = entry.number;
+                    return occurrence;
+                });
+                occurrences.push(occurrence);
+                if (MaybePromise.is(occurrence)) {
+                    isAsyncLoad = true;
                 }
             }
         }
@@ -205,6 +232,40 @@ export class OccurrenceManager {
         return result;
     }
 
+    /**
+     * Return an iterator over all occurrences in the store that are bigger or equal to the minimum eventNumber,
+     * if provided.
+     */
+    async *get(eventMin?: EventNumber) {
+        if (this.#cull) {
+            await this.#cull;
+        }
+        const startIndex = eventMin === undefined ? 0 : this.#findMinEventNumberIndex(eventMin);
+        if (startIndex === -1) {
+            return; // No entry matches the filter
+        }
+        this.#iteratingValuesInProgress = true;
+        try {
+            for (let i = startIndex; i < this.#occurrences.length; i++) {
+                const eventNumber = this.#occurrences[i].number;
+                const occurrence = this.#store.get(eventNumber);
+                if (MaybePromise.is(occurrence)) {
+                    yield {
+                        ...(await occurrence),
+                        number: eventNumber,
+                    };
+                } else {
+                    yield {
+                        ...occurrence,
+                        number: eventNumber,
+                    };
+                }
+            }
+        } finally {
+            this.#iteratingValuesInProgress = false;
+        }
+    }
+
     close(): MaybePromise<void> {
         MaybePromise.then(this.#cull, () => this.#store.close());
     }
@@ -212,20 +273,22 @@ export class OccurrenceManager {
     add(occurrence: Occurrence): MaybePromise<NumberedOccurrence> {
         return MaybePromise.then(this.#store.add(occurrence), entry => {
             logger.debug(`Recorded event #${entry.number}: ${Diagnostic.json(occurrence)}`);
-            this.#occurrences[occurrence.priority].push(entry);
+            this.#occurrences.push(entry);
             this.#storedEventCount++;
             if (this.#storedEventCount > this.#bufferConfig.maxEventAllowance) {
                 this.#startCull();
             }
-            return {
+            const numberedOccurrence = {
                 number: entry.number,
                 ...occurrence,
             };
+            this.#added.emit(numberedOccurrence);
+            return numberedOccurrence;
         });
     }
 
     #startCull() {
-        if (this.#cull) {
+        if (this.#cull || this.#iteratingValuesInProgress) {
             return;
         }
         const cull = this.#dropOldOccurrences();
@@ -235,7 +298,7 @@ export class OccurrenceManager {
     }
 
     #dropOldOccurrences() {
-        let count = this.#storedEventCount - this.#bufferConfig.minEventAllowance;
+        const count = this.#storedEventCount - this.#bufferConfig.minEventAllowance;
         if (count <= 0) {
             return;
         }
@@ -244,31 +307,15 @@ export class OccurrenceManager {
 
         const asyncDrops = Array<PromiseLike<void>>();
 
-        let totalCulled = 0;
-        for (const priority of [EventPriority.Debug, EventPriority.Info, EventPriority.Critical]) {
-            const occurrences = this.#occurrences[priority];
-            const reservation = this.#bufferConfig.minPriorityEventAllowance[PriorityNames[priority]];
-            let countThisPriority = 0;
-            while (count && occurrences.length > reservation) {
-                count--;
-                countThisPriority++;
-            }
-
-            totalCulled += countThisPriority;
-            for (const entry of occurrences.splice(0, countThisPriority)) {
-                const drop = MaybePromise.catch(this.#store.delete(entry.number), error =>
-                    logger.warn(`Error dropping occurrence #${entry}: ${error}`),
-                );
-                if (MaybePromise.is(drop)) {
-                    asyncDrops.push(drop);
-                }
-            }
-
-            if (!count) {
-                break;
+        for (const entry of this.#occurrences.splice(0, count)) {
+            const drop = MaybePromise.catch(this.#store.delete(entry.number), error =>
+                logger.warn(`Error dropping occurrence #${entry}: ${error}`),
+            );
+            if (MaybePromise.is(drop)) {
+                asyncDrops.push(drop);
             }
         }
-        this.#storedEventCount -= totalCulled;
+        this.#storedEventCount = this.#occurrences.length;
 
         if (asyncDrops.length) {
             return MatterAggregateError.allSettled(asyncDrops, "Error dropping occurrences")
@@ -278,12 +325,6 @@ export class OccurrenceManager {
     }
 }
 
-const PriorityNames = {
-    [EventPriority.Critical]: "critical",
-    [EventPriority.Info]: "info",
-    [EventPriority.Debug]: "debug",
-} as const;
-
 export namespace OccurrenceManager {
     /**
      * Buffer management configuration.  Controls
@@ -301,25 +342,10 @@ export namespace OccurrenceManager {
          * {@link minimumEventAllowance}.
          */
         maxEventAllowance: number;
-
-        /**
-         * Minimum allowances by priority.  This ensures a minimum number of events for each priority avoid LRU
-         * harvesting.
-         */
-        minPriorityEventAllowance: {
-            critical: number;
-            info: number;
-            debug: number;
-        };
     }
 
     export const DefaultBufferConfig: BufferConfig = {
         minEventAllowance: 10_000,
         maxEventAllowance: 11_000,
-        minPriorityEventAllowance: {
-            critical: 2_000,
-            info: 2_000,
-            debug: 2_000,
-        },
     };
 }

package/src/interaction/InteractionMessenger.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ReadResult } from "#action/index.js";
 import {
     Diagnostic,
     InternalError,
@@ -244,7 +245,11 @@ export class InteractionServerMessenger extends InteractionMessenger {
                         );
 
                         // This potentially sends multiple DataReport Messages
-                        await this.sendDataReport(dataReport, readRequest.isFabricFiltered, payload);
+                        await this.sendDataReport({
+                            baseDataReport: dataReport,
+                            forFabricFilteredRead: readRequest.isFabricFiltered,
+                            payload,
+                        });
                         break;
                     }
                     case MessageType.WriteRequest: {
@@ -306,12 +311,20 @@ export class InteractionServerMessenger extends InteractionMessenger {
      * Handle a DataReport with a Payload Iterator for a DataReport to send, split them into multiple DataReport
      * messages and send them out based on the size.
      */
-    async sendDataReport(
-        baseDataReport: BaseDataReport,
-        forFabricFilteredRead: boolean,
-        payload?: DataReportPayloadIterator,
-        waitForAck = true,
-    ) {
+    async sendDataReport(options: {
+        baseDataReport: BaseDataReport;
+        forFabricFilteredRead: boolean;
+        payload?: DataReportPayloadIterator;
+        waitForAck?: boolean;
+        suppressEmptyReport?: boolean;
+    }) {
+        const {
+            baseDataReport,
+            forFabricFilteredRead,
+            payload,
+            waitForAck = true,
+            suppressEmptyReport = false,
+        } = options;
         const { subscriptionId, suppressResponse, interactionModelRevision } = baseDataReport;
 
         const dataReport: TypeFromSchema<typeof TlvDataReportForSend> = {
@@ -622,7 +635,9 @@ export class InteractionServerMessenger extends InteractionMessenger {
             }
         }
 
-        await this.sendDataReportMessage(dataReport, waitForAck);
+        if (!suppressEmptyReport || dataReport.attributeReports?.length || dataReport.eventReports?.length) {
+            await this.sendDataReportMessage(dataReport, waitForAck);
+        }
     }
 
     async sendDataReportMessage(dataReport: TypeFromSchema<typeof TlvDataReportForSend>, waitForAck = true) {
@@ -673,6 +688,76 @@ export class InteractionServerMessenger extends InteractionMessenger {
             await this.waitForSuccess("DataReport", { timeoutMs: waitForAck ? undefined : 500 });
         }
     }
+
+    /**
+     * Convert a server interaction report to a DataReport entry
+     * TODO remove when anything is migrated completely
+     */
+    static convertServerInteractionReport(report: ReadResult.Report) {
+        switch (report.kind) {
+            case "attr-value": {
+                const { path, value: payload, version: dataVersion, tlv: schema } = report;
+                if (schema === undefined) {
+                    throw new InternalError(`Attribute ${path.clusterId}/${path.attributeId} not found`);
+                }
+                const data: AttributeReportPayload = {
+                    attributeData: {
+                        path,
+                        payload,
+                        schema,
+                        dataVersion,
+                    },
+                    hasFabricSensitiveData: true, // With this we disable the validation for missing data in encoding, we trust behavior logic
+                };
+                return data;
+            }
+            case "attr-status": {
+                const { path, status } = report;
+                const statusReport: AttributeReportPayload = {
+                    attributeStatus: {
+                        path,
+                        status: { status },
+                    },
+                    hasFabricSensitiveData: false,
+                };
+                return statusReport;
+            }
+            case "event-value": {
+                const {
+                    path,
+                    value: payload,
+                    number: eventNumber,
+                    priority,
+                    timestamp: epochTimestamp,
+                    tlv: schema,
+                } = report;
+                const data: EventReportPayload = {
+                    eventData: {
+                        path,
+                        eventNumber,
+                        priority,
+                        epochTimestamp,
+                        payload,
+                        schema,
+                    },
+                    hasFabricSensitiveData: true, // There are no Fabric sensitive events as of now. If ever added sanitizing needs to be added
+                };
+                return data;
+            }
+            case "event-status": {
+                const { path, status } = report;
+                const statusReport: EventReportPayload = {
+                    eventStatus: {
+                        path,
+                        status: { status },
+                    },
+                    hasFabricSensitiveData: false,
+                };
+                return statusReport;
+            }
+        }
+        throw new InternalError(`Unknown report type: ${report.kind}`);
+    }
 }
 
 export class IncomingInteractionClientMessenger extends InteractionMessenger {

package/src/interaction/index.ts

@@ -11,6 +11,5 @@ export * from "./EventDataDecoder.js";
 export * from "./InteractionClient.js";
 export * from "./InteractionEndpointStructure.js";
 export * from "./InteractionMessenger.js";
-export * from "./ServerSubscription.js";
 export * from "./Subscription.js";
 export * from "./SubscriptionClient.js";

package/src/peer/ControllerCommissioningFlow.ts

@@ -250,7 +250,7 @@ export class ControllerCommissioningFlow {
                 }
             } catch (error) {
                 if (error instanceof RecoverableCommissioningError) {
-                    logger.error(
+                    logger.warn(
                         `Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name} failed with recoverable error: ${error.message} ... Continuing with process`,
                     );
                 } else if (error instanceof CommissioningError || error instanceof StatusResponseError) {

package/src/protocol/MessageExchange.ts

@@ -186,6 +186,7 @@ export class MessageExchange {
     #closeTimer: Timer | undefined;
     #isClosing = false;
     #timedInteractionTimer: Timer | undefined;
+    #used: boolean;
 
     readonly #peerSessionId: number;
     readonly #nodeId: NodeId | undefined;
@@ -221,6 +222,7 @@ export class MessageExchange {
 
         // When the session is supporting MRP and the channel is not reliable, use MRP handling
         this.#useMRP = session.supportsMRP && !channel.isReliable;
+        this.#used = !isInitiator; // If we are the initiator then exchange was not used yet, so track it
 
         logger.debug(
             "New exchange",
@@ -390,6 +392,7 @@ export class MessageExchange {
         if (this.#sentMessageToAck !== undefined && messageType !== SecureMessageType.StandaloneAck)
             throw new MatterFlowError("The previous message has not been acked yet, cannot send a new message.");
 
+        this.#used = true;
         this.session.notifyActivity(false);
 
         let ackedMessageId = includeAcknowledgeMessageId;
@@ -660,6 +663,12 @@ export class MessageExchange {
             // close was already called, so let retries happen because close not forced
             return;
         }
+        if (!this.#used) {
+            // The exchange was never in use, so we can close it directly
+            // If we see that in the wild we should fix the reasons
+            logger.info(`Exchange ${this.session.name} / ${this.#exchangeId} was never used, closing directly`);
+            return this.#close();
+        }
         this.#isClosing = true;
 
         if (this.#receivedMessageToAck !== undefined) {
@@ -669,7 +678,10 @@ export class MessageExchange {
             try {
                 await this.sendStandaloneAckForMessage(messageToAck);
             } catch (error) {
-                logger.error("An error happened when closing the exchange", error);
+                logger.error(
+                    `An error happened when closing the exchange ${this.session.name} / ${this.#exchangeId}`,
+                    error,
+                );
             }
             if (force) {
                 // We have sent the Ack, so close here, no retries because close is forced

package/dist/cjs/interaction/ServerSubscription.d.ts

@@ -1,116 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { NumberedOccurrence } from "#events/Occurrence.js";
-import { MaybePromise } from "#general";
-import { PeerAddress } from "#peer/PeerAddress.js";
-import type { MessageExchange } from "#protocol/MessageExchange.js";
-import { SecureSession } from "#session/SecureSession.js";
-import { TlvEventFilter, TlvSchema, TypeFromSchema } from "#types";
-import { AnyAttributeServer } from "../cluster/server/AttributeServer.js";
-import { AnyEventServer } from "../cluster/server/EventServer.js";
-import { AttributePath, EventPath, InteractionEndpointStructure } from "./InteractionEndpointStructure.js";
-import { InteractionServerMessenger } from "./InteractionMessenger.js";
-import { Subscription, SubscriptionCriteria } from "./Subscription.js";
-export declare const MAX_INTERVAL_PUBLISHER_LIMIT_S: number; /** 1 hour */
-export declare const INTERNAL_INTERVAL_PUBLISHER_LIMIT_S: number; /** 3 min */
-export declare const MIN_INTERVAL_S = 2;
-export declare const DEFAULT_RANDOMIZATION_WINDOW_S = 10;
-/**
- * Server options that control subscription handling.
- */
-export interface ServerSubscriptionConfig {
-    /**
-     * Optional maximum subscription interval to use for sending subscription reports. It will be used if not too
-     * low and inside the range requested by the connected controller.
-     */
-    maxIntervalSeconds: number;
-    /**
-     * Optional minimum subscription interval to use for sending subscription reports. It will be used when other
-     * calculated values are smaller than it. Use this to make sure your device hardware can handle the load and to
-     * set limits.
-     */
-    minIntervalSeconds: number;
-    /**
-     * Optional subscription randomization window to use for sending subscription reports. This specifies a window
-     * in seconds from which a random part is added to the calculated maximum interval to make sure that devices
-     * that get powered on in parallel not all send at the same timepoint.
-     */
-    randomizationWindowSeconds: number;
-}
-export declare namespace ServerSubscriptionConfig {
-    /**
-     * Validate options and set defaults.
-     *
-     * @returns the resulting options
-     */
-    function of(options?: Partial<ServerSubscriptionConfig>): {
-        maxIntervalSeconds: number;
-        minIntervalSeconds: number;
-        randomizationWindowSeconds: number;
-    };
-}
-/**
- * Interface between {@link ServerSubscription} and the local Matter environment.
- */
-export interface ServerSubscriptionContext {
-    session: SecureSession;
-    structure: InteractionEndpointStructure;
-    readAttribute(path: AttributePath, attribute: AnyAttributeServer<unknown>, offline?: boolean): {
-        version: number;
-        value: unknown;
-    };
-    readEndpointAttributesForSubscription(attributes: {
-        path: AttributePath;
-        attribute: AnyAttributeServer<unknown>;
-        offline?: boolean;
-    }[]): {
-        path: AttributePath;
-        attribute: AnyAttributeServer<unknown>;
-        version: number;
-        value: unknown;
-    }[];
-    readEvent(path: EventPath, event: AnyEventServer<any, any>, eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined): Promise<NumberedOccurrence[]>;
-    initiateExchange(address: PeerAddress, protocolId: number): MessageExchange;
-}
-/**
- * Implements the server side of a single subscription.
- */
-export declare class ServerSubscription extends Subscription {
-    #private;
-    constructor(options: {
-        id: number;
-        context: ServerSubscriptionContext;
-        criteria: SubscriptionCriteria;
-        minIntervalFloorSeconds: number;
-        maxIntervalCeilingSeconds: number;
-        subscriptionOptions: ServerSubscriptionConfig;
-        useAsMaxInterval?: number;
-        useAsSendInterval?: number;
-    });
-    unregisterAttributeListeners(list: Array<string>): void;
-    unregisterEventListeners(list: Array<string>): void;
-    /**
-     * Update the session after an endpoint structure change. The method will initialize all missing new attributes and
-     * events and will remove listeners no longer needed.
-     * Newly added attributes are then treated as "changed values" and will be sent as subscription data update to the
-     * controller. The data of newly added events are not sent automatically.
-     */
-    updateSubscription(): Promise<void>;
-    get sendInterval(): number;
-    get minIntervalFloorSeconds(): number;
-    get maxIntervalCeilingSeconds(): number;
-    activate(): void;
-    sendInitialReport(messenger: InteractionServerMessenger): Promise<void>;
-    attributeChangeListener<T>(path: AttributePath, schema: TlvSchema<T>, version: number, value: T): void;
-    attributeChangeHandler<T>(path: AttributePath, schema: TlvSchema<T>, version: number, value: T): MaybePromise<void>;
-    eventChangeListener<T>(path: EventPath, schema: TlvSchema<T>, newEvent: NumberedOccurrence): void;
-    protected destroy(): Promise<void>;
-    /**
-     * Closes the subscription and flushes all outstanding data updates if requested.
-     */
-    close(graceful?: boolean, cancelledByPeer?: boolean): Promise<void>;
-}
-//# sourceMappingURL=ServerSubscription.d.ts.map

package/dist/cjs/interaction/ServerSubscription.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerSubscription.d.ts","sourceRoot":"","sources":["../../../src/interaction/ServerSubscription.ts"],"names":[],"mappings":"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"}