@matterbridge/core 3.6.0-dev-20260302-e3a7eb0 → 3.6.0-dev-20260303-f33e36a

package/dist/devices/closurePanel.d.ts

@@ -0,0 +1,204 @@
+import { MaybePromise } from '@matter/general';
+import { ClusterBehavior } from '@matter/node';
+import { ClosureDimension } from '../clusters/closure-dimension.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface ClosurePanelOptions {
+    resolution?: number;
+    stepValue?: number;
+}
+declare const ClosureDimensionServerBase: ClusterBehavior.Type<import("@matter/types").ClusterComposer.Of<import("@matter/types").ClusterType.Of<{
+    readonly id: 261;
+    readonly name: "ClosureDimension";
+    readonly revision: 1;
+    readonly features: {
+        readonly positioning: import("@matter/types").BitFlag;
+        readonly motionLatching: import("@matter/types").BitFlag;
+        readonly unit: import("@matter/types").BitFlag;
+        readonly limitation: import("@matter/types").BitFlag;
+        readonly speed: import("@matter/types").BitFlag;
+        readonly translation: import("@matter/types").BitFlag;
+        readonly rotation: import("@matter/types").BitFlag;
+        readonly modulation: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly currentState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }> | null, any>;
+        readonly targetState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }> | null, any>;
+    };
+    readonly commands: {
+        readonly setTarget: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number>;
+            latch: import("@matter/types").OptionalFieldType<boolean>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly positioning: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly resolution: import("@matter/types").FixedAttribute<number, any>;
+                readonly stepValue: import("@matter/types").FixedAttribute<number, any>;
+            };
+            readonly commands: {
+                readonly step: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    direction: import("@matter/types").FieldType<ClosureDimension.StepDirection>;
+                    numberOfSteps: import("@matter/types").FieldType<number>;
+                    speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly motionLatching: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly latchControlModes: import("@matter/types").FixedAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    remoteLatching: import("@matter/types").BitFlag;
+                    remoteUnlatching: import("@matter/types").BitFlag;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly unit: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly unit: import("@matter/types").FixedAttribute<ClosureDimension.ClosureUnit, any>;
+                readonly unitRange: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    min: import("@matter/types").FieldType<number>;
+                    max: import("@matter/types").FieldType<number>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly limitation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly limitRange: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    min: import("@matter/types").FieldType<number>;
+                    max: import("@matter/types").FieldType<number>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly translation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly translationDirection: import("@matter/types").FixedAttribute<ClosureDimension.TranslationDirection, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly rotationAxis: import("@matter/types").FixedAttribute<ClosureDimension.RotationAxis, any>;
+                readonly overflow: import("@matter/types").FixedAttribute<ClosureDimension.Overflow, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly modulation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly modulationType: import("@matter/types").FixedAttribute<ClosureDimension.ModulationType, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly positioning: false;
+            readonly motionLatching: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly unit: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly limitation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly speed: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly modulation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly rotation: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly modulation: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+            readonly modulation: true;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ClosureDimension.Feature.Positioning]>, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export declare namespace ClosureDimensionServer {
+    interface State {
+        currentState: ClosureDimension.DimensionState | null;
+        targetState: ClosureDimension.DimensionState | null;
+        resolution: number;
+        stepValue: number;
+    }
+}
+export declare class ClosureDimensionServer extends ClosureDimensionServerBase {
+    state: ClosureDimensionServer.State;
+    setTarget: (request: ClosureDimension.SetTargetRequest) => MaybePromise;
+    step: (request: ClosureDimension.StepRequest) => MaybePromise;
+}
+export declare class ClosurePanel extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: ClosurePanelOptions);
+}
+export {};

package/dist/devices/closurePanel.js

@@ -0,0 +1,55 @@
+import { ClusterBehavior } from '@matter/node';
+import { ClosureDimension } from '../clusters/closure-dimension.js';
+import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
+import { closurePanel } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createClusterSchema } from './customClusterSchema.js';
+const ClosureDimensionCluster = ClosureDimension.Cluster.with(ClosureDimension.Feature.Positioning);
+const ClosureDimensionServerBase = ClusterBehavior.for(ClosureDimensionCluster, createClusterSchema(ClosureDimensionCluster));
+export class ClosureDimensionServer extends ClosureDimensionServerBase {
+    setTarget = (request) => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SetTarget (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setTarget', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        const previousTarget = this.state.targetState ?? {};
+        const nextTarget = {
+            ...previousTarget,
+            ...(request?.position !== undefined ? { position: request.position } : null),
+            ...(request?.latch !== undefined ? { latch: request.latch } : null),
+            ...(request?.speed !== undefined ? { speed: request.speed } : null),
+        };
+        this.state.targetState = nextTarget;
+    };
+    step = (request) => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('step', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        const stepValue = this.state.stepValue;
+        const numberOfSteps = request.numberOfSteps;
+        const delta = stepValue * numberOfSteps;
+        const isIncrease = request.direction === ClosureDimension.StepDirection.Increase;
+        const previousCurrent = this.state.currentState ?? {};
+        const previousTarget = this.state.targetState ?? {};
+        const currentPosition = typeof previousCurrent.position === 'number' ? previousCurrent.position : typeof previousTarget.position === 'number' ? previousTarget.position : 0;
+        let nextPosition = isIncrease ? currentPosition + delta : currentPosition - delta;
+        nextPosition = Math.max(0, Math.min(10000, nextPosition));
+        this.state.currentState = {
+            ...previousCurrent,
+            position: nextPosition,
+            ...(request?.speed !== undefined ? { speed: request.speed } : null),
+        };
+        this.state.targetState = { ...previousTarget, position: nextPosition };
+    };
+}
+export class ClosurePanel extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([closurePanel], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure Panel');
+        this.behaviors.require(ClosureDimensionServer, {
+            currentState: null,
+            targetState: null,
+            resolution: options.resolution ?? 1,
+            stepValue: options.stepValue ?? 1,
+        });
+    }
+}

package/dist/devices/customClusterSchema.d.ts

@@ -0,0 +1,22 @@
+import { ClusterModel } from '../matter/export.js';
+type AnyCluster = {
+    id: number;
+    name: string;
+    revision?: number;
+    supportedFeatures?: Record<string, boolean>;
+    attributes?: Record<string, {
+        id: number;
+        default?: unknown;
+        optional?: boolean;
+    }>;
+    commands?: Record<string, {
+        requestId: number;
+        optional?: boolean;
+    }>;
+    events?: Record<string, {
+        id: number;
+        optional?: boolean;
+    }>;
+};
+export declare function createClusterSchema(cluster: AnyCluster): ClusterModel;
+export {};

package/dist/devices/customClusterSchema.js

@@ -0,0 +1,53 @@
+import { AttributeElement, ClusterModel, CommandElement, EventElement, FieldElement } from '../matter/export.js';
+export function createClusterSchema(cluster) {
+    const children = [];
+    const featureNames = Object.keys(cluster.supportedFeatures ?? {});
+    if (featureNames.length > 0) {
+        children.push(AttributeElement({
+            id: 0xfffc,
+            name: 'FeatureMap',
+            type: 'FeatureMap',
+            conformance: 'M',
+        }, ...featureNames.map((name, index) => FieldElement({
+            name,
+            id: index,
+            type: 'bool',
+            constraint: index,
+        }))));
+    }
+    for (const [name, attribute] of Object.entries(cluster.attributes ?? {})) {
+        children.push(AttributeElement({
+            id: attribute.id,
+            name,
+            type: 'any',
+            conformance: 'O',
+        }));
+    }
+    for (const [name, command] of Object.entries(cluster.commands ?? {})) {
+        const element = CommandElement({
+            id: command.requestId,
+            name,
+            type: 'any',
+            direction: 'request',
+            conformance: 'O',
+        });
+        element.operationalIsSupported = true;
+        children.push(element);
+    }
+    for (const [name, event] of Object.entries(cluster.events ?? {})) {
+        const element = EventElement({
+            id: event.id,
+            name,
+            type: 'any',
+            priority: name === 'operationalError' ? 'critical' : 'info',
+            conformance: 'O',
+        });
+        element.operationalIsSupported = true;
+        children.push(element);
+    }
+    return new ClusterModel({
+        id: cluster.id,
+        name: cluster.name,
+        revision: cluster.revision ?? 1,
+    }, ...children);
+}

package/dist/devices/export.d.ts

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
 export * from './castingVideoPlayer.js';
 export * from './speaker.js';
+export * from './closure.js';
+export * from './closurePanel.js';
+export * from './irrigationSystem.js';
+export * from './soilSensor.js';
 export * from './roboticVacuumCleaner.js';
 export * from './airConditioner.js';
 export * from './cooktop.js';

package/dist/devices/export.js

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
 export * from './castingVideoPlayer.js';
 export * from './speaker.js';
+export * from './closure.js';
+export * from './closurePanel.js';
+export * from './irrigationSystem.js';
+export * from './soilSensor.js';
 export * from './roboticVacuumCleaner.js';
 export * from './airConditioner.js';
 export * from './cooktop.js';

package/dist/devices/irrigationSystem.d.ts

@@ -0,0 +1,9 @@
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface IrrigationSystemOptions {
+    operationalState?: OperationalState.OperationalStateEnum;
+    flowMeasuredValue?: number | null;
+}
+export declare class IrrigationSystem extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: IrrigationSystemOptions);
+}

package/dist/devices/irrigationSystem.js

@@ -0,0 +1,12 @@
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { irrigationSystem } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class IrrigationSystem extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([irrigationSystem], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Irrigation System');
+        this.createDefaultOperationalStateClusterServer(options.operationalState ?? OperationalState.OperationalStateEnum.Stopped);
+        this.createDefaultFlowMeasurementClusterServer(options.flowMeasuredValue ?? null);
+    }
+}

package/dist/devices/soilSensor.d.ts

@@ -0,0 +1,14 @@
+import { ClusterBehavior } from '@matter/node';
+import { SoilMeasurement } from '../clusters/soil-measurement.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface SoilSensorOptions {
+    soilMoistureMeasuredValue?: number | null;
+}
+export declare const SoilMeasurementServer: ClusterBehavior.Type<SoilMeasurement.Cluster, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export declare class SoilSensor extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: SoilSensorOptions);
+    setSoilMoistureMeasuredValue(value: number | null): Promise<void>;
+    getSoilMoistureMeasuredValue(): number | null;
+}

package/dist/devices/soilSensor.js

@@ -0,0 +1,30 @@
+import { ClusterBehavior } from '@matter/node';
+import { MeasurementType } from '@matter/types/globals';
+import { SoilMeasurement } from '../clusters/soil-measurement.js';
+import { soilSensor } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createClusterSchema } from './customClusterSchema.js';
+export const SoilMeasurementServer = ClusterBehavior.for(SoilMeasurement.Cluster, createClusterSchema(SoilMeasurement.Cluster));
+export class SoilSensor extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([soilSensor], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Soil Sensor');
+        this.behaviors.require(SoilMeasurementServer, {
+            soilMoistureMeasurementLimits: {
+                measurementType: MeasurementType.SoilMoisture,
+                measured: true,
+                minMeasuredValue: 0,
+                maxMeasuredValue: 100,
+                accuracyRanges: [{ rangeMin: 0, rangeMax: 100, fixedMax: 1 }],
+            },
+            soilMoistureMeasuredValue: options.soilMoistureMeasuredValue ?? null,
+        });
+    }
+    async setSoilMoistureMeasuredValue(value) {
+        await this.setAttribute(SoilMeasurement.Cluster.id, 'soilMoistureMeasuredValue', value);
+    }
+    getSoilMoistureMeasuredValue() {
+        return this.getAttribute(SoilMeasurement.Cluster.id, 'soilMoistureMeasuredValue');
+    }
+}

package/dist/devices/solarPower.d.ts

@@ -1,4 +1,5 @@
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class SolarPower extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+    constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint, absMinPower?: number, absMaxPower?: number);
+    addPanel(name: string, tag: number, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint | null): MatterbridgeEndpoint;
 }

package/dist/devices/solarPower.js

@@ -1,9 +1,9 @@
-import { PowerSourceTag } from '@matter/node';
+import { NumberTag, PowerSourceTag } from '@matter/node';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { deviceEnergyManagement, electricalSensor, powerSource, solarPower } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class SolarPower extends MatterbridgeEndpoint {
-    constructor(name, serial, voltage = null, current = null, power = null, energyExported = null, absMinPower = 0, absMaxPower = 0) {
+    constructor(name, serial, voltage = null, current = null, power = null, energyExported = 0, absMinPower = 0, absMaxPower = 0) {
         super([solarPower, powerSource, electricalSensor, deviceEnergyManagement], {
             tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Solar.namespaceId, tag: PowerSourceTag.Solar.tag, label: null }],
             id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
@@ -18,4 +18,18 @@ export class SolarPower extends MatterbridgeEndpoint {
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
     }
+    addPanel(name, tag, voltage = null, current = null, power = null, energyExported = null) {
+        const panel = this.addChildDeviceType(name, electricalSensor, {
+            tagList: [
+                { mfgCode: null, namespaceId: PowerSourceTag.Solar.namespaceId, tag: PowerSourceTag.Solar.tag, label: null },
+                { mfgCode: null, namespaceId: NumberTag.One.namespaceId, tag, label: null },
+            ],
+        })
+            .createDefaultPowerTopologyClusterServer()
+            .createDefaultElectricalPowerMeasurementClusterServer(voltage, current, power)
+            .createDefaultElectricalEnergyMeasurementClusterServer(0, energyExported)
+            .addRequiredClusterServers();
+        panel.addUserLabel('panel', name.slice(0, 16));
+        return panel;
+    }
 }

package/dist/matterbridgeDeviceTypes.d.ts

@@ -93,3 +93,7 @@ export declare const waterHeater: DeviceTypeDefinition;
 export declare const solarPower: DeviceTypeDefinition;
 export declare const batteryStorage: DeviceTypeDefinition;
 export declare const heatPump: DeviceTypeDefinition;
+export declare const soilSensor: DeviceTypeDefinition;
+export declare const irrigationSystem: DeviceTypeDefinition;
+export declare const closure: DeviceTypeDefinition;
+export declare const closurePanel: DeviceTypeDefinition;

package/dist/matterbridgeDeviceTypes.js

@@ -86,6 +86,9 @@ import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-manag
 import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { DeviceTypeId } from '@matter/types/datatype';
+import { ClosureControl } from './clusters/closure-control.js';
+import { ClosureDimension } from './clusters/closure-dimension.js';
+import { SoilMeasurement } from './clusters/soil-measurement.js';
 export var DeviceClasses;
 (function (DeviceClasses) {
     DeviceClasses["Node"] = "Node";
@@ -643,3 +646,37 @@ export const heatPump = DeviceTypeDefinition({
     requiredServerClusters: [],
     optionalServerClusters: [Identify.Cluster.id, Thermostat.Cluster.id],
 });
+export const soilSensor = DeviceTypeDefinition({
+    name: 'MA-soilSensor',
+    code: 0x0045,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [Identify.Cluster.id, SoilMeasurement.Cluster.id],
+    optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+});
+export const irrigationSystem = DeviceTypeDefinition({
+    name: 'MA-irrigationSystem',
+    code: 0x0040,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [],
+    optionalServerClusters: [Identify.Cluster.id, OperationalState.Cluster.id, FlowMeasurement.Cluster.id],
+    requiredClientClusters: [],
+    optionalClientClusters: [FlowMeasurement.Cluster.id],
+});
+export const closure = DeviceTypeDefinition({
+    name: 'MA-closure',
+    code: 0x0230,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [Identify.Cluster.id, ClosureControl.Cluster.id],
+    optionalServerClusters: [],
+});
+export const closurePanel = DeviceTypeDefinition({
+    name: 'MA-closurePanel',
+    code: 0x0231,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [ClosureDimension.Cluster.id],
+    optionalServerClusters: [],
+});

package/dist/matterbridgeEndpointTypes.d.ts

@@ -40,6 +40,8 @@ export interface MatterbridgeEndpointCommands {
     stopMotion: HandlerFunction;
     goToLiftPercentage: HandlerFunction;
     goToTiltPercentage: HandlerFunction;
+    moveTo: HandlerFunction;
+    setTarget: HandlerFunction;
     lockDoor: HandlerFunction;
     unlockDoor: HandlerFunction;
     setpointRaiseLower: HandlerFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.6.0-dev-20260302-e3a7eb0",
+  "version": "3.6.0-dev-20260303-f33e36a",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,10 +122,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/thread": "3.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/types": "3.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/utils": "3.6.0-dev-20260302-e3a7eb0",
+    "@matterbridge/dgram": "3.6.0-dev-20260303-f33e36a",
+    "@matterbridge/thread": "3.6.0-dev-20260303-f33e36a",
+    "@matterbridge/types": "3.6.0-dev-20260303-f33e36a",
+    "@matterbridge/utils": "3.6.0-dev-20260303-f33e36a",
     "archiver": "7.0.1",
     "express": "5.2.1",
     "glob": "13.0.6",