![read() en bucle sobre a, b y c: un trozo ["abc"] en Node 24.19.0, tres trozos ["a","b","c"] en Node 26.13.0.](/_next/image?url=https%3A%2F%2Fblog-dev-apps.s3.sa-east-1.amazonaws.com%2Fblog-media%2F2026-11%2Fad0de64f-7616-49f1-a491-f9dcc443ee7c-blog-node-26-es.png&w=3840&q=90)
Node 24 a Node 26 en una API NestJS: lo que cambia de verdad
Cambié Node 24 por 26.13.0 en las dos APIs NestJS que mantengo en producción, la de este blog (vertex-api) y la de Pyxis (pyxis-api), y corrí todos los tests que tienen. Pasó todo sin cambiar una línea: 248 tests unitarios y 65 de extremo a extremo en una; 2600 unitarios, 373 de integración y 228 de extremo a extremo en la otra. Las dos arrancan, responden en /health y no imprimen ningún aviso de deprecación, ni siquiera con --pending-deprecation.
Ninguna de las dos pasa a Node 26 esta semana. Las dos corren en AWS Lambda, y el runtime nodejs26.x sigue en preview, que la propia AWS dice que no se use en producción.
Y una suite en verde prueba menos de lo que parece. Entre el 24 y el 26, read() de un Readable empezó a devolver otra cosa y fetch empezó a hablar otro protocolo. Ningún test mío lo cubre, porque nada de mi código depende de eso. El tuyo puede depender.
Lo que se va entre el 24 y el 26, y lo que el 24 avisa antes
El changelog de la 26.0.0, del 5 de mayo de 2026, lista tres eliminaciones que aparecen en todos los resúmenes: los módulos internos _stream_*, el writeHeader() de la respuesta HTTP y el flag --experimental-transform-types. Quien sale del 24 se lleva también las eliminaciones de la 25.0.0, una versión que quien solo usa LTS nunca corrió. Probé cada punto en 24.19.0 para ver si avisa antes de romperse:
| Lo que se va | Código | Eliminado en | ¿Node 24 avisa al ejecutar? |
|---|---|---|---|
require('_stream_readable') y los demás _stream_* | DEP0193 | 26 | no (solo _stream_wrap, por DEP0125) |
res.writeHeader() | DEP0063 | 26 | no, ni con --pending-deprecation |
--experimental-transform-types | flag | 26 | no |
SlowBuffer | DEP0030 | 25 | solo cuando alguien llama a SlowBuffer() |
fs.F_OK, fs.R_OK, fs.W_OK, fs.X_OK | DEP0176 | 25 | sí |
fs.rmdir(ruta, { recursive: true }) | DEP0147 | 25 | sí |
| Corepack incluido con Node | 25 | no aplica |
La lista completa está en la página Deprecated APIs. Dice que DEP0193 pasó a aviso en tiempo de ejecución en la 24.2.0, pero en la 24.19.0 require('_stream_readable') carga en silencio, y la misma página en la documentación de la 24.19.0 lo marca como solo de documentación. Yo confiaría en lo que imprime el proceso, no en la tabla.
En el 26, los dos primeros fallan así:
$ node -e "require('_stream_readable')"
Error: Cannot find module '_stream_readable'
code: 'MODULE_NOT_FOUND',
$ node --experimental-transform-types -e "1"
...\node.exe: bad option: --experimental-transform-types
Y un servidor HTTP que llama a res.writeHeader(200) responde normal en el 24, sin ningún aviso, y en el 26 lanza TypeError: res.writeHeader is not a function en la primera petición. El del flag es el más traicionero, porque no rompe una ruta: impide que el proceso arranque. En una API NestJS es difícil que esté en el código de la aplicación (el TypeScript nativo de Node no transforma decorators, así que una app Nest nunca corrió con él), pero puede estar en un NODE_OPTIONS, en el CMD de un Dockerfile o en un script de CI.
En TypeScript, el compilador ya atrapa una parte. El @types/node 24.13.2 de vertex-api no declara fs.F_OK ni writeHeader, y el 26.6.6 quita también SlowBuffer. Compilé a propósito un archivo que usa los tres: tsc con @types/node 26 señaló los tres, y los dos proyectos compilaron limpios con él. Lo que el compilador no lee es el JavaScript dentro de node_modules, y ahí apareció el caso más interesante.
El resto de la 26.0.0 son agregados: el global Temporal activado por defecto, V8 14.6 (con Map.prototype.getOrInsert() e Iterator.concat()) y undici 8 detrás de fetch. Y un efecto de Web Storage, activado desde el 25: en el 26, sin --localstorage-file, leer typeof localStorage devuelve "undefined" e imprime un ExperimentalWarning. Una biblioteca que lo revisa para saber si está en el navegador va a dejar ese aviso en tu log.
El paquete que muere en el require sin que el 24 avise
@nestjs/jwt usa jsonwebtoken, que usa jws, que usa jwa. En la versión 1.4.1 y en la 2.0.0, la primera línea de jwa carga buffer-equal-constant-time 1.0.1, y ese paquete lee SlowBuffer.prototype al principio del archivo, en el momento en que se carga. Del 25 en adelante, SlowBuffer es undefined.
En mis dos proyectos esto no pasa: vertex-api tiene jwa 2.0.1, y pyxis-api ni siquiera usa jsonwebtoken. Para ver el error, forcé la versión vieja en un directorio aparte:
{
"name": "repro-jwa",
"private": true,
"dependencies": { "jsonwebtoken": "9.0.2" },
"overrides": { "jwa": "1.4.1" }
}
$ node --trace-deprecation --pending-deprecation -e "require('jsonwebtoken'); console.log('ok')" # v24.19.0
ok
$ node -e "require('jsonwebtoken')" # v26.13.0
...\node_modules\buffer-equal-constant-time\index.js:37
var origSlowBufEqual = SlowBuffer.prototype.equal;
^
TypeError: Cannot read properties of undefined (reading 'prototype')
at Object.<anonymous> (...\node_modules\buffer-equal-constant-time\index.js:37:35)
...
at Object.<anonymous> (...\node_modules\jwa\index.js:1:19)
El 24 se queda callado porque el aviso de DEP0030 sale cuando alguien llama a SlowBuffer(), y este código solo lee una propiedad. jwa 1.4.2 y 2.0.1, publicados el 7 de mayo de 2025, solo cargan buffer-equal-constant-time si crypto.timingSafeEqual no existe, cosa que no pasa en ningún Node actual. Un lockfile que nadie actualiza desde antes de eso arranca en el 24 y se cae en el primer require del 26, al iniciar.
La corrección cabe en el rango que el package.json ya acepta (jsonwebtoken 9.0.2 pide jws ^3.2.2, que pide jwa ^1.4.1):
npm ls jwa
npm update jwa
En el directorio de prueba, npm update jwa llevó el paquete a la 1.4.2 y el mismo require pasó en el 26.
read() ahora devuelve un trozo a la vez
Este es el cambio de comportamiento de la 26.0.0 que menos aparece en los resúmenes (el commit se llama "stream: readable read one buffer at a time", nodejs/node#60441). En un Readable de bytes, sin setEncoding, read() sin argumento devolvía todo lo que había en el buffer interno, concatenado. En el 26, devuelve el siguiente trozo, del tamaño con que se empujó.
// readable-read.mjs: lo que devuelve read() sin argumento en Node 24 y en Node 26
import { Readable } from 'node:stream';
const r = new Readable({ read() {} });
r.push(Buffer.from('{"id":1,'));
r.push(Buffer.from('"ok":true}'));
r.push(null);
r.once('readable', () => {
const chunk = r.read(); // sin tamaño: "dame lo que haya en el buffer"
console.log(process.version, JSON.stringify(chunk.toString()));
try {
console.log('parsed:', JSON.parse(chunk));
} catch (err) {
console.log('JSON.parse failed:', err.message);
}
});
$ node readable-read.mjs # Node 24.19.0
v24.19.0 "{\"id\":1,\"ok\":true}"
parsed: { id: 1, ok: true }
$ node readable-read.mjs # Node 26.13.0
v26.13.0 "{\"id\":1,"
JSON.parse failed: Expected double-quoted property name in JSON at position 8 (line 1 column 9)
El efecto llega bastante más allá del read() escrito a mano. Leí los mismos tres trozos (a, b y c, empujados de una vez) de seis maneras:
| Cómo lee | Node 24.19.0 | Node 26.13.0 |
|---|---|---|
read() en bucle hasta null | ["abc"] | ["a","b","c"] |
for await (const chunk of stream) | ["abc"] | ["a","b","c"] |
stream.toArray() | ["abc"] | ["a","b","c"] |
evento 'data' | ["a","b","c"] | ["a","b","c"] |
text() de node:stream/consumers | "abc" | "abc" |
read() en bucle, con setEncoding('utf8') | ["abc"] | ["abc"] |
El camino nuevo solo aplica cuando el stream no tiene decoder; por eso setEncoding mantiene el comportamiento viejo. Código que armaba un mensaje con un único read(), o que trataba cada vuelta del for await como una unidad, pasa a recibir el mensaje en partes. En un socket real ese código ya estaba mal, porque la red nunca prometió fronteras de trozo; el 26 solo vuelve el error determinista.
La documentación de readable.read() de la propia 26.13.0 todavía dice que, sin el argumento, el método devuelve todo el contenido del buffer interno. El script de arriba muestra otra cosa. La descripción del PR sugiere readable.read(readable.readableLength) para acercarse al comportamiento viejo; cuando la idea es leerlo todo, prefiero dejar el read() manual y usar text(), json() o buffer() de node:stream/consumers, que dieron el mismo resultado en las dos versiones.
En los dos proyectos, el único lugar que lee un stream así es la exportación de CSV de pyxis-api: un for await sobre la salida del gzip, que junta los trozos con Buffer.concat y no depende de dónde termina cada uno.
fetch pasa a negociar HTTP/2
undici 8, que está detrás del fetch global en Node 26 (8.12.2 en la 26.13.0; la 24.19.0 trae la 7.29.0), activa HTTP/2 por defecto (nodejs/undici#4828). Si el servidor ofrece h2 en la negociación TLS, fetch lo usa. Un servidor local que acepta los dos protocolos muestra la diferencia:
# Certificado autofirmado, solo para la prueba. En Git Bash de Windows, antepón MSYS_NO_PATHCONV=1.
openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -days 2 -subj "/CN=localhost" -addext "subjectAltName=DNS:localhost"
// fetch-protocol.mjs: con qué versión de HTTP llega el fetch() global a un servidor que acepta las dos
import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';
const server = createSecureServer({
key: readFileSync(new URL('key.pem', import.meta.url)),
cert: readFileSync(new URL('cert.pem', import.meta.url)),
allowHTTP1: true, // acepta HTTP/1.1 y HTTP/2; el cliente elige, vía ALPN
});
server.on('request', (req, res) => res.end(`httpVersion=${req.httpVersion}`));
await new Promise((resolve) => server.listen(0, resolve));
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; // certificado autofirmado, solo en esta prueba local
const res = await fetch(`https://localhost:${server.address().port}/`);
console.log(process.version, `undici ${process.versions.undici}`, await res.text());
process.exit(0);
$ node fetch-protocol.mjs # Node 24.19.0
...
v24.19.0 undici 7.29.0 httpVersion=1.1
$ node fetch-protocol.mjs # Node 26.13.0
...
v26.13.0 undici 8.12.2 httpVersion=2.0
(El ... corta el aviso que Node imprime por el NODE_TLS_REJECT_UNAUTHORIZED.)
Los dos proyectos usan fetch para mandar correos por la API de Resend, y api.resend.com ofrece h2 en la negociación (lo comprobé con openssl s_client -alpn h2,http/1.1). En el 26, ese tráfico cambia de protocolo sin que cambie una sola línea de código. No mandé ningún correo en la prueba: lo que medí fue fetch, no Resend. La página de globals de la documentación de la 26.13.0, por cierto, todavía presenta undici como un cliente HTTP/1.1.
HTTP/2 por defecto también cambia cómo aparecen las fallas. Armé una prueba mínima: el primer fetch al origen lleva una cabecera que undici rechaza en las dos versiones (upgrade), y después vienen dos peticiones normales.
// fetch-h2-hang.mjs: undici rechaza el primer fetch al origen; ¿y los siguientes?
import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';
const server = createSecureServer({
key: readFileSync(new URL('key.pem', import.meta.url)),
cert: readFileSync(new URL('cert.pem', import.meta.url)),
allowHTTP1: true,
});
server.on('request', (req, res) => res.end(`httpVersion=${req.httpVersion}`));
await new Promise((resolve) => server.listen(0, resolve));
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
const url = `https://localhost:${server.address().port}/`;
// 'upgrade' es una cabecera que undici rechaza en fetch, en las dos versiones.
for (const headers of [{ upgrade: 'websocket' }, {}, {}]) {
const started = performance.now();
try {
const res = await fetch(url, { headers, signal: AbortSignal.timeout(3000) });
console.log(process.version, JSON.stringify(headers), res.status, await res.text());
} catch (err) {
const ms = Math.round(performance.now() - started);
console.log(process.version, JSON.stringify(headers), err.cause?.code ?? err.name, `${ms} ms`);
}
}
process.exit(0);
$ node fetch-h2-hang.mjs # Node 24.19.0
v24.19.0 {"upgrade":"websocket"} UND_ERR_INVALID_ARG 15 ms
...
v24.19.0 {} 200 httpVersion=1.1
v24.19.0 {} 200 httpVersion=1.1
$ node fetch-h2-hang.mjs # Node 26.13.0
v26.13.0 {"upgrade":"websocket"} UND_ERR_INVALID_ARG 17 ms
v26.13.0 {} TimeoutError 3004 ms
v26.13.0 {} TimeoutError 3005 ms
En el 26, las peticiones siguientes al mismo origen se quedan paradas hasta que AbortSignal.timeout las corta, y el aviso del NODE_TLS_REJECT_UNAUTHORIZED ni siquiera aparece: no se abrió ninguna conexión TLS. Lo repetí varias veces y el resultado no cambió. Con una petición exitosa antes, un solo rechazo no colgó nada, pero dos rechazos seguidos colgaron la petición siguiente. Una forma plausible de caer en esto es una ruta que reenvía a un fetch las cabeceras de la petición que recibió. No sé si es el mismo defecto de dos issues abiertas en undici sobre sesiones HTTP/2 que no se recuperan (#6073 y #6106, ambas de octubre de 2026); lo muestro porque es un tipo de falla que el mismo código no tenía en el 24.
La salida documentada para volver a HTTP/1.1 es instalar el paquete undici y cambiar el dispatcher global, como describe la página de globals de Node. Con estas líneas al principio del mismo script, las dos peticiones después del rechazo volvieron a responder:
+// Requiere el paquete undici en la versión que trae Node: npm install undici@8.12.2
+import { Agent, setGlobalDispatcher } from 'undici';
import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';
+setGlobalDispatcher(new Agent({ allowH2: false }));
$ node fetch-h2-off.mjs # Node 26.13.0
v26.13.0 {"upgrade":"websocket"} UND_ERR_INVALID_ARG 100 ms
...
v26.13.0 {} 200 httpVersion=1.1
v26.13.0 {} 200 httpVersion=1.1
Yo no apagaría HTTP/2 por reflejo. Pero en un servicio que habla con APIs de terceros por fetch, es el cambio del 26 que más vigilaría después del deploy, y lo primero que probaría si aparece un timeout nuevo.
Un escaneo para lo que el 24 no avisa
Para los puntos de la tabla que Node 24 no señala, escribí un script que busca los patrones en el proyecto y en node_modules y dice en qué paquete y versión está cada coincidencia. No tiene dependencias y corre en cualquier Node desde el 18:
#!/usr/bin/env node
// node26-scan.mjs: busca en el proyecto (código y node_modules) lo que Node 25 y 26 eliminaron.
// Uso: node node26-scan.mjs [carpeta-del-proyecto] (sin dependencias; corre en Node 18 o más nuevo)
import { readdirSync, readFileSync, statSync } from 'node:fs';
import { join, relative, sep, basename } from 'node:path';
const root = process.argv[2] ?? process.cwd();
// Cada regla: el patrón, el código DEP de la documentación de Node y lo que pasa en el 26.
const RULES = [
{ id: 'DEP0193', what: "require/import of 'node:_stream_*' (removed in 26)",
re: /(?:require\s*\(\s*|from\s+|import\s*\(\s*)['"](?:node:)?_stream_(?:readable|writable|duplex|transform|passthrough|wrap)['"]/ },
{ id: 'DEP0063', what: 'response.writeHeader() (removed in 26, use writeHead)',
re: /\.writeHeader\s*\(/ },
{ id: 'flag', what: '--experimental-transform-types (flag removed in 26)',
re: /--experimental-transform-types/ },
// Solo acceso al SlowBuffer de Node; los polyfills de navegador que definen el suyo quedan fuera.
{ id: 'DEP0030', what: 'SlowBuffer (removed in 25)',
re: /(?:require\(\s*['"](?:node:)?buffer['"]\s*\)|\bbuffer)\.SlowBuffer\b(?!\s*=[^=])|\bSlowBuffer\.prototype\b|new\s+SlowBuffer\s*\(|\{[^}]*\bSlowBuffer\b[^}]*\}\s*(?:=\s*require\(|from)\s*['"](?:node:)?buffer['"]/ },
{ id: 'DEP0176', what: 'fs.F_OK/R_OK/W_OK/X_OK (removed in 25, use fs.constants)',
re: /\bfs\.(?:F_OK|R_OK|W_OK|X_OK)\b/ },
{ id: 'DEP0147', what: 'fs.rmdir with { recursive } (removed in 25, use fs.rm)',
re: /\brmdir(?:Sync)?\s*\([^)]*recursive/ },
{ id: 'DEP0173', what: 'assert.CallTracker (removed in 25)',
re: /\bCallTracker\b/ },
{ id: 'DEP0160', what: "process.on('multipleResolves') (removed in 25)",
re: /['"]multipleResolves['"]/ },
{ id: 'DEP0205', what: 'module.register() (runtime warning in 26, use registerHooks)',
re: /\bmodule\.register\s*\(\s*[^)\s]|\{\s*register\s*\}\s*(?:=\s*require\(|from\s+)\s*['"](?:node:)?module['"]/ },
{ id: 'corepack', what: 'corepack (no longer bundled with Node since 25)',
re: /\bcorepack\s+(?:enable|prepare|use|install)\b/ },
];
const CODE = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
const DECLARATION = /\.d\.[cm]?ts$/;
const CONFIG = /^(?:package\.json|Dockerfile.*|.*\.ya?ml|.*\.sh|\.npmrc)$/;
const SKIP_DIRS = new Set(['.git', 'coverage', '.cache', '.turbo', '.next']);
// Los tests de los paquetes instalados no corren en tu app; los tests de tu proyecto, sí.
const PACKAGE_TESTS = /node_modules.*[\\/](?:tests?|__tests__)[\\/]|node_modules.*[\\/](?:tests?|[^\\/]+\.(?:test|spec))\.[cm]?js$/;
// Para cada archivo en node_modules, devuelve "paquete@versión"; fuera de él, "(project)".
const versions = new Map();
function packageOf(file) {
const parts = relative(root, file).split(sep);
const i = parts.lastIndexOf('node_modules');
if (i < 0) return '(project)';
const nameParts = parts[i + 1]?.startsWith('@') ? parts.slice(i + 1, i + 3) : parts.slice(i + 1, i + 2);
const dir = join(root, ...parts.slice(0, i + 1), ...nameParts);
if (!versions.has(dir)) {
let version = '?';
try { version = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')).version; } catch {}
versions.set(dir, `${nameParts.join('/')}@${version}`);
}
return versions.get(dir);
}
const findings = [];
let scanned = 0;
function walk(dir) {
let entries;
try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
for (const entry of entries) {
const full = join(dir, entry.name);
if (entry.isSymbolicLink()) continue;
if (entry.isDirectory()) {
// @types/node solo tiene declaraciones: SlowBuffer aparece ahí sin que se use.
if (!SKIP_DIRS.has(entry.name) && !(entry.name === 'node' && basename(dir) === '@types')) walk(full);
continue;
}
const isCode = CODE.test(entry.name) && !DECLARATION.test(entry.name);
if (!isCode && !CONFIG.test(entry.name)) continue;
if (PACKAGE_TESTS.test(full)) continue;
if (statSync(full).size > 5_000_000) continue;
scanned++;
readFileSync(full, 'utf8').split('\n').forEach((line, n) => {
for (const rule of RULES) {
const m = rule.re.exec(line);
if (!m) continue;
const start = Math.max(0, m.index - 40);
findings.push({ rule, pkg: packageOf(full), where: `${relative(root, full)}:${n + 1}`,
snippet: line.slice(start, m.index + m[0].length + 40).trim() });
}
});
}
}
walk(root);
console.log(`${scanned} files read in ${root}`);
if (!findings.length) console.log('Nothing found.');
for (const rule of RULES) {
const hits = findings.filter((f) => f.rule === rule);
if (!hits.length) continue;
console.log(`\n[${rule.id}] ${rule.what}: ${hits.length} hit(s)`);
for (const h of hits) console.log(` ${h.pkg} ${h.where}\n ${h.snippet}`);
}
En vertex-api, la salida completa fue esta:
$ node node26-scan.mjs vertex-api
21143 files read in vertex-api
[flag] --experimental-transform-types (flag removed in 26): 2 hit(s)
synckit@0.11.13 node_modules\synckit\lib\constants.js:23
export const TRANSFORM_TYPES_FLAG = '--experimental-transform-types';
synckit@0.11.13 node_modules\synckit\lib\index.cjs:72
const TRANSFORM_TYPES_FLAG = "--experimental-transform-types";
[DEP0030] SlowBuffer (removed in 25): 6 hit(s)
buffer-equal-constant-time@1.0.1 node_modules\buffer-equal-constant-time\index.js:4
var SlowBuffer = require('buffer').SlowBuffer;
buffer-equal-constant-time@1.0.1 node_modules\buffer-equal-constant-time\index.js:31
Buffer.prototype.equal = SlowBuffer.prototype.equal = function equal(that) {
buffer-equal-constant-time@1.0.1 node_modules\buffer-equal-constant-time\index.js:37
var origSlowBufEqual = SlowBuffer.prototype.equal;
buffer-equal-constant-time@1.0.1 node_modules\buffer-equal-constant-time\index.js:40
SlowBuffer.prototype.equal = origSlowBufEqual;
safe-buffer@5.2.1 node_modules\safe-buffer\index.js:64
return buffer.SlowBuffer(size)
safer-buffer@2.1.2 node_modules\safer-buffer\dangerous.js:54
return buffer.SlowBuffer(size)
[DEP0147] fs.rmdir with { recursive } (removed in 25, use fs.rm): 3 hit(s)
drizzle-kit@0.31.11 node_modules\drizzle-kit\bin.cjs:14350
rue, force: true }) : await j3.promises.rmdir(this.oldCacheDirectory, { recursive: true }));
tsx@4.23.0 node_modules\tsx\dist\index-D9F1FXzN.cjs:13
ecursive:!0,force:!0}):await j.promises.rmdir(this.oldCacheDirectory,{recursive:!0}))}catch{}}}var z=process.env.TSX_DI
tsx@4.23.0 node_modules\tsx\dist\index-XurvG3JN.mjs:13
ecursive:!0,force:!0}):await j.promises.rmdir(this.oldCacheDirectory,{recursive:!0}))}catch{}}}var q=process.env.TSX_DI
Once coincidencias, y ninguna rompe vertex-api en el 26. Leer cada una tomó pocos minutos:
synckitsolo usa el flag por debajo de Node 23.6; en el 26 el código sale delswitchantes de llegar a él.- En
drizzle-kity entsx, elrmdirconrecursiveestá en la rama de respaldo de unfs.rm ? ... : ..., que solo corre en un Node sinfs.rm. safe-buffer5.2.1 exporta elbuffernativo cuando este tieneallocUnsafeSlow, así que la función que llama aSlowBuffernunca se usa. Ningún paquete del árbol importasafer-buffer/dangerous.js.buffer-equal-constant-timees el paquete de la sección anterior. Se rompe si se carga, y eljwa2.0.1 de este proyecto no lo carga.
En pyxis-api, el escaneo encontró las mismas familias, sin buffer-equal-constant-time, y además un import { register } from "node:module" en jiti 2.6.1, que llega por ESLint y commitlint. Está en el archivo que solo corre con --import jiti/register, y nada en el proyecto usa eso.
El escaneo por sí solo no distingue lo que se carga de lo que solo está instalado. Para eso, el segundo script importa cada dependencia de producción del package.json en el Node con el que corre:
// load-deps.mjs: importa cada dependencia de producción del package.json en el Node actual.
// Guárdalo en la raíz del proyecto y córrelo con el Node nuevo: node load-deps.mjs
// Atrapa lo que se rompe al cargar el módulo, no lo que solo se rompe al llamar una función.
import { readFileSync } from 'node:fs';
const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
let failed = 0;
for (const name of Object.keys(pkg.dependencies ?? {})) {
try {
await import(name);
console.log(`ok ${name}`);
} catch (err) {
failed++;
console.log(`FAIL ${name}: ${err.code ?? err.name}: ${err.message.split('\n')[0]}`);
}
}
console.log(`${process.version}: ${failed} failed`);
process.exitCode = failed ? 1 : 0;
En el directorio con el jwa viejo, atrapa el problema en el 26 y no en el 24:
$ node load-deps.mjs # Node 24.19.0
ok jsonwebtoken
v24.19.0: 0 failed
$ node load-deps.mjs # Node 26.13.0
FAIL jsonwebtoken: TypeError: Cannot read properties of undefined (reading 'prototype')
v26.13.0: 1 failed
En vertex-api y pyxis-api, con el 26, todas las dependencias de producción cargaron (0 failed).
Lo que dijeron los dos proyectos
Corrí todo en los dos Nodes, con las bases de los tests de integración y de extremo a extremo en un Postgres desechable en Docker. Las suites con Jest corrieron con NODE_OPTIONS="--trace-deprecation --pending-deprecation":
| vertex-api (NestJS 11, Fastify) | pyxis-api (NestJS 12, Fastify) | |
|---|---|---|
| Unitarios | 248 de 248, en los dos | 2600 de 2600, en los dos |
| Integración con Postgres | (no tiene) | 373 de 373, en los dos |
| Extremo a extremo con Postgres | 65 de 65, en los dos | 228 de 228, en los dos |
| Lint y build | ok en los dos | ok en los dos, más typecheck y 33 tests de node --test |
| App arrancando con los dos flags de deprecación | 0 avisos | 0 avisos |
load-deps.mjs en el 26 | 0 fallas | 0 fallas |
El único addon nativo de los dos, el argon2 0.44.0 de vertex-api, cargó y generó un hash en el 26 sin recompilar. NODE_MODULE_VERSION pasó de 137 a 147, pero los binarios que trae el paquete son N-API, que no dependen de él. Un addon compilado contra la ABI de Node, sin N-API, necesitaría npm rebuild o una versión nueva.
Los engines tampoco frenan a nadie: @nestjs/core 11 y 12 piden >= 20, postgres pide >=12, Jest 30 acepta >=24.0.0, y drizzle-orm y fastify no declaran nada.
Tiempo y memoria
Medí con la máquina sin otros tests corriendo (CPU entre 6% y 20% antes de empezar), alternando 24 y 26 en cada ejecución. Las suites corrieron 5 veces cada una, después de una ronda de calentamiento descartada. El arranque es el tiempo entre crear el proceso y el primer 200 en /health, en 7 ejecuciones por Node. La memoria se leyó dentro del proceso (process.memoryUsage()) un segundo después de estar listo y de nuevo después de 500 peticiones a /health. Los números son medianas, con mínimo y máximo entre paréntesis:
| Node 24.19.0 | Node 26.13.0 | Diferencia | |
|---|---|---|---|
| vertex-api, unitarios | 3,60 s (3,57–4,76) | 3,27 s (3,19–3,52) | −9% |
| vertex-api, extremo a extremo | 4,63 s (4,58–4,99) | 4,03 s (3,97–4,15) | −13% |
| pyxis-api, unitarios | 19,8 s (19,7–21,9) | 18,3 s (18,1–18,6) | −7% |
vertex-api, hasta responder /health | 703 ms (694–764) | 575 ms (569–594) | −18% |
pyxis-api, hasta responder /health | 1112 ms (1097–1247) | 925 ms (917–1072) | −17% |
| vertex-api, RSS en reposo | 137 MiB (137–139) | 132 MiB (117–133) | −4% |
| pyxis-api, RSS en reposo | 241 MiB (214–242) | 182 MiB (180–184) | −24% |
| vertex-api, heap usado después de 500 peticiones | 55,5 MiB (55,3–57,8) | 62,5 MiB (58,4–62,6) | +13% |
| pyxis-api, heap usado después de 500 peticiones | 81,9 MiB (70,0–98,3) | 76,4 MiB (55,4–82,2) | −7% |
El 26 fue más rápido en todas las medianas de tiempo, y los rangos de mínimo y máximo de las dos versiones no se cruzan en ninguna fila de tiempo. En memoria, el RSS bajó en los dos proyectos, pero el heap después de las peticiones subió en uno y bajó en el otro. Con esa dispersión, yo no sacaría conclusiones sobre el heap. Esto es una laptop con Windows (i9-13900H) y un proceso de vida larga, no un cold start en Lambda, que tiene CPU y disco de otro tamaño. La ganancia en el arranque es el número que más quería medir en el runtime administrado, y todavía no pude.
En Lambda, el 26 todavía es preview
Las dos APIs corren en Lambda como imagen de contenedor, y las dos imágenes parten de public.ecr.aws/lambda/nodejs:24. Aquí es donde la fecha LTS de Node y la fecha de producción se separan.
AWS anunció nodejs26.x en preview pública en agosto de 2026 (anuncio y post en el blog de Compute), tanto como runtime administrado como imagen base con la etiqueta 26-preview. La página de runtimes dice con todas las letras que la preview no tiene SLA ni soporte y no debe usarse en producción, e indica noviembre de 2026 como mes objetivo del lanzamiento, con la aclaración de que la fecha es indicativa. El post de AWS ata el lanzamiento a que Node 26 llegue a Active LTS, lo que ocurrió el 28 de octubre, y apunta a un plazo de hasta dos meses después.
Hay un detalle de Lambda que una guía genérica de actualización no cubre. El runtime de Lambda apaga funciones experimentales de Node con flags propios: en 20, 22 y 24 pasa --no-experimental-require-module, y quien quiera require() de ES modules tiene que reactivarlo con NODE_OPTIONS=--experimental-require-module. El Dockerfile.lambda de pyxis-api hace exactamente eso. La tabla de la documentación todavía no incluye el 26, y en la issue de feedback de la preview (aws-lambda-nodejs-runtime-interface-client#198) hay reportes de usuarios de que require(esm) sigue apagado y de que Temporal no aparece en nodejs26.x.
Lo comprobé en la imagen 26-preview publicada el 30 de octubre (26-preview.2026.10.30.17-x86_64), con una función que solo devuelve lo que ve, invocada por el emulador que viene dentro de la imagen:
// index.js: lo que el runtime nodejs26.x (preview) le muestra a una función
exports.handler = async () => {
let requireEsm;
try {
requireEsm = require('./esm-dep.mjs').kind;
} catch (err) {
requireEsm = `${err.code}: ${err.message.split('\n')[0]}`;
}
return {
version: process.version,
temporal: typeof Temporal,
requireModuleFeature: process.features.require_module,
execArgv: process.execArgv,
nodeOptions: process.env.NODE_OPTIONS ?? null,
requireEsm,
};
};
== NODE_OPTIONS=''
{"version":"v26.13.0","temporal":"undefined","requireModuleFeature":false,
"execArgv":["--expose-gc","--max-http-header-size","81920","--no-experimental-detect-module",
"--no-experimental-require-module","--no-experimental-ffi","--max-semi-space-size=50","--max-old-space-size=2708"],
"nodeOptions":null,
"requireEsm":"ERR_REQUIRE_ESM: require() of ES Module /var/task/esm-dep.mjs from /var/task/index.js not supported."}
== NODE_OPTIONS=--experimental-require-module
{"version":"v26.13.0","temporal":"undefined","requireModuleFeature":true, ... "requireEsm":"esm"}
esm-dep.mjs es una línea, export const kind = 'esm';, y la salida se partió en líneas aquí para que quepa. Los dos reportes se confirman, por motivos distintos. require(esm) está apagado por el flag que pasa el runtime, y el mismo NODE_OPTIONS de antes lo reactiva. Temporal no vuelve con ningún flag: corriendo el node de la imagen directamente, fuera del runtime, typeof Temporal también da "undefined", y el process.config de ese binario trae v8_enable_temporal_support: 0, mientras que el zip oficial de la 26.13.0 trae 1. El Node de Lambda se compiló sin Temporal. Eso vale para la imagen de preview de esa fecha; el runtime puede cambiar antes del lanzamiento. Si piensas cambiar date-fns o Luxon por Temporal junto con la actualización, en Lambda ese cambio todavía tiene que esperar.
La hoja de ruta, en tu proyecto
Es lo que corrí, en orden. Los comandos son para bash (en Windows, Git Bash).
-
En tu Node 24 de siempre, mira lo que ya señala:
NODE_OPTIONS="--trace-deprecation --pending-deprecation" npm test npm run build && node --trace-deprecation --pending-deprecation dist/main.js -
Busca lo que no señala, y revisa
jwa:node node26-scan.mjs . npm ls jwa -
Pon un Node 26 al lado del instalado, sin cambiar el del sistema. Yo usé el zip oficial y verifiqué el SHA-256:
curl -O https://nodejs.org/dist/v26.13.0/SHASUMS256.txt curl -O https://nodejs.org/dist/v26.13.0/node-v26.13.0-win-x64.zip grep " node-v26.13.0-win-x64.zip$" SHASUMS256.txt | sha256sum -c - unzip -q node-v26.13.0-win-x64.zip export PATH="$PWD/node-v26.13.0-win-x64:$PATH" node -v # v26.13.0En Linux, el archivo es
node-v26.13.0-linux-x64.tar.xzy el binario queda enbin/; no corrí esa variante. -
Con el 26 en el
PATH, en la raíz del proyecto:node load-deps.mjs npm test npm run build && node --trace-deprecation --pending-deprecation dist/main.js -
Busca en tu código
read()sin argumento en streams de bytes,for awaitytoArray()que tratan cada trozo como una unidad, y cabeceras reenviadas afetch. Ningún script encuentra eso por ti. -
Cambia la versión en todos los lugares donde vive. En vertex-api son 5
node-version: 24en 4 workflows, 4FROM node:24-alpineen elDockerfiley 4FROM public.ecr.aws/lambda/nodejs:24en elDockerfile.lambda, además de@types/node. En pyxis-api son el.nvmrc(que leen 9 pasos de los workflows),engines, las imágenes fijadas por digest en los dos Dockerfiles y en el workflow que las replica, y@types/node. -
Decide el destino del deploy antes de cambiar la imagen: en Lambda,
nodejs:26-previewsirve para pruebas, no para producción.
El calendario que marca la prisa
Node 24 entró en mantenimiento el 20 de octubre de 2026 y llega al fin de vida el 30 de abril de 2028, según el schedule.json del proyecto. El 26 pasó a LTS ("Lithium") el 28 de octubre de 2026 y dura hasta fines de abril de 2029. No hay motivo de calendario para dejar el 24 este mes; el plazo que importa es abril de 2028.
El 26 es también la última versión del modelo viejo. A partir del 27, como el proyecto anunció en marzo, sale una versión major por año, en abril, que pasa a LTS en octubre. Toda versión pasa a LTS, y el papel de las versiones impares lo asume un canal alpha que empieza en octubre de 2026. Para quien solo usa LTS, según el propio anuncio, poco cambia más allá de la numeración.
Los dos Dockerfile.lambda siguen en nodejs:24 hasta que nodejs26.x salga de la preview. Lo que todavía falta medir es lo que esta prueba local no alcanza: cold start y memoria en el runtime administrado, y cómo se comportan las sesiones HTTP/2 de fetch en un proceso que Lambda congela entre una invocación y otra.
Comentarios
Cargando comentarios...