matterbridge 3.3.2 → 3.3.3-dev-20251012-1af2e85

package/dist/utils/hex.js

@@ -1,114 +1,39 @@
-/**
- * This file contains the hex functions.
- *
- * @file hex.ts
- * @author Luca Liguori
- * @created 2025-05-06
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { createPublicKey, createPrivateKey, X509Certificate } from 'node:crypto';
-/**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- *
- * Accepts any {ArrayBufferLike} input: a raw ArrayBuffer (binary data storage) or
- * a Uint8Array (TypedArray view over an ArrayBuffer). While an ArrayBuffer holds
- * the raw memory, a Uint8Array is a typed view into that memory, letting you access
- * its bytes directly. This function normalizes both by creating a Uint8Array view
- * before conversion.
- *
- * @param {ArrayBufferLike} buffer - The buffer or typed-array view to convert.
- * @returns {string} A lowercase hex string representation of the buffer's bytes.
- *
- * @throws {TypeError} If the input is not an ArrayBuffer or ArrayBufferView.
- */
 export function bufferToHex(buffer) {
-    // Check if the input is an ArrayBuffer or ArrayBufferView
     if (!(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer))) {
         throw new TypeError('Expected input to be an ArrayBuffer or ArrayBufferView');
     }
-    // Create a Uint8Array view over the buffer
     const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    // Convert each byte to 2-digit hex
     return Array.from(bytes)
         .map((byte) => byte.toString(16).padStart(2, '0'))
         .join('');
 }
-/**
- * Converts a hexadecimal string to a Uint8Array.
- *
- * @param {string} hex - The hex string to convert. Can include uppercase or lowercase characters.
- * @returns {Uint8Array} A Uint8Array representing the corresponding binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the input length is odd or contains non-hex characters.
- */
 export function hexToBuffer(hex) {
-    // Ensure the input is a string
     if (typeof hex !== 'string') {
         throw new TypeError('Expected a string for hex input');
     }
-    // Trim any whitespace from the input string
     const cleaned = hex.trim();
-    // Check if the length of the hex string is even
     if (cleaned.length % 2 !== 0) {
         throw new Error('Invalid hex string length, must be even');
     }
-    // Validate that the string contains only valid hex characters
     if (!/^[0-9a-fA-F]*$/.test(cleaned)) {
         throw new Error('Invalid hex string, contains non-hex characters');
     }
-    // Calculate the length of the resulting Uint8Array
     const length = cleaned.length / 2;
-    // Create a Uint8Array to hold the binary data
     const result = new Uint8Array(length);
-    // Convert each pair of hex characters into a byte
     for (let i = 0; i < length; i++) {
         result[i] = parseInt(cleaned.substr(i * 2, 2), 16);
     }
-    // Return the resulting Uint8Array
     return result;
 }
-/**
- * Converts a PEM (Privacy-Enhanced Mail) formatted string to a Uint8Array.
- *
- * PEM format is a base64-encoded format commonly used for cryptographic keys and certificates,
- * wrapped with header and footer lines like "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----".
- * This function extracts the base64 content and converts it to binary data using Node.js Buffer API.
- *
- * @param {string} pem - The PEM formatted string to convert.
- * @param {boolean} validate - Whether to validate the PEM content using Node.js crypto module. Default is false.
- * @returns {Uint8Array} A Uint8Array representing the decoded binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the PEM format is invalid, contains invalid base64 characters, or validation fails.
- */
 export function pemToBuffer(pem, validate = false) {
-    // Ensure the input is a string
     if (typeof pem !== 'string') {
         throw new TypeError('Expected a string for PEM input');
     }
-    // Trim whitespace from the input
     const cleaned = pem.trim();
-    // Check if the string appears to be in PEM format
     if (!cleaned.includes('-----BEGIN') || !cleaned.includes('-----END')) {
         throw new Error('Invalid PEM format: missing BEGIN/END markers');
     }
-    // Extract the base64 content between the header and footer
     const lines = cleaned.split('\n');
     const base64Lines = [];
     let inContent = false;
@@ -129,114 +54,65 @@ export function pemToBuffer(pem, validate = false) {
     if (base64Lines.length === 0) {
         throw new Error('Invalid PEM format: no content found between BEGIN/END markers');
     }
-    // Join all base64 lines together
     const base64String = base64Lines.join('');
-    // Validate base64 string format
     if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64String)) {
         throw new Error('Invalid PEM format: contains invalid base64 characters');
     }
     try {
-        // Use Node.js Buffer API instead of legacy atob()
         const buffer = Buffer.from(base64String, 'base64');
-        // Convert Buffer to Uint8Array
         const result = new Uint8Array(buffer);
-        // Validate PEM content using Node.js crypto module if requested
         if (validate) {
             try {
-                // Determine PEM type from the header and validate accordingly
                 const pemType = cleaned.match(/-----BEGIN\s+([^-]+)-----/)?.[1]?.trim();
                 if (pemType?.includes('CERTIFICATE')) {
-                    // Use X509Certificate for robust certificate validation
                     const cert = new X509Certificate(pem);
-                    // Check validity period
                     if (cert.validFrom && cert.validTo) {
                         const now = Date.now();
                         const from = Date.parse(cert.validFrom);
                         const to = Date.parse(cert.validTo);
-                        // istanbul ignore next if
                         if (now < from || now > to) {
                             throw new Error('Certificate is not currently valid');
                         }
                     }
-                    // Check subject/issuer fields
-                    // istanbul ignore next if
                     if (!cert.subject || !cert.issuer) {
                         throw new Error('Certificate missing subject or issuer');
                     }
-                    // Optionally check signature (not possible without CA chain)
                 }
                 else if (pemType?.includes('PRIVATE KEY')) {
-                    // For private keys, try to create a private key
                     createPrivateKey({ key: pem, format: 'pem' });
                 }
                 else if (pemType?.includes('PUBLIC KEY')) {
-                    // For public keys, try to create a public key
                     createPublicKey({ key: pem, format: 'pem' });
                 }
-                // If no specific type is detected, skip validation
             }
             catch (validationError) {
-                // istanbul ignore next
                 throw new Error(`PEM validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
             }
         }
         return result;
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to decode base64 content: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-/**
- * Extracts the raw 32-byte private key scalar from an EC private key PEM.
- *
- * This function parses an EC private key in PEM format and extracts the raw
- * 32-byte private scalar (the "d" value) used in elliptic curve cryptography.
- * This is the actual secret key material.
- *
- * @param {string} pemPrivateKey - The EC private key in PEM format
- * @returns {Uint8Array} The raw 32-byte private key scalar
- * @throws {Error} If the input is not a valid EC private key PEM
- *
- * @example
- * ```typescript
- * const pemKey = `-----BEGIN EC PRIVATE KEY-----
- * MHcCAQEEIFBxqFkUxMoN2JkUXLFeiZnLNUpftjLi0sKMbZ6uajHXoAoGCCqGSM49
- * AwEHoUQDQgAEcJ3eH/rG3zf9WmqMjh5eBSkeXz3Cb4Fig1rTosfHmgyjx/WnLPEe
- * BF4SHvLo0G2COJEHa/VDE5EiKWO9ZR6AOQ==
- * -----END EC PRIVATE KEY-----`;
- *
- * const rawKey = extractPrivateKeyRaw(pemKey);
- * console.log(rawKey.length); // 32
- * console.log(bufferToHex(rawKey)); // hex representation of the private scalar
- * ```
- */
 export function extractPrivateKeyRaw(pemPrivateKey) {
     if (typeof pemPrivateKey !== 'string') {
         throw new TypeError('Expected a string for PEM private key input');
     }
-    // Extract the private key block
     const keyBlock = /-----BEGIN (?:EC )?PRIVATE KEY-----[^-]+-----END (?:EC )?PRIVATE KEY-----/s.exec(pemPrivateKey);
     if (!keyBlock) {
         throw new Error('No EC PRIVATE KEY block found in the supplied PEM');
     }
     try {
-        // Create a private key object
         const privateKey = createPrivateKey(keyBlock[0]);
-        // Export as PKCS#8 DER format
         const pkcs8Der = privateKey.export({ format: 'der', type: 'pkcs8' });
-        // For P-256 curves, the private scalar is the last 32 bytes of the PKCS#8 DER
-        // istanbul ignore next
         if (pkcs8Der.length < 32) {
             throw new Error('Invalid private key: DER data too short');
         }
-        // Extract the last 32 bytes which contain the raw private scalar
         const rawPrivateKey = pkcs8Der.subarray(pkcs8Der.length - 32);
         return new Uint8Array(rawPrivateKey);
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to extract private key: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-//# sourceMappingURL=hex.js.map

package/dist/utils/isvalid.js

@@ -1,45 +1,7 @@
-/**
- * This file contains the validation functions.
- *
- * @file isvalid.ts
- * @author Luca Liguori
- * @created 2025-02-16
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Checks if a given string is a valid IPv4 address.
- *
- * @param {string} ipv4Address - The string to be checked.
- * @returns {boolean} - Returns true if the string is a valid IPv4 address, otherwise returns false.
- */
 export function isValidIpv4Address(ipv4Address) {
     const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
     return ipv4Regex.test(ipv4Address);
 }
-/**
- * Checks if a value is a valid number within the specified range.
- *
- * @param {any} value - The value to be checked.
- * @param {number} min - The minimum value allowed (optional).
- * @param {number} max - The maximum value allowed (optional).
- * @returns {value is number} Returns true if the value is a valid number within the specified range, otherwise false.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidNumber(value, min, max) {
     if (value === undefined || value === null || typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value))
         return false;
@@ -49,25 +11,9 @@ export function isValidNumber(value, min, max) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid boolean.
- *
- * @param {any} value - The value to be checked.
- * @returns {value is boolean} `true` if the value is a valid boolean, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidBoolean(value) {
     return value !== undefined && value !== null && typeof value === 'boolean';
 }
-/**
- * Checks if a value is a valid string.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min string length (optional).
- * @param {number} maxLength - The max string length (optional).
- * @returns {value is string} A boolean indicating whether the value is a valid string.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidString(value, minLength, maxLength) {
     if (value === undefined || value === null || typeof value !== 'string')
         return false;
@@ -77,25 +23,9 @@ export function isValidString(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid RegExp.
- *
- * @param {any} value - The value to be checked.
- * @returns {value is RegExp} A boolean indicating whether the value is a valid RegExp.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidRegExp(value) {
     return value !== undefined && value !== null && value instanceof RegExp;
 }
-/**
- * Checks if a value is a valid object.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min number of keys (optional).
- * @param {number} maxLength - The max number of keys (optional).
- * @returns {value is object} A boolean indicating whether the value is a valid object.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidObject(value, minLength, maxLength) {
     if (value === undefined || value === null || typeof value !== 'object' || Array.isArray(value))
         return false;
@@ -106,15 +36,6 @@ export function isValidObject(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid array.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min number of elements (optional).
- * @param {number} maxLength - The max number of elements (optional).
- * @returns {value is unknown[]} A boolean indicating whether the value is a valid array.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidArray(value, minLength, maxLength) {
     if (value === undefined || value === null || !Array.isArray(value))
         return false;
@@ -124,33 +45,12 @@ export function isValidArray(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if the given value is null.
- *
- * @param {any} value - The value to check.
- * @returns {value is null} `true` if the value is null, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidNull(value) {
     return value === null;
 }
-/**
- * Checks if a value is undefined.
- *
- * @param {any} value - The value to check.
- * @returns {value is undefined} `true` if the value is undefined, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidUndefined(value) {
     return value === undefined;
 }
-/**
- * Converts a semantic version string like "6.11.0-1011-raspi" to a numeric version code like 61100.
- * Format: major * 10000 + minor * 100 + patch
- *
- * @param {string} versionString The version string to parse
- * @returns {number | undefined} A numeric version code or undefined if parsing fails
- */
 export function parseVersionString(versionString) {
     if (!isValidString(versionString))
         return undefined;
@@ -167,4 +67,3 @@ export function parseVersionString(versionString) {
     }
     return major * 10000 + minor * 100 + patch;
 }
-//# sourceMappingURL=isvalid.js.map

package/dist/utils/jestHelpers.js

@@ -1,68 +1,21 @@
-/**
- * @description This file contains the Jest helpers.
- * @file src/helpers.test.ts
- * @author Luca Liguori
- * @created 2025-09-03
- * @version 1.0.5
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { rmSync } from 'node:fs';
 import { inspect } from 'node:util';
 import path from 'node:path';
-// Imports from Matterbridge
 import { jest } from '@jest/globals';
 import { DeviceTypeId, Endpoint, Environment, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle } from '@matter/main';
 import { AggregatorEndpoint, RootEndpoint } from '@matter/main/endpoints';
 import { MdnsService } from '@matter/main/protocol';
 import { AnsiLogger } from 'node-ansi-logger';
-// Imports from a plugin
-/*
-import { jest } from '@jest/globals';
-import { DeviceTypeId, Endpoint, Environment, MdnsService, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle } from 'matterbridge/matter';
-import { RootEndpoint, AggregatorEndpoint } from 'matterbridge/matter/endpoints';
-import { AnsiLogger } from 'matterbridge/logger';
-*/
 export let loggerLogSpy;
 export let consoleLogSpy;
 export let consoleDebugSpy;
 export let consoleInfoSpy;
 export let consoleWarnSpy;
 export let consoleErrorSpy;
-/**
- * Setup the Jest environment:
- * - it will remove any existing home directory
- * - setup the spies for logging
- *
- * @param {string} name The name of the test suite.
- * @param {boolean} debug If true, the logging is not mocked.
- *
- * ```typescript
- * import { consoleDebugSpy, consoleErrorSpy, consoleInfoSpy, consoleLogSpy, consoleWarnSpy, loggerLogSpy, setDebug, setupTest } from './jestHelpers.js';
- *
- * // Setup the test environment
- * setupTest(NAME, false);
- *
- * ```
- */
 export function setupTest(name, debug = false) {
     expect(name).toBeDefined();
     expect(typeof name).toBe('string');
-    expect(name.length).toBeGreaterThanOrEqual(4); // avoid accidental deletion of short paths like "/" or "C:\"
-    // Cleanup any existing home directory
+    expect(name.length).toBeGreaterThanOrEqual(4);
     rmSync(path.join('jest', name), { recursive: true, force: true });
     if (debug) {
         loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
@@ -81,11 +34,6 @@ export function setupTest(name, debug = false) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
-/**
- * Set or unset the debug mode.
- *
- * @param {boolean} debug If true, the logging is not mocked.
- */
 export function setDebug(debug) {
     if (debug) {
         loggerLogSpy.mockRestore();
@@ -110,21 +58,11 @@ export function setDebug(debug) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
-/**
- * Create a matter Environment for testing:
- * - it will remove any existing home directory
- * - setup the matter environment with homeDir, debug logging and ANSI format
- *
- * @param {string} homeDir Home directory for the environment.
- * @returns {Environment}  The default matter environment.
- */
 export function createTestEnvironment(homeDir) {
     expect(homeDir).toBeDefined();
     expect(typeof homeDir).toBe('string');
-    expect(homeDir.length).toBeGreaterThanOrEqual(4); // avoid accidental deletion of short paths like "/" or "C:\"
-    // Cleanup any existing home directory
+    expect(homeDir.length).toBeGreaterThanOrEqual(4);
     rmSync(homeDir, { recursive: true, force: true });
-    // Setup the matter environment
     const environment = Environment.default;
     environment.vars.set('log.level', MatterLogLevel.DEBUG);
     environment.vars.set('log.format', MatterLogFormat.ANSI);
@@ -133,18 +71,6 @@ export function createTestEnvironment(homeDir) {
     environment.vars.set('runtime.exitcode', false);
     return environment;
 }
-/**
- * Advance the Node.js event loop deterministically to allow chained asynchronous work (Promises scheduled in
- * microtasks and follow‑up macrotasks) to complete inside tests without adding arbitrary long timeouts.
- *
- * NOTE: This does not guarantee OS level network IO completion—only JavaScript task queue progression inside the
- *       current process.
- *
- * @param {number} ticks       Number of macrotask (setImmediate) turns to yield (default 3).
- * @param {number} microTurns  Number of microtask drains (Promise.resolve chains) after macrotask yielding (default 10).
- * @param {number} pause       Final timer delay in ms; set 0 to disable (default 100ms).
- * @returns {Promise<void>}        Resolves after the requested event loop advancement has completed.
- */
 export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
     for (let i = 0; i < ticks; i++)
         await new Promise((resolve) => setImmediate(resolve));
@@ -153,19 +79,6 @@ export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
     if (pause)
         await new Promise((resolve) => setTimeout(resolve, pause));
 }
-/**
- * Flush (await) the lazy endpoint number persistence mechanism used by matter.js.
- *
- * Background:
- *  assignNumber() batches persistence (store.saveNumber + updating __nextNumber__) via an internal promise (#numbersPersisted).
- *  Calling endpointStores.close() waits for the current batch only. If new endpoints were added in the same macrotask
- *  cycle additional micro/macro turns might be needed to ensure the batch started. We defensively yield macrotasks
- *  (setImmediate) and then await close() multiple rounds.
- *
- * @param {ServerNode} targetServer  The server whose endpoint numbering persistence should be flushed.
- * @param {number} rounds Number of macrotask + close cycles to run (2 is usually sufficient; 1 often works).
- * @returns {Promise<void>}          Resolves when pending number persistence batches have completed.
- */
 export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2) {
     const nodeStore = targetServer.env.get(ServerNodeStore);
     for (let i = 0; i < rounds; i++) {
@@ -173,12 +86,6 @@ export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2
         await nodeStore.endpointStores.close();
     }
 }
-/**
- * Collect all endpoints in the server endpoint tree (root -> descendants).
- *
- * @param {Endpoint} root  Root endpoint (typically the ServerNode root endpoint cast as Endpoint).
- * @returns {Endpoint[]}   Flat array including the root and every descendant once.
- */
 function collectAllEndpoints(root) {
     const list = [];
     const walk = (ep) => {
@@ -192,26 +99,14 @@ function collectAllEndpoints(root) {
     walk(root);
     return list;
 }
-/**
- * Assert that every endpoint attached to the server has an assigned and (batch-)persisted endpoint number.
- *
- * This waits for any outstanding number persistence batch (endpointStores.close()), then traverses the endpoint
- * graph and asserts:
- *  - Root endpoint: number is 0 (allowing undefined to coerce to 0 via nullish coalescing check).
- *  - All other endpoints: number > 0.
- *
- * @param {ServerNode} targetServer The server whose endpoint numbers are verified.
- * @returns {Promise<void>}         Resolves when assertions complete.
- */
 export async function assertAllEndpointNumbersPersisted(targetServer) {
     const nodeStore = targetServer.env.get(ServerNodeStore);
-    // Ensure any pending persistence finished (flush any in-flight batch promise)
     await nodeStore.endpointStores.close();
     const all = collectAllEndpoints(targetServer);
     for (const ep of all) {
         const store = nodeStore.storeForEndpoint(ep);
         if (ep.maybeNumber === 0) {
-            expect(store.number ?? 0).toBe(0); // root
+            expect(store.number ?? 0).toBe(0);
         }
         else {
             expect(store.number).toBeGreaterThan(0);
@@ -219,15 +114,7 @@ export async function assertAllEndpointNumbersPersisted(targetServer) {
     }
     return all.length;
 }
-/**
- * Start a matter server node for testing.
- *
- * @param {string} name Name of the server (used for logging and product description).
- * @param {number} port TCP port to listen on.
- * @returns {Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>} Resolves to an array containing the created ServerNode and its AggregatorNode.
- */
 export async function startServerNode(name, port) {
-    // Create the server node
     const server = await ServerNode.create({
         id: name + 'ServerNode',
         productDescription: {
@@ -236,7 +123,6 @@ export async function startServerNode(name, port) {
             vendorId: VendorId(0xfff1),
             productId: 0x8000,
         },
-        // Provide defaults for the BasicInformation cluster on the Root endpoint
         basicInformation: {
             vendorId: VendorId(0xfff1),
             vendorName: 'Matterbridge',
@@ -253,26 +139,21 @@ export async function startServerNode(name, port) {
     });
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
-    // Create the aggregator node
     const aggregator = new Endpoint(AggregatorEndpoint, {
         id: name + 'AggregatorNode',
     });
     expect(aggregator).toBeDefined();
-    // Add the aggregator to the server
     await server.add(aggregator);
     expect(server.parts.has(aggregator.id)).toBeTruthy();
     expect(server.parts.has(aggregator)).toBeTruthy();
     expect(aggregator.lifecycle.isReady).toBeTruthy();
-    // Run the server
     expect(server.lifecycle.isOnline).toBeFalsy();
-    // Wait for the server to be online
     await new Promise((resolve) => {
         server.lifecycle.online.on(async () => {
             resolve();
         });
         server.start();
     });
-    // Check if the server is online
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeTruthy();
     expect(server.lifecycle.isCommissioned).toBeFalsy();
@@ -284,41 +165,21 @@ export async function startServerNode(name, port) {
     expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
     expect(aggregator.lifecycle.hasId).toBeTruthy();
     expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    // Ensure the queue is empty and pause 100ms
     await flushAsync();
     return [server, aggregator];
 }
-/**
- * Stop a matter server node.
- *
- * @param {ServerNode<ServerNode.RootEndpoint>} server The server to stop.
- * @returns {Promise<void>} Resolves when the server has stopped.
- */
 export async function stopServerNode(server) {
-    // Flush any pending endpoint number persistence
     await flushAllEndpointNumberPersistence(server);
-    // Ensure all endpoint numbers are persisted
     await assertAllEndpointNumbersPersisted(server);
-    // Stop the server
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeTruthy();
     await server.close();
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeFalsy();
-    // stop the mDNS service
     await server.env.get(MdnsService)[Symbol.asyncDispose]();
-    // Ensure the queue is empty and pause 100ms
     await flushAsync();
 }
-/**
- * Add a device (endpoint) to a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to add the device to.
- * @param {Endpoint} device The device to add.
- * @param {number} pause The pause time in milliseconds after addition (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been added and is ready.
- */
 export async function addDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
@@ -331,7 +192,6 @@ export async function addDevice(owner, device, pause = 10) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : error;
         const errorInspect = inspect(error, { depth: 10 });
-        // eslint-disable-next-line no-console
         console.error(`Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
         return false;
     }
@@ -345,14 +205,6 @@ export async function addDevice(owner, device, pause = 10) {
     await flushAsync(1, 1, pause);
     return true;
 }
-/**
- * Delete a device (endpoint) from a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to remove the device from.
- * @param {Endpoint} device The device to remove.
- * @param {number} pause The pause time in milliseconds after deletion (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been removed and is no longer ready.
- */
 export async function deleteDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
@@ -365,7 +217,6 @@ export async function deleteDevice(owner, device, pause = 10) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : error;
         const errorInspect = inspect(error, { depth: 10 });
-        // eslint-disable-next-line no-console
         console.error(`Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
         return false;
     }
@@ -379,4 +230,3 @@ export async function deleteDevice(owner, device, pause = 10) {
     await flushAsync(1, 1, pause);
     return true;
 }
-//# sourceMappingURL=jestHelpers.js.map