@matter/node 0.17.9 → 0.18.0-alpha.0-20260812-4d7f2790e

package/src/behavior/cluster/ClusterBehaviorType.ts

@@ -5,20 +5,25 @@
  */
 
 import { Events, OfflineEvent, OnlineEvent, QuietEvent } from "#behavior/Events.js";
-import { AsyncObservable, camelize, EventEmitter, GeneratedClass, ImplementationError } from "@matter/general";
+import {
+    AsyncObservable,
+    camelize,
+    describeList,
+    EventEmitter,
+    GeneratedClass,
+    ImplementationError,
+} from "@matter/general";
 import {
     ClassSemantics,
     ClusterModel,
     CommandModel,
-    DecodedBitmap,
-    DefaultValue,
     ElementTag,
     FeatureMap,
     FeatureSet,
     Matter,
-    Metatype,
     Schema,
     Scope,
+    SelectDefaultValue,
     ValueModel,
 } from "@matter/model";
 import { Val } from "@matter/protocol";
@@ -72,15 +77,21 @@ export function ClusterBehaviorType({
         schema = syncFeatures(schema, namespace);
     }
 
+    // A feature the specification mandates without condition is not a selection.  We support it in our own
+    // implementations; for a peer we defer to the features it reports
+    if (!forClient) {
+        schema = selectUnconditionalFeatures(schema);
+    }
+
     // Construct namespace from schema if not provided
     if (!namespace) {
         namespace = ClusterType(schema);
     }
 
-    const useCache = name === undefined;
+    const useCache = name === undefined && commandFactory === undefined;
 
     if (useCache) {
-        const cached = ClusterBehaviorCache.get(base, schema, forClient);
+        const cached = ClusterBehaviorCache.get(base, schema, namespace, forClient);
         if (cached) {
             return cached;
         }
@@ -146,7 +157,7 @@ export function ClusterBehaviorType({
     schema.finalize();
 
     if (useCache) {
-        ClusterBehaviorCache.set(base, schema, type);
+        ClusterBehaviorCache.set(base, schema, namespace, type, forClient);
     }
 
     return type as ClusterBehavior.Type;
@@ -304,11 +315,8 @@ function createDerivedState({ scope, base, newProps }: DerivationContext) {
 
         // Make sure a default value is present if mandatory or marked as supported (note that the default value may
         // be "undefined" to indicate that an attribute is available optionally)
-        defaults[name] = selectDefaultValue(
-            scope,
-            oldDefaults[name] === undefined ? knownDefaults?.[name] : oldDefaults[name],
-            propSchema,
-        );
+        const oldDefault = oldDefaults[name] === undefined ? knownDefaults?.[name] : oldDefaults[name];
+        defaults[name] = oldDefault === undefined ? SelectDefaultValue(scope, propSchema) : oldDefault;
     }
 
     const StateType = DerivedState({
@@ -419,77 +427,66 @@ function schemaForId(id: number) {
  * We cache schema for clusters configured for certain features.  This in turn enables the RootSupervisor cache which
  * keys off of the schema.
  */
-const configuredSchemaCache = new Map<Schema.Cluster, Record<string, Schema.Cluster>>();
+const configuredSchemaCache = new WeakMap<Schema.Cluster, Record<string, Schema.Cluster>>();
+
+/**
+ * Schema that differ from another only by feature selection cache against that schema, so a selection reapplied to a
+ * variant converges on the original object rather than minting a third.
+ */
+const featureVariantOrigin = new WeakMap<Schema.Cluster, Schema.Cluster>();
 
 /**
  * Ensure the supported features enumerated by schema align with a namespace's feature selection.
  */
 function syncFeatures(schema: Schema.Cluster, namespace: object | undefined) {
-    // Determine features from namespace's supportedFeatures or schema
-    let incomingFeatures: FeatureSet;
-
     const nsSupportedFeatures = (namespace as { supportedFeatures?: Record<string, boolean> } | undefined)
         ?.supportedFeatures;
-    if (nsSupportedFeatures) {
-        incomingFeatures = new FeatureSet(nsSupportedFeatures);
-    } else {
-        // No feature override — use schema's defaults
+    if (nsSupportedFeatures === undefined) {
         return schema;
     }
 
-    if (incomingFeatures.is(schema.supportedFeatures)) {
-        return schema;
-    }
+    return syncFeaturesFromSet(schema, featureSetFor(schema, new FeatureSet(nsSupportedFeatures)));
+}
 
-    // If we have cached this version of the cluster, return the cached schema
-    const featureKey = [...incomingFeatures].sort().join(",");
-    let schemaBucket = configuredSchemaCache.get(schema);
-    if (schemaBucket === undefined) {
-        schemaBucket = {};
-        configuredSchemaCache.set(schema, schemaBucket);
-    } else {
-        if (featureKey in schemaBucket) {
-            return schemaBucket[featureKey];
-        }
-    }
+/**
+ * Apply a feature selection to a schema.  If `features` is `true`, all elements are included regardless of
+ * conformance ("complete" mode).
+ */
+function applyFeatureSelection(schema: Schema.Cluster, features: readonly string[] | true): Schema.Cluster {
+    const names = features === true ? (schema as ClusterModel).features.map(feature => feature.name) : features;
 
-    // New schema
-    schema = schema.clone();
-    schema.supportedFeatures = incomingFeatures;
+    return syncFeaturesFromSet(schema, featureSetFor(schema, names));
+}
 
-    // Cache
-    schemaBucket[featureKey] = schema;
+/**
+ * Map feature names to a schema's FeatureSet short codes.
+ */
+function featureSetFor(schema: Schema.Cluster, names: Iterable<string>) {
+    const model = schema as ClusterModel;
+    const { features } = model;
+    const { features: resolved, unresolved } = FeatureSet.resolve(features, names);
 
-    return schema;
+    if (unresolved.length) {
+        throw new ImplementationError(
+            `${model.name} has no feature ${describeList("and", ...unresolved.map(name => `"${name}"`))}; known features are ${FeatureSet.titlesOf(features).join(", ")}`,
+        );
+    }
+
+    return resolved;
 }
 
 /**
- * Apply a feature selection to a schema.  If `features` is `true`, all elements are included regardless of
- * conformance ("complete" mode).  Otherwise, maps feature names to the schema's FeatureSet short codes.
+ * Ensure features the specification mandates without condition are selected.
  */
-function applyFeatureSelection(schema: Schema.Cluster, features: readonly string[] | true): Schema.Cluster {
-    if (features === true) {
-        // "Complete" mode — clone schema and mark all features as supported
-        const featureSet = new FeatureSet();
-        for (const feature of (schema as ClusterModel).features) {
-            featureSet.add(feature.name);
-        }
-        return syncFeaturesFromSet(schema, featureSet);
+function selectUnconditionalFeatures(schema: Schema.Cluster) {
+    const unconditional = (schema as ClusterModel).unconditionalFeatures;
+    if (!unconditional.size) {
+        return schema;
     }
 
-    // Map user-facing feature names to schema short codes
-    const featureSet = new FeatureSet();
-    const model = schema as ClusterModel;
-    for (const name of features) {
-        for (const feature of model.features) {
-            if ((feature.title ?? feature.name) === name || feature.name === name) {
-                featureSet.add(feature.name);
-                break;
-            }
-        }
-    }
+    const selection = new FeatureSet([...schema.supportedFeatures, ...unconditional]);
 
-    return syncFeaturesFromSet(schema, featureSet);
+    return syncFeaturesFromSet(schema, selection);
 }
 
 /**
@@ -500,20 +497,26 @@ function syncFeaturesFromSet(schema: Schema.Cluster, featureSet: FeatureSet): Sc
         return schema;
     }
 
+    const origin = featureVariantOrigin.get(schema) ?? schema;
+    if (featureSet.is(origin.supportedFeatures)) {
+        return origin;
+    }
+
     const featureKey = [...featureSet].sort().join(",");
-    let schemaBucket = configuredSchemaCache.get(schema);
+    let schemaBucket = configuredSchemaCache.get(origin);
     if (schemaBucket === undefined) {
         schemaBucket = {};
-        configuredSchemaCache.set(schema, schemaBucket);
+        configuredSchemaCache.set(origin, schemaBucket);
     } else if (featureKey in schemaBucket) {
         return schemaBucket[featureKey];
     }
 
-    schema = schema.clone();
-    schema.supportedFeatures = featureSet;
-    schemaBucket[featureKey] = schema;
+    const variant = origin.clone();
+    variant.supportedFeatures = featureSet;
+    schemaBucket[featureKey] = variant;
+    featureVariantOrigin.set(variant, origin);
 
-    return schema;
+    return variant;
 }
 
 /**
@@ -521,9 +524,10 @@ function syncFeaturesFromSet(schema: Schema.Cluster, featureSet: FeatureSet): Sc
  */
 function computeFeatureFlags(schema: ClusterModel): Record<string, boolean> {
     const flags: Record<string, boolean> = {};
+    const supported = schema.supportedFeatures;
     for (const child of schema.featureMap.children) {
         const key = camelize(child.title ?? child.name);
-        flags[key] = schema.supportedFeatures.has(child.name);
+        flags[key] = supported.has(child.name);
     }
     return flags;
 }
@@ -589,49 +593,6 @@ function createDefaultCommandDescriptors({ scope, base, commandFactory }: Deriva
     return result;
 }
 
-function selectDefaultValue(scope: Scope, oldDefault: Val, member: ValueModel) {
-    if (oldDefault !== undefined) {
-        return oldDefault;
-    }
-
-    // No default unless mandatory or explicitly marked as implemented
-    if (!scope.hasOperationalSupport(member)) {
-        return;
-    }
-
-    // If there's an explicit default, use that
-    const effectiveDefault = DefaultValue(scope, member);
-    if (effectiveDefault !== undefined) {
-        if (member.effectiveMetatype === "bitmap") {
-            return DecodedBitmap(member, effectiveDefault);
-        }
-        return effectiveDefault;
-    }
-
-    // Default for nullable is null
-    if (member.nullable) {
-        return null;
-    }
-
-    switch (member.effectiveMetatype) {
-        case Metatype.integer:
-        case Metatype.float:
-            return 0;
-
-        case Metatype.boolean:
-            return false;
-
-        case Metatype.bitmap:
-        case Metatype.object:
-            // This is not a very good default but it is better than undefined
-            return {};
-
-        case Metatype.array:
-            // Same
-            return [];
-    }
-}
-
 /**
  * Create a descriptor that lazily creates the {@link Observable} on the "Events" class.
  */

package/src/behavior/cluster/ValidatedElements.ts

@@ -5,7 +5,7 @@
  */
 
 import { Diagnostic, ImplementationError, Logger, MatterAggregateError, Observable } from "@matter/general";
-import { ClusterModel, Conformance, Schema } from "@matter/model";
+import { ClusterModel, Conformance, FeatureSelectionErrors, Schema } from "@matter/model";
 import type { ClusterType } from "@matter/types";
 import { Behavior } from "../Behavior.js";
 import { introspectionInstanceOf } from "./cluster-behavior-utils.js";
@@ -15,6 +15,11 @@ import { NameDependentElements } from "./NameDependentElements.js";
 
 const logger = Logger.get("ValidatedElements");
 
+/**
+ * Schema whose feature selection we have already assessed.
+ */
+const validatedFeatureSelections = new WeakSet<ClusterModel>();
+
 /**
  * Thrown when a {@link ClusterBehavior} cannot be constructed due to fatal errors.
  */
@@ -121,6 +126,7 @@ export class ValidatedElements {
             this.error("instance", "Is not an object", true);
         }
 
+        this.#validateFeatures();
         this.#validateAttributes();
         this.#validateCommands();
         this.#validateEvents();
@@ -158,6 +164,25 @@ export class ValidatedElements {
         }
     }
 
+    /**
+     * Feature selection is a property of the schema, so assess each schema once however many behaviors share it.
+     */
+    #validateFeatures() {
+        if (validatedFeatureSelections.has(this.#schema)) {
+            return;
+        }
+
+        const errors = FeatureSelectionErrors(this.#schema);
+        if (errors.length) {
+            for (const error of errors) {
+                this.error("features", error, true);
+            }
+            return;
+        }
+
+        validatedFeatureSelections.add(this.#schema);
+    }
+
     #validateAttributes() {
         let state;
 

package/src/behavior/context/server/RemoteActorContext.ts

@@ -183,7 +183,6 @@ export function RemoteActorContext(options: RemoteActorContext.Options) {
             }
 
             const notifyInteractionComplete = () => {
-                exchange.closing.off(notifyInteractionComplete);
                 exchangeCompleteEvents.delete(exchange);
                 function handleErr(err: unknown) {
                     logger.warn("interactionComplete observer failed", Diagnostic.error(err));
@@ -199,7 +198,7 @@ export function RemoteActorContext(options: RemoteActorContext.Options) {
                     }
                 }
             };
-            exchange.closing.on(notifyInteractionComplete);
+            exchange.closing.once(notifyInteractionComplete);
         }
         const context: RemoteActorContext & T = {
             ...options,

package/src/behavior/state/managed/Datasource.ts

@@ -28,6 +28,28 @@ const logger = Logger.get("Datasource");
 
 const FEATURES_KEY = "__features__";
 
+/**
+ * Whether key is a member id, in the only spelling under which id keys are produced (canonical decimal, as emitted
+ * by memberKeyFor for members that define an id, persistentKeys and externalSet).
+ */
+function isIdKey(key: string) {
+    return /^(0|[1-9]\d*)$/.test(key);
+}
+
+/**
+ * Remove a state instance's schema-member value slots, keeping non-member helper fields (e.g. backing data for a
+ * Val.properties implementation).  The constructor must run — skipping it via Object.create would leave
+ * private-field brands uninstalled — so field initializers execute and the member slots are stripped afterwards.
+ */
+function stripMemberValues(values: Val.Struct, members: Set<string>) {
+    for (const key of Object.keys(values)) {
+        if (members.has(key)) {
+            delete values[key];
+        }
+    }
+    return values;
+}
+
 // Once-per-act() guard for local sessions (frozen — can't set interactionStarted on the session).
 const localInteractionBeginEmitted = new WeakSet<object>();
 
@@ -272,7 +294,6 @@ class DatasourceImpl implements Datasource, Datasource.ExternallyMutableStore.Co
     location;
     entropy;
     store?: Datasource.Store | Datasource.ExternallyMutableStore;
-    defaults?: Val.Struct;
     owner?: any;
     onChange?: (attrs: string[]) => MaybePromise<void>;
 
@@ -302,14 +323,17 @@ class DatasourceImpl implements Datasource, Datasource.ExternallyMutableStore.Co
         this.location = options.location;
         this.entropy = options.entropy;
         this.store = options.store;
-        this.defaults = options.defaults;
         this.owner = options.owner;
         this.onChange = options.onChange;
         this.primaryKey = options.primaryKey === "id" ? "id" : "name";
         this.events = options.events ?? {};
 
-        // Initialize values
+        // Initialize values.  An id-keyed datasource mirrors a peer, whose reports are the only source of values:
+        // the state class's name-keyed field initializers must not survive, or they masquerade as reported data
         const values = new options.type() as Val.Struct;
+        if (this.primaryKey === "id") {
+            stripMemberValues(values, options.supervisor.memberNames);
+        }
 
         let storedValues = options.store?.initialValues;
 
@@ -328,8 +352,57 @@ class DatasourceImpl implements Datasource, Datasource.ExternallyMutableStore.Co
             }
         }
 
+        let defaults = options.defaults;
+        if (this.primaryKey === "id") {
+            if (defaults !== undefined) {
+                // Only explicitly id-keyed defaults may seed a mirror (see PrimaryKey)
+                const kept = {} as Val.Struct;
+                const dropped = new Array<string>();
+                for (const key in defaults) {
+                    if (isIdKey(key)) {
+                        kept[key] = defaults[key];
+                    } else {
+                        dropped.push(key);
+                    }
+                }
+                if (dropped.length) {
+                    logger.warn(
+                        `Ignoring configured defaults [${dropped.join(", ")}] for ${options.location.path} because a peer's reports are the only source of values`,
+                    );
+                    defaults = kept;
+                }
+            }
+
+            if (storedValues !== undefined) {
+                // A store persisted before mirrors were id-keyed may hold peer data under property names; migrate it
+                // to the canonical id slot so it stays readable (idempotent — the store itself is not rewritten)
+                const ids = options.supervisor.propertyNamesAndIds;
+                let migrated: Val.Struct | undefined;
+                for (const key in storedValues) {
+                    const id = ids.get(key);
+                    if (id === undefined) {
+                        continue;
+                    }
+                    migrated ??= { ...storedValues };
+                    if (id in migrated) {
+                        // The store itself is never rewritten, so this repeats every load — not warn-worthy
+                        logger.debug(
+                            `Discarding legacy value stored at "${key}" for ${options.location.path} because a newer value exists at its id`,
+                        );
+                    } else {
+                        logger.debug(`Migrated stored value "${key}" to id ${id} for ${options.location.path}`);
+                        migrated[id] = migrated[key];
+                    }
+                    delete migrated[key];
+                }
+                if (migrated) {
+                    storedValues = migrated;
+                }
+            }
+        }
+
         const initialValues = {
-            ...options.defaults,
+            ...defaults,
             ...storedValues,
         };
 
@@ -735,16 +808,26 @@ class RootReference implements ValReference<Val.Struct>, Transaction.Participant
         // Clone values if we haven't already
         if (this.#values === this.#internals.values) {
             const old = this.#values;
-            this.#values = new this.#internals.type();
+
+            let keys: Iterable<string>;
+            if (this.primaryKey === "id") {
+                // A mirror's clone must not resurrect the state class's name-keyed field initializers — the peer's
+                // reports are the only source of values
+                this.#values = stripMemberValues(new this.#internals.type() as Val.Struct, this.#fields);
+                keys = Object.keys(old);
+            } else {
+                this.#values = new this.#internals.type();
+                const keySet = new Set<string>(this.#fields);
+                for (const key of Object.keys(old)) {
+                    keySet.add(key);
+                }
+                keys = keySet;
+            }
 
             const properties = (this.#values as Val.Dynamic)[Val.properties]
                 ? (this.#values as Val.Dynamic)[Val.properties](this.rootOwner, this.#session)
                 : undefined;
-            // `#fields` only lists property names; client mirrors also store values at numeric attribute ids.
-            const keys = new Set<string>(this.#fields);
-            for (const key of Object.keys(old)) {
-                keys.add(key);
-            }
+
             for (const key of keys) {
                 if (properties && key in properties) {
                     // Property is dynamic anyway, so do nothing

package/src/behavior/state/managed/ManagedReference.ts

@@ -6,7 +6,13 @@
 
 import { AccessControl, ExpiredReferenceError, Val } from "@matter/protocol";
 import type { Supervision } from "../../supervision/Supervision.js";
-import { memberFallbackKeyFor, memberKeyFor, memberValueOf } from "./MemberKeys.js";
+import {
+    memberFallbackKeyFor,
+    memberKeyFor,
+    memberReadFallbackKeyFor,
+    memberSlotOf,
+    memberValueOf,
+} from "./MemberKeys.js";
 import type { ValReference } from "./ValReference.js";
 
 type Container = Record<string | number, Val>;
@@ -38,6 +44,7 @@ export class ManagedReference implements ValReference {
 
     #key: string | number;
     #fallbackKey: string | number | undefined;
+    #readFallbackKey: string | number | undefined;
     #assertWriteOk: (value: Val) => void;
     #clone: ((container: Val) => Val) | undefined;
     #session: AccessControl.Session;
@@ -74,16 +81,19 @@ export class ManagedReference implements ValReference {
 
         const key = memberKeyFor(parent.primaryKey, name, id);
         const fallbackKey = memberFallbackKeyFor(parent.primaryKey, name, id);
+        const readFallbackKey = memberReadFallbackKeyFor(parent.primaryKey, name, id);
         this.#key = key;
         this.#fallbackKey = fallbackKey;
+        this.#readFallbackKey = readFallbackKey;
 
         let dynamicContainer: Val.Struct | undefined;
         if ((parent.value as Val.Dynamic)[Val.properties]) {
             dynamicContainer = (parent.value as Val.Dynamic)[Val.properties](parent.rootOwner, session);
-            if (key in (dynamicContainer as Container)) {
-                this.#value = (dynamicContainer as Container)[key];
-            } else if (fallbackKey !== undefined && fallbackKey in (dynamicContainer as Container)) {
-                this.#value = (dynamicContainer as Container)[fallbackKey];
+            // A provider is name-keyed regardless of the parent's keying and holds live values, never seeded
+            // defaults, so dynamic reads accept the name spelling where container reads must not
+            const slot = memberSlotOf(dynamicContainer as Container, key, fallbackKey);
+            if (slot !== undefined) {
+                this.#value = (dynamicContainer as Container)[slot];
             } else {
                 dynamicContainer = undefined;
             }
@@ -91,7 +101,7 @@ export class ManagedReference implements ValReference {
         this.#dynamicContainer = dynamicContainer;
 
         if (dynamicContainer === undefined) {
-            this.#value = memberValueOf(parent.value as Container, key, fallbackKey);
+            this.#value = memberValueOf(parent.value as Container, key, readFallbackKey);
         }
 
         // Propagate supervision config from parent
@@ -155,7 +165,7 @@ export class ManagedReference implements ValReference {
             );
             return memberValueOf(origProperties as Container, this.#key, this.#fallbackKey);
         }
-        return memberValueOf(this.parent!.original as Container, this.#key, this.#fallbackKey);
+        return memberValueOf(this.parent!.original as Container, this.#key, this.#readFallbackKey);
     }
 
     change(mutator: () => void) {
@@ -190,7 +200,7 @@ export class ManagedReference implements ValReference {
         const value =
             this.#dynamicContainer !== undefined
                 ? memberValueOf(this.#dynamicContainer as Container, this.#key, this.#fallbackKey)
-                : memberValueOf(this.parent!.value as Container, this.#key, this.#fallbackKey);
+                : memberValueOf(this.parent!.value as Container, this.#key, this.#readFallbackKey);
 
         this.#replaceValue(value);
     }

package/src/behavior/state/managed/MemberKeys.ts

@@ -11,7 +11,8 @@ import type { ValReference } from "./ValReference.js";
  * The slot a member occupies in a container keyed by {@link ValReference.primaryKey}.
  *
  * The persisted key set ({@link RootSupervisor.persistentKeys}) and a datasource container's own keys must both
- * derive from this function — if they diverge, attributes silently stop persisting.
+ * derive from this function — if they diverge, attributes silently stop persisting.  Callers must also agree on the
+ * id source: persistentKeys passes effectiveId where container writers pass id, equal for cluster attributes.
  */
 export function memberKeyFor(
     primaryKey: ValReference.PrimaryKey,
@@ -22,8 +23,8 @@ export function memberKeyFor(
 }
 
 /**
- * The key under the other keying convention, if distinct from {@link memberKeyFor}'s — whether a reader may fall
- * back to it is the reader's policy.
+ * The key under the other keying convention, if distinct from {@link memberKeyFor}'s.  For write migration and for
+ * reading name-keyed dynamic providers — a container reader uses {@link memberReadFallbackKeyFor}.
  */
 export function memberFallbackKeyFor(
     primaryKey: ValReference.PrimaryKey,
@@ -35,21 +36,47 @@ export function memberFallbackKeyFor(
 }
 
 /**
- * Read a member from container at key, falling back to fallbackKey; a caller passes `undefined` for fallbackKey
- * when it must not tolerate the fallback slot.
+ * The fallback slot a read may accept: a value decoded without a schema keys its members by TLV tag number, so a
+ * name-keyed container's reader accepts the element ID too. For an id-keyed container this is `undefined` — its
+ * name slot never holds peer data (see {@link ValReference.PrimaryKey}), only residue such as a legacy store's
+ * seeded default or an explicit `undefined` from attribute pruning.
  */
-export function memberValueOf(
+export function memberReadFallbackKeyFor(
+    primaryKey: ValReference.PrimaryKey,
+    name: string | number,
+    id: number | undefined,
+): string | number | undefined {
+    return primaryKey === "name" ? memberFallbackKeyFor(primaryKey, name, id) : undefined;
+}
+
+/**
+ * The slot a member currently occupies in container — key, fallbackKey if present there instead, else undefined.
+ */
+export function memberSlotOf(
     container: Val.Struct,
     key: string | number,
     fallbackKey: string | number | undefined,
-): Val | undefined {
+): string | number | undefined {
     if (key in container) {
-        return container[key];
+        return key;
     }
 
     if (fallbackKey !== undefined && fallbackKey in container) {
-        return container[fallbackKey];
+        return fallbackKey;
     }
 
     return undefined;
 }
+
+/**
+ * Read a member from container at key, falling back to fallbackKey; a caller passes `undefined` for fallbackKey
+ * when it must not tolerate the fallback slot.
+ */
+export function memberValueOf(
+    container: Val.Struct,
+    key: string | number,
+    fallbackKey: string | number | undefined,
+): Val | undefined {
+    const slot = memberSlotOf(container, key, fallbackKey);
+    return slot === undefined ? undefined : container[slot];
+}

package/src/behavior/state/managed/NameResolver.ts

@@ -60,7 +60,10 @@ export function NameResolver(
 
     /**
      * Read a property by name, preferring the id-keyed slot when available — client mirrors
-     * (`primaryKey: "id"`) hold live values at attribute ids while the property-name slot may be a stale default.
+     * (`primaryKey: "id"`) hold live values at attribute ids.
+     *
+     * The name-slot fallback must stay: the same resolver serves name-keyed containers, where the value
+     * legitimately lives at the property name.
      */
     function createDirectResolver(id?: number) {
         if (id === undefined) {