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.
| Motor | kairo | mol | dynamic | cellx | s |
|---|---|---|---|---|---|
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.

![Node.JS [ru]](/api/digests/it_development/daily/20261119/assets/sources/we-use-js.jpg?v=a5c8d2f41d1b69be62050734cec69b401848f59f814f8109602d16b49a9e4675)