# Turbopack se cuelga: el worker WASM que se lanza a sí mismo

> Mi build de Next.js 16 con Turbopack se quedaba esperando, sin error, por un LibRaw compilado con -pthread. El fork sin hilos y los otros cuatro fallos mudos.

**Respuesta corta:** mi build con Turbopack no fallaba, esperaba. LibRaw, lo que uso para decodificar RAW en el navegador, venía compilado con `-pthread`, y ese código generado lanza workers de su propio módulo desde dentro de un worker. El arreglo fue quitar `-pthread` en un fork, `libraw-wasm-nothread`.

Lo incómodo de esta historia es que ninguno de sus cinco fallos dio un error. El build se quedaba parado. Un `Promise.all` no terminaba nunca. Todas las fotos decían ser de enero de 1970. SnapCompress, mi compresor de imágenes en el navegador, perdía memoria por algo que el README no contaba. Y el workflow de release contestaba «ya publicado» a una versión que no estaba en npm.

Sin traza que pegar en un buscador, lo único que sirve es saber qué forma tiene cada silencio. Eso es lo que cuento aquí, con lo que se cambió en cada caso.

## El build no peta: espera a un worker que se lanza a sí mismo

En septiembre de 2026, Turbopack ya era el bundler por defecto de Next.js 16. La [documentación de Turbopack](https://nextjs.org/docs/app/api-reference/turbopack) lo dice sin rodeos y no hace falta configurar nada para usarlo. Así que mi build pasaba por él aunque yo no lo hubiera elegido, y con el paquete original, `libraw-wasm`, se colgaba sin error.

La causa está en cómo hace hilos Emscripten. Según su [documentación de pthreads](https://emscripten.org/docs/porting/pthreads.html), los implementa con `SharedArrayBuffer` y Web Workers, y se activan pasando `-pthread` al compilar y al enlazar. El runtime generado mantiene un pool de workers para esos hilos. En el `libraw.js` que publicaba el paquete original, la línea que crea cada worker del pool en el caso por defecto es esta (formateada para el post; en el fichero está minificada):

```js
worker = new Worker(new URL("libraw.js", import.meta.url), {
  type: "module",
  name: "em-pthread",
});
```

Fíjate en el fichero que carga: es el mismo `libraw.js` donde está esa línea. El grafo completo queda así: `index.js` lanza `worker.js`, `worker.js` importa `libraw.js`, y `libraw.js` lanza workers de `libraw.js`. Turbopack trata las expresiones `new Worker()` como dependencias que tiene que resolver en el build, y aquí la dependencia apunta a su propio módulo, desde dentro de un worker. El bundler se pone a resolver ese grafo autorreferente y ahí se queda.

En mi caso fue un módulo Emscripten compilado con `-pthread`. No sé cuántas dependencias más hacen lo mismo, pero si un build se me queda quieto sin mensaje, es lo primero que buscaría.

## LibRaw no necesitaba hilos para funcionar: quitar `-pthread` deshizo el bucle

LibRaw funciona sin hilos. Funcionar no es ir igual de rápido: no medí el rendimiento con hilos y sin ellos, así que no sé cuánto se pierde.

El commit de septiembre que creó el fork quitó `-pthread` y `-s USE_PTHREADS=1` del enlazado final, sacó `-lpthread` y OpenMP de la configuración de LibRaw y, de paso, subió la versión de Emscripten en los workflows. De ahí sale el nombre, `libraw-wasm-nothread`. Y como el mismo commit cambió los flags y la versión de Emscripten, no es un experimento de una sola variable.

No bastó con borrar el flag. Según el commit que lo arregló, un día después, el enlazado final fallaba con `undefined symbol: operator new`, y sospecha que antes el runtime de C++ que necesita el wrapper entraba de rebote con `-pthread`. Sea como sea, cambió el enlazado de `emcc` a `em++`, que es el que toca para C++.

El código del wrapper no cambió. Lo que cambia es la forma del grafo: en el `libraw.js` que publica el fork ya no hay ningún `new Worker`, y queda un único worker, el que `index.js` crea para `worker.js`. Lo comprobó un agente para este artículo sobre el paquete publicado en npm.

La documentación de Emscripten explica por qué no hay término medio: «It is not possible to build one binary that would be able to leverage multithreading when available and fall back to single threaded when not». O compilas con hilos o sin ellos. Y sin `-pthread` te ahorras otra cosa que esa misma página avisa: el código con pthreads necesita las cabeceras COOP y COEP en el despliegue.

## Dos llamadas a la vez y un solo hueco para la respuesta

Los dos fallos siguientes son anteriores al fork, de junio de 2026, y el fork los heredó ya arreglados. Los cuento porque fallaban igual de callados.

`Promise.all([raw.metadata(), raw.imageData()])` se quedaba colgado para siempre, sin error. El cliente del worker guardaba un único hueco para la respuesta pendiente. La respuesta de `metadata` llegaba primero, resolvía la promesa de `imageData` con el payload equivocado, y la promesa de `metadata` no se resolvía nunca.

El arreglo de junio, que está en el historial público del repo, da un id a cada llamada y guarda las pendientes en un mapa. Este es el patrón, adaptado del `index.js` del fork y sin la cola por instancia:

```js
class WorkerClient {
  constructor(url) {
    this.worker = new Worker(url, { type: "module" });
    this.pending = new Map(); // id -> { resolve, reject }
    this.nextId = 0;
    this.worker.onmessage = ({ data }) => {
      const slot = this.pending.get(data?.id);
      if (!slot) return; // respuesta desconocida o ya resuelta: se ignora
      this.pending.delete(data.id);
      if (data.error) slot.reject(new Error(data.error));
      else slot.resolve(data.out);
    };
  }

  call(fn, ...args) {
    return new Promise((resolve, reject) => {
      const id = this.nextId++;
      this.pending.set(id, { resolve, reject });
      this.worker.postMessage({ id, fn, args });
    });
  }

  dispose() {
    this.worker.terminate();
    for (const { reject } of this.pending.values()) reject(new Error("disposed"));
    this.pending.clear();
  }
}
```

El worker tiene que devolver el mismo `id` que recibió; en el fork es `self.postMessage({id, out})`. Además, el código real encadena las llamadas de cada instancia en una cola, porque LibRaw tiene estado: abres un fichero y luego le pides metadatos o píxeles de ese fichero. El mapa evita que una respuesta resuelva la promesa equivocada; la cola evita que dos llamadas pisen el mismo estado.

Cómo se reconoce: cada llamada suelta funciona y juntas se cuelgan. Si te pasa con cualquier cliente de worker, cuenta cuántos resolvers guarda a la vez.

## Todas las fotos eran de enero de 1970

También en junio de 2026, todas las fechas de captura salían en enero de 1970. LibRaw da el timestamp en segundos. `new Date()` espera milisegundos: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) lo define como el número de milisegundos desde el 1 de enero de 1970 en UTC. Pásale segundos y cualquier fecha reciente cae en las primeras semanas de 1970.

Con un ARW de Sony, la fecha pasó de 1970-01-20 a 2023-04-29 al cambiar una línea por `new Date(metadata.timestamp * 1000)`. Se comprobó con el fichero real.

Este es el fallo más traicionero de los cinco porque devuelve un dato con buena pinta. Una fecha es una fecha. Si ves muchas fotos agrupadas en enero de 1970, lo más probable es que te estén dando segundos.

## La fuga estaba en el README

Cada instancia de `LibRaw` tiene su propio worker y su propio heap WASM, y ninguno se libera hasta que llamas a `dispose()`. El README original no lo decía. SnapCompress tuvo una fuga por eso.

El código ya tenía `dispose()` desde junio; al README le faltaba decir que había que llamarlo. El commit de septiembre añadió al README del fork que cada instancia es dueña de un worker y que hay que llamar a `dispose()` en un `finally`, para que se ejecute aunque `open()` o `imageData()` lancen una excepción.

Si creas una instancia por foto, cuenta los workers vivos después de procesar unas cuantas. Si no bajan, tienes este problema, con LibRaw o con cualquier otra dependencia que meta un worker detrás de un `new`.

## El release era idempotente para el paquete equivocado

El fork heredó el workflow de release del original. Antes de publicar, ese workflow comprobaba en npm si la versión ya existía, para no fallar cuando un tag y una ejecución manual disparaban la misma release. Pero comprobaba `libraw-wasm@<versión>`, el paquete original, y no el fork.

El release nunca publicaba: el paso decía «ya publicado» y `npm publish` no llegaba a ejecutarse. El commit de septiembre cambió el nombre en la comprobación a `libraw-wasm-nothread`.

Un paso idempotente que responde «ya está hecho» es lo más difícil de vigilar, porque el log se ve verde. Cuando hagas un fork, busca el nombre antiguo en `.github/` antes de la primera release.

## Lo que me cuesta el fork y lo que no sé

Un fork es mantenimiento que antes no tenía. Lo que cambie en el paquete original lo tengo que traer yo, y el workflow de release ahora es mío, con lo que ya me ha fallado una vez.

Lo que me cuesta en velocidad sigue sin medir. El README del fork dice que el demosaicado de LibRaw no usaba hilos en el build original, pero lo apoya en un issue del paquete original, no en una medición mía. Lo que sí se ve en el paquete publicado es que el worker recursivo ya no está.

Los arreglos de junio de 2026 también están en la última versión publicada del paquete original: un agente vio el mapa de pendientes y la multiplicación del timestamp en su código para este artículo. Pero son de junio, y nada impide que ese código cambie en una versión futura del original.

## Si tu build de Turbopack se queda colgado sin mensaje

Primero, confirma que es Turbopack. La documentación de Next.js 16 indica cómo salir de él: `next build --webpack`. Si con webpack termina y con Turbopack no, ya tienes al sospechoso acotado: algo que Turbopack intenta resolver en tu grafo.

Después, busca workers de pthreads de Emscripten en tus dependencias. El runtime les pone el nombre `em-pthread`:

```bash
grep -rl --include='*.js' 'em-pthread' node_modules/
```

En una carpeta limpia con los dos paquetes instalados, un agente ejecutó ese comando para este artículo: devolvió el `libraw.js` y el `worker.js` de `libraw-wasm`, y nada de `libraw-wasm-nothread`.

Si aparece una dependencia y controlas su build, mira si de verdad necesita hilos y prueba a compilarla sin `-pthread`. Si no lo controlas, busca una variante sin hilos o haz el fork. No cuentes con `turbopackIgnore`: Turbopack documenta ese comentario para expresiones `new Worker()`, pero el README del fork cuenta que se probó primero y no bastó.

## Fuentes

- Emscripten, [Pthreads support](https://emscripten.org/docs/porting/pthreads.html), consultado el 15 de noviembre de 2026: `-pthread`, pool de workers y cabeceras COOP/COEP.
- Next.js, [Turbopack](https://nextjs.org/docs/app/api-reference/turbopack) y el [anuncio de Next.js 16](https://nextjs.org/blog/next-16), consultados el 15 de noviembre de 2026: bundler por defecto, `--webpack` y comentarios mágicos.
- MDN, [constructor de Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date), consultado el 15 de noviembre de 2026.
- El repo público del fork, [libraw-wasm-nothread](https://github.com/garbarok/libraw-wasm-nothread), y los paquetes de npm. Un agente leyó para este artículo el historial público, los commits de junio y septiembre y el código publicado; los hechos de mi parte salen de mis notas de cada fallo.

**Lectura relacionada:** [otro fallo que solo aparecía fuera de mi máquina: tests que pasan en local y fallan en Vercel](/blog/tests-localmente-fallan-vercel/).

---

**P.D.** ¿Te has encontrado algún build que se queda esperando sin decir nada? Cuéntame qué era en [LinkedIn](https://www.linkedin.com/in/oscargallegoruiz).
