@shutterstock/p-map-iterable 1.1.2 → 1.2.0

package/README.md

@@ -4,9 +4,11 @@
 
 `@shutterstock/p-map-iterable` provides several classes that allow processing results of `p-map`-style mapper functions by iterating the results as they are completed, with backpressure to limit the number of items that are processed ahead of the consumer.
 
+Use these classes for concurrent metadata lookups, capability probes, background status checks, or read/write pipelines. The [optional aliases](#optional-names-for-concurrent-work) `ConcurrentMapper`, `MappingQueue`, and `WorkerQueue` describe the input and result contracts without tying the work to a particular I/O operation.
+
 A common use case for `@shutterstock/p-map-iterable` is as a "prefetcher" that will fetch, for example, AWS S3 files in an AWS Lambda function. By prefetching large files the consumer is able to use 100% of the paid-for Lambda CPU time for the JS thread, rather than waiting idle while the next file is fetched. The backpressure (set by `maxUnread`) prevents the prefetcher from consuming unlimited memory or disk space by racing ahead of the consumer.
 
-These classes will typically be helpful in batch or queue consumers, not as much in request/response services.
+The caller supplies the operation to run for each input. Concurrency overlaps asynchronous work in the current JavaScript process; synchronous CPU work still uses the JavaScript event loop.
 
 # Example Usage Scenarios
 
@@ -25,14 +27,14 @@ for (const sourceId of sourceIds) {
 
 Each iteration takes 820ms total, but we waste time waiting for I/O. We could prefetch the next read (300ms) while processing (20ms) and writing (500ms), without changing the order of reads or writes.
 
-## Using `IterableMapper` as Prefetcher with Blocking Sequential Writes
+## Prefetching with `IterableMapper` and Blocking Sequential Writes
 
-`concurrency: 1` on the prefetcher preserves the order of the reads and and writes are sequential and blocking (unchanged).
+`concurrency: 1` on the prefetcher preserves the order of the reads, and writes remain sequential and blocking.
 
 ```typescript
 const source = new SomeSource();
 const sourceIds = [1, 2,... 1000];
-// Pre-reads up to 8 items serially and releases in sequential order
+// Prefetches serially within maxUnread and releases results in sequential order
 const sourcePrefetcher = new IterableMapper(sourceIds,
   async (sourceId) => source.read(sourceId),
   { concurrency: 1, maxUnread: 10 }
@@ -46,7 +48,7 @@ for await (const item of sourcePrefetcher) {    // may not block for fast source
 
 This reduces iteration time to 520ms by overlapping reads with processing/writing.
 
-## Using `IterableMapper` as Prefetcher with Background Sequential Writes with `IterableQueueMapperSimple`
+## Prefetching with `IterableMapper` and Background Sequential Writes with `IterableQueueMapperSimple`
 
 `concurrency: 1` on the prefetcher preserves the order of the reads.
 `concurrency: 1` on the flusher preserves the order of the writes, but allows the loop to iterate while last write is completing.
@@ -67,7 +69,7 @@ for await (const item of sourcePrefetcher) {    // may not block for fast source
   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
   await flusher.enqueue(outputItem);            // will periodically block for portion of write time
 }
-// Wait for all writes to complete
+// Close input permanently after the last enqueue and wait for all writes
 await flusher.onIdle();
 // Check for errors
 if (flusher.errors.length > 0) {
@@ -80,7 +82,7 @@ by overlapping reads and writes with the CPU processing step.
 In this contrived example, the loop time is reduced to 500ms - 20ms = 480ms.
 In cases where the CPU usage time is higher, the impact can be greater.
 
-## Using `IterableMapper` as Prefetcher with Out of Order Reads and Background Out of Order Writes with `IterableQueueMapperSimple`
+## Prefetching with `IterableMapper` and Out of Order Background Writes with `IterableQueueMapperSimple`
 
 For maximum throughput, allow out of order reads and writes with
 `IterableQueueMapper` (to iterate results with backpressure when too many unread items) or
@@ -102,7 +104,7 @@ for await (const item of sourcePrefetcher) {    // typically will not block
   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
   await flusher.enqueue(outputItem);            // typically will not block
 }
-// Wait for all writes to complete
+// Close input permanently after the last enqueue and wait for all writes
 await flusher.onIdle();
 // Check for errors
 if (flusher.errors.length > 0) {
@@ -152,6 +154,7 @@ These diagrams illustrate the differences in operation betweeen `p-map`, `p-queu
 # Features
 
 - [IterableMapper](https://tech.shutterstock.com/p-map-iterable/classes/IterableMapper.html)
+  - Also exported as `ConcurrentMapper`
   - Interface and concept based on: [p-map](https://github.com/sindresorhus/p-map)
   - Allows a sync or async iterable input
   - User supplied sync or async mapper function
@@ -159,13 +162,15 @@ These diagrams illustrate the differences in operation betweeen `p-map`, `p-queu
   - Allows a maximum queue depth of mapped items - if the consumer stops consuming, the queue will fill up, at which point the mapper will stop being invoked until an item is consumed from the queue
   - This allows mapping with backpressure so that the mapper does not consume unlimited resources (e.g. memory, disk, network, event loop time) by racing ahead of the consumer
 - [IterableQueueMapper](https://tech.shutterstock.com/p-map-iterable/classes/IterableQueueMapper.html)
+  - Also exported as `MappingQueue`
   - Wraps `IterableMapper`
   - Adds items to the queue via the `enqueue` method
 - [IterableQueueMapperSimple](https://tech.shutterstock.com/p-map-iterable/classes/IterableQueueMapperSimple.html)
+  - Also exported as `WorkerQueue`
   - Wraps `IterableQueueMapper`
   - Discards results as they become available
   - Exposes any accumulated errors through the `errors` property instead of throwing an `AggregateError`
-  - Not actually `Iterable` - May rename this before 1.0.0
+  - Consumes results internally and exposes no result iterator
 
 ## Lower Level Utilities
 - [IterableQueue](https://tech.shutterstock.com/p-map-iterable/classes/IterableQueue.html)
@@ -184,30 +189,87 @@ See [p-map](https://github.com/sindresorhus/p-map) docs for a good start in unde
 
 The key difference between `IterableMapper` and `pMap` are that `IterableMapper` does not return when the entire mapping is done, rather it exposes an iterable that the caller loops through. This enables results to be processed while the mapping is still happening, while optionally allowing for backpressure to slow or stop the mapping if the caller is not consuming items fast enough. Common use cases include `prefetching` items from a remote service - the next set of requests are dispatched asyncronously while the current responses are processed and the prefetch requests will pause when the unread queue fills up.
 
+`ConcurrentMapper` is an alias for this class. It also fits general mapping work such as enriching project metadata or probing a list of services. Consume results with `for await`; with `concurrency` greater than one, results can arrive out of input order.
+
 See [examples/iterable-mapper.ts](./examples/iterable-mapper.ts) for an example.
 
-Run the example with `npm run example:iterable-mapper`
+Run the example with `pnpm run example:iterable-mapper`
 
 # `IterableQueueMapper`
 
 `IterableQueueMapper` is similar to `IterableMapper` but instead of taking an iterable input it instead adds data via the `enqueue` method which will block if `maxUnread` will be reached by the current number of `mapper`'s running in parallel.
 
+`MappingQueue` is an alias for this class. Produce inputs and consume mapped results concurrently so the result buffer can drain. After the last awaited enqueue, call `done()` and finish consuming the iterator; `done()` closes input and does not wait for work to complete.
+
 See [examples/iterable-queue-mapper.ts](./examples/iterable-queue-mapper.ts) for an example.
 
-Run the example with `npm run example:iterable-queue-mapper`
+Run the example with `pnpm run example:iterable-queue-mapper`
 
 # `IterableQueueMapperSimple`
 
 `IterableQueueMapperSimple` is similar to `IterableQueueMapper` but instead exposing the results as an iterable it discards the results as soon as they are ready and exposes any errors through the `errors` property.
 
+`WorkerQueue` is an alias for this class. Supply one worker callback to process every enqueued input, such as a background Git status check. Await each enqueue for producer backpressure. After the last enqueue, await `onIdle()` to permanently close input and finish the accepted work, then inspect `errors`. An enqueue resolves when the input is accepted, rather than when its work completes.
+
 See [examples/iterable-queue-mapper-simple.ts](./examples/iterable-queue-mapper-simple.ts) for an example.
 
-Run the example with `npm run example:iterable-queue-mapper-simple`
+Run the example with `pnpm run example:iterable-queue-mapper-simple`
+
+## Optional names for concurrent work
+
+The package exports three optional class aliases. Choose the name that makes the input and result contracts clearest in your application:
+
+| Alias | Original class | Input | Results and completion |
+| --- | --- | --- | --- |
+| `ConcurrentMapper` | `IterableMapper` | Sync or async iterable | Consume mapped results with `for await`. Mapping pauses when the unread result buffer fills. |
+| `MappingQueue` | `IterableQueueMapper` | Awaited `enqueue(item)` calls | Consume results concurrently with production. Call `done()` after the last enqueue, then finish consuming the iterator. |
+| `WorkerQueue` | `IterableQueueMapperSimple` | Awaited `enqueue(item)` calls | Results are consumed internally. After the last enqueue, await `onIdle()` and check `errors`. |
+
+```typescript
+import {
+  ConcurrentMapper,
+  MappingQueue,
+  WorkerQueue,
+} from '@shutterstock/p-map-iterable';
+```
+
+The aliases are the original classes, with the same constructor identity, generic instance types, and subclassing behavior. Existing imports continue to work. Defaults, result ordering, backpressure, and error handling are identical through either name.
+
+Matching option types are available from the package root using `import type`:
+
+| Option alias | Original option type | Configuration |
+| --- | --- | --- |
+| `ConcurrentMapperOptions` | `IterableMapperOptions` | `concurrency`, `maxUnread`, `stopOnMapperError` |
+| `MappingQueueOptions` | `IterableQueueMapperOptions` | `concurrency`, `maxUnread`, `stopOnMapperError` |
+| `WorkerQueueOptions` | `IterableQueueMapperSimpleOptions` | `concurrency` |
+
+`MappingQueue` must have a result consumer even when you do not need the results. Awaiting every enqueue before starting iteration can block once the result buffer fills. Use `WorkerQueue` when results can be discarded. Its `onIdle()` permanently ends input; subsequent enqueues reject. Worker failures are collected in `errors` while other inputs continue to run, so check that property after shutdown.
+
+Each queue uses one fixed callback supplied at construction. Awaiting `enqueue()` provides producer backpressure and confirms acceptance of an input. Calling it without awaiting can accumulate pending inputs. For ongoing event-driven work, the application supplies any admission limits, cancellation, deduplication, or per-item completion handles. `WorkerQueue.onIdle()` is a final shutdown operation, so an application that needs reusable idle waits must manage that separately.
+
+See [examples/semantic-aliases.ts](./examples/semantic-aliases.ts) for metadata enrichment, queued capability probes with a concurrent result consumer, and background status checks with collected errors. Run it with `pnpm run example:semantic-aliases`.
 
 # Contributing - Setting up Build Environment
 
-- `nvm use`
-- `npm i`
-- `npm run build`
-- `npm run lint`
-- `npm run test`
+Use Node.js 24 and the pnpm version pinned in `package.json`:
+
+```sh
+nvm use
+corepack enable pnpm
+corepack prepare pnpm@12.7.0 --activate
+pnpm install --frozen-lockfile
+pnpm run build
+pnpm run build:docs
+pnpm run lint
+pnpm run test
+pnpm run example:semantic-aliases
+```
+
+Corepack enforces the pnpm version in `package.json`. pnpm's additional package
+manager switching is disabled to keep the single-document lockfile readable by
+GitHub's dependency graph and Dependabot. The pnpm configuration requires package
+releases to be at least seven days old.
+On macOS, `packageImportMethod: auto` prefers APFS copy-on-write clones from the
+shared pnpm store, so worktrees share package data until a file changes. Keep the
+store on the same APFS volume as the checkout. Other supported filesystems use
+pnpm's available import method.

package/dist/src/blocking-queue.js

@@ -36,10 +36,6 @@ class BlockingQueue {
         this._doneAdding = false;
         const { maxUnread = 8 } = options;
         this._options = { maxUnread };
-        // Avoid undefined errors on options
-        if (this._options.maxUnread === undefined) {
-            throw new TypeError('`maxUnread` must be set');
-        }
         // Validate maxUnread option
         if (!((Number.isSafeInteger(this._options.maxUnread) ||
             this._options.maxUnread === Number.POSITIVE_INFINITY) &&
@@ -77,14 +73,9 @@ class BlockingQueue {
         }
         // We always add to the internal queue, we just wait to return if the queue is full
         this._unreadQueue.enqueue(item);
-        if (this._readersWaiting.length > 0) {
-            // Release a reader if one is waiting for an item
-            // Remove the first waiting reader Promise from the queue
-            const reader = this._readersWaiting.dequeue();
-            if (reader === undefined) {
-                throw new TypeError('reader queue returned undefined');
-            }
-            // Resolve the Promise for a waiting reader
+        // Take the oldest reader if one is waiting; an empty queue returns undefined.
+        const reader = this._readersWaiting.dequeue();
+        if (reader !== undefined) {
             reader(undefined);
         }
         if (this._unreadQueue.length > this._options.maxUnread) {
@@ -115,14 +106,9 @@ class BlockingQueue {
             await this.waitForWrite();
             item = this._unreadQueue.dequeue();
         }
-        if (this._writersWaiting.length > 0) {
-            // Release a writer if one is waiting
-            // Remove the first waiting reader Promise from the queue
-            const writer = this._writersWaiting.dequeue();
-            if (writer === undefined) {
-                throw new TypeError('writer queue returned undefined');
-            }
-            // Resolve the Promise for a waiting writer
+        // Take the oldest writer if one is waiting; an empty queue returns undefined.
+        const writer = this._writersWaiting.dequeue();
+        if (writer !== undefined) {
             writer(undefined);
         }
         return item;

package/dist/src/blocking-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"blocking-queue.js","sourceRoot":"","sources":["../../src/blocking-queue.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"blocking-queue.js","sourceRoot":"","sources":["../../src/blocking-queue.ts"],"names":[],"mappings":"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"}

package/dist/src/index.d.ts

@@ -2,7 +2,8 @@ import { Mapper, IterableMapper, IterableMapperOptions } from './iterable-mapper
 import { BlockingQueue, BlockingQueueOptions } from './blocking-queue';
 import { IterableQueue, IterableQueueOptions } from './iterable-queue';
 import { IterableQueueMapper, IterableQueueMapperOptions } from './iterable-queue-mapper';
-import { IterableQueueMapperSimple } from './iterable-queue-mapper-simple';
+import { IterableQueueMapperSimple, IterableQueueMapperSimpleOptions } from './iterable-queue-mapper-simple';
 import { Queue } from './queue';
-export { Mapper, IterableMapper, IterableMapperOptions, IterableQueueMapper, IterableQueueMapperOptions, IterableQueueMapperSimple, BlockingQueue, BlockingQueueOptions, IterableQueue, IterableQueueOptions, Queue, };
+export { IterableMapper, IterableMapper as ConcurrentMapper, IterableQueueMapper, IterableQueueMapper as MappingQueue, IterableQueueMapperSimple, IterableQueueMapperSimple as WorkerQueue, BlockingQueue, IterableQueue, Queue, };
+export type { Mapper, IterableMapperOptions, IterableMapperOptions as ConcurrentMapperOptions, IterableQueueMapperOptions, IterableQueueMapperOptions as MappingQueueOptions, IterableQueueMapperSimpleOptions, IterableQueueMapperSimpleOptions as WorkerQueueOptions, BlockingQueueOptions, IterableQueueOptions, };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.IterableQueue = exports.BlockingQueue = exports.IterableQueueMapperSimple = exports.IterableQueueMapper = exports.IterableMapper = void 0;
+exports.Queue = exports.IterableQueue = exports.BlockingQueue = exports.WorkerQueue = exports.IterableQueueMapperSimple = exports.MappingQueue = exports.IterableQueueMapper = exports.ConcurrentMapper = exports.IterableMapper = void 0;
 const iterable_mapper_1 = require("./iterable-mapper");
 Object.defineProperty(exports, "IterableMapper", { enumerable: true, get: function () { return iterable_mapper_1.IterableMapper; } });
+Object.defineProperty(exports, "ConcurrentMapper", { enumerable: true, get: function () { return iterable_mapper_1.IterableMapper; } });
 const blocking_queue_1 = require("./blocking-queue");
 Object.defineProperty(exports, "BlockingQueue", { enumerable: true, get: function () { return blocking_queue_1.BlockingQueue; } });
 const iterable_queue_1 = require("./iterable-queue");
 Object.defineProperty(exports, "IterableQueue", { enumerable: true, get: function () { return iterable_queue_1.IterableQueue; } });
 const iterable_queue_mapper_1 = require("./iterable-queue-mapper");
 Object.defineProperty(exports, "IterableQueueMapper", { enumerable: true, get: function () { return iterable_queue_mapper_1.IterableQueueMapper; } });
+Object.defineProperty(exports, "MappingQueue", { enumerable: true, get: function () { return iterable_queue_mapper_1.IterableQueueMapper; } });
 const iterable_queue_mapper_simple_1 = require("./iterable-queue-mapper-simple");
 Object.defineProperty(exports, "IterableQueueMapperSimple", { enumerable: true, get: function () { return iterable_queue_mapper_simple_1.IterableQueueMapperSimple; } });
+Object.defineProperty(exports, "WorkerQueue", { enumerable: true, get: function () { return iterable_queue_mapper_simple_1.IterableQueueMapperSimple; } });
 const queue_1 = require("./queue");
 Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return queue_1.Queue; } });
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,uDAAkF;AAShF,+FATe,gCAAc,OASf;AARhB,qDAAuE;AAarE,8FAbO,8BAAa,OAaP;AAZf,qDAAuE;AAcrE,8FAdO,8BAAa,OAcP;AAbf,mEAA0F;AAQxF,oGARO,2CAAmB,OAQP;AAPrB,iFAA2E;AASzE,0GATO,wDAAyB,OASP;AAR3B,mCAAgC;AAa9B,sFAbO,aAAK,OAaP"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,uDAAkF;AAWhF,+FAXe,gCAAc,OAWf;AACI,iGAZH,gCAAc,OAYK;AAXpC,qDAAuE;AAgBrE,8FAhBO,8BAAa,OAgBP;AAff,qDAAuE;AAgBrE,8FAhBO,8BAAa,OAgBP;AAff,mEAA0F;AAUxF,oGAVO,2CAAmB,OAUP;AACI,6FAXhB,2CAAmB,OAWS;AAVrC,iFAGwC;AAQtC,0GAVA,wDAAyB,OAUA;AACI,4FAX7B,wDAAyB,OAWe;AAR1C,mCAAgC;AAW9B,sFAXO,aAAK,OAWP"}

package/dist/src/iterable-mapper.d.ts

@@ -1,5 +1,5 @@
 /**
- * Options for IterableMapper
+ * Options for `IterableMapper`, also exported as `ConcurrentMapperOptions`.
  */
 export interface IterableMapperOptions {
     /**
@@ -56,7 +56,7 @@ export interface IterableMapperOptions {
  * @template Element - Source element type
  * @template NewElement - Element type returned by the mapper
  * @param element - Iterated element
- * @param index - Index of the element in the source array
+ * @param index - Zero-based index of the input element
  */
 export type Mapper<Element = unknown, NewElement = unknown> = (element: Element, index: number) => NewElement | Promise<NewElement>;
 /**
@@ -65,9 +65,14 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  * `mapper` result in a queue of `maxUnread` size, before
  * being iterated / read by the caller.
  *
+ * Also exported as `ConcurrentMapper`, with the same constructor and instance types.
+ * Concurrency overlaps asynchronous callback work in the current JavaScript process.
+ * Results can arrive out of input order when `concurrency` is greater than one.
+ *
  * @remarks
  *
- * ### Typical Use Case
+ * ### Typical Use Cases
+ * - Enriching metadata or probing capabilities for a sync or async iterable of inputs
  * - Prefetching items from an async I/O source
  * - In the simple sequential (`concurrency: 1`) case, allows items to be prefetched async, preserving order, while caller processes an item
  * - Can allow parallel prefetches for sources that allow for out of order reads (`concurrency:  2+`)
@@ -88,7 +93,8 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *
  * ### Usage
  * - Items are exposed to the `mapper` via an iterator or async iterator (this includes generator and async generator functions)
- * - IMPORTANT: `mapper` method not be invoked when `maxUnread` is reached, until items are consumed
+ * - Consume results with `for await` while mapping proceeds
+ * - The `mapper` will not be invoked when `maxUnread` is reached, until items are consumed
  * - The iterable will set `done` when the `input` has indicated `done` and all `mapper` promises have resolved
  *
  * @example
@@ -112,14 +118,14 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Blocking Sequential Writes
+ * ### Prefetching with `IterableMapper` and Blocking Sequential Writes
  *
- * `concurrency: 1` on the prefetcher preserves the order of the reads and and writes are sequential and blocking (unchanged).
+ * `concurrency: 1` on the prefetcher preserves the order of the reads, and writes remain sequential and blocking.
  *
  * ```typescript
  * const source = new SomeSource();
  * const sourceIds = [1, 2,... 1000];
- * // Pre-reads up to 8 items serially and releases in sequential order
+ * // Prefetches serially within maxUnread and releases results in sequential order
  * const sourcePrefetcher = new IterableMapper(sourceIds,
  *   async (sourceId) => source.read(sourceId),
  *   { concurrency: 1, maxUnread: 10 }
@@ -135,7 +141,7 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Background Sequential Writes with `IterableQueueMapperSimple`
+ * ### Prefetching with `IterableMapper` and Background Sequential Writes with `IterableQueueMapperSimple`
  *
  * `concurrency: 1` on the prefetcher preserves the order of the reads.
  * `concurrency: 1` on the flusher preserves the order of the writes, but allows the loop to iterate while last write is completing.
@@ -156,7 +162,7 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
  *   await flusher.enqueue(outputItem);            // will periodically block for portion of write time
  * }
- * // Wait for all writes to complete
+ * // Close input permanently after the last enqueue and wait for all writes
  * await flusher.onIdle();
  * // Check for errors
  * if (flusher.errors.length > 0) {
@@ -171,7 +177,7 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Out of Order Reads and Background Out of Order Writes with `IterableQueueMapperSimple`
+ * ### Prefetching with `IterableMapper` and Out of Order Background Writes with `IterableQueueMapperSimple`
  *
  * For maximum throughput, allow out of order reads and writes with
  * `IterableQueueMapper` (to iterate results with backpressure when too many unread items) or
@@ -193,7 +199,7 @@ export type Mapper<Element = unknown, NewElement = unknown> = (element: Element,
  *   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
  *   await flusher.enqueue(outputItem);            // typically will not block
  * }
- * // Wait for all writes to complete
+ * // Close input permanently after the last enqueue and wait for all writes
  * await flusher.onIdle();
  * // Check for errors
  * if (flusher.errors.length > 0) {
@@ -227,7 +233,7 @@ export declare class IterableMapper<Element, NewElement> implements AsyncIterabl
      * @param mapper Function called for every item in `input`. Returns a `Promise` or value.
      * @param options IterableMapper options
      *
-     * @see {@link IterableQueueMapper} for full class documentation
+     * @see {@link IterableMapper} for full class documentation
      */
     constructor(input: AsyncIterable<Element> | Iterable<Element>, mapper: Mapper<Element, NewElement>, options?: IterableMapperOptions);
     [Symbol.asyncIterator](): AsyncIterator<NewElement>;
@@ -240,7 +246,6 @@ export declare class IterableMapper<Element, NewElement> implements AsyncIterabl
     next(): Promise<IteratorResult<NewElement>>;
     private bubbleUpErrors;
     private startARunnerIfNeeded;
-    private startAnotherRunner;
     private areWeDone;
     /**
      * Throw an exception if the wrapped NewElement is an Error

package/dist/src/iterable-mapper.js

@@ -1,11 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableMapper = void 0;
 //
 // 2021-08-25 - Initially based on: https://raw.githubusercontent.com/sindresorhus/p-map/main/index.js
 //
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const AggregateError = require('aggregate-error');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterableMapper = void 0;
+const aggregate_error_1 = __importDefault(require("aggregate-error"));
 const iterable_queue_1 = require("./iterable-queue");
 /**
  * Iterates over a source iterable / generator with specified `concurrency`,
@@ -13,9 +15,14 @@ const iterable_queue_1 = require("./iterable-queue");
  * `mapper` result in a queue of `maxUnread` size, before
  * being iterated / read by the caller.
  *
+ * Also exported as `ConcurrentMapper`, with the same constructor and instance types.
+ * Concurrency overlaps asynchronous callback work in the current JavaScript process.
+ * Results can arrive out of input order when `concurrency` is greater than one.
+ *
  * @remarks
  *
- * ### Typical Use Case
+ * ### Typical Use Cases
+ * - Enriching metadata or probing capabilities for a sync or async iterable of inputs
  * - Prefetching items from an async I/O source
  * - In the simple sequential (`concurrency: 1`) case, allows items to be prefetched async, preserving order, while caller processes an item
  * - Can allow parallel prefetches for sources that allow for out of order reads (`concurrency:  2+`)
@@ -36,7 +43,8 @@ const iterable_queue_1 = require("./iterable-queue");
  *
  * ### Usage
  * - Items are exposed to the `mapper` via an iterator or async iterator (this includes generator and async generator functions)
- * - IMPORTANT: `mapper` method not be invoked when `maxUnread` is reached, until items are consumed
+ * - Consume results with `for await` while mapping proceeds
+ * - The `mapper` will not be invoked when `maxUnread` is reached, until items are consumed
  * - The iterable will set `done` when the `input` has indicated `done` and all `mapper` promises have resolved
  *
  * @example
@@ -60,14 +68,14 @@ const iterable_queue_1 = require("./iterable-queue");
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Blocking Sequential Writes
+ * ### Prefetching with `IterableMapper` and Blocking Sequential Writes
  *
- * `concurrency: 1` on the prefetcher preserves the order of the reads and and writes are sequential and blocking (unchanged).
+ * `concurrency: 1` on the prefetcher preserves the order of the reads, and writes remain sequential and blocking.
  *
  * ```typescript
  * const source = new SomeSource();
  * const sourceIds = [1, 2,... 1000];
- * // Pre-reads up to 8 items serially and releases in sequential order
+ * // Prefetches serially within maxUnread and releases results in sequential order
  * const sourcePrefetcher = new IterableMapper(sourceIds,
  *   async (sourceId) => source.read(sourceId),
  *   { concurrency: 1, maxUnread: 10 }
@@ -83,7 +91,7 @@ const iterable_queue_1 = require("./iterable-queue");
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Background Sequential Writes with `IterableQueueMapperSimple`
+ * ### Prefetching with `IterableMapper` and Background Sequential Writes with `IterableQueueMapperSimple`
  *
  * `concurrency: 1` on the prefetcher preserves the order of the reads.
  * `concurrency: 1` on the flusher preserves the order of the writes, but allows the loop to iterate while last write is completing.
@@ -104,7 +112,7 @@ const iterable_queue_1 = require("./iterable-queue");
  *   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
  *   await flusher.enqueue(outputItem);            // will periodically block for portion of write time
  * }
- * // Wait for all writes to complete
+ * // Close input permanently after the last enqueue and wait for all writes
  * await flusher.onIdle();
  * // Check for errors
  * if (flusher.errors.length > 0) {
@@ -119,7 +127,7 @@ const iterable_queue_1 = require("./iterable-queue");
  *
  * @example
  *
- * ### Using `IterableMapper` as Prefetcher with Out of Order Reads and Background Out of Order Writes with `IterableQueueMapperSimple`
+ * ### Prefetching with `IterableMapper` and Out of Order Background Writes with `IterableQueueMapperSimple`
  *
  * For maximum throughput, allow out of order reads and writes with
  * `IterableQueueMapper` (to iterate results with backpressure when too many unread items) or
@@ -141,7 +149,7 @@ const iterable_queue_1 = require("./iterable-queue");
  *   const outputItem = doSomeOperation(item);     // takes 20 ms of CPU
  *   await flusher.enqueue(outputItem);            // typically will not block
  * }
- * // Wait for all writes to complete
+ * // Close input permanently after the last enqueue and wait for all writes
  * await flusher.onIdle();
  * // Check for errors
  * if (flusher.errors.length > 0) {
@@ -163,7 +171,7 @@ class IterableMapper {
      * @param mapper Function called for every item in `input`. Returns a `Promise` or value.
      * @param options IterableMapper options
      *
-     * @see {@link IterableQueueMapper} for full class documentation
+     * @see {@link IterableMapper} for full class documentation
      */
     constructor(input, mapper, options = {}) {
         this._errors = [];
@@ -180,12 +188,6 @@ class IterableMapper {
         if (typeof mapper !== 'function') {
             throw new TypeError('Mapper function is required');
         }
-        // Avoid undefined errors on options
-        if (this._options.concurrency === undefined ||
-            this._options.stopOnMapperError === undefined ||
-            this._options.maxUnread === undefined) {
-            throw new TypeError('Options are malformed after init');
-        }
         // Validate concurrency option
         if (!((Number.isSafeInteger(this._options.concurrency) ||
             this._options.concurrency === Number.POSITIVE_INFINITY) &&
@@ -248,7 +250,7 @@ class IterableMapper {
             if (!this._options.stopOnMapperError && this._errors.length > 0) {
                 // throw the errors as an aggregate exception
                 this._isRejected = true;
-                throw new AggregateError(this._errors);
+                throw new aggregate_error_1.default(this._errors);
             }
             return { value: undefined, done };
         }
@@ -265,7 +267,7 @@ class IterableMapper {
     bubbleUpErrors() {
         if (!this._options.stopOnMapperError && this._errors.length > 0) {
             // throw the errors as an aggregate exception
-            throw new AggregateError(this._errors);
+            throw new aggregate_error_1.default(this._errors);
         }
     }
     startARunnerIfNeeded() {
@@ -280,34 +282,15 @@ class IterableMapper {
                 if (this._activeRunners < this._options.concurrency) {
                     // We only create runners if we're under the concurrency limit
                     if (this._unreadQueue.length + this._activeRunners <= this._options.maxUnread) {
-                        // We only create runners if the number of runners + unread items will not
-                        // exceed the unread queue length
-                        // Start another source runner, but do not await it
-                        this.startAnotherRunner();
+                        // The eligibility checks above and reservation below run synchronously.
+                        // Reserve the slot before starting asynchronous source work.
+                        this._activeRunners++;
+                        void this.sourceNext();
                     }
                 }
             }
         }
     }
-    startAnotherRunner() {
-        if (this._activeRunners === this._options.concurrency) {
-            throw new TypeError('active runners would be greater than concurrency limit');
-        }
-        if (this._activeRunners + this._unreadQueue.length > this._options.maxUnread) {
-            throw new TypeError('active runners would overflow the read queue limit');
-        }
-        if (this._isIterableDone) {
-            throw new TypeError('runner should not be started when iterable is already done');
-        }
-        if (this._activeRunners < 0) {
-            throw new TypeError('active runners is less than 0');
-        }
-        // We only create runners if the number of runners + unread items will not
-        // exceed the unread queue length
-        this._activeRunners++;
-        // Start another source runner, but do not await it
-        void this.sourceNext();
-    }
     areWeDone() {
         if (this._isIterableDone) {
             // The source iterable has no more items

package/dist/src/iterable-mapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-mapper.js","sourceRoot":"","sources":["../../src/iterable-mapper.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"iterable-mapper.js","sourceRoot":"","sources":["../../src/iterable-mapper.ts"],"names":[],"mappings":"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"}

package/dist/src/iterable-queue-mapper-simple.d.ts

@@ -6,22 +6,25 @@ type Errors<T> = {
     } | Error;
 }[];
 /**
- * Options for IterableQueueMapperSimple
+ * Options for `IterableQueueMapperSimple`, also exported as `WorkerQueueOptions`.
  */
 export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'concurrency'>;
 /**
  * Accepts queue items via `enqueue` and calls the `mapper` on them
  * with specified `concurrency`, discards the results, and accumulates
- * exceptions in the `errors` property.  When empty, `await enqueue()`
- * will return immediately, but when `concurrency` items are in progress,
- * `await enqueue()` will block until a slot is available to accept the item.
+ * exceptions in the `errors` property. Await `enqueue()` for producer
+ * backpressure while the worker callback runs asynchronously.
+ *
+ * Also exported as `WorkerQueue`, with the same constructor and instance types.
+ * Each input uses the same worker callback supplied at construction. Asynchronous
+ * work overlaps in the current JavaScript process, and results are consumed internally.
  *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are not needed in a subsequent step (if they are, use `IterableQueueMapper`)
+ * ### Typical Use Cases
+ * - Running background status checks or other queued work through a fixed callback
+ * - Sending items to an async I/O destination
+ * - Processing items whose return values can be discarded (if results are needed, use `IterableQueueMapper` / `MappingQueue`)
  *
  * ### Error Handling
  *   The mapper should ideally handle all errors internally to enable error handling
@@ -31,7 +34,7 @@ export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'conc
  *   - Errors can be checked/handled during processing via the `errors` property
  *
  *   Key Differences from `IterableQueueMapper`:
- *   - `maxUnread` defaults to equal `concurrency` (simplifying queue management)
+ *   - The internal `maxUnread` limit equals `concurrency`; only `concurrency` is configurable
  *   - Results are automatically iterated and discarded (all work should happen in mapper)
  *   - Errors are collected rather than thrown (available via errors property)
  *
@@ -39,7 +42,11 @@ export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'conc
  * - Items are added to the queue via the `await enqueue()` method
  * - Check `errors` property to see if any errors occurred, stop if desired
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - After the last awaited enqueue, await `onIdle()` to close input permanently and finish accepted work
+ * - Subsequent enqueues reject, so `onIdle()` is a final shutdown operation
+ * - Worker failures are collected in `errors`; they do not reject `onIdle()`
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
+ * - Admission limits for event callbacks, cancellation, and per-item completion handles belong to the caller
  *
  * Note: the name is somewhat of a misnomer as this wraps `IterableQueueMapper`
  * but is not itself an `Iterable`.
@@ -70,7 +77,7 @@ export declare class IterableQueueMapperSimple<Element> {
     private discardResults;
     private worker;
     /**
-     * Accumulated errors from background `mappers`s
+     * Accumulated errors from the worker callback.
      *
      * @remarks
      *
@@ -83,24 +90,24 @@ export declare class IterableQueueMapperSimple<Element> {
      */
     get errors(): Errors<Element>;
     /**
-     * Accept a request for sending in the background if a concurrency slot is available.
-     * Else, do not return until a concurrency slot is freed up.
-     * This provides concurrency background writes with backpressure to prevent
-     * the caller from getting too far ahead.
+     * Accept an input for the worker callback, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of this item's work.
+     * Await each enqueue for producer backpressure.
      *
-     * MUST await `onIdle` for background `mappers`s to finish
-     * @param item
+     * After the last enqueue, await `onIdle()` to close input and finish accepted work.
+     * @param item Input for the worker callback
      */
     enqueue(item: Element): Promise<void>;
     /**
-     * Wait for all background `mapper`s to finish.
-     * MUST be called before exit to ensure no lost writes.
+     * Permanently close input and wait for all accepted work to finish.
+     * Call after the last awaited enqueue. Subsequent enqueues reject.
+     * Worker failures are available in `errors` instead of rejecting this wait.
      */
     onIdle(): Promise<void>;
     /**
-     * Indicates if all background `mapper`s have finished.
+     * Indicates whether final shutdown has completed.
      *
-     * @returns true if .onIdle() has been called and finished all background writes
+     * @returns true after `onIdle()` has finished all accepted work and closed input
      */
     get isIdle(): boolean;
 }

package/dist/src/iterable-queue-mapper-simple.js

@@ -6,16 +6,19 @@ const NoResult = Symbol('noresult');
 /**
  * Accepts queue items via `enqueue` and calls the `mapper` on them
  * with specified `concurrency`, discards the results, and accumulates
- * exceptions in the `errors` property.  When empty, `await enqueue()`
- * will return immediately, but when `concurrency` items are in progress,
- * `await enqueue()` will block until a slot is available to accept the item.
+ * exceptions in the `errors` property. Await `enqueue()` for producer
+ * backpressure while the worker callback runs asynchronously.
+ *
+ * Also exported as `WorkerQueue`, with the same constructor and instance types.
+ * Each input uses the same worker callback supplied at construction. Asynchronous
+ * work overlaps in the current JavaScript process, and results are consumed internally.
  *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are not needed in a subsequent step (if they are, use `IterableQueueMapper`)
+ * ### Typical Use Cases
+ * - Running background status checks or other queued work through a fixed callback
+ * - Sending items to an async I/O destination
+ * - Processing items whose return values can be discarded (if results are needed, use `IterableQueueMapper` / `MappingQueue`)
  *
  * ### Error Handling
  *   The mapper should ideally handle all errors internally to enable error handling
@@ -25,7 +28,7 @@ const NoResult = Symbol('noresult');
  *   - Errors can be checked/handled during processing via the `errors` property
  *
  *   Key Differences from `IterableQueueMapper`:
- *   - `maxUnread` defaults to equal `concurrency` (simplifying queue management)
+ *   - The internal `maxUnread` limit equals `concurrency`; only `concurrency` is configurable
  *   - Results are automatically iterated and discarded (all work should happen in mapper)
  *   - Errors are collected rather than thrown (available via errors property)
  *
@@ -33,7 +36,11 @@ const NoResult = Symbol('noresult');
  * - Items are added to the queue via the `await enqueue()` method
  * - Check `errors` property to see if any errors occurred, stop if desired
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - After the last awaited enqueue, await `onIdle()` to close input permanently and finish accepted work
+ * - Subsequent enqueues reject, so `onIdle()` is a final shutdown operation
+ * - Worker failures are collected in `errors`; they do not reject `onIdle()`
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
+ * - Admission limits for event callbacks, cancellation, and per-item completion handles belong to the caller
  *
  * Note: the name is somewhat of a misnomer as this wraps `IterableQueueMapper`
  * but is not itself an `Iterable`.
@@ -66,7 +73,6 @@ class IterableQueueMapperSimple {
         this._done = this.discardResults();
     }
     async discardResults() {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         let item = await this._writer.next();
         while (item.done !== true) {
             // Just discard all the results
@@ -85,7 +91,7 @@ class IterableQueueMapperSimple {
         return NoResult;
     }
     /**
-     * Accumulated errors from background `mappers`s
+     * Accumulated errors from the worker callback.
      *
      * @remarks
      *
@@ -100,34 +106,34 @@ class IterableQueueMapperSimple {
         return this._errors;
     }
     /**
-     * Accept a request for sending in the background if a concurrency slot is available.
-     * Else, do not return until a concurrency slot is freed up.
-     * This provides concurrency background writes with backpressure to prevent
-     * the caller from getting too far ahead.
+     * Accept an input for the worker callback, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of this item's work.
+     * Await each enqueue for producer backpressure.
      *
-     * MUST await `onIdle` for background `mappers`s to finish
-     * @param item
+     * After the last enqueue, await `onIdle()` to close input and finish accepted work.
+     * @param item Input for the worker callback
      */
     async enqueue(item) {
-        // Return immediately or wait for a slot to free up in the background writer
+        // Return immediately or wait for the underlying mapping queue to accept the input
         await this._writer.enqueue(item);
     }
     /**
-     * Wait for all background `mapper`s to finish.
-     * MUST be called before exit to ensure no lost writes.
+     * Permanently close input and wait for all accepted work to finish.
+     * Call after the last awaited enqueue. Subsequent enqueues reject.
+     * Worker failures are available in `errors` instead of rejecting this wait.
      */
     async onIdle() {
         if (this._isIdle)
             return;
-        // Indicate that we're done writing requests
+        // Indicate that no more inputs will be enqueued
         this._writer.done();
         await this._done;
         this._isIdle = true;
     }
     /**
-     * Indicates if all background `mapper`s have finished.
+     * Indicates whether final shutdown has completed.
      *
-     * @returns true if .onIdle() has been called and finished all background writes
+     * @returns true after `onIdle()` has finished all accepted work and closed input
      */
     get isIdle() {
         return this._isIdle;

package/dist/src/iterable-queue-mapper-simple.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue-mapper-simple.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper-simple.ts"],"names":[],"mappings":";;;AACA,mEAA8D;AAK9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAOpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAa,yBAAyB;IAOpC;;;;;;;;;;OAUG;IACH,YAAY,MAA6B,EAAE,UAA4C,EAAE;QAhBxE,YAAO,GAAoB,EAAE,CAAC;QAGvC,YAAO,GAAG,KAAK,CAAC;QActB,MAAM,EAAE,WAAW,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;QAEpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,IAAI,2CAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC;QAE7F,6BAA6B;QAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,6DAA6D;QAC7D,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YACzB,+BAA+B;YAC/B,oEAAoE;YACpE,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAClC;IACH,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,KAAa;QAC/C,IAAI;YACF,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAChC,8DAA8D;SAC/D;QAAC,OAAO,KAAU,EAAE;YACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;SACpC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,4EAA4E;QAC5E,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,MAAM;QACjB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAEzB,4CAA4C;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAEpB,MAAM,IAAI,CAAC,KAAK,CAAC;QAEjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AAtGD,8DAsGC"}
+{"version":3,"file":"iterable-queue-mapper-simple.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper-simple.ts"],"names":[],"mappings":";;;AACA,mEAA8D;AAK9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAOpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAa,yBAAyB;IAOpC;;;;;;;;;;OAUG;IACH,YAAY,MAA6B,EAAE,UAA4C,EAAE;QAhBxE,YAAO,GAAoB,EAAE,CAAC;QAGvC,YAAO,GAAG,KAAK,CAAC;QActB,MAAM,EAAE,WAAW,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;QAEpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,IAAI,2CAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC;QAE7F,6BAA6B;QAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC1B,+BAA+B;YAC/B,oEAAoE;YACpE,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,KAAa;QAC/C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAChC,8DAA8D;QAChE,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,kFAAkF;QAClF,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,MAAM;QACjB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAEzB,gDAAgD;QAChD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAEpB,MAAM,IAAI,CAAC,KAAK,CAAC;QAEjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AArGD,8DAqGC"}

package/dist/src/iterable-queue-mapper.d.ts

@@ -1,6 +1,6 @@
 import { IterableMapperOptions, Mapper } from './iterable-mapper';
 /**
- * Options for IterableQueueMapper
+ * Options for `IterableQueueMapper`, also exported as `MappingQueueOptions`.
  */
 export type IterableQueueMapperOptions = IterableMapperOptions;
 /**
@@ -9,12 +9,16 @@ export type IterableQueueMapperOptions = IterableMapperOptions;
  * of `maxUnread` size, before being iterated / read by the caller.
  * The `enqueue` method will block if the queue is full, until an item is read.
  *
+ * Also exported as `MappingQueue`, with the same constructor and instance types.
+ * Each input uses the same callback supplied at construction; results are exposed
+ * through the async iterator as mapping completes.
+ *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are needed in a subsequent step (if they are not, use `IterableQueueMapperSimple`)
+ * ### Typical Use Cases
+ * - Enqueuing capability probes or metadata lookups as inputs become available
+ * - Sending items to an async I/O destination and consuming its acknowledgements
+ * - Consuming mapped results in a subsequent step (if results can be discarded, use `IterableQueueMapperSimple` / `WorkerQueue`)
  * - Prevents the producer from racing ahead of the consumer if `maxUnread` is reached
  *
  * ### Error Handling
@@ -33,8 +37,10 @@ export type IterableQueueMapperOptions = IterableMapperOptions;
  * ### Usage
  * - Items are added to the queue via the `await enqueue()` method
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - Call `done()` when no more items will be enqueued
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - Produce inputs and consume results concurrently so the result buffer can drain
+ * - Call `done()` after the last awaited enqueue, then finish consuming the iterator
+ * - `enqueue()` confirms acceptance of an input; `done()` closes input without waiting for work to finish
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
  *
  * @category Enqueue Input
  *
@@ -62,7 +68,9 @@ export declare class IterableQueueMapper<Element, NewElement> implements AsyncIt
      */
     next(): Promise<IteratorResult<NewElement>>;
     /**
-     * Add an item to the queue, wait if the queue is full.
+     * Add an item to the queue, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of the mapper for this item.
+     * Await each enqueue while consuming results concurrently for producer backpressure.
      *
      * @param item Element to add
      */
@@ -70,7 +78,8 @@ export declare class IterableQueueMapper<Element, NewElement> implements AsyncIt
     /**
      * Indicate that no more items will be enqueued.
      *
-     * This releases all readers blocked on `enqueue`
+     * Call after the last awaited enqueue. Finish consuming the async iterator
+     * to wait for mapped results; this method does not wait for processing to finish.
      */
     done(): void;
 }

package/dist/src/iterable-queue-mapper.js

@@ -12,12 +12,16 @@ const iterable_queue_1 = require("./iterable-queue");
  * of `maxUnread` size, before being iterated / read by the caller.
  * The `enqueue` method will block if the queue is full, until an item is read.
  *
+ * Also exported as `MappingQueue`, with the same constructor and instance types.
+ * Each input uses the same callback supplied at construction; results are exposed
+ * through the async iterator as mapping completes.
+ *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are needed in a subsequent step (if they are not, use `IterableQueueMapperSimple`)
+ * ### Typical Use Cases
+ * - Enqueuing capability probes or metadata lookups as inputs become available
+ * - Sending items to an async I/O destination and consuming its acknowledgements
+ * - Consuming mapped results in a subsequent step (if results can be discarded, use `IterableQueueMapperSimple` / `WorkerQueue`)
  * - Prevents the producer from racing ahead of the consumer if `maxUnread` is reached
  *
  * ### Error Handling
@@ -36,8 +40,10 @@ const iterable_queue_1 = require("./iterable-queue");
  * ### Usage
  * - Items are added to the queue via the `await enqueue()` method
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - Call `done()` when no more items will be enqueued
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - Produce inputs and consume results concurrently so the result buffer can drain
+ * - Call `done()` after the last awaited enqueue, then finish consuming the iterator
+ * - `enqueue()` confirms acceptance of an input; `done()` closes input without waiting for work to finish
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
  *
  * @category Enqueue Input
  *
@@ -72,7 +78,9 @@ class IterableQueueMapper {
         return this._iterableMapper.next();
     }
     /**
-     * Add an item to the queue, wait if the queue is full.
+     * Add an item to the queue, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of the mapper for this item.
+     * Await each enqueue while consuming results concurrently for producer backpressure.
      *
      * @param item Element to add
      */
@@ -82,7 +90,8 @@ class IterableQueueMapper {
     /**
      * Indicate that no more items will be enqueued.
      *
-     * This releases all readers blocked on `enqueue`
+     * Call after the last awaited enqueue. Finish consuming the async iterator
+     * to wait for mapped results; this method does not wait for processing to finish.
      */
     done() {
         this._sourceIterable.done();

package/dist/src/iterable-queue-mapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue-mapper.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper.ts"],"names":[],"mappings":";;;AAAA,EAAE;AACF,sGAAsG;AACtG,EAAE;AACF,uDAAkF;AAClF,qDAAiD;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAa,mBAAmB;IAK9B;;;;;;;;;OASG;IACH,YAAY,MAAmC,EAAE,UAAsC,EAAE;QACvF,IAAI,CAAC,eAAe,GAAG,IAAI,8BAAa,CAAC;YACvC,SAAS,EAAE,CAAC;SACb,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACnF,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACI,IAAI;QACT,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC9B,CAAC;CACF;AApDD,kDAoDC"}
+{"version":3,"file":"iterable-queue-mapper.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper.ts"],"names":[],"mappings":";;;AAAA,EAAE;AACF,sGAAsG;AACtG,EAAE;AACF,uDAAkF;AAClF,qDAAiD;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,mBAAmB;IAK9B;;;;;;;;;OASG;IACH,YAAY,MAAmC,EAAE,UAAsC,EAAE;QACvF,IAAI,CAAC,eAAe,GAAG,IAAI,8BAAa,CAAC;YACvC,SAAS,EAAE,CAAC;SACb,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACnF,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACI,IAAI;QACT,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC9B,CAAC;CACF;AAvDD,kDAuDC"}

package/dist/src/iterable-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue.js","sourceRoot":"","sources":["../../src/iterable-queue.ts"],"names":[],"mappings":";;;AAAA,qDAAuE;AAIvE;;;;GAIG;AACH,MAAa,aACX,SAAQ,8BAAsB;IAG9B;;;OAGG;IACH,YAAY,UAAgC,EAAE;QAC5C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI;QACf,6BAA6B;QAC7B,MAAM,IAAI,GAAwB,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QAEvD,IAAI,IAAI,KAAK,SAAS,EAAE;YACtB,yCAAyC;YACzC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;SACzC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACtC,CAAC;CACF;AAjCD,sCAiCC"}
+{"version":3,"file":"iterable-queue.js","sourceRoot":"","sources":["../../src/iterable-queue.ts"],"names":[],"mappings":";;;AAAA,qDAAuE;AAIvE;;;;GAIG;AACH,MAAa,aACX,SAAQ,8BAAsB;IAG9B;;;OAGG;IACH,YAAY,UAAgC,EAAE;QAC5C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI;QACf,6BAA6B;QAC7B,MAAM,IAAI,GAAwB,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QAEvD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,yCAAyC;YACzC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QAC1C,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACtC,CAAC;CACF;AAjCD,sCAiCC"}

package/dist/src/queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/queue.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,kGAAkG;AAClG,EAAE;;;AAEF;;;;GAIG;AACH,MAAa,KAAK;IAAlB;QACU,WAAM,GAA2B,EAAE,CAAC;QACpC,UAAK,GAAG,CAAC,CAAC;QACV,UAAK,GAAG,CAAC,CAAC;IAsBpB,CAAC;IApBC,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC;IAED,0CAA0C;IACnC,OAAO,CAAC,OAAU;QACvB,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;SACnD;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACtC,CAAC;IAED,yCAAyC;IAClC,OAAO;QACZ,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAEhD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACjC,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAzBD,sBAyBC"}
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/queue.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,kGAAkG;AAClG,EAAE;;;AAEF;;;;GAIG;AACH,MAAa,KAAK;IAAlB;QACU,WAAM,GAA2B,EAAE,CAAC;QACpC,UAAK,GAAG,CAAC,CAAC;QACV,UAAK,GAAG,CAAC,CAAC;IAsBpB,CAAC;IApBC,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC;IAED,0CAA0C;IACnC,OAAO,CAAC,OAAU;QACvB,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACtC,CAAC;IAED,yCAAyC;IAClC,OAAO;QACZ,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAEhD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACjC,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAzBD,sBAyBC"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@shutterstock/p-map-iterable",
-  "version": "1.1.2",
-  "description": "Set of classes used for async prefetching with backpressure (IterableMapper) and async flushing with backpressure (IterableQueueMapper, IterableQueueMapperSimple)",
+  "version": "1.2.0",
+  "packageManager": "pnpm@12.7.0",
+  "description": "Concurrent mapping and queued background work with backpressure, streaming results, and collected errors",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "publishConfig": {
@@ -29,9 +30,10 @@
     "example:iterable-mapper": "ts-node -r tsconfig-paths/register examples/iterable-mapper.ts",
     "example:iterable-queue-mapper": "ts-node -r tsconfig-paths/register examples/iterable-queue-mapper.ts",
     "example:iterable-queue-mapper-simple": "ts-node -r tsconfig-paths/register examples/iterable-queue-mapper-simple.ts",
+    "example:semantic-aliases": "ts-node -r tsconfig-paths/register examples/semantic-aliases.ts",
     "test": "jest",
-    "lint": "eslint ./ --ext .ts --ext .tsx",
-    "lint-and-fix": "eslint ./ --ext .ts --ext .tsx --fix"
+    "lint": "eslint .",
+    "lint-and-fix": "eslint . --fix"
   },
   "files": [
     "dist/",
@@ -44,24 +46,28 @@
   },
   "license": "MIT",
   "dependencies": {
-    "aggregate-error": "^3.0.0"
+    "aggregate-error": "^3.1.0"
   },
   "peerDependencies": {
-    "aggregate-error": "^3.0.0"
+    "aggregate-error": "^3.1.0"
   },
   "devDependencies": {
-    "@types/jest": "29.5.2",
-    "@typescript-eslint/eslint-plugin": "^5.13.0",
-    "@typescript-eslint/parser": "^5.13.0",
-    "eslint": "^7.15.0",
-    "eslint-config-prettier": "^7.0.0",
-    "eslint-plugin-prettier": "^3.2.0",
-    "jest": "29.5.0",
-    "prettier": "^2.2.1",
-    "ts-jest": "29.1.0",
-    "ts-node": "10.9.1",
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "30.0.0",
+    "@types/node": "^26.6.3",
+    "@typescript-eslint/eslint-plugin": "^8.70.1",
+    "@typescript-eslint/parser": "^8.70.1",
+    "eslint": "^10.11.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.12.0",
+    "jest": "30.5.2",
+    "lcov-parse": "1.0.0",
+    "prettier": "^3.9.9",
+    "ts-jest": "29.4.14",
+    "ts-node": "10.9.2",
     "tsconfig-paths": "4.2.0",
-    "typedoc": "^0.24.8",
-    "typescript": "5.1.3"
+    "typedoc": "^0.28.20",
+    "typescript": "6.0.3"
   }
 }