matterbridge 3.3.7 → 3.3.8-dev-20251114-9b65e59

package/dist/{utils → jestutils}/jestHelpers.js

@@ -1,73 +1,46 @@
-/**
- * @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';
-import { jest } from '@jest/globals';
 import { AnsiLogger } from 'node-ansi-logger';
-// @matter
-import '@matter/nodejs';
-import { LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Environment, Lifecycle } from '@matter/general';
-import { DeviceTypeId, VendorId } from '@matter/types';
-import { MdnsService } from '@matter/protocol';
-import { ServerNode, Endpoint, ServerNodeStore } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
-import { RootEndpoint } from '@matter/node/endpoints/root';
-// 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';
-*/
+import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Environment, Lifecycle } from '@matter/general';
+import { Endpoint, ServerNode, ServerNodeStore } from '@matter/node';
+import { DeviceTypeId, VendorId } from '@matter/types/datatype';
+import { AggregatorEndpoint, RootEndpoint } from '@matter/node/endpoints';
+import { MdnsService } from '@matter/main/protocol';
+import { Matterbridge } from '../matterbridge.js';
+import { MATTER_STORAGE_NAME } from '../matterbridgeTypes.js';
 export let loggerLogSpy;
+export let loggerDebugSpy;
+export let loggerInfoSpy;
+export let loggerNoticeSpy;
+export let loggerWarnSpy;
+export let loggerErrorSpy;
+export let loggerFatalSpy;
 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) {
+export let addBridgedEndpointSpy;
+export let removeBridgedEndpointSpy;
+export let removeAllBridgedEndpointsSpy;
+export let matterbridge;
+export let environment;
+export let server;
+export let aggregator;
+export let log;
+export async 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 });
+    const { jest } = await import('@jest/globals');
+    loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
+    loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
+    loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
+    loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
+    loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
+    loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
     if (debug) {
         loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
         consoleLogSpy = jest.spyOn(console, 'log');
@@ -84,13 +57,12 @@ export function setupTest(name, debug = false) {
         consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
+    addBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
+    removeBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
+    removeAllBridgedEndpointsSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
 }
-/**
- * Set or unset the debug mode.
- *
- * @param {boolean} debug If true, the logging is not mocked.
- */
-export function setDebug(debug) {
+export async function setDebug(debug) {
+    const { jest } = await import('@jest/globals');
     if (debug) {
         loggerLogSpy.mockRestore();
         consoleLogSpy.mockRestore();
@@ -114,42 +86,133 @@ 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
-    rmSync(homeDir, { recursive: true, force: true });
-    // Setup the matter environment
-    const environment = Environment.default;
+export async function createMatterbridgeEnvironment(name) {
+    matterbridge = await Matterbridge.loadInstance(false);
+    expect(matterbridge).toBeDefined();
+    expect(matterbridge).toBeInstanceOf(Matterbridge);
+    matterbridge.matterbridgeVersion = '3.3.0';
+    matterbridge.bridgeMode = 'bridge';
+    matterbridge.rootDirectory = path.join('jest', name);
+    matterbridge.homeDirectory = path.join('jest', name);
+    matterbridge.matterbridgeDirectory = path.join('jest', name, '.matterbridge');
+    matterbridge.matterbridgePluginDirectory = path.join('jest', name, 'Matterbridge');
+    matterbridge.matterbridgeCertDirectory = path.join('jest', name, '.mattercert');
+    matterbridge.log.logLevel = "debug";
+    log = new AnsiLogger({ logName: 'Plugin platform', logTimestampFormat: 4, logLevel: "debug" });
+    matterbridge.environment = createTestEnvironment(name);
+    expect(matterbridge.environment).toBeDefined();
+    expect(matterbridge.environment).toBeInstanceOf(Environment);
+    return matterbridge;
+}
+export async function startMatterbridgeEnvironment(port = 5540) {
+    await matterbridge.startMatterStorage();
+    expect(matterbridge.matterStorageService).toBeDefined();
+    expect(matterbridge.matterStorageManager).toBeDefined();
+    expect(matterbridge.matterbridgeContext).toBeDefined();
+    server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
+    expect(server).toBeDefined();
+    expect(server).toBeDefined();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    matterbridge.serverNode = server;
+    aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
+    expect(aggregator).toBeDefined();
+    matterbridge.aggregatorNode = aggregator;
+    expect(await server.add(aggregator)).toBeDefined();
+    expect(server.parts.has(aggregator.id)).toBeTruthy();
+    expect(server.parts.has(aggregator)).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await new Promise((resolve) => {
+        server.lifecycle.online.on(async () => {
+            resolve();
+        });
+        server.start();
+    });
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    expect(server.lifecycle.isCommissioned).toBeFalsy();
+    expect(server.lifecycle.isPartsReady).toBeTruthy();
+    expect(server.lifecycle.hasId).toBeTruthy();
+    expect(server.lifecycle.hasNumber).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
+    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
+    expect(aggregator.lifecycle.hasId).toBeTruthy();
+    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
+    await flushAsync();
+    return [server, aggregator];
+}
+export function addMatterbridgePlatform(platform, name) {
+    if (name)
+        platform.config.name = name;
+    expect(platform).toBeDefined();
+    expect(platform.config.name).toBeDefined();
+    expect(platform.config.type).toBeDefined();
+    expect(platform.type).toBeDefined();
+    expect(platform.config.version).toBeDefined();
+    expect(platform.version).toBeDefined();
+    expect(platform.config.debug).toBeDefined();
+    expect(platform.config.unregisterOnShutdown).toBeDefined();
+    matterbridge.plugins._plugins.set(platform.config.name, {
+        name: platform.config.name,
+        path: './',
+        type: platform.type,
+        version: platform.version,
+        description: 'Plugin ' + platform.config.name,
+        author: 'Unknown',
+        enabled: true,
+    });
+    platform['name'] = platform.config.name;
+}
+export async function stopMatterbridgeEnvironment() {
+    expect(matterbridge).toBeDefined();
+    expect(server).toBeDefined();
+    expect(aggregator).toBeDefined();
+    await flushAllEndpointNumberPersistence(server);
+    await assertAllEndpointNumbersPersisted(server);
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    await server.close();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await matterbridge.stopMatterStorage();
+    expect(matterbridge.matterStorageService).not.toBeDefined();
+    expect(matterbridge.matterStorageManager).not.toBeDefined();
+    expect(matterbridge.matterbridgeContext).not.toBeDefined();
+    await flushAsync();
+}
+export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250) {
+    await destroyInstance(matterbridge, cleanupPause, destroyPause);
+    await closeMdnsInstance(matterbridge);
+    Matterbridge.instance = undefined;
+}
+export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {
+    await matterbridge.cleanup('destroying instance...', false, cleanupPause);
+    if (destroyPause > 0)
+        await flushAsync(undefined, undefined, destroyPause);
+}
+export async function closeMdnsInstance(matterbridge) {
+    const mdns = matterbridge.environment.get(MdnsService);
+    if (mdns && mdns[Symbol.asyncDispose] && typeof mdns[Symbol.asyncDispose] === 'function')
+        await mdns[Symbol.asyncDispose]();
+    if (mdns && mdns.close && typeof mdns.close === 'function')
+        await mdns.close();
+}
+export function createTestEnvironment(name) {
+    expect(name).toBeDefined();
+    expect(typeof name).toBe('string');
+    expect(name.length).toBeGreaterThanOrEqual(4);
+    rmSync(path.join('jest', name), { recursive: true, force: true });
+    environment = Environment.default;
     environment.vars.set('log.level', MatterLogLevel.DEBUG);
     environment.vars.set('log.format', MatterLogFormat.ANSI);
-    environment.vars.set('path.root', homeDir);
+    environment.vars.set('path.root', path.join('jest', name, '.matterbridge', MATTER_STORAGE_NAME));
     environment.vars.set('runtime.signals', false);
     environment.vars.set('runtime.exitcode', false);
+    new MdnsService(environment);
     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) {
+export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
     for (let i = 0; i < ticks; i++)
         await new Promise((resolve) => setImmediate(resolve));
     for (let i = 0; i < microTurns; i++)
@@ -157,19 +220,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++) {
@@ -177,12 +227,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) => {
@@ -196,26 +240,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);
@@ -223,24 +255,16 @@ 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({
+    server = await ServerNode.create({
         id: name + 'ServerNode',
+        environment,
         productDescription: {
             name: name + 'ServerNode',
             deviceType: DeviceTypeId(RootEndpoint.deviceType),
             vendorId: VendorId(0xfff1),
             productId: 0x8000,
         },
-        // Provide defaults for the BasicInformation cluster on the Root endpoint
         basicInformation: {
             vendorId: VendorId(0xfff1),
             vendorName: 'Matterbridge',
@@ -257,26 +281,21 @@ export async function startServerNode(name, port) {
     });
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
-    // Create the aggregator node
-    const aggregator = new Endpoint(AggregatorEndpoint, {
+    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();
@@ -288,41 +307,25 @@ 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
+    const mdns = environment.get(MdnsService);
+    if (mdns && typeof mdns[Symbol.asyncDispose] === 'function')
+        await mdns[Symbol.asyncDispose]();
+    if (mdns && typeof mdns.close === 'function')
+        await mdns.close();
     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();
@@ -335,7 +338,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;
     }
@@ -346,17 +348,9 @@ export async function addDevice(owner, device, pause = 10) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Active);
-    await flushAsync(1, 1, pause);
+    await flushAsync(undefined, undefined, 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();
@@ -369,7 +363,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;
     }
@@ -380,7 +373,6 @@ export async function deleteDevice(owner, device, pause = 10) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
-    await flushAsync(1, 1, pause);
+    await flushAsync(undefined, undefined, pause);
     return true;
 }
-//# sourceMappingURL=jestHelpers.js.map

package/dist/logger/export.js

@@ -1,2 +1 @@
 export * from 'node-ansi-logger';
-//# sourceMappingURL=export.js.map

package/dist/matter/behaviors.js

@@ -1,3 +1 @@
-// @matter
 export * from '@matter/node/behaviors';
-//# sourceMappingURL=behaviors.js.map

package/dist/matter/clusters.js

@@ -1,3 +1 @@
-// @matter
 export * from '@matter/types/clusters';
-//# sourceMappingURL=clusters.js.map

package/dist/matter/devices.js

@@ -1,3 +1 @@
-// @matter
 export * from '@matter/node/devices';
-//# sourceMappingURL=devices.js.map

package/dist/matter/endpoints.js

@@ -1,3 +1 @@
-// @matter
 export { AggregatorEndpoint, ElectricalSensorEndpoint, PowerSourceEndpoint, BridgedNodeEndpoint, RootEndpoint, DeviceEnergyManagementEndpoint, OtaProviderEndpoint, OtaRequestorEndpoint } from '@matter/node/endpoints';
-//# sourceMappingURL=endpoints.js.map

package/dist/matter/export.js

@@ -1,7 +1,4 @@
-/* eslint-disable import/export */
-// @matter
 export * from '@matter/main';
 export { SemanticNamespace, ClosureTag, CompassDirectionTag, CompassLocationTag, DirectionTag, ElectricalMeasurementTag, LaundryTag, LevelTag, LocationTag, NumberTag, PositionTag, PowerSourceTag, RefrigeratorTag, RoomAirConditionerTag, SwitchesTag, } from '@matter/main';
 export { AttributeElement, ClusterElement, ClusterModel, CommandElement, EventElement, FieldElement } from '@matter/main/model';
 export { MdnsService, Val } from '@matter/main/protocol';
-//# sourceMappingURL=export.js.map

package/dist/matter/types.js

@@ -1,5 +1,2 @@
-/* eslint-disable import/export */
-// @matter
 export * from '@matter/types';
 export { ClusterRegistry } from '@matter/types';
-//# sourceMappingURL=types.js.map