@matter/protocol 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/src/peer/ControllerDiscovery.ts

@@ -14,7 +14,6 @@ import {
     Seconds,
     ServerAddress,
 } from "#general";
-import { CommissionableDeviceDiscoveryFailedError } from "#peer/ControllerCommissioningFlow.js";
 import { RetransmissionLimitReachedError } from "#protocol/errors.js";
 import { NodeId } from "#types";
 import {
@@ -27,9 +26,13 @@ import {
 } from "../common/Scanner.js";
 import { Fabric } from "../fabric/Fabric.js";
 import { MdnsClient } from "../mdns/MdnsClient.js";
+import { CommissioningError } from "./CommissioningError.js";
 
 const logger = Logger.get("ControllerDiscovery");
 
+/** Error that throws when the device could not be discovered using the provided details. */
+export class CommissionableDeviceDiscoveryFailedError extends CommissioningError {}
+
 export class DiscoveryError extends RetransmissionLimitReachedError {}
 
 /**

package/src/peer/InteractionQueue.ts

@@ -4,12 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Environment, Environmental, Millis, PromiseQueue } from "#general";
+import { Environment, Environmental, Millis, Semaphore } from "#general";
 
 const CONCURRENT_QUEUED_INTERACTIONS = 4;
 const INTERACTION_QUEUE_DELAY = Millis(100);
 
-export class InteractionQueue extends PromiseQueue {
+export class InteractionQueue extends Semaphore {
     constructor() {
         super(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY);
     }

package/src/peer/PeerAddressStore.ts

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ReadScope } from "#action/client/ReadScope.js";
 import { Construction, MaybePromise } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
@@ -28,8 +27,6 @@ export abstract class PeerDataStore {
     abstract maxEventNumber: EventNumber;
     abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
 
-    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[], scope: ReadScope): MaybePromise<void>;
-
     // TODO: Find a maybe better way to achieve this without functions
     abstract retrieveAttribute(
         endpointId: EndpointNumber,
@@ -37,10 +34,4 @@ export abstract class PeerDataStore {
         attributeId: AttributeId,
     ): DecodedAttributeReportValue<any> | undefined;
     abstract retrieveAttributes(endpointId: EndpointNumber, clusterId: ClusterId): DecodedAttributeReportValue<any>[];
-    abstract getClusterDataVersion(endpointId: EndpointNumber, clusterId: ClusterId): number | undefined;
-    abstract getClusterDataVersions(
-        filterEndpointId?: EndpointNumber,
-        filterClusterId?: ClusterId,
-    ): { endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[];
-    abstract cleanupAttributeData(endpointId: EndpointNumber, clusterIds?: ClusterId[]): MaybePromise<void>;
 }

package/src/peer/PeerSet.ts

@@ -44,7 +44,6 @@ import { Session } from "#session/Session.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { CaseAuthenticatedTag, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
-import { InteractionQueue } from "./InteractionQueue.js";
 import { Peer } from "./Peer.js";
 import { PeerAddressStore, PeerDataStore } from "./PeerAddressStore.js";
 import { PeerDescriptor } from "./PeerDescriptor.js";
@@ -116,7 +115,6 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
     readonly #peers = new BasicSet<Peer>();
     readonly #construction: Construction<PeerSet>;
     readonly #store: PeerAddressStore;
-    readonly #interactionQueue = new InteractionQueue();
     readonly #nodeCachedData = new PeerAddressMap<PeerDataStore>(); // Temporarily until we store it in new API
     readonly #disconnected = AsyncObservable<[peer: Peer]>();
     readonly #peerContext: Peer.Context;
@@ -241,10 +239,6 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         return this.#peers;
     }
 
-    get interactionQueue() {
-        return this.#interactionQueue;
-    }
-
     async connect(address: PeerAddress, options: PeerConnectionOptions & { operationalAddress?: ServerAddressUdp }) {
         await this.#ensureConnection(address, { ...options, allowUnknownPeer: true });
     }
@@ -272,13 +266,26 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
 
         const peer = this.for(address);
 
-        if (this.#sessions.maybeSessionFor(address) || peer.activeDiscovery?.type === NodeDiscoveryType.FullDiscovery) {
+        // We have a session, so we assume we have connection
+        if (this.#sessions.maybeSessionFor(address)) {
+            return;
+        }
+
+        // There is an active discovery running for Full discovery, we can not do more than that, do not block the call
+        // because it will error in the next step
+        if (peer.activeDiscovery?.type === NodeDiscoveryType.FullDiscovery) {
             return;
         }
 
         const { promise: existingReconnectPromise } = peer.activeReconnection ?? {};
         if (existingReconnectPromise !== undefined) {
-            return existingReconnectPromise;
+            // There is an active timed reconnection running and we also do not want a Full discovery here, so return
+            // the existing promise
+            if (options.discoveryOptions?.discoveryType !== NodeDiscoveryType.FullDiscovery) {
+                return existingReconnectPromise;
+            } else {
+                return;
+            }
         }
 
         const { promise, resolver, rejecter } = createPromise<SecureSession>();
@@ -294,9 +301,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 rejecter(error);
             });
 
-        if (options.discoveryOptions?.discoveryType !== NodeDiscoveryType.FullDiscovery) {
-            return promise;
-        }
+        return promise;
     }
 
     /**
@@ -312,34 +317,62 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
             const session = await this.#sessions.groupSessionForAddress(address, this.#transports);
             return new DedicatedChannelExchangeProvider(this.#exchanges, session);
         }
+        const peer = this.for(address);
         let initiallyConnected = !!this.#sessions.maybeSessionFor(address);
-        return new ReconnectableExchangeProvider(this.#exchanges, this.#sessions, address, async () => {
+        return new ReconnectableExchangeProvider(this.#exchanges, this.#sessions, address, async reconnOptions => {
+            const { asOf, resetInitialState } = reconnOptions ?? {};
             const { caseAuthenticatedTags, discoveryOptions } = options;
 
-            if (!initiallyConnected && !this.#sessions.maybeSessionFor(address)) {
+            const fullDiscoveryRunning = peer.activeDiscovery?.type === NodeDiscoveryType.FullDiscovery;
+
+            if (resetInitialState && !fullDiscoveryRunning) {
+                initiallyConnected = !!this.#sessions.maybeSessionFor(address);
+            }
+
+            if (!initiallyConnected && !this.#sessions.maybeSessionFor(address) && !fullDiscoveryRunning) {
+                // When we know that we have no operational address, do a 10s discovery initially, else we use the last known address
+                const discoveryType =
+                    this.#getLastOperationalAddress(address) === undefined
+                        ? NodeDiscoveryType.TimedDiscovery
+                        : NodeDiscoveryType.None;
                 // We got an uninitialized node, so do the first connection as usual
                 await this.#ensureConnection(address, {
-                    discoveryOptions: { discoveryType: NodeDiscoveryType.None },
+                    discoveryOptions: {
+                        discoveryType,
+                        timeout:
+                            discoveryType === NodeDiscoveryType.TimedDiscovery
+                                ? RETRANSMISSION_DISCOVERY_TIMEOUT
+                                : undefined,
+                    },
                     caseAuthenticatedTags,
                 });
-                initiallyConnected = true; // We only do this connection once, rest is handled in following code
+                initiallyConnected = true; // We only do this connection once, the rest is handled in the following code
                 if (this.#sessions.maybeSessionFor(address)) {
                     return;
                 }
             }
 
-            if (!this.#sessions.maybeSessionFor(address)) {
+            if (
+                !this.#sessions.maybeSessionFor(address) &&
+                discoveryOptions?.discoveryType !== NodeDiscoveryType.FullDiscovery &&
+                (!peer.activeDiscovery || peer.activeDiscovery.type === NodeDiscoveryType.FullDiscovery) // The above value might be outdated
+            ) {
                 throw new RetransmissionLimitReachedError(`Device ${PeerAddress(address)} is unreachable`);
             }
 
             // Close all sessions
-            await this.#sessions.handlePeerLoss(address);
+            await this.#sessions.handlePeerLoss(address, asOf);
+
+            if (this.#sessions.maybeSessionFor(address)) {
+                // Ok, it seems we got a new session after provided Timestamp, so use this
+                return;
+            }
 
             // Enrich discoveryData with data from the node store when not provided
             const { discoveryData } = discoveryOptions ?? {
-                discoveryData: this.get(address)?.descriptor.discoveryData,
+                discoveryData: peer.descriptor.discoveryData,
             };
-            // Try to use first result for one last try before we need to reconnect
+            // Try to use the first result for one last try before we need to reconnect
             const operationalAddress = this.#knownOperationalAddressFor(address, true);
             if (operationalAddress === undefined) {
                 logger.info(
@@ -349,7 +382,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 throw new RetransmissionLimitReachedError(`No operational address found for ${PeerAddress(address)}`);
             }
 
-            // Try to reconnect to last known address
+            // Try to reconnect to the last known address
             if (
                 (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, {
                     expectedProcessingTime: Seconds(2),
@@ -376,8 +409,6 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         for (const peer of this.#peers) {
             await peer.close();
         }
-
-        this.#interactionQueue.close();
     }
 
     /**
@@ -755,7 +786,9 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
             peer = new Peer({ address, dataStore: await this.#store.createNodeStore(address) }, this.#peerContext);
             this.#peers.add(peer);
         }
-        peer.descriptor.operationalAddress = operationalServerAddress ?? peer.descriptor.operationalAddress;
+        if (operationalServerAddress !== undefined) {
+            peer.descriptor.operationalAddress = operationalServerAddress;
+        }
         if (discoveryData !== undefined) {
             peer.descriptor.discoveryData = {
                 ...peer.descriptor.discoveryData,

package/src/peer/PhysicalDeviceProperties.ts

@@ -78,7 +78,7 @@ export namespace PhysicalDeviceProperties {
         }
         if (maxIntervalCeiling < defaultCeiling) {
             logger.debug(
-                `${description}: maxIntervalCeilingSeconds ideally is ${defaultCeiling}s instead of ${maxIntervalCeiling}s due to device type`,
+                `${description}: maxIntervalCeilingSeconds ideally is ${Duration.format(defaultCeiling)} instead of ${Duration.format(maxIntervalCeiling)} due to device type`,
             );
         }
 

package/src/peer/index.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+export * from "./CommissioningError.js";
 export * from "./ControllerCommissioner.js";
 export * from "./ControllerCommissioningFlow.js";
 export * from "./ControllerDiscovery.js";

package/src/protocol/DeviceCommissioner.ts

@@ -25,7 +25,6 @@ import { SecureChannelProtocol } from "#securechannel/SecureChannelProtocol.js";
 import { PaseServer } from "#session/pase/PaseServer.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { CommissioningOptions, STANDARD_COMMISSIONING_TIMEOUT, StatusCode, StatusResponseError } from "#types";
-import type { ControllerCommissioner } from "../peer/ControllerCommissioner.js";
 import { DeviceAdvertiser } from "./DeviceAdvertiser.js";
 
 const logger = Logger.get("DeviceCommissioner");

package/src/protocol/ExchangeManager.ts

@@ -245,9 +245,9 @@ export class ExchangeManager {
             message.payloadHeader.messageType,
         );
         const messageDiagnostics = Diagnostic.dict({
-            message: messageId,
+            message: hex.fixed(messageId, 8),
             protocol: message.payloadHeader.protocolId,
-            exId: message.payloadHeader.exchangeId,
+            exId: hex.word(message.payloadHeader.exchangeId),
             via: channel.name,
         });
 

package/src/protocol/ExchangeProvider.ts

@@ -3,7 +3,7 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Diagnostic, Duration, Observable } from "#general";
+import { Diagnostic, Duration, Observable, Timestamp } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
 import { DEFAULT_EXPECTED_PROCESSING_TIME } from "#protocol/MessageChannel.js";
@@ -37,7 +37,7 @@ export abstract class ExchangeProvider {
 
     abstract maximumPeerResponseTime(expectedProcessingTime?: Duration): Duration;
     abstract initiateExchange(): Promise<MessageExchange>;
-    abstract reconnectChannel(): Promise<boolean>;
+    abstract reconnectChannel(options: { asOf?: Timestamp; resetInitialState?: boolean }): Promise<boolean>;
     abstract session: Session;
 
     get channelType() {
@@ -80,14 +80,14 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
 export class ReconnectableExchangeProvider extends ExchangeProvider {
     readonly supportsReconnect = true;
     readonly #address: PeerAddress;
-    readonly #reconnectChannelFunc: () => Promise<void>;
+    readonly #reconnectChannelFunc: (options?: { asOf?: Timestamp; resetInitialState?: boolean }) => Promise<void>;
     readonly #channelUpdated = Observable<[void]>();
 
     constructor(
         exchangeManager: ExchangeManager,
         protected readonly sessions: SessionManager,
         address: PeerAddress,
-        reconnectChannelFunc: () => Promise<void>,
+        reconnectChannelFunc: (options?: { asOf?: Timestamp; resetInitialState?: boolean }) => Promise<void>,
     ) {
         super(exchangeManager);
         this.#address = address;
@@ -118,9 +118,11 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         return this.exchangeManager.initiateExchange(this.#address, INTERACTION_PROTOCOL_ID);
     }
 
-    async reconnectChannel() {
-        if (this.#reconnectChannelFunc === undefined) return false;
-        await this.#reconnectChannelFunc();
+    async reconnectChannel(options: { asOf?: Timestamp; resetInitialState?: boolean } = {}) {
+        if (this.#reconnectChannelFunc === undefined) {
+            return false;
+        }
+        await this.#reconnectChannelFunc(options);
         return true;
     }
 

package/src/session/NodeSession.ts

@@ -277,9 +277,10 @@ export class NodeSession extends SecureSession {
         await this.handlePeerLoss();
     }
 
-    async handlePeerLoss(currentExchange?: MessageExchange) {
+    async handlePeerLoss(data: { currentExchange?: MessageExchange; keepSubscriptions?: boolean } = {}) {
         this.#isPeerLost = true;
-        await this.initiateForceClose(currentExchange);
+        const { currentExchange, keepSubscriptions } = data;
+        await this.initiateForceClose(currentExchange, keepSubscriptions);
     }
 
     get isPeerLost() {
@@ -311,9 +312,9 @@ export class NodeSession extends SecureSession {
         });
     }
 
-    override async initiateForceClose(currentExchange?: MessageExchange) {
+    override async initiateForceClose(currentExchange?: MessageExchange, keepSubscriptions = false) {
         this.#isPeerLost = true;
-        await super.initiateForceClose(currentExchange);
+        await super.initiateForceClose(currentExchange, keepSubscriptions);
     }
 
     override addExchange(exchange: MessageExchange) {

package/src/session/Session.ts

@@ -254,14 +254,18 @@ export abstract class Session {
     /**
      * Force-close the session.
      *
-     * This terminates subscriptions and exchanges without notifying peers.  It places the session in a closing state
-     * so no further exchanges are accepted.
+     * This terminates (potentially) subscriptions and exchanges without notifying peers.  It places the session in a
+     * closing state so no further exchanges are accepted.
      *
      * @param except an exchange that should not be forced close; this allows the current exchange to remain open
+     * @param keepSubscriptions whether to keep the subscriptions open after force-closing the session.
+     *  TODO refactor when moving subscriptions away from sessions
      */
-    async initiateForceClose(except?: MessageExchange) {
+    async initiateForceClose(except?: MessageExchange, keepSubscriptions = false) {
         await this.initiateClose(async () => {
-            await this.closeSubscriptions();
+            if (!keepSubscriptions) {
+                await this.closeSubscriptions();
+            }
             for (const exchange of this.#exchanges) {
                 if (exchange === except) {
                     continue;

package/src/session/SessionManager.ts

@@ -26,6 +26,7 @@ import {
     ObserverGroup,
     StorageContext,
     StorageManager,
+    Time,
     Timestamp,
     toHex,
 } from "#general";
@@ -424,9 +425,25 @@ export class SessionManager {
         return this.#sessions.filter(session => session.fabric?.fabricIndex === fabricIndex);
     }
 
-    async handlePeerLoss(address: PeerAddress, asOf?: Timestamp) {
+    /**
+     * Removes all Peer sessions but keeps subscriptions intact because they could be refreshed on restart when the
+     * device supports persistent subscriptions.
+     */
+    handlePeerShutdown(address: PeerAddress, asOf?: Timestamp) {
+        return this.#handlePeerLoss({ address, asOf: asOf ?? Time.nowMs, keepSubscriptions: true });
+    }
+
+    /**
+     * Removes all Peer sessions and closes subscriptions.
+     */
+    handlePeerLoss(address: PeerAddress, asOf?: Timestamp) {
+        return this.#handlePeerLoss({ address, asOf: asOf ?? Time.nowMs });
+    }
+
+    async #handlePeerLoss(options: { address: PeerAddress; asOf?: Timestamp; keepSubscriptions?: boolean }) {
         await this.#construction;
 
+        const { address, asOf, keepSubscriptions } = options;
         for (const session of this.#sessions) {
             if (!session.peerIs(address)) {
                 continue;
@@ -436,7 +453,7 @@ export class SessionManager {
                 continue;
             }
 
-            await session.handlePeerLoss();
+            await session.handlePeerLoss({ keepSubscriptions });
         }
     }
 

package/dist/cjs/cluster/client/AttributeClient.d.ts

@@ -1,75 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Attribute, AttributeId, ClusterId, EndpointNumber, TlvSchema } from "#types";
-import { InteractionClient } from "../../interaction/InteractionClient.js";
-/**
- * Factory function to create an AttributeClient for a given attribute.
- */
-export declare function createAttributeClient<T>(attribute: Attribute<T, any>, name: string, endpointId: EndpointNumber | undefined, clusterId: ClusterId, interactionClient: InteractionClient, present?: boolean): AttributeClient<T>;
-/**
- * General class for AttributeClients
- */
-export declare class AttributeClient<T = any> {
-    #private;
-    readonly attribute: Attribute<T, any>;
-    readonly name: string;
-    readonly endpointId: EndpointNumber | undefined;
-    readonly clusterId: ClusterId;
-    protected readonly schema: TlvSchema<any>;
-    readonly id: AttributeId;
-    constructor(attribute: Attribute<T, any>, name: string, endpointId: EndpointNumber | undefined, clusterId: ClusterId, interactionClient: InteractionClient);
-    /**
-     * Set the value of the attribute. When dataVersion parameter is provided the value is only set when the
-     * cluster dataVersion of the server matches. If it does not match it is rejected with an Error.
-     */
-    set(value: T, dataVersion?: number): Promise<void>;
-    get fabricScoped(): boolean;
-    getLocal(): T | undefined;
-    /**
-     * Get the value of the attribute. Fabric scoped reads are always done with the remote.
-     * The `requestFromRemote` parameter allowed to force or prevent remote reads:
-     * - `true` forces a remote read
-     * - `false` forces a local read, return undefined if no value is available
-     * - `undefined` returns local values if available or if the read is fabric filtered, otherwise remote read
-     */
-    get(requestFromRemote?: boolean, isFabricFiltered?: boolean): Promise<T | undefined>;
-    /**
-     * Get the value with version of the attribute. Fabric scoped reads are always done with the remote.
-     * The `requestFromRemote` parameter allowed to force or prevent remote reads:
-     * - `true` forces a remote read
-     * - `false` forces a local read, return undefined if no value is available
-     * - `undefined` returns local values if available or if the read is fabric filtered, otherwise remote read
-     */
-    getWithVersion(requestFromRemote?: boolean, isFabricFiltered?: boolean): Promise<{
-        value: T;
-        version: number;
-    } | undefined>;
-    /** Subscribe to the attribute. */
-    subscribe(minIntervalFloorSeconds: number, maxIntervalCeilingSeconds: number, knownDataVersion?: number, isFabricFiltered?: boolean): Promise<{
-        maxInterval: number;
-    }>;
-    /**
-     * Update the value of the attribute. Just internally used!
-     * @private
-     */
-    update(value: T): void;
-    /** Add a listener to the attribute. */
-    addListener(listener: (newValue: T) => void): void;
-    /** Remove a listener from the attribute. */
-    removeListener(listener: (newValue: T) => void): void;
-}
-/**
- * Special AttributeClient class to allow identifying attributes that are supported because reported by the Devices.
- */
-export declare class SupportedAttributeClient<T> extends AttributeClient<T> {
-}
-/**
- * Special AttributeClient class to allow identifying attributes that are supported because reported by the Devices,
- * but the contained attribute is unknown.
- */
-export declare class UnknownSupportedAttributeClient extends SupportedAttributeClient<any> {
-}
-//# sourceMappingURL=AttributeClient.d.ts.map

package/dist/cjs/cluster/client/AttributeClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttributeClient.d.ts","sourceRoot":"","sources":["../../../../src/cluster/client/AttributeClient.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,SAAS,EAAkB,WAAW,EAAE,SAAS,EAAE,cAAc,EAAe,SAAS,EAAE,MAAM,QAAQ,CAAC;AACnH,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAE3E;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACnC,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,cAAc,GAAG,SAAS,EACtC,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,iBAAiB,EACpC,OAAO,UAAQ,GAChB,eAAe,CAAC,CAAC,CAAC,CAQpB;AAED;;GAEG;AACH,qBAAa,eAAe,CAAC,CAAC,GAAG,GAAG;;IAU5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,UAAU,EAAE,cAAc,GAAG,SAAS;IAC/C,QAAQ,CAAC,SAAS,EAAE,SAAS;IATjC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAE1C,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;gBAIZ,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,cAAc,GAAG,SAAS,EACtC,SAAS,EAAE,SAAS,EAC7B,iBAAiB,EAAE,iBAAiB;IAWxC;;;OAGG;IACG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM;IA4CxC,IAAI,YAAY,YAEf;IAED,QAAQ;IAWR;;;;;;OAMG;IACG,GAAG,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,gBAAgB,UAAO;IAkB9D;;;;;;OAMG;IACG,cAAc,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,gBAAgB,UAAO;;;;IAkBzE,kCAAkC;IAC5B,SAAS,CACX,uBAAuB,EAAE,MAAM,EAC/B,yBAAyB,EAAE,MAAM,EACjC,gBAAgB,CAAC,EAAE,MAAM,EACzB,gBAAgB,UAAO;;;IAoB3B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC;IAIf,uCAAuC;IACvC,WAAW,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI;IAI3C,4CAA4C;IAC5C,cAAc,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI;CAMjD;AAED;;GAEG;AACH,qBAAa,wBAAwB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;CAAG;AAEtE;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,wBAAwB,CAAC,GAAG,CAAC;CAAG"}