@matter/model 0.16.1 → 0.16.2-alpha.0-20260114-d3127faee

package/src/decoration/decorators/response.ts

@@ -4,31 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { FieldSemantics } from "#decoration/semantics/FieldSemantics.js";
-import { CommandElement } from "#elements/CommandElement.js";
 import { Decorator } from "#general";
-import { CommandModel } from "#models/CommandModel.js";
-import { DatatypeModel } from "#models/DatatypeModel.js";
+import { element } from "./element.js";
 
 /**
  * Specify the response type for a command.
  */
-export function response(type: DatatypeModel): Decorator.ClassMethod {
-    return Decorator((_target, context) => {
-        const requestSemantics = FieldSemantics.of(context);
-
-        requestSemantics.modelType = CommandModel;
-        const request = requestSemantics.mutableModel as CommandModel;
-
-        const name = `${request.name}Response`;
-        new CommandModel({
-            name,
-            id: request.id,
-            parent: request.parent,
-            direction: CommandElement.Direction.Response,
-            operationalBase: type,
-        });
-
-        request.response = name;
-    });
+export function response(...modifiers: element.Modifier<Decorator.MethodCollector>[]) {
+    return element({ Tag: "response" }, ...modifiers);
 }

package/src/decoration/semantics/ClassSemantics.ts

@@ -291,15 +291,15 @@ export class ClassSemantics extends Semantics {
         // Invoke any custom extension logic
         this.#new?.[ClassSemantics.extend]?.(this);
 
-        // Apply base finalization
-        super.finalize();
-
         // Finalize fields
         if (this.#definedFields) {
             for (const field of this.#definedFields.values()) {
                 field.finalize();
             }
         }
+
+        // Apply base finalization
+        super.finalize();
     }
 
     #applyBaseSemantics() {
@@ -355,6 +355,10 @@ export class ClassSemantics extends Semantics {
         }
         return new type({ name, operationalBase: struct });
     }
+
+    get owner() {
+        return this;
+    }
 }
 
 export namespace ClassSemantics {

package/src/decoration/semantics/FieldSemantics.ts

@@ -15,12 +15,23 @@ import { Semantics } from "./Semantics.js";
  * Decorator metadata associated with a specific class field.
  */
 export class FieldSemantics extends Semantics {
+    #owner: ClassSemantics;
+
     constructor(owner: ClassSemantics, name: string) {
         super();
+        this.#owner = owner;
 
         this.mutableModel = new FieldModel({ name, parent: owner.mutableModel });
     }
 
+    get owner() {
+        return this.#owner;
+    }
+
+    get semanticModel() {
+        return this.localModel;
+    }
+
     protected override createModel(): Model {
         // We create our model unconditionally so this shouldn't happen
         throw new InternalError("Unexpected FieldSemantics.createModel");

package/src/decoration/semantics/Semantics.ts

@@ -6,9 +6,11 @@
 
 import { MetadataConflictError } from "#decoration/errors.js";
 import { InternalError } from "#general";
+import { CommandModel } from "#models/CommandModel.js";
 import type { Model } from "#models/Model.js";
 import * as models from "#standard/elements/models.js";
 import type { ClassSemantics } from "./ClassSemantics.js";
+import type { FieldSemantics } from "./FieldSemantics.js";
 
 const standardModels = new Set(Object.values(models) as Model[]);
 
@@ -22,6 +24,8 @@ export abstract class Semantics {
     #localModel?: Model;
     #isFinal = false;
 
+    response?: FieldSemantics;
+
     /**
      * Determine whether these semantics are final.
      *
@@ -39,6 +43,19 @@ export abstract class Semantics {
             return;
         }
 
+        if (this.response && this.semanticModel instanceof CommandModel) {
+            this.response.finalize();
+
+            const response = this.response.localModel;
+            if (response) {
+                if (response.id === undefined) {
+                    // Default response ID is request ID
+                    response.id = this.semanticModel.id;
+                }
+                (this.mutableModel as CommandModel).operationalResponse = this.response.localModel as CommandModel;
+            }
+        }
+
         this.#isFinal = true;
         Object.freeze(this);
         this.#localModel?.finalize();
@@ -144,6 +161,8 @@ export abstract class Semantics {
         this.#localModel = replacement;
     }
 
+    abstract owner: ClassSemantics;
+    abstract semanticModel?: Model;
     protected abstract createModel(type?: Model.ConcreteType): Model;
 }
 

package/src/models/CommandModel.ts

@@ -14,6 +14,8 @@ export class CommandModel extends ValueModel<CommandElement> implements CommandE
     direction?: CommandElement.Direction;
     response?: string;
 
+    operationalResponse?: CommandModel | null;
+
     get fabricScoped() {
         return !!this.effectiveAccess.fabric;
     }
@@ -26,8 +28,21 @@ export class CommandModel extends ValueModel<CommandElement> implements CommandE
         return this.effectiveDirection === CommandElement.Direction.Response;
     }
 
+    set isResponse(isResponse: boolean) {
+        this.direction = isResponse ? CommandElement.Direction.Response : CommandElement.Direction.Request;
+    }
+
     get responseModel() {
-        return new ModelTraversal().findResponse(this);
+        switch (this.operationalResponse) {
+            case undefined:
+                return new ModelTraversal().findResponse(this);
+
+            case null:
+                return undefined;
+
+            default:
+                return this.operationalResponse;
+        }
     }
 
     get effectiveDirection() {
@@ -55,11 +70,12 @@ export class CommandModel extends ValueModel<CommandElement> implements CommandE
         return this.direction;
     }
 
-    constructor(definition: Model.Definition<CommandModel>, ...children: Model.ChildDefinition<CommandModel>[]) {
+    constructor(definition: CommandModel.Definition, ...children: Model.ChildDefinition<CommandModel>[]) {
         super(definition, ...children);
 
         this.direction = definition.direction as CommandElement.Direction;
         this.response = definition.response;
+        this.operationalResponse = definition.operationalResponse;
     }
 
     override toElement(omitResources = false, extra?: Record<string, unknown>) {
@@ -70,8 +86,23 @@ export class CommandModel extends ValueModel<CommandElement> implements CommandE
         });
     }
 
+    override finalize() {
+        if (this.isFinal) {
+            return;
+        }
+
+        const operationalResponse = this.operationalResponse ?? (this.operationalResponse = this.responseModel ?? null);
+        operationalResponse?.finalize();
+
+        super.finalize();
+    }
+
     static Tag = CommandElement.Tag;
     static requiresId = true;
 }
 
+export namespace CommandModel {
+    export type Definition = Model.Definition<CommandModel> & { operationalResponse?: CommandModel };
+}
+
 CommandModel.register();