@naturalcycles/nodejs-lib 15.125.2 → 15.125.3

package/dist/stream/pipeline.d.ts

@@ -116,4 +116,5 @@ export declare class Pipeline<T = unknown> {
     forEach(fn: AbortableAsyncMapper<T, void>, opt?: TransformMapOptions<T, void> & TransformLogProgressOptions<T>): Promise<void>;
     forEachSync(fn: AbortableMapper<T, void>, opt?: TransformMapSyncOptions<T, void> & TransformLogProgressOptions<T>): Promise<void>;
     run(): Promise<void>;
+    private isGracefullyAborted;
 }

package/dist/stream/pipeline.js

@@ -347,11 +347,18 @@ export class Pipeline {
             });
         }
         catch (err) {
-            if (err instanceof Error && err.cause?.message === PIPELINE_GRACEFUL_ABORT) {
+            // The abort reason is checked on the signal rather than on `err.cause`: when the source has
+            // already emitted `end` by the time the abort lands (small `Readable.from` sources), node's
+            // pipeline reports ERR_STREAM_PREMATURE_CLOSE without a cause instead of the AbortError.
+            if (this.isGracefullyAborted()) {
                 console.log('pipeline gracefully aborted'); // todo: this message may be removed later
                 return;
             }
             throw err;
         }
     }
+    isGracefullyAborted() {
+        const { aborted, reason } = this.abortableSignal;
+        return aborted && reason instanceof Error && reason.message === PIPELINE_GRACEFUL_ABORT;
+    }
 }

package/dist/stream/transform/transformMap.js

@@ -31,6 +31,7 @@ export function transformMap(mapper, opt = {}) {
     let inFlight = 0;
     let blockedCallback = null;
     let flushBlocked = null;
+    let destroyBlocked = null;
     // Warmup - cached concurrency to reduce Date.now() syscalls
     let warmupComplete = warmupSeconds <= 0 || maxConcurrency <= 1;
     let concurrency = warmupComplete ? maxConcurrency : 1;
@@ -117,7 +118,20 @@ export function transformMap(mapper, opt = {}) {
                 if (inFlight === 0 && flushBlocked) {
                     flushBlocked.resolve();
                 }
+                // Let a pending destroy complete once nothing is in flight any more
+                if (inFlight === 0 && destroyBlocked) {
+                    destroyBlocked.resolve();
+                }
+            }
+        },
+        async destroy(err, cb) {
+            // An upstream abort (e.g. `limit` or END) destroys this stream while mappers are still running.
+            // The close is held until they settle, so that the pipeline resolves only once their side effects are done.
+            if (inFlight > 0) {
+                destroyBlocked = pDefer();
+                await destroyBlocked;
             }
+            cb(err);
         },
         async flush(cb) {
             // Wait for all in-flight operations to complete

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.125.2",
+  "version": "15.125.3",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@standard-schema/spec": "^1",
@@ -14,7 +14,7 @@
     "yaml": "^2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "0.0.0",
+    "@naturalcycles/dev-lib": "20.65.1",
     "typescript": "^7"
   },
   "exports": {

package/src/stream/pipeline.ts

@@ -466,11 +466,19 @@ export class Pipeline<T = unknown> {
         signal: this.abortableSignal,
       })
     } catch (err) {
-      if (err instanceof Error && (err.cause as any)?.message === PIPELINE_GRACEFUL_ABORT) {
+      // The abort reason is checked on the signal rather than on `err.cause`: when the source has
+      // already emitted `end` by the time the abort lands (small `Readable.from` sources), node's
+      // pipeline reports ERR_STREAM_PREMATURE_CLOSE without a cause instead of the AbortError.
+      if (this.isGracefullyAborted()) {
         console.log('pipeline gracefully aborted') // todo: this message may be removed later
         return
       }
       throw err
     }
   }
+
+  private isGracefullyAborted(): boolean {
+    const { aborted, reason } = this.abortableSignal
+    return aborted && reason instanceof Error && reason.message === PIPELINE_GRACEFUL_ABORT
+  }
 }

package/src/stream/transform/transformMap.ts

@@ -127,6 +127,7 @@ export function transformMap<IN = any, OUT = IN>(
   let inFlight = 0
   let blockedCallback: (() => void) | null = null
   let flushBlocked: DeferredPromise | null = null
+  let destroyBlocked: DeferredPromise | null = null
 
   // Warmup - cached concurrency to reduce Date.now() syscalls
   let warmupComplete = warmupSeconds <= 0 || maxConcurrency <= 1
@@ -220,7 +221,22 @@ export function transformMap<IN = any, OUT = IN>(
         if (inFlight === 0 && flushBlocked) {
           flushBlocked.resolve()
         }
+
+        // Let a pending destroy complete once nothing is in flight any more
+        if (inFlight === 0 && destroyBlocked) {
+          destroyBlocked.resolve()
+        }
+      }
+    },
+    async destroy(err, cb) {
+      // An upstream abort (e.g. `limit` or END) destroys this stream while mappers are still running.
+      // The close is held until they settle, so that the pipeline resolves only once their side effects are done.
+      if (inFlight > 0) {
+        destroyBlocked = pDefer()
+        await destroyBlocked
       }
+
+      cb(err)
     },
     async flush(cb) {
       // Wait for all in-flight operations to complete