@adaas/are 0.0.2 → 0.0.3

package/dist/node/lib/AreInstruction/AreInstruction.types.d.mts

@@ -0,0 +1,14 @@
+import '@adaas/a-concept';
+export { d as AreInstructionNewProps, e as AreInstructionSerialized } from '../../Are.context-D7w32H1G.mjs';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.mjs';
+import '../AreStore/AreStore.constants.mjs';
+import '../AreScene/AreScene.constants.mjs';
+import '../AreAttribute/AreAttribute.types.mjs';
+import '../AreAttribute/AreAttribute.constants.mjs';
+import '../AreComponent/Are.component.mjs';
+import '../AreComponent/Are.types.mjs';
+import '../AreComponent/Are.constants.mjs';
+import '../AreNode/AreNode.constants.mjs';

package/dist/node/lib/AreInstruction/AreInstruction.types.d.ts

@@ -0,0 +1,14 @@
+import '@adaas/a-concept';
+export { d as AreInstructionNewProps, e as AreInstructionSerialized } from '../../Are.context-9Ija_fdC.js';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.js';
+import '../AreStore/AreStore.constants.js';
+import '../AreScene/AreScene.constants.js';
+import '../AreAttribute/AreAttribute.types.js';
+import '../AreAttribute/AreAttribute.constants.js';
+import '../AreComponent/Are.component.js';
+import '../AreComponent/Are.types.js';
+import '../AreComponent/Are.constants.js';
+import '../AreNode/AreNode.constants.js';

package/dist/node/lib/AreInstruction/AreInstruction.types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=AreInstruction.types.js.map
+//# sourceMappingURL=AreInstruction.types.js.map

package/dist/node/lib/AreInstruction/AreInstruction.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"AreInstruction.types.js"}

package/dist/node/lib/AreInstruction/AreInstruction.types.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=AreInstruction.types.mjs.map
+//# sourceMappingURL=AreInstruction.types.mjs.map

package/dist/node/lib/AreInstruction/AreInstruction.types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"AreInstruction.types.mjs"}

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.d.mts

@@ -0,0 +1,14 @@
+export { b as AreDeclaration } from '../../../Are.context-D7w32H1G.mjs';
+import '@adaas/a-concept';
+import '@adaas/a-utils/a-signal';
+import '../../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../../AreStore/AreStore.types.mjs';
+import '../../AreStore/AreStore.constants.mjs';
+import '../../AreScene/AreScene.constants.mjs';
+import '../../AreAttribute/AreAttribute.types.mjs';
+import '../../AreAttribute/AreAttribute.constants.mjs';
+import '../../AreComponent/Are.component.mjs';
+import '../../AreComponent/Are.types.mjs';
+import '../../AreComponent/Are.constants.mjs';
+import '../../AreNode/AreNode.constants.mjs';

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.d.ts

@@ -0,0 +1,14 @@
+export { b as AreDeclaration } from '../../../Are.context-9Ija_fdC.js';
+import '@adaas/a-concept';
+import '@adaas/a-utils/a-signal';
+import '../../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../../AreStore/AreStore.types.js';
+import '../../AreStore/AreStore.constants.js';
+import '../../AreScene/AreScene.constants.js';
+import '../../AreAttribute/AreAttribute.types.js';
+import '../../AreAttribute/AreAttribute.constants.js';
+import '../../AreComponent/Are.component.js';
+import '../../AreComponent/Are.types.js';
+import '../../AreComponent/Are.constants.js';
+import '../../AreNode/AreNode.constants.js';

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var aFrame = require('@adaas/a-frame');
+var AreInstruction_entity = require('@adaas/are/instruction/AreInstruction.entity');
+var AreInstruction_constants = require('@adaas/are/instruction/AreInstruction.constants');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+exports.AreDeclaration = class AreDeclaration extends AreInstruction_entity.AreInstruction {
+  constructor(param1, param2, param3) {
+    if (typeof param1 === "object" && "aseid" in param1)
+      super(param1);
+    else
+      super({
+        name: param1 || AreInstruction_constants.AreInstructionDefaultNames.Default,
+        parent: param2 instanceof exports.AreDeclaration ? param2 : void 0,
+        group: param2 instanceof exports.AreDeclaration ? param2.group : void 0,
+        payload: param2 instanceof exports.AreDeclaration ? param3 || {} : param2 || {}
+        // id: [param1, A_IdentityHelper.generateTimeId(), param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T]
+      });
+  }
+};
+exports.AreDeclaration = __decorateClass([
+  aFrame.A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreDeclaration",
+    description: "AreDeclaration is a top-level rendering instruction that represents the creation of a new element in the ARE scene. It carries the target tag name and parent reference needed by the Host to construct the DOM element, and can be applied or reverted to manage element creation and removal deterministically."
+  })
+], exports.AreDeclaration);
+//# sourceMappingURL=AreDeclaration.instruction.js.map
+//# sourceMappingURL=AreDeclaration.instruction.js.map

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/AreInstruction/types/AreDeclaration.instruction.ts"],"names":["AreDeclaration","AreInstruction","AreInstructionDefaultNames","A_Frame"],"mappings":";;;;;;;;;;;;;;AAeaA,sBAAA,GAAN,6BAGGC,oCAAA,CAAqB;AAAA,EAgC3B,WAAA,CAII,MAAA,EAIA,MAAA,EAIA,MAAA,EACF;AACE,IAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,OAAA,IAAW,MAAA;AACzC,MAAA,KAAA,CAAM,MAAM,CAAA;AAAA;AAEZ,MAAA,KAAA,CAAM;AAAA,QACF,IAAA,EAAM,UAAUC,mDAAA,CAA2B,OAAA;AAAA,QAC3C,MAAA,EAAQ,MAAA,YAAkBF,sBAAA,GAAiB,MAAA,GAAS,MAAA;AAAA,QACpD,KAAA,EAAO,MAAA,YAAkBA,sBAAA,GAAiB,MAAA,CAAO,KAAA,GAAQ,MAAA;AAAA,QACzD,SAAS,MAAA,YAAkBA,sBAAA,GAAkB,UAAU,EAAC,GAAW,UAAU;AAAC;AAAA,OAEpD,CAAA;AAAA,EACtC;AAEJ;AA7DaA,sBAAA,GAAN,eAAA,CAAA;AAAA,EALNG,eAAQ,MAAA,CAAO;AAAA,IACZ,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,gBAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACYH,sBAAA,CAAA","file":"AreDeclaration.instruction.js","sourcesContent":["import { A_IdentityHelper } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"@adaas/are/instruction/AreInstruction.types\";\nimport { AreInstructionDefaultNames } from \"@adaas/are/instruction/AreInstruction.constants\";\n\n\n/**\n * This is a top-level instruction that represents the creation of a new element in the scene. It contains all the necessary information to create a new element, such as its tag and parent. This instruction can be applied to the scene to create a new element and can be reverted to remove the created element.\n */\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreDeclaration',\n    description: 'AreDeclaration is a top-level rendering instruction that represents the creation of a new element in the ARE scene. It carries the target tag name and parent reference needed by the Host to construct the DOM element, and can be applied or reverted to manage element creation and removal deterministically.'\n})\nexport class AreDeclaration<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends AreInstruction<T, S> {\n\n    constructor(\n        /**\n         * Serialized form of the instruction, used for deserialization and reconstruction of the instruction instance. This allows for the instruction to be easily stored, transmitted, and recreated in different contexts or at different times, while maintaining all the necessary information and relationships intact.\n         */\n        serialized: AreInstructionSerialized,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        name: string,\n        /**\n         * In case this is a child instruction that is related to a declaration instruction, we can pass the parent declaration instruction to establish the relationship between them. This allows us to manage related instructions together and ensure that they are executed in the correct order in the scene.\n         */\n        parent: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        payload: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        name?: string,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        payload?: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        param1?: string | S,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        param2?: T | AreDeclaration,\n        /**\n         * In case this is a child instruction that is related to a declaration instruction, we can pass the parent declaration instruction to establish the relationship between them. This allows us to manage related instructions together and ensure that they are executed in the correct order in the scene.\n         */\n        param3?: AreDeclaration | T,\n    ) {\n        if (typeof param1 === 'object' && 'aseid' in param1)\n            super(param1);\n        else\n            super({\n                name: param1 || AreInstructionDefaultNames.Default,\n                parent: param2 instanceof AreDeclaration ? param2 : undefined,\n                group: param2 instanceof AreDeclaration ? param2.group : undefined,\n                payload: param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T,\n                // id: [param1, A_IdentityHelper.generateTimeId(), param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T]\n            } as AreInstructionNewProps<T>);\n    }\n\n}"]}

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.mjs

@@ -0,0 +1,30 @@
+import { __decorateClass } from '../../../chunk-EQQGB2QZ.mjs';
+import { A_Frame } from '@adaas/a-frame';
+import { AreInstruction } from '@adaas/are/instruction/AreInstruction.entity';
+import { AreInstructionDefaultNames } from '@adaas/are/instruction/AreInstruction.constants';
+
+let AreDeclaration = class extends AreInstruction {
+  constructor(param1, param2, param3) {
+    if (typeof param1 === "object" && "aseid" in param1)
+      super(param1);
+    else
+      super({
+        name: param1 || AreInstructionDefaultNames.Default,
+        parent: param2 instanceof AreDeclaration ? param2 : void 0,
+        group: param2 instanceof AreDeclaration ? param2.group : void 0,
+        payload: param2 instanceof AreDeclaration ? param3 || {} : param2 || {}
+        // id: [param1, A_IdentityHelper.generateTimeId(), param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T]
+      });
+  }
+};
+AreDeclaration = __decorateClass([
+  A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreDeclaration",
+    description: "AreDeclaration is a top-level rendering instruction that represents the creation of a new element in the ARE scene. It carries the target tag name and parent reference needed by the Host to construct the DOM element, and can be applied or reverted to manage element creation and removal deterministically."
+  })
+], AreDeclaration);
+
+export { AreDeclaration };
+//# sourceMappingURL=AreDeclaration.instruction.mjs.map
+//# sourceMappingURL=AreDeclaration.instruction.mjs.map

package/dist/node/lib/AreInstruction/types/AreDeclaration.instruction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/AreInstruction/types/AreDeclaration.instruction.ts"],"names":[],"mappings":";;;;;AAeO,IAAM,cAAA,GAAN,cAGG,cAAA,CAAqB;AAAA,EAgC3B,WAAA,CAII,MAAA,EAIA,MAAA,EAIA,MAAA,EACF;AACE,IAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,OAAA,IAAW,MAAA;AACzC,MAAA,KAAA,CAAM,MAAM,CAAA;AAAA;AAEZ,MAAA,KAAA,CAAM;AAAA,QACF,IAAA,EAAM,UAAU,0BAAA,CAA2B,OAAA;AAAA,QAC3C,MAAA,EAAQ,MAAA,YAAkB,cAAA,GAAiB,MAAA,GAAS,MAAA;AAAA,QACpD,KAAA,EAAO,MAAA,YAAkB,cAAA,GAAiB,MAAA,CAAO,KAAA,GAAQ,MAAA;AAAA,QACzD,SAAS,MAAA,YAAkB,cAAA,GAAkB,UAAU,EAAC,GAAW,UAAU;AAAC;AAAA,OAEpD,CAAA;AAAA,EACtC;AAEJ;AA7Da,cAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,MAAA,CAAO;AAAA,IACZ,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,gBAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,cAAA,CAAA","file":"AreDeclaration.instruction.mjs","sourcesContent":["import { A_IdentityHelper } from \"@adaas/a-concept\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"@adaas/are/instruction/AreInstruction.types\";\nimport { AreInstructionDefaultNames } from \"@adaas/are/instruction/AreInstruction.constants\";\n\n\n/**\n * This is a top-level instruction that represents the creation of a new element in the scene. It contains all the necessary information to create a new element, such as its tag and parent. This instruction can be applied to the scene to create a new element and can be reverted to remove the created element.\n */\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreDeclaration',\n    description: 'AreDeclaration is a top-level rendering instruction that represents the creation of a new element in the ARE scene. It carries the target tag name and parent reference needed by the Host to construct the DOM element, and can be applied or reverted to manage element creation and removal deterministically.'\n})\nexport class AreDeclaration<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends AreInstruction<T, S> {\n\n    constructor(\n        /**\n         * Serialized form of the instruction, used for deserialization and reconstruction of the instruction instance. This allows for the instruction to be easily stored, transmitted, and recreated in different contexts or at different times, while maintaining all the necessary information and relationships intact.\n         */\n        serialized: AreInstructionSerialized,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        name: string,\n        /**\n         * In case this is a child instruction that is related to a declaration instruction, we can pass the parent declaration instruction to establish the relationship between them. This allows us to manage related instructions together and ensure that they are executed in the correct order in the scene.\n         */\n        parent: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        payload: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        name?: string,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        payload?: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host. For example, for CreateElement instruction, the name can be \"createElement\", so the Host can have a method with the same name to handle this instruction.\n         */\n        param1?: string | S,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for CreateElement instruction, the payload can contain the tag name and parent information, so the Host can use this information to create the element in the correct place in the scene.\n         */\n        param2?: T | AreDeclaration,\n        /**\n         * In case this is a child instruction that is related to a declaration instruction, we can pass the parent declaration instruction to establish the relationship between them. This allows us to manage related instructions together and ensure that they are executed in the correct order in the scene.\n         */\n        param3?: AreDeclaration | T,\n    ) {\n        if (typeof param1 === 'object' && 'aseid' in param1)\n            super(param1);\n        else\n            super({\n                name: param1 || AreInstructionDefaultNames.Default,\n                parent: param2 instanceof AreDeclaration ? param2 : undefined,\n                group: param2 instanceof AreDeclaration ? param2.group : undefined,\n                payload: param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T,\n                // id: [param1, A_IdentityHelper.generateTimeId(), param2 instanceof AreDeclaration ? (param3 || {}) as T : (param2 || {}) as T]\n            } as AreInstructionNewProps<T>);\n    }\n\n}"]}

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.d.mts

@@ -0,0 +1,14 @@
+export { f as AreMutation } from '../../../Are.context-D7w32H1G.mjs';
+import '@adaas/a-concept';
+import '@adaas/a-utils/a-signal';
+import '../../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../../AreStore/AreStore.types.mjs';
+import '../../AreStore/AreStore.constants.mjs';
+import '../../AreScene/AreScene.constants.mjs';
+import '../../AreAttribute/AreAttribute.types.mjs';
+import '../../AreAttribute/AreAttribute.constants.mjs';
+import '../../AreComponent/Are.component.mjs';
+import '../../AreComponent/Are.types.mjs';
+import '../../AreComponent/Are.constants.mjs';
+import '../../AreNode/AreNode.constants.mjs';

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.d.ts

@@ -0,0 +1,14 @@
+export { f as AreMutation } from '../../../Are.context-9Ija_fdC.js';
+import '@adaas/a-concept';
+import '@adaas/a-utils/a-signal';
+import '../../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../../AreStore/AreStore.types.js';
+import '../../AreStore/AreStore.constants.js';
+import '../../AreScene/AreScene.constants.js';
+import '../../AreAttribute/AreAttribute.types.js';
+import '../../AreAttribute/AreAttribute.constants.js';
+import '../../AreComponent/Are.component.js';
+import '../../AreComponent/Are.types.js';
+import '../../AreComponent/Are.constants.js';
+import '../../AreNode/AreNode.constants.js';

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var aFrame = require('@adaas/a-frame');
+var AreInstruction_constants = require('@adaas/are/instruction/AreInstruction.constants');
+var AreInstruction_entity = require('@adaas/are/instruction/AreInstruction.entity');
+var AreInstruction_error = require('@adaas/are/instruction/AreInstruction.error');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+exports.AreMutation = class AreMutation extends AreInstruction_entity.AreInstruction {
+  get parent() {
+    return this._parent;
+  }
+  get group() {
+    return this._group || this.parent;
+  }
+  constructor(param1, param2, param3) {
+    if (typeof param1 === "object" && "aseid" in param1)
+      super(param1);
+    else
+      super({
+        name: param1 || AreInstruction_constants.AreInstructionDefaultNames.Mutation,
+        group: param2,
+        parent: param2,
+        payload: param3
+        // id: [param1, param3, param2?.group]
+      });
+  }
+  fromNew(newEntity) {
+    if (!newEntity.parent)
+      throw new AreInstruction_error.AreInstructionError({
+        title: "Mutation instruction must have a parent declaration instruction",
+        description: `Mutation instruction with name ${newEntity.name} must have a parent declaration instruction for grouping and organization purposes. Please provide a parent declaration instruction when creating this mutation instruction.`
+      });
+    super.fromNew(newEntity);
+  }
+};
+exports.AreMutation = __decorateClass([
+  aFrame.A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreMutation",
+    description: "AreMutation is a rendering instruction that represents a reversible change applied to an existing declaration node in the ARE scene \u2014 such as updating an attribute, modifying content, or altering child structure. It references a parent AreDeclaration and is grouped with related mutations for coordinated apply and revert operations."
+  })
+], exports.AreMutation);
+//# sourceMappingURL=AreMutation.instruction.js.map
+//# sourceMappingURL=AreMutation.instruction.js.map

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/AreInstruction/types/AreMutation.instruction.ts"],"names":["AreMutation","AreInstruction","AreInstructionDefaultNames","AreInstructionError","A_Frame"],"mappings":";;;;;;;;;;;;;;;AAeaA,mBAAA,GAAN,0BAGGC,oCAAA,CAAqB;AAAA,EAE3B,IAAI,MAAA,GAAiB;AACjB,IAAA,OAAO,IAAA,CAAK,OAAA;AAAA,EAChB;AAAA,EAGA,IAAI,KAAA,GAAgB;AAChB,IAAA,OAAO,IAAA,CAAK,UAAU,IAAA,CAAK,MAAA;AAAA,EAC/B;AAAA,EAsBA,WAAA,CAII,MAAA,EAIA,MAAA,EAIA,MAAA,EACF;AACE,IAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,OAAA,IAAW,MAAA;AACzC,MAAA,KAAA,CAAM,MAAM,CAAA;AAAA;AAEZ,MAAA,KAAA,CAAM;AAAA,QACF,IAAA,EAAM,UAAUC,mDAAA,CAA2B,QAAA;AAAA,QAC3C,KAAA,EAAO,MAAA;AAAA,QACP,MAAA,EAAQ,MAAA;AAAA,QACR,OAAA,EAAS;AAAA;AAAA,OAEiB,CAAA;AAAA,EACtC;AAAA,EAIA,QAAQ,SAAA,EAA4C;AAChD,IAAA,IAAI,CAAC,SAAA,CAAU,MAAA;AACX,MAAA,MAAM,IAAIC,wCAAA,CAAoB;AAAA,QAC1B,KAAA,EAAO,iEAAA;AAAA,QACP,WAAA,EAAa,CAAA,+BAAA,EAAkC,SAAA,CAAU,IAAI,CAAA,4KAAA;AAAA,OAChE,CAAA;AAEL,IAAA,KAAA,CAAM,QAAQ,SAAS,CAAA;AAAA,EAC3B;AACJ;AAvEaH,mBAAA,GAAN,eAAA,CAAA;AAAA,EALNI,eAAQ,MAAA,CAAO;AAAA,IACZ,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,aAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACYJ,mBAAA,CAAA","file":"AreMutation.instruction.js","sourcesContent":["import { title } from \"process\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { AreInstructionDefaultNames } from \"@adaas/are/instruction/AreInstruction.constants\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { AreInstructionError } from \"@adaas/are/instruction/AreInstruction.error\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"@adaas/are/instruction/AreInstruction.types\";\nimport { AreDeclaration } from \"./AreDeclaration.instruction\";\n\n\n\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreMutation',\n    description: 'AreMutation is a rendering instruction that represents a reversible change applied to an existing declaration node in the ARE scene — such as updating an attribute, modifying content, or altering child structure. It references a parent AreDeclaration and is grouped with related mutations for coordinated apply and revert operations.'\n})\nexport class AreMutation<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends AreInstruction<T, S> {\n\n    get parent(): string {\n        return this._parent!;\n    }\n\n\n    get group(): string {\n        return this._group || this.parent;\n    }\n\n    constructor(\n        /**\n         * Serialized form of the instruction, used for deserialization and reconstruction of the instruction instance. This allows for the instruction to be easily stored, transmitted, and recreated in different contexts or at different times, while maintaining all the necessary information and relationships intact.\n         */\n        serialized: S,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host.\n         */\n        name: string,\n        /**\n         * Parent instruction for grouping in case of mutations related to a specific declaration. This allows for better organization and management of instructions in the scene, as all mutations related to the same declaration will be executed together.\n         */\n        parent: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for AddAttribute instruction, the payload can contain the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.\n         */\n        payload?: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host.\n         */\n        param1: string | S,\n        /**\n         * Parent instruction for grouping in case of mutations related to a specific declaration. This allows for better organization and management of instructions in the scene, as all mutations related to the same declaration will be executed together.\n         */\n        param2?: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for AddAttribute instruction, the payload can contain the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.\n         */\n        param3?: T,\n    ) {\n        if (typeof param1 === 'object' && 'aseid' in param1)\n            super(param1);\n        else\n            super({\n                name: param1 || AreInstructionDefaultNames.Mutation,\n                group: param2,\n                parent: param2,\n                payload: param3,\n                // id: [param1, param3, param2?.group]\n            } as AreInstructionNewProps<T>);\n    }\n\n\n\n    fromNew(newEntity: AreInstructionNewProps<T>): void {\n        if (!newEntity.parent)\n            throw new AreInstructionError({\n                title: \"Mutation instruction must have a parent declaration instruction\",\n                description: `Mutation instruction with name ${newEntity.name} must have a parent declaration instruction for grouping and organization purposes. Please provide a parent declaration instruction when creating this mutation instruction.`\n            });\n\n        super.fromNew(newEntity);\n    }\n}"]}

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.mjs

@@ -0,0 +1,45 @@
+import { __decorateClass } from '../../../chunk-EQQGB2QZ.mjs';
+import { A_Frame } from '@adaas/a-frame';
+import { AreInstructionDefaultNames } from '@adaas/are/instruction/AreInstruction.constants';
+import { AreInstruction } from '@adaas/are/instruction/AreInstruction.entity';
+import { AreInstructionError } from '@adaas/are/instruction/AreInstruction.error';
+
+let AreMutation = class extends AreInstruction {
+  get parent() {
+    return this._parent;
+  }
+  get group() {
+    return this._group || this.parent;
+  }
+  constructor(param1, param2, param3) {
+    if (typeof param1 === "object" && "aseid" in param1)
+      super(param1);
+    else
+      super({
+        name: param1 || AreInstructionDefaultNames.Mutation,
+        group: param2,
+        parent: param2,
+        payload: param3
+        // id: [param1, param3, param2?.group]
+      });
+  }
+  fromNew(newEntity) {
+    if (!newEntity.parent)
+      throw new AreInstructionError({
+        title: "Mutation instruction must have a parent declaration instruction",
+        description: `Mutation instruction with name ${newEntity.name} must have a parent declaration instruction for grouping and organization purposes. Please provide a parent declaration instruction when creating this mutation instruction.`
+      });
+    super.fromNew(newEntity);
+  }
+};
+AreMutation = __decorateClass([
+  A_Frame.Entity({
+    namespace: "A-ARE",
+    name: "AreMutation",
+    description: "AreMutation is a rendering instruction that represents a reversible change applied to an existing declaration node in the ARE scene \u2014 such as updating an attribute, modifying content, or altering child structure. It references a parent AreDeclaration and is grouped with related mutations for coordinated apply and revert operations."
+  })
+], AreMutation);
+
+export { AreMutation };
+//# sourceMappingURL=AreMutation.instruction.mjs.map
+//# sourceMappingURL=AreMutation.instruction.mjs.map

package/dist/node/lib/AreInstruction/types/AreMutation.instruction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/AreInstruction/types/AreMutation.instruction.ts"],"names":[],"mappings":";;;;;;AAeO,IAAM,WAAA,GAAN,cAGG,cAAA,CAAqB;AAAA,EAE3B,IAAI,MAAA,GAAiB;AACjB,IAAA,OAAO,IAAA,CAAK,OAAA;AAAA,EAChB;AAAA,EAGA,IAAI,KAAA,GAAgB;AAChB,IAAA,OAAO,IAAA,CAAK,UAAU,IAAA,CAAK,MAAA;AAAA,EAC/B;AAAA,EAsBA,WAAA,CAII,MAAA,EAIA,MAAA,EAIA,MAAA,EACF;AACE,IAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,OAAA,IAAW,MAAA;AACzC,MAAA,KAAA,CAAM,MAAM,CAAA;AAAA;AAEZ,MAAA,KAAA,CAAM;AAAA,QACF,IAAA,EAAM,UAAU,0BAAA,CAA2B,QAAA;AAAA,QAC3C,KAAA,EAAO,MAAA;AAAA,QACP,MAAA,EAAQ,MAAA;AAAA,QACR,OAAA,EAAS;AAAA;AAAA,OAEiB,CAAA;AAAA,EACtC;AAAA,EAIA,QAAQ,SAAA,EAA4C;AAChD,IAAA,IAAI,CAAC,SAAA,CAAU,MAAA;AACX,MAAA,MAAM,IAAI,mBAAA,CAAoB;AAAA,QAC1B,KAAA,EAAO,iEAAA;AAAA,QACP,WAAA,EAAa,CAAA,+BAAA,EAAkC,SAAA,CAAU,IAAI,CAAA,4KAAA;AAAA,OAChE,CAAA;AAEL,IAAA,KAAA,CAAM,QAAQ,SAAS,CAAA;AAAA,EAC3B;AACJ;AAvEa,WAAA,GAAN,eAAA,CAAA;AAAA,EALN,QAAQ,MAAA,CAAO;AAAA,IACZ,SAAA,EAAW,OAAA;AAAA,IACX,IAAA,EAAM,aAAA;AAAA,IACN,WAAA,EAAa;AAAA,GAChB;AAAA,CAAA,EACY,WAAA,CAAA","file":"AreMutation.instruction.mjs","sourcesContent":["import { title } from \"process\";\nimport { A_Frame } from \"@adaas/a-frame\";\nimport { AreInstructionDefaultNames } from \"@adaas/are/instruction/AreInstruction.constants\";\nimport { AreInstruction } from \"@adaas/are/instruction/AreInstruction.entity\";\nimport { AreInstructionError } from \"@adaas/are/instruction/AreInstruction.error\";\nimport { AreInstructionNewProps, AreInstructionSerialized } from \"@adaas/are/instruction/AreInstruction.types\";\nimport { AreDeclaration } from \"./AreDeclaration.instruction\";\n\n\n\n@A_Frame.Entity({\n    namespace: 'A-ARE',\n    name: 'AreMutation',\n    description: 'AreMutation is a rendering instruction that represents a reversible change applied to an existing declaration node in the ARE scene — such as updating an attribute, modifying content, or altering child structure. It references a parent AreDeclaration and is grouped with related mutations for coordinated apply and revert operations.'\n})\nexport class AreMutation<\n    T extends Record<string, any> = Record<string, any>,\n    S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>\n> extends AreInstruction<T, S> {\n\n    get parent(): string {\n        return this._parent!;\n    }\n\n\n    get group(): string {\n        return this._group || this.parent;\n    }\n\n    constructor(\n        /**\n         * Serialized form of the instruction, used for deserialization and reconstruction of the instruction instance. This allows for the instruction to be easily stored, transmitted, and recreated in different contexts or at different times, while maintaining all the necessary information and relationships intact.\n         */\n        serialized: S,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host.\n         */\n        name: string,\n        /**\n         * Parent instruction for grouping in case of mutations related to a specific declaration. This allows for better organization and management of instructions in the scene, as all mutations related to the same declaration will be executed together.\n         */\n        parent: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for AddAttribute instruction, the payload can contain the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.\n         */\n        payload?: T,\n    )\n    constructor(\n        /**\n         * The name of the operation to be performed in Host.\n         */\n        param1: string | S,\n        /**\n         * Parent instruction for grouping in case of mutations related to a specific declaration. This allows for better organization and management of instructions in the scene, as all mutations related to the same declaration will be executed together.\n         */\n        param2?: AreDeclaration,\n        /**\n         * A set of additional parameters that may be needed for the rendering purpose. For example, for AddAttribute instruction, the payload can contain the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.\n         */\n        param3?: T,\n    ) {\n        if (typeof param1 === 'object' && 'aseid' in param1)\n            super(param1);\n        else\n            super({\n                name: param1 || AreInstructionDefaultNames.Mutation,\n                group: param2,\n                parent: param2,\n                payload: param3,\n                // id: [param1, param3, param2?.group]\n            } as AreInstructionNewProps<T>);\n    }\n\n\n\n    fromNew(newEntity: AreInstructionNewProps<T>): void {\n        if (!newEntity.parent)\n            throw new AreInstructionError({\n                title: \"Mutation instruction must have a parent declaration instruction\",\n                description: `Mutation instruction with name ${newEntity.name} must have a parent declaration instruction for grouping and organization purposes. Please provide a parent declaration instruction when creating this mutation instruction.`\n            });\n\n        super.fromNew(newEntity);\n    }\n}"]}

package/dist/node/lib/AreInterpreter/AreInterpreter.component.d.mts

@@ -0,0 +1,49 @@
+import { A_Component, A_Scope, A_Feature } from '@adaas/a-concept';
+import { k as AreScene, c as AreInstruction, o as AreStore } from '../../Are.context-D7w32H1G.mjs';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.mjs';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.mjs';
+import '../AreStore/AreStore.constants.mjs';
+import '../AreScene/AreScene.constants.mjs';
+import '../AreAttribute/AreAttribute.types.mjs';
+import '../AreAttribute/AreAttribute.constants.mjs';
+import '../AreComponent/Are.component.mjs';
+import '../AreComponent/Are.types.mjs';
+import '../AreComponent/Are.constants.mjs';
+import '../AreNode/AreNode.constants.mjs';
+
+declare class AreInterpreter extends A_Component {
+    /**
+     * Decorator to mark a method as an instruction Apply handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be applied. The method should contain logic to perform the necessary operations on the rendering target based on the instruction's content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Apply(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Decorator to mark a method as an instruction Update handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction has been updated. The method should contain logic to perform the necessary operations on the rendering target to update the effects of the instruction based on its new content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Update(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Decorator to mark a method as an instruction Revert handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be reverted. The method should contain logic to perform the necessary operations on the rendering target to undo the effects of the instruction based on its content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Revert(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * The method responsible for executing the render operation based on the current state of the Scene. It processes the instructions that need to be applied and reverted, ensuring that the rendering target is updated accordingly. The method handles any errors that may occur during the application or reversion of instructions, maintaining the integrity of the rendering process.
+     *
+     * @param scene
+     */
+    interpret(scene: AreScene): void;
+    protected applyInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected updateInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected revertInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+}
+
+export { AreInterpreter };

package/dist/node/lib/AreInterpreter/AreInterpreter.component.d.ts

@@ -0,0 +1,49 @@
+import { A_Component, A_Scope, A_Feature } from '@adaas/a-concept';
+import { k as AreScene, c as AreInstruction, o as AreStore } from '../../Are.context-9Ija_fdC.js';
+import '@adaas/a-utils/a-signal';
+import '../AreEvent/AreEvent.context.js';
+import '@adaas/a-utils/a-execution';
+import '../AreStore/AreStore.types.js';
+import '../AreStore/AreStore.constants.js';
+import '../AreScene/AreScene.constants.js';
+import '../AreAttribute/AreAttribute.types.js';
+import '../AreAttribute/AreAttribute.constants.js';
+import '../AreComponent/Are.component.js';
+import '../AreComponent/Are.types.js';
+import '../AreComponent/Are.constants.js';
+import '../AreNode/AreNode.constants.js';
+
+declare class AreInterpreter extends A_Component {
+    /**
+     * Decorator to mark a method as an instruction Apply handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be applied. The method should contain logic to perform the necessary operations on the rendering target based on the instruction's content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Apply(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Decorator to mark a method as an instruction Update handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction has been updated. The method should contain logic to perform the necessary operations on the rendering target to update the effects of the instruction based on its new content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Update(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Decorator to mark a method as an instruction Revert handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be reverted. The method should contain logic to perform the necessary operations on the rendering target to undo the effects of the instruction based on its content and context.
+     *
+     * @param action
+     * @returns
+     */
+    static Revert(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * The method responsible for executing the render operation based on the current state of the Scene. It processes the instructions that need to be applied and reverted, ensuring that the rendering target is updated accordingly. The method handles any errors that may occur during the application or reversion of instructions, maintaining the integrity of the rendering process.
+     *
+     * @param scene
+     */
+    interpret(scene: AreScene): void;
+    protected applyInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected updateInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected revertInstruction(instruction: AreInstruction, interpreter: AreInterpreter, store: AreStore, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+}
+
+export { AreInterpreter };

package/dist/node/lib/AreInterpreter/AreInterpreter.component.js

@@ -0,0 +1,164 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var aFrame = require('@adaas/a-frame');
+var AreScene_context = require('@adaas/are/scene/AreScene.context');
+var AreNode_entity = require('@adaas/are/node/AreNode.entity');
+var AreNode_constants = require('@adaas/are/node/AreNode.constants');
+var AreInstruction_constants = require('@adaas/are/instruction/AreInstruction.constants');
+var AreInstruction_entity = require('@adaas/are/instruction/AreInstruction.entity');
+var AreStore_context = require('@adaas/are/store/AreStore.context');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+exports.AreInterpreter = class AreInterpreter extends aConcept.A_Component {
+  /**
+   * Decorator to mark a method as an instruction Apply handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be applied. The method should contain logic to perform the necessary operations on the rendering target based on the instruction's content and context.
+   * 
+   * @param action 
+   * @returns 
+   */
+  static Apply(action) {
+    const name = action + AreInstruction_constants.AreInstructionFeatures.Apply;
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name,
+        scope: [target.constructor]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * Decorator to mark a method as an instruction Update handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction has been updated. The method should contain logic to perform the necessary operations on the rendering target to update the effects of the instruction based on its new content and context.
+   * 
+   * @param action 
+   * @returns 
+   */
+  static Update(action) {
+    const name = action + AreInstruction_constants.AreInstructionFeatures.Update;
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name,
+        scope: [target.constructor]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * Decorator to mark a method as an instruction Revert handler for the specific instruction type. The method will be called during the render phase of the ARE component when the corresponding instruction needs to be reverted. The method should contain logic to perform the necessary operations on the rendering target to undo the effects of the instruction based on its content and context.
+   * 
+   * @param action 
+   * @returns 
+   */
+  static Revert(action) {
+    const name = action + AreInstruction_constants.AreInstructionFeatures.Revert;
+    return (target, propertyKey, descriptor) => {
+      return aConcept.A_Feature.Extend({
+        name,
+        scope: [target.constructor]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  interpret(scene) {
+    const { toApply, toRevert } = scene.changes;
+    for (const instruction of toRevert) {
+      try {
+        instruction.revert();
+        scene.unApply(instruction);
+      } catch (error) {
+        instruction.apply();
+        scene.apply(instruction);
+      }
+    }
+    for (const instruction of toApply) {
+      try {
+        instruction.apply();
+        scene.apply(instruction);
+      } catch (error) {
+        instruction.revert();
+        scene.unApply(instruction);
+      }
+    }
+  }
+  applyInstruction(instruction, interpreter, store, scope, feature, ...args) {
+    try {
+      store.watch(instruction);
+      feature.chain(interpreter, instruction.name + AreInstruction_constants.AreInstructionFeatures.Apply, scope);
+      store.unwatch(instruction);
+    } catch (error) {
+      store.unwatch(instruction);
+      throw error;
+    }
+  }
+  updateInstruction(instruction, interpreter, store, scope, feature, ...args) {
+    try {
+      store.watch(instruction);
+      feature.chain(interpreter, instruction.name + AreInstruction_constants.AreInstructionFeatures.Update, scope);
+      store.unwatch(instruction);
+    } catch (error) {
+      store.unwatch(instruction);
+      throw error;
+    }
+  }
+  revertInstruction(instruction, interpreter, store, scope, feature, ...args) {
+    try {
+      feature.chain(interpreter, instruction.name + AreInstruction_constants.AreInstructionFeatures.Revert, scope);
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreNode_constants.AreNodeFeatures.onInterpret,
+    scope: [AreNode_entity.AreNode]
+  }),
+  __decorateParam(0, aConcept.A_Inject(AreScene_context.AreScene))
+], exports.AreInterpreter.prototype, "interpret", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreInstruction_constants.AreInstructionFeatures.Apply,
+    scope: [AreInstruction_entity.AreInstruction]
+  }),
+  __decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  __decorateParam(1, aConcept.A_Inject(exports.AreInterpreter)),
+  __decorateParam(2, aConcept.A_Inject(AreStore_context.AreStore)),
+  __decorateParam(3, aConcept.A_Inject(aConcept.A_Scope)),
+  __decorateParam(4, aConcept.A_Inject(aConcept.A_Feature))
+], exports.AreInterpreter.prototype, "applyInstruction", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreInstruction_constants.AreInstructionFeatures.Update,
+    scope: [AreInstruction_entity.AreInstruction]
+  }),
+  __decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  __decorateParam(1, aConcept.A_Inject(exports.AreInterpreter)),
+  __decorateParam(2, aConcept.A_Inject(AreStore_context.AreStore)),
+  __decorateParam(3, aConcept.A_Inject(aConcept.A_Scope)),
+  __decorateParam(4, aConcept.A_Inject(aConcept.A_Feature))
+], exports.AreInterpreter.prototype, "updateInstruction", 1);
+__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: AreInstruction_constants.AreInstructionFeatures.Revert,
+    scope: [AreInstruction_entity.AreInstruction]
+  }),
+  __decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  __decorateParam(1, aConcept.A_Inject(exports.AreInterpreter)),
+  __decorateParam(2, aConcept.A_Inject(AreStore_context.AreStore)),
+  __decorateParam(3, aConcept.A_Inject(aConcept.A_Scope)),
+  __decorateParam(4, aConcept.A_Inject(aConcept.A_Feature))
+], exports.AreInterpreter.prototype, "revertInstruction", 1);
+exports.AreInterpreter = __decorateClass([
+  aFrame.A_Frame.Component({
+    description: "Stateless executor that reads the Scene and translates its instructions into operations on a rendering target. Computes the diff between applied and planned, calls revert on removed instructions and apply on added ones. Owns no state of its own \u2014 all state lives in the Scene. Can be swapped for any target implementation (DOMInterpreter, SSRInterpreter, CanvasInterpreter) without touching any other part of the pipeline."
+  })
+], exports.AreInterpreter);
+//# sourceMappingURL=AreInterpreter.component.js.map
+//# sourceMappingURL=AreInterpreter.component.js.map