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

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

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BdxMessageType } from "#types";
+import { Flow } from "./flow/Flow.js";
+import { PersistedFileDesignator } from "./PersistedFileDesignator.js";
+import { BdxInit } from "./schema/BdxInitMessagesSchema.js";
+export declare class BdxSessionConfiguration {
+    #private;
+    constructor(options: BdxSessionConfiguration.Options);
+    get isSender(): boolean;
+    get initMessage(): BdxInit | undefined;
+    get isInitiator(): boolean;
+    get fileDesignator(): PersistedFileDesignator;
+    get transferConfig(): BdxSessionConfiguration.Config;
+}
+export declare namespace BdxSessionConfiguration {
+    interface Config {
+        /**
+         * Array of preferred transfer driver modes, in order of preference. Use this to configure the proposed behavior.
+         * Default is [SenderDrive, ReceiverDrive]
+         */
+        preferredDriverModes?: Flow.DriverMode[];
+        /** Asynchronous transfer is not supported right now because provisional. */
+        asynchronousTransferAllowed?: false;
+        /** Maximum block size to use for the session. This value is ignored if the transport only supports smaller blocks. */
+        maxBlockSize?: number;
+        /** Maximum transfer size to use for the session. Defaults to 100MB */
+        maxTransferSize?: number;
+        /** The start offset of the data to send. When using this, you need to know what you are doing. */
+        senderStartOffset?: number;
+        /** The maximum length of the data to send. When using this, you need to know what you are doing. */
+        senderMaxLength?: number;
+    }
+    const DefaultConfig: BdxSessionConfiguration.Config;
+    interface InitiatorOptions extends BdxSessionConfiguration.Config {
+        /** FileDesignator to use for the session. The value is usually pre-determined with the peer. */
+        fileDesignator: PersistedFileDesignator;
+    }
+    interface SenderInitiatorOptions extends InitiatorOptions {
+        /** The start offset of the data to send. When using this, you need to know what you are doing. */
+        senderStartOffset?: number;
+        /** The maximum length of the data to send. When using this, you need to know what you are doing. */
+        senderMaxLength?: number;
+    }
+    interface ReceiverOptions extends BdxSessionConfiguration.Config {
+        initMessageType: BdxMessageType;
+        initMessage: BdxInit;
+    }
+    interface Options extends BdxSessionConfiguration.Config {
+        /** True if the session is initiated as a sender, false for receiver */
+        isSender: boolean;
+        /** File designator to use for the session */
+        fileDesignator: PersistedFileDesignator;
+        /** The initial message received to start the session */
+        initMessage?: BdxInit;
+    }
+}
+//# sourceMappingURL=BdxSessionConfiguration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BdxSessionConfiguration.d.ts","sourceRoot":"","sources":["../../../src/bdx/BdxSessionConfiguration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAE5D,qBAAa,uBAAuB;;gBAMpB,OAAO,EAAE,uBAAuB,CAAC,OAAO;IAiCpD,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,WAAW,IAAI,OAAO,GAAG,SAAS,CAErC;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,cAAc,IAAI,uBAAuB,CAE5C;IAED,IAAI,cAAc,IAAI,uBAAuB,CAAC,MAAM,CAEnD;CACJ;AAED,yBAAiB,uBAAuB,CAAC;IACrC,UAAiB,MAAM;QACnB;;;WAGG;QACH,oBAAoB,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC;QAEzC,4EAA4E;QAC5E,2BAA2B,CAAC,EAAE,KAAK,CAAC;QAEpC,sHAAsH;QACtH,YAAY,CAAC,EAAE,MAAM,CAAC;QAEtB,sEAAsE;QACtE,eAAe,CAAC,EAAE,MAAM,CAAC;QAEzB,kGAAkG;QAClG,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAE3B,oGAAoG;QACpG,eAAe,CAAC,EAAE,MAAM,CAAC;KAC5B;IAEM,MAAM,aAAa,EAAE,uBAAuB,CAAC,MAOnD,CAAC;IAEF,UAAiB,gBAAiB,SAAQ,uBAAuB,CAAC,MAAM;QACpE,gGAAgG;QAChG,cAAc,EAAE,uBAAuB,CAAC;KAC3C;IAED,UAAiB,sBAAuB,SAAQ,gBAAgB;QAC5D,kGAAkG;QAClG,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAE3B,oGAAoG;QACpG,eAAe,CAAC,EAAE,MAAM,CAAC;KAC5B;IAED,UAAiB,eAAgB,SAAQ,uBAAuB,CAAC,MAAM;QACnE,eAAe,EAAE,cAAc,CAAC;QAChC,WAAW,EAAE,OAAO,CAAC;KACxB;IAED,UAAiB,OAAQ,SAAQ,uBAAuB,CAAC,MAAM;QAC3D,uEAAuE;QACvE,QAAQ,EAAE,OAAO,CAAC;QAElB,6CAA6C;QAC7C,cAAc,EAAE,uBAAuB,CAAC;QAExC,wDAAwD;QACxD,WAAW,CAAC,EAAE,OAAO,CAAC;KACzB;CACJ"}

package/dist/esm/bdx/BdxSessionConfiguration.js

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ImplementationError } from "#general";
+import { Flow } from "./flow/Flow.js";
+class BdxSessionConfiguration {
+  #isSender;
+  #initMessage;
+  #transferConfig;
+  #fileDesignator;
+  constructor(options) {
+    const { isSender, fileDesignator, initMessage } = options;
+    this.#fileDesignator = fileDesignator;
+    this.#isSender = isSender;
+    this.#initMessage = initMessage;
+    this.#transferConfig = { ...BdxSessionConfiguration.DefaultConfig, ...options };
+    const {
+      preferredDriverModes = [],
+      maxBlockSize,
+      maxTransferSize,
+      asynchronousTransferAllowed,
+      senderStartOffset,
+      senderMaxLength
+    } = this.#transferConfig;
+    if (preferredDriverModes.length === 0) {
+      throw new ImplementationError("At least one preferred driver mode must be set.");
+    }
+    if (maxBlockSize !== void 0 && maxBlockSize <= 0) {
+      throw new ImplementationError("Max block size must be greater than 0");
+    }
+    if (maxTransferSize !== void 0 && maxTransferSize <= 0) {
+      throw new ImplementationError("Max transfer size must be greater than 0");
+    }
+    if (asynchronousTransferAllowed) {
+      throw new ImplementationError("Asynchronous transfer is not supported");
+    }
+    if (!isSender && (senderStartOffset !== void 0 || senderMaxLength !== void 0)) {
+      throw new ImplementationError("Sender start offset and sender max length are only supported for senders");
+    }
+  }
+  get isSender() {
+    return this.#isSender;
+  }
+  get initMessage() {
+    return this.#initMessage;
+  }
+  get isInitiator() {
+    return this.#initMessage === void 0;
+  }
+  get fileDesignator() {
+    return this.#fileDesignator;
+  }
+  get transferConfig() {
+    return this.#transferConfig;
+  }
+}
+((BdxSessionConfiguration2) => {
+  BdxSessionConfiguration2.DefaultConfig = {
+    preferredDriverModes: [
+      Flow.DriverMode.SenderDrive,
+      // Default if multiple is supported, so lets use this
+      Flow.DriverMode.ReceiverDrive
+    ],
+    asynchronousTransferAllowed: false,
+    // Provisional, not supported
+    maxTransferSize: 1024 * 1e5
+    // 100 MB, lets use that as maximum transfer filesize for now just to protect
+  };
+})(BdxSessionConfiguration || (BdxSessionConfiguration = {}));
+export {
+  BdxSessionConfiguration
+};
+//# sourceMappingURL=BdxSessionConfiguration.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/BdxSessionConfiguration.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,2BAA2B;AAEpC,SAAS,YAAY;AAId,MAAM,wBAAwB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,SAA0C;AAClD,UAAM,EAAE,UAAU,gBAAgB,YAAY,IAAI;AAClD,SAAK,kBAAkB;AACvB,SAAK,YAAY;AACjB,SAAK,eAAe;AACpB,SAAK,kBAAkB,EAAE,GAAG,wBAAwB,eAAe,GAAG,QAAQ;AAG9E,UAAM;AAAA,MACF,uBAAuB,CAAC;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACJ,IAAI,KAAK;AACT,QAAI,qBAAqB,WAAW,GAAG;AACnC,YAAM,IAAI,oBAAoB,iDAAiD;AAAA,IACnF;AACA,QAAI,iBAAiB,UAAa,gBAAgB,GAAG;AACjD,YAAM,IAAI,oBAAoB,uCAAuC;AAAA,IACzE;AACA,QAAI,oBAAoB,UAAa,mBAAmB,GAAG;AACvD,YAAM,IAAI,oBAAoB,0CAA0C;AAAA,IAC5E;AACA,QAAI,6BAA6B;AAC7B,YAAM,IAAI,oBAAoB,wCAAwC;AAAA,IAC1E;AACA,QAAI,CAAC,aAAa,sBAAsB,UAAa,oBAAoB,SAAY;AACjF,YAAM,IAAI,oBAAoB,0EAA0E;AAAA,IAC5G;AAAA,EACJ;AAAA,EAEA,IAAI,WAAoB;AACpB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAI,cAAmC;AACnC,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAI,cAAuB;AACvB,WAAO,KAAK,iBAAiB;AAAA,EACjC;AAAA,EAEA,IAAI,iBAA0C;AAC1C,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,IAAI,iBAAiD;AACjD,WAAO,KAAK;AAAA,EAChB;AACJ;AAAA,CAEO,CAAUA,6BAAV;AAwBI,EAAMA,yBAAA,gBAAgD;AAAA,IACzD,sBAAsB;AAAA,MAClB,KAAK,WAAW;AAAA;AAAA,MAChB,KAAK,WAAW;AAAA,IACpB;AAAA,IACA,6BAA6B;AAAA;AAAA,IAC7B,iBAAiB,OAAQ;AAAA;AAAA,EAC7B;AAAA,GA/Ba;",
+  "names": ["BdxSessionConfiguration"]
+}

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+/**
+ * Class to represent a File designator from Matter.
+ * Specification wise this is a bytes object, but to store in a storage we need a string name.
+ * This class provides a way to convert between the two.
+ */
+export declare class FileDesignator {
+    #private;
+    /** Create a FileDesignator from a string or bytes object. */
+    constructor(fd: string | Bytes);
+    /** Return the bytes representation of the FileDesignator. */
+    get bytes(): Bytes;
+    /** Return the textual/string representation of the FileDesignator. */
+    get text(): string;
+}
+//# sourceMappingURL=FileDesignator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileDesignator.d.ts","sourceRoot":"","sources":["../../../src/bdx/FileDesignator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;GAIG;AACH,qBAAa,cAAc;;IAGvB,6DAA6D;gBACjD,EAAE,EAAE,MAAM,GAAG,KAAK;IAQ9B,6DAA6D;IAC7D,IAAI,KAAK,IAAI,KAAK,CAEjB;IAED,sEAAsE;IACtE,IAAI,IAAI,IAAI,MAAM,CAgBjB;CACJ"}

package/dist/esm/bdx/FileDesignator.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+class FileDesignator {
+  #fd;
+  /** Create a FileDesignator from a string or bytes object. */
+  constructor(fd) {
+    if (typeof fd === "string") {
+      this.#fd = Bytes.fromString(fd);
+    } else {
+      this.#fd = fd;
+    }
+  }
+  /** Return the bytes representation of the FileDesignator. */
+  get bytes() {
+    return this.#fd;
+  }
+  /** Return the textual/string representation of the FileDesignator. */
+  get text() {
+    const fileDesignatorData = Bytes.of(this.#fd);
+    const isValidName = fileDesignatorData.every(
+      (byte) => byte >= 65 && byte <= 90 || // A-Z
+      byte >= 97 && byte <= 122 || // a-z
+      byte >= 48 && byte <= 57 || // 0..9
+      byte === 46 || // "."
+      byte === 45
+      // "-"
+    );
+    if (isValidName) {
+      return fileDesignatorData.reduce((name, byte) => name + String.fromCharCode(byte), "");
+    } else {
+      return `0x${Bytes.toHex(fileDesignatorData)}`;
+    }
+  }
+}
+export {
+  FileDesignator
+};
+//# sourceMappingURL=FileDesignator.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/FileDesignator.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,aAAa;AAOf,MAAM,eAAe;AAAA,EACxB;AAAA;AAAA,EAGA,YAAY,IAAoB;AAC5B,QAAI,OAAO,OAAO,UAAU;AACxB,WAAK,MAAM,MAAM,WAAW,EAAE;AAAA,IAClC,OAAO;AACH,WAAK,MAAM;AAAA,IACf;AAAA,EACJ;AAAA;AAAA,EAGA,IAAI,QAAe;AACf,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGA,IAAI,OAAe;AACf,UAAM,qBAAqB,MAAM,GAAG,KAAK,GAAG;AAE5C,UAAM,cAAc,mBAAmB;AAAA,MACnC,UACK,QAAQ,MAAQ,QAAQ;AAAA,MACxB,QAAQ,MAAQ,QAAQ;AAAA,MACxB,QAAQ,MAAQ,QAAQ;AAAA,MACzB,SAAS;AAAA,MACT,SAAS;AAAA;AAAA,IACjB;AACA,QAAI,aAAa;AACb,aAAO,mBAAmB,OAAO,CAAC,MAAM,SAAS,OAAO,OAAO,aAAa,IAAI,GAAG,EAAE;AAAA,IACzF,OAAO;AACH,aAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAAA,IAC/C;AAAA,EACJ;AACJ;",
+  "names": []
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes, StorageContext } from "#general";
+import { FileDesignator } from "./FileDesignator.js";
+/** A FileDesignator that points to a persisted file in a given StorageContext. */
+export declare class PersistedFileDesignator extends FileDesignator {
+    #private;
+    constructor(fd: string | Bytes, storage: StorageContext);
+    exists(): import("#general").MaybePromise<boolean>;
+    openBlob(): Promise<Blob>;
+    writeFromStream(stream: ReadableStream<Bytes>): import("#general").MaybePromise<void>;
+}
+//# sourceMappingURL=PersistedFileDesignator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PersistedFileDesignator.d.ts","sourceRoot":"","sources":["../../../src/bdx/PersistedFileDesignator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAuB,cAAc,EAAE,MAAM,UAAU,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,kFAAkF;AAClF,qBAAa,uBAAwB,SAAQ,cAAc;;gBAI3C,EAAE,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,EAAE,cAAc;IAKvD,MAAM;IAIA,QAAQ;IAad,eAAe,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC;CAGhD"}

package/dist/esm/bdx/PersistedFileDesignator.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ImplementationError } from "#general";
+import { FileDesignator } from "./FileDesignator.js";
+class PersistedFileDesignator extends FileDesignator {
+  #storage;
+  #blob;
+  constructor(fd, storage) {
+    super(fd);
+    this.#storage = storage;
+  }
+  exists() {
+    return this.#storage.has(this.text);
+  }
+  async openBlob() {
+    if (this.#blob === void 0) {
+      const blobName = this.text;
+      if (!this.#storage.has(blobName)) {
+        throw new ImplementationError(
+          "File designator must point to an existing file in the storage to send data"
+        );
+      }
+      this.#blob = await this.#storage.openBlob(blobName);
+    }
+    return this.#blob;
+  }
+  writeFromStream(stream) {
+    return this.#storage.writeBlobFromStream(this.text, stream);
+  }
+}
+export {
+  PersistedFileDesignator
+};
+//# sourceMappingURL=PersistedFileDesignator.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bdx/PersistedFileDesignator.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAgB,2BAA2C;AAC3D,SAAS,sBAAsB;AAGxB,MAAM,gCAAgC,eAAe;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/esm/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/esm/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/esm/bdx/bdx-session-initiator.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ImplementationError, InternalError, Logger } from "#general";
+import { BdxStatusCode } from "#types";
+import { BdxError } from "./BdxError.js";
+import { BdxMessenger } from "./BdxMessenger.js";
+import { Flow } from "./flow/Flow.js";
+import { BDX_VERSION } from "./schema/BdxInitMessagesSchema.js";
+const logger = 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 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 BdxError(
+        `File designator ${config.fileDesignator.text} does not point to an existing file in the storage to send data`,
+        BdxStatusCode.FileDesignatorUnknown
+      );
+    }
+    let { startOffset } = initMessage;
+    if (startOffset !== void 0) {
+      startOffset = BdxMessenger.asSafeNumber(startOffset, "Start offset", 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 BdxError(
+          `Requested maxLength ${length}bytes${startOffset ? ` with startOffset ${startOffset}` : ""} exceeds available size ${blobToRead.size} for blob ${config.fileDesignator.text}`,
+          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 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 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: BDX_VERSION,
+        senderDrive: !!preferredDriverModes?.includes(Flow.DriverMode.SenderDrive),
+        receiverDrive: !!preferredDriverModes?.includes(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 BdxError("Can not determine a valid transfer mode", BdxStatusCode.TransferMethodNotSupported);
+    }
+    const requestedMaxBlockSize = config.transferConfig.maxBlockSize;
+    if (requestedMaxBlockSize !== void 0 && maxBlockSize > requestedMaxBlockSize) {
+      maxBlockSize = requestedMaxBlockSize;
+    }
+    const maxLength = BdxMessenger.asSafeNumber(initMaxLength, "Max length", BdxStatusCode.LengthTooLarge);
+    const transferControl = {
+      version: 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 BdxError(
+        "Asynchronous transfer is not supported in this implementation",
+        BdxStatusCode.TransferMethodNotSupported
+      );
+    }
+    const dataLength = "length" in acceptMessage2 && acceptMessage2.length !== void 0 ? BdxMessenger.asSafeNumber(
+      acceptMessage2.length,
+      "Accept message length field",
+      BdxStatusCode.LengthTooLarge
+    ) : maxLength;
+    const transferParameters = {
+      transferMode: senderDrive ? Flow.DriverMode.SenderDrive : 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;
+  }
+}
+export {
+  bdxSessionInitiator
+};
+//# sourceMappingURL=bdx-session-initiator.js.map

package/dist/esm/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/esm/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/esm/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/esm/bdx/flow/DrivenSendingFlow.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OutboundFlow } from "./OutboundFlow.js";
+class DrivenSendingFlow extends 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;
+  }
+}
+export {
+  DrivenSendingFlow
+};
+//# sourceMappingURL=DrivenSendingFlow.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/DrivenSendingFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,oBAAoB;AAOtB,MAAM,0BAA0B,aAAa;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/esm/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/esm/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/esm/bdx/flow/DrivingReceivingFlow.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InboundFlow } from "./InboundFlow.js";
+class DrivingReceivingFlow extends 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;
+  }
+}
+export {
+  DrivingReceivingFlow
+};
+//# sourceMappingURL=DrivingReceivingFlow.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/flow/DrivingReceivingFlow.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,mBAAmB;AAOrB,MAAM,6BAA6B,YAAY;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": []
+}