@matter/protocol 0.17.0-alpha.0-20260507-059f7763b → 0.17.0-alpha.0-20260508-29ff5ae9e

package/dist/esm/action/client/ClientInteraction.js

@@ -1,935 +0,0 @@
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-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();
-};
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Invoke } from "#action/request/Invoke.js";
-import { Read } from "#action/request/Read.js";
-import { resolvePathForSpecifier } from "#action/request/Specifier.js";
-import { BdxMessenger } from "#bdx/BdxMessenger.js";
-import { Mark } from "#common/Mark.js";
-import { InteractionClientMessenger, MessageType } from "#interaction/InteractionMessenger.js";
-import { Subscription } from "#interaction/Subscription.js";
-import { PeerAddress } from "#peer/PeerAddress.js";
-import { ExchangeProvider } from "#protocol/ExchangeProvider.js";
-import {
-  Abort,
-  AbortedError,
-  AsyncIterator,
-  BasicSet,
-  ChannelType,
-  ClosedError,
-  createPromise,
-  Diagnostic,
-  Duration,
-  Entropy,
-  Forever,
-  ImplementationError,
-  Instant,
-  isObject,
-  Logger,
-  Minutes,
-  Mutex,
-  RetrySchedule,
-  Seconds,
-  Time
-} from "@matter/general";
-import { Status, TlvOfModel, TlvSubscribeResponse } from "@matter/types";
-import { TlvVoid } from "@matter/types/tlv";
-import { InputChunk } from "./InputChunk.js";
-import { ClientSubscriptions } from "./subscription/ClientSubscriptions.js";
-import { PeerSubscription } from "./subscription/PeerSubscription.js";
-import { SustainedSubscription } from "./subscription/SustainedSubscription.js";
-const logger = Logger.get("ClientInteraction");
-const MAX_COMMAND_REF = 65535;
-const SUBSCRIPTION_PROCESSING_TIME = Seconds(10);
-const DEFAULT_MIN_INTERVAL_FLOOR = Seconds(1);
-const SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT = Minutes(60);
-const DEFAULT_TIMED_REQUEST_TIMEOUT = Seconds(10);
-const DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE = Seconds(30);
-class ClientInteraction {
-  #environment;
-  #lifetime;
-  #exchangeProvider;
-  #interactions = new BasicSet();
-  #subscriptions;
-  #abort;
-  #sustainRetries;
-  #address;
-  #network;
-  // Command batching state
-  #pendingCommands = /* @__PURE__ */ new Map();
-  #batchMutex;
-  #batchTimer;
-  #nextCommandRef = 1;
-  constructor({ environment, abort, sustainRetries, exchangeProvider, address, network }) {
-    this.#environment = environment;
-    this.#exchangeProvider = exchangeProvider ?? environment.get(ExchangeProvider);
-    if (environment.has(ClientSubscriptions)) {
-      this.#subscriptions = environment.get(ClientSubscriptions);
-    }
-    this.#abort = Abort.subtask(abort);
-    this.#sustainRetries = new RetrySchedule(
-      environment.get(Entropy),
-      RetrySchedule.Configuration(SustainedSubscription.DefaultRetrySchedule, sustainRetries)
-    );
-    this.#address = address;
-    this.#batchMutex = new Mutex(this);
-    this.#network = network;
-    this.#lifetime = environment.join("interactions");
-    Object.defineProperties(this.#lifetime.details, {
-      "# active": {
-        get: () => {
-          return this.#interactions.size;
-        },
-        enumerable: true
-      }
-    });
-  }
-  async close(reason) {
-    var _stack = [];
-    try {
-      if (reason === void 0) {
-        reason = new ClosedError("Interaction component closed");
-      }
-      const _closing = __using(_stack, this.#lifetime.closing());
-      this.#batchTimer?.stop();
-      for (const [, pending] of this.#pendingCommands) {
-        pending.cleanup?.();
-        pending.reject(reason);
-      }
-      this.#pendingCommands.clear();
-      await this.#batchMutex.close();
-      this.#abort(reason);
-      while (this.#interactions.size) {
-        await this.#interactions.deleted;
-      }
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  }
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-  get subscriptions() {
-    if (this.#subscriptions === void 0) {
-      this.#subscriptions = this.#environment.get(ClientSubscriptions);
-    }
-    return this.#subscriptions;
-  }
-  /**
-   * Read attributes and events.
-   */
-  async *read(request, session, extraAbort) {
-    var _stack = [];
-    try {
-      const readPathsCount = (request.attributeRequests?.length ?? 0) + (request.eventRequests?.length ?? 0);
-      if (readPathsCount > 9) {
-        logger.info(
-          "Read interactions with more than 9 paths might be not allowed by the device. Consider splitting them into several read requests."
-        );
-      }
-      const context = __using(_stack, await this.#begin("reading", request, session, extraAbort), true);
-      const { abort, messenger } = context;
-      logger.info("Read", Mark.OUTBOUND, messenger.exchange.via, session?.logContext ?? "", request);
-      await messenger.sendReadRequest(request, { abort });
-      let attributeReportCount = 0;
-      let eventReportCount = 0;
-      const leftOverData = new Array();
-      for await (const report of messenger.readDataReports({ abort })) {
-        attributeReportCount += report.attributeReports?.length ?? 0;
-        eventReportCount += report.eventReports?.length ?? 0;
-        yield InputChunk(report, leftOverData);
-        abort.throwIfAborted();
-      }
-      logger.info(
-        "Read",
-        Mark.INBOUND,
-        messenger.exchange.via,
-        messenger.exchange.diagnostics,
-        Diagnostic.weak(
-          attributeReportCount + eventReportCount === 0 ? "(empty)" : Diagnostic.dict({ attributes: attributeReportCount, events: eventReportCount })
-        )
-      );
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise = __callDispose(_stack, _error, _hasError);
-      _promise && await _promise;
-    }
-  }
-  /**
-   * Probe the peer with an empty read to verify session liveness.
-   *
-   * Optionally sends to a different address than the session's current one via {@link addressOverride},
-   * without affecting other exchanges on the session.
-   *
-   * @returns true if the probe succeeded, false otherwise
-   */
-  async probe(options) {
-    if (this.#abort.aborted) {
-      return false;
-    }
-    const abort = new Abort({ abort: [options?.abort, this.#abort] });
-    let messenger;
-    try {
-      messenger = await InteractionClientMessenger.create(this.#exchangeProvider, {
-        network: options?.network ?? this.#network,
-        abort,
-        addressOverride: options?.addressOverride,
-        requireExistingSession: true
-      });
-    } catch {
-      abort[Symbol.dispose]();
-      return false;
-    }
-    logger.info("Probe", Mark.OUTBOUND, messenger.exchange.via);
-    try {
-      await messenger.sendReadRequest(Read({ fabricFilter: false }), {
-        abort,
-        suppressPeerLoss: options?.suppressPeerLoss
-      });
-      for await (const _report of messenger.readDataReports({ abort })) ;
-      logger.info(
-        "Probe",
-        Mark.INBOUND,
-        messenger.exchange.via,
-        messenger.exchange.diagnostics,
-        Diagnostic.weak("(success)")
-      );
-      return true;
-    } catch {
-      if (!abort.aborted) {
-        logger.info(
-          "Probe",
-          Mark.INBOUND,
-          messenger.exchange.via,
-          messenger.exchange.diagnostics,
-          Diagnostic.weak("(failed)")
-        );
-      }
-      return false;
-    } finally {
-      await messenger.close();
-      abort[Symbol.dispose]();
-    }
-  }
-  /**
-   * Write to node attributes.
-   */
-  async write(request, session) {
-    var _stack = [];
-    try {
-      const context = __using(_stack, await this.#begin("writing", request, session), true);
-      const { abort, messenger } = context;
-      if (request.timedRequest) {
-        await messenger.sendTimedRequest(request.timeout ?? DEFAULT_TIMED_REQUEST_TIMEOUT, { abort });
-      }
-      logger.info("Write", Mark.OUTBOUND, messenger.exchange.via, request);
-      const response = await messenger.sendWriteCommand(request, session);
-      if (request.suppressResponse) {
-        return void 0;
-      }
-      if (!response || !response.writeResponses?.length) {
-        return [];
-      }
-      let successCount = 0;
-      let failureCount = 0;
-      const result = response.writeResponses.map(
-        ({
-          path: { nodeId, endpointId, clusterId, attributeId, listIndex },
-          status: { status, clusterStatus }
-        }) => {
-          if (status === Status.Success) {
-            successCount++;
-          } else {
-            failureCount++;
-          }
-          return {
-            kind: "attr-status",
-            path: {
-              nodeId,
-              endpointId,
-              clusterId,
-              attributeId,
-              listIndex
-            },
-            status,
-            clusterStatus
-          };
-        }
-      );
-      logger.info(
-        "Write",
-        Mark.INBOUND,
-        messenger.exchange.via,
-        messenger.exchange.diagnostics,
-        Diagnostic.weak(
-          successCount + failureCount === 0 ? "(empty)" : Diagnostic.dict({ success: successCount, failure: failureCount })
-        )
-      );
-      return result;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise = __callDispose(_stack, _error, _hasError);
-      _promise && await _promise;
-    }
-  }
-  /**
-   * Invoke a single batch of commands (internal implementation).
-   */
-  async *#invokeSingle(request, session) {
-    var _stack = [];
-    try {
-      const context = __using(_stack, await this.#begin("invoking", request, session), true);
-      const { abort, messenger } = context;
-      if (request.timedRequest) {
-        await messenger.sendTimedRequest(request.timeout ?? DEFAULT_TIMED_REQUEST_TIMEOUT, { abort });
-      }
-      logger.info(
-        "Invoke",
-        Mark.OUTBOUND,
-        messenger.exchange.via,
-        Diagnostic.asFlags({ suppressResponse: request.suppressResponse, timed: request.timedRequest }),
-        request
-      );
-      const { expectedProcessingTime, useExtendedFailSafeMessageResponseTimeout } = request;
-      const result = await messenger.sendInvokeCommand(request, {
-        expectedProcessingTime: expectedProcessingTime ?? (useExtendedFailSafeMessageResponseTimeout ? DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE : void 0),
-        abort
-      });
-      if (!request.suppressResponse) {
-        if (result && result.invokeResponses?.length) {
-          const chunk = result.invokeResponses.map((response) => {
-            if (response.command !== void 0) {
-              const {
-                commandPath: { endpointId, clusterId, commandId },
-                commandRef,
-                commandFields
-              } = response.command;
-              const cmd = request.commands.get(commandRef);
-              if (!cmd) {
-                throw new ImplementationError(
-                  `No response schema found for commandRef ${commandRef} (endpoint ${endpointId}, cluster ${clusterId}, command ${commandId})`
-                );
-              }
-              let responseSchema;
-              if (Invoke.isLegacy(cmd)) {
-                responseSchema = cmd.command.responseSchema ?? TlvVoid;
-              } else {
-                const command = Invoke.commandOf(cmd);
-                const responseModel = command.schema.responseModel;
-                responseSchema = responseModel ? TlvOfModel(responseModel) ?? TlvVoid : TlvVoid;
-              }
-              if (commandFields === void 0 && responseSchema !== TlvVoid) {
-                throw new ImplementationError(
-                  `No command fields found for commandRef ${commandRef} (endpoint ${endpointId}, cluster ${clusterId}, command ${commandId})`
-                );
-              }
-              const data = commandFields === void 0 ? void 0 : responseSchema?.decodeTlv(commandFields);
-              logger.info(
-                "Invoke",
-                Mark.INBOUND,
-                messenger.exchange.via,
-                messenger.exchange.diagnostics,
-                Diagnostic.strong(Invoke.isLegacy(cmd) ? "(legacy)" : resolvePathForSpecifier(cmd)),
-                isObject(data) ? Diagnostic.dict(data) : Diagnostic.weak("(no payload)")
-              );
-              const res = {
-                kind: "cmd-response",
-                path: {
-                  endpointId,
-                  clusterId,
-                  commandId
-                },
-                commandRef,
-                data
-              };
-              return res;
-            } else if (response.status !== void 0) {
-              const {
-                commandPath: { endpointId, clusterId, commandId },
-                commandRef,
-                status: { status, clusterStatus }
-              } = response.status;
-              const res = {
-                kind: "cmd-status",
-                path: {
-                  endpointId,
-                  clusterId,
-                  commandId
-                },
-                commandRef,
-                status,
-                clusterStatus
-              };
-              const cmd = request.commands.get(commandRef);
-              if (cmd) {
-                logger.info(
-                  "Invoke",
-                  Mark.INBOUND,
-                  messenger.exchange.via,
-                  messenger.exchange.diagnostics,
-                  Diagnostic.strong(Invoke.isLegacy(cmd) ? "(legacy)" : resolvePathForSpecifier(cmd)),
-                  Diagnostic.dict({ status: `${Status[status]} (${status})`, clusterStatus })
-                );
-              }
-              return res;
-            } else {
-              return void 0;
-            }
-          }).filter((r) => r !== void 0);
-          yield chunk;
-        } else {
-          yield [];
-        }
-        abort.throwIfAborted();
-      }
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise = __callDispose(_stack, _error, _hasError);
-      _promise && await _promise;
-    }
-  }
-  /**
-   * Split commands across multiple parallel invoke-exchanges.
-   * Results are streamed as they arrive from any batch, not buffered.
-   */
-  async *#invokeWithSplitting(request, maxPathsPerInvoke, session) {
-    const allCommands = [...request.commands.entries()];
-    const batches = new Array();
-    for (let i = 0; i < allCommands.length; i += maxPathsPerInvoke) {
-      const batchEntries = allCommands.slice(i, i + maxPathsPerInvoke);
-      batches.push(new Map(batchEntries));
-    }
-    const iterators = batches.map((batchCommands) => {
-      const batchInvokeRequests = request.invokeRequests.filter((ir) => batchCommands.has(ir.commandRef));
-      const batchRequest = {
-        ...request,
-        commands: batchCommands,
-        invokeRequests: batchInvokeRequests,
-        [Diagnostic.value]: () => Diagnostic.list(
-          [...batchCommands.values()].map((cmd) => {
-            const { commandRef } = cmd;
-            const fields = "fields" in cmd ? cmd.fields : void 0;
-            return [
-              Diagnostic.strong(Invoke.isLegacy(cmd) ? "(legacy)" : resolvePathForSpecifier(cmd)),
-              "with",
-              isObject(fields) ? Diagnostic.dict(fields) : "(no payload)",
-              commandRef !== void 0 ? `(ref ${commandRef})` : ""
-            ];
-          })
-        )
-      };
-      return this.#invokeSingle(batchRequest, session);
-    });
-    yield* AsyncIterator.merge(iterators, "One or more invoke batches failed");
-  }
-  /**
-   * Invoke one or more commands.
-   *
-   * When the number of commands exceeds the peer's MaxPathsPerInvoke limit (or 1 for older nodes),
-   * commands are split across multiple parallel exchanges automatically.
-   *
-   * Single commands are automatically batched with other commands invoked in the same timer tick
-   * when the device supports multiple invokes per exchange and the target is not endpoint 0.
-   */
-  async *invoke(request, session) {
-    if (request.largeMessage) {
-      yield* this.#invokeSingle(request, session);
-      return;
-    }
-    const maxPathsPerInvoke = this.#exchangeProvider.maxPathsPerInvoke ?? 1;
-    if (request.invokeRequests.length === 1 && request.batchDuration !== false && maxPathsPerInvoke) {
-      const endpointId = request.invokeRequests[0].commandPath.endpointId;
-      if (endpointId !== void 0 && endpointId !== 0 && !request.timedRequest) {
-        yield* this.#invokeWithBatching(request, session);
-        return;
-      }
-    }
-    const commandCount = request.commands.size;
-    if (commandCount > maxPathsPerInvoke) {
-      yield* this.#invokeWithSplitting(request, maxPathsPerInvoke, session);
-    } else {
-      yield* this.#invokeSingle(request, session);
-    }
-  }
-  /**
-   * Queue a single command for batched execution.
-   * Yields the raw response entry when the batch completes.
-   */
-  async *#invokeWithBatching(request, session) {
-    if (this.#abort.aborted) {
-      throw new ImplementationError("Client interaction unavailable after close");
-    }
-    await this.#exchangeProvider.connect({
-      connectionTimeout: session?.connectionTimeout,
-      abort: session?.abort
-    });
-    const cmd = [...request.commands.values()][0];
-    const commandRef = this.#allocateCommandRef();
-    const { endpointId, clusterId, commandId } = request.invokeRequests[0].commandPath;
-    const pathKey = `${endpointId}-${clusterId}-${commandId}`;
-    const { promise, resolver, rejecter } = createPromise();
-    const pending = {
-      request: { ...cmd, commandRef },
-      pathKey,
-      network: request.network,
-      resolve: resolver,
-      reject: rejecter
-    };
-    this.#pendingCommands.set(commandRef, pending);
-    const abortSignal = session?.abort;
-    if (abortSignal) {
-      if (abortSignal.aborted) {
-        this.#pendingCommands.delete(commandRef);
-        pending.reject(new AbortedError());
-        return;
-      }
-      const onAbort = () => {
-        pending.aborted = true;
-        this.#pendingCommands.delete(commandRef);
-        pending.reject(new AbortedError());
-      };
-      abortSignal.addEventListener("abort", onAbort, { once: true });
-      pending.cleanup = () => abortSignal.removeEventListener("abort", onAbort);
-    }
-    const duration = request.batchDuration || Instant;
-    if (this.#batchTimer?.isRunning) {
-      const remaining = this.#batchTimer.interval - (this.#batchTimer.elapsed?.time ?? 0);
-      if (duration < remaining) {
-        this.#batchTimer.stop();
-        this.#batchTimer.interval = duration;
-        this.#batchTimer.start();
-      }
-    } else {
-      if (!this.#batchTimer) {
-        this.#batchTimer = Time.getTimer("invoke-batch", duration, () => this.#flushBatch());
-      } else {
-        this.#batchTimer.interval = duration;
-      }
-      this.#batchTimer.start();
-    }
-    try {
-      const entry = await promise;
-      if (entry !== void 0) {
-        yield [entry];
-      }
-    } finally {
-      pending.cleanup?.();
-    }
-  }
-  #allocateCommandRef() {
-    const startRef = this.#nextCommandRef;
-    do {
-      const ref = this.#nextCommandRef;
-      this.#nextCommandRef = this.#nextCommandRef >= MAX_COMMAND_REF ? 1 : this.#nextCommandRef + 1;
-      if (!this.#pendingCommands.has(ref)) {
-        return ref;
-      }
-    } while (this.#nextCommandRef !== startRef);
-    throw new ImplementationError("No available commandRef values");
-  }
-  async #flushBatch() {
-    if (this.#pendingCommands.size === 0) {
-      return;
-    }
-    const commands = new Map(this.#pendingCommands);
-    this.#pendingCommands.clear();
-    const batches = this.#partitionBatch(commands);
-    for (const batch of batches) {
-      try {
-        await this.#batchMutex.produce(async () => {
-          await this.#executeBatch(batch);
-        });
-      } catch (error) {
-        for (const [, pending] of batch) {
-          pending.reject(error);
-        }
-      }
-    }
-  }
-  /**
-   * Partition commands into sub-batches where each sub-batch has unique command paths.
-   * Uses greedy fill: each command goes into the first batch that doesn't already contain its path.
-   */
-  #partitionBatch(commands) {
-    if (commands.size <= 1) {
-      return [commands];
-    }
-    const batches = [];
-    for (const [ref, pending] of commands) {
-      let placed = false;
-      for (const batch of batches) {
-        if (!batch.paths.has(pending.pathKey)) {
-          batch.paths.add(pending.pathKey);
-          batch.commands.set(ref, pending);
-          placed = true;
-          break;
-        }
-      }
-      if (!placed) {
-        batches.push({
-          paths: /* @__PURE__ */ new Set([pending.pathKey]),
-          commands: /* @__PURE__ */ new Map([[ref, pending]])
-        });
-      }
-    }
-    return batches.map((b) => b.commands);
-  }
-  async #executeBatch(commands) {
-    try {
-      for (const [ref, pending] of commands) {
-        if (pending.aborted) {
-          commands.delete(ref);
-        }
-      }
-      if (commands.size === 0) {
-        return;
-      }
-      const commandList = [...commands.values()];
-      const isSingleCommand = commandList.length === 1;
-      const invokeRequests = isSingleCommand ? [{ ...commandList[0].request, commandRef: void 0 }] : commandList.map((c) => c.request);
-      logger.debug(`Executing ${invokeRequests.length} command(s)${isSingleCommand ? "" : " (batched)"}`);
-      const batchNetwork = commandList.find((c) => c.network !== void 0)?.network;
-      const batchRequest = {
-        ...Invoke({ commands: invokeRequests, skipValidation: true }),
-        network: batchNetwork
-      };
-      const maxPathsPerInvoke = this.#exchangeProvider.maxPathsPerInvoke ?? 1;
-      const chunks = invokeRequests.length > maxPathsPerInvoke ? this.#invokeWithSplitting(batchRequest, maxPathsPerInvoke) : this.#invokeSingle(batchRequest);
-      for await (const chunk of chunks) {
-        for (const entry of chunk) {
-          let pending;
-          if (isSingleCommand) {
-            pending = commandList[0];
-            commands.clear();
-          } else {
-            pending = commands.get(entry.commandRef);
-            if (!pending) {
-              if (entry.commandRef !== void 0) {
-                logger.info(`Response for aborted commandRef ${entry.commandRef} discarded`);
-              } else {
-                logger.warn(`Received response for unknown commandRef ${entry.commandRef}`);
-              }
-              continue;
-            }
-            commands.delete(entry.commandRef);
-          }
-          if (pending.aborted) {
-            logger.info(`Response for aborted command discarded`);
-            continue;
-          }
-          pending.resolve(entry);
-        }
-      }
-      for (const [, pending] of commands) {
-        if (!pending.aborted) {
-          pending.resolve(void 0);
-        }
-      }
-    } catch (error) {
-      for (const [, pending] of commands) {
-        if (!pending.aborted) {
-          pending.reject(error);
-        }
-      }
-    }
-  }
-  /**
-   * Subscribe to attribute values and events.
-   */
-  async subscribe(request, session) {
-    let interactionSession = session;
-    const subscriptionPathsCount = (request.attributeRequests?.length ?? 0) + (request.eventRequests?.length ?? 0);
-    if (subscriptionPathsCount === 0) {
-      throw new ImplementationError("When subscribing to attributes and events, at least one must be specified.");
-    }
-    if (subscriptionPathsCount > 3) {
-      logger.info("Subscribe interactions with more than 3 paths might be not allowed by the device.");
-    }
-    const peer = this.#exchangeProvider.peerAddress;
-    if (peer === void 0) {
-      throw new ImplementationError("Subscription unavailable because peer is uncommissioned");
-    }
-    if (!request.keepSubscriptions) {
-      for (const subscription2 of this.subscriptions) {
-        if (!PeerAddress.is(peer, subscription2.peer)) {
-          continue;
-        }
-        logger.debug(
-          `Removing subscription with ID ${Subscription.idStrOf(subscription2)} because new subscription replaces it`
-        );
-        subscription2.close();
-      }
-    }
-    const {
-      minIntervalFloor = DEFAULT_MIN_INTERVAL_FLOOR,
-      maxIntervalCeiling = SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT
-    } = request;
-    if (maxIntervalCeiling < minIntervalFloor) {
-      throw new ImplementationError(
-        `Invalid subscription request: maxIntervalCeiling (${Duration.format(
-          maxIntervalCeiling
-        )}) is less than minIntervalFloor (${Duration.format(minIntervalFloor)})`
-      );
-    }
-    const subscribe = async (request2, extraAbort) => {
-      var _stack = [];
-      try {
-        const context = __using(_stack, await this.#begin("subscribing", request2, interactionSession, extraAbort), true);
-        const { abort, messenger } = context;
-        logger.info(
-          "Subscribe",
-          Mark.OUTBOUND,
-          messenger.exchange.via,
-          Diagnostic.asFlags({ keepSubscriptions: request2.keepSubscriptions }),
-          Diagnostic.dict({
-            min: Duration.format(request2.minIntervalFloor),
-            max: Duration.format(request2.maxIntervalCeiling)
-          }),
-          request2
-        );
-        await messenger.sendSubscribeRequest(
-          {
-            ...request2,
-            minIntervalFloorSeconds: Seconds.of(minIntervalFloor),
-            maxIntervalCeilingSeconds: Seconds.of(maxIntervalCeiling)
-          },
-          { abort }
-        );
-        await this.#handleSubscriptionResponse(request2, readChunks(messenger, abort));
-        abort.throwIfAborted();
-        const responseMessage = await messenger.nextMessage(MessageType.SubscribeResponse, { abort });
-        const response = TlvSubscribeResponse.decode(responseMessage.payload);
-        const subscription2 = new PeerSubscription({
-          lifetime: this.subscriptions,
-          request: request2,
-          peer,
-          closed: () => this.subscriptions.delete(subscription2),
-          response,
-          abort,
-          maxPeerResponseTime: this.maximumPeerResponseTime(SUBSCRIPTION_PROCESSING_TIME)
-        });
-        this.subscriptions.addPeer(subscription2);
-        logger.info(
-          "Subscription successful",
-          Mark.INBOUND,
-          messenger.exchange.via,
-          messenger.exchange.diagnostics,
-          Diagnostic.dict({
-            id: Subscription.idStrOf(response.subscriptionId),
-            interval: Duration.format(Seconds(response.maxInterval)),
-            timeout: Duration.format(subscription2.timeout)
-          })
-        );
-        return subscription2;
-      } catch (_) {
-        var _error = _, _hasError = true;
-      } finally {
-        var _promise = __callDispose(_stack, _error, _hasError);
-        _promise && await _promise;
-      }
-    };
-    const read = (request2, extraAbort, logContext) => {
-      let readSession = interactionSession;
-      if (logContext !== void 0) {
-        readSession = {
-          ...readSession,
-          logContext: readSession?.logContext ? { ...readSession.logContext, ...logContext } : logContext
-        };
-      }
-      return this.read(request2, readSession, extraAbort);
-    };
-    let subscription;
-    if (request.sustain) {
-      interactionSession = { ...interactionSession, connectionTimeout: Forever };
-      subscription = new SustainedSubscription({
-        lifetime: this.subscriptions,
-        subscribe,
-        peer,
-        closed: () => this.subscriptions.delete(subscription),
-        request,
-        abort: session?.abort,
-        retries: this.#sustainRetries,
-        read,
-        // TCP has 1:1 session-connection binding plus OS keep-alive — the session is
-        // evicted when the connection drops, so no liveness probe is needed.
-        probe: (abort) => this.#exchangeProvider.channelType === ChannelType.TCP ? Promise.resolve(true) : this.probe({ abort })
-      });
-    } else {
-      subscription = await subscribe(request);
-    }
-    this.subscriptions.addActive(subscription);
-    return subscription;
-  }
-  async #handleSubscriptionResponse(request, result) {
-    if (request.updated) {
-      await request.updated(result);
-    } else {
-      for await (const _chunk of result) ;
-    }
-  }
-  async initBdx(request, session) {
-    if (this.#abort.aborted) {
-      throw new ImplementationError("Client interaction unavailable after close");
-    }
-    this.#interactions.add(request);
-    const abort = new Abort({ abort: [session?.abort, this.#abort] });
-    const messenger = await BdxMessenger.create(this.#exchangeProvider, request.messageTimeout);
-    const context = {
-      abort,
-      messenger,
-      [Symbol.asyncDispose]: async () => {
-        await messenger.close();
-        this.#interactions.delete(request);
-        abort[Symbol.dispose]();
-      }
-    };
-    try {
-      abort.throwIfAborted();
-    } catch (e) {
-      await context[Symbol.asyncDispose]();
-      throw e;
-    }
-    return { context };
-  }
-  async #begin(what, request, session, extraAbort) {
-    const lifetime = this.#lifetime.join(what);
-    const requiredTransport = "largeMessage" in request && request.largeMessage ? ChannelType.TCP : void 0;
-    let abort;
-    let messenger;
-    try {
-      if (this.#abort.aborted) {
-        throw new ImplementationError(
-          `Cannot ${what} ${this.#address ?? "uncommissioned node"} because interactable is closed`
-        );
-      }
-      abort = new Abort({ abort: [session?.abort, this.#abort, extraAbort] });
-      try {
-        messenger = await InteractionClientMessenger.create(this.#exchangeProvider, {
-          network: request.network ?? this.#network,
-          abort,
-          connectionTimeout: session?.connectionTimeout,
-          addressOverride: request.addressOverride,
-          requiredTransport
-        });
-      } catch (e) {
-        abort[Symbol.dispose]();
-        throw e;
-      }
-    } catch (e) {
-      lifetime[Symbol.dispose]();
-      throw e;
-    }
-    this.#interactions.add(request);
-    Object.defineProperty(lifetime.details, "via", {
-      get() {
-        return messenger.exchange.via;
-      }
-    });
-    const context = {
-      abort,
-      messenger,
-      [Symbol.asyncDispose]: async () => {
-        var _stack = [];
-        try {
-          const _closing = __using(_stack, lifetime.closing());
-          await messenger.close();
-          this.#interactions.delete(request);
-          abort[Symbol.dispose]();
-        } catch (_) {
-          var _error = _, _hasError = true;
-        } finally {
-          __callDispose(_stack, _error, _hasError);
-        }
-      }
-    };
-    try {
-      abort.throwIfAborted();
-    } catch (e) {
-      await context[Symbol.asyncDispose]();
-      throw e;
-    }
-    return context;
-  }
-  get channelType() {
-    return this.#exchangeProvider.channelType;
-  }
-  /** Dedicated secure session backing this interaction, if the provider exposes one. */
-  get session() {
-    return this.#exchangeProvider.session;
-  }
-  /** Calculates the current maximum response time for a message use in additional logic like timers. */
-  maximumPeerResponseTime(expectedProcessingTime, includeMaximumSendingTime = false) {
-    return this.#exchangeProvider.maximumPeerResponseTime(expectedProcessingTime, includeMaximumSendingTime);
-  }
-  get address() {
-    if (this.#address === void 0) {
-      throw new ImplementationError("Uncommissioned node has no peer address");
-    }
-    return this.#address;
-  }
-}
-async function* readChunks(messenger, abort) {
-  const leftOverData = new Array();
-  for await (const report of messenger.readDataReports({ abort })) {
-    yield InputChunk(report, leftOverData);
-    abort.throwIfAborted();
-  }
-}
-export {
-  ClientInteraction,
-  DEFAULT_MIN_INTERVAL_FLOOR,
-  SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT
-};
-//# sourceMappingURL=ClientInteraction.js.map