@matter/protocol 0.16.0-alpha.0-20250916-d577beb1d → 0.16.0-alpha.0-20250921-b7a3dda23

package/dist/esm/bdx/flow/Flow.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BdxMessenger } from "../BdxMessenger.js";
+import { PersistedFileDesignator } from "../PersistedFileDesignator.js";
+/** Base class for BDX transfer flows. */
+export declare abstract class Flow {
+    #private;
+    constructor(messenger: BdxMessenger, transferParameters: Flow.TransferOptions);
+    protected get transferParameters(): Flow.TransferOptions;
+    protected get isClosed(): boolean;
+    protected get messenger(): BdxMessenger;
+    protected get bytesLeft(): number | undefined;
+    protected set bytesLeft(value: number);
+    protected set finalBlockCounter(blockCounter: number);
+    protected get finalBlockCounter(): number;
+    /** Determines the next message counter to use for the next message, also handles wrapping around at 2^32. */
+    protected get nextMessageCounter(): number;
+    /** Utility function to check if a block counter is valid */
+    protected validateCounter(messageBlockCounter: number, expectedCounter?: number): number;
+    close(_error?: unknown): Promise<void>;
+    /**
+     * Main logic method to execute the flow.
+     * The promise resolves when the flow is complete, or rejects on any error or unexpected conditions.
+     */
+    processTransfer(): Promise<void>;
+    protected abstract initTransfer(): Promise<void>;
+    protected abstract transferNextChunk(): Promise<boolean>;
+    protected abstract finalizeTransfer(): Promise<void>;
+}
+export declare namespace Flow {
+    interface TransferOptions {
+        transferMode: DriverMode;
+        asynchronousTransfer: false;
+        dataLength?: number;
+        startOffset: number;
+        blockSize: number;
+        isDriver: boolean;
+        fileDesignator: PersistedFileDesignator;
+    }
+    enum DriverMode {
+        SenderDrive = "senderDrive",
+        ReceiverDrive = "receiverDrive"
+    }
+}
+//# sourceMappingURL=Flow.d.ts.map

package/dist/esm/bdx/flow/Flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/Flow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAExE,yCAAyC;AACzC,8BAAsB,IAAI;;gBAQV,SAAS,EAAE,YAAY,EAAE,kBAAkB,EAAE,IAAI,CAAC,eAAe;IAM7E,SAAS,KAAK,kBAAkB,IAAI,IAAI,CAAC,eAAe,CAEvD;IAED,SAAS,KAAK,QAAQ,YAErB;IAED,SAAS,KAAK,SAAS,iBAEtB;IAED,SAAS,KAAK,SAAS,IAAI,MAAM,GAAG,SAAS,CAE5C;IAED,SAAS,KAAK,SAAS,CAAC,KAAK,EAAE,MAAM,EAEpC;IAED,SAAS,KAAK,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAKnD;IAED,SAAS,KAAK,iBAAiB,IAPe,MAAM,CAYnD;IAED,6GAA6G;IAC7G,SAAS,KAAK,kBAAkB,WAG/B;IAED,4DAA4D;IAC5D,SAAS,CAAC,eAAe,CAAC,mBAAmB,EAAE,MAAM,EAAE,eAAe,SAA0B;IAU1F,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO;IAI5B;;;OAGG;IACG,eAAe;IAerB,SAAS,CAAC,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAEhD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAExD,SAAS,CAAC,QAAQ,CAAC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;CACvD;AAED,yBAAiB,IAAI,CAAC;IAClB,UAAiB,eAAe;QAC5B,YAAY,EAAE,UAAU,CAAC;QACzB,oBAAoB,EAAE,KAAK,CAAC;QAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC;QAClB,cAAc,EAAE,uBAAuB,CAAC;KAC3C;IAED,KAAY,UAAU;QAClB,WAAW,gBAAgB;QAC3B,aAAa,kBAAkB;KAClC;CACJ"}

package/dist/esm/bdx/flow/Flow.js

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "#general";
+import { BdxStatusCode } from "#types";
+import { BdxError } from "../BdxError.js";
+class Flow {
+  #transferParameters;
+  #messenger;
+  #isClosed = false;
+  #blockCounter = 0;
+  #bytesLeft;
+  #finalBlockCounter;
+  constructor(messenger, transferParameters) {
+    this.#messenger = messenger;
+    this.#transferParameters = transferParameters;
+    this.#bytesLeft = transferParameters.dataLength;
+  }
+  get transferParameters() {
+    return this.#transferParameters;
+  }
+  get isClosed() {
+    return this.#isClosed;
+  }
+  get messenger() {
+    return this.#messenger;
+  }
+  get bytesLeft() {
+    return this.#bytesLeft;
+  }
+  set bytesLeft(value) {
+    this.#bytesLeft = value;
+  }
+  set finalBlockCounter(blockCounter) {
+    if (this.#finalBlockCounter !== void 0) {
+      throw new InternalError("Transfer already finalized. finalizeTransfer() should only be called once.");
+    }
+    this.#finalBlockCounter = blockCounter;
+  }
+  get finalBlockCounter() {
+    if (this.#finalBlockCounter === void 0) {
+      throw new InternalError("Transfer not finalized. Call finalizeTransfer() after completing the transfer.");
+    }
+    return this.#finalBlockCounter;
+  }
+  /** Determines the next message counter to use for the next message, also handles wrapping around at 2^32. */
+  get nextMessageCounter() {
+    this.#blockCounter = (this.#blockCounter + 1) % 4294967296;
+    return this.#blockCounter;
+  }
+  /** Utility function to check if a block counter is valid */
+  validateCounter(messageBlockCounter, expectedCounter = this.nextMessageCounter) {
+    if (messageBlockCounter !== expectedCounter) {
+      throw new BdxError(
+        `Received Block with unexpected block counter: ${messageBlockCounter}, expected: ${expectedCounter}`,
+        BdxStatusCode.BadBlockCounter
+      );
+    }
+    return messageBlockCounter;
+  }
+  async close(_error) {
+    this.#isClosed = true;
+  }
+  /**
+   * Main logic method to execute the flow.
+   * The promise resolves when the flow is complete, or rejects on any error or unexpected conditions.
+   */
+  async processTransfer() {
+    await this.initTransfer();
+    while (!this.isClosed) {
+      if (await this.transferNextChunk()) {
+        break;
+      }
+    }
+    if (!this.isClosed) {
+      await this.finalizeTransfer();
+    }
+  }
+}
+((Flow2) => {
+  let DriverMode;
+  ((DriverMode2) => {
+    DriverMode2["SenderDrive"] = "senderDrive";
+    DriverMode2["ReceiverDrive"] = "receiverDrive";
+  })(DriverMode = Flow2.DriverMode || (Flow2.DriverMode = {}));
+})(Flow || (Flow = {}));
+export {
+  Flow
+};
+//# sourceMappingURL=Flow.js.map

package/dist/esm/bdx/flow/Flow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/Flow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB;AAKlB,MAAe,KAAK;AAAA,EACd;AAAA,EACA;AAAA,EACT,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB;AAAA,EACA;AAAA,EAEA,YAAY,WAAyB,oBAA0C;AAC3E,SAAK,aAAa;AAClB,SAAK,sBAAsB;AAC3B,SAAK,aAAa,mBAAmB;AAAA,EACzC;AAAA,EAEA,IAAc,qBAA2C;AACrD,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAc,WAAW;AACrB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAc,YAAY;AACtB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAc,YAAgC;AAC1C,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAc,UAAU,OAAe;AACnC,SAAK,aAAa;AAAA,EACtB;AAAA,EAEA,IAAc,kBAAkB,cAAsB;AAClD,QAAI,KAAK,uBAAuB,QAAW;AACvC,YAAM,IAAI,cAAc,4EAA4E;AAAA,IACxG;AACA,SAAK,qBAAqB;AAAA,EAC9B;AAAA,EAEA,IAAc,oBAAoB;AAC9B,QAAI,KAAK,uBAAuB,QAAW;AACvC,YAAM,IAAI,cAAc,gFAAgF;AAAA,IAC5G;AACA,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGA,IAAc,qBAAqB;AAC/B,SAAK,iBAAiB,KAAK,gBAAgB,KAAK;AAChD,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGU,gBAAgB,qBAA6B,kBAAkB,KAAK,oBAAoB;AAC9F,QAAI,wBAAwB,iBAAiB;AACzC,YAAM,IAAI;AAAA,QACN,iDAAiD,mBAAmB,eAAe,eAAe;AAAA,QAClG,cAAc;AAAA,MAClB;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA,EAEA,MAAM,MAAM,QAAkB;AAC1B,SAAK,YAAY;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,kBAAkB;AACpB,UAAM,KAAK,aAAa;AAGxB,WAAO,CAAC,KAAK,UAAU;AACnB,UAAI,MAAM,KAAK,kBAAkB,GAAG;AAChC;AAAA,MACJ;AAAA,IACJ;AAEA,QAAI,CAAC,KAAK,UAAU;AAChB,YAAM,KAAK,iBAAiB;AAAA,IAChC;AAAA,EACJ;AAOJ;AAAA,CAEO,CAAUA,UAAV;AAWI,MAAK;AAAL,IAAKC,gBAAL;AACH,IAAAA,YAAA,iBAAc;AACd,IAAAA,YAAA,mBAAgB;AAAA,KAFR,aAAAD,MAAA,eAAAA,MAAA;AAAA,GAXC;",
+  "names": ["Flow", "DriverMode"]
+}

package/dist/esm/bdx/flow/FollowingReceivingFlow.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OutboundFlow } from "./OutboundFlow.js";
+/**
+ * BDX Transport flow logic for a "BDX Following Receiver":
+ * - Reads BlockQuery(WithSkip) messages and responds with Block or (for last block) BlockEof.
+ *   Data are skipped over when requested by the peer.
+ * - After the last block is send it expects an AckEof
+ */
+export declare class FollowingReceivingFlow extends OutboundFlow {
+    protected transferNextChunk(): Promise<boolean>;
+}
+//# sourceMappingURL=FollowingReceivingFlow.d.ts.map

package/dist/esm/bdx/flow/FollowingReceivingFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FollowingReceivingFlow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/FollowingReceivingFlow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,YAAY;cACpC,iBAAiB;CAgCpC"}

package/dist/esm/bdx/flow/FollowingReceivingFlow.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Logger } from "#general";
+import { BdxMessageType, BdxStatusCode } from "#types";
+import { BdxMessenger } from "../BdxMessenger.js";
+import { BdxMessage } from "../schema/BdxMessage.js";
+import { OutboundFlow } from "./OutboundFlow.js";
+const logger = Logger.get("BdxFollowingReceivingFlow");
+class FollowingReceivingFlow extends OutboundFlow {
+  async transferNextChunk() {
+    const { iterator, streamReader } = this.stream;
+    const blockQuery = await this.messenger.readBlockQuery();
+    const bytesToSkip = BdxMessage.is(blockQuery, BdxMessageType.BlockQueryWithSkip) ? BdxMessenger.asSafeNumber(
+      blockQuery.message.bytesToSkip,
+      "BytesToSkip",
+      BdxStatusCode.TransferFailedUnknownError
+    ) : 0;
+    const { blockCounter } = blockQuery.message;
+    this.validateCounter(blockCounter);
+    if (bytesToSkip > 0) {
+      const skipped = await streamReader.skip(bytesToSkip);
+      logger.debug(`Skipped ${skipped}bytes of data (requested ${bytesToSkip}bytes)`);
+    }
+    const { data, done } = await this.readDataChunk(iterator);
+    if (done) {
+      await this.messenger.sendBlockEof({ data, blockCounter });
+      this.finalBlockCounter = blockCounter;
+      return true;
+    }
+    await this.messenger.sendBlock({ data, blockCounter });
+    return false;
+  }
+}
+export {
+  FollowingReceivingFlow
+};
+//# sourceMappingURL=FollowingReceivingFlow.js.map

package/dist/esm/bdx/flow/FollowingReceivingFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/FollowingReceivingFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,cAAc;AACvB,SAAS,gBAAgB,qBAAqB;AAC9C,SAAS,oBAAoB;AAC7B,SAAS,kBAAkB;AAC3B,SAAS,oBAAoB;AAE7B,MAAM,SAAS,OAAO,IAAI,2BAA2B;AAO9C,MAAM,+BAA+B,aAAa;AAAA,EACrD,MAAgB,oBAAoB;AAChC,UAAM,EAAE,UAAU,aAAa,IAAI,KAAK;AAGxC,UAAM,aAAa,MAAM,KAAK,UAAU,eAAe;AACvD,UAAM,cAAc,WAAW,GAAG,YAAY,eAAe,kBAAkB,IACzE,aAAa;AAAA,MACT,WAAW,QAAQ;AAAA,MACnB;AAAA,MACA,cAAc;AAAA,IAClB,IACA;AAEN,UAAM,EAAE,aAAa,IAAI,WAAW;AACpC,SAAK,gBAAgB,YAAY;AAEjC,QAAI,cAAc,GAAG;AACjB,YAAM,UAAU,MAAM,aAAa,KAAK,WAAW;AACnD,aAAO,MAAM,WAAW,OAAO,4BAA4B,WAAW,QAAQ;AAAA,IAClF;AACA,UAAM,EAAE,MAAM,KAAK,IAAI,MAAM,KAAK,cAAc,QAAQ;AAExD,QAAI,MAAM;AACN,YAAM,KAAK,UAAU,aAAa,EAAE,MAAM,aAAa,CAAC;AACxD,WAAK,oBAAoB;AACzB,aAAO;AAAA,IACX;AAEA,UAAM,KAAK,UAAU,UAAU,EAAE,MAAM,aAAa,CAAC;AAErD,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/esm/bdx/flow/FollowingSendingFlow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InboundFlow } from "./InboundFlow.js";
+/**
+ * BDX Transport flow logic for a "BDX Following Sender":
+ * - Reads the Block and sends an Ack (if synchronous transfer is used)
+ * - Last message is confirmed with an AckEof
+ */
+export declare class FollowingSendingFlow extends InboundFlow {
+    protected transferNextChunk(): Promise<boolean>;
+}
+//# sourceMappingURL=FollowingSendingFlow.d.ts.map

package/dist/esm/bdx/flow/FollowingSendingFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FollowingSendingFlow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/FollowingSendingFlow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;cACjC,iBAAiB;CAuBpC"}

package/dist/esm/bdx/flow/FollowingSendingFlow.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InboundFlow } from "./InboundFlow.js";
+class FollowingSendingFlow extends InboundFlow {
+  async transferNextChunk() {
+    const { asynchronousTransfer } = this.transferParameters;
+    const { writeController } = this.stream;
+    const {
+      kind: messageType,
+      message: { data, blockCounter }
+    } = await this.messenger.readBlock();
+    this.validateCounter(blockCounter);
+    if (this.writeDataChunk(writeController, data, messageType)) {
+      this.finalBlockCounter = blockCounter;
+      return true;
+    }
+    if (!asynchronousTransfer) {
+      await this.messenger.sendBlockAck({ blockCounter });
+    }
+    return false;
+  }
+}
+export {
+  FollowingSendingFlow
+};
+//# sourceMappingURL=FollowingSendingFlow.js.map

package/dist/esm/bdx/flow/FollowingSendingFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/FollowingSendingFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,mBAAmB;AAOrB,MAAM,6BAA6B,YAAY;AAAA,EAClD,MAAgB,oBAAoB;AAChC,UAAM,EAAE,qBAAqB,IAAI,KAAK;AACtC,UAAM,EAAE,gBAAgB,IAAI,KAAK;AAEjC,UAAM;AAAA,MACF,MAAM;AAAA,MACN,SAAS,EAAE,MAAM,aAAa;AAAA,IAClC,IAAI,MAAM,KAAK,UAAU,UAAU;AACnC,SAAK,gBAAgB,YAAY;AAGjC,QAAI,KAAK,eAAe,iBAAiB,MAAM,WAAW,GAAG;AACzD,WAAK,oBAAoB;AACzB,aAAO;AAAA,IACX;AAEA,QAAI,CAAC,sBAAsB;AAEvB,YAAM,KAAK,UAAU,aAAa,EAAE,aAAa,CAAC;AAAA,IACtD;AAEA,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/esm/bdx/flow/InboundFlow.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+import { BdxMessageType } from "#types";
+import { Flow } from "./Flow.js";
+/**
+ * Base class for inbound BDX transfer flows where data is received from the peer and written to our node.
+ */
+export declare abstract class InboundFlow extends Flow {
+    #private;
+    /**
+     * Returns initialized streams for the transfer and initializes the #closeStream class function
+     */
+    protected initTransfer(): Promise<void>;
+    protected get stream(): {
+        writeController: ReadableStreamDefaultController<AllowSharedBufferSource>;
+        writePromise: PromiseLike<void>;
+    };
+    protected finalizeTransfer(): Promise<void>;
+    protected writeDataChunk(writeController: ReadableStreamDefaultController<Bytes>, data: Bytes, messageType: BdxMessageType): boolean;
+    close(error?: unknown): Promise<void>;
+}
+//# sourceMappingURL=InboundFlow.d.ts.map

package/dist/esm/bdx/flow/InboundFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InboundFlow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/InboundFlow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAA+B,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAiB,MAAM,QAAQ,CAAC;AAEvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;GAEG;AACH,8BAAsB,WAAY,SAAQ,IAAI;;IAK1C;;OAEG;cACa,YAAY;IAkC5B,SAAS,KAAK,MAAM;;;MAKnB;cAEe,gBAAgB;IAOhC,SAAS,CAAC,cAAc,CACpB,eAAe,EAAE,+BAA+B,CAAC,KAAK,CAAC,EACvD,IAAI,EAAE,KAAK,EACX,WAAW,EAAE,cAAc;IA0BhB,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO;CAIvC"}

package/dist/esm/bdx/flow/InboundFlow.js

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "#general";
+import { BdxMessageType, BdxStatusCode } from "#types";
+import { BdxError } from "../BdxError.js";
+import { Flow } from "./Flow.js";
+class InboundFlow extends Flow {
+  #closeStreams;
+  #writeController;
+  #writePromise;
+  /**
+   * Returns initialized streams for the transfer and initializes the #closeStream class function
+   */
+  async initTransfer() {
+    let writeController;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        writeController = controller;
+      }
+    });
+    const { fileDesignator } = this.transferParameters;
+    const writePromise = fileDesignator.writeFromStream(stream);
+    this.#closeStreams = async (error) => {
+      if (writeController !== void 0) {
+        if (error != void 0) {
+          writeController.error(error);
+          try {
+            await writePromise;
+          } catch {
+          }
+        }
+      }
+      if (!stream.locked) {
+        await stream.cancel();
+      }
+    };
+    this.#writeController = writeController;
+    this.#writePromise = writePromise;
+  }
+  get stream() {
+    if (!this.#writeController || !this.#writePromise) {
+      throw new InternalError("Transfer not initialized. Call initTransfer() before starting the transfer.");
+    }
+    return { writeController: this.#writeController, writePromise: this.#writePromise };
+  }
+  async finalizeTransfer() {
+    const { writePromise } = this.stream;
+    const blockCounter = this.finalBlockCounter;
+    await writePromise;
+    await this.messenger.sendBlockAckEof({ blockCounter });
+  }
+  writeDataChunk(writeController, data, messageType) {
+    writeController.enqueue(data);
+    if (this.bytesLeft !== void 0) {
+      this.bytesLeft -= data.byteLength;
+    }
+    let done = false;
+    if (messageType === BdxMessageType.BlockEof) {
+      if (this.bytesLeft !== void 0 && this.bytesLeft !== 0) {
+        throw new BdxError(
+          `Received BlockEof with ${this.bytesLeft}bytes left, but no more data available`,
+          this.bytesLeft > 0 ? BdxStatusCode.LengthTooShort : BdxStatusCode.LengthTooLarge
+        );
+      }
+      done = true;
+      writeController.close();
+    }
+    return done;
+  }
+  async close(error) {
+    await super.close(error);
+    await this.#closeStreams?.(error);
+  }
+}
+export {
+  InboundFlow
+};
+//# sourceMappingURL=InboundFlow.js.map

package/dist/esm/bdx/flow/InboundFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/InboundFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAgB,qBAAmC;AACnD,SAAS,gBAAgB,qBAAqB;AAC9C,SAAS,gBAAgB;AACzB,SAAS,YAAY;AAKd,MAAe,oBAAoB,KAAK;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAKA,MAAgB,eAAe;AAE3B,QAAI;AACJ,UAAM,SAAS,IAAI,eAAsB;AAAA,MACrC,OAAO,gBAAc;AACjB,0BAAkB;AAAA,MACtB;AAAA,IACJ,CAAC;AACD,UAAM,EAAE,eAAe,IAAI,KAAK;AAChC,UAAM,eAAe,eAAe,gBAAgB,MAAM;AAG1D,SAAK,gBAAgB,OAAO,UAAoB;AAC5C,UAAI,oBAAoB,QAAW;AAC/B,YAAI,SAAS,QAAW;AAEpB,0BAAgB,MAAM,KAAK;AAC3B,cAAI;AACA,kBAAM;AAAA,UACV,QAAQ;AAAA,UAER;AAAA,QACJ;AAAA,MACJ;AAEA,UAAI,CAAC,OAAO,QAAQ;AAChB,cAAM,OAAO,OAAO;AAAA,MACxB;AAAA,IACJ;AAEA,SAAK,mBAAmB;AACxB,SAAK,gBAAgB;AAAA,EACzB;AAAA,EAEA,IAAc,SAAS;AACnB,QAAI,CAAC,KAAK,oBAAoB,CAAC,KAAK,eAAe;AAC/C,YAAM,IAAI,cAAc,6EAA6E;AAAA,IACzG;AACA,WAAO,EAAE,iBAAiB,KAAK,kBAAkB,cAAc,KAAK,cAAc;AAAA,EACtF;AAAA,EAEA,MAAgB,mBAAmB;AAC/B,UAAM,EAAE,aAAa,IAAI,KAAK;AAC9B,UAAM,eAAe,KAAK;AAC1B,UAAM;AACN,UAAM,KAAK,UAAU,gBAAgB,EAAE,aAAa,CAAC;AAAA,EACzD;AAAA,EAEU,eACN,iBACA,MACA,aACF;AAEE,oBAAgB,QAAQ,IAAI;AAC5B,QAAI,KAAK,cAAc,QAAW;AAC9B,WAAK,aAAa,KAAK;AAAA,IAC3B;AAEA,QAAI,OAAO;AAGX,QAAI,gBAAgB,eAAe,UAAU;AACzC,UAAI,KAAK,cAAc,UAAa,KAAK,cAAc,GAAG;AACtD,cAAM,IAAI;AAAA,UACN,0BAA0B,KAAK,SAAS;AAAA,UACxC,KAAK,YAAY,IAAI,cAAc,iBAAiB,cAAc;AAAA,QACtE;AAAA,MACJ;AAEA,aAAO;AACP,sBAAgB,MAAM;AAAA,IAC1B;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,MAAe,MAAM,OAAiB;AAClC,UAAM,MAAM,MAAM,KAAK;AACvB,UAAM,KAAK,gBAAgB,KAAK;AAAA,EACpC;AACJ;",
+  "names": []
+}

package/dist/esm/bdx/flow/OutboundFlow.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BytesStreamReader } from "#general";
+import { Flow } from "./Flow.js";
+/**
+ * Base class for outbound BDX transfer flows where data is read from our node and sent to the peer.
+ */
+export declare abstract class OutboundFlow extends Flow {
+    #private;
+    protected get stream(): {
+        iterator: AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+        streamReader: BytesStreamReader;
+    };
+    /**
+     * Returns initialized streams for the transfer and initializes the #closeStream class function
+     */
+    protected initTransfer(): Promise<void>;
+    /**
+     * Reads one data chunk from the reader and does some basic checks.
+     */
+    protected readDataChunk(reader: AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>): Promise<{
+        data: Uint8Array<ArrayBufferLike>;
+        done: boolean;
+    }>;
+    protected finalizeTransfer(): Promise<void>;
+    close(error?: unknown): Promise<void>;
+}
+//# sourceMappingURL=OutboundFlow.d.ts.map

package/dist/esm/bdx/flow/OutboundFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutboundFlow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/OutboundFlow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAiB,MAAM,UAAU,CAAC;AAG5D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;GAEG;AACH,8BAAsB,YAAa,SAAQ,IAAI;;IAK3C,SAAS,KAAK,MAAM;;;MAKnB;IAED;;OAEG;cACa,YAAY;IAoC5B;;OAEG;cACa,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC;;;;cA6ChF,gBAAgB;IAMjB,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO;CAIvC"}

package/dist/esm/bdx/flow/OutboundFlow.js

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BytesStreamReader, InternalError } from "#general";
+import { BdxStatusCode } from "#types";
+import { BdxError } from "../BdxError.js";
+import { Flow } from "./Flow.js";
+class OutboundFlow extends Flow {
+  #closeStreams;
+  #iterator;
+  #streamReader;
+  get stream() {
+    if (this.#iterator === void 0 || this.#streamReader === void 0) {
+      throw new InternalError("Read stream not initialized");
+    }
+    return { iterator: this.#iterator, streamReader: this.#streamReader };
+  }
+  /**
+   * Returns initialized streams for the transfer and initializes the #closeStream class function
+   */
+  async initTransfer() {
+    const { blockSize } = this.transferParameters;
+    const blob = await this.transferParameters.fileDesignator.openBlob();
+    const blobSize = blob.size;
+    const { startOffset = 0, dataLength = blobSize } = this.transferParameters;
+    const dataBlob = startOffset > 0 || dataLength !== blobSize ? blob.slice(startOffset, startOffset + dataLength) : blob;
+    const stream = dataBlob.stream();
+    const reader = stream.getReader();
+    this.#closeStreams = async (_error) => {
+      if (stream.locked) {
+        reader?.releaseLock();
+        try {
+          await reader?.cancel();
+        } catch (error) {
+          if (!(error instanceof TypeError)) {
+            throw error;
+          }
+        }
+      }
+      await stream.cancel();
+    };
+    const streamReader = new BytesStreamReader(reader);
+    this.#iterator = streamReader.read(blockSize);
+    this.#streamReader = streamReader;
+  }
+  /**
+   * Reads one data chunk from the reader and does some basic checks.
+   */
+  async readDataChunk(reader) {
+    const { blockSize, dataLength } = this.transferParameters;
+    let { value, done = false } = await reader.next();
+    if (value === void 0) {
+      if (!done) {
+        throw new BdxError(
+          `Data length too short, expected ${blockSize}bytes, but got less`,
+          BdxStatusCode.LengthTooShort
+        );
+      }
+      value = new Uint8Array();
+    } else if (value.byteLength < blockSize) {
+      ({ done = false } = await reader.next());
+      if (!done) {
+        throw new BdxError(
+          `Data length too short, expected ${blockSize}bytes, but got less`,
+          BdxStatusCode.LengthTooShort
+        );
+      }
+    }
+    if (this.bytesLeft !== void 0 && dataLength !== void 0) {
+      this.bytesLeft -= value.byteLength;
+      if (this.bytesLeft < 0) {
+        throw new BdxError(
+          `Data length exceeded, expected ${dataLength}bytes, but got ${-this.bytesLeft}bytes more`,
+          BdxStatusCode.LengthTooLarge
+        );
+      }
+      if (done && this.bytesLeft > 0) {
+        throw new BdxError(
+          `Data length too short, expected ${dataLength}bytes, but got ${this.bytesLeft}bytes less`,
+          BdxStatusCode.LengthTooShort
+        );
+      }
+      if (this.bytesLeft === 0) {
+        done = true;
+      }
+    }
+    return { data: value, done };
+  }
+  async finalizeTransfer() {
+    const blockCounter = this.finalBlockCounter;
+    const { blockCounter: ackedBlockCounter } = await this.messenger.readBlockAckEof();
+    this.validateCounter(ackedBlockCounter, blockCounter);
+  }
+  async close(error) {
+    await super.close(error);
+    await this.#closeStreams?.(error);
+  }
+}
+export {
+  OutboundFlow
+};
+//# sourceMappingURL=OutboundFlow.js.map

package/dist/esm/bdx/flow/OutboundFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/OutboundFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,mBAAmB,qBAAqB;AACjD,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB;AACzB,SAAS,YAAY;AAKd,MAAe,qBAAqB,KAAK;AAAA,EAC5C;AAAA,EACA;AAAA,EACA;AAAA,EAEA,IAAc,SAAS;AACnB,QAAI,KAAK,cAAc,UAAa,KAAK,kBAAkB,QAAW;AAClE,YAAM,IAAI,cAAc,6BAA6B;AAAA,IACzD;AACA,WAAO,EAAE,UAAU,KAAK,WAAW,cAAc,KAAK,cAAc;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA,EAKA,MAAgB,eAAe;AAC3B,UAAM,EAAE,UAAU,IAAI,KAAK;AAE3B,UAAM,OAAO,MAAM,KAAK,mBAAmB,eAAe,SAAS;AACnE,UAAM,WAAW,KAAK;AAGtB,UAAM,EAAE,cAAc,GAAG,aAAa,SAAS,IAAI,KAAK;AAExD,UAAM,WACF,cAAc,KAAK,eAAe,WAAW,KAAK,MAAM,aAAa,cAAc,UAAU,IAAI;AAErG,UAAM,SAAS,SAAS,OAAO;AAE/B,UAAM,SAAS,OAAO,UAAU;AAEhC,SAAK,gBAAgB,OAAO,WAAqB;AAC7C,UAAI,OAAO,QAAQ;AACf,gBAAQ,YAAY;AACpB,YAAI;AACA,gBAAM,QAAQ,OAAO;AAAA,QACzB,SAAS,OAAO;AAEZ,cAAI,EAAE,iBAAiB,YAAY;AAC/B,kBAAM;AAAA,UACV;AAAA,QACJ;AAAA,MACJ;AACA,YAAM,OAAO,OAAO;AAAA,IACxB;AAEA,UAAM,eAAe,IAAI,kBAAkB,MAAM;AACjD,SAAK,YAAY,aAAa,KAAK,SAAS;AAC5C,SAAK,gBAAgB;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAgB,cAAc,QAAoE;AAC9F,UAAM,EAAE,WAAW,WAAW,IAAI,KAAK;AACvC,QAAI,EAAE,OAAO,OAAO,MAAM,IAAI,MAAM,OAAO,KAAK;AAChD,QAAI,UAAU,QAAW;AAErB,UAAI,CAAC,MAAM;AACP,cAAM,IAAI;AAAA,UACN,mCAAmC,SAAS;AAAA,UAC5C,cAAc;AAAA,QAClB;AAAA,MACJ;AACA,cAAQ,IAAI,WAAW;AAAA,IAC3B,WAAW,MAAM,aAAa,WAAW;AAErC,OAAC,EAAE,OAAO,MAAM,IAAI,MAAM,OAAO,KAAK;AACtC,UAAI,CAAC,MAAM;AACP,cAAM,IAAI;AAAA,UACN,mCAAmC,SAAS;AAAA,UAC5C,cAAc;AAAA,QAClB;AAAA,MACJ;AAAA,IACJ;AAEA,QAAI,KAAK,cAAc,UAAa,eAAe,QAAW;AAC1D,WAAK,aAAa,MAAM;AACxB,UAAI,KAAK,YAAY,GAAG;AACpB,cAAM,IAAI;AAAA,UACN,kCAAkC,UAAU,kBAAkB,CAAC,KAAK,SAAS;AAAA,UAC7E,cAAc;AAAA,QAClB;AAAA,MACJ;AACA,UAAI,QAAQ,KAAK,YAAY,GAAG;AAC5B,cAAM,IAAI;AAAA,UACN,mCAAmC,UAAU,kBAAkB,KAAK,SAAS;AAAA,UAC7E,cAAc;AAAA,QAClB;AAAA,MACJ;AACA,UAAI,KAAK,cAAc,GAAG;AACtB,eAAO;AAAA,MACX;AAAA,IACJ;AAEA,WAAO,EAAE,MAAM,OAAO,KAAK;AAAA,EAC/B;AAAA,EAEA,MAAgB,mBAAmB;AAC/B,UAAM,eAAe,KAAK;AAC1B,UAAM,EAAE,cAAc,kBAAkB,IAAI,MAAM,KAAK,UAAU,gBAAgB;AACjF,SAAK,gBAAgB,mBAAmB,YAAY;AAAA,EACxD;AAAA,EAEA,MAAe,MAAM,OAAiB;AAClC,UAAM,MAAM,MAAM,KAAK;AACvB,UAAM,KAAK,gBAAgB,KAAK;AAAA,EACpC;AACJ;",
+  "names": []
+}

package/dist/esm/bdx/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./BdxClient.js";
+export * from "./BdxError.js";
+export * from "./BdxMessenger.js";
+export * from "./BdxProtocol.js";
+export * from "./BdxSession.js";
+export * from "./BdxSessionConfiguration.js";
+export * from "./FileDesignator.js";
+export * from "./flow/Flow.js";
+export * from "./PersistedFileDesignator.js";
+export * from "./schema/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/bdx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bdx/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC"}

package/dist/esm/bdx/index.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./BdxClient.js";
+export * from "./BdxError.js";
+export * from "./BdxMessenger.js";
+export * from "./BdxProtocol.js";
+export * from "./BdxSession.js";
+export * from "./BdxSessionConfiguration.js";
+export * from "./FileDesignator.js";
+export * from "./flow/Flow.js";
+export * from "./PersistedFileDesignator.js";
+export * from "./schema/index.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/bdx/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/index.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/esm/bdx/schema/BdxAcceptMessagesSchema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+import { Schema, TypeFromPartialBitSchema } from "#types";
+import { BdxTransferControlBitmap } from "./BdxInitMessagesSchema.js";
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.5.2 */
+export interface BdxSendAccept {
+    /**
+     * Transfer control details
+     * TC
+     * 1 octet
+     */
+    transferControl: TypeFromPartialBitSchema<typeof BdxTransferControlBitmap>;
+    /**
+     * Specifies the maximum data size (in bytes) of the block that the Initiator supports, exclusive of block header
+     * fields, such as a block counter.
+     * MBS, 2 octets
+     */
+    maxBlockSize: number;
+    /**
+     * Allows the Initiator to send additional application-specific information about the file to be transferred
+     * MD, Variable length, TLV
+     */
+    metaData?: Bytes;
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.5.3 */
+export interface BdxReceiveAccept extends BdxSendAccept {
+    /**
+     * Specifies a predetermined definite length for the transfer
+     * DEFLEN, 4/8 octets
+     */
+    length?: number | bigint;
+}
+/** Schema for BDX SendAccept message */
+export declare class BdxSendAcceptMessageSchema<M extends BdxSendAccept> extends Schema<M> {
+    encodeInternal(message: M): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): M;
+    validate({ transferControl, maxBlockSize }: M): void;
+}
+export declare const BdxSendAcceptMessage: BdxSendAcceptMessageSchema<BdxSendAccept>;
+/** Schema for Bdx ReceiveAccept message */
+export declare class BdxReceiveAcceptMessageSchema extends BdxSendAcceptMessageSchema<BdxReceiveAccept> {
+    encodeInternal(message: BdxReceiveAccept): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): BdxReceiveAccept;
+}
+export declare const BdxReceiveAcceptMessage: BdxReceiveAcceptMessageSchema;
+//# sourceMappingURL=BdxAcceptMessagesSchema.d.ts.map

package/dist/esm/bdx/schema/BdxAcceptMessagesSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BdxAcceptMessagesSchema.d.ts","sourceRoot":"","sources":["../../../../src/bdx/schema/BdxAcceptMessagesSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAkC,MAAM,UAAU,CAAC;AACjE,OAAO,EAAiB,MAAM,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAGH,wBAAwB,EAE3B,MAAM,4BAA4B,CAAC;AAEpC,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,eAAe,EAAE,wBAAwB,CAAC,OAAO,wBAAwB,CAAC,CAAC;IAE3E;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC;CACpB;AAED,oEAAoE;AACpE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACnD;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,wCAAwC;AACxC,qBAAa,0BAA0B,CAAC,CAAC,SAAS,aAAa,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC9E,cAAc,CAAC,OAAO,EAAE,CAAC;IAezB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC;IAgBtB,QAAQ,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,EAAE,CAAC;CAiBzD;AACD,eAAO,MAAM,oBAAoB,2CAAmC,CAAC;AAErE,2CAA2C;AAC3C,qBAAa,6BAA8B,SAAQ,0BAA0B,CAAC,gBAAgB,CAAC;IAClF,cAAc,CAAC,OAAO,EAAE,gBAAgB;IA6BxC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,gBAAgB;CAyB1D;AACD,eAAO,MAAM,uBAAuB,+BAAsC,CAAC"}