@elurjs/core 3.6.1 → 3.7.0-beta.0

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

@@ -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;

package/dist/lib/elur/next/mount-helpers.d.cts

@@ -0,0 +1,25 @@
+import { type ElurComponent } from "../lifecycle.js";
+import { type _captureContextSnapshot } from "../context.js";
+export declare function _postMountScope<T>(fn: () => T): T;
+export declare function _postMountScopeSub<T>(fn: () => T): T;
+export declare function _deferOnMount(fn: () => void): void;
+/**
+ * Monta un ElurComponent via kernel: onInit → render → _render → onMount
+ * (post-commit). Errores van por onError o re-lanzan. Cleanup = unmount().
+ */
+export declare function _mountComponent(inst: ElurComponent, parent: Node, before: Node | null): () => void;
+/**
+ * Igual que `_mountComponent` pero traga todos los errores de lifecycle —
+ * para contenido de transitions y fallbacks de error boundaries.
+ */
+export declare function _mountComponentSilent(inst: ElurComponent, parent: Node, before: Node | null): () => void;
+/**
+ * Monta con contexto capturado — para render dinámico/keyed dentro de
+ * effects, donde provide/inject hereda del punto de declaración.
+ */
+export declare function _mountComponentWithCtx(inst: ElurComponent, parent: Node, before: Node | null, ctxSnapshot: ReturnType<typeof _captureContextSnapshot>): () => void;
+/**
+ * Mount con onMount diferido — dentro de fragments de `html` donde el DOM
+ * aún no está insertado: el hook corre cuando el fragment hace commit.
+ */
+export declare function _mountComponentDeferred(inst: ElurComponent, parent: Node, before: Node | null, postMountHooks: Array<() => void>, disposes: Array<() => void>): void;

package/dist/lib/elur/next/mount-helpers.d.ts

@@ -0,0 +1,25 @@
+import { type ElurComponent } from "../lifecycle.js";
+import { type _captureContextSnapshot } from "../context.js";
+export declare function _postMountScope<T>(fn: () => T): T;
+export declare function _postMountScopeSub<T>(fn: () => T): T;
+export declare function _deferOnMount(fn: () => void): void;
+/**
+ * Monta un ElurComponent via kernel: onInit → render → _render → onMount
+ * (post-commit). Errores van por onError o re-lanzan. Cleanup = unmount().
+ */
+export declare function _mountComponent(inst: ElurComponent, parent: Node, before: Node | null): () => void;
+/**
+ * Igual que `_mountComponent` pero traga todos los errores de lifecycle —
+ * para contenido de transitions y fallbacks de error boundaries.
+ */
+export declare function _mountComponentSilent(inst: ElurComponent, parent: Node, before: Node | null): () => void;
+/**
+ * Monta con contexto capturado — para render dinámico/keyed dentro de
+ * effects, donde provide/inject hereda del punto de declaración.
+ */
+export declare function _mountComponentWithCtx(inst: ElurComponent, parent: Node, before: Node | null, ctxSnapshot: ReturnType<typeof _captureContextSnapshot>): () => void;
+/**
+ * Mount con onMount diferido — dentro de fragments de `html` donde el DOM
+ * aún no está insertado: el hook corre cuando el fragment hace commit.
+ */
+export declare function _mountComponentDeferred(inst: ElurComponent, parent: Node, before: Node | null, postMountHooks: Array<() => void>, disposes: Array<() => void>): void;

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

@@ -0,0 +1,29 @@
+/**
+ * next/ — fork del mount() público (../component.ts) sobre el kernel.
+ *
+ * Diferencias vs el estable:
+ *  - Componentes (clase o invocación funcional) montan via ComponentInstance:
+ *    máquina de estados, owner propio, mount transaccional, onMount
+ *    post-commit, unmount idempotente.
+ *  - `options.router` se inyecta via `provides` en el frame de contexto de la
+ *    instancia (A.12) en vez de un stack global.
+ *  - Templates raíz montan bajo un Owner raíz — así los componentes internos
+ *    tienen cadena de owners y provide/inject resuelve por instancias.
+ */
+import type { ElurTemplate, ElurMountHandle } from "../template/index.js";
+import { type ElurComponent } from "../lifecycle.js";
+import type { Router } from "../router.js";
+import { type ComponentInvocation } from "./component.js";
+export interface MountOptions {
+    router?: Router;
+}
+/**
+ * Mounts a ElurTemplate, ElurComponent o ComponentInvocation en el DOM.
+ *
+ *   mount(Counter({ initial: 10 }), "#app");  // componente funcional
+ *   mount(new Timer(), "#app");               // clase con lifecycle
+ *   mount(html`…`, "#app");                   // template
+ *
+ * @returns { unmount() } — mata el árbol reactivo completo y remueve el DOM.
+ */
+export declare function mount(component: ElurTemplate | ElurComponent | ComponentInvocation<any>, container: Element | string, options?: MountOptions): ElurMountHandle;

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

@@ -0,0 +1,29 @@
+/**
+ * next/ — fork del mount() público (../component.ts) sobre el kernel.
+ *
+ * Diferencias vs el estable:
+ *  - Componentes (clase o invocación funcional) montan via ComponentInstance:
+ *    máquina de estados, owner propio, mount transaccional, onMount
+ *    post-commit, unmount idempotente.
+ *  - `options.router` se inyecta via `provides` en el frame de contexto de la
+ *    instancia (A.12) en vez de un stack global.
+ *  - Templates raíz montan bajo un Owner raíz — así los componentes internos
+ *    tienen cadena de owners y provide/inject resuelve por instancias.
+ */
+import type { ElurTemplate, ElurMountHandle } from "../template/index.js";
+import { type ElurComponent } from "../lifecycle.js";
+import type { Router } from "../router.js";
+import { type ComponentInvocation } from "./component.js";
+export interface MountOptions {
+    router?: Router;
+}
+/**
+ * Mounts a ElurTemplate, ElurComponent o ComponentInvocation en el DOM.
+ *
+ *   mount(Counter({ initial: 10 }), "#app");  // componente funcional
+ *   mount(new Timer(), "#app");               // clase con lifecycle
+ *   mount(html`…`, "#app");                   // template
+ *
+ * @returns { unmount() } — mata el árbol reactivo completo y remueve el DOM.
+ */
+export declare function mount(component: ElurTemplate | ElurComponent | ComponentInvocation<any>, container: Element | string, options?: MountOptions): ElurMountHandle;

package/dist/lib/elur/next/node-binding.d.cts

@@ -0,0 +1,6 @@
+/**
+ * Activates a reactive node binding at `anchor`.
+ * Handles: text, ElurTemplate, ElurComponent, KeyedList, Array, and static values.
+ * Pushes dispose functions into `disposes`.
+ */
+export declare function activateNodeBinding(anchor: Text, value: unknown, disposes: Array<() => void>, postMountHooks: Array<() => void>): void;

package/dist/lib/elur/next/node-binding.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Activates a reactive node binding at `anchor`.
+ * Handles: text, ElurTemplate, ElurComponent, KeyedList, Array, and static values.
+ * Pushes dispose functions into `disposes`.
+ */
+export declare function activateNodeBinding(anchor: Text, value: unknown, disposes: Array<() => void>, postMountHooks: Array<() => void>): void;

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

@@ -0,0 +1,193 @@
+/**
+ * Elur "next" — grafo reactivo push-pull versionado (experimental).
+ *
+ * Módulo aislado de `../reactivity.ts` (PLAN_TECNICO_ELUR_NEXT §B.3–B.9):
+ * nunca importar ambos en el mismo path de producción — mezclar signals de
+ * dos grafos rompe la semántica.
+ *
+ * Modelo:
+ *  - PUSH: signal.set() → version++ → invalida consumidores (DIRTY directos,
+ *    CHECK transitivos) y encola effects una sola vez. No recalcula nada.
+ *  - PULL: antes de ejecutar un effect se estabilizan sus fuentes — los
+ *    computeds DIRTY/CHECK se refrescan recursivamente y sólo propagan si el
+ *    resultado realmente cambió (early cutoff por versión).
+ *  - Liveness: un computed sin consumidores vivos no se suscribe a sus
+ *    fuentes; se refresca por sondeo de versiones al leerse (O(1) si el
+ *    epoch global no cambió).
+ *  - Edges: `Link` doble-enlazado compartido entre la lista de sources del
+ *    consumidor y la de consumers del productor — subscribe/remove O(1),
+ *    reutilizados entre evaluaciones (mark & sweep por `evalMark`).
+ */
+/** Cualquier cosa que pueda poseer consumidores: Owner raíz, Effect, Computed. */
+export interface OwnerLike {
+    /** Hijos poseídos (effects, computeds, sub-owners) — disposal recursivo. */
+    children: Disposable[] | null;
+    /** Cleanups registrados con onCleanup() durante la última evaluación. */
+    cleanups: (() => void)[] | null;
+    /** Owner que era activo cuando este nodo fue creado (árbol de owners). */
+    parent: OwnerLike | null;
+    /**
+     * A.16: boundary por owner — un consumidor sin handler propio burbujea
+     * el error por la cadena de owners hasta que uno lo maneja (true).
+     */
+    onOwnerError?: (err: unknown) => boolean;
+}
+export interface Disposable {
+    dispose(): void;
+}
+/** Raíz de ownership explícita (un mount, un test, un sub-árbol). */
+export declare class Owner implements OwnerLike, Disposable {
+    children: Disposable[] | null;
+    cleanups: (() => void)[] | null;
+    parent: OwnerLike | null;
+    onOwnerError?: (err: unknown) => boolean;
+    private _disposed;
+    dispose(): void;
+}
+/** Owner actual — para diagnóstico e integración con el kernel de mounts. */
+export declare function getOwner(): OwnerLike | null;
+/**
+ * Ejecuta fn con `owner` como dueño activo. Todo effect/computed creado
+ * dentro queda poseído por él y se destruye con él.
+ */
+export declare function runWithOwner<T>(owner: OwnerLike | null, fn: () => T): T;
+/**
+ * Raíz reactiva: `const dispose = createRoot(d => {...})`. Todo lo creado
+ * dentro muere con `dispose()` — elimina la clase de leaks de B.2.5.
+ */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+/** Registra una limpieza en el owner activo (effect, computed o root). */
+export declare function onCleanup(fn: () => void): void;
+/**
+ * B.9: ciclo de efectos — un write dentro de un effect re-encola trabajo; si
+ * un nodo corre más de MAX_RUNS_PER_FLUSH en el mismo flush, es un bucle.
+ * El mensaje incluye el camino de dependencias del efecto (sus fuentes y,
+ * si son computeds, las suyas) para localizar el ciclo.
+ */
+export declare class ReactiveCycleError extends Error {
+    constructor(effect: ConsumerNode, runs: number);
+}
+interface ErrorHandler {
+    (err: unknown): void;
+}
+/** @internal */
+export declare function _pushErrorHandler(h: ErrorHandler): void;
+/** @internal */
+export declare function _popErrorHandler(): void;
+export interface _SignalDebugHooks {
+    onCreate?: (signal: Signal<any>, initialValue: unknown) => void;
+    onWrite?: (signal: Signal<any>, value: unknown) => void;
+}
+/** @internal */
+export declare function _setSignalDebugHooks(hooks: _SignalDebugHooks | null): void;
+/** @internal — añade suscriptor sin reemplazar; devuelve unsubscribe. */
+export declare function _addSignalDebugHooks(hooks: _SignalDebugHooks): () => void;
+/** @internal — la nueva impl no tiene notify buffer; se expone para paridad. */
+export declare function _getNotifyBufSize(): number;
+interface ProducerNode {
+    /** Incrementa en cada cambio real de valor. */
+    version: number;
+    /** Nº de links vivos en `consumersHead` (liveness del productor). */
+    liveCount: number;
+    consumersHead: Link | null;
+}
+/**
+ * Edge compartido: vive en dos listas a la vez — la de sources del consumer
+ * (`nextSource/prevSource`) y la de consumers del producer
+ * (`nextTarget/prevTarget`). `mark` lo usa el consumer para decidir qué
+ * links sobrevivieron a la última evaluación; `linked` indica si está
+ * insertado en la lista del producer (los computeds fríos no lo están).
+ */
+interface Link {
+    source: ProducerNode;
+    target: ConsumerNode;
+    seenVersion: number;
+    mark: number;
+    linked: boolean;
+    nextSource: Link | null;
+    prevSource: Link | null;
+    nextTarget: Link | null;
+    prevTarget: Link | null;
+}
+interface ConsumerNode {
+    state: number;
+    sourcesHead: Link | null;
+    /** Contador de evaluación — marca los links usados en esta pasada. */
+    evalMark: number;
+    live(): boolean;
+}
+export declare class Signal<T> implements ProducerNode {
+    version: number;
+    liveCount: number;
+    consumersHead: Link | null;
+    private _v;
+    constructor(initialValue: T);
+    get value(): T;
+    set value(newValue: T);
+    update(fn: (current: T) => T): void;
+    peek(): T;
+    dispose(): void;
+}
+export declare class Computed<T> extends Signal<T> implements ConsumerNode, OwnerLike {
+    state: number;
+    sourcesHead: Link | null;
+    evalMark: number;
+    /** Último epoch en que se verificó fresco — sondeo O(1) para fríos. */
+    lastCleanEpoch: number;
+    children: Disposable[] | null;
+    cleanups: (() => void)[] | null;
+    parent: OwnerLike | null;
+    _value: T | undefined;
+    fn: () => T;
+    equals: (a: T, b: T) => boolean;
+    hasValue: boolean;
+    private _evaluated;
+    /** B.12.1: transientes del DFS de refresh (0 entre refreshes). */
+    _pFlags: number;
+    _pCursor: Link | null;
+    _pLink: Link | null;
+    constructor(fn: () => T, equals?: (a: T, b: T) => boolean);
+    live(): boolean;
+    get value(): T;
+    peek(): T;
+    dispose(): void;
+}
+export declare function signal<T>(initialValue: T): Signal<T>;
+export declare function computed<T>(fn: () => T, equals?: (a: T, b: T) => boolean): Computed<T>;
+/** Corre una vez al crear; re-corre sólo si una fuente cambió de verdad. */
+export declare function effect(fn: () => void | (() => void)): () => void;
+/**
+ * @internal — effect de render (bindings DOM internos): se encola en la
+ * cola de render, que se drena ANTES que la de user effects (B.8). La API
+ * pública `effect()` sigue siendo la de usuario.
+ */
+export declare function _renderEffect(fn: () => void | (() => void)): () => void;
+export declare function batch<T>(fn: () => T): T;
+export declare function untrack<T>(fn: () => T): T;
+export interface WatchOptions {
+    immediate?: boolean;
+    once?: boolean;
+}
+export declare function watch<T>(source: Signal<T> | (() => T), cb: (value: T, oldValue: T | undefined) => void, options?: WatchOptions): () => void;
+export declare function nextTick(fn?: () => void): Promise<void>;
+/**
+ * @internal — binding de texto especializado (C.6): `node.nodeValue` sigue
+ * `fn()` con el mínimo consumer posible. `null`/`false`/`undefined` → "".
+ * Devuelve disposer (mata la suscripción; el caller remueve el nodo).
+ */
+export declare function _bindText(node: {
+    nodeValue: string | null;
+}, fn: () => unknown): () => void;
+/**
+ * @internal — C.6 T1: suscripción directa señal→writer. El writer corre una
+ * vez al montar (valor inicial) y por cada cambio real de la señal, en la
+ * cola de render. Devuelve disposer.
+ */
+export declare function _bindSignal<T>(source: Signal<T>, write: (v: T) => void): () => void;
+/**
+ * @internal — C.7 T2: suscripción directa señal→(getter derivado)→writer.
+ * Equivale a `_bindSignal(dep, () => write(get()))` con compare incluido,
+ * sin el closure intermedio ni el double-compare. Devuelve disposer.
+ */
+export declare function _bindDerived<T>(source: Signal<unknown>, get: () => T, write: (v: T) => void): () => void;
+export {};

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

@@ -0,0 +1,193 @@
+/**
+ * Elur "next" — grafo reactivo push-pull versionado (experimental).
+ *
+ * Módulo aislado de `../reactivity.ts` (PLAN_TECNICO_ELUR_NEXT §B.3–B.9):
+ * nunca importar ambos en el mismo path de producción — mezclar signals de
+ * dos grafos rompe la semántica.
+ *
+ * Modelo:
+ *  - PUSH: signal.set() → version++ → invalida consumidores (DIRTY directos,
+ *    CHECK transitivos) y encola effects una sola vez. No recalcula nada.
+ *  - PULL: antes de ejecutar un effect se estabilizan sus fuentes — los
+ *    computeds DIRTY/CHECK se refrescan recursivamente y sólo propagan si el
+ *    resultado realmente cambió (early cutoff por versión).
+ *  - Liveness: un computed sin consumidores vivos no se suscribe a sus
+ *    fuentes; se refresca por sondeo de versiones al leerse (O(1) si el
+ *    epoch global no cambió).
+ *  - Edges: `Link` doble-enlazado compartido entre la lista de sources del
+ *    consumidor y la de consumers del productor — subscribe/remove O(1),
+ *    reutilizados entre evaluaciones (mark & sweep por `evalMark`).
+ */
+/** Cualquier cosa que pueda poseer consumidores: Owner raíz, Effect, Computed. */
+export interface OwnerLike {
+    /** Hijos poseídos (effects, computeds, sub-owners) — disposal recursivo. */
+    children: Disposable[] | null;
+    /** Cleanups registrados con onCleanup() durante la última evaluación. */
+    cleanups: (() => void)[] | null;
+    /** Owner que era activo cuando este nodo fue creado (árbol de owners). */
+    parent: OwnerLike | null;
+    /**
+     * A.16: boundary por owner — un consumidor sin handler propio burbujea
+     * el error por la cadena de owners hasta que uno lo maneja (true).
+     */
+    onOwnerError?: (err: unknown) => boolean;
+}
+export interface Disposable {
+    dispose(): void;
+}
+/** Raíz de ownership explícita (un mount, un test, un sub-árbol). */
+export declare class Owner implements OwnerLike, Disposable {
+    children: Disposable[] | null;
+    cleanups: (() => void)[] | null;
+    parent: OwnerLike | null;
+    onOwnerError?: (err: unknown) => boolean;
+    private _disposed;
+    dispose(): void;
+}
+/** Owner actual — para diagnóstico e integración con el kernel de mounts. */
+export declare function getOwner(): OwnerLike | null;
+/**
+ * Ejecuta fn con `owner` como dueño activo. Todo effect/computed creado
+ * dentro queda poseído por él y se destruye con él.
+ */
+export declare function runWithOwner<T>(owner: OwnerLike | null, fn: () => T): T;
+/**
+ * Raíz reactiva: `const dispose = createRoot(d => {...})`. Todo lo creado
+ * dentro muere con `dispose()` — elimina la clase de leaks de B.2.5.
+ */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+/** Registra una limpieza en el owner activo (effect, computed o root). */
+export declare function onCleanup(fn: () => void): void;
+/**
+ * B.9: ciclo de efectos — un write dentro de un effect re-encola trabajo; si
+ * un nodo corre más de MAX_RUNS_PER_FLUSH en el mismo flush, es un bucle.
+ * El mensaje incluye el camino de dependencias del efecto (sus fuentes y,
+ * si son computeds, las suyas) para localizar el ciclo.
+ */
+export declare class ReactiveCycleError extends Error {
+    constructor(effect: ConsumerNode, runs: number);
+}
+interface ErrorHandler {
+    (err: unknown): void;
+}
+/** @internal */
+export declare function _pushErrorHandler(h: ErrorHandler): void;
+/** @internal */
+export declare function _popErrorHandler(): void;
+export interface _SignalDebugHooks {
+    onCreate?: (signal: Signal<any>, initialValue: unknown) => void;
+    onWrite?: (signal: Signal<any>, value: unknown) => void;
+}
+/** @internal */
+export declare function _setSignalDebugHooks(hooks: _SignalDebugHooks | null): void;
+/** @internal — añade suscriptor sin reemplazar; devuelve unsubscribe. */
+export declare function _addSignalDebugHooks(hooks: _SignalDebugHooks): () => void;
+/** @internal — la nueva impl no tiene notify buffer; se expone para paridad. */
+export declare function _getNotifyBufSize(): number;
+interface ProducerNode {
+    /** Incrementa en cada cambio real de valor. */
+    version: number;
+    /** Nº de links vivos en `consumersHead` (liveness del productor). */
+    liveCount: number;
+    consumersHead: Link | null;
+}
+/**
+ * Edge compartido: vive en dos listas a la vez — la de sources del consumer
+ * (`nextSource/prevSource`) y la de consumers del producer
+ * (`nextTarget/prevTarget`). `mark` lo usa el consumer para decidir qué
+ * links sobrevivieron a la última evaluación; `linked` indica si está
+ * insertado en la lista del producer (los computeds fríos no lo están).
+ */
+interface Link {
+    source: ProducerNode;
+    target: ConsumerNode;
+    seenVersion: number;
+    mark: number;
+    linked: boolean;
+    nextSource: Link | null;
+    prevSource: Link | null;
+    nextTarget: Link | null;
+    prevTarget: Link | null;
+}
+interface ConsumerNode {
+    state: number;
+    sourcesHead: Link | null;
+    /** Contador de evaluación — marca los links usados en esta pasada. */
+    evalMark: number;
+    live(): boolean;
+}
+export declare class Signal<T> implements ProducerNode {
+    version: number;
+    liveCount: number;
+    consumersHead: Link | null;
+    private _v;
+    constructor(initialValue: T);
+    get value(): T;
+    set value(newValue: T);
+    update(fn: (current: T) => T): void;
+    peek(): T;
+    dispose(): void;
+}
+export declare class Computed<T> extends Signal<T> implements ConsumerNode, OwnerLike {
+    state: number;
+    sourcesHead: Link | null;
+    evalMark: number;
+    /** Último epoch en que se verificó fresco — sondeo O(1) para fríos. */
+    lastCleanEpoch: number;
+    children: Disposable[] | null;
+    cleanups: (() => void)[] | null;
+    parent: OwnerLike | null;
+    _value: T | undefined;
+    fn: () => T;
+    equals: (a: T, b: T) => boolean;
+    hasValue: boolean;
+    private _evaluated;
+    /** B.12.1: transientes del DFS de refresh (0 entre refreshes). */
+    _pFlags: number;
+    _pCursor: Link | null;
+    _pLink: Link | null;
+    constructor(fn: () => T, equals?: (a: T, b: T) => boolean);
+    live(): boolean;
+    get value(): T;
+    peek(): T;
+    dispose(): void;
+}
+export declare function signal<T>(initialValue: T): Signal<T>;
+export declare function computed<T>(fn: () => T, equals?: (a: T, b: T) => boolean): Computed<T>;
+/** Corre una vez al crear; re-corre sólo si una fuente cambió de verdad. */
+export declare function effect(fn: () => void | (() => void)): () => void;
+/**
+ * @internal — effect de render (bindings DOM internos): se encola en la
+ * cola de render, que se drena ANTES que la de user effects (B.8). La API
+ * pública `effect()` sigue siendo la de usuario.
+ */
+export declare function _renderEffect(fn: () => void | (() => void)): () => void;
+export declare function batch<T>(fn: () => T): T;
+export declare function untrack<T>(fn: () => T): T;
+export interface WatchOptions {
+    immediate?: boolean;
+    once?: boolean;
+}
+export declare function watch<T>(source: Signal<T> | (() => T), cb: (value: T, oldValue: T | undefined) => void, options?: WatchOptions): () => void;
+export declare function nextTick(fn?: () => void): Promise<void>;
+/**
+ * @internal — binding de texto especializado (C.6): `node.nodeValue` sigue
+ * `fn()` con el mínimo consumer posible. `null`/`false`/`undefined` → "".
+ * Devuelve disposer (mata la suscripción; el caller remueve el nodo).
+ */
+export declare function _bindText(node: {
+    nodeValue: string | null;
+}, fn: () => unknown): () => void;
+/**
+ * @internal — C.6 T1: suscripción directa señal→writer. El writer corre una
+ * vez al montar (valor inicial) y por cada cambio real de la señal, en la
+ * cola de render. Devuelve disposer.
+ */
+export declare function _bindSignal<T>(source: Signal<T>, write: (v: T) => void): () => void;
+/**
+ * @internal — C.7 T2: suscripción directa señal→(getter derivado)→writer.
+ * Equivale a `_bindSignal(dep, () => write(get()))` con compare incluido,
+ * sin el closure intermedio ni el double-compare. Devuelve disposer.
+ */
+export declare function _bindDerived<T>(source: Signal<unknown>, get: () => T, write: (v: T) => void): () => void;
+export {};

package/dist/lib/elur/next-2/component.cjs

@@ -0,0 +1,2 @@
+const e=require(`./reactivity.cjs`),t=require(`../template/types.cjs`),n=require(`../../lifecycle.cjs`),r=require(`../../context.cjs`);function i(e){return t.isElurTemplate(e)?e:null}function a(e){return typeof e==`object`&&!!e&&e.__isElurSlot===!0}var o=1,s=class t{id=o++;kind;state=`created`;owner=new e.Owner;parent=null;hooks={};renderable=null;context=new Map;_inst=null;_invocation=null;_renderCleanup=null;_mountCleanups=null;_propSignals=null;_liveProps=null;_phase=`setup`;_mountParent=null;_mountBefore=null;_domNodes=null;_controllers=null;constructor(e){n.isElurComponent(e)?(this.kind=`class`,this._inst=e):(this.kind=`function`,this._invocation=e),this.owner.onOwnerError=e=>c(this,{phase:`effect`,component:this,cause:e}).handled}mount(r,i,a){if(this.state!==`created`)throw Error(`[elur-next] ComponentInstance.mount(): estado inválido "${this.state}" (una instancia montada no puede montarse otra vez).`);if(f.set(this.owner,this),p.set(this.owner,this.context),this._resolveParent(),this.owner.parent=a?.declOwner===void 0?e.getOwner():a.declOwner,a?.provides)for(let[e,t]of a.provides)this.context.set(e,t);this._mountParent=r,this._mountBefore=i;let o=!n.isElurComponent(this._inst),s=this;o&&n._debugComponentMountStart(s);let l=i?Array.prototype.indexOf.call(r.childNodes,i):r.childNodes.length;try{this.state=`initializing`,e.runWithOwner(this.owner,()=>this._withScope(a?.ctxSnapshot,()=>{if(this._initBody(),this._inst?._controllers)for(let e of this._inst._controllers)this.addController(e);if(this._controllers)for(let e of this._controllers)e.hostInit?.();this._phase=`mount`,this.state=`pending-mount`,this._renderCleanup=this.renderable._render(r,i);let e=i?Array.prototype.indexOf.call(r.childNodes,i):r.childNodes.length;this._domNodes=Array.prototype.slice.call(r.childNodes,l,e)})),this.state=`mounted`;let t=()=>this._runOnMount();a?.deferOnMount?a.deferOnMount(t):t()}catch(e){this._rollback();let n=c(this,{phase:this._phase,component:this,cause:e});if(!n.handled)throw e;`retry`in n&&n.retry?new t(this._inst??this._invocation).mount(r,i,a):`fallback`in n&&n.fallback!==void 0&&this._renderFallback(n.fallback,r,i)}finally{o&&n._debugComponentMountEnd(s)}}addController(e){(this._controllers??=[]).push(e)}detach(){if(this.state!==`mounted`||!this._domNodes)return;let t=document.createDocumentFragment();for(let e of this._domNodes)t.appendChild(e);this.state=`deactivated`,this._controllers&&e.runWithOwner(this.owner,()=>{for(let e of this._controllers)e.hostDeactivate?.()})}attach(t,n){if(this.state!==`deactivated`||!this._domNodes)return;let r=t??this._mountParent,i=n===void 0?this._mountBefore:n;if(r){for(let e of this._domNodes)r.insertBefore(e,i);this.state=`mounted`,this._controllers&&e.runWithOwner(this.owner,()=>{for(let e of this._controllers)e.hostActivate?.()})}}unmount(){if(this.state!==`created`&&!(this.state===`disposing`||this.state===`disposed`)){if(this.state===`failed`){this.state=`disposed`;return}this.state===`deactivated`&&(this._domNodes=null),this.state=`disposing`,n.isElurComponent(this._inst)||n._debugComponentUnmount(this);try{e.runWithOwner(this.owner,()=>{if(this.hooks.onUnmount?.call(this._inst??void 0),this._inst?.onUnmount?.(),this._controllers)for(let e of this._controllers)e.hostUnmount?.()})}catch(e){this._reportSwallowed(e,`unmount`)}if(this._mountCleanups){for(let e of this._mountCleanups)try{e()}catch(e){this._reportSwallowed(e,`cleanup`)}this._mountCleanups=null}this.owner.dispose();try{this._renderCleanup?.()}finally{this._renderCleanup=null,this.state=`disposed`}}}dispose(){this.unmount()}_runOnMount(){if(this.state===`mounted`)try{let t=e.runWithOwner(this.owner,()=>{let e=this.kind===`class`?this._inst.onMount?.():this.hooks.onMount?.();if(this._controllers)for(let e of this._controllers)e.hostMounted?.();return e});typeof t==`function`&&(this._mountCleanups??=[]).push(t)}catch(e){this._rollback();let t=c(this,{phase:`mount`,component:this,cause:e});if(!t.handled)throw e;`fallback`in t&&t.fallback!==void 0&&this._renderFallback(t.fallback,this._mountParent,this._mountBefore)}}_handleError(e){if(this.kind===`function`&&this.hooks.onError){let t=this.hooks.onError(e);return t===void 0?{handled:!0}:t}return this.kind===`class`&&this._inst?.onError?(this._inst.onError(e.cause),{handled:!0}):null}_reportSwallowed(e,t){c(this,{phase:t,component:this,cause:e}).handled||console.error(`[elur-next] error en `+t+`:`,e)}_renderFallback(e,n,r){let a=i(e);if(a)a._render(n,r);else if(typeof e==`string`||typeof e==`number`)n.insertBefore(document.createTextNode(String(e)),r);else if(Array.isArray(e))for(let t of e)this._renderFallback(t,n,r);else e&&new t(e).mount(n,r)}_resolveParent(){let t=e.getOwner();for(;t;){let e=f.get(t);if(e){this.parent=e;return}t=t.parent}}_rollback(){this.owner.dispose();try{this._renderCleanup?.()}finally{this._renderCleanup=null,this.state=`failed`}}_makeSetupCtx(){let e=this;return{owner:this.owner,onMount(t){e.hooks.onMount=t},onUnmount(t){e.hooks.onUnmount=t},onError(t){e.hooks.onError=t},onServerRender(t){e.hooks.onServerRender=t},propSignal(t){return e._propSignals?.get(t)},slots:this._invocation?.slots,slot(t=`default`){return e._invocation?.slots?.[t]}}}_initBody(){if(this.kind===`class`){let e=this._inst;this._phase=`init`,e.onInit?.(),this._phase=`render`,this.state=`rendering`,this.renderable=i(e.render())}else{let e=this._invocation,t=this._makeSetupCtx();this._phase=`setup`,this.state=`rendering`,this.renderable=i(e.definition.setup(this._initProps(e.props),t))}if(!this.renderable)throw Error(`[elur-next] El componente #${this.id} no produjo un template renderizable.`)}_withScope(e,t){if(e)r._withComponentContext(e,t);else{r._pushComponentContext();try{t()}finally{r._popComponentContext()}}}_hydrate(t){if(this.state!==`created`)throw Error(`[elur-next] _hydrate(): estado inválido "${this.state}".`);f.set(this.owner,this),p.set(this.owner,this.context),this._resolveParent(),this.owner.parent=e.getOwner();try{this.state=`initializing`;let n;e.runWithOwner(this.owner,()=>this._withScope(void 0,()=>{this._initBody(),this.state=`pending-mount`,n=t.render(this.renderable)})),this._renderCleanup=typeof n==`function`?n:null,this.state=`mounted`,this._runOnMount()}catch(n){if(t.mismatch===`throw`)throw n;t.mismatch!==`remount`&&console.warn(`[elur] Hydration mismatch en componente; remounting:`,n),this.owner.dispose();let r=this.renderable;this.state=`initializing`,e.runWithOwner(this.owner,()=>this._withScope(void 0,()=>{r||this._initBody(),this.state=`pending-mount`,this._renderCleanup=this.renderable._render(t.parent,t.bounds?.end??null)})),this.state=`mounted`,this._runOnMount()}}async _renderServer(t){this.state=`initializing`,f.set(this.owner,this),p.set(this.owner,this.context),this._resolveParent(),this.owner.parent=e.getOwner(),e.runWithOwner(this.owner,()=>this._withScope(void 0,()=>{this._initBody(),this.kind===`class`?this._inst.onServerRender?.():this.hooks.onServerRender?.()}));try{return await t.render(this.renderable,{markers:t.markers})}finally{this.owner.dispose(),this.state=`disposed`}}_initProps(t){if(this._propSignals=new Map,this._liveProps={},typeof t==`object`&&t)for(let[n,r]of Object.entries(t)){if(n===`key`)continue;let t=e.signal(r);this._propSignals.set(n,t),Object.defineProperty(this._liveProps,n,{enumerable:!0,get:()=>t.value})}return this._liveProps}matches(e){if(this.kind!==`function`||!this._invocation)return!1;let t=e=>typeof e==`object`&&e?e.key:void 0;return e.definition===this._invocation.definition&&t(e.props)===t(this._invocation.props)}updateProps(t){if(!this._propSignals||!this._liveProps)return;let n=new Set;if(typeof t==`object`&&t)for(let[r,i]of Object.entries(t)){if(r===`key`)continue;n.add(r);let t=this._propSignals.get(r);if(t)t.value=i;else{let t=e.signal(i);this._propSignals.set(r,t),Object.defineProperty(this._liveProps,r,{enumerable:!0,get:()=>t.value})}}for(let e of this._propSignals.keys())n.has(e)||(this._propSignals.get(e).value=void 0)}};function c(e,t){let n=e;for(;n;){let e=n._handleError(t);if(e!==null)return e;n=n.parent}return{handled:!1}}function l(e){return new s(e)}var u=class{[t.ELUR_RENDER_PROTOCOL]={mountDom:e=>{let t=new s(this);return t.mount(e.parent,e.before),()=>t.unmount()},renderServer:e=>new s(this)._renderServer(e),hydrateDom:e=>{let t=new s(this);return t._hydrate(e),()=>t.unmount()}};definition;props;slots;constructor(e,t,n){this.definition=e,this.props=t,this.slots=n}};function d(e){return e instanceof u}var f=new WeakMap,p=new WeakMap;function m(e,t){p.set(e,t)}r._pushContextScopeResolver(()=>{let t=[],n=e.getOwner();for(;n;){let e=p.get(n);e&&t.push(e),n=n.parent}if(t.length!==0)return t.reverse(),t}),exports.ComponentInstance=s,exports._registerContextOwner=m,exports.adaptClassComponent=l,exports.isComponentInvocation=d,exports.isElurSlot=a;
+//# sourceMappingURL=component.cjs.map