@elurjs/core 3.6.1 → 3.7.0-beta.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"component.cjs","names":[],"sources":["../../../../src/elur/next-2/component.ts"],"sourcesContent":["/**\n * Elur \"next\" — kernel unificado de componentes (experimental).\n *\n * Implementa A.6–A.9 del PLAN_TECNICO_ELUR_NEXT sobre el ownership de\n * `./reactivity.ts`:\n *  - Una sola `ComponentInstance` para clases y funciones (adaptadores).\n *  - Máquina de estados (A.7): created → initializing → rendering →\n *    pending-mount → mounted → disposing → disposed (o failed).\n *  - Mount transaccional (A.9): cualquier fallo dispara rollback —\n *    cleanups registrados, owner reactivo disposed, DOM insertado removido.\n *  - `unmount()` idempotente (A.2.10).\n *  - `onMount` corre DESPUÉS del commit DOM (A.2.9).\n *  - Todo lo creado en setup/render pertenece al owner de la instancia y\n *    muere con unmount (A.2.1 — no más effects huérfanos).\n *\n * Las invocaciones implementan `ELUR_RENDER_PROTOCOL.mountDom`, así el\n * renderer existente las monta sin saber que son componentes.\n */\n\nimport {\n  getOwner,\n  runWithOwner,\n  signal,\n  Owner,\n  Signal,\n  type Disposable,\n  type OwnerLike,\n} from \"./reactivity.js\";\nimport {\n  isElurComponent,\n  _debugComponentMountStart,\n  _debugComponentMountEnd,\n  _debugComponentUnmount,\n  type ElurComponent,\n  type ComponentController,\n} from \"../lifecycle.js\";\nimport {\n  ELUR_RENDER_PROTOCOL,\n  isElurTemplate,\n  type DomProtocolContext,\n} from \"../template/types.js\";\nimport {\n  _pushComponentContext,\n  _popComponentContext,\n  _withComponentContext,\n  _pushContextScopeResolver,\n} from \"../context.js\";\n\n// --- Máquina de estados (A.7) -------------------------------------------------\n\nexport type ComponentState =\n  | \"created\"\n  | \"initializing\"\n  | \"rendering\"\n  | \"pending-mount\"\n  | \"mounted\"\n  | \"deactivated\"\n  | \"disposing\"\n  | \"disposed\"\n  | \"failed\";\n\n// --- Hooks --------------------------------------------------------------------\n\n// --- A.16: error boundaries ----------------------------------------------------\n\n/** Fase del lifecycle donde ocurrió el error. */\nexport type ErrorPhase =\n  | \"setup\"\n  | \"init\"\n  | \"render\"\n  | \"hydrate\"\n  | \"mount\"\n  | \"effect\"\n  | \"activate\"\n  | \"deactivate\"\n  | \"cleanup\"\n  | \"unmount\";\n\n/** Información estructurada del error (A.16). */\nexport interface ComponentErrorInfo {\n  phase: ErrorPhase;\n  /** Instancia donde ocurrió el error (no la boundary que lo maneja). */\n  component: ComponentInstance;\n  cause: unknown;\n}\n\n/** Resolución de una boundary (A.16). */\nexport type ErrorResolution =\n  | { handled: false }\n  | { handled: true; fallback?: Renderable }\n  | { handled: true; retry: true };\n\nexport interface ComponentHooks {\n  /** Tras el commit DOM. Puede devolver cleanup (corre en unmount). */\n  onMount?: () => (() => void) | void;\n  /** Antes de remover el DOM. */\n  onUnmount?: () => void;\n  /**\n   * Boundary de errores (A.16): recibe info estructurada; el error burbujea\n   * por la cadena de instancias hasta una boundary que devuelva handled.\n   * `void` = manejado sin más.\n   */\n  onError?: (info: ComponentErrorInfo) => ErrorResolution | void;\n  /** A.17: tras setup durante SSR — nunca en cliente. */\n  onServerRender?: () => void;\n}\n\n/** Contexto que recibe el setup de un componente funcional. */\nexport interface SetupCtx {\n  onMount(fn: () => (() => void) | void): void;\n  onUnmount(fn: () => void): void;\n  onError(fn: (info: ComponentErrorInfo) => ErrorResolution | void): void;\n  /** A.17: hook server-side — corre tras setup durante SSR, nunca en cliente. */\n  onServerRender(fn: () => void): void;\n  /** Owner de la instancia — para runWithOwner/getOwner manual. */\n  readonly owner: OwnerLike;\n  /** Señal interna de una prop (A.13) — para acceso reactivo explícito. */\n  propSignal<K extends string>(key: K): Signal<unknown> | undefined;\n  /**\n   * A.14: renderiza el contenido de un slot (lazy — corre el render del\n   * slot bajo el owner del padre que lo declaró). `\"default\"` por defecto.\n   */\n  slot(name?: string): unknown;\n  /** A.14: slots declarados en la invocación. */\n  readonly slots: Record<string, Slot> | undefined;\n}\n\n// --- Renderable ---------------------------------------------------------------\n\ninterface RenderableValue {\n  _render(parent: Node, before: Node | null): () => void;\n}\n\nfunction asRenderable(v: unknown): RenderableValue | null {\n  if (isElurTemplate(v)) return v as unknown as RenderableValue;\n  return null;\n}\n\n// --- A.14: Slots (lazy, marcados) --------------------------------------------------\n\n/** Renderable común: cualquier cosa montable en un binding. */\nexport type Renderable =\n  | ElurComponent\n  | ComponentInvocation<unknown>\n  | Slot\n  | { _render(parent: Node, before: Node | null): () => void }\n  | string\n  | number\n  | bigint\n  | false\n  | null\n  | undefined\n  | Renderable[];\n\n/**\n * Slot lazy y marcado (A.14): el contenido se renderiza bajo el owner del\n * padre que LO DECLARÓ (contexto léxico), aunque se monte dentro del\n * componente consumidor.\n */\nexport interface Slot {\n  readonly __isElurSlot: true;\n  /** Owner capturado en el punto de declaración (contexto léxico). */\n  readonly owner: OwnerLike | null;\n  render(): unknown;\n}\n\nexport function slot(render: () => unknown): Slot {\n  return { __isElurSlot: true, owner: getOwner(), render };\n}\n\nexport function isElurSlot(v: unknown): v is Slot {\n  return (\n    v != null &&\n    typeof v === \"object\" &&\n    (v as { __isElurSlot?: boolean }).__isElurSlot === true\n  );\n}\n\n// --- ComponentInstance ----------------------------------------------------------\n\nlet nextInstanceId = 1;\n\nexport class ComponentInstance implements Disposable {\n  readonly id = nextInstanceId++;\n  readonly kind: \"class\" | \"function\";\n  state: ComponentState = \"created\";\n  /** Owner reactivo de la instancia — todo lo creado dentro muere con él. */\n  readonly owner = new Owner();\n  /** Instancia padre (owner activo cuando se creó esta instancia). */\n  parent: ComponentInstance | null = null;\n  hooks: ComponentHooks = {};\n  renderable: RenderableValue | null = null;\n  /** A.12: frame de provide/inject propio de la instancia — permanente. */\n  readonly context = new Map<unknown, unknown>();\n\n  private _inst: ElurComponent | null = null;\n  private _invocation: ComponentInvocation<any> | null = null;\n  private _renderCleanup: (() => void) | null = null;\n  private _mountCleanups: (() => void)[] | null = null;\n  /** A.13: señales internas por prop + objeto live pasado al setup. */\n  private _propSignals: Map<string, Signal<unknown>> | null = null;\n  private _liveProps: Record<string, unknown> | null = null;\n  /** A.16: fase actual del lifecycle — para el ComponentErrorInfo. */\n  private _phase: ErrorPhase = \"setup\";\n  /** A.16: posición de montaje — para renderizar fallback de boundary. */\n  private _mountParent: Node | null = null;\n  private _mountBefore: Node | null = null;\n  /** A.3.8: nodos DOM de la instancia — para detach/attach. */\n  private _domNodes: Node[] | null = null;\n  /** A.21: controllers de ciclo de vida (Lit-style). */\n  private _controllers: ComponentController[] | null = null;\n\n  constructor(source: ElurComponent | ComponentInvocation<any>) {\n    if (isElurComponent(source)) {\n      this.kind = \"class\";\n      this._inst = source;\n    } else {\n      this.kind = \"function\";\n      this._invocation = source;\n    }\n    // A.16: errores de effects/computeds de la instancia burbujean aquí.\n    this.owner.onOwnerError = (err) =>\n      reportError(this, { phase: \"effect\", component: this, cause: err })\n        .handled;\n  }\n\n  /**\n   * Mount transaccional (A.9). Cualquier fase que falle → rollback completo:\n   * owner disposed, cleanups corridos, DOM insertado removido, state=failed.\n   *\n   * Opciones:\n   *  - `ctxSnapshot`: contexto capturado en el punto de declaración\n   *    (mounts dentro de effects dinámicos heredan provide/inject).\n   *  - `deferOnMount`: recibe una función `fire()` que corre onMount; el\n   *    caller decide cuándo invocarla (fragments aún no insertados).\n   */\n  mount(\n    parent: Node,\n    before: Node | null,\n    opts?: {\n      ctxSnapshot?: Map<unknown, unknown>[];\n      deferOnMount?: (fire: () => void) => void;\n      /** Valores a proveer en el frame de contexto de la instancia (A.12). */\n      provides?: Iterable<readonly [unknown, unknown]>;\n      /**\n       * A.14: owner del declarante — para contenido de slots, el owner padre\n       * es el del padre que declaró el contenido, no el del punto de montaje.\n       */\n      declOwner?: OwnerLike | null;\n    },\n  ): void {\n    if (this.state !== \"created\") {\n      throw new Error(\n        `[elur-next] ComponentInstance.mount(): estado inválido \"${this.state}\" (una instancia montada no puede montarse otra vez).`,\n      );\n    }\n    ownerToInstance.set(this.owner, this);\n    ownerToContext.set(this.owner, this.context);\n    this._resolveParent();\n    // A.12: el owner de la instancia se cuelga del owner activo en el punto\n    // de declaración — así la cadena de owners reproduce el árbol de\n    // componentes y provide/inject resuelven por instancias.\n    this.owner.parent = opts?.declOwner !== undefined ? opts.declOwner : getOwner();\n    if (opts?.provides) {\n      for (const [k, v] of opts.provides) this.context.set(k, v);\n    }\n    this._mountParent = parent;\n    this._mountBefore = before;\n\n    // A.2.4: debug events sólo para funcionales — las clases ya emiten por\n    // mount-helpers; emitir aquí duplicaría. El payload es la\n    // ComponentInstance (id/kind/state/parent en el árbol).\n    const isFunctional = !isElurComponent(this._inst);\n    const dbg = this as unknown as ElurComponent;\n    if (isFunctional) _debugComponentMountStart(dbg);\n\n    // A.3.8: índice donde empieza el DOM de la instancia — para capturar el\n    // rango de nodos tras _render y poder detach/attach después.\n    const startIndex = before\n      ? Array.prototype.indexOf.call(parent.childNodes, before)\n      : parent.childNodes.length;\n\n    try {\n      // --- initializing + rendering + pending-mount, TODO bajo el mismo\n      // frame de contexto: los hijos montados durante _render heredan el\n      // provide de esta instancia (como en la impl actual).\n      this.state = \"initializing\";\n      runWithOwner(this.owner, () =>\n        this._withScope(opts?.ctxSnapshot, () => {\n          this._initBody();\n          // A.21: controllers de la clase + programáticos — hostInit dentro\n          // del frame para que lo que creen quede poseído por la instancia.\n          if (this._inst?._controllers) {\n            for (const c of this._inst._controllers) this.addController(c);\n          }\n          if (this._controllers) {\n            for (const c of this._controllers) c.hostInit?.();\n          }\n          // pending-mount: activar bindings + insertar DOM, aún dentro del\n          // frame de contexto para que los hijos hereden provide/inject.\n          this._phase = \"mount\";\n          this.state = \"pending-mount\";\n          this._renderCleanup = this.renderable!._render(parent, before);\n          // A.3.8: capturar los nodos insertados entre startIndex y `before`.\n          const endIndex = before\n            ? Array.prototype.indexOf.call(parent.childNodes, before)\n            : parent.childNodes.length;\n          this._domNodes = Array.prototype.slice.call(\n            parent.childNodes,\n            startIndex,\n            endIndex,\n          ) as Node[];\n        }),\n      );\n\n      // --- commit ---\n      this.state = \"mounted\";\n\n      // onMount DESPUÉS del commit DOM (A.2.9) — inmediato o diferido por\n      // el caller (fragments que aún no están en el documento).\n      const fire = () => this._runOnMount();\n      if (opts?.deferOnMount) opts.deferOnMount(fire);\n      else fire();\n    } catch (err) {\n      this._rollback();\n      const res = reportError(this, {\n        phase: this._phase,\n        component: this,\n        cause: err,\n      });\n      if (!res.handled) throw err;\n      if (\"retry\" in res && res.retry) {\n        // Una sola reintento — instancia fresca (el owner viejo está\n        // disposed); un segundo fallo se propaga igual.\n        new ComponentInstance(this._inst ?? this._invocation!).mount(\n          parent,\n          before,\n          opts,\n        );\n      } else if (\"fallback\" in res && res.fallback !== undefined) {\n        this._renderFallback(res.fallback, parent, before);\n      }\n    } finally {\n      // A.3.3/A.2.4: mountEnd balanceado — se emite haya éxito, rollback,\n      // retry o fallback, para que el tooling pueda emparejar start/end.\n      if (isFunctional) _debugComponentMountEnd(dbg);\n    }\n  }\n\n  /** A.21: registra un controller — sus hooks corren bajo este owner. */\n  addController(c: ComponentController): void {\n    (this._controllers ??= []).push(c);\n  }\n\n  /**\n   * A.3.8: saca el DOM de la instancia SIN disponer nada — effects, signals\n   * y contexto siguen vivos (página cached, Suspense, transición). No-op si\n   * no está montado.\n   */\n  detach(): void {\n    if (this.state !== \"mounted\" || !this._domNodes) return;\n    const frag = document.createDocumentFragment();\n    for (const n of this._domNodes) frag.appendChild(n);\n    this.state = \"deactivated\";\n    // A.21: hostDeactivate — signals/effects del controller siguen vivos.\n    if (this._controllers) {\n      runWithOwner(this.owner, () => {\n        for (const c of this._controllers!) c.hostDeactivate?.();\n      });\n    }\n  }\n\n  /**\n   * A.3.8: reinserta el DOM de una instancia detached en la posición original\n   * (o en parent/before dados). No-op si no está deactivated.\n   */\n  attach(parent?: Node, before?: Node | null): void {\n    if (this.state !== \"deactivated\" || !this._domNodes) return;\n    const p = parent ?? this._mountParent;\n    const b = before !== undefined ? before : this._mountBefore;\n    if (!p) return;\n    for (const n of this._domNodes) p.insertBefore(n, b);\n    this.state = \"mounted\";\n    // A.21: hostActivate — la instancia volvió al DOM.\n    if (this._controllers) {\n      runWithOwner(this.owner, () => {\n        for (const c of this._controllers!) c.hostActivate?.();\n      });\n    }\n  }\n\n  /** Idempotente (A.2.10): disponer dos veces es seguro. */\n  unmount(): void {\n    if (this.state === \"created\") return; // nunca montado\n    if (this.state === \"disposing\" || this.state === \"disposed\") return;\n    if (this.state === \"failed\") {\n      this.state = \"disposed\";\n      return;\n    }\n    // A.3.8: unmount de una instancia detached dispone igual — el cleanup\n    // del renderable remueve los nodos de su padre actual (el fragment).\n    if (this.state === \"deactivated\") this._domNodes = null;\n    this.state = \"disposing\";\n    // A.2.4: mismo criterio — sólo funcionales (las clases emiten por\n    // mount-helpers).\n    if (!isElurComponent(this._inst)) {\n      _debugComponentUnmount(this as unknown as ElurComponent);\n    }\n    try {\n      // A.12: bajo el owner → inject() resuelve dentro de onUnmount también.\n      runWithOwner(this.owner, () => {\n        this.hooks.onUnmount?.call(this._inst ?? undefined);\n        this._inst?.onUnmount?.();\n        // A.21: hostUnmount antes del disposal del owner.\n        if (this._controllers) {\n          for (const c of this._controllers) c.hostUnmount?.();\n        }\n      });\n    } catch (err) {\n      // A.16: errores de unmount no abortan el disposal pero se reportan.\n      this._reportSwallowed(err, \"unmount\");\n    }\n    if (this._mountCleanups) {\n      for (const fn of this._mountCleanups) {\n        try {\n          fn();\n        } catch (err) {\n          // A.3.4/A.16: cleanup errors continúan el teardown, pero se reportan.\n          this._reportSwallowed(err, \"cleanup\");\n        }\n      }\n      this._mountCleanups = null;\n    }\n    // Owner primero (mata effects/computeds/cleanups de la instancia),\n    // luego el cleanup del renderable (remueve DOM + cleanup propio).\n    this.owner.dispose();\n    try {\n      this._renderCleanup?.();\n    } finally {\n      this._renderCleanup = null;\n      this.state = \"disposed\";\n    }\n  }\n\n  dispose(): void {\n    this.unmount();\n  }\n\n  /** @internal — corre onMount una vez; no-op si ya no está montado. */\n  _runOnMount(): void {\n    if (this.state !== \"mounted\") return;\n    try {\n      // A.12: bajo el owner → inject() dentro de onMount resuelve por la\n      // cadena de instancias (contexto permanente, no sólo durante render).\n      const mountRet = runWithOwner(this.owner, () => {\n        const r =\n          this.kind === \"class\" ? this._inst!.onMount?.() : this.hooks.onMount?.();\n        // A.21\n        if (this._controllers) {\n          for (const c of this._controllers) c.hostMounted?.();\n        }\n        return r;\n      });\n      if (typeof mountRet === \"function\") {\n        (this._mountCleanups ??= []).push(mountRet);\n      }\n    } catch (err) {\n      // A.16: onMount falla → rollback completo + boundary (+fallback).\n      this._rollback();\n      const res = reportError(this, {\n        phase: \"mount\",\n        component: this,\n        cause: err,\n      });\n      if (!res.handled) throw err;\n      if (\"fallback\" in res && res.fallback !== undefined) {\n        this._renderFallback(res.fallback, this._mountParent!, this._mountBefore);\n      }\n    }\n  }\n\n  /**\n   * @internal A.16: intenta manejar el error con el boundary propio.\n   * `null` = este nodo no tiene boundary — seguir subiendo.\n   */\n  _handleError(info: ComponentErrorInfo): ErrorResolution | null {\n    if (this.kind === \"function\" && this.hooks.onError) {\n      const r = this.hooks.onError(info);\n      if (r === undefined) return { handled: true };\n      return r;\n    }\n    if (this.kind === \"class\" && this._inst?.onError) {\n      this._inst.onError(info.cause);\n      return { handled: true };\n    }\n    return null;\n  }\n\n  /** A.16: errores de teardown — se reportan a la cadena; si nadie los maneja quedan registrados. */\n  private _reportSwallowed(err: unknown, phase: ErrorPhase): void {\n    const res = reportError(this, { phase, component: this, cause: err });\n    if (!res.handled) console.error(\"[elur-next] error en \" + phase + \":\", err);\n  }\n\n  /** A.16: renderiza el fallback de una boundary en la posición del componente. */\n  private _renderFallback(\n    fallback: Renderable,\n    parent: Node,\n    before: Node | null,\n  ): void {\n    const r = asRenderable(fallback);\n    if (r) r._render(parent, before);\n    else if (typeof fallback === \"string\" || typeof fallback === \"number\") {\n      parent.insertBefore(document.createTextNode(String(fallback)), before);\n    } else if (Array.isArray(fallback)) {\n      for (const f of fallback) this._renderFallback(f, parent, before);\n    }\n    // ComponentInvocation / ElurComponent se montan por el camino normal.\n    else if (fallback) {\n      new ComponentInstance(fallback as ComponentInvocation<unknown>).mount(\n        parent,\n        before,\n      );\n    }\n  }\n\n  /** Camina la cadena de owners hasta la instancia registrada más cercana. */\n  private _resolveParent(): void {\n    let o = getOwner();\n    while (o) {\n      const inst = ownerToInstance.get(o);\n      if (inst) {\n        this.parent = inst;\n        return;\n      }\n      o = o.parent;\n    }\n  }\n\n  private _rollback(): void {\n    // Cancelar hooks pendientes + cleanups + owner + hijos + DOM insertado.\n    this.owner.dispose();\n    try {\n      this._renderCleanup?.();\n    } finally {\n      this._renderCleanup = null;\n      this.state = \"failed\";\n    }\n  }\n\n  private _makeSetupCtx(): SetupCtx {\n    const inst = this;\n    return {\n      owner: this.owner,\n      onMount(fn) {\n        inst.hooks.onMount = fn;\n      },\n      onUnmount(fn) {\n        inst.hooks.onUnmount = fn;\n      },\n      onError(fn) {\n        inst.hooks.onError = fn;\n      },\n      onServerRender(fn) {\n        inst.hooks.onServerRender = fn;\n      },\n      propSignal(key) {\n        return inst._propSignals?.get(key);\n      },\n      slots: this._invocation?.slots,\n      // Devuelve el Slot marcado — el renderer lo desenvuelve bajo el owner\n      // del declarante (contexto léxico, A.14).\n      slot(name = \"default\") {\n        return inst._invocation?.slots?.[name];\n      },\n    };\n  }\n\n  /** Fases initializing+rendering: setup/onInit + render → this.renderable. */\n  private _initBody(): void {\n    if (this.kind === \"class\") {\n      const inst = this._inst!;\n      this._phase = \"init\";\n      inst.onInit?.();\n      this._phase = \"render\";\n      this.state = \"rendering\";\n      this.renderable = asRenderable(inst.render());\n    } else {\n      const inv = this._invocation!;\n      const ctx = this._makeSetupCtx();\n      this._phase = \"setup\";\n      this.state = \"rendering\";\n      // A.13: LiveProps — getters readonly sobre signals internas.\n      // Leer props.x dentro de un binding/effect registra dependencia.\n      this.renderable = asRenderable(\n        inv.definition.setup(this._initProps(inv.props), ctx),\n      );\n    }\n    if (!this.renderable) {\n      throw new Error(\n        `[elur-next] El componente #${this.id} no produjo un template renderizable.`,\n      );\n    }\n  }\n\n  /** Corre `body` dentro del frame de contexto (snapshot o frame nuevo). */\n  private _withScope(\n    ctxSnapshot: Map<unknown, unknown>[] | undefined,\n    body: () => void,\n  ): void {\n    if (ctxSnapshot) {\n      _withComponentContext(ctxSnapshot, body);\n    } else {\n      _pushComponentContext();\n      try {\n        body();\n      } finally {\n        _popComponentContext();\n      }\n    }\n  }\n\n  /**\n   * A.18 — hidratación: setup/onInit + render una sola vez, luego adopta el\n   * DOM SSR via ctx.render (que activa bindings dentro del owner de la\n   * instancia). En mismatch: rollback de la activación + remount por el mismo\n   * kernel REUSANDO el renderable — setup/onInit no se duplica.\n   */\n  _hydrate(ctx: {\n    parent: Node;\n    bounds: { start: Comment; end: Comment } | null;\n    render(value: unknown): unknown;\n    /** \"throw\" propaga el mismatch en vez de remontar (HydrateOptions). */\n    mismatch?: \"throw\" | \"warn-remount\" | \"remount\";\n  }): void {\n    if (this.state !== \"created\") {\n      throw new Error(`[elur-next] _hydrate(): estado inválido \"${this.state}\".`);\n    }\n    ownerToInstance.set(this.owner, this);\n    ownerToContext.set(this.owner, this.context);\n    this._resolveParent();\n    this.owner.parent = getOwner();\n    try {\n      this.state = \"initializing\";\n      let hydrateCleanup: unknown;\n      runWithOwner(this.owner, () =>\n        this._withScope(undefined, () => {\n          this._initBody();\n          this.state = \"pending-mount\";\n          hydrateCleanup = ctx.render(this.renderable);\n        }),\n      );\n      this._renderCleanup =\n        typeof hydrateCleanup === \"function\" ? (hydrateCleanup as () => void) : null;\n      this.state = \"mounted\";\n      this._runOnMount();\n    } catch (error) {\n      if (ctx.mismatch === \"throw\") throw error;\n      if (ctx.mismatch !== \"remount\") {\n        console.warn(\"[elur] Hydration mismatch en componente; remounting:\", error);\n      }\n      // Mismatch SSR → rollback de la activación y remount por el kernel,\n      // reutilizando this.renderable (onInit/setup ya corrieron — A.18).\n      this.owner.dispose();\n      const retry = this.renderable;\n      this.state = \"initializing\";\n      runWithOwner(this.owner, () =>\n        this._withScope(undefined, () => {\n          if (!retry) this._initBody();\n          this.state = \"pending-mount\";\n          this._renderCleanup = this.renderable!._render(\n            ctx.parent,\n            ctx.bounds?.end ?? null,\n          );\n        }),\n      );\n      this.state = \"mounted\";\n      this._runOnMount();\n    }\n  }\n\n  /**\n   * A.17 — SSR: setup/onInit + onServerRender + serializar el renderable.\n   * NO corre onMount/onUnmount; el owner server-side se dispone al final\n   * (mata effects/computeds creados en setup).\n   */\n  async _renderServer(sctx: {\n    markers?: boolean;\n    render(value: unknown, options?: { markers?: boolean }): string | Promise<string>;\n  }): Promise<string> {\n    this.state = \"initializing\";\n    ownerToInstance.set(this.owner, this);\n    ownerToContext.set(this.owner, this.context);\n    this._resolveParent();\n    this.owner.parent = getOwner();\n    runWithOwner(this.owner, () =>\n      this._withScope(undefined, () => {\n        this._initBody();\n        if (this.kind === \"class\") this._inst!.onServerRender?.();\n        else this.hooks.onServerRender?.();\n      }),\n    );\n    try {\n      return await sctx.render(this.renderable, { markers: sctx.markers });\n    } finally {\n      // Disposal server-side: cleanups + hijos reactivos, sin lifecycle DOM.\n      this.owner.dispose();\n      this.state = \"disposed\";\n    }\n  }\n\n  /**\n   * A.13 — crea el objeto LiveProps: propiedades readonly respaldadas por\n   * signals. OJO: destructurar props en setup crea snapshots no reactivos.\n   */\n  private _initProps(props: unknown): Record<string, unknown> {\n    this._propSignals = new Map();\n    this._liveProps = {};\n    if (props != null && typeof props === \"object\") {\n      for (const [key, value] of Object.entries(props)) {\n        if (key === \"key\") continue; // la key es identidad, no prop reactiva\n        const sig = signal(value);\n        this._propSignals.set(key, sig);\n        Object.defineProperty(this._liveProps, key, {\n          enumerable: true,\n          get: () => sig.value,\n        });\n      }\n    }\n    return this._liveProps;\n  }\n\n  /**\n   * A.13/A.15 — true si `inv` es la misma definición con la misma key:\n   * entonces el runtime debe actualizar props, no recrear el setup.\n   */\n  matches(inv: ComponentInvocation<any>): boolean {\n    if (this.kind !== \"function\" || !this._invocation) return false;\n    const keyOf = (p: unknown) =>\n      p != null && typeof p === \"object\"\n        ? (p as Record<string, unknown>).key\n        : undefined;\n    return (\n      inv.definition === this._invocation.definition &&\n      keyOf(inv.props) === keyOf(this._invocation.props)\n    );\n  }\n\n  /**\n   * A.13 — actualiza props sin recrear setup: escribe cada signal de prop.\n   * Props nuevas se añaden; props desaparecidas quedan en undefined.\n   */\n  updateProps(props: unknown): void {\n    if (!this._propSignals || !this._liveProps) return;\n    const seen = new Set<string>();\n    if (props != null && typeof props === \"object\") {\n      for (const [key, value] of Object.entries(props)) {\n        if (key === \"key\") continue;\n        seen.add(key);\n        const sig = this._propSignals.get(key);\n        if (sig) {\n          sig.value = value;\n        } else {\n          const s = signal(value);\n          this._propSignals.set(key, s);\n          Object.defineProperty(this._liveProps, key, {\n            enumerable: true,\n            get: () => s.value,\n          });\n        }\n      }\n    }\n    for (const key of this._propSignals.keys()) {\n      if (!seen.has(key)) this._propSignals.get(key)!.value = undefined;\n    }\n  }\n}\n\n/**\n * A.16: burbujeo de errores por la cadena de instancias (padres reales del\n * árbol de componentes). Devuelve la primera resolución manejada; si nadie\n * maneja el error, `{ handled: false }` y el caller decide (re-lanzar o\n * registrar).\n */\nexport function reportError(\n  from: ComponentInstance,\n  info: ComponentErrorInfo,\n): ErrorResolution {\n  let cur: ComponentInstance | null = from;\n  while (cur) {\n    const r = cur._handleError(info);\n    if (r !== null) return r;\n    cur = cur.parent;\n  }\n  return { handled: false };\n}\n\n// --- Adaptador de clase ---------------------------------------------------------\n\n/** Envuelve un ElurComponent de clase en el kernel unificado. */\nexport function adaptClassComponent(inst: ElurComponent): ComponentInstance {\n  const ci = new ComponentInstance(inst);\n  // Los hooks de clase se leen de la instancia en mount/unmount directamente\n  // (onInit/onMount/onUnmount/onError) — no necesitan registro por ctx.\n  return ci;\n}\n\n// --- Componentes funcionales (A.5) ------------------------------------------------\n\nexport interface ComponentDefinition<P> {\n  (props?: P, slots?: Record<string, Slot>): ComponentInvocation<P>;\n  readonly setup: (props: P | undefined, ctx: SetupCtx) => unknown;\n  readonly _isComponentDefinition: true;\n}\n\n/** Invocación marcada: `Counter({ initial: 10 })` NO ejecuta setup — monta después. */\nexport class ComponentInvocation<P> {\n  readonly [ELUR_RENDER_PROTOCOL] = {\n    mountDom: (ctx: DomProtocolContext): (() => void) => {\n      const inst = new ComponentInstance(this as ComponentInvocation<any>);\n      // mount() resuelve `parent` caminando la cadena de owners — bajo el\n      // swap, el caller corre dentro del owner del componente padre.\n      inst.mount(ctx.parent, ctx.before);\n      return () => inst.unmount();\n    },\n    // A.17 — SSR: setup + onServerRender + serialización; sin lifecycle DOM.\n    renderServer: (sctx: {\n      markers?: boolean;\n      render(value: unknown, options?: { markers?: boolean }): string | Promise<string>;\n    }): Promise<string> => {\n      const inst = new ComponentInstance(this as ComponentInvocation<any>);\n      return inst._renderServer(sctx);\n    },\n    // A.18 — hidratación: setup una vez + adopta DOM SSR; mismatch → remount\n    // por el kernel reusando el renderable.\n    hydrateDom: (ctx: {\n      parent: Node;\n      bounds: { start: Comment; end: Comment } | null;\n      render(value: unknown): unknown;\n    }): (() => void) => {\n      const inst = new ComponentInstance(this as ComponentInvocation<any>);\n      inst._hydrate(ctx);\n      return () => inst.unmount();\n    },\n  };\n\n  readonly definition: ComponentDefinition<P>;\n  readonly props: P | undefined;\n  /** A.14: slots declarados en la llamada — `Card(props, { default: slot(...) })`. */\n  readonly slots: Record<string, Slot> | undefined;\n\n  constructor(\n    definition: ComponentDefinition<P>,\n    props: P | undefined,\n    slots?: Record<string, Slot>,\n  ) {\n    this.definition = definition;\n    this.props = props;\n    this.slots = slots;\n  }\n}\n\nexport function isComponentInvocation(v: unknown): v is ComponentInvocation<any> {\n  return v instanceof ComponentInvocation;\n}\n\n/** Owner → instancia, para localizar el padre al montar una invocación. */\nconst ownerToInstance = new WeakMap<OwnerLike, ComponentInstance>();\n/** Owner → frame de contexto (instancias o roots de mount con provides). */\nconst ownerToContext = new WeakMap<OwnerLike, Map<unknown, unknown>>();\n\n/**\n * @internal — registra un frame de contexto para un owner raíz (mount de\n * template con router, roots de app, etc).\n */\nexport function _registerContextOwner(\n  owner: OwnerLike,\n  context: Map<unknown, unknown>,\n): void {\n  ownerToContext.set(owner, context);\n}\n\n// --- A.12: contexto permanente por instancia -----------------------------------\n//\n// El modelo actual usa un stack global empujado durante init/render — por eso\n// provide/inject fallan fuera de esas fases (A.3.6). Aquí el contexto ES de la\n// instancia: un Map propio por ComponentInstance, resuelto caminando la cadena\n// de owners activa. inject() funciona en setup, effects, onMount y callbacks —\n// el árbol de owners reproduce el árbol de componentes permanentemente.\n// Si no hay instancia en la cadena → undefined → el resolver cae al stack\n// global (misma semántica: provide fuera de componente lanza error).\n\n// Resolver secundario: el primario (server/index, ALS) gana durante SSR;\n// éste se consulta cuando aquél devuelve undefined (lado cliente).\n_pushContextScopeResolver(() => {\n  const frames: Map<unknown, unknown>[] = [];\n  let o: OwnerLike | null = getOwner();\n  while (o) {\n    const ctx = ownerToContext.get(o);\n    if (ctx) frames.push(ctx);\n    o = o.parent;\n  }\n  if (frames.length === 0) return undefined;\n  frames.reverse(); // cadena innermost→outermost → stack outermost→innermost\n  return frames;\n});\n\n/**\n * Define un componente funcional de primera clase (A.5):\n * `Counter(props)` retorna una invocación marcada; el runtime ejecuta el\n * setup cuando monta la invocación.\n */\nexport function defineComponent<P = Record<string, never>>(\n  setup: (props: P | undefined, ctx: SetupCtx) => unknown,\n): ComponentDefinition<P> {\n  const def = ((props?: P, slots?: Record<string, Slot>) =>\n    new ComponentInvocation<P>(\n      def as ComponentDefinition<P>,\n      props,\n      slots,\n    )) as ComponentDefinition<P>;\n  (def as { setup: unknown }).setup = setup;\n  (def as { _isComponentDefinition: boolean })._isComponentDefinition = true;\n  return def;\n}\n\n// --- Mount de alto nivel ------------------------------------------------------------\n\n/**\n * Monta un componente (clase o invocación funcional) en `container` y\n * devuelve el handle con `unmount()`. Todo el árbol reactivo muere con el\n * unmount — sin fugas de effects/computeds.\n */\nexport function mountComponent(\n  value: ElurComponent | ComponentInvocation<any>,\n  container: Element,\n): { unmount(): void; instance: ComponentInstance } {\n  const inst = new ComponentInstance(value);\n  inst.mount(container, null);\n  return { unmount: () => inst.unmount(), instance: inst };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,283 @@
+/**
+ * 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;
+        /** "throw" propaga el mismatch en vez de remontar (HydrateOptions). */
+        mismatch?: "throw" | "warn-remount" | "remount";
+    }): 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 {};