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

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

@@ -0,0 +1,125 @@
+"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 BdxAcceptMessagesSchema_exports = {};
+__export(BdxAcceptMessagesSchema_exports, {
+  BdxReceiveAcceptMessage: () => BdxReceiveAcceptMessage,
+  BdxReceiveAcceptMessageSchema: () => BdxReceiveAcceptMessageSchema,
+  BdxSendAcceptMessage: () => BdxSendAcceptMessage,
+  BdxSendAcceptMessageSchema: () => BdxSendAcceptMessageSchema
+});
+module.exports = __toCommonJS(BdxAcceptMessagesSchema_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_BdxError = require("../BdxError.js");
+var import_BdxInitMessagesSchema = require("./BdxInitMessagesSchema.js");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BdxSendAcceptMessageSchema extends import_types.Schema {
+  encodeInternal(message) {
+    this.validate(message);
+    const { transferControl, maxBlockSize, metaData } = message;
+    const writer = new import_general.DataWriter(import_general.Endian.Little);
+    writer.writeUInt8(import_BdxInitMessagesSchema.BdxTransferControlSchema.encode(transferControl));
+    writer.writeUInt16(maxBlockSize);
+    if (metaData && metaData.byteLength > 0) {
+      writer.writeByteArray(metaData);
+    }
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new import_general.DataReader(bytes, import_general.Endian.Little);
+    const transferControl = import_BdxInitMessagesSchema.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 !== import_BdxInitMessagesSchema.BDX_VERSION) {
+      throw new import_BdxError.BdxError(
+        `Unsupported BDX version: ${transferControl.version}`,
+        import_types.BdxStatusCode.VersionNotSupported
+      );
+    }
+    if (!transferControl.senderDrive && !transferControl.receiverDrive && !transferControl.asynchronousTransfer) {
+      throw new import_BdxError.BdxError(
+        "BDX transfer control need to specify at least one of sender drive, receiver drive or asynchronousTransfer",
+        import_types.BdxStatusCode.BadMessageContent
+      );
+    }
+    if (maxBlockSize < 1 || maxBlockSize > 65535) {
+      throw new import_BdxError.BdxError("Max Block Size must be between 1 and 65535bytes", import_types.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 import_general.DataWriter(import_general.Endian.Little);
+    writer.writeUInt8(import_BdxInitMessagesSchema.BdxTransferControlSchema.encode(transferControl));
+    writer.writeUInt8(import_BdxInitMessagesSchema.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 import_general.DataReader(bytes, import_general.Endian.Little);
+    const transferControl = import_BdxInitMessagesSchema.BdxTransferControlSchema.decode(reader.readUInt8());
+    const rangeControl = import_BdxInitMessagesSchema.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();
+//# sourceMappingURL=BdxAcceptMessagesSchema.js.map

package/dist/cjs/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/cjs/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/cjs/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/cjs/bdx/schema/BdxBlockMessagesSchema.js

@@ -0,0 +1,92 @@
+"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 BdxBlockMessagesSchema_exports = {};
+__export(BdxBlockMessagesSchema_exports, {
+  BdxBlockAckEofMessage: () => BdxBlockAckEofMessage,
+  BdxBlockAckMessage: () => BdxBlockAckMessage,
+  BdxBlockEofMessage: () => BdxBlockEofMessage,
+  BdxBlockMessage: () => BdxBlockMessage,
+  BdxBlockMessageSchema: () => BdxBlockMessageSchema,
+  BdxBlockQueryMessage: () => BdxBlockQueryMessage,
+  BdxBlockQueryWithSkipMessage: () => BdxBlockQueryWithSkipMessage,
+  BdxBlockQueryWithSkipMessageSchema: () => BdxBlockQueryWithSkipMessageSchema,
+  BdxCounterOnlyMessageSchema: () => BdxCounterOnlyMessageSchema
+});
+module.exports = __toCommonJS(BdxBlockMessagesSchema_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BdxCounterOnlyMessageSchema extends import_types.Schema {
+  encodeInternal(message) {
+    const { blockCounter } = message;
+    const writer = new import_general.DataWriter(import_general.Endian.Little);
+    writer.writeUInt32(blockCounter);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new import_general.DataReader(bytes, import_general.Endian.Little);
+    return {
+      blockCounter: reader.readUInt32()
+    };
+  }
+}
+const BdxCounterOnlyMessage = new BdxCounterOnlyMessageSchema();
+const BdxBlockQueryMessage = BdxCounterOnlyMessage;
+const BdxBlockAckMessage = BdxCounterOnlyMessage;
+const BdxBlockAckEofMessage = BdxCounterOnlyMessage;
+class BdxBlockQueryWithSkipMessageSchema extends import_types.Schema {
+  encodeInternal(message) {
+    const { blockCounter, bytesToSkip } = message;
+    const writer = new import_general.DataWriter(import_general.Endian.Little);
+    writer.writeUInt32(blockCounter);
+    writer.writeUInt64(bytesToSkip);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new import_general.DataReader(bytes, import_general.Endian.Little);
+    return {
+      blockCounter: reader.readUInt32(),
+      bytesToSkip: reader.readUInt64()
+    };
+  }
+}
+const BdxBlockQueryWithSkipMessage = new BdxBlockQueryWithSkipMessageSchema();
+class BdxBlockMessageSchema extends import_types.Schema {
+  encodeInternal(message) {
+    const { blockCounter, data } = message;
+    const writer = new import_general.DataWriter(import_general.Endian.Little);
+    writer.writeUInt32(blockCounter);
+    writer.writeByteArray(data);
+    return writer.toByteArray();
+  }
+  decodeInternal(bytes) {
+    const reader = new import_general.DataReader(bytes, import_general.Endian.Little);
+    return {
+      blockCounter: reader.readUInt32(),
+      data: reader.remainingBytes
+    };
+  }
+}
+const BdxBlockMessage = new BdxBlockMessageSchema();
+const BdxBlockEofMessage = BdxBlockMessage;
+//# sourceMappingURL=BdxBlockMessagesSchema.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bdx/schema/BdxBlockMessagesSchema.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAsD;AACtD,mBAAuB;AAPvB;AAAA;AAAA;AAAA;AAAA;AAoCO,MAAM,oCAAoC,oBAAuB;AAAA,EACpE,eAAe,SAAyB;AACpC,UAAM,EAAE,aAAa,IAAI;AAEzB,UAAM,SAAS,IAAI,0BAAW,sBAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAA8B;AACzC,UAAM,SAAS,IAAI,0BAAW,OAAO,sBAAO,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,oBAA8B;AAAA,EAClF,eAAe,SAAgC;AAC3C,UAAM,EAAE,cAAc,YAAY,IAAI;AAEtC,UAAM,SAAS,IAAI,0BAAW,sBAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,YAAY,WAAW;AAC9B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAAqC;AAChD,UAAM,SAAS,IAAI,0BAAW,OAAO,sBAAO,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,oBAAiB;AAAA,EACxD,eAAe,SAAmB;AAC9B,UAAM,EAAE,cAAc,KAAK,IAAI;AAE/B,UAAM,SAAS,IAAI,0BAAW,sBAAO,MAAM;AAC3C,WAAO,YAAY,YAAY;AAC/B,WAAO,eAAe,IAAI;AAC1B,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,eAAe,OAAwB;AACnC,UAAM,SAAS,IAAI,0BAAW,OAAO,sBAAO,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/cjs/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/cjs/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/cjs/bdx/schema/BdxInitMessagesSchema.js

@@ -0,0 +1,153 @@
+"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 BdxInitMessagesSchema_exports = {};
+__export(BdxInitMessagesSchema_exports, {
+  BDX_VERSION: () => BDX_VERSION,
+  BdxInitMessageSchema: () => BdxInitMessageSchema,
+  BdxRangeControlBitmap: () => BdxRangeControlBitmap,
+  BdxRangeControlSchema: () => BdxRangeControlSchema,
+  BdxReceiveInitMessage: () => BdxReceiveInitMessage,
+  BdxSendInitMessage: () => BdxSendInitMessage,
+  BdxTransferControlBitmap: () => BdxTransferControlBitmap,
+  BdxTransferControlSchema: () => BdxTransferControlSchema
+});
+module.exports = __toCommonJS(BdxInitMessagesSchema_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
+ */
+const BDX_VERSION = 0;
+const BdxTransferControlBitmap = {
+  /** Protocol Version, Only allowed version is 0.0 for now */
+  version: (0, import_types.BitField)(0, 4),
+  /** Indicates if Sender drive is supported by Initiator */
+  senderDrive: (0, import_types.BitFlag)(4),
+  /** Indicates if Receiver drive is supported by Initiator */
+  receiverDrive: (0, import_types.BitFlag)(5),
+  /**
+   * Indicates if Asynchronous Transfer is supported by Initiator
+   * Synchronous mode is always implicitly supported.
+   */
+  asynchronousTransfer: (0, import_types.BitFlag)(6)
+};
+const BdxTransferControlSchema = (0, import_types.BitmapSchema)(BdxTransferControlBitmap);
+const BdxRangeControlBitmap = {
+  /** Indicates if the transfer has a definite length */
+  definiteLength: (0, import_types.BitFlag)(0),
+  /** Indicates if the transfer has a start offset */
+  startOffset: (0, import_types.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: (0, import_types.BitFlag)(4)
+};
+const BdxRangeControlSchema = (0, import_types.BitmapSchema)(BdxRangeControlBitmap);
+class BdxInitMessageSchema extends import_types.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 import_general.DataWriter(import_general.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 import_general.DataReader(bytes, import_general.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 import_BdxError.BdxError(
+        `Unsupported BDX version: ${transferProtocol.version}`,
+        import_types.BdxStatusCode.VersionNotSupported
+      );
+    }
+    if (!transferProtocol.senderDrive && !transferProtocol.receiverDrive) {
+      throw new import_BdxError.BdxError(
+        "BDX transfer protocol needs to allow either sender or receiver drive",
+        import_types.BdxStatusCode.BadMessageContent
+      );
+    }
+    if (fileDesignator.byteLength === 0) {
+      throw new import_BdxError.BdxError("File Designator cannot be empty", import_types.BdxStatusCode.BadMessageContent);
+    }
+    if (fileDesignator.byteLength > 65535) {
+      throw new import_BdxError.BdxError(
+        "File Designator length exceeds maximum allowed size of 65535bytes",
+        import_types.BdxStatusCode.BadMessageContent
+      );
+    }
+    if (maxBlockSize < 1 || maxBlockSize > 65535) {
+      throw new import_BdxError.BdxError("Max Block Size must be between 1 and 65535bytes", import_types.BdxStatusCode.BadMessageContent);
+    }
+  }
+}
+const BdxSendInitMessage = new BdxInitMessageSchema();
+const BdxReceiveInitMessage = BdxSendInitMessage;
+//# sourceMappingURL=BdxInitMessagesSchema.js.map

package/dist/cjs/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/cjs/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/cjs/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"}