@matter/protocol 0.17.0-alpha.0-20260507-059f7763b → 0.17.0-alpha.0-20260508-29ff5ae9e

package/src/peer/PeerConnection.ts

@@ -23,6 +23,7 @@ import {
     Diagnostic,
     Duration,
     Heap,
+    IpChannelType,
     Lifetime,
     Logger,
     Millis,
@@ -30,6 +31,7 @@ import {
     ServerAddress,
     ServerAddressIp,
     ServerAddressSet,
+    ServerAddressTcp,
     ServerAddressUdp,
     Time,
     Timestamp,
@@ -94,7 +96,11 @@ export async function PeerConnection(
     const via = Diagnostic.via(peer.address.toString());
 
     const timing = options?.timing ? PeerTimingParameters.merge(context.timing, options.timing) : context.timing;
-    const useTcp = options?.transport === ChannelType.TCP;
+    const requiredTransport = options?.requiredTransport;
+    const preferredTransport = options?.preferredTransport;
+
+    // Lazy so descriptor.T arriving mid-connect (operational mDNS) is honored for later expansions.
+    const resolveTransports = () => peer.resolveTransports(requiredTransport, preferredTransport);
 
     using overallAbort = new Abort(options);
     using lifetime = (peer.lifetime ?? Lifetime.process).join("connecting");
@@ -130,11 +136,20 @@ export async function PeerConnection(
     // Address set used for interning
     const addresses = ServerAddressSet<ServerAddressIp>();
 
-    // Addresses we will attempt to connect to in priority order
-    const pendingAddresses = new Heap<ServerAddressIp>(
-        ServerAddressSet.compareDesirability,
-        addresses.add.bind(addresses),
-    );
+    // Addresses to try, ordered by desirability and (for same-IP variants) by transport-list index.
+    const pendingAddresses = new Heap<ServerAddressIp>((a, b) => {
+        const primary = ServerAddressSet.compareDesirability(a, b);
+        const transports = resolveTransports();
+        if (primary !== 0 || transports === undefined) {
+            return primary;
+        }
+        return transportIndex(a, transports) - transportIndex(b, transports);
+    }, addresses.add.bind(addresses));
+
+    function transportIndex(address: ServerAddressIp, transports: IpChannelType[]): number {
+        const type = (address as { type?: IpChannelType }).type;
+        return type === undefined ? -1 : transports.indexOf(type);
+    }
 
     // When the service is undiscovered, we attempt to connect to the last-known good address and store it here
     let attemptingFallback: ServerAddressIp | undefined;
@@ -235,35 +250,41 @@ export async function PeerConnection(
     }
 
     /**
-     * When TCP transport is required, stamp the address with the TCP type.
+     * Expand an address into one variant per requested transport, or return it unchanged when no
+     * transport list is set.
      */
-    function applyTransportConstraint(address: ServerAddressIp): ServerAddressIp {
-        if (useTcp) {
-            return { ...address, type: "tcp" } as ServerAddressIp;
+    function expandAddresses(address: ServerAddressIp): ServerAddressIp[] {
+        const transports = resolveTransports();
+        if (transports === undefined) {
+            return [address];
         }
-        return address;
+        return transports.map(type =>
+            type === ChannelType.TCP
+                ? ({ ...address, type } satisfies ServerAddressTcp)
+                : ({ ...address, type } satisfies ServerAddressUdp),
+        );
     }
 
     /**
      * Enqueue an address if not already attempting.
      */
     function addAddress(address: ServerAddressIp) {
-        address = applyTransportConstraint(address);
-        address = addresses.add(address);
-
-        // Skip if we're already attempting connection to this address
-        const attempt = attempts.get(address);
-        if (attempt !== undefined) {
-            if (attemptingFallback && ServerAddress.isEqual(attemptingFallback, address)) {
-                // The "fallback" is now a "real" address
-                attemptingFallback = undefined;
-                kicker?.emit("discover"); // ... and trigger rediscovery / restart of the CASE exchange as needed
+        for (const variant of expandAddresses(address)) {
+            const interned = addresses.add(variant);
+
+            // Skip if we're already attempting connection to this exact (ip,port,type) variant
+            const attempt = attempts.get(interned);
+            if (attempt !== undefined) {
+                if (attemptingFallback && ServerAddress.isEqual(attemptingFallback, interned)) {
+                    // The "fallback" is now a "real" address
+                    attemptingFallback = undefined;
+                    kicker?.emit("discover"); // ... and trigger rediscovery / restart of the CASE exchange as needed
+                }
+                continue;
             }
 
-            return;
+            pendingAddresses.add(interned);
         }
-
-        pendingAddresses.add(address);
     }
 
     /**
@@ -275,9 +296,16 @@ export async function PeerConnection(
         }
 
         const fallback = peer.descriptor.operationalAddress;
-        attemptingFallback = fallback ? applyTransportConstraint(fallback) : undefined;
-        if (attemptingFallback) {
-            pendingAddresses.add(attemptingFallback);
+        if (!fallback) {
+            attemptingFallback = undefined;
+            return;
+        }
+        const variants = expandAddresses(fallback);
+        // The interned first variant is the fallback marker; reference equality
+        // must match what comes back out of pendingAddresses.
+        attemptingFallback = addresses.add(variants[0]);
+        for (const variant of variants) {
+            pendingAddresses.add(variant);
         }
     }
 
@@ -313,30 +341,31 @@ export async function PeerConnection(
     }
 
     /**
-     * End connection attempt.
+     * End connection attempt(s) for the given address. Discovery emits bare addresses without
+     * transport type; expand into the same variants `addAddress` enqueued so the typed
+     * entries in `attempts`/`pendingAddresses` actually match.
      */
     function deleteAddress(address: ServerAddressIp, why: string) {
-        address = addresses.add(address);
-        const attempt = attempts.get(address);
-
-        if (attempt) {
-            const operationalAddress = peer.descriptor.operationalAddress;
-            if (
-                attempts.size === 1 &&
-                operationalAddress !== undefined &&
-                ServerAddress.isEqual(operationalAddress, address)
-            ) {
-                // If we only have one attempt running and this is for the known operational address,
-                // fall back to fallback mode and just keep it running
-                attemptingFallback = address;
-                return;
-            }
-            debug(via, address, why);
-            attempt.abort();
-            attempts.delete(address);
+        const variants = expandAddresses(address).map(v => addresses.add(v));
+        const operationalAddress = peer.descriptor.operationalAddress;
+        const isOperational = operationalAddress !== undefined && ServerAddress.isEqual(operationalAddress, address);
+
+        // If only operational-address attempts remain, keep them alive as fallback.
+        const remainingNonOperational = attempts.size - variants.filter(v => attempts.has(v)).length;
+        if (isOperational && remainingNonOperational === 0) {
+            attemptingFallback = variants[0];
+            return;
         }
 
-        pendingAddresses.delete(address);
+        for (const variant of variants) {
+            const attempt = attempts.get(variant);
+            if (attempt) {
+                debug(via, variant, why);
+                attempt.abort();
+                attempts.delete(variant);
+            }
+            pendingAddresses.delete(variant);
+        }
     }
 
     function error(address: ServerAddressIp, ...message: unknown[]) {
@@ -602,12 +631,11 @@ export namespace PeerConnection {
         network?: string;
         kicker?: Observable<[KickOrigin]>;
 
-        /**
-         * Constrain the transport type for this connection. When set to `ChannelType.TCP`, the
-         * connection will be established over TCP (requires peer TCP Server support and local
-         * TCP outgoing enabled). When undefined, the default transport (UDP/MRP) is used.
-         */
-        transport?: ChannelType;
+        /** See {@link Peer.ConnectOptions.requiredTransport}. */
+        requiredTransport?: ChannelType;
+
+        /** See {@link Peer.ConnectOptions.preferredTransport}. */
+        preferredTransport?: ChannelType;
 
         /**
          * Per-call overrides for timing parameters.

package/src/peer/PeerDescriptor.ts

@@ -6,10 +6,31 @@
 
 import { DiscoveryData } from "#common/Scanner.js";
 import { SessionParameters } from "#session/SessionParameters.js";
-import { isDeepEqual, ServerAddressIp } from "@matter/general";
+import { isDeepEqual, ServerAddress, ServerAddressIp, ServerAddressTcp, ServerAddressUdp } from "@matter/general";
 import { CaseAuthenticatedTag } from "@matter/types";
 import { PeerAddress } from "./PeerAddress.js";
 
+/** Address persisted alongside a peer; transport type is required so storage stays schema-conformant. */
+export type OperationalAddress = ServerAddressUdp | ServerAddressTcp;
+
+export namespace OperationalAddress {
+    /**
+     * Narrow an arbitrary {@link ServerAddress} (or persisted shape lacking transport tag) to
+     * {@link OperationalAddress}. Returns `undefined` for non-IP addresses; defaults missing
+     * `type` to `"udp"` so storage written before transport tagging existed still loads.
+     */
+    export function from(address: ServerAddress | ServerAddressIp | undefined): OperationalAddress | undefined {
+        if (address === undefined || !ServerAddress.isIp(address)) {
+            return undefined;
+        }
+        const type = (address as { type?: string }).type;
+        if (type === "tcp" || type === "udp") {
+            return address as OperationalAddress;
+        }
+        return { ...address, type: "udp" };
+    }
+}
+
 /**
  * Operational information for a single peer.
  *
@@ -29,7 +50,7 @@ export interface PeerDescriptor {
     /**
      * A physical address the peer may be accessed at, if known.
      */
-    operationalAddress?: ServerAddressIp;
+    operationalAddress?: OperationalAddress;
 
     /**
      * Additional information collected while locating the peer.
@@ -53,7 +74,7 @@ export interface PeerDescriptor {
 
 export class ObservablePeerDescriptor implements PeerDescriptor {
     #address: PeerAddress;
-    #operationalAddress?: ServerAddressIp;
+    #operationalAddress?: OperationalAddress;
     #discoveryData?: DiscoveryData;
     #caseAuthenticatedTags?: readonly CaseAuthenticatedTag[];
     #sessionParameters?: SessionParameters;
@@ -78,7 +99,7 @@ export class ObservablePeerDescriptor implements PeerDescriptor {
         return this.#operationalAddress;
     }
 
-    set operationalAddress(value: ServerAddressIp | undefined) {
+    set operationalAddress(value: OperationalAddress | undefined) {
         if (isDeepEqual(this.#operationalAddress, value)) {
             return;
         }

package/src/peer/PeerExchangeProvider.ts

@@ -48,14 +48,12 @@ export class PeerExchangeProvider extends ExchangeProvider {
     }
 
     override async connect(options?: NewExchangeOptions): Promise<void> {
-        // Use explicit requirement, or fall back to the peer's transport preference
-        const transport = options?.requiredTransport ?? this.#peer.transportPreference;
-
         await this.#peer.connect({
             abort: options?.abort,
             network: options?.network,
             connectionTimeout: options?.connectionTimeout,
-            transport,
+            requiredTransport: options?.requiredTransport,
+            preferredTransport: options?.preferredTransport,
         });
     }
 
@@ -85,15 +83,19 @@ export class PeerExchangeProvider extends ExchangeProvider {
                         this.#peer.address,
                         this.#context.exchanges,
                     );
-                } else if (options?.requiredTransport === ChannelType.TCP) {
-                    // When TCP is explicitly required (e.g. Large Message Quality), only use TCP.
-                    // No fallback — the caller needs TCP or nothing.
-                    session = this.#peer.newestSession(ChannelType.TCP);
-                } else if (this.#peer.transportPreference === ChannelType.TCP) {
-                    // When TCP is preferred, try TCP first but fall back to any available session.
-                    session = this.#peer.newestSession(ChannelType.TCP) ?? this.#peer.newestSession();
                 } else {
-                    session = this.#peer.newestSession();
+                    const transports = this.#peer.resolveTransports(
+                        options?.requiredTransport,
+                        options?.preferredTransport,
+                    );
+                    if (transports === undefined) {
+                        session = this.#peer.newestSession();
+                    } else {
+                        for (const t of transports) {
+                            session = this.#peer.newestSession(t);
+                            if (session) break;
+                        }
+                    }
                 }
                 if (session === undefined) {
                     if (options?.requireExistingSession) {

package/src/peer/PeerSet.ts

@@ -33,7 +33,7 @@ import { FabricIndex } from "@matter/types";
 import { NetworkProfiles } from "./NetworkProfile.js";
 import { Peer } from "./Peer.js";
 import { PeerConnection } from "./PeerConnection.js";
-import { PeerDescriptor } from "./PeerDescriptor.js";
+import { OperationalAddress, PeerDescriptor } from "./PeerDescriptor.js";
 import { PeerTimingParameters } from "./PeerTimingParameters.js";
 
 /**
@@ -61,6 +61,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
     readonly #networks: NetworkProfiles;
     readonly #observers = new ObserverGroup();
     #exchanges?: ExchangeManager;
+    #transportPreference?: ChannelType.TCP;
 
     constructor(context: PeerSetContext) {
         const { lifetime, sessions, names, networks, timing, handleError } = context;
@@ -138,6 +139,18 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         return this.#disconnected;
     }
 
+    /**
+     * Default outgoing transport preference applied to peers created by this set when they have
+     * no per-peer override. Honored as a soft preference at connect time.
+     */
+    get transportPreference() {
+        return this.#transportPreference;
+    }
+
+    set transportPreference(pref: ChannelType.TCP | undefined) {
+        this.#transportPreference = pref;
+    }
+
     /**
      * Unconditional get.
      *
@@ -150,11 +163,18 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         }
 
         peer = new Peer({ address }, this.#peerContext);
+        this.#applyDefaultPreference(peer);
         this.#peers.add(peer);
 
         return peer;
     }
 
+    #applyDefaultPreference(peer: Peer) {
+        if (peer.transportPreference === undefined && this.#transportPreference !== undefined) {
+            peer.transportPreference = this.#transportPreference;
+        }
+    }
+
     has(item: PeerAddress | PeerDescriptor | Peer) {
         return !!this.get(item);
     }
@@ -270,6 +290,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         let peer = this.get(descriptor.address);
         if (peer === undefined) {
             peer = new Peer(descriptor, this.#peerContext);
+            this.#applyDefaultPreference(peer);
             this.#peers.add(peer);
         }
 
@@ -299,7 +320,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
     }
 }
 
-function operationalAddressOf(session: Session) {
+function operationalAddressOf(session: Session): OperationalAddress | undefined {
     if (session.isClosed || !isIpNetworkChannel(session.channel)) {
         return;
     }
@@ -307,5 +328,5 @@ function operationalAddressOf(session: Session) {
     if (session.channel.transportChannel.type === ChannelType.TCP) {
         return;
     }
-    return session.channel.networkAddress;
+    return { ...session.channel.networkAddress, type: "udp" };
 }

package/src/protocol/ExchangeProvider.ts

@@ -46,6 +46,13 @@ export interface NewExchangeOptions extends Omit<InteractionSettings, "transacti
 
     /** Required transport type for this exchange. If set, only sessions of this transport type are used. */
     requiredTransport?: ChannelType;
+
+    /**
+     * Per-call soft transport preference. Honored only when the peer advertises matching server
+     * capability; otherwise the connect path falls back to UDP. Has no effect when
+     * {@link requiredTransport} is set.
+     */
+    preferredTransport?: ChannelType;
 }
 
 /**

package/dist/cjs/action/Interactable.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { InteractionSettings } from "./InteractionSettings.js";
-import { Invoke } from "./request/Invoke.js";
-import { Read } from "./request/Read.js";
-import { Subscribe } from "./request/Subscribe.js";
-import { Write } from "./request/Write.js";
-import { InvokeResult } from "./response/InvokeResult.js";
-import { ReadResult } from "./response/ReadResult.js";
-import { SubscribeResult } from "./response/SubscribeResult.js";
-import { WriteResult } from "./response/WriteResult.js";
-import { AccessControl } from "./server/AccessControl.js";
-export type InteractionSession = AccessControl.Session & InteractionSettings;
-/**
- * Objects implementing this interface can participate in Matter interactions.
- */
-export interface Interactable<SessionT = InteractionSession> {
-    /**
-     * Perform a Matter read interaction.
-     */
-    read(request: Read, session?: SessionT): ReadResult;
-    /**
-     * Perform a Matter subscribe interaction.
-     */
-    subscribe(request: Subscribe, session?: SessionT): SubscribeResult;
-    /**
-     * Perform a Matter write interaction.
-     */
-    write<T extends Write>(request: T, session?: SessionT): WriteResult<T>;
-    /**
-     * Perform a Matter invoke interaction.
-     */
-    invoke(request: Invoke, session?: SessionT): InvokeResult;
-}
-//# sourceMappingURL=Interactable.d.ts.map

package/dist/cjs/action/Interactable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Interactable.d.ts","sourceRoot":"","sources":["../../../src/action/Interactable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,GAAG,mBAAmB,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,QAAQ,GAAG,kBAAkB;IACvD;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAEpD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,eAAe,CAAC;IAEnE;;OAEG;IACH,KAAK,CAAC,CAAC,SAAS,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAEvE;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;CAC7D"}

package/dist/cjs/action/Interactable.js

@@ -1,22 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Interactable_exports = {};
-module.exports = __toCommonJS(Interactable_exports);
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-//# sourceMappingURL=Interactable.js.map

package/dist/cjs/action/Interactable.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/action/Interactable.ts"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
-  "names": []
-}

package/dist/cjs/action/InteractionSettings.d.ts

@@ -1,45 +0,0 @@
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { ExchangeLogContext } from "#protocol/MessageExchange.js";
-import { Duration, Transaction } from "@matter/general";
-/**
- * Configuration that applies to all interactions.
- */
-export interface InteractionSettings {
-    /**
-     * The transaction for the interaction.
-     *
-     * If this is undefined the interaction executes in a new, independent transaction that commits automatically.
-     */
-    transaction?: Transaction;
-    /**
-     * Aborts the interaction if supported by the underlying implementation.
-     *
-     * Most interactions with local nodes are not abortable, but local command implementations may optionally implement
-     * abort support.
-     *
-     * Interactions with remote nodes are abortable.
-     */
-    abort?: AbortSignal;
-    /**
-     * Timeout on connection.
-     *
-     * This limits the amount of time matter.js will wait for a new connection to the underlying node when performing
-     * remote interactions.  This timeout is from the time of first connection attempt; if matter.js is already
-     * attempting to establish a connection this may result in a timeout sooner than the supplied duration.
-     *
-     * The purpose of this timeout is to allow user-facing interactions to fail more quickly when the peer is known to
-     * be unresponsive.
-     *
-     * Use {@link abort} with a timed {@link AbortSignal} to limit total interaction time.
-     *
-     * This parameter has no effect when interacting with local nodes.
-     */
-    connectionTimeout?: Duration;
-    /** Additional context information for logging to be included at the beginning of the Message log. */
-    logContext?: ExchangeLogContext;
-}
-//# sourceMappingURL=InteractionSettings.d.ts.map

package/dist/cjs/action/InteractionSettings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InteractionSettings.d.ts","sourceRoot":"","sources":["../../../src/action/InteractionSettings.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;IAEpB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,QAAQ,CAAC;IAE7B,qGAAqG;IACrG,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACnC"}

package/dist/cjs/action/InteractionSettings.js

@@ -1,22 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var InteractionSettings_exports = {};
-module.exports = __toCommonJS(InteractionSettings_exports);
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-//# sourceMappingURL=InteractionSettings.js.map

package/dist/cjs/action/InteractionSettings.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/action/InteractionSettings.ts"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
-  "names": []
-}

package/dist/cjs/action/Val.d.ts

@@ -1,56 +0,0 @@
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { AccessControl } from "./server/AccessControl.js";
-/**
- * Any JS value representing a value defined by Matter.
- */
-export type Val = unknown;
-export declare namespace Val {
-    /**
-     * Type for Matter structs.  In JS this is an object with string keys.
-     */
-    type Struct = Record<string, Val>;
-    /**
-     * An ordered map representation of {@link Struct} that preserves insertion order of keys.
-     *
-     * Used when attribute-change ordering must be maintained across the processing pipeline.
-     */
-    type StructMap = Map<string | number, Val>;
-    /**
-     * Type for Matter structs encoded using protocol semantics.  In JS this is an object with "numeric" keys.
-     */
-    type ProtocolStruct = Record<number, Val>;
-    /**
-     * Type for Matter lists.  In Js this is an array.
-     */
-    type List = Val[];
-    /**
-     * Any matter collection type.
-     */
-    type Collection = Struct | List;
-    /**
-     * A readonly version of {@link Collection}.
-     */
-    type ReadonlyCollection = {
-        readonly [K: string | number]: Val;
-    } | ReadonlyArray<unknown>;
-    const properties: unique symbol;
-    /**
-     * Unmanaged raw state classes have no contextual information.  They may implement this interface to provide an
-     * alternate context-aware object for property read, write and validation.
-     */
-    interface Dynamic<O = any, S extends AccessControl.Session = AccessControl.Session> extends Struct {
-        /**
-         * Obtain a context-aware property source (and sink).  Supervision will read/write properties from here if
-         * present.  Otherwise they're read from static state as normal.
-         *
-         * @param owner the owner of the root reference of the managed value
-         * @param session the {@link AccessControl.Session} accessing the value
-         */
-        [properties]<This extends Val.Struct>(this: This, owner: O, session: S): Partial<This>;
-    }
-}
-//# sourceMappingURL=Val.d.ts.map

package/dist/cjs/action/Val.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Val.d.ts","sourceRoot":"","sources":["../../../src/action/Val.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC;AAE1B,yBAAiB,GAAG,CAAC,CAAC;IAClB;;OAEG;IACH,KAAY,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEzC;;;;OAIG;IACH,KAAY,SAAS,GAAG,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC;IAElD;;OAEG;IACH,KAAY,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEjD;;OAEG;IACH,KAAY,IAAI,GAAG,GAAG,EAAE,CAAC;IAEzB;;OAEG;IACH,KAAY,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;IAEvC;;OAEG;IACH,KAAY,kBAAkB,GAAG;QAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAA;KAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IAE1F,MAAM,UAAU,eAAuB,CAAC;IAE/C;;;OAGG;IACH,UAAiB,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,aAAa,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAE,SAAQ,MAAM;QACrG;;;;;;WAMG;QACH,CAAC,UAAU,CAAC,CAAC,IAAI,SAAS,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1F;CACJ"}

package/dist/cjs/action/Val.js

@@ -1,33 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Val_exports = {};
-__export(Val_exports, {
-  Val: () => Val
-});
-module.exports = __toCommonJS(Val_exports);
-/**
- * @license
- * Copyright 2022-2026 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-var Val;
-((Val2) => {
-  Val2.properties = /* @__PURE__ */ Symbol("properties");
-})(Val || (Val = {}));
-//# sourceMappingURL=Val.js.map

package/dist/cjs/action/Val.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/action/Val.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,IAAU;AAAA,CAAV,CAAUA,SAAV;AAiCI,EAAMA,KAAA,aAAa,uBAAO,YAAY;AAAA,GAjChC;",
-  "names": ["Val"]
-}