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

package/dist/esm/bdx/schema/BdxAcceptMessagesSchema.js

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataReader, DataWriter, Endian } from "#general";
+import { BdxStatusCode, Schema } from "#types";
+import { BdxError } from "../BdxError.js";
+import {
+  BDX_VERSION,
+  BdxRangeControlSchema,
+  BdxTransferControlSchema
+} from "./BdxInitMessagesSchema.js";
+class BdxSendAcceptMessageSchema extends Schema {
+  encodeInternal(message) {
+    this.validate(message);
+    const { transferControl, maxBlockSize, metaData } = message;
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt8(BdxTransferControlSchema.encode(transferControl));
+    writer.writeUInt16(maxBlockSize);
+    if (metaData && metaData.byteLength > 0) {
+      writer.writeByteArray(metaData);
+    }
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    const transferControl = BdxTransferControlSchema.decode(reader.readUInt8());
+    const maxBlockSize = reader.readUInt16();
+    const metaData = reader.remainingBytesCount > 0 ? reader.remainingBytes : void 0;
+    const result = {
+      transferControl,
+      maxBlockSize,
+      metaData
+    };
+    this.validate(result);
+    return result;
+  }
+  validate({ transferControl, maxBlockSize }) {
+    if (transferControl.version !== BDX_VERSION) {
+      throw new BdxError(
+        `Unsupported BDX version: ${transferControl.version}`,
+        BdxStatusCode.VersionNotSupported
+      );
+    }
+    if (!transferControl.senderDrive && !transferControl.receiverDrive && !transferControl.asynchronousTransfer) {
+      throw new BdxError(
+        "BDX transfer control need to specify at least one of sender drive, receiver drive or asynchronousTransfer",
+        BdxStatusCode.BadMessageContent
+      );
+    }
+    if (maxBlockSize < 1 || maxBlockSize > 65535) {
+      throw new BdxError("Max Block Size must be between 1 and 65535bytes", BdxStatusCode.BadMessageContent);
+    }
+  }
+}
+const BdxSendAcceptMessage = new BdxSendAcceptMessageSchema();
+class BdxReceiveAcceptMessageSchema extends BdxSendAcceptMessageSchema {
+  encodeInternal(message) {
+    this.validate(message);
+    const { transferControl, maxBlockSize, metaData, length } = message;
+    const rangeControl = {
+      definiteLength: length !== void 0 && length !== 0,
+      wideRange: typeof length === "bigint"
+    };
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt8(BdxTransferControlSchema.encode(transferControl));
+    writer.writeUInt8(BdxRangeControlSchema.encode(rangeControl));
+    writer.writeUInt16(maxBlockSize);
+    if (length !== void 0 && length !== 0) {
+      if (rangeControl.wideRange) {
+        writer.writeUInt64(length);
+      } else {
+        writer.writeUInt32(length);
+      }
+    }
+    if (metaData && metaData.byteLength > 0) {
+      writer.writeByteArray(metaData);
+    }
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    const transferControl = BdxTransferControlSchema.decode(reader.readUInt8());
+    const rangeControl = BdxRangeControlSchema.decode(reader.readUInt8());
+    const maxBlockSize = reader.readUInt16();
+    let length = rangeControl.definiteLength ? rangeControl.wideRange ? reader.readUInt64() : reader.readUInt32() : void 0;
+    if (length === 0) {
+      length = void 0;
+    }
+    const metaData = reader.remainingBytesCount > 0 ? reader.remainingBytes : void 0;
+    const result = {
+      transferControl,
+      maxBlockSize,
+      metaData,
+      length
+    };
+    this.validate(result);
+    return result;
+  }
+}
+const BdxReceiveAcceptMessage = new BdxReceiveAcceptMessageSchema();
+export {
+  BdxReceiveAcceptMessage,
+  BdxReceiveAcceptMessageSchema,
+  BdxSendAcceptMessage,
+  BdxSendAcceptMessageSchema
+};
+//# sourceMappingURL=BdxAcceptMessagesSchema.js.map

package/dist/esm/bdx/schema/BdxAcceptMessagesSchema.js.map

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

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

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+import { Schema } from "#types";
+interface BdxCounterOnly {
+    blockCounter: number;
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.2 */
+export interface BdxBlockQuery extends BdxCounterOnly {
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.6 */
+export interface BdxBlockAck extends BdxCounterOnly {
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.7 */
+export interface BdxBlockAckEof extends BdxCounterOnly {
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.3 */
+export interface BdxBlockQueryWithSkip extends BdxCounterOnly {
+    bytesToSkip: number | bigint;
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.4 */
+export interface BdxBlock extends BdxCounterOnly {
+    data: Bytes;
+}
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.6.5 */
+export interface BdxBlockEof extends BdxBlock {
+}
+/** Schema for BDX messages that only contain a block counter: BlockQuery, BlockAck, BlockAckEof. */
+export declare class BdxCounterOnlyMessageSchema extends Schema<BdxCounterOnly> {
+    encodeInternal(message: BdxCounterOnly): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): BdxCounterOnly;
+}
+export declare const BdxBlockQueryMessage: BdxCounterOnlyMessageSchema;
+export declare const BdxBlockAckMessage: BdxCounterOnlyMessageSchema;
+export declare const BdxBlockAckEofMessage: BdxCounterOnlyMessageSchema;
+/** Schema for BDX BlockQueryWithSkip message. */
+export declare class BdxBlockQueryWithSkipMessageSchema extends Schema<BdxBlockQueryWithSkip> {
+    encodeInternal(message: BdxBlockQueryWithSkip): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): BdxBlockQueryWithSkip;
+}
+export declare const BdxBlockQueryWithSkipMessage: BdxBlockQueryWithSkipMessageSchema;
+/** Schema for BDX Block and BlockEof message that contain Block data. */
+export declare class BdxBlockMessageSchema extends Schema<BdxBlock> {
+    encodeInternal(message: BdxBlock): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): BdxBlock;
+}
+export declare const BdxBlockMessage: BdxBlockMessageSchema;
+export declare const BdxBlockEofMessage: BdxBlockMessageSchema;
+export {};
+//# sourceMappingURL=BdxBlockMessagesSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BdxBlockMessagesSchema.d.ts","sourceRoot":"","sources":["../../../../src/bdx/schema/BdxBlockMessagesSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAkC,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,UAAU,cAAc;IACpB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,oEAAoE;AACpE,MAAM,WAAW,aAAc,SAAQ,cAAc;CAAG;AAExD,oEAAoE;AACpE,MAAM,WAAW,WAAY,SAAQ,cAAc;CAAG;AAEtD,oEAAoE;AACpE,MAAM,WAAW,cAAe,SAAQ,cAAc;CAAG;AAEzD,oEAAoE;AACpE,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IACzD,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC;AAED,oEAAoE;AACpE,MAAM,WAAW,QAAS,SAAQ,cAAc;IAC5C,IAAI,EAAE,KAAK,CAAC;CACf;AAED,oEAAoE;AACpE,MAAM,WAAW,WAAY,SAAQ,QAAQ;CAAG;AAEhD,oGAAoG;AACpG,qBAAa,2BAA4B,SAAQ,MAAM,CAAC,cAAc,CAAC;IACnE,cAAc,CAAC,OAAO,EAAE,cAAc;IAQtC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc;CAM/C;AAED,eAAO,MAAM,oBAAoB,6BAAwB,CAAC;AAC1D,eAAO,MAAM,kBAAkB,6BAAwB,CAAC;AACxD,eAAO,MAAM,qBAAqB,6BAAwB,CAAC;AAE3D,iDAAiD;AACjD,qBAAa,kCAAmC,SAAQ,MAAM,CAAC,qBAAqB,CAAC;IACjF,cAAc,CAAC,OAAO,EAAE,qBAAqB;IAS7C,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,qBAAqB;CAOtD;AACD,eAAO,MAAM,4BAA4B,oCAA2C,CAAC;AAErF,yEAAyE;AACzE,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,QAAQ,CAAC;IACvD,cAAc,CAAC,OAAO,EAAE,QAAQ;IAShC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ;CAOzC;AACD,eAAO,MAAM,eAAe,uBAA8B,CAAC;AAC3D,eAAO,MAAM,kBAAkB,uBAAkB,CAAC"}

package/dist/esm/bdx/schema/BdxBlockMessagesSchema.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataReader, DataWriter, Endian } from "#general";
+import { Schema } from "#types";
+class BdxCounterOnlyMessageSchema extends Schema {
+  encodeInternal(message) {
+    const { blockCounter } = message;
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt32(blockCounter);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    return {
+      blockCounter: reader.readUInt32()
+    };
+  }
+}
+const BdxCounterOnlyMessage = new BdxCounterOnlyMessageSchema();
+const BdxBlockQueryMessage = BdxCounterOnlyMessage;
+const BdxBlockAckMessage = BdxCounterOnlyMessage;
+const BdxBlockAckEofMessage = BdxCounterOnlyMessage;
+class BdxBlockQueryWithSkipMessageSchema extends Schema {
+  encodeInternal(message) {
+    const { blockCounter, bytesToSkip } = message;
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt32(blockCounter);
+    writer.writeUInt64(bytesToSkip);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    return {
+      blockCounter: reader.readUInt32(),
+      bytesToSkip: reader.readUInt64()
+    };
+  }
+}
+const BdxBlockQueryWithSkipMessage = new BdxBlockQueryWithSkipMessageSchema();
+class BdxBlockMessageSchema extends Schema {
+  encodeInternal(message) {
+    const { blockCounter, data } = message;
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt32(blockCounter);
+    writer.writeByteArray(data);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    return {
+      blockCounter: reader.readUInt32(),
+      data: reader.remainingBytes
+    };
+  }
+}
+const BdxBlockMessage = new BdxBlockMessageSchema();
+const BdxBlockEofMessage = BdxBlockMessage;
+export {
+  BdxBlockAckEofMessage,
+  BdxBlockAckMessage,
+  BdxBlockEofMessage,
+  BdxBlockMessage,
+  BdxBlockMessageSchema,
+  BdxBlockQueryMessage,
+  BdxBlockQueryWithSkipMessage,
+  BdxBlockQueryWithSkipMessageSchema,
+  BdxCounterOnlyMessageSchema
+};
+//# sourceMappingURL=BdxBlockMessagesSchema.js.map

package/dist/esm/bdx/schema/BdxBlockMessagesSchema.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/schema/BdxBlockMessagesSchema.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAgB,YAAY,YAAY,cAAc;AACtD,SAAS,cAAc;AA6BhB,MAAM,oCAAoC,OAAuB;AAAA,EACpE,eAAe,SAAyB;AACpC,UAAM,EAAE,aAAa,IAAI;AAEzB,UAAM,SAAS,IAAI,WAAW,OAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAA8B;AACzC,UAAM,SAAS,IAAI,WAAW,OAAO,OAAO,MAAM;AAClD,WAAO;AAAA,MACH,cAAc,OAAO,WAAW;AAAA,IACpC;AAAA,EACJ;AACJ;AACA,MAAM,wBAAwB,IAAI,4BAA4B;AACvD,MAAM,uBAAuB;AAC7B,MAAM,qBAAqB;AAC3B,MAAM,wBAAwB;AAG9B,MAAM,2CAA2C,OAA8B;AAAA,EAClF,eAAe,SAAgC;AAC3C,UAAM,EAAE,cAAc,YAAY,IAAI;AAEtC,UAAM,SAAS,IAAI,WAAW,OAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,YAAY,WAAW;AAC9B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAAqC;AAChD,UAAM,SAAS,IAAI,WAAW,OAAO,OAAO,MAAM;AAClD,WAAO;AAAA,MACH,cAAc,OAAO,WAAW;AAAA,MAChC,aAAa,OAAO,WAAW;AAAA,IACnC;AAAA,EACJ;AACJ;AACO,MAAM,+BAA+B,IAAI,mCAAmC;AAG5E,MAAM,8BAA8B,OAAiB;AAAA,EACxD,eAAe,SAAmB;AAC9B,UAAM,EAAE,cAAc,KAAK,IAAI;AAE/B,UAAM,SAAS,IAAI,WAAW,OAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,eAAe,IAAI;AAC1B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAAwB;AACnC,UAAM,SAAS,IAAI,WAAW,OAAO,OAAO,MAAM;AAClD,WAAO;AAAA,MACH,cAAc,OAAO,WAAW;AAAA,MAChC,MAAM,OAAO;AAAA,IACjB;AAAA,EACJ;AACJ;AACO,MAAM,kBAAkB,IAAI,sBAAsB;AAClD,MAAM,qBAAqB;",
+  "names": []
+}

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

@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+import { BitField, BitFlag, Schema, TypeFromPartialBitSchema } from "#types";
+export declare const BDX_VERSION = 0;
+/**
+ * BDX Transfer protocol bitmap definition
+ * Bit 7 is reserved for future use
+ *
+ * @see {@link MatterSpecification.v141.Core}, section 11.22.5.1
+ */
+export declare const BdxTransferControlBitmap: {
+    /** Protocol Version, Only allowed version is 0.0 for now */
+    version: BitField;
+    /** Indicates if Sender drive is supported by Initiator */
+    senderDrive: BitFlag;
+    /** Indicates if Receiver drive is supported by Initiator */
+    receiverDrive: BitFlag;
+    /**
+     * Indicates if Asynchronous Transfer is supported by Initiator
+     * Synchronous mode is always implicitly supported.
+     */
+    asynchronousTransfer: BitFlag;
+};
+export declare const BdxTransferControlSchema: import("#types").BitmapSchemaInternal<{
+    /** Protocol Version, Only allowed version is 0.0 for now */
+    version: BitField;
+    /** Indicates if Sender drive is supported by Initiator */
+    senderDrive: BitFlag;
+    /** Indicates if Receiver drive is supported by Initiator */
+    receiverDrive: BitFlag;
+    /**
+     * Indicates if Asynchronous Transfer is supported by Initiator
+     * Synchronous mode is always implicitly supported.
+     */
+    asynchronousTransfer: BitFlag;
+}>;
+/**
+ * BDX Range control bitmap definition
+ * Bits 2-3 and 5-7 is reserved for future use
+ *
+ * @see {@link MatterSpecification.v141.Core}, section 11.22.5.1
+ */
+export declare const BdxRangeControlBitmap: {
+    /** Indicates if the transfer has a definite length */
+    definiteLength: BitFlag;
+    /** Indicates if the transfer has a start offset */
+    startOffset: BitFlag;
+    /**
+     * Indicates if wide (64-bit) range enabled for values
+     * Offset (STARTFOFS) and length (DEFLEN) are 4 octets (32-bit) little-endian unsigned quantities.
+     */
+    wideRange: BitFlag;
+};
+export declare const BdxRangeControlSchema: import("#types").BitmapSchemaInternal<{
+    /** Indicates if the transfer has a definite length */
+    definiteLength: BitFlag;
+    /** Indicates if the transfer has a start offset */
+    startOffset: BitFlag;
+    /**
+     * Indicates if wide (64-bit) range enabled for values
+     * Offset (STARTFOFS) and length (DEFLEN) are 4 octets (32-bit) little-endian unsigned quantities.
+     */
+    wideRange: BitFlag;
+}>;
+/** @see {@link MatterSpecification.v141.Core}, section 11.22.5.1 */
+export type BdxInit = {
+    /**
+     * Transfer protocol details
+     * PTC
+     * 1 octet
+     */
+    transferProtocol: TypeFromPartialBitSchema<typeof BdxTransferControlBitmap>;
+    /**
+     * Range Control details - Removed because it is used by encoding/decoding implicitly
+     * RTC, 1 octet
+     */
+    /**
+     * Specifies the maximum data size (in bytes) of the block that the Initiator supports, exclusive of block header
+     * fields, such as a block counter.
+     * PMBS, 2 octets
+     */
+    maxBlockSize: number;
+    /**
+     * Optional 32-bit/64-bit length that specifies the offset in bytes from start of the file from which the Sender
+     * would start the transfer.
+     * STARTOFS, 4/8 octets
+     */
+    startOffset?: number | bigint;
+    /**
+     * Specifies a predetermined definite length for the transfer
+     * DEFLEN, 4/8 octets
+     */
+    maxLength?: number | bigint;
+    /**
+     * Identifier chosen by the Initiator to identify the payload to be transferred.
+     * FD, 2 octets + Variable length
+     */
+    fileDesignator: Bytes;
+    /**
+     * Allows the Initiator to send additional application-specific information about the file to be transferred
+     * MD, Variable length, TLV
+     */
+    metaData?: Bytes;
+};
+/** Schema for BDX SendInit and ReceiveInit messages. */
+export declare class BdxInitMessageSchema extends Schema<BdxInit> {
+    encodeInternal(message: BdxInit): Uint8Array<ArrayBufferLike>;
+    decodeInternal(bytes: Bytes): BdxInit;
+    validate({ transferProtocol, maxBlockSize, fileDesignator }: BdxInit): void;
+}
+export declare const BdxSendInitMessage: BdxInitMessageSchema;
+export declare const BdxReceiveInitMessage: BdxInitMessageSchema;
+//# sourceMappingURL=BdxInitMessagesSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BdxInitMessagesSchema.d.ts","sourceRoot":"","sources":["../../../../src/bdx/schema/BdxInitMessagesSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAkC,MAAM,UAAU,CAAC;AACjE,OAAO,EAAiB,QAAQ,EAAE,OAAO,EAAgB,MAAM,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAG1G,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;IACjC,4DAA4D;;IAG5D,0DAA0D;;IAG1D,4DAA4D;;IAG5D;;;OAGG;;CAEN,CAAC;AACF,eAAO,MAAM,wBAAwB;IAfjC,4DAA4D;;IAG5D,0DAA0D;;IAG1D,4DAA4D;;IAG5D;;;OAGG;;EAGuE,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;IAC9B,sDAAsD;;IAGtD,mDAAmD;;IAGnD;;;OAGG;;CAEN,CAAC;AACF,eAAO,MAAM,qBAAqB;IAZ9B,sDAAsD;;IAGtD,mDAAmD;;IAGnD;;;OAGG;;EAGiE,CAAC;AAEzE,oEAAoE;AACpE,MAAM,MAAM,OAAO,GAAG;IAClB;;;;OAIG;IACH,gBAAgB,EAAE,wBAAwB,CAAC,OAAO,wBAAwB,CAAC,CAAC;IAE5E;;;OAGG;IAGH;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE9B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B;;;OAGG;IACH,cAAc,EAAE,KAAK,CAAC;IAEtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC;CACpB,CAAC;AAEF,wDAAwD;AACxD,qBAAa,oBAAqB,SAAQ,MAAM,CAAC,OAAO,CAAC;IACrD,cAAc,CAAC,OAAO,EAAE,OAAO;IAwC/B,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAqC5B,QAAQ,CAAC,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,EAAE,OAAO;CA0BhF;AACD,eAAO,MAAM,kBAAkB,sBAA6B,CAAC;AAC7D,eAAO,MAAM,qBAAqB,sBAAqB,CAAC"}

package/dist/esm/bdx/schema/BdxInitMessagesSchema.js

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataReader, DataWriter, Endian } from "#general";
+import { BdxStatusCode, BitField, BitFlag, BitmapSchema, Schema } from "#types";
+import { BdxError } from "../BdxError.js";
+const BDX_VERSION = 0;
+const BdxTransferControlBitmap = {
+  /** Protocol Version, Only allowed version is 0.0 for now */
+  version: BitField(0, 4),
+  /** Indicates if Sender drive is supported by Initiator */
+  senderDrive: BitFlag(4),
+  /** Indicates if Receiver drive is supported by Initiator */
+  receiverDrive: BitFlag(5),
+  /**
+   * Indicates if Asynchronous Transfer is supported by Initiator
+   * Synchronous mode is always implicitly supported.
+   */
+  asynchronousTransfer: BitFlag(6)
+};
+const BdxTransferControlSchema = BitmapSchema(BdxTransferControlBitmap);
+const BdxRangeControlBitmap = {
+  /** Indicates if the transfer has a definite length */
+  definiteLength: BitFlag(0),
+  /** Indicates if the transfer has a start offset */
+  startOffset: BitFlag(1),
+  /**
+   * Indicates if wide (64-bit) range enabled for values
+   * Offset (STARTFOFS) and length (DEFLEN) are 4 octets (32-bit) little-endian unsigned quantities.
+   */
+  wideRange: BitFlag(4)
+};
+const BdxRangeControlSchema = BitmapSchema(BdxRangeControlBitmap);
+class BdxInitMessageSchema extends Schema {
+  encodeInternal(message) {
+    this.validate(message);
+    const { transferProtocol, maxBlockSize, startOffset, maxLength, fileDesignator, metaData } = message;
+    const rangeControl = {
+      startOffset: startOffset !== void 0,
+      definiteLength: maxLength !== void 0 && maxLength !== 0,
+      wideRange: typeof startOffset === "bigint" || typeof maxLength === "bigint"
+    };
+    const writer = new DataWriter(Endian.Little);
+    writer.writeUInt8(BdxTransferControlSchema.encode(transferProtocol));
+    writer.writeUInt8(BdxRangeControlSchema.encode(rangeControl));
+    writer.writeUInt16(maxBlockSize);
+    if (startOffset !== void 0) {
+      if (rangeControl.wideRange) {
+        writer.writeUInt64(startOffset);
+      } else {
+        writer.writeUInt32(startOffset);
+      }
+    }
+    if (maxLength !== void 0 && maxLength !== 0) {
+      if (rangeControl.wideRange) {
+        writer.writeUInt64(maxLength);
+      } else {
+        writer.writeUInt32(maxLength);
+      }
+    }
+    writer.writeUInt16(fileDesignator.byteLength);
+    writer.writeByteArray(fileDesignator);
+    if (metaData && metaData.byteLength > 0) {
+      writer.writeByteArray(metaData);
+    }
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new DataReader(bytes, Endian.Little);
+    const transferProtocol = BdxTransferControlSchema.decode(reader.readUInt8());
+    const rangeControl = BdxRangeControlSchema.decode(reader.readUInt8());
+    const maxBlockSize = reader.readUInt16();
+    const startOffset = rangeControl.startOffset ? rangeControl.wideRange ? reader.readUInt64() : reader.readUInt32() : void 0;
+    let maxLength = rangeControl.definiteLength ? rangeControl.wideRange ? reader.readUInt64() : reader.readUInt32() : void 0;
+    if (maxLength === 0) {
+      maxLength = void 0;
+    }
+    const fileDesignatorLength = reader.readUInt16();
+    const fileDesignator = reader.readByteArray(fileDesignatorLength);
+    const metaData = reader.remainingBytesCount > 0 ? reader.remainingBytes : void 0;
+    const result = {
+      transferProtocol,
+      maxBlockSize,
+      startOffset,
+      maxLength,
+      fileDesignator,
+      metaData
+    };
+    this.validate(result);
+    return result;
+  }
+  validate({ transferProtocol, maxBlockSize, fileDesignator }) {
+    if (transferProtocol.version !== BDX_VERSION) {
+      throw new BdxError(
+        `Unsupported BDX version: ${transferProtocol.version}`,
+        BdxStatusCode.VersionNotSupported
+      );
+    }
+    if (!transferProtocol.senderDrive && !transferProtocol.receiverDrive) {
+      throw new BdxError(
+        "BDX transfer protocol needs to allow either sender or receiver drive",
+        BdxStatusCode.BadMessageContent
+      );
+    }
+    if (fileDesignator.byteLength === 0) {
+      throw new BdxError("File Designator cannot be empty", BdxStatusCode.BadMessageContent);
+    }
+    if (fileDesignator.byteLength > 65535) {
+      throw new BdxError(
+        "File Designator length exceeds maximum allowed size of 65535bytes",
+        BdxStatusCode.BadMessageContent
+      );
+    }
+    if (maxBlockSize < 1 || maxBlockSize > 65535) {
+      throw new BdxError("Max Block Size must be between 1 and 65535bytes", BdxStatusCode.BadMessageContent);
+    }
+  }
+}
+const BdxSendInitMessage = new BdxInitMessageSchema();
+const BdxReceiveInitMessage = BdxSendInitMessage;
+export {
+  BDX_VERSION,
+  BdxInitMessageSchema,
+  BdxRangeControlBitmap,
+  BdxRangeControlSchema,
+  BdxReceiveInitMessage,
+  BdxSendInitMessage,
+  BdxTransferControlBitmap,
+  BdxTransferControlSchema
+};
+//# sourceMappingURL=BdxInitMessagesSchema.js.map

package/dist/esm/bdx/schema/BdxInitMessagesSchema.js.map

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

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes } from "#general";
+import { BdxMessageType, Schema, SchemaType } from "#types";
+export interface BdxMessage<T extends BdxMessageType> {
+    kind: T;
+    message: SchemaType<BdxMessage.Kinds[T]>;
+}
+/** Convenient wrapper around BDX message encoding/decoding and type guards. */
+export declare namespace BdxMessage {
+    function encode<T extends BdxMessageType>({ kind, message }: BdxMessage<T>): AllowSharedBufferSource;
+    function decode<T extends BdxMessageType>(kind: T, payload: Bytes): BdxMessage<T>;
+    function is<T extends BdxMessageType>(message: BdxMessage<any>, kind: T): message is BdxMessage<T>;
+    function assert<T extends BdxMessageType>(message: BdxMessage<any>, kind: T): asserts message is BdxMessage<T>;
+    const Kinds: {
+        [key: number]: Schema<any>;
+    };
+    type Kinds = typeof Kinds;
+}
+//# sourceMappingURL=BdxMessage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BdxMessage.d.ts","sourceRoot":"","sources":["../../../../src/bdx/schema/BdxMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAiB,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAY5D,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,cAAc;IAChD,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5C;AAED,+EAA+E;AAC/E,yBAAiB,UAAU,CAAC;IACxB,SAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC,2BAKhF;IAED,SAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAKvF;IAED,SAAgB,EAAE,CAAC,CAAC,SAAS,cAAc,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,CAExG;IAED,SAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAC3C,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,EACxB,IAAI,EAAE,CAAC,GACR,OAAO,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,CAMlC;IAEM,MAAM,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;KAWtC,CAAC;IAEX,KAAY,KAAK,GAAG,OAAO,KAAK,CAAC;CACpC"}

package/dist/esm/bdx/schema/BdxMessage.js

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "#general";
+import { BdxMessageType } from "#types";
+import { BdxReceiveAcceptMessage, BdxSendAcceptMessage } from "./BdxAcceptMessagesSchema.js";
+import {
+  BdxBlockAckEofMessage,
+  BdxBlockAckMessage,
+  BdxBlockEofMessage,
+  BdxBlockMessage,
+  BdxBlockQueryMessage,
+  BdxBlockQueryWithSkipMessage
+} from "./BdxBlockMessagesSchema.js";
+import { BdxReceiveInitMessage, BdxSendInitMessage } from "./BdxInitMessagesSchema.js";
+var BdxMessage;
+((BdxMessage2) => {
+  function encode({ kind, message }) {
+    if (!(kind in BdxMessage2.Kinds)) {
+      throw new InternalError(`Can not encode unknown BDX message type: ${kind}`);
+    }
+    return BdxMessage2.Kinds[kind].encode(message);
+  }
+  BdxMessage2.encode = encode;
+  function decode(kind, payload) {
+    if (!(kind in BdxMessage2.Kinds)) {
+      throw new InternalError(`Can not decode unknown BDX message type: ${kind}`);
+    }
+    return { kind, message: BdxMessage2.Kinds[kind].decode(payload) };
+  }
+  BdxMessage2.decode = decode;
+  function is(message, kind) {
+    return message.kind === kind;
+  }
+  BdxMessage2.is = is;
+  function assert(message, kind) {
+    if (message.kind !== kind) {
+      throw new InternalError(
+        `Expected BDX message of type ${BdxMessageType[kind]}, but got ${BdxMessageType[message.kind]}(${message.kind})`
+      );
+    }
+  }
+  BdxMessage2.assert = assert;
+  BdxMessage2.Kinds = {
+    [BdxMessageType.SendInit]: BdxSendInitMessage,
+    [BdxMessageType.ReceiveInit]: BdxReceiveInitMessage,
+    [BdxMessageType.SendAccept]: BdxSendAcceptMessage,
+    [BdxMessageType.ReceiveAccept]: BdxReceiveAcceptMessage,
+    [BdxMessageType.BlockQuery]: BdxBlockQueryMessage,
+    [BdxMessageType.BlockQueryWithSkip]: BdxBlockQueryWithSkipMessage,
+    [BdxMessageType.Block]: BdxBlockMessage,
+    [BdxMessageType.BlockEof]: BdxBlockEofMessage,
+    [BdxMessageType.BlockAck]: BdxBlockAckMessage,
+    [BdxMessageType.BlockAckEof]: BdxBlockAckEofMessage
+  };
+})(BdxMessage || (BdxMessage = {}));
+export {
+  BdxMessage
+};
+//# sourceMappingURL=BdxMessage.js.map

package/dist/esm/bdx/schema/BdxMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/schema/BdxMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAgB,qBAAqB;AACrC,SAAS,sBAA0C;AACnD,SAAS,yBAAyB,4BAA4B;AAC9D;AAAA,EACI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AACP,SAAS,uBAAuB,0BAA0B;AAQnD,IAAU;AAAA,CAAV,CAAUA,gBAAV;AACI,WAAS,OAAiC,EAAE,MAAM,QAAQ,GAAkB;AAC/E,QAAI,EAAE,QAAQA,YAAA,QAAQ;AAClB,YAAM,IAAI,cAAc,4CAA4C,IAAI,EAAE;AAAA,IAC9E;AACA,WAAOA,YAAA,MAAM,IAAI,EAAE,OAAO,OAAO;AAAA,EACrC;AALO,EAAAA,YAAS;AAOT,WAAS,OAAiC,MAAS,SAA+B;AACrF,QAAI,EAAE,QAAQA,YAAA,QAAQ;AAClB,YAAM,IAAI,cAAc,4CAA4C,IAAI,EAAE;AAAA,IAC9E;AACA,WAAO,EAAE,MAAM,SAASA,YAAA,MAAM,IAAI,EAAE,OAAO,OAAO,EAAE;AAAA,EACxD;AALO,EAAAA,YAAS;AAOT,WAAS,GAA6B,SAA0B,MAAmC;AACtG,WAAO,QAAQ,SAAS;AAAA,EAC5B;AAFO,EAAAA,YAAS;AAIT,WAAS,OACZ,SACA,MACgC;AAChC,QAAI,QAAQ,SAAS,MAAM;AACvB,YAAM,IAAI;AAAA,QACN,gCAAgC,eAAe,IAAI,CAAC,aAAa,eAAe,QAAQ,IAAI,CAAC,IAAI,QAAQ,IAAI;AAAA,MACjH;AAAA,IACJ;AAAA,EACJ;AATO,EAAAA,YAAS;AAWT,EAAMA,YAAA,QAAwC;AAAA,IACjD,CAAC,eAAe,QAAQ,GAAG;AAAA,IAC3B,CAAC,eAAe,WAAW,GAAG;AAAA,IAC9B,CAAC,eAAe,UAAU,GAAG;AAAA,IAC7B,CAAC,eAAe,aAAa,GAAG;AAAA,IAChC,CAAC,eAAe,UAAU,GAAG;AAAA,IAC7B,CAAC,eAAe,kBAAkB,GAAG;AAAA,IACrC,CAAC,eAAe,KAAK,GAAG;AAAA,IACxB,CAAC,eAAe,QAAQ,GAAG;AAAA,IAC3B,CAAC,eAAe,QAAQ,GAAG;AAAA,IAC3B,CAAC,eAAe,WAAW,GAAG;AAAA,EAClC;AAAA,GAzCa;",
+  "names": ["BdxMessage"]
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ProtocolStatusMessage, ProtocolStatusMessageSchema } from "#protocol/ProtocolStatusMessage.js";
+import { BdxStatusCode } from "#types";
+export type BdxStatus = Omit<ProtocolStatusMessage<BdxStatusCode>, "protocolData">;
+export declare class BdxStatusMessageSchema extends ProtocolStatusMessageSchema<BdxStatus> {
+}
+export declare const BdxStatusMessage: BdxStatusMessageSchema;
+//# sourceMappingURL=BdxStatusMessageSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BdxStatusMessageSchema.d.ts","sourceRoot":"","sources":["../../../../src/bdx/schema/BdxStatusMessageSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AACxG,OAAO,EAAmB,aAAa,EAAE,MAAM,QAAQ,CAAC;AAExD,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,EAAE,cAAc,CAAC,CAAC;AAEnF,qBAAa,sBAAuB,SAAQ,2BAA2B,CAAC,SAAS,CAAC;CAAG;AAErF,eAAO,MAAM,gBAAgB,wBAAqD,CAAC"}

package/dist/esm/bdx/schema/BdxStatusMessageSchema.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ProtocolStatusMessageSchema } from "#protocol/ProtocolStatusMessage.js";
+import { BDX_PROTOCOL_ID } from "#types";
+class BdxStatusMessageSchema extends ProtocolStatusMessageSchema {
+}
+const BdxStatusMessage = new BdxStatusMessageSchema(BDX_PROTOCOL_ID, false);
+export {
+  BdxStatusMessage,
+  BdxStatusMessageSchema
+};
+//# sourceMappingURL=BdxStatusMessageSchema.js.map