@matter/protocol 0.16.0-alpha.0-20250913-0bc2515df → 0.16.0-alpha.0-20250920-809524dba

package/dist/cjs/bdx/PersistedFileDesignator.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/PersistedFileDesignator.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA2D;AAC3D,4BAA+B;AAP/B;AAAA;AAAA;AAAA;AAAA;AAUO,MAAM,gCAAgC,qCAAe;AAAA,EACxD;AAAA,EACA;AAAA,EAEA,YAAY,IAAoB,SAAyB;AACrD,UAAM,EAAE;AACR,SAAK,WAAW;AAAA,EACpB;AAAA,EAEA,SAAS;AACL,WAAO,KAAK,SAAS,IAAI,KAAK,IAAI;AAAA,EACtC;AAAA,EAEA,MAAM,WAAW;AACb,QAAI,KAAK,UAAU,QAAW;AAC1B,YAAM,WAAW,KAAK;AACtB,UAAI,CAAC,KAAK,SAAS,IAAI,QAAQ,GAAG;AAC9B,cAAM,IAAI;AAAA,UACN;AAAA,QACJ;AAAA,MACJ;AACA,WAAK,QAAQ,MAAM,KAAK,SAAS,SAAS,QAAQ;AAAA,IACtD;AACA,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,gBAAgB,QAA+B;AAC3C,WAAO,KAAK,SAAS,oBAAoB,KAAK,MAAM,MAAM;AAAA,EAC9D;AACJ;",
+  "names": []
+}

package/dist/cjs/bdx/bdx-session-initiator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BdxMessenger } from "./BdxMessenger.js";
+import { BdxSessionConfiguration } from "./BdxSessionConfiguration.js";
+import { Flow } from "./flow/Flow.js";
+/**
+ * Handles the initiation of a BDX session by exchanging *Init and *Accept messages and negotiating the transfer
+ * parameters.
+ */
+export declare function bdxSessionInitiator(messenger: BdxMessenger, config: BdxSessionConfiguration): Promise<Flow.TransferOptions>;
+//# sourceMappingURL=bdx-session-initiator.d.ts.map

package/dist/cjs/bdx/bdx-session-initiator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bdx-session-initiator.d.ts","sourceRoot":"","sources":["../../../src/bdx/bdx-session-initiator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAMtC;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,uBAAuB,iCAgOjG"}

package/dist/cjs/bdx/bdx-session-initiator.js

@@ -0,0 +1,218 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bdx_session_initiator_exports = {};
+__export(bdx_session_initiator_exports, {
+  bdxSessionInitiator: () => bdxSessionInitiator
+});
+module.exports = __toCommonJS(bdx_session_initiator_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_BdxError = require("./BdxError.js");
+var import_BdxMessenger = require("./BdxMessenger.js");
+var import_Flow = require("./flow/Flow.js");
+var import_BdxInitMessagesSchema = require("./schema/BdxInitMessagesSchema.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("bdxSessionInitiator");
+async function bdxSessionInitiator(messenger, config) {
+  if (config.isInitiator) {
+    if (config.isSender) {
+      const initMessage2 = await buildInitMessage();
+      const acceptMessage3 = await messenger.sendSendInit(initMessage2);
+      return collectAcceptParameters(
+        acceptMessage3,
+        // We define the data, so we know it are numbers
+        initMessage2.startOffset !== void 0 ? Number(initMessage2.startOffset) : void 0,
+        initMessage2.maxLength !== void 0 ? Number(initMessage2.maxLength) : void 0
+      );
+    }
+    const acceptMessage2 = await messenger.sendReceiveInit(await buildInitMessage());
+    return collectAcceptParameters(acceptMessage2);
+  }
+  const initMessage = config.initMessage;
+  if (initMessage === void 0) {
+    throw new import_general.InternalError("Initial message must be set before starting from initial message");
+  }
+  logger.debug(`Initialize BDX ${config.isSender ? "ReceiveInit" : "SendInit"} from incoming Message`, initMessage);
+  if (config.isSender) {
+    if (!config.fileDesignator.exists()) {
+      throw new import_BdxError.BdxError(
+        `File designator ${config.fileDesignator.text} does not point to an existing file in the storage to send data`,
+        import_types.BdxStatusCode.FileDesignatorUnknown
+      );
+    }
+    let { startOffset } = initMessage;
+    if (startOffset !== void 0) {
+      startOffset = import_BdxMessenger.BdxMessenger.asSafeNumber(startOffset, "Start offset", import_types.BdxStatusCode.StartOffsetNotSupported);
+    }
+    const acceptMessage2 = await determineAcceptParameters(initMessage);
+    const length = "length" in acceptMessage2 && typeof acceptMessage2.length === "number" ? acceptMessage2.length : void 0;
+    const blobToRead = await config.fileDesignator.openBlob();
+    if (length !== void 0 && length > 0) {
+      const availableSize = blobToRead.size - (startOffset ?? 0);
+      if (length > availableSize) {
+        throw new import_BdxError.BdxError(
+          `Requested maxLength ${length}bytes${startOffset ? ` with startOffset ${startOffset}` : ""} exceeds available size ${blobToRead.size} for blob ${config.fileDesignator.text}`,
+          import_types.BdxStatusCode.LengthTooLarge
+        );
+      }
+    }
+    await messenger.sendReceiveAccept(acceptMessage2);
+    return collectAcceptParameters(acceptMessage2, startOffset, length);
+  }
+  const acceptMessage = {
+    ...await determineAcceptParameters(initMessage),
+    length: void 0
+    // Length is not included in SendAccept, so take out to not confuse in logs
+  };
+  await messenger.sendSendAccept(acceptMessage);
+  return collectAcceptParameters(acceptMessage);
+  async function buildInitMessage() {
+    const {
+      senderStartOffset,
+      maxTransferSize,
+      senderMaxLength,
+      preferredDriverModes,
+      asynchronousTransferAllowed
+    } = config.transferConfig;
+    const { isSender, fileDesignator } = config;
+    let startOffset;
+    let maxLength;
+    if (isSender) {
+      maxLength = (await fileDesignator.openBlob()).size;
+      if (senderStartOffset !== void 0) {
+        if (maxLength <= senderStartOffset) {
+          throw new import_general.ImplementationError(
+            `Available data of ${maxLength}bytes are smaller than senderStartOffset ${senderStartOffset}bytes`
+          );
+        }
+        startOffset = senderStartOffset;
+        maxLength -= startOffset;
+      }
+      if (maxTransferSize !== void 0) {
+        if (maxLength > maxTransferSize) {
+          throw new import_general.ImplementationError(
+            `Requested maxLength ${maxLength}bytes exceeds maximum transfer size ${maxTransferSize}bytes`
+          );
+        }
+      }
+      if (senderMaxLength !== void 0) {
+        if (maxLength >= senderMaxLength) {
+          maxLength = senderMaxLength;
+        } else {
+          logger.info(
+            `Ignoring requested senderMaxLength ${senderMaxLength}bytes as it is larger then the relevant payload size of ${maxLength}bytes`
+          );
+        }
+      }
+    }
+    let maxBlockSize = messenger.maxPayloadSize - 4;
+    const requestedBlockSize = config.transferConfig.maxBlockSize;
+    if (requestedBlockSize !== void 0) {
+      if (maxBlockSize > requestedBlockSize) {
+        maxBlockSize = requestedBlockSize;
+      } else {
+        logger.info(
+          `Ignoring requested maxBlockSize ${requestedBlockSize}, as it is larger then the transport max payload size ${maxBlockSize}bytes`
+        );
+      }
+    }
+    return {
+      transferProtocol: {
+        version: import_BdxInitMessagesSchema.BDX_VERSION,
+        senderDrive: !!preferredDriverModes?.includes(import_Flow.Flow.DriverMode.SenderDrive),
+        receiverDrive: !!preferredDriverModes?.includes(import_Flow.Flow.DriverMode.ReceiverDrive),
+        asynchronousTransfer: asynchronousTransferAllowed
+        // always false for now
+      },
+      maxBlockSize,
+      fileDesignator: fileDesignator.bytes,
+      startOffset,
+      maxLength
+    };
+  }
+  async function determineAcceptParameters(initMessage2) {
+    const { transferProtocol, maxLength: initMaxLength = 0 } = initMessage2;
+    let { maxBlockSize } = initMessage2;
+    let finalDriverMode;
+    for (const mode of config.transferConfig.preferredDriverModes) {
+      if (transferProtocol[mode]) {
+        finalDriverMode = mode;
+        break;
+      }
+    }
+    if (finalDriverMode === void 0) {
+      throw new import_BdxError.BdxError("Can not determine a valid transfer mode", import_types.BdxStatusCode.TransferMethodNotSupported);
+    }
+    const requestedMaxBlockSize = config.transferConfig.maxBlockSize;
+    if (requestedMaxBlockSize !== void 0 && maxBlockSize > requestedMaxBlockSize) {
+      maxBlockSize = requestedMaxBlockSize;
+    }
+    const maxLength = import_BdxMessenger.BdxMessenger.asSafeNumber(initMaxLength, "Max length", import_types.BdxStatusCode.LengthTooLarge);
+    const transferControl = {
+      version: import_BdxInitMessagesSchema.BDX_VERSION,
+      // We support the minimum version, so no need for further checks
+      [finalDriverMode]: true,
+      // this sets either senderDrive or receiveDriver property
+      asynchronousTransfer: false
+      // Not supported so ignore if it was received
+    };
+    return {
+      transferControl,
+      maxBlockSize,
+      length: maxLength > 0 ? maxLength : void 0
+    };
+  }
+  function collectAcceptParameters(acceptMessage2, startOffset = 0, maxLength) {
+    const {
+      transferControl: { senderDrive, asynchronousTransfer },
+      maxBlockSize
+    } = acceptMessage2;
+    if (asynchronousTransfer) {
+      throw new import_BdxError.BdxError(
+        "Asynchronous transfer is not supported in this implementation",
+        import_types.BdxStatusCode.TransferMethodNotSupported
+      );
+    }
+    const dataLength = "length" in acceptMessage2 && acceptMessage2.length !== void 0 ? import_BdxMessenger.BdxMessenger.asSafeNumber(
+      acceptMessage2.length,
+      "Accept message length field",
+      import_types.BdxStatusCode.LengthTooLarge
+    ) : maxLength;
+    const transferParameters = {
+      transferMode: senderDrive ? import_Flow.Flow.DriverMode.SenderDrive : import_Flow.Flow.DriverMode.ReceiverDrive,
+      asynchronousTransfer: false,
+      // always false for now
+      dataLength,
+      startOffset,
+      blockSize: maxBlockSize,
+      isDriver: config.isSender && senderDrive || !config.isSender && !senderDrive,
+      fileDesignator: config.fileDesignator
+    };
+    logger.debug(
+      `${transferParameters.isDriver ? "We are" : "Peer is"} driving-${config.isSender ? "sender" : "receiver"} with negotiated transfer parameters`,
+      transferParameters
+    );
+    return transferParameters;
+  }
+}
+//# sourceMappingURL=bdx-session-initiator.js.map

package/dist/cjs/bdx/bdx-session-initiator.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/bdx-session-initiator.ts"],
+  "mappings": "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",
+  "names": ["initMessage", "acceptMessage"]
+}

package/dist/cjs/bdx/flow/DrivenSendingFlow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 Driving Sender":
+ * - Send out the Block and wait for Ack (if synchronous transfer is used)
+ * - Last message is sent with BlockEof and expects AckEof
+ */
+export declare class DrivenSendingFlow extends OutboundFlow {
+    protected transferNextChunk(): Promise<boolean>;
+}
+//# sourceMappingURL=DrivenSendingFlow.d.ts.map

package/dist/cjs/bdx/flow/DrivenSendingFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrivenSendingFlow.d.ts","sourceRoot":"","sources":["../../../../src/bdx/flow/DrivenSendingFlow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;cAC/B,iBAAiB;CAyBpC"}

package/dist/cjs/bdx/flow/DrivenSendingFlow.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DrivenSendingFlow_exports = {};
+__export(DrivenSendingFlow_exports, {
+  DrivenSendingFlow: () => DrivenSendingFlow
+});
+module.exports = __toCommonJS(DrivenSendingFlow_exports);
+var import_OutboundFlow = require("./OutboundFlow.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class DrivenSendingFlow extends import_OutboundFlow.OutboundFlow {
+  async transferNextChunk() {
+    const { asynchronousTransfer } = this.transferParameters;
+    const { iterator } = this.stream;
+    const blockCounter = this.nextMessageCounter;
+    const { data, done } = await this.readDataChunk(iterator);
+    if (done) {
+      await this.messenger.sendBlockEof({ data: data ?? new Uint8Array(), blockCounter });
+      this.finalBlockCounter = blockCounter;
+      return true;
+    }
+    await this.messenger.sendBlock({ data, blockCounter });
+    if (!asynchronousTransfer) {
+      const { blockCounter: ackedBlockCounter } = await this.messenger.readBlockAck();
+      this.validateCounter(ackedBlockCounter, blockCounter);
+    }
+    return false;
+  }
+}
+//# sourceMappingURL=DrivenSendingFlow.js.map

package/dist/cjs/bdx/flow/DrivenSendingFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/DrivenSendingFlow.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,0BAA6B;AAN7B;AAAA;AAAA;AAAA;AAAA;AAaO,MAAM,0BAA0B,iCAAa;AAAA,EAChD,MAAgB,oBAAoB;AAChC,UAAM,EAAE,qBAAqB,IAAI,KAAK;AACtC,UAAM,EAAE,SAAS,IAAI,KAAK;AAE1B,UAAM,eAAe,KAAK;AAE1B,UAAM,EAAE,MAAM,KAAK,IAAI,MAAM,KAAK,cAAc,QAAQ;AAExD,QAAI,MAAM;AAEN,YAAM,KAAK,UAAU,aAAa,EAAE,MAAM,QAAQ,IAAI,WAAW,GAAG,aAAa,CAAC;AAClF,WAAK,oBAAoB;AACzB,aAAO;AAAA,IACX;AAGA,UAAM,KAAK,UAAU,UAAU,EAAE,MAAM,aAAa,CAAC;AAGrD,QAAI,CAAC,sBAAsB;AACvB,YAAM,EAAE,cAAc,kBAAkB,IAAI,MAAM,KAAK,UAAU,aAAa;AAC9E,WAAK,gBAAgB,mBAAmB,YAAY;AAAA,IACxD;AACA,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/cjs/bdx/flow/DrivingReceivingFlow.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 Driving Receiver":
+ * - Requests the next Blow using BlockQuery and then reads the Block
+ * - Last message is confirmed with an AckEof
+ */
+export declare class DrivingReceivingFlow extends InboundFlow {
+    transferNextChunk(): Promise<boolean>;
+}
+//# sourceMappingURL=DrivingReceivingFlow.d.ts.map

package/dist/cjs/bdx/flow/DrivingReceivingFlow.d.ts.map

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

package/dist/cjs/bdx/flow/DrivingReceivingFlow.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DrivingReceivingFlow_exports = {};
+__export(DrivingReceivingFlow_exports, {
+  DrivingReceivingFlow: () => DrivingReceivingFlow
+});
+module.exports = __toCommonJS(DrivingReceivingFlow_exports);
+var import_InboundFlow = require("./InboundFlow.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class DrivingReceivingFlow extends import_InboundFlow.InboundFlow {
+  async transferNextChunk() {
+    const { writeController } = this.stream;
+    const blockCounter = this.nextMessageCounter;
+    await this.messenger.sendBlockQuery({ blockCounter });
+    const {
+      kind: messageType,
+      message: { blockCounter: dataBlockCounter, data }
+    } = await this.messenger.readBlock();
+    this.validateCounter(dataBlockCounter, blockCounter);
+    if (this.writeDataChunk(writeController, data, messageType)) {
+      this.finalBlockCounter = dataBlockCounter;
+      return true;
+    }
+    return false;
+  }
+}
+//# sourceMappingURL=DrivingReceivingFlow.js.map

package/dist/cjs/bdx/flow/DrivingReceivingFlow.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/DrivingReceivingFlow.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,yBAA4B;AAN5B;AAAA;AAAA;AAAA;AAAA;AAaO,MAAM,6BAA6B,+BAAY;AAAA,EAClD,MAAM,oBAAoB;AACtB,UAAM,EAAE,gBAAgB,IAAI,KAAK;AAEjC,UAAM,eAAe,KAAK;AAI1B,UAAM,KAAK,UAAU,eAAe,EAAE,aAAa,CAAC;AAGpD,UAAM;AAAA,MACF,MAAM;AAAA,MACN,SAAS,EAAE,cAAc,kBAAkB,KAAK;AAAA,IACpD,IAAI,MAAM,KAAK,UAAU,UAAU;AACnC,SAAK,gBAAgB,kBAAkB,YAAY;AAGnD,QAAI,KAAK,eAAe,iBAAiB,MAAM,WAAW,GAAG;AACzD,WAAK,oBAAoB;AACzB,aAAO;AAAA,IACX;AAEA,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/bdx/flow/Flow.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Flow_exports = {};
+__export(Flow_exports, {
+  Flow: () => Flow
+});
+module.exports = __toCommonJS(Flow_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_BdxError = require("../BdxError.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_general.InternalError("Transfer already finalized. finalizeTransfer() should only be called once.");
+    }
+    this.#finalBlockCounter = blockCounter;
+  }
+  get finalBlockCounter() {
+    if (this.#finalBlockCounter === void 0) {
+      throw new import_general.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 import_BdxError.BdxError(
+        `Received Block with unexpected block counter: ${messageBlockCounter}, expected: ${expectedCounter}`,
+        import_types.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 = {}));
+//# sourceMappingURL=Flow.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/Flow.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA8B;AAC9B,mBAA8B;AAC9B,sBAAyB;AARzB;AAAA;AAAA;AAAA;AAAA;AAaO,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,6BAAc,4EAA4E;AAAA,IACxG;AACA,SAAK,qBAAqB;AAAA,EAC9B;AAAA,EAEA,IAAc,oBAAoB;AAC9B,QAAI,KAAK,uBAAuB,QAAW;AACvC,YAAM,IAAI,6BAAc,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,2BAAc;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/cjs/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/cjs/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"}