smart-lifecycle 0.1.1

package/dist/rendering/managed-host/input-attribute-policy.d.ts

@@ -0,0 +1,60 @@
+import { IInputAttributePolicy } from './input-attribute-policy.interface.js';
+/**
+ * Implements the responsibility of determining which attributes are component inputs.
+ *
+ * @description
+ * Applies a policy to classify host attributes as inputs or styling/metadata:
+ * - **Always inputs:** Attributes with bindings ({{expression}})
+ * - **Never inputs:** Reserved attributes (class, id, style, data-*, aria-*, slot)
+ * - **Conservative policy:** Non-reserved attributes are treated as inputs
+ * - **Metadata-aware:** Uses component metadata input declarations if available
+ *
+ * @example
+ * ```typescript
+ * const policy = new InputAttributePolicy();
+ * policy.isInputAttribute('title', host, metadata); // true
+ * policy.isInputAttribute('class', host, metadata); // false (reserved)
+ * policy.isInputAttribute('data-test', host, metadata); // false (reserved)
+ * ```
+ */
+export declare class InputAttributePolicy implements IInputAttributePolicy {
+    /**
+     * Reserved attribute names that should NEVER be treated as inputs.
+     * These are structural/styling attributes managed by the framework.
+     */
+    private static readonly RESERVED_ATTRIBUTES;
+    /**
+     * Reserved attribute prefixes that should NEVER be treated as inputs.
+     */
+    private static readonly RESERVED_PREFIXES;
+    /**
+     * Determines if an attribute should be treated as a component input.
+     *
+     * @param attributeName - Name of the attribute to evaluate
+     * @param hostElement - Host element containing the attribute
+     * @param metadata - Optional component metadata for input declarations
+     * @returns true if attribute is an input; false if it should remain on host
+     * @throws Error if attributeName or hostElement is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const policy = new InputAttributePolicy();
+     *
+     * // Reserved attributes (never inputs)
+     * policy.isInputAttribute('class', host); // false
+     * policy.isInputAttribute('id', host); // false
+     * policy.isInputAttribute('data-test', host); // false
+     * policy.isInputAttribute('aria-label', host); // false
+     *
+     * // Component inputs
+     * policy.isInputAttribute('title', host); // true
+     * policy.isInputAttribute('name', host); // true
+     * policy.isInputAttribute('items', host); // true
+     *
+     * // Bindings are always inputs (detected by BindingResolver)
+     * policy.isInputAttribute('msg', host); // true (if has {{binding}})
+     * ```
+     */
+    isInputAttribute(attributeName: string, hostElement: HTMLElement, metadata?: unknown): boolean;
+}
+//# sourceMappingURL=input-attribute-policy.d.ts.map

package/dist/rendering/managed-host/input-attribute-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-attribute-policy.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/input-attribute-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAqB,YAAW,qBAAqB;IAChE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAkBxC;IAEH;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAIvC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CACd,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO;CAuCX"}

package/dist/rendering/managed-host/input-attribute-policy.interface.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Defines the responsibility of determining which attributes are component inputs.
+ *
+ * @description
+ * Decides which host attributes should be treated as component inputs:
+ * - Stored in SmartInputStore
+ * - Removed from host element DOM
+ * - Trigger 'smart-input-changed' events
+ *
+ * **Policy:**
+ * - Attributes with bindings ({{expression}}) are ALWAYS inputs
+ * - Reserved attributes are NEVER inputs: class, id, style, data-*, aria-*, slot
+ * - Attributes matching component metadata inputs are inputs (if metadata available)
+ * - Fallback: conservative policy treats non-reserved attributes as inputs
+ *
+ * @example
+ * ```typescript
+ * const policy: IInputAttributePolicy = new InputAttributePolicy();
+ * const isInput = policy.isInputAttribute('title', hostElement, metadata);
+ * // true: title should be stored and removed from host
+ * ```
+ */
+export interface IInputAttributePolicy {
+    /**
+     * Determines if an attribute should be treated as a component input.
+     *
+     * @param attributeName - Name of the attribute to evaluate
+     * @param hostElement - Host element containing the attribute
+     * @param metadata - Optional component metadata for input declarations
+     * @returns true if attribute is an input; false if it should remain on host
+     * @throws Error if attributeName or hostElement is null or undefined
+     *
+     * @example
+     * ```typescript
+     * policy.isInputAttribute('class', host, metadata); // false (reserved)
+     * policy.isInputAttribute('data-test', host, metadata); // false (reserved)
+     * policy.isInputAttribute('title', host, metadata); // true (input)
+     * policy.isInputAttribute('name', host, metadata); // true (input)
+     * ```
+     */
+    isInputAttribute(attributeName: string, hostElement: HTMLElement, metadata?: unknown): boolean;
+}
+//# sourceMappingURL=input-attribute-policy.interface.d.ts.map

package/dist/rendering/managed-host/input-attribute-policy.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-attribute-policy.interface.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/input-attribute-policy.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CACd,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CAAC;CACZ"}

package/dist/rendering/managed-host/input-attribute-policy.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=input-attribute-policy.interface.js.map

package/dist/rendering/managed-host/input-attribute-policy.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-attribute-policy.interface.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/input-attribute-policy.interface.ts"],"names":[],"mappings":""}

package/dist/rendering/managed-host/input-attribute-policy.js

@@ -0,0 +1,114 @@
+/**
+ * Implements the responsibility of determining which attributes are component inputs.
+ *
+ * @description
+ * Applies a policy to classify host attributes as inputs or styling/metadata:
+ * - **Always inputs:** Attributes with bindings ({{expression}})
+ * - **Never inputs:** Reserved attributes (class, id, style, data-*, aria-*, slot)
+ * - **Conservative policy:** Non-reserved attributes are treated as inputs
+ * - **Metadata-aware:** Uses component metadata input declarations if available
+ *
+ * @example
+ * ```typescript
+ * const policy = new InputAttributePolicy();
+ * policy.isInputAttribute('title', host, metadata); // true
+ * policy.isInputAttribute('class', host, metadata); // false (reserved)
+ * policy.isInputAttribute('data-test', host, metadata); // false (reserved)
+ * ```
+ */
+export class InputAttributePolicy {
+    /**
+     * Reserved attribute names that should NEVER be treated as inputs.
+     * These are structural/styling attributes managed by the framework.
+     */
+    static RESERVED_ATTRIBUTES = new Set([
+        'class',
+        'id',
+        'style',
+        'slot',
+        'disabled',
+        'role',
+        'tabindex',
+        // Keep structural attributes on host for smart-action, etc.
+        'href',
+        'target',
+        'rel',
+        'type',
+        'name',
+        'value',
+        // smart-action uses 'event' to declare which action to dispatch.
+        // Must stay on the element so resolveActionName can read it via getAttribute.
+        'event'
+    ]);
+    /**
+     * Reserved attribute prefixes that should NEVER be treated as inputs.
+     */
+    static RESERVED_PREFIXES = [
+        'data-',
+        'aria-',
+        'smart-'
+    ];
+    /**
+     * Determines if an attribute should be treated as a component input.
+     *
+     * @param attributeName - Name of the attribute to evaluate
+     * @param hostElement - Host element containing the attribute
+     * @param metadata - Optional component metadata for input declarations
+     * @returns true if attribute is an input; false if it should remain on host
+     * @throws Error if attributeName or hostElement is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const policy = new InputAttributePolicy();
+     *
+     * // Reserved attributes (never inputs)
+     * policy.isInputAttribute('class', host); // false
+     * policy.isInputAttribute('id', host); // false
+     * policy.isInputAttribute('data-test', host); // false
+     * policy.isInputAttribute('aria-label', host); // false
+     *
+     * // Component inputs
+     * policy.isInputAttribute('title', host); // true
+     * policy.isInputAttribute('name', host); // true
+     * policy.isInputAttribute('items', host); // true
+     *
+     * // Bindings are always inputs (detected by BindingResolver)
+     * policy.isInputAttribute('msg', host); // true (if has {{binding}})
+     * ```
+     */
+    isInputAttribute(attributeName, hostElement, metadata) {
+        if (!attributeName) {
+            throw new Error('Attribute name is required');
+        }
+        if (!hostElement) {
+            throw new Error('Host element is required');
+        }
+        // Rule 1: Reserved attributes are NEVER inputs
+        if (InputAttributePolicy.RESERVED_ATTRIBUTES.has(attributeName)) {
+            return false;
+        }
+        // Rule 2: Reserved prefixes are NEVER inputs
+        for (const prefix of InputAttributePolicy.RESERVED_PREFIXES) {
+            if (attributeName.startsWith(prefix)) {
+                return false;
+            }
+        }
+        // Rule 3: Attributes with bindings are ALWAYS inputs
+        const attrValue = hostElement.getAttribute(attributeName);
+        if (attrValue && attrValue.includes('{{')) {
+            return true;
+        }
+        // Rule 4: If metadata declares inputs, use that list
+        if (metadata && typeof metadata === 'object' && 'inputs' in metadata) {
+            const inputsArray = metadata.inputs;
+            if (Array.isArray(inputsArray)) {
+                return inputsArray.includes(attributeName);
+            }
+        }
+        // Rule 5: Conservative fallback - treat as input
+        // This allows components to receive any custom attribute as an input
+        // unless explicitly reserved by rules 1-2
+        return true;
+    }
+}
+//# sourceMappingURL=input-attribute-policy.js.map

package/dist/rendering/managed-host/input-attribute-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-attribute-policy.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/input-attribute-policy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,oBAAoB;IAC/B;;;OAGG;IACK,MAAM,CAAU,mBAAmB,GAAG,IAAI,GAAG,CAAC;QACpD,OAAO;QACP,IAAI;QACJ,OAAO;QACP,MAAM;QACN,UAAU;QACV,MAAM;QACN,UAAU;QACV,4DAA4D;QAC5D,MAAM;QACN,QAAQ;QACR,KAAK;QACL,MAAM;QACN,MAAM;QACN,OAAO;QACP,iEAAiE;QACjE,8EAA8E;QAC9E,OAAO;KACR,CAAC,CAAC;IAEH;;OAEG;IACK,MAAM,CAAU,iBAAiB,GAAG;QAC1C,OAAO;QACP,OAAO;QACP,QAAQ;KACT,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CACd,aAAqB,EACrB,WAAwB,EACxB,QAAkB;QAElB,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QAED,+CAA+C;QAC/C,IAAI,oBAAoB,CAAC,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;YAChE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,6CAA6C;QAC7C,KAAK,MAAM,MAAM,IAAI,oBAAoB,CAAC,iBAAiB,EAAE,CAAC;YAC5D,IAAI,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBACrC,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QAED,qDAAqD;QACrD,MAAM,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;QAC1D,IAAI,SAAS,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC;QACd,CAAC;QAED,qDAAqD;QACrD,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACrE,MAAM,WAAW,GAAI,QAAoC,CAAC,MAAM,CAAC;YACjE,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC/B,OAAO,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC;QAED,iDAAiD;QACjD,qEAAqE;QACrE,0CAA0C;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC"}

package/dist/rendering/managed-host/managed-element-registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Defines the responsibility of tracking elements managed by the SmartComponents engine.
+ */
+export interface IManagedElementRegistry {
+    /**
+     * Registers an element as managed by SmartComponents engine.
+     *
+     * @param element - Element to register
+     * @param componentId - Component selector/ID for debugging
+     * @throws Error if element or componentId is null/undefined
+     */
+    register(element: Element, componentId: string): void;
+    /**
+     * Checks if an element is managed by SmartComponents engine.
+     *
+     * @param element - Element to check
+     * @returns true if element is registered as managed
+     */
+    isManagedElement(element: Element): boolean;
+    /**
+     * Gets the componentId for a managed element.
+     *
+     * @param element - Managed element
+     * @returns Component ID if element is managed; undefined otherwise
+     */
+    getComponentId(element: Element): string | undefined;
+    /**
+     * Unregisters an element from managed tracking.
+     *
+     * @param element - Element to unregister
+     */
+    unregister(element: Element): void;
+}
+export declare const ManagedElementRegistry: IManagedElementRegistry;
+//# sourceMappingURL=managed-element-registry.d.ts.map

package/dist/rendering/managed-host/managed-element-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-registry.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtD;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;IAE5C;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IAErD;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACpC;AA+BD,eAAO,MAAM,sBAAsB,EAAE,uBA6EpC,CAAC"}

package/dist/rendering/managed-host/managed-element-registry.js

@@ -0,0 +1,103 @@
+/**
+ * Implements a global registry for managed elements.
+ *
+ * @description
+ * Central WeakMap-based registry that tracks Elements rendered by SmartComponents engine.
+ * When the engine/pipeline renders a component (host or nested), it registers the Element
+ * with its componentId/metadata. This registry provides the authoritative source for
+ * determining if an Element is managed, independent of tag name heuristics.
+ *
+ * **Usage Pattern:**
+ * 1. RenderPipeline registers host element when rendering component
+ * 2. TemplateCompiler/BindingResolver registers nested component elements
+ * 3. IManagedElementResolver queries this registry
+ *
+ * @example
+ * ```typescript
+ * // Register element as managed
+ * ManagedElementRegistry.register(element, 'my-component');
+ *
+ * // Query element status
+ * const isManaged = ManagedElementRegistry.isManagedElement(element); // true
+ *
+ * // Unregister on cleanup
+ * ManagedElementRegistry.unregister(element);
+ * ```
+ */
+const registry = new WeakMap();
+export const ManagedElementRegistry = {
+    /**
+     * Registers an element as managed by SmartComponents engine.
+     *
+     * @param element - Element to register (host or nested component element)
+     * @param componentId - Component selector/ID for debugging/tracing
+     * @throws Error if element or componentId is null/undefined
+     *
+     * @example
+     * ```typescript
+     * // Register host element
+     * ManagedElementRegistry.register(hostElement, 'my-component');
+     *
+     * // Register nested component element
+     * ManagedElementRegistry.register(nestedElement, 'child-component');
+     * ```
+     */
+    register(element, componentId) {
+        if (!element) {
+            throw new Error("Element is required");
+        }
+        if (!componentId) {
+            throw new Error("Component ID is required");
+        }
+        registry.set(element, componentId);
+    },
+    /**
+     * Checks if an element is managed by SmartComponents engine.
+     *
+     * @param element - Element to check
+     * @returns true if element is registered as managed; false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (ManagedElementRegistry.isManagedElement(element)) {
+     *   // Apply managed element policies
+     * }
+     * ```
+     */
+    isManagedElement(element) {
+        if (!element) {
+            return false;
+        }
+        return registry.has(element);
+    },
+    /**
+     * Gets the componentId for a managed element.
+     *
+     * @param element - Managed element
+     * @returns Component ID if element is managed; undefined otherwise
+     */
+    getComponentId(element) {
+        if (!element) {
+            return undefined;
+        }
+        return registry.get(element);
+    },
+    /**
+     * Unregisters an element from managed tracking.
+     *
+     * @param element - Element to unregister
+     *
+     * @example
+     * ```typescript
+     * // Cleanup on component destroy
+     * ManagedElementRegistry.unregister(element);
+     * ```
+     */
+    unregister(element) {
+        if (!element) {
+            return;
+        }
+        registry.delete(element);
+    },
+};
+//# sourceMappingURL=managed-element-registry.js.map

package/dist/rendering/managed-host/managed-element-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-registry.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-registry.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAmB,CAAC;AAEhD,MAAM,CAAC,MAAM,sBAAsB,GAA4B;IAC7D;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,OAAgB,EAAE,WAAmB;QAC5C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,OAAgB;QAC/B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,OAAgB;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;OAUG;IACH,UAAU,CAAC,OAAgB;QACzB,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;CACF,CAAC"}

package/dist/rendering/managed-host/managed-element-resolver.d.ts

@@ -0,0 +1,27 @@
+import { IManagedElementResolver } from "./managed-element-resolver.interface.js";
+import type { IManagedElementRegistry } from "./managed-element-registry.js";
+/**
+ * Implements the responsibility of determining if an Element is managed by SmartComponents.
+ *
+ * @description
+ * Provides authoritative answer based on IManagedElementRegistry, which tracks actual
+ * component associations created by the rendering pipeline. Does NOT use tag name heuristics.
+ */
+export declare class ManagedElementResolver implements IManagedElementResolver {
+    private readonly registry;
+    /**
+     * Initializes a new instance of ManagedElementResolver.
+     *
+     * @param registry - Registry for managed element tracking
+     * @throws Error if registry is null or undefined
+     */
+    constructor(registry: IManagedElementRegistry);
+    /**
+     * Determines if an element is managed by SmartComponents engine.
+     *
+     * @param element - Element to check for SmartComponent association
+     * @returns true if element is registered in ManagedElementRegistry; false otherwise
+     */
+    isManagedElement(element: Element): boolean;
+}
+//# sourceMappingURL=managed-element-resolver.d.ts.map

package/dist/rendering/managed-host/managed-element-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-resolver.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,uBAAuB;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IAEnD;;;;;OAKG;gBACS,QAAQ,EAAE,uBAAuB;IAK7C;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;CAG5C"}

package/dist/rendering/managed-host/managed-element-resolver.interface.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Defines the responsibility of determining if an Element is managed by SmartComponents.
+ *
+ * @description
+ * A managed element is one that has an associated SmartComponent instance rendered
+ * by the SmartComponents engine, regardless of its tag name. This resolver provides
+ * the authoritative answer based on actual component registration, NOT tag name heuristics.
+ *
+ * @example
+ * ```typescript
+ * const resolver: IManagedElementResolver = new ManagedElementResolver();
+ * const isManaged = resolver.isManagedElement(element);
+ * if (isManaged) {
+ *   // Element has SmartComponent association - apply managed policies
+ * }
+ * ```
+ */
+export interface IManagedElementResolver {
+    /**
+     * Determines if an element is managed by SmartComponents engine.
+     *
+     * @param element - Element to check for SmartComponent association
+     * @returns true if element has associated SmartComponent; false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Managed: element rendered by engine with componentId/metadata
+     * resolver.isManagedElement(hostElement); // true
+     *
+     * // Not managed: regular HTML or external custom element
+     * resolver.isManagedElement(divElement); // false
+     * ```
+     */
+    isManagedElement(element: Element): boolean;
+}
+//# sourceMappingURL=managed-element-resolver.interface.d.ts.map

package/dist/rendering/managed-host/managed-element-resolver.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-resolver.interface.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-resolver.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;CAC7C"}

package/dist/rendering/managed-host/managed-element-resolver.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=managed-element-resolver.interface.js.map

package/dist/rendering/managed-host/managed-element-resolver.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-resolver.interface.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-resolver.interface.ts"],"names":[],"mappings":""}

package/dist/rendering/managed-host/managed-element-resolver.js

@@ -0,0 +1,31 @@
+/**
+ * Implements the responsibility of determining if an Element is managed by SmartComponents.
+ *
+ * @description
+ * Provides authoritative answer based on IManagedElementRegistry, which tracks actual
+ * component associations created by the rendering pipeline. Does NOT use tag name heuristics.
+ */
+export class ManagedElementResolver {
+    registry;
+    /**
+     * Initializes a new instance of ManagedElementResolver.
+     *
+     * @param registry - Registry for managed element tracking
+     * @throws Error if registry is null or undefined
+     */
+    constructor(registry) {
+        if (!registry)
+            throw new Error("ManagedElementRegistry is required");
+        this.registry = registry;
+    }
+    /**
+     * Determines if an element is managed by SmartComponents engine.
+     *
+     * @param element - Element to check for SmartComponent association
+     * @returns true if element is registered in ManagedElementRegistry; false otherwise
+     */
+    isManagedElement(element) {
+        return this.registry.isManagedElement(element);
+    }
+}
+//# sourceMappingURL=managed-element-resolver.js.map

package/dist/rendering/managed-host/managed-element-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-element-resolver.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-element-resolver.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,MAAM,OAAO,sBAAsB;IAChB,QAAQ,CAA0B;IAEnD;;;;;OAKG;IACH,YAAY,QAAiC;QAC3C,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACrE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,OAAgB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;CACF"}

package/dist/rendering/managed-host/managed-host-context.interface.d.ts

@@ -0,0 +1,31 @@
+import { SmartComponent } from '../../core/smart-component.js';
+import { ComponentMetadata } from '../../core/component-metadata.js';
+/**
+ * Defines the responsibility of representing a managed host element.
+ *
+ * @description
+ * A managed host is an HTMLElement that is being rendered by the SmartComponents
+ * engine with an associated SmartComponent instance. This context captures the
+ * local rendering state where we have access to both the host element and its
+ * component metadata.
+ *
+ * @example
+ * ```typescript
+ * const context: IManagedHostContext = {
+ *   hostElement: document.querySelector('my-component'),
+ *   componentId: 'my-component',
+ *   metadata: ComponentMetadataRegistry.get('my-component')
+ * };
+ * ```
+ */
+export interface IManagedHostContext {
+    /** The host HTMLElement being managed by the rendering engine */
+    readonly hostElement: HTMLElement;
+    /** Component ID (selector) for metadata lookup */
+    readonly componentId: string;
+    /** Component metadata (template, lifecycle, etc) */
+    readonly metadata: ComponentMetadata;
+    /** Component instance (available after initialization) */
+    readonly instance?: SmartComponent;
+}
+//# sourceMappingURL=managed-host-context.interface.d.ts.map

package/dist/rendering/managed-host/managed-host-context.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-host-context.interface.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-host-context.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;CACpC"}

package/dist/rendering/managed-host/managed-host-context.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=managed-host-context.interface.js.map

package/dist/rendering/managed-host/managed-host-context.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-host-context.interface.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/managed-host-context.interface.ts"],"names":[],"mappings":""}

package/dist/rendering/managed-host/outlet-resolver.d.ts

@@ -0,0 +1,43 @@
+import { IOutletResolver } from "./outlet-resolver.interface.js";
+/**
+ * Implements the responsibility of locating the target outlet element within a rendered component.
+ *
+ * @description
+ * Resolves the outlet element using a prioritized strategy:
+ * 1. Element with `.outlet` class (explicit outlet marker)
+ * 2. First child element if root has single child (common pattern)
+ * 3. Fallback: rootElement itself (conservative approach)
+ *
+ * @example
+ * ```typescript
+ * const resolver = new OutletResolver();
+ * const outlet = resolver.resolve(compiledElement);
+ * // Returns the element that should receive host styling
+ * ```
+ */
+export declare class OutletResolver implements IOutletResolver {
+    /**
+     * Resolves the outlet element within a compiled component root.
+     *
+     * @param rootElement - The compiled component root element
+     * @returns The outlet element that should receive host styling
+     * @throws Error if rootElement is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Template: <div><span class="outlet"></span></div>
+     * const outlet = resolver.resolve(rootElement);
+     * // Returns the span.outlet element
+     *
+     * // Template: <div><span>content</span></div>
+     * const outlet = resolver.resolve(rootElement);
+     * // Returns the span (single child)
+     *
+     * // Template: <div>multiple<span>children</span></div>
+     * const outlet = resolver.resolve(rootElement);
+     * // Returns rootElement (fallback)
+     * ```
+     */
+    resolve(rootElement: HTMLElement): HTMLElement;
+}
+//# sourceMappingURL=outlet-resolver.d.ts.map

package/dist/rendering/managed-host/outlet-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlet-resolver.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/outlet-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW;CAyB/C"}

package/dist/rendering/managed-host/outlet-resolver.interface.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Defines the responsibility of locating the target outlet element within a rendered component.
+ *
+ * @description
+ * The outlet is the element that should receive host styling (class/id migration).
+ * Resolution strategy:
+ * 1. Element with `.outlet` class
+ * 2. First child element (if single root)
+ * 3. Fallback: the rootElement itself
+ *
+ * @example
+ * ```typescript
+ * const resolver: IOutletResolver = new OutletResolver();
+ * const outlet = resolver.resolve(compiledElement);
+ * // outlet could be .outlet element, first child, or compiledElement itself
+ * ```
+ */
+export interface IOutletResolver {
+    /**
+     * Resolves the outlet element within a compiled component root.
+     *
+     * @param rootElement - The compiled component root element
+     * @returns The outlet element that should receive host styling
+     * @throws Error if rootElement is null or undefined
+     */
+    resolve(rootElement: HTMLElement): HTMLElement;
+}
+//# sourceMappingURL=outlet-resolver.interface.d.ts.map

package/dist/rendering/managed-host/outlet-resolver.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlet-resolver.interface.d.ts","sourceRoot":"","sources":["../../../src/rendering/managed-host/outlet-resolver.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;CAChD"}

package/dist/rendering/managed-host/outlet-resolver.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outlet-resolver.interface.js.map

package/dist/rendering/managed-host/outlet-resolver.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlet-resolver.interface.js","sourceRoot":"","sources":["../../../src/rendering/managed-host/outlet-resolver.interface.ts"],"names":[],"mappings":""}