ReactiveEngine v3.0 y listas intrusivas en JS: cómo dejar Set y Map acelera la reactividadArtículo · digest del 19 de noviembre
ReactiveEngine v3.0 y listas intrusivas en JS: cómo dejar Set y Map acelera la reactividad
Artículo4 secciones≈ 9 min

ReactiveEngine v3.0 y listas intrusivas en JS: cómo dejar Set y Map acelera la reactividad

Escribes un computed normal con una condición if/else, por ejemplo una pantalla que alterna entre dos pestañas. Desde fuera parece un detalle menor. Pero en un motor reactivo ingenuo justo ahí se esconde el freno: mientras el grafo de dependencias es estático, Set y Map vuelan; en cuanto las suscripciones empiezan a saltar en cada ciclo, el motor se pone a calcular hashes, borrar entradas y generar basura para el recolector.

Sobre esa idea se apoya el lanzamiento de @pravosleva/reactive-engine v3.0.0 (parche actual 3.0.2 del 18 de noviembre de 2026, código en GitHub). El autor del análisis en Habr, @mad-den, destacó el enfoque del creador: la API pública se mantuvo totalmente compatible hacia atrás —aunque la primera versión, según cuenta, estaba «en coma»—, pero todo el núcleo se reescribió desde cero. En lugar de Set y Map pusieron listas doblemente enlazadas intrusivas y un pool de objetos. Un truco del kernel de Linux, pero en JS normal y con un peso de apenas 7.31 KB gzip.

Por qué Set y Map patinan cuando las suscripciones saltan

Detrás de las señales hay un grafo reactivo: las señales (signal), cálculos (computed) y efectos (effect) son nodos, y las suscripciones de «quién depende de quién» son aristas. La forma directa es sencilla: la señal guarda un Set de suscriptores y el computed guarda un Set de señales leídas.

Cuando cambia una rama if/else dentro de computed, el motor se desuscribe de las dependencias viejas y recoge las nuevas:

// Recálculo ingenuo de dependencias usando Set normal
function recompute(node, computeFn) {
  for (const dep of node.deps) {
    // Búsqueda por hash en los buckets de Set en cada baja
    dep.subs.delete(node)
  }
  node.deps.clear()
  return computeFn()
}

Con una decena de nodos ni se nota. Pero en un bucle caliente donde las ramas cambian miles de veces seguidas, cada delete y add en Set calcula un hash, entra en tablas internas y crea objetos temporales. Sube la GC pressure (presión sobre el recolector de basura). V8 (Scavenger y Mark-Sweep) empieza a dispararse en mitad de los cálculos y provoca micropausas. Por eso los motores modernos de señales (alien-signals, Vue 3.5+, Preact Signals) fueron dejando Set por listas intrusivas inspiradas en struct list_head del kernel de Linux.

Lista intrusiva y pool LinkPool por debajo

En una colección normal, el contenedor reserva memoria para un envoltorio aparte alrededor de los datos. En una lista doblemente enlazada intrusiva, los punteros prev y next viven dentro del propio objeto de enlace, sin buckets externos ni hashes.

En src/core/core.ts de ReactiveEngine, cada arista del grafo es un NodeLink. Participa a la vez en dos listas: suscriptores de la señal (nextSubscriber / prevSubscriber) y dependencias del consumidor (nextDependency / prevDependency). Darse de baja cuesta O(1): el motor no busca el nodo en un Set, sino que simplemente reenlaza un par de referencias en los vecinos.

Después entra el pool de objetos (LinkPool). Al romper un enlace, NodeLink no va a la basura: el método clear() limpia los campos y guarda el objeto en un array-pool para reutilizarlo al instante:

// De src/core/core.ts (@pravosleva/reactive-engine v3.0.x)
export class NodeLink {
  public source: ReactiveNode | null = null
  public target: ReactiveNode | null = null
  public nextSubscriber: NodeLink | null = null
  public prevSubscriber: NodeLink | null = null
  public nextDependency: NodeLink | null = null
  public prevDependency: NodeLink | null = null
  public version: number = 0

  public clear(): void {
    this.source = null
    this.target = null
    this.nextSubscriber = null
    this.prevSubscriber = null
    this.nextDependency = null
    this.prevDependency = null
    this.version = 0
  }
}

export class LinkPool {
  private static pool: NodeLink[] = []
  private static size = 0
  // Tope de 2048 (~64–96 KB en Old Space de V8)
  private static maxPoolSize = 2048

  public static acquire(
    source: ReactiveNode,
    target: ReactiveNode
  ): NodeLink {
    if (this.size > 0) {
      this.size--
      const link = this.pool[this.size]
      this.pool[this.size] = null as unknown as NodeLink
      link.source = source
      link.target = target
      return link
    }
    const link = new NodeLink()
    link.source = source
    link.target = target
    return link
  }

  public static release(link: NodeLink): void {
    link.clear()
    if (this.size < this.maxPoolSize) {
      this.pool[this.size] = link
      this.size++
    }
  }
}

Un detalle acertado es el tope estricto maxPoolSize = 2048 (unos 64–96 KB en Old Space de V8). Si la app sufre un pico puntual y el grafo crece mucho, los enlaces sobrantes no se quedan atascados en memoria para siempre: V8 Scavenger los recoge sin problema. Y en un bucle caliente estable, el motor recicla los mismos objetos con cero asignaciones nuevas.

Qué mostraron los benchmarks y tests de corrección del grafo

En transitive-bullshit/js-reactivity-benchmark, los motores se comparan por media geométrica frente al participante más rápido de cada suite: 1.00× es el líder, cuanto menor, mejor.

Motorkairomoldynamiccellxs
alien-signals (3.2.1)1.00×1.03×1.00×1.10×1.02×
Preact Signals (1.14.4)1.19×1.03×1.52×1.32×1.37×
@pravosleva/reactive-engine (3.0.0)1.69×1.06×1.30×1.22×3.69×
@vue/reactivity (3.5.44)1.89×1.00×2.03×1.51×1.54×
@angular/signals (22.1.7)2.72×1.05×3.32×1.63×3.29×
SolidJS (1.9.17)3.78×1.27×4.39×1.63×3.89×
Svelte v5 (5.57.0)3.92×1.03×2.80×111.18×3.40×
MobX (7.0.6)4.41×1.28×4.37×2.54×4.90×

El panorama es honesto. En escenarios dinámicos el nuevo núcleo supera con claridad tanto a Vue como a Angular Signals: en dynamic las suscripciones se reconfiguran sin parar, en kairo se prueba propagación amplia y cambio de ramas if/else, y en mol una pasada larga de diez mil iteraciones con dependencias condicionales castiga de inmediato a cualquier motor con pausas de GC. En cambio, en la suite s el índice general es bastante más flojo y queda por detrás de alien-signals y Vue (aunque en la prueba puntual updateComputations1000to1 toma ventaja).

En ejecuciones dinámicas pesadas, la diferencia frente a los grandes frameworks se nota aún más:

Tiempo de ejecución en escenarios dinámicos pesados (menor es mejor)

En la malla densa wide dense y en la propagación amplia broadPropagation, mover punteros en lugar de tablas hash y evitar asignaciones extra da un margen notable de tiempo.

En la suite de corrección de grafo johnsoncodehk/reactive-framework-test-suite, el motor pasó 159 de 161 pruebas (98.8%), al mismo nivel que @vue/reactivity 3.5.45, al que le fallan otros dos casos (#123 y #141). Ambos fallos de ReactiveEngine (#212 y #213) corresponden al caso raro de Inner Write: escribir de vuelta en la señal raíz directamente desde un efecto que depende de ella. En la práctica es un antipatrón, y en exactamente los mismos dos casos tropiezan el polyfill oficial de TC39 Signals (signal-polyfill) y @solidjs/signals.

Servicios y DI como en Angular, pero sin Angular

¿Por qué en Habr compararon la librería justo con @angular/core? Por el estilo de organización del código: ReactiveEngine estructura la lógica de negocio alrededor de clases-servicio (AbstractService) e Inyección de Dependencias (DI), donde los servicios no se instancian a mano en los componentes, sino que se obtienen de un contenedor común con engine.inject(...).

import { AbstractService } from '@pravosleva/reactive-engine'
import { ReactiveEngine } from '@pravosleva/reactive-engine/react'

// La lógica vive en una clase normal y no depende de React
class CounterService extends AbstractService {
  public counter = this.engine.signal<number>(0, 'counter:value')

  public inc = () => {
    this.counter.value += 1
  }
}

const engine = new ReactiveEngine()

export const CounterWidget = () => {
  const logic = engine.inject(CounterService)
  // Por debajo usa useSyncExternalStore contra UI tearing
  const counter = engine.use(logic.counter)

  return (
    <button onClick={logic.inc}>
      Count: {counter}
    </button>
  )
}

El paquete tiene licencia MIT, cero dependencias externas y adaptadores para React (^18.0.0 || ^19.2.0), Vue (>=3.2.0) y Angular (>=16.0.0). En la documentación en ruso hay incluso una sección «Patrones STM» con análisis de tareas típicas.

Eso sí, conviene valorar su madurez con realismo: a pesar de un núcleo cuidado y buenos tests, la comunidad alrededor del repositorio es todavía muy joven (al momento de revisar, el proyecto tenía 0 estrellas en GitHub, es decir, un bus factor de uno). Si tu aplicación vive entera dentro de Vue 3 o Angular, la reactividad integrada casi siempre será más fácil de mantener. En cambio, cuando en React o JS puro quieres servicios DI limpios con un grafo rápido de señales —o simplemente te da curiosidad ver en código real cómo funcionan las listas intrusivas en JS—, vale la pena probar ReactiveEngine v3.0.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 6