@matter/node 0.16.0-alpha.0-20251205-dfb1e1556 → 0.16.0-alpha.0-20251209-d6072d23e

package/dist/cjs/node/server/ServerSubscription.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,6 +20,47 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 var ServerSubscription_exports = {};
 __export(ServerSubscription_exports, {
   DEFAULT_RANDOMIZATION_WINDOW: () => DEFAULT_RANDOMIZATION_WINDOW,
@@ -53,15 +98,18 @@ var ServerSubscriptionConfig;
   }
   ServerSubscriptionConfig2.of = of;
 })(ServerSubscriptionConfig || (ServerSubscriptionConfig = {}));
-class ServerSubscription extends import_protocol.Subscription {
+class ServerSubscription {
+  #lifetime;
   #context;
+  #id;
+  #isClosed = false;
+  #isCanceledByPeer = false;
+  #request;
+  #cancelled = (0, import_general.AsyncObservable)();
+  #maxInterval;
   #lastUpdateTime = import_general.Timestamp.zero;
   #updateTimer;
-  #sendDelayTimer = import_general.Time.getTimer(
-    `Subscription ${this.id} delay`,
-    (0, import_general.Millis)(50),
-    () => this.#triggerSendUpdate()
-  );
+  #sendDelayTimer;
   #outstandingAttributeUpdates;
   #outstandingEventsMinNumber;
   #changeHandlers = new import_general.ObserverGroup();
@@ -69,28 +117,16 @@ class ServerSubscription extends import_protocol.Subscription {
   #seededClusterDetails = /* @__PURE__ */ new Map();
   #latestSeededEventNumber = (0, import_types.EventNumber)(0);
   #sendInterval;
-  #minIntervalFloor;
-  #maxIntervalCeiling;
   #peerAddress;
   #sendNextUpdateImmediately = false;
   #sendUpdateErrorCounter = 0;
   #currentUpdatePromise;
   constructor(options) {
-    const {
-      id,
-      context,
-      criteria,
-      minIntervalFloor,
-      maxIntervalCeiling,
-      subscriptionOptions,
-      useAsMaxInterval,
-      useAsSendInterval
-    } = options;
-    super(context.session, id, criteria);
+    const { id, context, request, subscriptionOptions, useAsMaxInterval, useAsSendInterval } = options;
+    this.#id = id;
+    this.#request = request;
     this.#context = context;
     this.#peerAddress = this.session.peerAddress;
-    this.#minIntervalFloor = minIntervalFloor;
-    this.#maxIntervalCeiling = maxIntervalCeiling;
     let maxInterval;
     let sendInterval;
     if (useAsMaxInterval !== void 0 && useAsSendInterval !== void 0) {
@@ -105,12 +141,60 @@ class ServerSubscription extends import_protocol.Subscription {
     }
     this.maxInterval = maxInterval;
     this.#sendInterval = sendInterval;
+    this.#sendDelayTimer = import_general.Time.getTimer(
+      `Subscription ${this.idStr} delay`,
+      (0, import_general.Millis)(50),
+      () => this.#triggerSendUpdate()
+    );
     this.#updateTimer = import_general.Time.getTimer(
-      `Subscription ${this.id} update`,
+      `Subscription ${this.idStr} update`,
       this.#sendInterval,
       () => this.#prepareDataUpdate()
     );
   }
+  get subscriptionId() {
+    return this.#id;
+  }
+  get idStr() {
+    return import_general.hex.fixed(this.#id, 8);
+  }
+  get session() {
+    return this.#context.session;
+  }
+  get isCanceledByPeer() {
+    return this.#isCanceledByPeer;
+  }
+  get request() {
+    return this.#request;
+  }
+  get cancelled() {
+    return this.#cancelled;
+  }
+  get maxInterval() {
+    if (this.#maxInterval === void 0) {
+      throw new import_general.InternalError("Subscription maxInterval accessed before it was set");
+    }
+    return this.#maxInterval;
+  }
+  get sendInterval() {
+    return this.#sendInterval;
+  }
+  get minIntervalFloor() {
+    return (0, import_general.Seconds)(this.request.minIntervalFloorSeconds);
+  }
+  get maxIntervalCeiling() {
+    return (0, import_general.Seconds)(this.request.maxIntervalCeilingSeconds);
+  }
+  set maxInterval(value) {
+    if (this.#maxInterval !== void 0) {
+      throw new import_general.InternalError("Subscription maxInterval set twice");
+    }
+    this.#maxInterval = value;
+  }
+  async handlePeerCancel() {
+    this.#isCanceledByPeer = true;
+    await this.close();
+  }
   #determineSendingIntervals(subscriptionMinInterval, subscriptionMaxInterval, subscriptionRandomizationWindow) {
     const maxInterval = import_general.Duration.min(
       import_general.Millis.floor(
@@ -118,8 +202,8 @@ class ServerSubscription extends import_protocol.Subscription {
           import_general.Duration.max(
             subscriptionMinInterval,
             import_general.Duration.max(
-              this.#minIntervalFloor,
-              import_general.Duration.min(subscriptionMaxInterval, this.#maxIntervalCeiling)
+              this.minIntervalFloor,
+              import_general.Duration.min(subscriptionMaxInterval, this.maxIntervalCeiling)
             )
           ) + subscriptionRandomizationWindow * Math.random()
         )
@@ -128,7 +212,7 @@ class ServerSubscription extends import_protocol.Subscription {
     );
     let sendInterval = import_general.Millis.floor((0, import_general.Millis)(maxInterval / 2));
     if (sendInterval < import_general.Minutes.one) {
-      sendInterval = import_general.Duration.max(this.#minIntervalFloor, import_general.Millis.floor((0, import_general.Millis)(maxInterval * 0.8)));
+      sendInterval = import_general.Duration.max(this.minIntervalFloor, import_general.Millis.floor((0, import_general.Millis)(maxInterval * 0.8)));
     }
     if (sendInterval < subscriptionMinInterval) {
       logger.warn(
@@ -150,7 +234,7 @@ class ServerSubscription extends import_protocol.Subscription {
     }
   }
   #handleClusterStateChanges(endpointId, clusterId, changedAttrs, version) {
-    if (this.isClosed || !changedAttrs.length) {
+    if (this.#isClosed || !changedAttrs.length) {
       return;
     }
     if (this.#seededClusterDetails !== void 0) {
@@ -163,7 +247,7 @@ class ServerSubscription extends import_protocol.Subscription {
     this.#prepareDataUpdate();
   }
   #handleAddedEvents(occurrence) {
-    if (this.isClosed) {
+    if (this.#isClosed) {
       return;
     }
     if (this.#outstandingEventsMinNumber === void 0 || this.#latestSeededEventNumber !== void 0) {
@@ -174,23 +258,16 @@ class ServerSubscription extends import_protocol.Subscription {
     }
   }
   #sendEventUrgently({ endpointId, clusterId, eventId }) {
-    return (this.criteria.eventRequests ?? []).some(
+    return (this.request.eventRequests ?? []).some(
       ({ endpointId: reqEndpointId, clusterId: reqClusterId, eventId: reqEventId, isUrgent }) => isUrgent && (reqEndpointId === void 0 || reqEndpointId === endpointId) && (reqClusterId === void 0 || reqClusterId === clusterId) && (reqEventId === void 0 || reqEventId === eventId)
     );
   }
-  get sendInterval() {
-    return this.#sendInterval;
-  }
-  get minIntervalFloor() {
-    return this.#minIntervalFloor;
-  }
-  get maxIntervalCeiling() {
-    return this.#maxIntervalCeiling;
-  }
   activate() {
-    super.activate();
-    if (this.criteria.eventFilters !== void 0) this.criteria.eventFilters.length = 0;
-    if (this.criteria.dataVersionFilters !== void 0) this.criteria.dataVersionFilters.length = 0;
+    this.session.subscriptions.add(this);
+    logger.debug(this.session.via, "New subscription", import_general.Diagnostic.strong(this.idStr));
+    this.#lifetime = this.#context.session.join("subscription", import_general.Diagnostic.strong(this.#id));
+    if (this.request.eventFilters !== void 0) this.request.eventFilters.length = 0;
+    if (this.request.dataVersionFilters !== void 0) this.request.dataVersionFilters.length = 0;
     this.#sendUpdatesActivated = true;
     if (this.#outstandingEventsMinNumber !== void 0 && this.#latestSeededEventNumber !== void 0) {
       if (this.#latestSeededEventNumber < this.#outstandingEventsMinNumber) {
@@ -215,7 +292,7 @@ class ServerSubscription extends import_protocol.Subscription {
    * sending by 50ms in any case to make sure to catch all updates.
    */
   #prepareDataUpdate() {
-    if (this.#sendDelayTimer.isRunning || this.isClosed) {
+    if (this.#sendDelayTimer.isRunning || this.#isClosed) {
       return;
     }
     if (!this.#sendUpdatesActivated) {
@@ -224,87 +301,114 @@ class ServerSubscription extends import_protocol.Subscription {
     this.#updateTimer.stop();
     const now = import_general.Time.nowMs;
     const timeSinceLastUpdate = (0, import_general.Millis)(now - this.#lastUpdateTime);
-    if (timeSinceLastUpdate < this.#minIntervalFloor) {
+    if (timeSinceLastUpdate < this.minIntervalFloor) {
       this.#updateTimer = import_general.Time.getTimer(
         "Subscription update",
-        (0, import_general.Millis)(this.#minIntervalFloor - timeSinceLastUpdate),
+        (0, import_general.Millis)(this.minIntervalFloor - timeSinceLastUpdate),
         () => this.#prepareDataUpdate()
       ).start();
       return;
     }
     this.#sendDelayTimer.start();
     this.#updateTimer = import_general.Time.getTimer(
-      `Subscription update ${this.id}`,
+      `Subscription update ${this.idStr}`,
       this.#sendInterval,
       () => this.#prepareDataUpdate()
     ).start();
   }
-  #triggerSendUpdate(onlyWithData = false) {
+  #triggerSendUpdate(onlyWithData = false, session) {
     if (this.#currentUpdatePromise !== void 0) {
       logger.debug("Sending update already in progress, delaying update ...");
       this.#sendNextUpdateImmediately = true;
       return;
     }
-    this.#currentUpdatePromise = this.#sendUpdate(onlyWithData).catch((error) => logger.warn("Sending subscription update failed:", error)).finally(() => this.#currentUpdatePromise = void 0);
+    this.#currentUpdatePromise = this.#sendUpdate(onlyWithData, session).catch((error) => logger.warn("Sending subscription update failed:", error)).finally(() => this.#currentUpdatePromise = void 0);
   }
   /**
    * Determine all attributes that have changed since the last update and send them out to the subscriber.
    */
-  async #sendUpdate(onlyWithData = false) {
-    const attributeFilter = this.#outstandingAttributeUpdates;
-    this.#outstandingAttributeUpdates = void 0;
-    const eventsMinNumber = this.#outstandingEventsMinNumber;
-    this.#outstandingEventsMinNumber = void 0;
-    if (onlyWithData && attributeFilter === void 0 && eventsMinNumber === void 0) {
-      return;
-    }
-    this.#lastUpdateTime = import_general.Time.nowMs;
+  async #sendUpdate(onlyWithData = false, session) {
+    var _stack3 = [];
     try {
-      if (await this.#sendUpdateMessage(attributeFilter, eventsMinNumber, onlyWithData)) {
-        this.#sendUpdateErrorCounter = 0;
-      }
-    } catch (error) {
-      if (this.isClosed) {
-        return;
-      }
-      this.#sendUpdateErrorCounter++;
-      logger.info(
-        `Error sending subscription update message (error count=${this.#sendUpdateErrorCounter}):`,
-        error instanceof import_general.MatterError && error.message || error
-      );
-      if (this.#sendUpdateErrorCounter <= 2) {
-        if (attributeFilter !== void 0) {
-          for (const [endpointId, clusters] of Object.entries(attributeFilter)) {
-            for (const [clusterId, attributes] of Object.entries(clusters)) {
-              this.#addOutstandingAttributes(
-                (0, import_types.EndpointNumber)(parseInt(endpointId)),
-                (0, import_types.ClusterId)(parseInt(clusterId)),
-                Array.from(attributes)
-              );
+      const updating = __using(_stack3, this.#lifetime?.join("updating"));
+      while (true) {
+        const attributeFilter = this.#outstandingAttributeUpdates;
+        this.#outstandingAttributeUpdates = void 0;
+        const eventsMinNumber = this.#outstandingEventsMinNumber;
+        this.#outstandingEventsMinNumber = void 0;
+        if (onlyWithData && attributeFilter === void 0 && eventsMinNumber === void 0) {
+          break;
+        }
+        this.#lastUpdateTime = import_general.Time.nowMs;
+        try {
+          var _stack = [];
+          try {
+            const sending = __using(_stack, updating?.join("sending"));
+            if (await this.#sendUpdateMessage(sending, attributeFilter, eventsMinNumber, onlyWithData, session)) {
+              this.#sendUpdateErrorCounter = 0;
+            }
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            __callDispose(_stack, _error, _hasError);
+          }
+        } catch (error) {
+          if (this.#isClosed) {
+            return;
+          }
+          this.#sendUpdateErrorCounter++;
+          logger.info(
+            `Error sending subscription update message (error count=${this.#sendUpdateErrorCounter}):`,
+            error instanceof import_general.MatterError && error.message || error
+          );
+          if (this.#sendUpdateErrorCounter <= 2) {
+            if (attributeFilter !== void 0) {
+              for (const [endpointId, clusters] of Object.entries(attributeFilter)) {
+                for (const [clusterId, attributes] of Object.entries(clusters)) {
+                  this.#addOutstandingAttributes(
+                    (0, import_types.EndpointNumber)(parseInt(endpointId)),
+                    (0, import_types.ClusterId)(parseInt(clusterId)),
+                    Array.from(attributes)
+                  );
+                }
+              }
+            }
+            if (eventsMinNumber !== void 0) {
+              this.#outstandingEventsMinNumber = eventsMinNumber;
+            }
+          } else {
+            logger.info(
+              `Sending update failed 3 times in a row, canceling subscription ${this.idStr} and let controller subscribe again.`
+            );
+            this.#sendNextUpdateImmediately = false;
+            if (error instanceof import_general.NoResponseTimeoutError || error instanceof import_general.NetworkError || error instanceof import_protocol.SessionClosedError) {
+              var _stack2 = [];
+              try {
+                const _messaging = __using(_stack2, updating?.join("canceling"));
+                this.#isCanceledByPeer = true;
+                await this.#cancel();
+                break;
+              } catch (_2) {
+                var _error2 = _2, _hasError2 = true;
+              } finally {
+                __callDispose(_stack2, _error2, _hasError2);
+              }
+            } else {
+              throw error;
             }
           }
         }
-        if (eventsMinNumber !== void 0) {
-          this.#outstandingEventsMinNumber = eventsMinNumber;
+        if (!this.#sendNextUpdateImmediately) {
+          break;
         }
-      } else {
-        logger.info(
-          `Sending update failed 3 times in a row, canceling subscription ${this.id} and let controller subscribe again.`
-        );
+        logger.debug("Sending delayed update immediately after last one was sent");
         this.#sendNextUpdateImmediately = false;
-        if (error instanceof import_general.NoResponseTimeoutError || error instanceof import_general.NetworkError || error instanceof import_protocol.NoChannelError) {
-          this.isCanceledByPeer = true;
-          await this.destroy();
-          return;
-        } else {
-          throw error;
-        }
+        onlyWithData = true;
       }
-    }
-    if (this.#sendNextUpdateImmediately) {
-      logger.debug("Sending delayed update immediately after last one was sent.");
-      this.#sendNextUpdateImmediately = false;
-      await this.#sendUpdate(true);
+    } catch (_3) {
+      var _error3 = _3, _hasError3 = true;
+    } finally {
+      __callDispose(_stack3, _error3, _hasError3);
     }
   }
   /**
@@ -312,7 +416,7 @@ class ServerSubscription extends import_protocol.Subscription {
    */
   async *#processAttributesAndEventsReport(context, suppressStatusReports = false) {
     const request = {
-      ...this.criteria,
+      ...this.request,
       interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
       // irrelevant here, set to our version
     };
@@ -397,60 +501,85 @@ class ServerSubscription extends import_protocol.Subscription {
   }
   async sendInitialReport(messenger, readContext, suppressStatusReports) {
     this.#updateTimer.stop();
-    if (this.criteria.attributeRequests?.length) {
+    if (this.request.attributeRequests?.length) {
       this.#changeHandlers.on(
         this.#context.node.protocol.attrsChanged,
         this.#handleClusterStateChanges.bind(this)
       );
     }
-    if (this.criteria.eventRequests?.length) {
+    if (this.request.eventRequests?.length) {
       this.#changeHandlers.on(this.#context.node.protocol.eventHandler.added, this.#handleAddedEvents.bind(this));
     }
     await messenger.sendDataReport({
       baseDataReport: {
         suppressResponse: false,
         // we always need proper response for initial report
-        subscriptionId: this.id,
+        subscriptionId: this.subscriptionId,
         interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
       },
-      forFabricFilteredRead: this.criteria.isFabricFiltered,
+      forFabricFilteredRead: this.request.isFabricFiltered,
       payload: this.#processAttributesAndEventsReport(readContext, suppressStatusReports)
     });
   }
-  async #flush() {
+  async #flush(flushViaSession) {
     this.#sendDelayTimer.stop();
     if (this.#outstandingAttributeUpdates !== void 0 || this.#outstandingEventsMinNumber !== void 0) {
-      logger.debug(`Flushing subscription ${this.id}${this.isClosed ? " (for closing)" : ""}`);
-      this.#triggerSendUpdate(true);
+      logger.debug(`Flushing subscription ${this.idStr}${this.#isClosed ? " (for closing)" : ""}`);
+      this.#triggerSendUpdate(true, flushViaSession);
       if (this.#currentUpdatePromise) {
-        await this.#currentUpdatePromise;
+        var _stack = [];
+        try {
+          const _waiting = __using(_stack, this.#lifetime?.join("waiting on flush"));
+          await this.#currentUpdatePromise;
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       }
     }
   }
-  async destroy() {
-    this.#sendUpdatesActivated = false;
-    this.#changeHandlers.close();
-    this.#updateTimer.stop();
-    this.#sendDelayTimer.stop();
-    await super.destroy();
-  }
   /**
    * Closes the subscription and flushes all outstanding data updates if requested.
    */
-  async close(flush = false, cancelledByPeer = false) {
-    if (this.isClosed) {
+  async close(flushViaSession) {
+    if (this.#isClosed) {
       return;
     }
-    if (cancelledByPeer) {
-      this.isCanceledByPeer = true;
-    }
-    await this.destroy();
-    if (flush) {
-      await this.#flush();
-    }
+    this.#isClosed = true;
+    await this.#cancel(flushViaSession);
     if (this.#currentUpdatePromise) {
-      await this.#currentUpdatePromise;
+      var _stack = [];
+      try {
+        const _waiting = __using(_stack, this.#lifetime?.closing()?.join("waiting on update"));
+        await this.#currentUpdatePromise;
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    }
+  }
+  async #cancel(flushViaSession) {
+    const closing = this.#lifetime?.closing();
+    this.#sendUpdatesActivated = false;
+    this.#changeHandlers.close();
+    if (flushViaSession !== void 0) {
+      var _stack = [];
+      try {
+        const _flushing = __using(_stack, closing?.join("flushing"));
+        await this.#flush(flushViaSession);
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
     }
+    this.#updateTimer.stop();
+    this.#sendDelayTimer.stop();
+    this.session.subscriptions.delete(this);
+    logger.debug(this.session.via, "Deleted subscription", import_general.hex.fixed(this.subscriptionId, 8));
+    this.cancelled.emit(this);
   }
   /**
    * Iterates over all attributes and events that have changed since the last update and sends them to
@@ -459,14 +588,13 @@ class ServerSubscription extends import_protocol.Subscription {
    */
   async *#iterateDataUpdate(exchange, attributeFilter, eventsMinNumber) {
     const request = {
-      ...this.criteria,
+      ...this.request,
       interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
       // irrelevant here, set to our version
     };
     const session = (0, import_RemoteActorContext.RemoteActorContext)({
       activity: exchange[import_NodeActivity.NodeActivity.activityKey],
       fabricFiltered: request.isFabricFiltered,
-      message: {},
       exchange,
       node: this.#context.node
     }).beginReadOnly();
@@ -499,50 +627,81 @@ class ServerSubscription extends import_protocol.Subscription {
       session[Symbol.dispose]();
     }
   }
-  async #sendUpdateMessage(attributeFilter, eventsMinNumber, onlyWithData) {
-    const exchange = this.#context.initiateExchange(this.#peerAddress, import_types.INTERACTION_PROTOCOL_ID);
+  async #sendUpdateMessage(lifetime, attributeFilter, eventsMinNumber, onlyWithData, session) {
+    const exchange = this.#context.initiateExchange(session ?? this.#peerAddress, import_types.INTERACTION_PROTOCOL_ID);
     if (exchange === void 0) return false;
     const messenger = new import_protocol.InteractionServerMessenger(exchange);
     try {
       if (attributeFilter === void 0 && eventsMinNumber === void 0) {
-        await messenger.sendDataReport({
-          baseDataReport: {
-            suppressResponse: true,
-            // suppressResponse true for empty DataReports
-            subscriptionId: this.id,
-            interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
-          },
-          forFabricFilteredRead: this.criteria.isFabricFiltered,
-          waitForAck: !this.isClosed
-          // Do not wait for ack when closed
-        });
+        var _stack = [];
+        try {
+          const _sending = __using(_stack, lifetime?.join("sending keepalive"));
+          await messenger.sendDataReport({
+            baseDataReport: {
+              suppressResponse: true,
+              // suppressResponse true for empty DataReports
+              subscriptionId: this.subscriptionId,
+              interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+            },
+            forFabricFilteredRead: this.request.isFabricFiltered,
+            waitForAck: !this.#isClosed
+            // Do not wait for ack when closed
+          });
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       } else {
-        await messenger.sendDataReport({
-          baseDataReport: {
-            suppressResponse: false,
-            // Non-empty data reports always need to send response
-            subscriptionId: this.id,
-            interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
-          },
-          forFabricFilteredRead: this.criteria.isFabricFiltered,
-          payload: this.#iterateDataUpdate(exchange, attributeFilter, eventsMinNumber),
-          waitForAck: !this.isClosed,
-          // Do not wait for ack when closed
-          suppressEmptyReport: onlyWithData
-        });
+        var _stack2 = [];
+        try {
+          const _sending = __using(_stack2, lifetime?.join("sending data"));
+          await messenger.sendDataReport({
+            baseDataReport: {
+              suppressResponse: false,
+              // Non-empty data reports always need to send response
+              subscriptionId: this.subscriptionId,
+              interactionModelRevision: import_model.Specification.INTERACTION_MODEL_REVISION
+            },
+            forFabricFilteredRead: this.request.isFabricFiltered,
+            payload: this.#iterateDataUpdate(exchange, attributeFilter, eventsMinNumber),
+            waitForAck: !this.#isClosed,
+            // Do not wait for ack when closed
+            suppressEmptyReport: onlyWithData
+          });
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
       }
     } catch (error) {
-      if (import_types.StatusResponseError.is(error, import_types.StatusCode.InvalidSubscription, import_types.StatusCode.Failure)) {
-        logger.info(`Subscription ${this.id} cancelled by peer.`);
-        this.isCanceledByPeer = true;
-        await this.close(false);
-      } else {
-        import_types.StatusResponseError.accept(error);
-        logger.info(`Subscription ${this.id} update failed:`, error);
-        await this.close(false);
+      var _stack3 = [];
+      try {
+        if (import_types.StatusResponseError.is(error, import_types.StatusCode.InvalidSubscription, import_types.StatusCode.Failure)) {
+          logger.info(`Subscription ${this.idStr} cancelled by peer`);
+          this.#isCanceledByPeer = true;
+        } else {
+          import_types.StatusResponseError.accept(error);
+          logger.info(`Subscription ${this.idStr} update failed:`, error);
+        }
+        const _canceling = __using(_stack3, lifetime?.join("canceling"));
+        await this.#cancel();
+      } catch (_3) {
+        var _error3 = _3, _hasError3 = true;
+      } finally {
+        __callDispose(_stack3, _error3, _hasError3);
       }
     } finally {
-      await messenger.close();
+      var _stack4 = [];
+      try {
+        const _closing = __using(_stack4, lifetime?.join("closing messenger"));
+        await messenger.close();
+      } catch (_4) {
+        var _error4 = _4, _hasError4 = true;
+      } finally {
+        __callDispose(_stack4, _error4, _hasError4);
+      }
     }
     return true;
   }