@adaas/are 0.0.3 → 0.0.5

package/dist/browser/index.d.mts

@@ -1,9 +1,31 @@
 import * as _adaas_a_concept from '@adaas/a-concept';
-import { A_Component, A_TYPES__Entity_Serialized, A_Entity, A_Scope, A_TYPES__Fragment_Serialized, A_Fragment, ASEID, A_TYPES__Paths, A_TYPES__Entity_Constructor, A_Error, A_Feature, A_TYPES__Ctor, A_ComponentMeta, A_TYPES__ComponentMeta } from '@adaas/a-concept';
-import { A_SignalVector, A_Signal, A_SignalState } from '@adaas/a-utils/a-signal';
+import { A_Component, A_Fragment, A_Entity, A_Scope, ASEID, A_TYPES__Entity_Serialized, A_TYPES__Entity_Constructor, A_Error, A_Feature, A_TYPES__Paths, A_TYPES__Fragment_Serialized, A_TYPES__Ctor, A_ComponentMeta, A_TYPES__ComponentMeta, A_TYPES__Component_Constructor, A_TYPES__A_DependencyInjectable } from '@adaas/a-concept';
+import { A_SignalVector, A_Signal, A_SignalState, A_SignalBus } from '@adaas/a-utils/a-signal';
+import { AreNode as AreNode$1 } from '@adaas/are/node/AreNode.entity';
 import { A_ExecutionContext } from '@adaas/a-utils/a-execution';
+import { AreEvent as AreEvent$1 } from '@adaas/are/event/AreEvent.context';
+import { AreScene as AreScene$1 } from '@adaas/are/scene/AreScene.context';
+import { AreAttribute as AreAttribute$1 } from '@adaas/are/attribute/AreAttribute.entity';
+import { Are as Are$1 } from '@adaas/are/component/Are.component';
+import { AreSyntaxTokenMatch as AreSyntaxTokenMatch$1, AreSyntaxTokenPayload as AreSyntaxTokenPayload$1, AreSyntaxTokenRules as AreSyntaxTokenRules$1 } from '@adaas/are/syntax/AreSyntax.types';
+import { AreStore as AreStore$1 } from '@adaas/are/store/AreStore.context';
+import { AreSyntax as AreSyntax$1 } from '@adaas/are/syntax/AreSyntax.context';
+import { AreContext as AreContext$1 } from '@adaas/are/component/Are.context';
 import { A_Logger } from '@adaas/a-utils/a-logger';
+import { AreInstruction as AreInstruction$1 } from '@adaas/are/instruction/AreInstruction.entity';
+import { AreDeclaration as AreDeclaration$1 } from '@adaas/are/instruction/types/AreDeclaration.instruction';
+import { AreInstructionSerialized as AreInstructionSerialized$1, AreInstructionNewProps as AreInstructionNewProps$1 } from '@adaas/are/instruction/AreInstruction.types';
+import { AreMutation as AreMutation$1 } from '@adaas/are/instruction/types/AreMutation.instruction';
+import { AreStoreWatchingEntity as AreStoreWatchingEntity$1 } from '@adaas/are/store/AreStore.types';
+import { AreSignal as AreSignal$1 } from '@adaas/are/signals/AreSignal.entity';
 import { A_Route } from '@adaas/a-utils/a-route';
+import { AreCompiler as AreCompiler$1 } from '@adaas/are/compiler/AreCompiler.component';
+import { AreTransformer as AreTransformer$1 } from '@adaas/are/transformer/AreTransformer.component';
+import { AreLoader as AreLoader$1 } from '@adaas/are/loader/AreLoader.component';
+import { AreInterpreter as AreInterpreter$1 } from '@adaas/are/interpreter/AreInterpreter.component';
+import { AreLifecycle as AreLifecycle$1 } from '@adaas/are/lifecycle/AreLifecycle.component';
+import { AreTokenizer as AreTokenizer$1 } from '@adaas/are/tokenizer/AreTokenizer.component';
+import { AreSignals as AreSignals$1 } from '@adaas/are/signals/AreSignals.component';
 
 declare const AreFeatures: {
     /**
@@ -170,414 +192,358 @@ declare class Are extends A_Component {
     data(...args: any[]): Promise<void> | void;
 }
 
-declare class AreEvent<T extends Record<string, any> = Record<string, any>> extends A_ExecutionContext<T> {
-}
-
-type AreInstructionNewProps<T extends any = Record<string, any>> = {
+declare class AreContext extends A_ExecutionContext {
     /**
-     * The deduplication ID that prevents duplicated instruction within the same node.
-     *
-     * For example to prevent duplicated AddAttribute instruction for the same attribute, we can use the attribute name as the deduplication ID, so if we have two AddAttribute instructions with the same attribute name, only the first one will be applied, and the second one will be ignored.
-     *
-     *
-     * [!] Note; By default it uses action name and group if provided
+     * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
      */
+    protected _source: string;
     /**
-     * the Host operation to be performed. Exactly this name will be used to call a method from the Host class.
+     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
      */
-    name: string;
+    protected _roots: Array<AreNode$1>;
     /**
-     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
+     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
      */
-    parent?: AreInstruction | undefined;
+    protected _signalsMap: Map<string, A_SignalVector>;
+    protected _performance: Map<string, number>;
+    protected _performanceStart: Map<string, number>;
+    protected _performanceDepth: Map<string, number>;
     /**
-     * Group is an optional property that can be used to group instructions together.
-     *
-     * For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on.
-     *
-     * This can be useful to manage complex changes that involve multiple instructions.
-     *
-     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
+     * The global object can be used to store any global data or configurations that need to be accessed across different components and entities within the ARE framework. This can include things like theme settings, user preferences, or any other shared data that is relevant to the entire scene or application. By centralizing this information in the context, it allows for easier management and access to global state without needing to pass it through multiple layers of components or entities.
      */
-    group?: AreInstruction | undefined;
+    get globals(): any;
+    constructor(
     /**
-     * A set of additional parameters that may be needed for the rendering purpose.
-     *
-     * For example: for AddAttribute instruction, we may need to provide the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.
+     * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
      */
-    payload?: T;
-};
-type AreInstructionSerialized<T extends any = Record<string, any>> = {
+    source?: string);
     /**
-     * The name of the instruction, which corresponds to the operation that should be performed in the Host. This name is used to identify the specific method in the Host that should be called to execute the instruction, allowing for a clear mapping between instructions and their corresponding actions in the rendering process.
+     * The scope of the context, which can be used to access other entities and features within the same scope. This is particularly useful for components that need to interact with other parts of the scene or component, as it allows them to access shared data and functionality without needing to pass it explicitly through parameters.
      */
-    name: string;
+    get scope(): _adaas_a_concept.A_Scope<any, _adaas_a_concept.A_TYPES__Component_Constructor<_adaas_a_concept.A_Component>[], _adaas_a_concept.A_TYPES__Error_Constructor<_adaas_a_concept.A_Error<_adaas_a_concept.A_TYPES__Error_Init, _adaas_a_concept.A_TYPES__Error_Serialized>>[], _adaas_a_concept.A_TYPES__Entity_Constructor<_adaas_a_concept.A_Entity<any, _adaas_a_concept.A_TYPES__Entity_Serialized>>[], A_Fragment<_adaas_a_concept.A_TYPES__Fragment_Serialized>[]>;
     /**
-     * The type of the instruction, which can be used to categorize instructions and determine how they should be processed. For example, we can have different types for declaration instructions (e.g., DeclarationInstruction or CreateElement) and mutation instructions (e.g., AddAttribute), allowing for better organization and management of instructions based on their purpose and behavior in the scene.
+     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
      */
-    type: string;
+    get roots(): Array<AreNode$1>;
     /**
-     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
+     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
      */
-    parent?: string | undefined;
+    get source(): string;
+    get performance(): Array<string>;
+    get stats(): string[];
+    protected countInstructions(node: AreNode$1): number;
+    protected countNodes(node: AreNode$1): number;
     /**
-     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. The best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
+     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     *
+     * @param node
      */
-    group?: string | undefined;
+    addRoot(node: AreNode$1): void;
     /**
-     * A set of additional parameters that may be needed for the rendering purpose. For example: for AddAttribute instruction, we may need to provide the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.
+     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     *
+     * @param node
      */
-    payload: T;
-} & A_TYPES__Entity_Serialized;
-
-declare const AreStoreAreComponentMetaKeys: {
-    readonly StoreExtensions: "_AreStore_StoreExtensions";
-};
-
-type AreStorePathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? AreStorePathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
-type AreStoreWatchingEntity = {
-    update(...args: any[]): void;
-};
-type AreStoreAreComponentMetaKeyNames = typeof AreStoreAreComponentMetaKeys[keyof typeof AreStoreAreComponentMetaKeys];
+    removeRoot(node: AreNode$1): void;
+    startPerformance(label?: string): void;
+    endPerformance(label: string): void;
+}
 
-declare class AreInstruction<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>> extends A_Entity<AreInstructionNewProps<T>, S> implements AreStoreWatchingEntity {
+declare const AreNodeFeatures: {
     /**
-     * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
+     * Feature that is called to handle before init lifecycle of the element node
      */
-    protected _name: string;
+    readonly onBeforeInit: "_AreNode_onBeforeInit";
     /**
-     * The payload of the instruction, which can contain any additional information 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. The payload is optional and can be an empty object if no additional information is needed.
+     * Feature that is called to init the element node
      */
-    protected _payload?: T;
+    readonly onInit: "_AreNode_onInit";
     /**
-     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions.
      *
-     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
      */
-    protected _group: string | undefined;
+    readonly onAfterInit: "_AreNode_onAfterInit";
     /**
-     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
+     * Feature that is called to handle before mount lifecycle of the element node
      */
-    protected _parent: string | undefined;
+    readonly onBeforeMount: "_AreNode_onBeforeMount";
     /**
-     * A set of properties that influence the behavior of the instruction, for example, for AddTextInstruction, we can interpolation dependent on some key in the store, so we can have a property called "interpolationKey" that will be used to track the dependencies of the instruction, and when the value of this key changes in the scope, we can update the instruction accordingly.
+     * Feature that is called to mount the element node
      */
-    protected _props: Set<string>;
+    readonly onMount: "_AreNode_onMount";
     /**
-     * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
+     * Feature that is called to handle after mount lifecycle of the element node
      */
-    get name(): string;
+    readonly onAfterMount: "_AreNode_onAfterMount";
     /**
-     * The payload of the instruction, which can contain any additional information 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. The payload is optional and can be an empty object if no additional information is needed.
-     *
-     * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.
+     * Feature that is called to handle before update lifecycle of the element node
      */
-    get payload(): T;
+    readonly onBeforeUpdate: "_AreNode_onBeforeUpdate";
     /**
-     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions.
-     *
-     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
+     * Feature that is called to handle update lifecycle of the element node
      */
-    get group(): string | undefined;
+    readonly onUpdate: "_AreNode_onUpdate";
     /**
-     * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
-     *
-     * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.
+     * Feature that is called to handle after update lifecycle of the element node
      */
-    get parent(): string | undefined;
-    get id(): string;
-    get owner(): AreNode;
-    fromNew(newEntity: AreInstructionNewProps<T>): void;
-    fromUndefined(): void;
+    readonly onAfterUpdate: "_AreNode_onAfterUpdate";
     /**
-     * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions.
-     *
-     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.
-     *
-     * @param instruction
-     * @returns
+     * Feature that is called to handle before unmount lifecycle of the element node
      */
-    groupWith(instruction: AreInstruction): this;
+    readonly onBeforeUnmount: "_AreNode_onBeforeUnmount";
     /**
-     * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.
-     *
-     * @returns
+     * Feature that is called to unmount the element node
      */
-    unGroup(): this;
+    readonly onUnmount: "_AreNode_onUnmount";
     /**
-     * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies.
-     *
-     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.
-     *
-     * @param parent
-     * @returns
+     * Feature that is called to handle after unmount lifecycle of the element node
      */
-    attachTo(parent: AreInstruction): this;
+    readonly onAfterUnmount: "_AreNode_onAfterUnmount";
     /**
-     * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.
-     *
-     * @returns
+     * Feature that is called to handle before destroy lifecycle of the element node
      */
-    detach(): this;
+    readonly onBeforeDestroy: "_AreNode_onBeforeDestroy";
     /**
-     * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output.
-     *
-     * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.
-     *
-     * @param scope
+     * Feature that is called to handle before destroy lifecycle of the element node
      */
-    apply(scope?: A_Scope): void;
+    readonly onDestroy: "_AreNode_onDestroy";
     /**
-     * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.
-     *
-     * @param scope
+     * Feature that is called to handle after destroy lifecycle of the element node
      */
-    update(scope?: A_Scope): void;
+    readonly onAfterDestroy: "_AreNode_onAfterDestroy";
     /**
-     * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.
-     *
-     * @param scope
+     * Feature that is called to tokenize the element node template and extract its content, attributes, and child nodes.
      */
-    revert(scope?: A_Scope): void;
-}
-
-/**
- * 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.
- */
-declare class AreDeclaration<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>> extends AreInstruction<T, S> {
-    constructor(
+    readonly onTokenize: "_AreNode_onTokenize";
     /**
-     * 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.
+     * Feature that is called to transform the element node template, markup, styles, and data into a format that can be used for compilation. This feature is responsible for processing the raw template and extracting the necessary information to create the render plan and instructions for the node.
      */
-    serialized: AreInstructionSerialized);
-    constructor(
+    readonly onTransform: "_AreNode_onTransform";
     /**
-     * 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.
+     * Event fired when the element node is interpreted
      */
-    name: string, 
+    readonly onInterpret: "_AreNode_onInterpret";
     /**
-     * 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.
+     * Feature that is called to compile the element node
      */
-    parent: AreDeclaration, 
+    readonly onCompile: "_AreNode_onCompile";
     /**
-     * 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.
+     * Feature that is called to handle events
      */
-    payload: T);
-    constructor(
+    readonly onEmit: "_AreNode_onEmit";
+};
+declare const AreNodeStatuses: {
     /**
-     * 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.
+     * Status indicating that the node is pending compilation. When a node is in the pending status, it means that it has been created but has not yet been compiled. During this phase, the node is typically being prepared for compilation, which may involve setting up its template, markup, styles, and any associated data or context. Once the node is ready for compilation, its status will change to "compiling".
      */
-    name?: string, 
+    readonly Pending: "pending";
     /**
-     * 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.
+     * Status indicating that the node is in the process of being compiled. During this status, the node is being analyzed and transformed based on its template, markup, and styles to generate the necessary instructions for rendering and updating the node in the scene.
      */
-    payload?: T);
-}
-
-declare const AreSceneStatuses: {
-    Active: string;
-    Inactive: string;
-    Destroyed: string;
-};
-
-type AreSceneChanges = {
+    readonly Compiling: "compiling";
     /**
-     * An array of instructions that are planned to be applied to the scene. These instructions represent the changes that will be made to the scene when they
+     * Status indicating that the node has been compiled and is ready to be rendered. In this status, the node has generated all the necessary instructions and is prepared to be mounted in the scene.
      */
-    toApply: AreInstruction[];
+    readonly Compiled: "compiled";
     /**
-     * An array of instructions that are planned to be reverted from the scene. These instructions represent the changes that will be undone from the scene when they are reverted, allowing for a rollback of changes if needed.
+     * Status indicating that the node is currently mounted in the scene. When a node is mounted, it means that it has been rendered and is actively part of the scene's structure and content.
+     */
+    readonly Mounted: "mounted";
+    /**
+     * Status indicating that the node has been unmounted from the scene. When a node is unmounted, it means that it has been removed from the scene's structure and content, and is no longer actively rendered in the scene.
      */
-    toRevert: AreInstruction[];
+    readonly Unmounted: "unmounted";
 };
-type AreScene_Serialized = {
-    instructions: AreInstructionSerialized[];
-} & A_TYPES__Fragment_Serialized;
-type AreSceneStatusNames = typeof AreSceneStatuses[keyof typeof AreSceneStatuses];
 
-declare class AreMutation<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>> extends AreInstruction<T, S> {
-    get parent(): string;
-    get group(): string;
-    constructor(
+type AreNodeNewProps = AreSyntaxTokenMatch$1;
+type AreNodeFeatureNames = typeof AreNodeFeatures[keyof typeof AreNodeFeatures];
+type AreNodeStatusNames = typeof AreNodeStatuses[keyof typeof AreNodeStatuses];
+
+declare class AreNode extends A_Entity<AreNodeNewProps> {
     /**
-     * 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.
+     * The current status of the node, which can be used to track the lifecycle and rendering state of the node within the scene.
      */
-    serialized: S);
-    constructor(
+    status: AreNodeStatusNames;
     /**
-     * The name of the operation to be performed in Host.
+     * The opening string that defines the start of a node in the source. This is typically used for parsing and tokenizing the source to identify the structure and content of the node. The opening string can include the tag name, attributes, and other syntax that indicates the beginning of a node.
      */
-    name: string, 
+    protected _opening: string;
     /**
-     * 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.
+     * The closing string that defines the end of a node in the source. This is typically used for parsing and tokenizing the source to identify the structure and content of the node. The closing string can include the tag name, attributes, and other syntax that indicates the end of a node.
      */
-    parent: AreDeclaration, 
+    protected _closing: string;
     /**
-     * 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.
+     * The position of the node in the source string, which can be used for error reporting, debugging, and other purposes related to tracking the location of the node within the original source. The position is a character index identifying where the node is defined.
      */
-    payload?: T);
-    fromNew(newEntity: AreInstructionNewProps<T>): void;
-}
-
-declare class AreScene extends A_Fragment {
-    protected _groupToInstructionsMap: Map<string, Set<AreInstruction>>;
+    protected _position: number;
     /**
-     * Plan is a queue of changes that should be applied to render the node
-     *
-     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
+     * The payload associated with the node, which can include any additional data or metadata that is extracted during the tokenization process. The payload can be used to store custom information related to the node, such as directive arguments, binding expressions, or any other relevant data that may be needed for processing and rendering the node within the scene.
      */
-    protected _plan: Array<AreInstruction>;
+    protected _payload?: AreSyntaxTokenPayload$1;
     /**
-     * State is a list of instructions that are currently applied to the node,
-     * so it represents the current state of the node in the scene.
-     *
-     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
-     *
-     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
+     * Content string defined for the node — the inner content between delimiters.
+     * Example: `{{name}}`
      */
-    protected _state: Array<AreInstruction>;
-    protected _host: AreDeclaration | undefined;
+    protected _content: string;
     /**
-     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
+     * Markup string defined for the node
+     * Example: `<custom-component :prop="value"> <div>Inner Content</div> </custom-component>`
      */
-    protected _status: AreSceneStatusNames;
-    constructor(
+    protected _markup: string;
     /**
-     * Scene identity will be used to identify mounting point in the parent scene
+     * The scope associated with this node
+     * uses to store all nested fragments and entities like other AreNodes and Scene
      */
-    id: string | ASEID);
+    protected _scope: A_Scope;
     /**
-     * Scene ID that corresponds to the root node's ID (part of ASEID)
+     * Actual node identifier.
      */
     get id(): string;
     /**
-     * The scope where scene is registered. This scope is owned by AreNode
+     * Actual node type.
+     * By default it's a tag name
      */
-    get scope(): A_Scope;
+    get type(): string;
     /**
-     * The owner node of the scene, which is the node that registered the scene in its scope.
-     * This is typically the node that is responsible for rendering the scene and managing its lifecycle.
+     * Content string defined for the node — the inner content between delimiters.
+     * Example: `{{name}}`
      */
-    get owner(): AreNode;
+    get content(): string;
     /**
-     * It's a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle.
+     * Markup string defined for the node
+     * Example: `<custom-component :prop="value"> <div>Inner Content</div> </custom-component>`
      */
-    get host(): AreDeclaration | undefined;
+    get markup(): string;
     /**
-     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
+     * The scope associated with this node
+     * uses to store all nested fragments and entities like other AreNodes and Scene
      */
-    get status(): AreSceneStatusNames;
-    get isActive(): boolean;
-    get isInactive(): boolean;
+    get scope(): A_Scope;
     /**
-     * Returns All declaration instructions are registered in the scene scope. Since declaration instructions are the main instructions that represent the structure of the node, we have a separate getter for them to easily access and manage them in the scene.
+     * The attributes defined for the node, which can include static attributes, binding attributes, directive attributes, and event attributes. These attributes are extracted during tokenization and processed during the compilation phase to generate the corresponding SceneInstructions for rendering and updating the node in the scene.
      */
-    get declarations(): AreDeclaration[];
+    get attributes(): AreAttribute$1[];
     /**
-     * Returns All mutation instructions are registered in the scene scope. Mutation instructions are the instructions that represent the changes to be applied to the node, so we have a separate getter for them to easily access and manage them in the scene, especially when we want to apply or revert changes based on the mutations.
+     * A custom component associated with this node, which can be used to provide custom logic and behavior for the node. This component is typically defined in the context and can be resolved based on the node's type or other identifying information. The component can include its own content, markup, styles, and features that are specific to the functionality it provides.
+     *
+     * Example: If the node type is "custom-component", the corresponding component would be resolved from the context and can be used to provide custom rendering and behavior for nodes of that type.
+     *
+     * [!] Note: The component is optional and may not be defined for all nodes. If no component is associated with the node, it will be treated as a standard HTML element or a basic node without custom logic.
      */
-    get mutations(): AreMutation[];
+    get component(): Are$1 | undefined;
     /**
-     * Returns All instructions are registered in the scene scope.
+     * The parent node of this node, which is the node that registered the current node in its scope. This is typically the node that is responsible for rendering the current node and managing its lifecycle within the scene. The parent node can be used to access shared context, propagate events, and manage interactions between nodes in a hierarchical structure.
+     *
+     * Example: For a node defined as `<div><span>Child Node</span></div>`, the parent node of the `<span>` element would be the `<div>` element, which is responsible for rendering the `<span>` and managing its lifecycle within the scene.
      */
-    get instructions(): AreInstruction[];
+    get parent(): AreNode | undefined;
     /**
-     * Plan is a queue of changes that should be applied to render the node
+     * The child nodes of this node, which are typically defined in the markup and registered in the scope as child entities. These child nodes can represent nested elements or components within the node and can have their own content, markup, styles, and features. The child nodes are managed within the scope of the parent node and can be accessed and manipulated as needed for rendering, updating, and lifecycle management.
      *
-     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
+     * Example: For a node defined as `<div><span>Child Node</span></div>`, the child node would be the `<span>` element, which is registered as a child entity in the scope of the parent `<div>` node.
      */
-    get planned(): AreInstruction[];
+    get children(): (AreNode)[];
     /**
-     * State is a list of instructions that are currently applied to the node,
-     * so it represents the current state of the node in the scene.
-     *
-     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
-     *
-     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
+     * It returns the scene where the node exists, so it should be the scene of the rootNode,
+     * primary parent of this node.
      */
-    get applied(): AreInstruction[];
+    get scene(): AreScene$1;
+    protected _scene: AreScene$1;
+    fromNew(newEntity: AreNodeNewProps): void;
+    fromASEID(aseid: string | ASEID): void;
     /**
-     * Should return instructions to be reverted and to be applied.
-     * A difference between plan vs state is that plan is what should be applied to the scene,
-     * while state is what currently applied to the scene.
+     * Sets the content string for the node — the inner text/markup between the node's
+     * opening and closing delimiters. Content is processed by the rendering engine to
+     * generate the corresponding SceneInstructions for rendering the node.
      *
+     * @param content
      */
-    get changes(): AreSceneChanges;
-    activate(): void;
-    deactivate(): void;
+    setContent(content: string): void;
     /**
-     * Each scene has a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle. This method allows to set the host instruction for the scene, but it will throw an error if we try to set another host instruction while there is already a host instruction set, so we can ensure that there is only one host instruction for the scene at any given time.
+     * Sets the markup string for the node, which is the full raw matched string including delimiters. The markup can include HTML-like syntax, custom components, directives, and other features that are processed by the rendering engine to generate the corresponding SceneInstructions for rendering the node.
      *
-     * @param instruction
+     * @param markup
      */
-    setHost(instruction: AreDeclaration): void;
+    setMarkup(markup: string): void;
     /**
-     * Unsets the current host instruction from the scene.
+     * Adds a child node to the current node's scope and ensures the child inherits from this node's scope.
      *
-     * This method should be used when we want to remove the primary declaration instruction that represents the node in the scene, for example, when we want to unmount the node or when we want to replace it with another node. Unsetting the host instruction will allow us to set a new host instruction for the scene if needed.
+     * @param child - The node to add as a child
      */
-    removeHost(): void;
+    addChild(child: AreNode): void;
     /**
-     * Method that should register the instruction in the plan, so it will be rendered in the next render cycle.
+     * Removes a child node from the current node's scope. This is typically used when a child node is no longer needed or should be detached from the parent node. The method ensures that the child node is properly deregistered from the scope and any associated resources are cleaned up as necessary.
      *
-     * @param instruction
+     * @param node  - The child node to be removed from the current node's scope
+     */
+    removeChild(node: AreNode): void;
+    /**
+     * Executes initialization logic for the node, which typically involves setting up the node's scope, registering any necessary entities, and preparing the node for rendering and interaction within the scene. This method is called during the initial phase of the node's lifecycle and is responsible for ensuring that the node is properly initialized before it is compiled and rendered in the scene.
      */
-    plan(instruction: AreInstruction): void;
-    planBefore(instruction: AreInstruction, beforeInstruction: AreInstruction): void;
-    planAfter(instruction: AreInstruction, afterInstruction: AreInstruction): void;
-    moveBefore(instruction: AreInstruction, beforeInstruction: AreInstruction): void;
-    moveAfter(instruction: AreInstruction, afterInstruction: AreInstruction): void;
+    init(): void;
     /**
-     * Allows to remove instruction from the plan, so it will not be rendered anymore, but it will still be registered in the scene scope, so it can be planned again if needed.
+     * Loads the node, which typically involves executing any necessary setup or initialization logic to prepare the node for rendering and interaction within the scene. This may include processing the node's content, markup, styles, and features to generate the corresponding SceneInstructions, as well as setting up any event listeners or reactive properties as needed.
+     */
+    load(): Promise<any>;
+    /**
+     * Tokenizes the node content, which typically involves parsing the raw content string to identify the structure, child nodes, attributes, directives, and other features. This process is essential for breaking down the content into its constituent parts and preparing it for further processing during the compilation phase. The tokenization process can involve creating child nodes, extracting attributes and their values, and identifying any directives or bindings that need to be processed during rendering.
+     */
+    tokenize(): void;
+    /**
+     * Transforms the node, which typically involves executing any necessary logic to reshape the node's structure or content before it is compiled and rendered in the scene. This may include applying any transformations defined by directives, processing any dynamic content or expressions, and performing any other necessary tasks to ensure that the node is properly prepared for compilation and rendering based on its content, markup, styles, and features.
+     */
+    transform(): void;
+    /**
+     * Compile the node. This method should transform the node's content, markup, and styles into a set of SceneInstructions that can be executed to render the node in the scene. The compile method is responsible for processing the node's features, attributes, directives, and other properties to generate the necessary instructions for rendering and updating the node in response to changes in state or context.
      *
-     * @param instruction
+     * [!] Note: The compile method should ensure that the node's scope is properly inherited from the context scope before processing, and it should handle any errors that may occur during compilation to ensure that the node can be rendered correctly in the scene.
      */
-    unPlan(instruction: AreInstruction): void;
+    compile(): void;
     /**
-     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
+     * Mounts the node, which typically involves executing any necessary logic to render the node in the scene and to set up any interactions or behaviors associated with the node. This may include applying the generated SceneInstructions from the compile phase, attaching event listeners, and performing any other necessary tasks to ensure that the node is properly rendered and functional within the scene.
      *
-     * @param instruction
-     * @returns
+     * [!] Note: The mount method should ensure that the node's scope is properly inherited from the context scope before performing any mounting logic, and it should handle any errors that may occur during mounting to ensure that the node can be rendered correctly in the scene.
      */
-    getPlanned(instruction: AreInstruction): AreInstruction | undefined;
+    mount(): void;
     /**
-     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
+     * Interprets the node, which typically involves executing any necessary logic to process the node's features, attributes, directives, and other properties to generate the corresponding SceneInstructions for rendering and updating the node in response to changes in state or context. This method is responsible for ensuring that the node is properly interpreted based on its content, markup, styles, and features to enable dynamic behavior and responsiveness within the scene.
      *
-     * @param instruction
-     * @returns
+     * [!] Note: The interpret method should NOT go though own child, since it may be used by both mount and update operations!
      */
-    isInPlan(instruction: AreInstruction): boolean;
+    interpret(): void;
     /**
-     * Method moves the instruction to state to keep it applied and to be able to revert it later if needed. The instruction should be already registered in the scene scope and planned to be applied, otherwise it will not be applied.
+     * Updates the node, which typically involves executing any necessary logic to update the node's rendering and behavior in response to changes in state, context, or other factors. This may include reapplying SceneInstructions, updating event listeners, and performing any other necessary tasks to ensure that the node remains functional and correctly rendered within the scene as changes occur.
      *
-     * @param instruction
+     * [!] Note: The update method should ensure that the node's scope is properly inherited from the context scope before performing any update logic, and it should handle any errors that may occur during updating to ensure that the node can be updated correctly in the scene.
      */
-    apply(instruction: AreInstruction): void;
+    update(): void;
     /**
-     * Method moves the instruction from state to unapply it and to be able to apply it later if needed. The instruction should be already registered in the scene scope and applied, otherwise it will not be unapplied.
+     * Unmounts the node, which typically involves executing any necessary logic to remove the node from the scene and to clean up any resources associated with the node. This may include reverting any applied SceneInstructions, detaching event listeners, and performing any other necessary tasks to ensure that the node is properly removed from the scene and that resources are released as needed.
      *
-     * @param instruction
+     * [!] Note: The unmount method should ensure that the node's scope is properly inherited from the context scope before performing any unmounting logic, and it should handle any errors that may occur during unmounting to ensure that the node can be removed correctly from the scene.
      */
-    unApply(instruction: AreInstruction): void;
+    unmount(): void;
+    cloneWithScope<T extends AreNode = AreNode>(this: T): T;
+    reset(): void;
+    clone<T extends AreNode = AreNode>(this: T): T;
     /**
-     * Checks if the instruction is already in the state, so it is currently applied to the scene.
+     * Emits an event or a scope to the node, which can be used to trigger event handlers or to provide additional context for processing within the node. The method can accept either an AreEvent instance or an A_Scope instance, and it will handle the emission accordingly. This allows for flexible communication and interaction within the node's context, enabling dynamic behavior and responsiveness based on events or changes in scope.
      *
-     * @param instruction
-     * @returns
+     * @param scope - The scope or event to be emitted to the node
      */
-    getApplied(instruction: AreInstruction): AreInstruction | undefined;
+    emit(scope: A_Scope): any;
+    emit(event: AreEvent$1): any;
     /**
-     * Checks if the instruction is already in the state, so it is currently applied to the scene.
+     * Destroys the node, which typically involves executing any necessary cleanup logic to remove the node from the scene and to free up any resources associated with the node. This may include deregistering the node from its scope, removing any event listeners or reactive properties, and performing any other necessary cleanup tasks to ensure that the node is properly removed from the scene and that resources are released as needed.
      *
-     * @param instruction
-     * @returns
+     * [!] Note: The destroy method should ensure that the node's scope is properly inherited from the context scope before performing any cleanup, and it should handle any errors that may occur during destruction to ensure that resources are released correctly.
      */
-    isApplied(instruction: AreInstruction): boolean;
+    destroy(): Promise<any>;
     /**
-     * Method that should reset the scene to the initial state, so it will clear the plan and state, but it will not deregister the instructions from the scene scope, so they will still be registered in the scene and can be planned and applied again if needed.
+     * Method to ensure that the current scope is inherited from the context scope
      *
+     * @throws A_Error if the scope is not inherited from the context scope
      */
-    reset(): void;
+    protected checkScopeInheritance(): void;
 }
 
 declare const AreAttributeFeatures: {
@@ -675,7 +641,7 @@ declare class AreAttribute extends A_Entity<AreAttribute_Init, AreAttribute_Seri
     /**
      * The owner node of the attribute, which is the node that the attribute is attached to. This can be used to access the properties and features of the owner node, as well as to determine the context in which the attribute is being used. For example, if the attribute is attached to a button element, the owner would be that button node, and the attribute could use this information to modify the button's behavior or appearance based on its content and context.
      */
-    get owner(): AreNode;
+    get owner(): AreNode$1;
     /**
      * Initializes the attribute based on the provided properties. This method is called when a new attribute is created and should set up the attribute's state based on the provided properties. It can also be used to generate a unique ASEID for the attribute based on its name and content, which can be used for caching and identification purposes within the ARE framework.
      *
@@ -720,53 +686,7 @@ declare class AreAttribute extends A_Entity<AreAttribute_Init, AreAttribute_Seri
     validate(scope?: A_Scope): void;
 }
 
-declare class AreStore<T extends Record<string, any> = Record<string, any>> extends A_ExecutionContext<T> {
-    protected dependencies: Map<string, Set<AreStoreWatchingEntity>>;
-    protected _keys: Set<keyof T>;
-    /**
-     * Allows to define a pure function that will be executed in the context of the store, so it can access the store's data and methods, but it won't have access to the component's scope or other features. This can be useful for example for defining a function that will update the store's data based on some logic, without having access to the component's scope or other features, so we can keep the store's logic separate from the component's logic.
-     */
-    static get Function(): <T extends Are>(target: T, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    get owner(): AreNode;
-    get parent(): AreStore | undefined;
-    get context(): AreContext;
-    constructor(aseid: ASEID | string);
-    get watchers(): Set<AreStoreWatchingEntity>;
-    get keys(): Set<keyof T>;
-    watch(instruction: AreStoreWatchingEntity): void;
-    unwatch(instruction: AreStoreWatchingEntity): void;
-    set<K extends keyof T>(values: Partial<T>): this;
-    set<P extends A_TYPES__Paths<T>>(key: P, value: AreStorePathValue<T, P>): this;
-    get<K extends keyof T>(key: K): T[K] | undefined;
-    protected setAsObject(values: Partial<T>): this;
-    protected setAsKeyValue<K extends keyof T, P extends A_TYPES__Paths<T>>(key: K | P, value: T[K] | AreStorePathValue<T, P>): this;
-    /**
-     * Notifies instructions — immediately or deferred if inside a batch.
-     */
-    private notify;
-    /**
-     * Removes an instruction from all dependency sets.
-     * Called when an instruction is reverted/destroyed.
-     */
-    unregister(instruction: AreStoreWatchingEntity): void;
-    /**
-     * Normalizes a path once — reused in both get and set.
-     */
-    private normalizePath;
-    /**
-     * Extracts direct children of the current markup level into typed instances.
-     * No tree walking, recursion, or nested parsing — just direct children.
-     */
-    extractPathSegments(path: string): string[];
-    /**
-     * Method allows to initialize all extensions defined in the component with @AreStore.Function decorator, so we can use them in the store's context. This method should be called in the component's constructor after super() call, so the store will have access to the component's instance and its properties.
-     *
-     * @param component
-     */
-    loadExtensions(component: Are): void;
-}
-
-interface AreSyntaxTokenRules<T extends AreNode = AreNode> {
+interface AreSyntaxTokenRules<T extends AreNode$1 = AreNode$1> {
     /** Opening delimiter e.g. '<', '{{', '<!--', '{' */
     opening?: string;
     /** Closing delimiter e.g. '>', '}}', '-->', '}' */
@@ -836,599 +756,644 @@ interface AreSyntaxInitOptions {
     strictMode?: boolean;
 }
 type AreSyntaxCompiledExpression = {
-    execute: (store: AreStore, scope?: Record<string, any>) => any;
+    execute: (store: AreStore$1, scope?: Record<string, any>) => any;
     isCallable: boolean;
 };
 
-declare const AreNodeFeatures: {
+declare class AreSyntax extends A_Fragment {
     /**
-     * Feature that is called to handle before init lifecycle of the element node
+     * Max allowed length of an expression string to prevent excessively long inputs that could lead to performance issues or abuse.
      */
-    readonly onBeforeInit: "_AreNode_onBeforeInit";
+    private readonly MAX_LENGTH;
     /**
-     * Feature that is called to init the element node
+     * Max allowed nesting depth of parentheses, brackets, and braces in expressions to prevent excessively complex inputs that could lead to performance issues or abuse. Default is 5 levels of nesting.
      */
-    readonly onInit: "_AreNode_onInit";
+    private readonly MAX_DEPTH;
     /**
-     *
+     * List of regex patterns that are blocked in expressions to prevent access to unsafe or sensitive features. This includes patterns for global objects, functions, and syntax that could be used for malicious purposes (e.g. "eval", "Function", "fetch", "XMLHttpRequest", "import", "require", "document", "window", "globalThis", "global", "process", "__proto__", "constructor", "prototype"). Expressions containing any of these patterns will be rejected during validation.
      */
-    readonly onAfterInit: "_AreNode_onAfterInit";
+    private readonly BLOCKED_PATTERNS;
     /**
-     * Feature that is called to handle before mount lifecycle of the element node
+     * Set of global identifiers that are blocked in expressions to prevent access to unsafe or sensitive features. This includes global objects and functions that could be used for malicious purposes (e.g. "eval", "Function", "fetch", "XMLHttpRequest", "document", "window", "globalThis", "global", "process", "setTimeout", "setInterval", "localStorage", "sessionStorage", "indexedDB", "WebSocket", "Worker"). Accessing any of these identifiers in an expression will be rejected during validation.
      */
-    readonly onBeforeMount: "_AreNode_onBeforeMount";
+    private readonly BLOCKED_GLOBALS;
     /**
-     * Feature that is called to mount the element node
+     * Regex pattern that defines the allowed characters in expressions. This pattern allows letters, digits, whitespace, and common operators and punctuation used in JavaScript expressions. Expressions containing characters that do not match this pattern will be rejected during validation to prevent injection of potentially harmful code.
      */
-    readonly onMount: "_AreNode_onMount";
+    private readonly ALLOWED_CHARS;
     /**
-     * Feature that is called to handle after mount lifecycle of the element node
+     * Simple dot-path identifier pattern (e.g. "name", "user.name", "user.profile.name").
+     * Matches strings that consist solely of identifier characters separated by dots.
      */
-    readonly onAfterMount: "_AreNode_onAfterMount";
+    private readonly SIMPLE_PATH;
     /**
-     * Feature that is called to handle before update lifecycle of the element node
+     * Compiled expression — a pre-parsed function ready for repeated execution.
+     * Created once via compile(), reused on every apply/click.
      */
-    readonly onBeforeUpdate: "_AreNode_onBeforeUpdate";
+    private readonly _rules;
+    private readonly _trimWhitespace;
+    private readonly _strictMode;
+    constructor(config?: Partial<AreSyntaxInitOptions>);
     /**
-     * Feature that is called to handle update lifecycle of the element node
+     * Get the array of token rules that define the syntax for parsing templates. Each rule specifies how to identify and process a particular type of token (e.g. interpolation, directive, comment) within templates. The rules are checked in order of priority, allowing for flexible and customizable parsing behavior.
      */
-    readonly onUpdate: "_AreNode_onUpdate";
+    get rules(): AreSyntaxTokenRules<AreNode>[];
     /**
-     * Feature that is called to handle after update lifecycle of the element node
+     * Indicates whether leading and trailing whitespace should be trimmed from token content. When enabled, any whitespace at the start or end of the content captured by a token will be removed before further processing. This can help prevent issues with unintended spaces affecting rendering or logic, especially in cases like interpolations or directives where extra whitespace may be common. Default is true.
      */
-    readonly onAfterUpdate: "_AreNode_onAfterUpdate";
+    get trimWhitespace(): boolean;
     /**
-     * Feature that is called to handle before unmount lifecycle of the element node
+     * Indicates whether the parser should throw an error when it encounters unclosed tokens. When enabled, if the parser finds an opening delimiter without a corresponding closing delimiter (e.g. an unclosed interpolation or directive), it will throw an error instead of silently ignoring it. This can help catch syntax errors and ensure that templates are well-formed. Default is true.
      */
-    readonly onBeforeUnmount: "_AreNode_onBeforeUnmount";
+    get strictMode(): boolean;
     /**
-     * Feature that is called to unmount the element node
-     */
-    readonly onUnmount: "_AreNode_onUnmount";
-    /**
-     * Feature that is called to handle after unmount lifecycle of the element node
-     */
-    readonly onAfterUnmount: "_AreNode_onAfterUnmount";
-    /**
-     * Feature that is called to handle before destroy lifecycle of the element node
-     */
-    readonly onBeforeDestroy: "_AreNode_onBeforeDestroy";
-    /**
-     * Feature that is called to handle before destroy lifecycle of the element node
-     */
-    readonly onDestroy: "_AreNode_onDestroy";
-    /**
-     * Feature that is called to handle after destroy lifecycle of the element node
+     * Compiles an expression string into a reusable executor.
+     * Performs validation and Function construction once.
+     * Use when the same expression will be evaluated multiple times
+     * e.g. event handlers, instructions that re-apply on store changes.
+     *
+     * @example
+     *   // compile once at apply() time
+     *   const compiled = AreCommonHelper.compile('(e) => !!pageTitle ? $testHandler(e, item) : null')
+     *
+     *   // execute on every click — no re-parsing, no re-validation
+     *   element.addEventListener('click', (e) => {
+     *       const fn = compiled.execute(store, { $testHandler: handler, item })
+     *       if (typeof fn === 'function') fn(e)
+     *   })
      */
-    readonly onAfterDestroy: "_AreNode_onAfterDestroy";
+    compile(expr: string): AreSyntaxCompiledExpression;
     /**
-     * Feature that is called to tokenize the element node template and extract its content, attributes, and child nodes.
+     * Evaluates an expression string against the provided store.
+     * Automatically determines whether the result should be callable
+     * based on the shape of the expression.
+     *
+     * Returns the raw value for plain expressions (interpolations, bindings).
+     * Returns a bound function for callable expressions (event handlers).
+     *
+     * @param expr  Expression string to evaluate.
+     * @param store AreStore used for identifier resolution.
+     * @param scope Optional extra bindings checked **before** the store.
+     *              Useful for injecting event-specific values (`$event`, `element`)
+     *              or emit wrappers (`$handleClick`).
+     *
+     * @example
+     *   // simple value
+     *   evaluate('user.name', store)
+     *
+     *   // with emit wrapper
+     *   evaluate('$handleClick($event, user.name)', store, {
+     *       $event: domEvent,
+     *       $handleClick: (...args) => node.emit(new AreEvent('handleClick', args)),
+     *   })
+     *
+     *   // arrow with conditional
+     *   evaluate('(e) => isValid(user.name) ? $handleClick(e) : null', store, {
+     *       $handleClick: (...args) => node.emit(new AreEvent('handleClick', args)),
+     *   })
      */
-    readonly onTokenize: "_AreNode_onTokenize";
+    evaluate(expr: string, store: AreStore$1, scope?: Record<string, any>): any;
     /**
-     * Feature that is called to transform the element node template, markup, styles, and data into a format that can be used for compilation. This feature is responsible for processing the raw template and extracting the necessary information to create the render plan and instructions for the node.
+     * Extracts $-prefixed handler names from an expression.
+     * These represent event emission targets, not store references.
+     *
+     * Examples:
+     *   "$handleClick"                                     → Set(["handleClick"])
+     *   "$handleClick(user.name)"                           → Set(["handleClick"])
+     *   "(e) => isValid(user.name) ? $handleClick(e) : null" → Set(["handleClick"])
      */
-    readonly onTransform: "_AreNode_onTransform";
+    extractEmitHandlers(expr: string): Set<string>;
+    private isCallableExpression;
+    private validate;
+    private checkDepth;
+    private createSandbox;
+    private nestedHandler;
+    private assertSafeKey;
+    private execute;
+}
+
+declare class AreSyntaxError extends A_Error {
+    static readonly SyntaxParseError = "Are Syntax Parse Error";
+    static readonly SyntaxNotSupportedError = "Are Syntax Not Supported Error";
+    static readonly MethodNotImplementedError = "Are Syntax Method Not Implemented Error";
+}
+
+declare class AreTokenizer extends A_Component {
     /**
-     * Event fired when the element node is interpreted
+     * Get the AreSyntax from the current scope. The AreSyntax defines the syntax rules and structures for tokenizing templates. It provides mechanisms for parsing and interpreting templates, attributes, directives, interpolations, and event listeners, enabling dynamic and interactive UI rendering within the ARE framework. If no AreSyntax is found in the scope, an error is thrown indicating that AreTokenizer requires an AreSyntax to function properly.
      */
-    readonly onInterpret: "_AreNode_onInterpret";
+    protected get config(): AreSyntax$1;
     /**
-     * Feature that is called to compile the element node
+     * Instantiate AreNodes based on the token matches obtained from scanning the source template. This method takes the raw source string from the context, scans it for tokens using the defined syntax rules, and creates corresponding AreNode instances for each matched token. The resulting array of AreNodes represents the structured representation of the template, which can then be used for further processing, such as rendering or applying scene instructions.
+     *
+     *
+     * @param context
+     * @returns
      */
-    readonly onCompile: "_AreNode_onCompile";
+    instantiate<T extends AreNode$1>(context: AreContext$1): void;
+    tokenize(node: AreNode$1, context: AreContext$1, logger?: A_Logger): void;
+    protected scan(source: string, from: number, to: number, context: AreContext$1): AreSyntaxTokenMatch$1[];
+    protected findNextMatch(source: string, from: number, to: number): AreSyntaxTokenMatch$1 | null;
+    protected matchRule(source: string, rule: AreSyntaxTokenRules$1, from: number, to: number): AreSyntaxTokenMatch$1 | null;
+    protected matchStandardRule(source: string, rule: AreSyntaxTokenRules$1, from: number, to: number): AreSyntaxTokenMatch$1 | null;
+    protected matchPrefixedRule(source: string, rule: AreSyntaxTokenRules$1, from: number, to: number): AreSyntaxTokenMatch$1 | null;
+    protected findMatchingClose(source: string, opening: string, closing: string, from: number, to: number): number;
+    protected buildMatch(rule: AreSyntaxTokenRules$1, raw: string, content: string, position: number, closingUsed: string): AreSyntaxTokenMatch$1;
+    protected tryPlainText(raw: string, position: number): AreSyntaxTokenMatch$1 | null;
+    protected findRuleForMatch(match: AreSyntaxTokenMatch$1): AreSyntaxTokenRules$1 | undefined;
+}
+
+declare class AreTokenizerError extends A_Error {
+}
+
+declare class AreCompiler extends A_Component {
     /**
-     * Feature that is called to handle events
+     * Defines a custom method for compiling a node into a set of SceneInstructions. This method is called during the compilation phase of the ARE component and should perform any necessary transformations on the node and its attributes to generate the appropriate instructions for rendering. This can include tasks such as processing directives, evaluating expressions, and generating instructions for dynamic content based on the node's properties and context.
+     *
+     * @param node
      */
-    readonly onEmit: "_AreNode_onEmit";
-};
-declare const AreNodeStatuses: {
+    static Compile<T extends AreNode$1>(node: A_TYPES__Entity_Constructor<T>): any;
     /**
-     * Status indicating that the node is pending compilation. When a node is in the pending status, it means that it has been created but has not yet been compiled. During this phase, the node is typically being prepared for compilation, which may involve setting up its template, markup, styles, and any associated data or context. Once the node is ready for compilation, its status will change to "compiling".
+     * Defines a custom method for compiling an attribute into a set of SceneInstructions. This method is called during the compilation phase of the ARE component and should perform any necessary transformations on the attribute to generate the appropriate instructions for rendering. This can include tasks such as processing directives, evaluating expressions, and generating instructions for dynamic content based on the attribute's properties and context.
+     *
+     * @param attribute
      */
-    readonly Pending: "pending";
+    static Compile<T extends AreAttribute$1>(attribute: A_TYPES__Entity_Constructor<T>): any;
+    compile(node: AreNode$1, scene: AreScene$1, logger?: A_Logger, ...args: any[]): void;
+}
+
+declare class AreCompilerError extends A_Error {
+    static readonly RenderError = "Are Compiler Render Error";
+    static readonly CompilationError = "Are Compiler Compilation Error";
+}
+
+declare class AreTransformer extends A_Component {
+    transform(node: AreNode$1, scope: A_Scope, scene: AreScene$1, ...args: any[]): void;
+}
+
+declare class AreInterpreter extends A_Component {
     /**
-     * Status indicating that the node is in the process of being compiled. During this status, the node is being analyzed and transformed based on its template, markup, and styles to generate the necessary instructions for rendering and updating the node in the scene.
+     * 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
      */
-    readonly Compiling: "compiling";
+    static Apply(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
     /**
-     * Status indicating that the node has been compiled and is ready to be rendered. In this status, the node has generated all the necessary instructions and is prepared to be mounted in the scene.
+     * 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
      */
-    readonly Compiled: "compiled";
+    static Update(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
     /**
-     * Status indicating that the node is currently mounted in the scene. When a node is mounted, it means that it has been rendered and is actively part of the scene's structure and content.
+     * 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
      */
-    readonly Mounted: "mounted";
+    static Revert(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
     /**
-     * Status indicating that the node has been unmounted from the scene. When a node is unmounted, it means that it has been removed from the scene's structure and content, and is no longer actively rendered in the scene.
+     * 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
      */
-    readonly Unmounted: "unmounted";
+    interpret(scene: AreScene$1): void;
+    protected applyInstruction(instruction: AreInstruction$1, interpreter: AreInterpreter, store: AreStore$1, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected updateInstruction(instruction: AreInstruction$1, interpreter: AreInterpreter, store: AreStore$1, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    protected revertInstruction(instruction: AreInstruction$1, interpreter: AreInterpreter, store: AreStore$1, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+}
+
+declare class AreInterpreterError extends A_Error {
+}
+
+declare const AreStoreAreComponentMetaKeys: {
+    readonly StoreExtensions: "_AreStore_StoreExtensions";
 };
 
-type AreNodeNewProps = AreSyntaxTokenMatch;
-type AreNodeFeatureNames = typeof AreNodeFeatures[keyof typeof AreNodeFeatures];
-type AreNodeStatusNames = typeof AreNodeStatuses[keyof typeof AreNodeStatuses];
+type AreStorePathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? AreStorePathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+type AreStoreWatchingEntity = {
+    update(...args: any[]): void;
+};
+type AreStoreAreComponentMetaKeyNames = typeof AreStoreAreComponentMetaKeys[keyof typeof AreStoreAreComponentMetaKeys];
 
-declare class AreNode extends A_Entity<AreNodeNewProps> {
-    /**
-     * The current status of the node, which can be used to track the lifecycle and rendering state of the node within the scene.
-     */
-    status: AreNodeStatusNames;
-    /**
-     * The opening string that defines the start of a node in the source. This is typically used for parsing and tokenizing the source to identify the structure and content of the node. The opening string can include the tag name, attributes, and other syntax that indicates the beginning of a node.
-     */
-    protected _opening: string;
-    /**
-     * The closing string that defines the end of a node in the source. This is typically used for parsing and tokenizing the source to identify the structure and content of the node. The closing string can include the tag name, attributes, and other syntax that indicates the end of a node.
-     */
-    protected _closing: string;
-    /**
-     * The position of the node in the source string, which can be used for error reporting, debugging, and other purposes related to tracking the location of the node within the original source. The position is a character index identifying where the node is defined.
-     */
-    protected _position: number;
-    /**
-     * The payload associated with the node, which can include any additional data or metadata that is extracted during the tokenization process. The payload can be used to store custom information related to the node, such as directive arguments, binding expressions, or any other relevant data that may be needed for processing and rendering the node within the scene.
-     */
-    protected _payload?: AreSyntaxTokenPayload;
-    /**
-     * Content string defined for the node — the inner content between delimiters.
-     * Example: `{{name}}`
-     */
-    protected _content: string;
-    /**
-     * Markup string defined for the node
-     * Example: `<custom-component :prop="value"> <div>Inner Content</div> </custom-component>`
-     */
-    protected _markup: string;
-    /**
-     * The scope associated with this node
-     * uses to store all nested fragments and entities like other AreNodes and Scene
-     */
-    protected _scope: A_Scope;
+declare class AreStore<T extends Record<string, any> = Record<string, any>> extends A_ExecutionContext<T> {
+    protected dependencies: Map<string, Set<AreStoreWatchingEntity>>;
+    protected _keys: Set<keyof T>;
     /**
-     * Actual node identifier.
+     * Allows to define a pure function that will be executed in the context of the store, so it can access the store's data and methods, but it won't have access to the component's scope or other features. This can be useful for example for defining a function that will update the store's data based on some logic, without having access to the component's scope or other features, so we can keep the store's logic separate from the component's logic.
      */
-    get id(): string;
+    static get Function(): <T extends Are$1>(target: T, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    get owner(): AreNode$1;
+    get parent(): AreStore | undefined;
+    get context(): AreContext$1;
+    constructor(aseid: ASEID | string);
+    get watchers(): Set<AreStoreWatchingEntity>;
+    get keys(): Set<keyof T>;
+    watch(instruction: AreStoreWatchingEntity): void;
+    unwatch(instruction: AreStoreWatchingEntity): void;
+    set<K extends keyof T>(values: Partial<T>): this;
+    set<P extends A_TYPES__Paths<T>>(key: P, value: AreStorePathValue<T, P>): this;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    protected setAsObject(values: Partial<T>): this;
+    protected setAsKeyValue<K extends keyof T, P extends A_TYPES__Paths<T>>(key: K | P, value: T[K] | AreStorePathValue<T, P>): this;
     /**
-     * Actual node type.
-     * By default it's a tag name
+     * Notifies instructions — immediately or deferred if inside a batch.
      */
-    get type(): string;
+    private notify;
     /**
-     * Content string defined for the node — the inner content between delimiters.
-     * Example: `{{name}}`
+     * Removes an instruction from all dependency sets.
+     * Called when an instruction is reverted/destroyed.
      */
-    get content(): string;
+    unregister(instruction: AreStoreWatchingEntity): void;
     /**
-     * Markup string defined for the node
-     * Example: `<custom-component :prop="value"> <div>Inner Content</div> </custom-component>`
+     * Normalizes a path once — reused in both get and set.
      */
-    get markup(): string;
+    private normalizePath;
     /**
-     * The scope associated with this node
-     * uses to store all nested fragments and entities like other AreNodes and Scene
+     * Extracts direct children of the current markup level into typed instances.
+     * No tree walking, recursion, or nested parsing — just direct children.
      */
-    get scope(): A_Scope;
+    extractPathSegments(path: string): string[];
     /**
-     * The attributes defined for the node, which can include static attributes, binding attributes, directive attributes, and event attributes. These attributes are extracted during tokenization and processed during the compilation phase to generate the corresponding SceneInstructions for rendering and updating the node in the scene.
+     * Method allows to initialize all extensions defined in the component with @AreStore.Function decorator, so we can use them in the store's context. This method should be called in the component's constructor after super() call, so the store will have access to the component's instance and its properties.
+     *
+     * @param component
      */
-    get attributes(): AreAttribute[];
+    loadExtensions(component: Are$1): void;
+}
+
+declare class AreEvent<T extends Record<string, any> = Record<string, any>> extends A_ExecutionContext<T> {
+}
+
+/**
+ * Properties for the AreEvent context
+ *
+ */
+type AreEventProps<T = any> = {
     /**
-     * A custom component associated with this node, which can be used to provide custom logic and behavior for the node. This component is typically defined in the context and can be resolved based on the node's type or other identifying information. The component can include its own content, markup, styles, and features that are specific to the functionality it provides.
-     *
-     * Example: If the node type is "custom-component", the corresponding component would be resolved from the context and can be used to provide custom rendering and behavior for nodes of that type.
-     *
-     * [!] Note: The component is optional and may not be defined for all nodes. If no component is associated with the node, it will be treated as a standard HTML element or a basic node without custom logic.
+     * The data associated with the event
      */
-    get component(): Are | undefined;
+    data: T;
     /**
-     * The parent node of this node, which is the node that registered the current node in its scope. This is typically the node that is responsible for rendering the current node and managing its lifecycle within the scene. The parent node can be used to access shared context, propagate events, and manage interactions between nodes in a hierarchical structure.
-     *
-     * Example: For a node defined as `<div><span>Child Node</span></div>`, the parent node of the `<span>` element would be the `<div>` element, which is responsible for rendering the `<span>` and managing its lifecycle within the scene.
+     * The name of the event
      */
-    get parent(): AreNode | undefined;
+    event: string;
+};
+
+declare const AreSceneStatuses: {
+    Active: string;
+    Inactive: string;
+    Destroyed: string;
+};
+
+type AreSceneChanges = {
     /**
-     * The child nodes of this node, which are typically defined in the markup and registered in the scope as child entities. These child nodes can represent nested elements or components within the node and can have their own content, markup, styles, and features. The child nodes are managed within the scope of the parent node and can be accessed and manipulated as needed for rendering, updating, and lifecycle management.
-     *
-     * Example: For a node defined as `<div><span>Child Node</span></div>`, the child node would be the `<span>` element, which is registered as a child entity in the scope of the parent `<div>` node.
+     * An array of instructions that are planned to be applied to the scene. These instructions represent the changes that will be made to the scene when they
      */
-    get children(): (AreNode)[];
+    toApply: AreInstruction$1[];
     /**
-     * It returns the scene where the node exists, so it should be the scene of the rootNode,
-     * primary parent of this node.
+     * An array of instructions that are planned to be reverted from the scene. These instructions represent the changes that will be undone from the scene when they are reverted, allowing for a rollback of changes if needed.
      */
-    get scene(): AreScene;
-    protected _scene: AreScene;
-    fromNew(newEntity: AreNodeNewProps): void;
-    fromASEID(aseid: string | ASEID): void;
+    toRevert: AreInstruction$1[];
+};
+type AreScene_Serialized = {
+    instructions: AreInstructionSerialized$1[];
+} & A_TYPES__Fragment_Serialized;
+type AreSceneStatusNames = typeof AreSceneStatuses[keyof typeof AreSceneStatuses];
+
+declare class AreScene extends A_Fragment {
+    protected _groupToInstructionsMap: Map<string, Set<AreInstruction$1>>;
     /**
-     * Sets the content string for the node — the inner text/markup between the node's
-     * opening and closing delimiters. Content is processed by the rendering engine to
-     * generate the corresponding SceneInstructions for rendering the node.
+     * Plan is a queue of changes that should be applied to render the node
      *
-     * @param content
+     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
      */
-    setContent(content: string): void;
+    protected _plan: Array<AreInstruction$1>;
     /**
-     * Sets the markup string for the node, which is the full raw matched string including delimiters. The markup can include HTML-like syntax, custom components, directives, and other features that are processed by the rendering engine to generate the corresponding SceneInstructions for rendering the node.
+     * State is a list of instructions that are currently applied to the node,
+     * so it represents the current state of the node in the scene.
      *
-     * @param markup
+     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
+     *
+     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
      */
-    setMarkup(markup: string): void;
+    protected _state: Array<AreInstruction$1>;
+    protected _host: AreDeclaration$1 | undefined;
     /**
-     * Adds a child node to the current node's scope and ensures the child inherits from this node's scope.
-     *
-     * @param child - The node to add as a child
+     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
      */
-    addChild(child: AreNode): void;
+    protected _status: AreSceneStatusNames;
+    constructor(
     /**
-     * Removes a child node from the current node's scope. This is typically used when a child node is no longer needed or should be detached from the parent node. The method ensures that the child node is properly deregistered from the scope and any associated resources are cleaned up as necessary.
-     *
-     * @param node  - The child node to be removed from the current node's scope
+     * Scene identity will be used to identify mounting point in the parent scene
      */
-    removeChild(node: AreNode): void;
+    id: string | ASEID);
     /**
-     * Executes initialization logic for the node, which typically involves setting up the node's scope, registering any necessary entities, and preparing the node for rendering and interaction within the scene. This method is called during the initial phase of the node's lifecycle and is responsible for ensuring that the node is properly initialized before it is compiled and rendered in the scene.
+     * Scene ID that corresponds to the root node's ID (part of ASEID)
      */
-    init(): void;
+    get id(): string;
     /**
-     * Loads the node, which typically involves executing any necessary setup or initialization logic to prepare the node for rendering and interaction within the scene. This may include processing the node's content, markup, styles, and features to generate the corresponding SceneInstructions, as well as setting up any event listeners or reactive properties as needed.
+     * The scope where scene is registered. This scope is owned by AreNode
      */
-    load(): Promise<any>;
+    get scope(): A_Scope;
     /**
-     * Tokenizes the node content, which typically involves parsing the raw content string to identify the structure, child nodes, attributes, directives, and other features. This process is essential for breaking down the content into its constituent parts and preparing it for further processing during the compilation phase. The tokenization process can involve creating child nodes, extracting attributes and their values, and identifying any directives or bindings that need to be processed during rendering.
+     * The owner node of the scene, which is the node that registered the scene in its scope.
+     * This is typically the node that is responsible for rendering the scene and managing its lifecycle.
      */
-    tokenize(): void;
+    get owner(): AreNode$1;
     /**
-     * Transforms the node, which typically involves executing any necessary logic to reshape the node's structure or content before it is compiled and rendered in the scene. This may include applying any transformations defined by directives, processing any dynamic content or expressions, and performing any other necessary tasks to ensure that the node is properly prepared for compilation and rendering based on its content, markup, styles, and features.
+     * It's a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle.
      */
-    transform(): void;
+    get host(): AreDeclaration$1 | undefined;
     /**
-     * Compile the node. This method should transform the node's content, markup, and styles into a set of SceneInstructions that can be executed to render the node in the scene. The compile method is responsible for processing the node's features, attributes, directives, and other properties to generate the necessary instructions for rendering and updating the node in response to changes in state or context.
-     *
-     * [!] Note: The compile method should ensure that the node's scope is properly inherited from the context scope before processing, and it should handle any errors that may occur during compilation to ensure that the node can be rendered correctly in the scene.
+     * Scene status is used to determine the current lifecycle stage of the scene, which can be 'active', 'inactive' or 'destroyed'. This status can be used to control the behavior of the scene and its instructions, for example, we can prevent applying new instructions to an inactive or destroyed scene, or we can trigger certain actions when the scene becomes active or inactive. The default status of the scene is 'inactive', which means that the scene is not yet rendered and its instructions are not applied, and it will become 'active' when it is mounted and its instructions are applied, and it will become 'destroyed' when it is unmounted and its instructions are reverted.
      */
-    compile(): void;
+    get status(): AreSceneStatusNames;
+    get isActive(): boolean;
+    get isInactive(): boolean;
     /**
-     * Mounts the node, which typically involves executing any necessary logic to render the node in the scene and to set up any interactions or behaviors associated with the node. This may include applying the generated SceneInstructions from the compile phase, attaching event listeners, and performing any other necessary tasks to ensure that the node is properly rendered and functional within the scene.
-     *
-     * [!] Note: The mount method should ensure that the node's scope is properly inherited from the context scope before performing any mounting logic, and it should handle any errors that may occur during mounting to ensure that the node can be rendered correctly in the scene.
+     * Returns All declaration instructions are registered in the scene scope. Since declaration instructions are the main instructions that represent the structure of the node, we have a separate getter for them to easily access and manage them in the scene.
      */
-    mount(): void;
+    get declarations(): AreDeclaration$1[];
     /**
-     * Interprets the node, which typically involves executing any necessary logic to process the node's features, attributes, directives, and other properties to generate the corresponding SceneInstructions for rendering and updating the node in response to changes in state or context. This method is responsible for ensuring that the node is properly interpreted based on its content, markup, styles, and features to enable dynamic behavior and responsiveness within the scene.
-     *
-     * [!] Note: The interpret method should NOT go though own child, since it may be used by both mount and update operations!
+     * Returns All mutation instructions are registered in the scene scope. Mutation instructions are the instructions that represent the changes to be applied to the node, so we have a separate getter for them to easily access and manage them in the scene, especially when we want to apply or revert changes based on the mutations.
      */
-    interpret(): void;
+    get mutations(): AreMutation$1[];
     /**
-     * Updates the node, which typically involves executing any necessary logic to update the node's rendering and behavior in response to changes in state, context, or other factors. This may include reapplying SceneInstructions, updating event listeners, and performing any other necessary tasks to ensure that the node remains functional and correctly rendered within the scene as changes occur.
-     *
-     * [!] Note: The update method should ensure that the node's scope is properly inherited from the context scope before performing any update logic, and it should handle any errors that may occur during updating to ensure that the node can be updated correctly in the scene.
+     * Returns All instructions are registered in the scene scope.
      */
-    update(): void;
+    get instructions(): AreInstruction$1[];
     /**
-     * Unmounts the node, which typically involves executing any necessary logic to remove the node from the scene and to clean up any resources associated with the node. This may include reverting any applied SceneInstructions, detaching event listeners, and performing any other necessary tasks to ensure that the node is properly removed from the scene and that resources are released as needed.
+     * Plan is a queue of changes that should be applied to render the node
      *
-     * [!] Note: The unmount method should ensure that the node's scope is properly inherited from the context scope before performing any unmounting logic, and it should handle any errors that may occur during unmounting to ensure that the node can be removed correctly from the scene.
+     * It works as FIFO, so the first instruction that should be applied is the first one in the queue, and so on.
      */
-    unmount(): void;
-    cloneWithScope<T extends AreNode = AreNode>(this: T): T;
-    reset(): void;
-    clone<T extends AreNode = AreNode>(this: T): T;
+    get planned(): AreInstruction$1[];
     /**
-     * Emits an event or a scope to the node, which can be used to trigger event handlers or to provide additional context for processing within the node. The method can accept either an AreEvent instance or an A_Scope instance, and it will handle the emission accordingly. This allows for flexible communication and interaction within the node's context, enabling dynamic behavior and responsiveness based on events or changes in scope.
+     * State is a list of instructions that are currently applied to the node,
+     * so it represents the current state of the node in the scene.
      *
-     * @param scope - The scope or event to be emitted to the node
+     * It always in a reverse order of the plan, so the last instruction in the state is the first one that should be reverted when we need to revert the changes, and so on.
+     *
+     * For example, if we have a node with two instructions in the plan: [Instruction A, Instruction B], and both of them are applied to the node, then the state will be [Instruction B, Instruction A], so when we need to revert the changes, we will revert Instruction B first, and then Instruction A.
      */
-    emit(scope: A_Scope): any;
-    emit(event: AreEvent): any;
+    get applied(): AreInstruction$1[];
     /**
-     * Destroys the node, which typically involves executing any necessary cleanup logic to remove the node from the scene and to free up any resources associated with the node. This may include deregistering the node from its scope, removing any event listeners or reactive properties, and performing any other necessary cleanup tasks to ensure that the node is properly removed from the scene and that resources are released as needed.
+     * Should return instructions to be reverted and to be applied.
+     * A difference between plan vs state is that plan is what should be applied to the scene,
+     * while state is what currently applied to the scene.
      *
-     * [!] Note: The destroy method should ensure that the node's scope is properly inherited from the context scope before performing any cleanup, and it should handle any errors that may occur during destruction to ensure that resources are released correctly.
      */
-    destroy(): Promise<any>;
+    get changes(): AreSceneChanges;
+    activate(): void;
+    deactivate(): void;
     /**
-     * Method to ensure that the current scope is inherited from the context scope
+     * Each scene has a primary declaration instruction that represents the node in the scene, so it should be registered as a host instruction for the scene, and it will be used to keep track of the node in the scene and to manage its lifecycle. This method allows to set the host instruction for the scene, but it will throw an error if we try to set another host instruction while there is already a host instruction set, so we can ensure that there is only one host instruction for the scene at any given time.
      *
-     * @throws A_Error if the scope is not inherited from the context scope
+     * @param instruction
      */
-    protected checkScopeInheritance(): void;
-}
-
-declare class AreContext extends A_ExecutionContext {
+    setHost(instruction: AreDeclaration$1): void;
     /**
-     * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
+     * Unsets the current host instruction from the scene.
+     *
+     * This method should be used when we want to remove the primary declaration instruction that represents the node in the scene, for example, when we want to unmount the node or when we want to replace it with another node. Unsetting the host instruction will allow us to set a new host instruction for the scene if needed.
      */
-    protected _source: string;
+    removeHost(): void;
     /**
-     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
+     * Method that should register the instruction in the plan, so it will be rendered in the next render cycle.
+     *
+     * @param instruction
      */
-    protected _roots: Array<AreNode>;
+    plan(instruction: AreInstruction$1): void;
+    planBefore(instruction: AreInstruction$1, beforeInstruction: AreInstruction$1): void;
+    planAfter(instruction: AreInstruction$1, afterInstruction: AreInstruction$1): void;
+    moveBefore(instruction: AreInstruction$1, beforeInstruction: AreInstruction$1): void;
+    moveAfter(instruction: AreInstruction$1, afterInstruction: AreInstruction$1): void;
     /**
-     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     * Allows to remove instruction from the plan, so it will not be rendered anymore, but it will still be registered in the scene scope, so it can be planned again if needed.
+     *
+     * @param instruction
      */
-    protected _signalsMap: Map<string, A_SignalVector>;
-    protected _performance: Map<string, number>;
-    protected _performanceStart: Map<string, number>;
-    protected _performanceDepth: Map<string, number>;
+    unPlan(instruction: AreInstruction$1): void;
     /**
-     * The global object can be used to store any global data or configurations that need to be accessed across different components and entities within the ARE framework. This can include things like theme settings, user preferences, or any other shared data that is relevant to the entire scene or application. By centralizing this information in the context, it allows for easier management and access to global state without needing to pass it through multiple layers of components or entities.
+     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
+     *
+     * @param instruction
+     * @returns
      */
-    get globals(): any;
-    constructor(
+    getPlanned(instruction: AreInstruction$1): AreInstruction$1 | undefined;
     /**
-     * The source string represents the original template or input from which the ARE scene is generated. This can be used for debugging, error reporting, or any features that require access to the raw template data. The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
+     * Checks if the instruction is already in the plan, so it will be rendered in the next render cycle.
+     *
+     * @param instruction
+     * @returns
      */
-    source?: string);
+    isInPlan(instruction: AreInstruction$1): boolean;
     /**
-     * The scope of the context, which can be used to access other entities and features within the same scope. This is particularly useful for components that need to interact with other parts of the scene or component, as it allows them to access shared data and functionality without needing to pass it explicitly through parameters.
+     * Method moves the instruction to state to keep it applied and to be able to revert it later if needed. The instruction should be already registered in the scene scope and planned to be applied, otherwise it will not be applied.
+     *
+     * @param instruction
      */
-    get scope(): _adaas_a_concept.A_Scope<any, _adaas_a_concept.A_TYPES__Component_Constructor<_adaas_a_concept.A_Component>[], _adaas_a_concept.A_TYPES__Error_Constructor<_adaas_a_concept.A_Error<_adaas_a_concept.A_TYPES__Error_Init, _adaas_a_concept.A_TYPES__Error_Serialized>>[], _adaas_a_concept.A_TYPES__Entity_Constructor<_adaas_a_concept.A_Entity<any, _adaas_a_concept.A_TYPES__Entity_Serialized>>[], A_Fragment<_adaas_a_concept.A_TYPES__Fragment_Serialized>[]>;
+    apply(instruction: AreInstruction$1): void;
     /**
-     * The roots array holds references to the root nodes of the ARE scene, allowing for easy access and management of the top-level components in the rendering hierarchy. The signalsMap is a mapping between root nodes and their associated signal vectors, enabling efficient management of reactive updates and interactions within the ARE framework based on changes in the application state or user input.
+     * Method moves the instruction from state to unapply it and to be able to apply it later if needed. The instruction should be already registered in the scene scope and applied, otherwise it will not be unapplied.
+     *
+     * @param instruction
      */
-    get roots(): Array<AreNode>;
+    unApply(instruction: AreInstruction$1): void;
     /**
-     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     * Checks if the instruction is already in the state, so it is currently applied to the scene.
+     *
+     * @param instruction
+     * @returns
      */
-    get source(): string;
-    get performance(): Array<string>;
-    get stats(): string[];
-    protected countInstructions(node: AreNode): number;
-    protected countNodes(node: AreNode): number;
+    getApplied(instruction: AreInstruction$1): AreInstruction$1 | undefined;
     /**
-     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     * Checks if the instruction is already in the state, so it is currently applied to the scene.
      *
-     * @param node
+     * @param instruction
+     * @returns
      */
-    addRoot(node: AreNode): void;
+    isApplied(instruction: AreInstruction$1): boolean;
     /**
-     * This property stores a map between root node and conditions that should be met to render particular component inside the root node. This can be used to manage complex rendering logic and to optimize performance by ensuring that components are only rendered when necessary based on the defined conditions.
+     * Method that should reset the scene to the initial state, so it will clear the plan and state, but it will not deregister the instructions from the scene scope, so they will still be registered in the scene and can be planned and applied again if needed.
      *
-     * @param node
      */
-    removeRoot(node: AreNode): void;
-    startPerformance(label?: string): void;
-    endPerformance(label: string): void;
+    reset(): void;
 }
 
-declare class AreSyntax extends A_Fragment {
+declare class AreSceneError extends A_Error {
+    static readonly SceneAlreadyInactive = "AreSceneError.SceneAlreadyInactive";
+    static readonly SceneAlreadyActive = "AreSceneError.SceneAlreadyActive";
+    static readonly HostInstructionHasConnectedInstructions = "AreSceneError.HostInstructionHasConnectedInstructions";
+    static readonly SingleHostInstruction = "AreSceneError.SingleHostInstruction";
+    static readonly SceneError = "AreSceneError.SceneError";
+    static readonly RootNotFound = "AreSceneError.RootNotFound";
+    static readonly UpdateFailed = "AreSceneError.UpdateFailed";
+    static readonly MountFailed = "AreSceneError.MountFailed";
+    static readonly UnmountFailed = "AreSceneError.UnmountFailed";
+    static readonly MountPointNotFound = "AreSceneError.MountPointNotFound";
+    static readonly InvalidTemplate = "AreSceneError.InvalidTemplate";
+    static readonly RenderFailed = "AreSceneError.RenderFailed";
+}
+
+type AreInstructionNewProps<T extends any = Record<string, any>> = {
     /**
-     * Max allowed length of an expression string to prevent excessively long inputs that could lead to performance issues or abuse.
+     * The deduplication ID that prevents duplicated instruction within the same node.
+     *
+     * For example to prevent duplicated AddAttribute instruction for the same attribute, we can use the attribute name as the deduplication ID, so if we have two AddAttribute instructions with the same attribute name, only the first one will be applied, and the second one will be ignored.
+     *
+     *
+     * [!] Note; By default it uses action name and group if provided
      */
-    private readonly MAX_LENGTH;
     /**
-     * Max allowed nesting depth of parentheses, brackets, and braces in expressions to prevent excessively complex inputs that could lead to performance issues or abuse. Default is 5 levels of nesting.
+     * the Host operation to be performed. Exactly this name will be used to call a method from the Host class.
      */
-    private readonly MAX_DEPTH;
+    name: string;
     /**
-     * List of regex patterns that are blocked in expressions to prevent access to unsafe or sensitive features. This includes patterns for global objects, functions, and syntax that could be used for malicious purposes (e.g. "eval", "Function", "fetch", "XMLHttpRequest", "import", "require", "document", "window", "globalThis", "global", "process", "__proto__", "constructor", "prototype"). Expressions containing any of these patterns will be rejected during validation.
+     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
      */
-    private readonly BLOCKED_PATTERNS;
+    parent?: AreInstruction | undefined;
     /**
-     * Set of global identifiers that are blocked in expressions to prevent access to unsafe or sensitive features. This includes global objects and functions that could be used for malicious purposes (e.g. "eval", "Function", "fetch", "XMLHttpRequest", "document", "window", "globalThis", "global", "process", "setTimeout", "setInterval", "localStorage", "sessionStorage", "indexedDB", "WebSocket", "Worker"). Accessing any of these identifiers in an expression will be rejected during validation.
+     * Group is an optional property that can be used to group instructions together.
+     *
+     * For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on.
+     *
+     * This can be useful to manage complex changes that involve multiple instructions.
+     *
+     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
      */
-    private readonly BLOCKED_GLOBALS;
+    group?: AreInstruction | undefined;
     /**
-     * Regex pattern that defines the allowed characters in expressions. This pattern allows letters, digits, whitespace, and common operators and punctuation used in JavaScript expressions. Expressions containing characters that do not match this pattern will be rejected during validation to prevent injection of potentially harmful code.
+     * A set of additional parameters that may be needed for the rendering purpose.
+     *
+     * For example: for AddAttribute instruction, we may need to provide the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.
      */
-    private readonly ALLOWED_CHARS;
+    payload?: T;
+};
+type AreInstructionSerialized<T extends any = Record<string, any>> = {
     /**
-     * Simple dot-path identifier pattern (e.g. "name", "user.name", "user.profile.name").
-     * Matches strings that consist solely of identifier characters separated by dots.
+     * The name of the instruction, which corresponds to the operation that should be performed in the Host. This name is used to identify the specific method in the Host that should be called to execute the instruction, allowing for a clear mapping between instructions and their corresponding actions in the rendering process.
      */
-    private readonly SIMPLE_PATH;
+    name: string;
     /**
-     * Compiled expression — a pre-parsed function ready for repeated execution.
-     * Created once via compile(), reused on every apply/click.
+     * The type of the instruction, which can be used to categorize instructions and determine how they should be processed. For example, we can have different types for declaration instructions (e.g., DeclarationInstruction or CreateElement) and mutation instructions (e.g., AddAttribute), allowing for better organization and management of instructions based on their purpose and behavior in the scene.
      */
-    private readonly _rules;
-    private readonly _trimWhitespace;
-    private readonly _strictMode;
-    constructor(config?: Partial<AreSyntaxInitOptions>);
+    type: string;
     /**
-     * Get the array of token rules that define the syntax for parsing templates. Each rule specifies how to identify and process a particular type of token (e.g. interpolation, directive, comment) within templates. The rules are checked in order of priority, allowing for flexible and customizable parsing behavior.
+     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
      */
-    get rules(): AreSyntaxTokenRules<AreNode>[];
+    parent?: string | undefined;
     /**
-     * Indicates whether leading and trailing whitespace should be trimmed from token content. When enabled, any whitespace at the start or end of the content captured by a token will be removed before further processing. This can help prevent issues with unintended spaces affecting rendering or logic, especially in cases like interpolations or directives where extra whitespace may be common. Default is true.
+     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions. The best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
      */
-    get trimWhitespace(): boolean;
+    group?: string | undefined;
     /**
-     * Indicates whether the parser should throw an error when it encounters unclosed tokens. When enabled, if the parser finds an opening delimiter without a corresponding closing delimiter (e.g. an unclosed interpolation or directive), it will throw an error instead of silently ignoring it. This can help catch syntax errors and ensure that templates are well-formed. Default is true.
+     * A set of additional parameters that may be needed for the rendering purpose. For example: for AddAttribute instruction, we may need to provide the attribute name and value as a payload, so the Host can use this information to add the attribute to the node.
      */
-    get strictMode(): boolean;
+    payload: T;
+} & A_TYPES__Entity_Serialized;
+
+declare class AreInstruction<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized<T> = AreInstructionSerialized<T>> extends A_Entity<AreInstructionNewProps<T>, S> implements AreStoreWatchingEntity$1 {
     /**
-     * Compiles an expression string into a reusable executor.
-     * Performs validation and Function construction once.
-     * Use when the same expression will be evaluated multiple times
-     * e.g. event handlers, instructions that re-apply on store changes.
-     *
-     * @example
-     *   // compile once at apply() time
-     *   const compiled = AreCommonHelper.compile('(e) => !!pageTitle ? $testHandler(e, item) : null')
-     *
-     *   // execute on every click — no re-parsing, no re-validation
-     *   element.addEventListener('click', (e) => {
-     *       const fn = compiled.execute(store, { $testHandler: handler, item })
-     *       if (typeof fn === 'function') fn(e)
-     *   })
+     * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
      */
-    compile(expr: string): AreSyntaxCompiledExpression;
+    protected _name: string;
+    /**
+     * The payload of the instruction, which can contain any additional information 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. The payload is optional and can be an empty object if no additional information is needed.
+     */
+    protected _payload?: T;
     /**
-     * Evaluates an expression string against the provided store.
-     * Automatically determines whether the result should be callable
-     * based on the shape of the expression.
-     *
-     * Returns the raw value for plain expressions (interpolations, bindings).
-     * Returns a bound function for callable expressions (event handlers).
-     *
-     * @param expr  Expression string to evaluate.
-     * @param store AreStore used for identifier resolution.
-     * @param scope Optional extra bindings checked **before** the store.
-     *              Useful for injecting event-specific values (`$event`, `element`)
-     *              or emit wrappers (`$handleClick`).
-     *
-     * @example
-     *   // simple value
-     *   evaluate('user.name', store)
-     *
-     *   // with emit wrapper
-     *   evaluate('$handleClick($event, user.name)', store, {
-     *       $event: domEvent,
-     *       $handleClick: (...args) => node.emit(new AreEvent('handleClick', args)),
-     *   })
+     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions.
      *
-     *   // arrow with conditional
-     *   evaluate('(e) => isValid(user.name) ? $handleClick(e) : null', store, {
-     *       $handleClick: (...args) => node.emit(new AreEvent('handleClick', args)),
-     *   })
+     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
      */
-    evaluate(expr: string, store: AreStore, scope?: Record<string, any>): any;
+    protected _group: string | undefined;
     /**
-     * Extracts $-prefixed handler names from an expression.
-     * These represent event emission targets, not store references.
-     *
-     * Examples:
-     *   "$handleClick"                                     → Set(["handleClick"])
-     *   "$handleClick(user.name)"                           → Set(["handleClick"])
-     *   "(e) => isValid(user.name) ? $handleClick(e) : null" → Set(["handleClick"])
+     * The parent instruction that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
      */
-    extractEmitHandlers(expr: string): Set<string>;
-    private isCallableExpression;
-    private validate;
-    private checkDepth;
-    private createSandbox;
-    private nestedHandler;
-    private assertSafeKey;
-    private execute;
-}
-
-declare class AreSyntaxError extends A_Error {
-    static readonly SyntaxParseError = "Are Syntax Parse Error";
-    static readonly SyntaxNotSupportedError = "Are Syntax Not Supported Error";
-    static readonly MethodNotImplementedError = "Are Syntax Method Not Implemented Error";
-}
-
-declare class AreTokenizer extends A_Component {
+    protected _parent: string | undefined;
     /**
-     * Get the AreSyntax from the current scope. The AreSyntax defines the syntax rules and structures for tokenizing templates. It provides mechanisms for parsing and interpreting templates, attributes, directives, interpolations, and event listeners, enabling dynamic and interactive UI rendering within the ARE framework. If no AreSyntax is found in the scope, an error is thrown indicating that AreTokenizer requires an AreSyntax to function properly.
+     * A set of properties that influence the behavior of the instruction, for example, for AddTextInstruction, we can interpolation dependent on some key in the store, so we can have a property called "interpolationKey" that will be used to track the dependencies of the instruction, and when the value of this key changes in the scope, we can update the instruction accordingly.
      */
-    protected get config(): AreSyntax;
+    protected _props: Set<string>;
     /**
-     * Instantiate AreNodes based on the token matches obtained from scanning the source template. This method takes the raw source string from the context, scans it for tokens using the defined syntax rules, and creates corresponding AreNode instances for each matched token. The resulting array of AreNodes represents the structured representation of the template, which can then be used for further processing, such as rendering or applying scene instructions.
+     * The name of the instruction, for example "CreateElement", "AddAttribute", "RemoveNode", etc. This is used to identify the type of the instruction and how to process it. The name should be in PascalCase format, and should be unique across all instruction types. It is recommended to use a prefix that indicates the category of the instruction, for example "CreateElement" for instructions that create new elements, "UpdateAttribute" for instructions that update attributes, etc.
+     */
+    get name(): string;
+    /**
+     * The payload of the instruction, which can contain any additional information 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. The payload is optional and can be an empty object if no additional information is needed.
      *
+     * [!] Note, the payload should be serializable, so it can be stored and transmitted easily. It is recommended to use simple data structures for the payload, such as objects, arrays, strings, numbers, etc., and avoid using complex data types that may not be easily serializable.
+     */
+    get payload(): T;
+    /**
+     * Group is an optional property that can be used to group instructions together. For example a set of instructions that depend on create CreateElement instruction can be grouped together with the same group name, so if the CreateElement instruction is reverted, all the instructions in the same group will be reverted as well, and so on. This can be useful to manage complex changes that involve multiple instructions.
      *
-     * @param context
-     * @returns
+     * [!] Note, the best option is to use ASEID of the Instruction as a group, so all instructions with the same ASEID will be treated as a single change, and will be applied and reverted together.
      */
-    instantiate<T extends AreNode>(context: AreContext): void;
-    tokenize(node: AreNode, context: AreContext, logger?: A_Logger): void;
-    protected scan(source: string, from: number, to: number, context: AreContext): AreSyntaxTokenMatch[];
-    protected findNextMatch(source: string, from: number, to: number): AreSyntaxTokenMatch | null;
-    protected matchRule(source: string, rule: AreSyntaxTokenRules, from: number, to: number): AreSyntaxTokenMatch | null;
-    protected matchStandardRule(source: string, rule: AreSyntaxTokenRules, from: number, to: number): AreSyntaxTokenMatch | null;
-    protected matchPrefixedRule(source: string, rule: AreSyntaxTokenRules, from: number, to: number): AreSyntaxTokenMatch | null;
-    protected findMatchingClose(source: string, opening: string, closing: string, from: number, to: number): number;
-    protected buildMatch(rule: AreSyntaxTokenRules, raw: string, content: string, position: number, closingUsed: string): AreSyntaxTokenMatch;
-    protected tryPlainText(raw: string, position: number): AreSyntaxTokenMatch | null;
-    protected findRuleForMatch(match: AreSyntaxTokenMatch): AreSyntaxTokenRules | undefined;
-}
-
-declare class AreTokenizerError extends A_Error {
-}
-
-declare class AreCompiler extends A_Component {
+    get group(): string | undefined;
     /**
-     * Defines a custom method for compiling a node into a set of SceneInstructions. This method is called during the compilation phase of the ARE component and should perform any necessary transformations on the node and its attributes to generate the appropriate instructions for rendering. This can include tasks such as processing directives, evaluating expressions, and generating instructions for dynamic content based on the node's properties and context.
+     * The parent instruction ASEID that created this instruction. For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, the AddAttribute instruction would have the CreateElement instruction as its parent. This can be used to track the hierarchy of instructions and their dependencies.
      *
-     * @param node
+     * [!] Note, the parent should be provided as an ASEID string, so it can be easily referenced and tracked across different contexts and times.
      */
-    static Compile<T extends AreNode>(node: A_TYPES__Entity_Constructor<T>): any;
+    get parent(): string | undefined;
+    get id(): string;
+    get owner(): AreNode$1;
+    fromNew(newEntity: AreInstructionNewProps<T>): void;
+    fromUndefined(): void;
     /**
-     * Defines a custom method for compiling an attribute into a set of SceneInstructions. This method is called during the compilation phase of the ARE component and should perform any necessary transformations on the attribute to generate the appropriate instructions for rendering. This can include tasks such as processing directives, evaluating expressions, and generating instructions for dynamic content based on the attribute's properties and context.
+     * Group this instruction with another instruction. This means that when one of the instructions in the group is applied or reverted, all the instructions in the same group will be applied or reverted together. This can be useful to manage complex changes that involve multiple instructions.
      *
-     * @param attribute
+     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can group them together with the same group name, so if we revert the CreateElement instruction, the AddAttribute instruction will be reverted as well, and so on.
+     *
+     * @param instruction
+     * @returns
      */
-    static Compile<T extends AreAttribute>(attribute: A_TYPES__Entity_Constructor<T>): any;
-    compile(node: AreNode, scene: AreScene, logger?: A_Logger, ...args: any[]): void;
-}
-
-declare class AreCompilerError extends A_Error {
-    static readonly RenderError = "Are Compiler Render Error";
-    static readonly CompilationError = "Are Compiler Compilation Error";
-}
-
-declare class AreTransformer extends A_Component {
-    transform(node: AreNode, scope: A_Scope, scene: AreScene, ...args: any[]): void;
-}
-
-declare class AreInterpreter extends A_Component {
+    groupWith(instruction: AreInstruction): this;
     /**
-     * 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.
+     * Ungroup this instruction from any group. This means that this instruction will be treated as an independent instruction, and will not be applied or reverted together with any other instructions. This can be useful when you want to separate an instruction from a group, so it can be applied or reverted independently.
      *
-     * @param action
      * @returns
      */
-    static Apply(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    unGroup(): this;
     /**
-     * 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.
+     * Attach this instruction to a parent instruction. This means that this instruction will be considered as a child of the parent instruction, and can be used to track the hierarchy of instructions and their dependencies.
      *
-     * @param action
+     * For example, if we have a CreateElement instruction that creates a new element, and then we have an AddAttribute instruction that adds an attribute to that element, we can attach the AddAttribute instruction to the CreateElement instruction as its parent, so we can track that the AddAttribute instruction is related to the CreateElement instruction.
+     *
+     * @param parent
      * @returns
      */
-    static Update(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    attachTo(parent: AreInstruction): this;
     /**
-     * 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.
+     * Detach this instruction from its parent instruction. This means that this instruction will no longer be considered as a child of the parent instruction, and will not be related to it in any way. This can be useful when you want to separate an instruction from its parent, so it can be treated as an independent instruction.
      *
-     * @param action
      * @returns
      */
-    static Revert(action: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    detach(): this;
     /**
-     * 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.
+     * Apply this instruction to the scene. This means that the changes represented by this instruction will be applied to the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output.
      *
-     * @param scene
+     * For example, if this instruction is a CreateElement instruction, when we apply it, the Host will create a new element in the scene according to the information provided in the payload of the instruction. If this instruction is an AddAttribute instruction, when we apply it, the Host will add the specified attribute to the target element in the scene. The apply method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for applying the instruction.
+     *
+     * @param scope
      */
-    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;
-}
-
-declare class AreInterpreterError extends A_Error {
-}
-
-/**
- * Properties for the AreEvent context
- *
- */
-type AreEventProps<T = any> = {
+    apply(scope?: A_Scope): void;
     /**
-     * The data associated with the event
+     * Update this instruction in the scene. This means that the changes represented by this instruction will be updated in the scene, and the Host will perform the necessary operations to reflect these changes in the rendered output. This is particularly useful for instructions that have dynamic properties or effects that may change over time, allowing for adjustments to be made to the instruction's behavior or effects without needing to revert and reapply it entirely. The update method can also accept an optional scope parameter, which can be used to provide additional context or information that may be needed for updating the instruction.
+     *
+     * @param scope
      */
-    data: T;
+    update(scope?: A_Scope): void;
     /**
-     * The name of the event
+     * Revert this instruction from the scene. This means that the changes represented by this instruction will be reverted from the scene, and the Host will perform the necessary operations to undo these changes in the rendered output.
+     *
+     * @param scope
      */
-    event: string;
-};
-
-declare class AreSceneError extends A_Error {
-    static readonly SceneAlreadyInactive = "AreSceneError.SceneAlreadyInactive";
-    static readonly SceneAlreadyActive = "AreSceneError.SceneAlreadyActive";
-    static readonly HostInstructionHasConnectedInstructions = "AreSceneError.HostInstructionHasConnectedInstructions";
-    static readonly SingleHostInstruction = "AreSceneError.SingleHostInstruction";
-    static readonly SceneError = "AreSceneError.SceneError";
-    static readonly RootNotFound = "AreSceneError.RootNotFound";
-    static readonly UpdateFailed = "AreSceneError.UpdateFailed";
-    static readonly MountFailed = "AreSceneError.MountFailed";
-    static readonly UnmountFailed = "AreSceneError.UnmountFailed";
-    static readonly MountPointNotFound = "AreSceneError.MountPointNotFound";
-    static readonly InvalidTemplate = "AreSceneError.InvalidTemplate";
-    static readonly RenderFailed = "AreSceneError.RenderFailed";
+    revert(scope?: A_Scope): void;
 }
 
 declare const AreInstructionFeatures: {
@@ -1454,9 +1419,66 @@ declare const AreInstructionDefaultNames: {
 declare class AreInstructionError extends A_Error {
 }
 
+/**
+ * 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.
+ */
+declare class AreDeclaration<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized$1<T> = AreInstructionSerialized$1<T>> extends AreInstruction$1<T, S> {
+    constructor(
+    /**
+     * 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.
+     */
+    serialized: AreInstructionSerialized$1);
+    constructor(
+    /**
+     * 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.
+     */
+    name: string, 
+    /**
+     * 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.
+     */
+    parent: AreDeclaration, 
+    /**
+     * 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.
+     */
+    payload: T);
+    constructor(
+    /**
+     * 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.
+     */
+    name?: string, 
+    /**
+     * 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.
+     */
+    payload?: T);
+}
+
+declare class AreMutation<T extends Record<string, any> = Record<string, any>, S extends AreInstructionSerialized$1<T> = AreInstructionSerialized$1<T>> extends AreInstruction$1<T, S> {
+    get parent(): string;
+    get group(): string;
+    constructor(
+    /**
+     * 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.
+     */
+    serialized: S);
+    constructor(
+    /**
+     * The name of the operation to be performed in Host.
+     */
+    name: string, 
+    /**
+     * 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.
+     */
+    parent: AreDeclaration, 
+    /**
+     * 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.
+     */
+    payload?: T);
+    fromNew(newEntity: AreInstructionNewProps$1<T>): void;
+}
+
 declare class AreLifecycle extends A_Component {
-    static Init<T extends AreNode>(node: A_TYPES__Entity_Constructor<T>): any;
-    static Init<T extends AreAttribute>(attribute: A_TYPES__Entity_Constructor<T>): any;
+    static Init<T extends AreNode$1>(node: A_TYPES__Entity_Constructor<T>): any;
+    static Init<T extends AreAttribute$1>(attribute: A_TYPES__Entity_Constructor<T>): any;
     /**
      *  Handles before init lifecycle of the AreNode
      *
@@ -1466,7 +1488,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    beforeInit(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    beforeInit(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Initializes the AreNode and prepares it for mounting
      *
@@ -1477,7 +1499,7 @@ declare class AreLifecycle extends A_Component {
      * @param logger
      * @param args
      */
-    init(node: AreNode, scope: A_Scope, context: AreContext, logger?: A_Logger, ...args: any[]): void;
+    init(node: AreNode$1, scope: A_Scope, context: AreContext$1, logger?: A_Logger, ...args: any[]): void;
     /**
      * Handles after init lifecycle of the AreNode
      *
@@ -1491,7 +1513,7 @@ declare class AreLifecycle extends A_Component {
     /**
      * Node to be mounted
      */
-    node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      *  Handles before mount lifecycle of the AreNode
      *
@@ -1501,7 +1523,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    beforeMount(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    beforeMount(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Mount the AreNode into the Host
      *
@@ -1514,11 +1536,11 @@ declare class AreLifecycle extends A_Component {
     /**
      * Node to be mounted
      */
-    node: AreNode, 
+    node: AreNode$1, 
     /**
      * Node Content
      */
-    scene: AreScene, logger?: A_Logger, ...args: any[]): void;
+    scene: AreScene$1, logger?: A_Logger, ...args: any[]): void;
     /**
      * Handles after mount lifecycle of the AreNode
      *
@@ -1532,7 +1554,7 @@ declare class AreLifecycle extends A_Component {
     /**
      * Node to be mounted
      */
-    node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Handles before update lifecycle of the AreNode
      *
@@ -1542,7 +1564,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    beforeUpdate(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    beforeUpdate(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Updates the AreNode in the AreScene
      *
@@ -1554,7 +1576,7 @@ declare class AreLifecycle extends A_Component {
     /**
      * Node to be updated
      */
-    node: AreNode, context: AreContext, logger?: A_Logger, ...args: any[]): void;
+    node: AreNode$1, context: AreContext$1, logger?: A_Logger, ...args: any[]): void;
     /**
      * Handles after update lifecycle of the AreNode
      *
@@ -1564,7 +1586,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    afterUpdate(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    afterUpdate(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Handles before unmount lifecycle of the AreNode
      *
@@ -1574,7 +1596,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    beforeUnmount(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    beforeUnmount(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Unmounts the AreNode from the Host
      *
@@ -1583,7 +1605,7 @@ declare class AreLifecycle extends A_Component {
      * @param args
      *
      */
-    unmount(node: AreNode, scene: AreScene, ...args: any[]): void;
+    unmount(node: AreNode$1, scene: AreScene$1, ...args: any[]): void;
     /**
      * Handles after unmount lifecycle of the AreNode
      *
@@ -1593,7 +1615,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    afterUnmount(node: AreNode, scope: A_Scope, scene: AreScene, feature: A_Feature, ...args: any[]): void;
+    afterUnmount(node: AreNode$1, scope: A_Scope, scene: AreScene$1, feature: A_Feature, ...args: any[]): void;
     /**
      * Handles before destroy lifecycle of the AreNode
      *
@@ -1603,7 +1625,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    beforeDestroy(node: AreNode, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    beforeDestroy(node: AreNode$1, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
     /**
      * Destroys the AreNode from the Host
      *
@@ -1612,7 +1634,7 @@ declare class AreLifecycle extends A_Component {
      * @param args
      *
      */
-    destroy(node: AreNode, scene: AreScene, ...args: any[]): void;
+    destroy(node: AreNode$1, scene: AreScene$1, ...args: any[]): void;
     /**
      * Handles after destroy lifecycle of the AreNode
      *
@@ -1622,7 +1644,7 @@ declare class AreLifecycle extends A_Component {
      * @param feature
      * @param args
      */
-    afterDestroy(node: AreNode, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
+    afterDestroy(node: AreNode$1, scope: A_Scope, feature: A_Feature, ...args: any[]): void;
 }
 
 declare class AreLifecycleError extends A_Error {
@@ -1640,7 +1662,7 @@ declare class AreLoader extends A_Component {
      * @param logger
      * @param args
      */
-    load(node: AreNode, scope: A_Scope, feature: A_Feature, logger?: A_Logger, context?: AreContext, ...args: any[]): Promise<void>;
+    load(node: AreNode$1, scope: A_Scope, feature: A_Feature, logger?: A_Logger, context?: AreContext$1, ...args: any[]): Promise<void>;
 }
 
 declare class AreLoaderError extends A_Error {
@@ -1666,7 +1688,7 @@ declare class AreWatcher extends A_Component {
 declare class AreSignal<_TSignalDataType extends Record<string, any> = Record<string, any>> extends A_Signal<_TSignalDataType> {
 }
 
-type AreSignalsContextConfig<T extends Are> = {
+type AreSignalsContextConfig<T extends Are$1> = {
     [key in string]: {
         default: A_TYPES__Ctor<T>;
         pool: Array<A_TYPES__Ctor<T>>;
@@ -1678,14 +1700,14 @@ type AreSignalsContextConfig<T extends Are> = {
 };
 
 declare class AreSignalsMeta extends A_ComponentMeta<{
-    vectorToComponent: Map<A_SignalVector, A_TYPES__Ctor<Are>>;
-    componentToVector: Map<A_TYPES__Ctor<Are>, Set<A_SignalVector>>;
+    vectorToComponent: Map<A_SignalVector, A_TYPES__Ctor<Are$1>>;
+    componentToVector: Map<A_TYPES__Ctor<Are$1>, Set<A_SignalVector>>;
 } & A_TYPES__ComponentMeta> {
-    registerCondition<T extends Are>(component: A_TYPES__Ctor<T>, vector: A_SignalVector): void;
-    findComponentByVector(vector: A_SignalVector): A_TYPES__Ctor<Are> | undefined;
+    registerCondition<T extends Are$1>(component: A_TYPES__Ctor<T>, vector: A_SignalVector): void;
+    findComponentByVector(vector: A_SignalVector): A_TYPES__Ctor<Are$1> | undefined;
 }
 
-declare class AreSignalsContext<T extends Are = Are> extends A_Fragment {
+declare class AreSignalsContext<T extends Are$1 = Are$1> extends A_Fragment {
     /**
      * Where key is the root ID and the value is an Array of components that participate in conditional compilation.
      */
@@ -1695,11 +1717,11 @@ declare class AreSignalsContext<T extends Are = Are> extends A_Fragment {
         vector: Array<any>;
         component: A_TYPES__Ctor<T>;
     }>>;
-    protected _subscribers: Set<AreNode>;
+    protected _subscribers: Set<AreNode$1>;
     protected signalsMeta(): AreSignalsMeta;
-    subscribe<S extends AreNode>(subscriber: S): void;
-    unsubscribe<S extends AreNode>(subscriber: S): void;
-    get subscribers(): Set<AreNode>;
+    subscribe<S extends AreNode$1>(subscriber: S): void;
+    unsubscribe<S extends AreNode$1>(subscriber: S): void;
+    get subscribers(): Set<AreNode$1>;
     constructor(
     /**
      * Where key is the root ID and the value is an Array of components that participate in conditional compilation.
@@ -1718,7 +1740,7 @@ declare class AreSignalsContext<T extends Are = Are> extends A_Fragment {
      * @param node The AreNode whose root ID is used to retrieve the components.
      * @returns An array of component constructors.
      */
-    getComponentByRoot(node: AreNode): Array<A_TYPES__Ctor<T>>;
+    getComponentByRoot(node: AreNode$1): Array<A_TYPES__Ctor<T>>;
     /**
      * Adds a new component to the specified root ID. If the root ID does not exist, it will be created.
      *
@@ -1765,18 +1787,88 @@ declare class AreSignals extends A_Component {
      * @param feature
      * @param args
      */
-    propagateEvent(node: AreNode, scope: A_Scope, event: AreEvent, feature: A_Feature, logger?: A_Logger, ...args: any[]): Promise<void>;
+    propagateEvent(node: AreNode$1, scope: A_Scope, event: AreEvent$1, feature: A_Feature, logger?: A_Logger, ...args: any[]): Promise<void>;
 }
 
-declare class AreInit extends AreSignal {
+declare class AreInit extends AreSignal$1 {
     static default(): AreInit | undefined;
 }
 
-declare class AreRoute extends AreSignal<A_Route> {
+declare class AreRoute extends AreSignal$1<A_Route> {
     constructor(path: string | RegExp);
     get route(): A_Route;
     static default(): AreRoute | undefined;
     compare(other: A_Signal<A_Route>): boolean;
 }
 
-export { Are, AreAttribute, type AreAttributeFeatureNames, AreAttributeFeatures, type AreAttribute_Init, type AreAttribute_Serialized, AreCompiler, AreCompilerError, AreContext, type AreContextInit, AreDeclaration, AreEvent, type AreEventProps, type AreFeatureNames, AreFeatures, AreInit, AreInstruction, AreInstructionDefaultNames, AreInstructionError, AreInstructionFeatures, type AreInstructionNewProps, type AreInstructionSerialized, AreInterpreter, AreInterpreterError, AreLifecycle, AreLifecycleError, AreLoader, AreLoaderError, AreMutation, AreNode, type AreNodeFeatureNames, AreNodeFeatures, type AreNodeNewProps, type AreNodeStatusNames, AreNodeStatuses, type ArePropDefinition, AreRoute, AreScene, type AreSceneChanges, AreSceneError, type AreSceneStatusNames, AreSceneStatuses, type AreScene_Serialized, AreSignal, AreSignals, AreSignalsContext, type AreSignalsContextConfig, AreStore, type AreStoreAreComponentMetaKeyNames, AreStoreAreComponentMetaKeys, type AreStorePathValue, type AreStoreWatchingEntity, AreSyntax, type AreSyntaxCompiledExpression, AreSyntaxError, type AreSyntaxInitOptions, type AreSyntaxTokenMatch, type AreSyntaxTokenPayload, type AreSyntaxTokenRules, AreTokenizer, AreTokenizerError, AreTransformer, AreWatcher };
+type AreEngineDependencies = {
+    context: AreContext$1;
+    syntax: AreSyntax$1;
+    loader: A_TYPES__Component_Constructor<AreLoader$1>;
+    tokenizer: A_TYPES__Component_Constructor<AreTokenizer$1>;
+    compiler: A_TYPES__Component_Constructor<AreCompiler$1>;
+    transformer: A_TYPES__Component_Constructor<AreTransformer$1>;
+    interpreter: A_TYPES__Component_Constructor<AreInterpreter$1>;
+    lifecycle: A_TYPES__Component_Constructor<AreLifecycle$1>;
+    signals: A_TYPES__Component_Constructor<AreSignals$1>;
+};
+
+declare class AreEngine extends A_Component {
+    /**
+     * Feature decorator for the load method, which is responsible for the initial loading phase of the engine. This method is where the engine reads the source template, tokenizes it, and prepares the initial context for building the scene. The decorator allows for extending or overriding the default loading behavior by attaching additional functionality before or after the load process.
+     */
+    static get Load(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the build method, which is responsible for constructing the scene based on the loaded context. This method typically involves initializing root nodes, applying transformations, and compiling the scene into a format that can be executed by the interpreter. The decorator allows for customizing the build process by adding additional steps or modifying the existing behavior.
+     */
+    static get Build(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Feature decorator for the execute method, which is responsible for the final execution phase of the engine. This method typically involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes. The decorator allows for customizing the execution process by adding additional steps or modifying the existing behavior.
+     */
+    static get Execute(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any;
+    /**
+     * Method to start the engine, which involves loading necessary resources, building the scene, and executing the rendering process. It accepts an optional scope parameter that can be used to provide a custom scope for the engine's operations, allowing for greater flexibility in how dependencies are managed and accessed during the rendering lifecycle.
+     *
+     * @param scope
+     * @returns
+     */
+    load(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for building the scene, which includes initializing root nodes, loading necessary data, applying transformations, and compiling the scene into a format that can be executed by the interpreter.
+     *
+     * @param context
+     * @param logger
+     */
+    build(scope?: A_Scope): Promise<void>;
+    /**
+     * Method responsible for executing the rendering process, which involves mounting the root nodes to the DOM and starting the reactive update cycle based on signals and state changes.
+     *
+     * @param context
+     * @param logger
+     */
+    execute(scope?: A_Scope): Promise<void>;
+    protected defaultBuild(context: AreContext$1, logger?: A_Logger): Promise<void>;
+    protected defaultExecute(context: AreContext$1, bus?: A_SignalBus, logger?: A_Logger): Promise<void>;
+    init(scope: A_Scope): Promise<void>;
+    verify(scope: A_Scope, syntax?: AreSyntax$1, syntaxContext?: AreSyntax$1, transformer?: AreTransformer$1, loader?: AreLoader$1, compiler?: AreCompiler$1, interpreter?: AreInterpreter$1, lifecycle?: AreLifecycle$1, logger?: A_Logger): Promise<void>;
+    /**
+     * Method to pack all necessary dependencies for the engine. This method is called during the initialization phase of the engine and ensures that all required components are registered in the container scope, allowing for proper dependency injection and management throughout the engine's lifecycle.
+     *
+     * @param scope
+     * @param dependencies
+     */
+    protected package(scope: A_Scope, dependencies?: Partial<AreEngineDependencies>): void;
+    protected packDependency<T extends A_TYPES__A_DependencyInjectable>(scope: A_Scope, dependency: T | A_TYPES__Ctor<T>, existed?: A_TYPES__Ctor<T>): T | A_TYPES__Ctor<T>;
+}
+
+declare const AreEngineFeatures: {
+    Load: string;
+    Build: string;
+    Execute: string;
+};
+
+declare class AreEngineError extends A_Error {
+    static readonly MissedRequiredDependency = "A Required Dependency is missing in AreEngine";
+}
+
+export { Are, AreAttribute, type AreAttributeFeatureNames, AreAttributeFeatures, type AreAttribute_Init, type AreAttribute_Serialized, AreCompiler, AreCompilerError, AreContext, type AreContextInit, AreDeclaration, AreEngine, type AreEngineDependencies, AreEngineError, AreEngineFeatures, AreEvent, type AreEventProps, type AreFeatureNames, AreFeatures, AreInit, AreInstruction, AreInstructionDefaultNames, AreInstructionError, AreInstructionFeatures, type AreInstructionNewProps, type AreInstructionSerialized, AreInterpreter, AreInterpreterError, AreLifecycle, AreLifecycleError, AreLoader, AreLoaderError, AreMutation, AreNode, type AreNodeFeatureNames, AreNodeFeatures, type AreNodeNewProps, type AreNodeStatusNames, AreNodeStatuses, type ArePropDefinition, AreRoute, AreScene, type AreSceneChanges, AreSceneError, type AreSceneStatusNames, AreSceneStatuses, type AreScene_Serialized, AreSignal, AreSignals, AreSignalsContext, type AreSignalsContextConfig, AreStore, type AreStoreAreComponentMetaKeyNames, AreStoreAreComponentMetaKeys, type AreStorePathValue, type AreStoreWatchingEntity, AreSyntax, type AreSyntaxCompiledExpression, AreSyntaxError, type AreSyntaxInitOptions, type AreSyntaxTokenMatch, type AreSyntaxTokenPayload, type AreSyntaxTokenRules, AreTokenizer, AreTokenizerError, AreTransformer, AreWatcher };