@elurjs/core 3.6.1 → 3.7.0-beta.0

package/dist/lib/elur/next/component.d.cts

@@ -0,0 +1,281 @@
+/**
+ * Elur "next" — kernel unificado de componentes (experimental).
+ *
+ * Implementa A.6–A.9 del PLAN_TECNICO_ELUR_NEXT sobre el ownership de
+ * `./reactivity.ts`:
+ *  - Una sola `ComponentInstance` para clases y funciones (adaptadores).
+ *  - Máquina de estados (A.7): created → initializing → rendering →
+ *    pending-mount → mounted → disposing → disposed (o failed).
+ *  - Mount transaccional (A.9): cualquier fallo dispara rollback —
+ *    cleanups registrados, owner reactivo disposed, DOM insertado removido.
+ *  - `unmount()` idempotente (A.2.10).
+ *  - `onMount` corre DESPUÉS del commit DOM (A.2.9).
+ *  - Todo lo creado en setup/render pertenece al owner de la instancia y
+ *    muere con unmount (A.2.1 — no más effects huérfanos).
+ *
+ * Las invocaciones implementan `ELUR_RENDER_PROTOCOL.mountDom`, así el
+ * renderer existente las monta sin saber que son componentes.
+ */
+import { Owner, Signal, type Disposable, type OwnerLike } from "./reactivity.js";
+import { type ElurComponent, type ComponentController } from "../lifecycle.js";
+import { ELUR_RENDER_PROTOCOL, type DomProtocolContext } from "../template/types.js";
+export type ComponentState = "created" | "initializing" | "rendering" | "pending-mount" | "mounted" | "deactivated" | "disposing" | "disposed" | "failed";
+/** Fase del lifecycle donde ocurrió el error. */
+export type ErrorPhase = "setup" | "init" | "render" | "hydrate" | "mount" | "effect" | "activate" | "deactivate" | "cleanup" | "unmount";
+/** Información estructurada del error (A.16). */
+export interface ComponentErrorInfo {
+    phase: ErrorPhase;
+    /** Instancia donde ocurrió el error (no la boundary que lo maneja). */
+    component: ComponentInstance;
+    cause: unknown;
+}
+/** Resolución de una boundary (A.16). */
+export type ErrorResolution = {
+    handled: false;
+} | {
+    handled: true;
+    fallback?: Renderable;
+} | {
+    handled: true;
+    retry: true;
+};
+export interface ComponentHooks {
+    /** Tras el commit DOM. Puede devolver cleanup (corre en unmount). */
+    onMount?: () => (() => void) | void;
+    /** Antes de remover el DOM. */
+    onUnmount?: () => void;
+    /**
+     * Boundary de errores (A.16): recibe info estructurada; el error burbujea
+     * por la cadena de instancias hasta una boundary que devuelva handled.
+     * `void` = manejado sin más.
+     */
+    onError?: (info: ComponentErrorInfo) => ErrorResolution | void;
+    /** A.17: tras setup durante SSR — nunca en cliente. */
+    onServerRender?: () => void;
+}
+/** Contexto que recibe el setup de un componente funcional. */
+export interface SetupCtx {
+    onMount(fn: () => (() => void) | void): void;
+    onUnmount(fn: () => void): void;
+    onError(fn: (info: ComponentErrorInfo) => ErrorResolution | void): void;
+    /** A.17: hook server-side — corre tras setup durante SSR, nunca en cliente. */
+    onServerRender(fn: () => void): void;
+    /** Owner de la instancia — para runWithOwner/getOwner manual. */
+    readonly owner: OwnerLike;
+    /** Señal interna de una prop (A.13) — para acceso reactivo explícito. */
+    propSignal<K extends string>(key: K): Signal<unknown> | undefined;
+    /**
+     * A.14: renderiza el contenido de un slot (lazy — corre el render del
+     * slot bajo el owner del padre que lo declaró). `"default"` por defecto.
+     */
+    slot(name?: string): unknown;
+    /** A.14: slots declarados en la invocación. */
+    readonly slots: Record<string, Slot> | undefined;
+}
+interface RenderableValue {
+    _render(parent: Node, before: Node | null): () => void;
+}
+/** Renderable común: cualquier cosa montable en un binding. */
+export type Renderable = ElurComponent | ComponentInvocation<unknown> | Slot | {
+    _render(parent: Node, before: Node | null): () => void;
+} | string | number | bigint | false | null | undefined | Renderable[];
+/**
+ * Slot lazy y marcado (A.14): el contenido se renderiza bajo el owner del
+ * padre que LO DECLARÓ (contexto léxico), aunque se monte dentro del
+ * componente consumidor.
+ */
+export interface Slot {
+    readonly __isElurSlot: true;
+    /** Owner capturado en el punto de declaración (contexto léxico). */
+    readonly owner: OwnerLike | null;
+    render(): unknown;
+}
+export declare function slot(render: () => unknown): Slot;
+export declare function isElurSlot(v: unknown): v is Slot;
+export declare class ComponentInstance implements Disposable {
+    readonly id: number;
+    readonly kind: "class" | "function";
+    state: ComponentState;
+    /** Owner reactivo de la instancia — todo lo creado dentro muere con él. */
+    readonly owner: Owner;
+    /** Instancia padre (owner activo cuando se creó esta instancia). */
+    parent: ComponentInstance | null;
+    hooks: ComponentHooks;
+    renderable: RenderableValue | null;
+    /** A.12: frame de provide/inject propio de la instancia — permanente. */
+    readonly context: Map<unknown, unknown>;
+    private _inst;
+    private _invocation;
+    private _renderCleanup;
+    private _mountCleanups;
+    /** A.13: señales internas por prop + objeto live pasado al setup. */
+    private _propSignals;
+    private _liveProps;
+    /** A.16: fase actual del lifecycle — para el ComponentErrorInfo. */
+    private _phase;
+    /** A.16: posición de montaje — para renderizar fallback de boundary. */
+    private _mountParent;
+    private _mountBefore;
+    /** A.3.8: nodos DOM de la instancia — para detach/attach. */
+    private _domNodes;
+    /** A.21: controllers de ciclo de vida (Lit-style). */
+    private _controllers;
+    constructor(source: ElurComponent | ComponentInvocation<any>);
+    /**
+     * Mount transaccional (A.9). Cualquier fase que falle → rollback completo:
+     * owner disposed, cleanups corridos, DOM insertado removido, state=failed.
+     *
+     * Opciones:
+     *  - `ctxSnapshot`: contexto capturado en el punto de declaración
+     *    (mounts dentro de effects dinámicos heredan provide/inject).
+     *  - `deferOnMount`: recibe una función `fire()` que corre onMount; el
+     *    caller decide cuándo invocarla (fragments aún no insertados).
+     */
+    mount(parent: Node, before: Node | null, opts?: {
+        ctxSnapshot?: Map<unknown, unknown>[];
+        deferOnMount?: (fire: () => void) => void;
+        /** Valores a proveer en el frame de contexto de la instancia (A.12). */
+        provides?: Iterable<readonly [unknown, unknown]>;
+        /**
+         * A.14: owner del declarante — para contenido de slots, el owner padre
+         * es el del padre que declaró el contenido, no el del punto de montaje.
+         */
+        declOwner?: OwnerLike | null;
+    }): void;
+    /** A.21: registra un controller — sus hooks corren bajo este owner. */
+    addController(c: ComponentController): void;
+    /**
+     * A.3.8: saca el DOM de la instancia SIN disponer nada — effects, signals
+     * y contexto siguen vivos (página cached, Suspense, transición). No-op si
+     * no está montado.
+     */
+    detach(): void;
+    /**
+     * A.3.8: reinserta el DOM de una instancia detached en la posición original
+     * (o en parent/before dados). No-op si no está deactivated.
+     */
+    attach(parent?: Node, before?: Node | null): void;
+    /** Idempotente (A.2.10): disponer dos veces es seguro. */
+    unmount(): void;
+    dispose(): void;
+    /** @internal — corre onMount una vez; no-op si ya no está montado. */
+    _runOnMount(): void;
+    /**
+     * @internal A.16: intenta manejar el error con el boundary propio.
+     * `null` = este nodo no tiene boundary — seguir subiendo.
+     */
+    _handleError(info: ComponentErrorInfo): ErrorResolution | null;
+    /** A.16: errores de teardown — se reportan a la cadena; si nadie los maneja quedan registrados. */
+    private _reportSwallowed;
+    /** A.16: renderiza el fallback de una boundary en la posición del componente. */
+    private _renderFallback;
+    /** Camina la cadena de owners hasta la instancia registrada más cercana. */
+    private _resolveParent;
+    private _rollback;
+    private _makeSetupCtx;
+    /** Fases initializing+rendering: setup/onInit + render → this.renderable. */
+    private _initBody;
+    /** Corre `body` dentro del frame de contexto (snapshot o frame nuevo). */
+    private _withScope;
+    /**
+     * A.18 — hidratación: setup/onInit + render una sola vez, luego adopta el
+     * DOM SSR via ctx.render (que activa bindings dentro del owner de la
+     * instancia). En mismatch: rollback de la activación + remount por el mismo
+     * kernel REUSANDO el renderable — setup/onInit no se duplica.
+     */
+    _hydrate(ctx: {
+        parent: Node;
+        bounds: {
+            start: Comment;
+            end: Comment;
+        } | null;
+        render(value: unknown): unknown;
+    }): void;
+    /**
+     * A.17 — SSR: setup/onInit + onServerRender + serializar el renderable.
+     * NO corre onMount/onUnmount; el owner server-side se dispone al final
+     * (mata effects/computeds creados en setup).
+     */
+    _renderServer(sctx: {
+        markers?: boolean;
+        render(value: unknown, options?: {
+            markers?: boolean;
+        }): string | Promise<string>;
+    }): Promise<string>;
+    /**
+     * A.13 — crea el objeto LiveProps: propiedades readonly respaldadas por
+     * signals. OJO: destructurar props en setup crea snapshots no reactivos.
+     */
+    private _initProps;
+    /**
+     * A.13/A.15 — true si `inv` es la misma definición con la misma key:
+     * entonces el runtime debe actualizar props, no recrear el setup.
+     */
+    matches(inv: ComponentInvocation<any>): boolean;
+    /**
+     * A.13 — actualiza props sin recrear setup: escribe cada signal de prop.
+     * Props nuevas se añaden; props desaparecidas quedan en undefined.
+     */
+    updateProps(props: unknown): void;
+}
+/**
+ * A.16: burbujeo de errores por la cadena de instancias (padres reales del
+ * árbol de componentes). Devuelve la primera resolución manejada; si nadie
+ * maneja el error, `{ handled: false }` y el caller decide (re-lanzar o
+ * registrar).
+ */
+export declare function reportError(from: ComponentInstance, info: ComponentErrorInfo): ErrorResolution;
+/** Envuelve un ElurComponent de clase en el kernel unificado. */
+export declare function adaptClassComponent(inst: ElurComponent): ComponentInstance;
+export interface ComponentDefinition<P> {
+    (props?: P, slots?: Record<string, Slot>): ComponentInvocation<P>;
+    readonly setup: (props: P | undefined, ctx: SetupCtx) => unknown;
+    readonly _isComponentDefinition: true;
+}
+/** Invocación marcada: `Counter({ initial: 10 })` NO ejecuta setup — monta después. */
+export declare class ComponentInvocation<P> {
+    readonly [ELUR_RENDER_PROTOCOL]: {
+        mountDom: (ctx: DomProtocolContext) => (() => void);
+        renderServer: (sctx: {
+            markers?: boolean;
+            render(value: unknown, options?: {
+                markers?: boolean;
+            }): string | Promise<string>;
+        }) => Promise<string>;
+        hydrateDom: (ctx: {
+            parent: Node;
+            bounds: {
+                start: Comment;
+                end: Comment;
+            } | null;
+            render(value: unknown): unknown;
+        }) => (() => void);
+    };
+    readonly definition: ComponentDefinition<P>;
+    readonly props: P | undefined;
+    /** A.14: slots declarados en la llamada — `Card(props, { default: slot(...) })`. */
+    readonly slots: Record<string, Slot> | undefined;
+    constructor(definition: ComponentDefinition<P>, props: P | undefined, slots?: Record<string, Slot>);
+}
+export declare function isComponentInvocation(v: unknown): v is ComponentInvocation<any>;
+/**
+ * @internal — registra un frame de contexto para un owner raíz (mount de
+ * template con router, roots de app, etc).
+ */
+export declare function _registerContextOwner(owner: OwnerLike, context: Map<unknown, unknown>): void;
+/**
+ * Define un componente funcional de primera clase (A.5):
+ * `Counter(props)` retorna una invocación marcada; el runtime ejecuta el
+ * setup cuando monta la invocación.
+ */
+export declare function defineComponent<P = Record<string, never>>(setup: (props: P | undefined, ctx: SetupCtx) => unknown): ComponentDefinition<P>;
+/**
+ * Monta un componente (clase o invocación funcional) en `container` y
+ * devuelve el handle con `unmount()`. Todo el árbol reactivo muere con el
+ * unmount — sin fugas de effects/computeds.
+ */
+export declare function mountComponent(value: ElurComponent | ComponentInvocation<any>, container: Element): {
+    unmount(): void;
+    instance: ComponentInstance;
+};
+export {};

package/dist/lib/elur/next/component.d.ts

@@ -0,0 +1,281 @@
+/**
+ * Elur "next" — kernel unificado de componentes (experimental).
+ *
+ * Implementa A.6–A.9 del PLAN_TECNICO_ELUR_NEXT sobre el ownership de
+ * `./reactivity.ts`:
+ *  - Una sola `ComponentInstance` para clases y funciones (adaptadores).
+ *  - Máquina de estados (A.7): created → initializing → rendering →
+ *    pending-mount → mounted → disposing → disposed (o failed).
+ *  - Mount transaccional (A.9): cualquier fallo dispara rollback —
+ *    cleanups registrados, owner reactivo disposed, DOM insertado removido.
+ *  - `unmount()` idempotente (A.2.10).
+ *  - `onMount` corre DESPUÉS del commit DOM (A.2.9).
+ *  - Todo lo creado en setup/render pertenece al owner de la instancia y
+ *    muere con unmount (A.2.1 — no más effects huérfanos).
+ *
+ * Las invocaciones implementan `ELUR_RENDER_PROTOCOL.mountDom`, así el
+ * renderer existente las monta sin saber que son componentes.
+ */
+import { Owner, Signal, type Disposable, type OwnerLike } from "./reactivity.js";
+import { type ElurComponent, type ComponentController } from "../lifecycle.js";
+import { ELUR_RENDER_PROTOCOL, type DomProtocolContext } from "../template/types.js";
+export type ComponentState = "created" | "initializing" | "rendering" | "pending-mount" | "mounted" | "deactivated" | "disposing" | "disposed" | "failed";
+/** Fase del lifecycle donde ocurrió el error. */
+export type ErrorPhase = "setup" | "init" | "render" | "hydrate" | "mount" | "effect" | "activate" | "deactivate" | "cleanup" | "unmount";
+/** Información estructurada del error (A.16). */
+export interface ComponentErrorInfo {
+    phase: ErrorPhase;
+    /** Instancia donde ocurrió el error (no la boundary que lo maneja). */
+    component: ComponentInstance;
+    cause: unknown;
+}
+/** Resolución de una boundary (A.16). */
+export type ErrorResolution = {
+    handled: false;
+} | {
+    handled: true;
+    fallback?: Renderable;
+} | {
+    handled: true;
+    retry: true;
+};
+export interface ComponentHooks {
+    /** Tras el commit DOM. Puede devolver cleanup (corre en unmount). */
+    onMount?: () => (() => void) | void;
+    /** Antes de remover el DOM. */
+    onUnmount?: () => void;
+    /**
+     * Boundary de errores (A.16): recibe info estructurada; el error burbujea
+     * por la cadena de instancias hasta una boundary que devuelva handled.
+     * `void` = manejado sin más.
+     */
+    onError?: (info: ComponentErrorInfo) => ErrorResolution | void;
+    /** A.17: tras setup durante SSR — nunca en cliente. */
+    onServerRender?: () => void;
+}
+/** Contexto que recibe el setup de un componente funcional. */
+export interface SetupCtx {
+    onMount(fn: () => (() => void) | void): void;
+    onUnmount(fn: () => void): void;
+    onError(fn: (info: ComponentErrorInfo) => ErrorResolution | void): void;
+    /** A.17: hook server-side — corre tras setup durante SSR, nunca en cliente. */
+    onServerRender(fn: () => void): void;
+    /** Owner de la instancia — para runWithOwner/getOwner manual. */
+    readonly owner: OwnerLike;
+    /** Señal interna de una prop (A.13) — para acceso reactivo explícito. */
+    propSignal<K extends string>(key: K): Signal<unknown> | undefined;
+    /**
+     * A.14: renderiza el contenido de un slot (lazy — corre el render del
+     * slot bajo el owner del padre que lo declaró). `"default"` por defecto.
+     */
+    slot(name?: string): unknown;
+    /** A.14: slots declarados en la invocación. */
+    readonly slots: Record<string, Slot> | undefined;
+}
+interface RenderableValue {
+    _render(parent: Node, before: Node | null): () => void;
+}
+/** Renderable común: cualquier cosa montable en un binding. */
+export type Renderable = ElurComponent | ComponentInvocation<unknown> | Slot | {
+    _render(parent: Node, before: Node | null): () => void;
+} | string | number | bigint | false | null | undefined | Renderable[];
+/**
+ * Slot lazy y marcado (A.14): el contenido se renderiza bajo el owner del
+ * padre que LO DECLARÓ (contexto léxico), aunque se monte dentro del
+ * componente consumidor.
+ */
+export interface Slot {
+    readonly __isElurSlot: true;
+    /** Owner capturado en el punto de declaración (contexto léxico). */
+    readonly owner: OwnerLike | null;
+    render(): unknown;
+}
+export declare function slot(render: () => unknown): Slot;
+export declare function isElurSlot(v: unknown): v is Slot;
+export declare class ComponentInstance implements Disposable {
+    readonly id: number;
+    readonly kind: "class" | "function";
+    state: ComponentState;
+    /** Owner reactivo de la instancia — todo lo creado dentro muere con él. */
+    readonly owner: Owner;
+    /** Instancia padre (owner activo cuando se creó esta instancia). */
+    parent: ComponentInstance | null;
+    hooks: ComponentHooks;
+    renderable: RenderableValue | null;
+    /** A.12: frame de provide/inject propio de la instancia — permanente. */
+    readonly context: Map<unknown, unknown>;
+    private _inst;
+    private _invocation;
+    private _renderCleanup;
+    private _mountCleanups;
+    /** A.13: señales internas por prop + objeto live pasado al setup. */
+    private _propSignals;
+    private _liveProps;
+    /** A.16: fase actual del lifecycle — para el ComponentErrorInfo. */
+    private _phase;
+    /** A.16: posición de montaje — para renderizar fallback de boundary. */
+    private _mountParent;
+    private _mountBefore;
+    /** A.3.8: nodos DOM de la instancia — para detach/attach. */
+    private _domNodes;
+    /** A.21: controllers de ciclo de vida (Lit-style). */
+    private _controllers;
+    constructor(source: ElurComponent | ComponentInvocation<any>);
+    /**
+     * Mount transaccional (A.9). Cualquier fase que falle → rollback completo:
+     * owner disposed, cleanups corridos, DOM insertado removido, state=failed.
+     *
+     * Opciones:
+     *  - `ctxSnapshot`: contexto capturado en el punto de declaración
+     *    (mounts dentro de effects dinámicos heredan provide/inject).
+     *  - `deferOnMount`: recibe una función `fire()` que corre onMount; el
+     *    caller decide cuándo invocarla (fragments aún no insertados).
+     */
+    mount(parent: Node, before: Node | null, opts?: {
+        ctxSnapshot?: Map<unknown, unknown>[];
+        deferOnMount?: (fire: () => void) => void;
+        /** Valores a proveer en el frame de contexto de la instancia (A.12). */
+        provides?: Iterable<readonly [unknown, unknown]>;
+        /**
+         * A.14: owner del declarante — para contenido de slots, el owner padre
+         * es el del padre que declaró el contenido, no el del punto de montaje.
+         */
+        declOwner?: OwnerLike | null;
+    }): void;
+    /** A.21: registra un controller — sus hooks corren bajo este owner. */
+    addController(c: ComponentController): void;
+    /**
+     * A.3.8: saca el DOM de la instancia SIN disponer nada — effects, signals
+     * y contexto siguen vivos (página cached, Suspense, transición). No-op si
+     * no está montado.
+     */
+    detach(): void;
+    /**
+     * A.3.8: reinserta el DOM de una instancia detached en la posición original
+     * (o en parent/before dados). No-op si no está deactivated.
+     */
+    attach(parent?: Node, before?: Node | null): void;
+    /** Idempotente (A.2.10): disponer dos veces es seguro. */
+    unmount(): void;
+    dispose(): void;
+    /** @internal — corre onMount una vez; no-op si ya no está montado. */
+    _runOnMount(): void;
+    /**
+     * @internal A.16: intenta manejar el error con el boundary propio.
+     * `null` = este nodo no tiene boundary — seguir subiendo.
+     */
+    _handleError(info: ComponentErrorInfo): ErrorResolution | null;
+    /** A.16: errores de teardown — se reportan a la cadena; si nadie los maneja quedan registrados. */
+    private _reportSwallowed;
+    /** A.16: renderiza el fallback de una boundary en la posición del componente. */
+    private _renderFallback;
+    /** Camina la cadena de owners hasta la instancia registrada más cercana. */
+    private _resolveParent;
+    private _rollback;
+    private _makeSetupCtx;
+    /** Fases initializing+rendering: setup/onInit + render → this.renderable. */
+    private _initBody;
+    /** Corre `body` dentro del frame de contexto (snapshot o frame nuevo). */
+    private _withScope;
+    /**
+     * A.18 — hidratación: setup/onInit + render una sola vez, luego adopta el
+     * DOM SSR via ctx.render (que activa bindings dentro del owner de la
+     * instancia). En mismatch: rollback de la activación + remount por el mismo
+     * kernel REUSANDO el renderable — setup/onInit no se duplica.
+     */
+    _hydrate(ctx: {
+        parent: Node;
+        bounds: {
+            start: Comment;
+            end: Comment;
+        } | null;
+        render(value: unknown): unknown;
+    }): void;
+    /**
+     * A.17 — SSR: setup/onInit + onServerRender + serializar el renderable.
+     * NO corre onMount/onUnmount; el owner server-side se dispone al final
+     * (mata effects/computeds creados en setup).
+     */
+    _renderServer(sctx: {
+        markers?: boolean;
+        render(value: unknown, options?: {
+            markers?: boolean;
+        }): string | Promise<string>;
+    }): Promise<string>;
+    /**
+     * A.13 — crea el objeto LiveProps: propiedades readonly respaldadas por
+     * signals. OJO: destructurar props en setup crea snapshots no reactivos.
+     */
+    private _initProps;
+    /**
+     * A.13/A.15 — true si `inv` es la misma definición con la misma key:
+     * entonces el runtime debe actualizar props, no recrear el setup.
+     */
+    matches(inv: ComponentInvocation<any>): boolean;
+    /**
+     * A.13 — actualiza props sin recrear setup: escribe cada signal de prop.
+     * Props nuevas se añaden; props desaparecidas quedan en undefined.
+     */
+    updateProps(props: unknown): void;
+}
+/**
+ * A.16: burbujeo de errores por la cadena de instancias (padres reales del
+ * árbol de componentes). Devuelve la primera resolución manejada; si nadie
+ * maneja el error, `{ handled: false }` y el caller decide (re-lanzar o
+ * registrar).
+ */
+export declare function reportError(from: ComponentInstance, info: ComponentErrorInfo): ErrorResolution;
+/** Envuelve un ElurComponent de clase en el kernel unificado. */
+export declare function adaptClassComponent(inst: ElurComponent): ComponentInstance;
+export interface ComponentDefinition<P> {
+    (props?: P, slots?: Record<string, Slot>): ComponentInvocation<P>;
+    readonly setup: (props: P | undefined, ctx: SetupCtx) => unknown;
+    readonly _isComponentDefinition: true;
+}
+/** Invocación marcada: `Counter({ initial: 10 })` NO ejecuta setup — monta después. */
+export declare class ComponentInvocation<P> {
+    readonly [ELUR_RENDER_PROTOCOL]: {
+        mountDom: (ctx: DomProtocolContext) => (() => void);
+        renderServer: (sctx: {
+            markers?: boolean;
+            render(value: unknown, options?: {
+                markers?: boolean;
+            }): string | Promise<string>;
+        }) => Promise<string>;
+        hydrateDom: (ctx: {
+            parent: Node;
+            bounds: {
+                start: Comment;
+                end: Comment;
+            } | null;
+            render(value: unknown): unknown;
+        }) => (() => void);
+    };
+    readonly definition: ComponentDefinition<P>;
+    readonly props: P | undefined;
+    /** A.14: slots declarados en la llamada — `Card(props, { default: slot(...) })`. */
+    readonly slots: Record<string, Slot> | undefined;
+    constructor(definition: ComponentDefinition<P>, props: P | undefined, slots?: Record<string, Slot>);
+}
+export declare function isComponentInvocation(v: unknown): v is ComponentInvocation<any>;
+/**
+ * @internal — registra un frame de contexto para un owner raíz (mount de
+ * template con router, roots de app, etc).
+ */
+export declare function _registerContextOwner(owner: OwnerLike, context: Map<unknown, unknown>): void;
+/**
+ * Define un componente funcional de primera clase (A.5):
+ * `Counter(props)` retorna una invocación marcada; el runtime ejecuta el
+ * setup cuando monta la invocación.
+ */
+export declare function defineComponent<P = Record<string, never>>(setup: (props: P | undefined, ctx: SetupCtx) => unknown): ComponentDefinition<P>;
+/**
+ * Monta un componente (clase o invocación funcional) en `container` y
+ * devuelve el handle con `unmount()`. Todo el árbol reactivo muere con el
+ * unmount — sin fugas de effects/computeds.
+ */
+export declare function mountComponent(value: ElurComponent | ComponentInvocation<any>, container: Element): {
+    unmount(): void;
+    instance: ComponentInstance;
+};
+export {};

package/dist/lib/elur/next/dom-write.d.cts

@@ -0,0 +1,18 @@
+export type DomWriteKind = "text" | "attr" | "prop" | "class" | "style" | "custom";
+export interface DomWrite {
+    /** Identidad del binding — dos writes con el mismo id colapsan (último gana). */
+    id: unknown;
+    kind: DomWriteKind;
+    write: () => void;
+}
+/**
+ * Cola tipada: `id` identifica el binding. Si el mismo binding escribe varias
+ * veces antes del flush, sólo corre la última escritura — Map.set reemplaza el
+ * valor conservando la posición de inserción.
+ */
+export declare function queueDomWrite(id: unknown, kind: DomWriteKind, write: () => void): void;
+/**
+ * Compat con la API actual: deduplica por identidad del closure
+ * (comportamiento idéntico a la impl estable).
+ */
+export declare function queueDOMWrite(task: () => void): void;

package/dist/lib/elur/next/dom-write.d.ts

@@ -0,0 +1,18 @@
+export type DomWriteKind = "text" | "attr" | "prop" | "class" | "style" | "custom";
+export interface DomWrite {
+    /** Identidad del binding — dos writes con el mismo id colapsan (último gana). */
+    id: unknown;
+    kind: DomWriteKind;
+    write: () => void;
+}
+/**
+ * Cola tipada: `id` identifica el binding. Si el mismo binding escribe varias
+ * veces antes del flush, sólo corre la última escritura — Map.set reemplaza el
+ * valor conservando la posición de inserción.
+ */
+export declare function queueDomWrite(id: unknown, kind: DomWriteKind, write: () => void): void;
+/**
+ * Compat con la API actual: deduplica por identidad del closure
+ * (comportamiento idéntico a la impl estable).
+ */
+export declare function queueDOMWrite(task: () => void): void;

package/dist/lib/elur/next/hydrate.d.cts

@@ -0,0 +1,14 @@
+import { type ElurComponent } from "../lifecycle.js";
+import { type ComponentInvocation } from "./component.js";
+import { type ElurMountHandle, type ElurTemplate } from "../template/types.js";
+export interface HydrateOptions {
+    mismatch?: "throw" | "warn-remount" | "remount";
+    onMismatch?: (error: HydrationMismatch) => void;
+    context?: unknown;
+}
+export interface HydrationMismatch {
+    index: number;
+    kind: "node" | "attribute" | "event" | "descriptor" | "keyed";
+    message: string;
+}
+export declare function hydrate(value: ElurTemplate | ElurComponent | ComponentInvocation<any>, container: Element, options?: HydrateOptions): ElurMountHandle;

package/dist/lib/elur/next/hydrate.d.ts

@@ -0,0 +1,14 @@
+import { type ElurComponent } from "../lifecycle.js";
+import { type ComponentInvocation } from "./component.js";
+import { type ElurMountHandle, type ElurTemplate } from "../template/types.js";
+export interface HydrateOptions {
+    mismatch?: "throw" | "warn-remount" | "remount";
+    onMismatch?: (error: HydrationMismatch) => void;
+    context?: unknown;
+}
+export interface HydrationMismatch {
+    index: number;
+    kind: "node" | "attribute" | "event" | "descriptor" | "keyed";
+    message: string;
+}
+export declare function hydrate(value: ElurTemplate | ElurComponent | ComponentInvocation<any>, container: Element, options?: HydrateOptions): ElurMountHandle;

package/dist/lib/elur/next/keyed-diff.d.cts

@@ -0,0 +1,46 @@
+import { type KEntry, type KeyedList } from "../template/types.js";
+import { type RepeatKey } from "../template/keyed.js";
+/**
+ * C.16.1: lista keyed "live" — renderItem recibe accessors (`getItem`,
+ * `getIndex`) en vez del item capturado. Misma key + objeto nuevo → las
+ * señales del item se actualizan y los bindings re-corren sin remount,
+ * preservando identidad de DOM y estado del item.
+ */
+export interface LiveKeyedList<T = unknown> {
+    readonly __isKeyedList: true;
+    readonly live: true;
+    readonly items: T[];
+    readonly keyFn: (item: T, index: number) => string | number;
+    readonly renderItem: (getItem: () => T, getIndex: () => number) => unknown;
+}
+export declare function repeatLive<T>(items: T[], keyFn: (item: T, index: number) => string | number, renderItem: (getItem: () => T, getIndex: () => number) => unknown): LiveKeyedList<T>;
+/**
+ * Mounts a single keyed item's rendered value before `endMarker` inside `parent`.
+ * Used by the DOM renderer and the hydration renderer so both engines share the
+ * exact same reconciliation semantics.
+ */
+export declare function createKeyedMount(ctxSnapshot: Map<unknown, unknown>[]): (rendered: unknown, parent: Node, endMarker: Node) => () => void;
+export interface KeyedDiffOptions {
+    /** Node marking the start of the keyed zone. */
+    zoneStart: Node;
+    /** End boundary; new content is inserted before this node. */
+    anchor: Node;
+    /** Live map of key → entry (start/end markers + cleanup). */
+    state: Map<RepeatKey, KEntry>;
+    /** Key order from the previous reconciliation pass. */
+    prevOrder: RepeatKey[];
+    /** The current keyed list value (clásica o live). */
+    list: KeyedList | LiveKeyedList;
+    /** Mounts a freshly rendered item into the DOM. */
+    mount: (rendered: unknown, parent: Node, endMarker: Node) => () => void;
+    /** Context snapshot for component mounts inside the effect. */
+    ctxSnapshot?: Map<unknown, unknown>[];
+    /** Called when a duplicate key is encountered. */
+    onDuplicateKey?: (key: RepeatKey) => void;
+}
+/**
+ * Reconciles a keyed list between `zoneStart` and `anchor` using the same LIS
+ * algorithm used by the DOM renderer. Total replacement (O(1)) when no key
+ * survives; otherwise remove/insert/move with minimal DOM operations.
+ */
+export declare function reconcileKeyedList(opts: KeyedDiffOptions): void;