spliterator 5.0.0 → 6.0.0

package/README.md

@@ -153,6 +153,62 @@ for (const row of CSVSpliterator.from(largeCsvString)) {
 
 Correctness is identical either way; `whenReady()` only affects which scanner runs.
 
+## Choosing a primitive
+
+The question that predicts the answer is not "how big is my file?" — it's **how much work happens per row.**
+
+| Per-row work                                                 | What dominates | Reach for                                                                                           |
+| ------------------------------------------------------------ | -------------- | --------------------------------------------------------------------------------------------------- |
+| None — counting, segmenting, pulling a couple of fields      | The scan       | `Spliterator` raw byte ranges. The SIMD scanner earns its keep here (~5–6 GB/s vs ~600 MB/s for JS) |
+| ~1–3 µs — `JSON.parse`, CSV → object, string normalize       | The parse      | Plain sequential `fromAsync`. Threads **lose** here (0.3–0.9×); JSONL runs ~0.5× of `readline`      |
+| Milliseconds — model inference, geocoding, crypto, image ops | Your handler   | `parallelMapWorkers`, or `AsyncSpliterator.asManyWorkers` for one large file                        |
+| I/O-bound — file fan-out, network                            | Latency        | `parallelMap` (caller's thread). Concurrency peaks around 2–3, then **degrades**                    |
+
+The line worth internalizing: **the scan is almost never your bottleneck unless you aren't parsing.** Measure before adopting a parallel primitive.
+
+The naming encodes one rule:
+
+> **If you can pass a closure, it runs on your thread. If you must pass a module path, it runs on another one.**
+
+Closures can't cross a `postMessage` boundary, so `parallelMap` takes a function and `parallelMapWorkers` takes a path — and `asMany`/`asManyWorkers` divide the same way.
+
+|                       | Caller's thread             | Worker threads                   |
+| --------------------- | --------------------------- | -------------------------------- |
+| A collection of items | `parallelMap`               | `parallelMapWorkers`             |
+| One large file        | `AsyncSpliterator.asMany`   | `AsyncSpliterator.asManyWorkers` |
+| Just the boundaries   | `AsyncSpliterator.segments` | (feeds either)                   |
+
+### Chaining
+
+`fromAsync` returns an `AsyncSequence` — a lazy, chainable async iterator whose core methods (`map`, `filter`, `take`, `drop`, `flatMap`, `reduce`, `toArray`, `forEach`, `some`, `every`, `find`) match the [async iterator helpers proposal][helpers] in name and semantics. No polyfill required.
+
+[helpers]: https://github.com/tc39/proposal-async-iterator-helpers
+
+```ts
+const cakes = await JSONSpliterator.fromAsync<Row>("menu.jsonl", { delimiter: "\n" })
+	.filter((row) => row.category === "Ice Cream Cake")
+	.map((row) => row.item_name)
+	.take(10)
+	.toArray()
+```
+
+Filtering happens while streaming, and `take(10)` closes the file handle instead of reading the rest. The operators fuse into a single pass rather than nesting one async generator per step, so chain depth is nearly free — doubling the operator count costs about 10%, where nesting would roughly double it. `flatMap`, `chunks`, and `parallelMap` are the exceptions, since they need inner-iterator state.
+
+The synchronous `from` returns a plain generator, which already has the same helpers natively on Node 24+.
+
+### Small sources are read whole
+
+Opening a file handle and standing up a read stream costs about 100µs, which is most of the work for a small file. So `fromAsync` reads sources of 128 KiB or less into memory and parses them synchronously — measured ~1.85× faster at 635 B and ~1.4× at 125 KiB. Output is identical either way.
+
+The threshold is deliberately small. Above ~256 KiB the advantage stops being measurable, while the memory cost keeps growing — a 1 GiB file costs ~105 MB resident streamed against ~1.1 GB read whole. Raising it buys nothing and spends memory linearly.
+
+```ts
+// Force streaming, whatever the size — when a bounded footprint is the point.
+JSONSpliterator.fromAsync("data.jsonl", { delimiter: "\n", bulkThreshold: 0 })
+```
+
+Sources with no knowable length (a pipe, a `ReadableStream`) get an end-of-input test instead: if the first chunk read is also the last, the whole input is already in memory and is parsed directly. Otherwise it streams as normal.
+
 ### Parallel parsing across threads
 
 For one large file with a CPU-bound per-row transform, `AsyncSpliterator.asManyWorkers` splits the file into delimiter-aligned segments and runs a handler module across worker threads — each worker owns its own handle and reads only its segment. Results stream back to the main thread as a single async iterator, for a single-thread writer (a database, a JSONL file).

package/out/index.d.ts

@@ -3,21 +3,27 @@
  * @license MIT
  * @author Teffen Ellis, et al.
  */
+export * from "./lib/adaptive-source.js";
+export * from "./lib/AsyncSequence.js";
 export * from "./lib/BufferController.js";
 export * from "./lib/casing.js";
 export * from "./lib/CharacterSequence.js";
+export * from "./lib/chunks.js";
 export * from "./lib/CompositeDataView.js";
 export * from "./lib/CSVSpliterator.js";
 export * from "./lib/IndexQueue.js";
 export * from "./lib/JSONSpliterator.js";
 export * from "./lib/parallel-map.js";
+export * from "./lib/parallel-map-workers.js";
+export * from "./lib/pivot.js";
 export * from "./lib/PSVSpliterator.js";
 export * from "./lib/segments.js";
 export * from "./lib/shared.js";
 export * from "./lib/SlidingWindow.js";
 export * from "./lib/Spliterator.js";
-export * from "./lib/take.js";
 export * from "./lib/TextSpliterator.js";
 export * from "./lib/TSVSpliterator.js";
+export * from "./lib/utils.js";
 export * from "./lib/writer.js";
+export * from "./lib/zip.js";
 //# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,yBAAyB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA"}

package/out/index.js

@@ -3,21 +3,27 @@
  * @license MIT
  * @author Teffen Ellis, et al.
  */
+export * from "./lib/adaptive-source.js";
+export * from "./lib/AsyncSequence.js";
 export * from "./lib/BufferController.js";
 export * from "./lib/casing.js";
 export * from "./lib/CharacterSequence.js";
+export * from "./lib/chunks.js";
 export * from "./lib/CompositeDataView.js";
 export * from "./lib/CSVSpliterator.js";
 export * from "./lib/IndexQueue.js";
 export * from "./lib/JSONSpliterator.js";
 export * from "./lib/parallel-map.js";
+export * from "./lib/parallel-map-workers.js";
+export * from "./lib/pivot.js";
 export * from "./lib/PSVSpliterator.js";
 export * from "./lib/segments.js";
 export * from "./lib/shared.js";
 export * from "./lib/SlidingWindow.js";
 export * from "./lib/Spliterator.js";
-export * from "./lib/take.js";
 export * from "./lib/TextSpliterator.js";
 export * from "./lib/TSVSpliterator.js";
+export * from "./lib/utils.js";
 export * from "./lib/writer.js";
+export * from "./lib/zip.js";
 //# sourceMappingURL=index.js.map

package/out/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,yBAAyB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA"}

package/out/lib/AsyncSequence.d.ts

@@ -0,0 +1,180 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+import { ReadableStream, type ReadableWritablePair, type StreamPipeOptions } from "stream/web";
+/**
+ * A chainable operation in a fused pipeline.
+ *
+ * Ops are **descriptors**, not closures over iteration state — `take`/`drop` counters live in the iterator, not here,
+ * so a sequence can describe its chain before anyone pulls from it.
+ */
+type Op = {
+    kind: typeof OP_MAP;
+    fn: (value: any, counter: number) => unknown;
+} | {
+    kind: typeof OP_FILTER;
+    fn: (value: any, counter: number) => unknown;
+} | {
+    kind: typeof OP_TAKE;
+    limit: number;
+} | {
+    kind: typeof OP_DROP;
+    limit: number;
+};
+declare const OP_MAP = 0;
+declare const OP_FILTER = 1;
+declare const OP_TAKE = 2;
+declare const OP_DROP = 3;
+/**
+ * What a sequence can be built over.
+ *
+ * The thunk form defers construction until the first pull, which is what lets a `fromAsync` whose underlying open is
+ * asynchronous still return a sequence synchronously — the caller chains immediately and no file is opened until
+ * something iterates.
+ */
+export type SequenceSource<T> = AsyncIterable<T> | Iterable<T> | (() => AsyncIterable<T> | Iterable<T> | PromiseLike<AsyncIterable<T> | Iterable<T>>);
+/**
+ * Options for {@linkcode AsyncSequence.parallelMap}.
+ */
+export interface ParallelMapSequenceOptions {
+    /**
+     * Maximum callbacks in flight at once.
+     *
+     * For I/O-bound work this peaks **low** — often ~2–3 — and then _degrades_ as callers contend for the same disk or
+     * socket. Sweep it rather than reaching for `availableParallelism()`.
+     */
+    concurrency: number;
+    /**
+     * Abort signal. When aborted, iteration stops after the currently-yielded value; in-flight callbacks are allowed to
+     * settle so none reject unobserved.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * A lazy, chainable async iterator.
+ *
+ * The core methods (`map`, `filter`, `take`, `drop`, `flatMap`, `reduce`, `toArray`, `forEach`, `some`, `every`,
+ * `find`) match the [async iterator helpers proposal][proposal] in name, arity, and semantics — including the `counter`
+ * second argument handed to every callback. Callbacks may return promises. Code written against this keeps working
+ * verbatim if the proposal ever ships natively.
+ *
+ * [proposal]: https://github.com/tc39/proposal-async-iterator-helpers
+ *
+ * **Chain depth is nearly free.** A chain is an op list plus a source, not nested generators, so one async boundary is
+ * paid per item no matter how many operators you stack; only the op loop grows. Measured on Node 26 over 2M items:
+ * ~5.4M items/s at three operators and ~4.9M/s at six, against ~2.3M/s for the equivalent nested-generator
+ * implementation, where each operator adds a microtask hop. Doubling the operator count costs ~10% here and would cost
+ * ~2× there. Only {@linkcode flatMap}, {@linkcode chunks}, and {@linkcode parallelMap} break fusion, because they need
+ * inner-iterator state.
+ *
+ * Callback results are awaited **only when thenable**, so synchronous callbacks — the common case — cost no microtask
+ * hop at all.
+ *
+ * **When not to reach for this.** Wrapping costs ~1.9× a bare async generator (~10.3M/s), one extra async frame per
+ * item. On parsed rows (`JSON.parse` at ~1–3µs) that is 3–8%, invisible. On raw {@linkcode Uint8Array} ranges with no
+ * per-row parse it is most of the cost — iterate the {@linkcode AsyncSpliterator} directly there.
+ *
+ * Single-shot, like the iterators the proposal specifies: iterating consumes the source.
+ */
+export declare class AsyncSequence<T> implements AsyncIterableIterator<T> {
+    #private;
+    constructor(source: SequenceSource<unknown>, ops?: readonly Op[]);
+    /**
+     * Wrap any iterable or async iterable as a chainable sequence.
+     */
+    static from<T>(source: SequenceSource<T>): AsyncSequence<T>;
+    /**
+     * Transform each value. The callback receives `(value, counter)` and may return a promise.
+     */
+    map<U>(fn: (value: T, counter: number) => U | PromiseLike<U>): AsyncSequence<U>;
+    /**
+     * Keep values for which the callback is truthy. The callback receives `(value, counter)` and may return a promise.
+     */
+    filter(fn: (value: T, counter: number) => unknown): AsyncSequence<T>;
+    /**
+     * Yield at most `limit` values, then close the underlying iterator.
+     *
+     * The close is what makes this safe on a file-backed source — `take(5)` over a 40GB file releases the handle rather
+     * than leaving it open until GC.
+     */
+    take(limit: number): AsyncSequence<T>;
+    /**
+     * Skip the first `limit` values.
+     */
+    drop(limit: number): AsyncSequence<T>;
+    /**
+     * Map each value to an iterable and flatten one level.
+     *
+     * **Fusion barrier.** Unlike the other operators this needs inner-iterator state, so it starts a fresh fused segment
+     * rather than joining the current op list. Stacking `flatMap` costs one async boundary each; stacking
+     * `map`/`filter`/`take`/`drop` costs nothing.
+     */
+    flatMap<U>(fn: (value: T, counter: number) => AsyncIterable<U> | Iterable<U> | PromiseLike<AsyncIterable<U> | Iterable<U>>): AsyncSequence<U>;
+    /**
+     * Collect every remaining value into an array.
+     *
+     * **Reads the whole source into memory.** On a sequence backed by a file this defeats the point of streaming — filter
+     * and map first so only what you keep is materialized.
+     */
+    toArray(): Promise<T[]>;
+    /**
+     * Invoke the callback for each value, for side effects.
+     */
+    forEach(fn: (value: T, counter: number) => unknown): Promise<void>;
+    /**
+     * Fold the sequence to a single value. Without `initialValue` the first value seeds the accumulator, and an empty
+     * sequence is a `TypeError` — matching `Array.prototype.reduce`.
+     */
+    reduce(fn: (accumulator: T, value: T, counter: number) => T | PromiseLike<T>): Promise<T>;
+    reduce<U>(fn: (accumulator: U, value: T, counter: number) => U | PromiseLike<U>, initialValue: U): Promise<U>;
+    /**
+     * Whether any value satisfies the callback. Short-circuits and closes the underlying iterator.
+     */
+    some(fn: (value: T, counter: number) => unknown): Promise<boolean>;
+    /**
+     * Whether every value satisfies the callback. Short-circuits and closes the underlying iterator.
+     */
+    every(fn: (value: T, counter: number) => unknown): Promise<boolean>;
+    /**
+     * The first value satisfying the callback, or `undefined`. Short-circuits and closes the underlying iterator.
+     */
+    find(fn: (value: T, counter: number) => unknown): Promise<T | undefined>;
+    /**
+     * Group values into arrays of `size`, with a shorter final batch if the sequence does not divide evenly.
+     *
+     * Distinct from {@linkcode take}, which yields the first `size` _values_. Named for the [iterator chunking
+     * proposal](https://github.com/tc39/proposal-iterator-chunking).
+     *
+     * **Fusion barrier**, like {@linkcode flatMap}.
+     */
+    chunks(size: number): AsyncSequence<T[]>;
+    /**
+     * Map values through a callback with up to `concurrency` calls in flight, yielding in **completion order** — not
+     * input order.
+     *
+     * The callback is a closure, so it runs on the caller's thread. This overlaps _latency_ (file reads, network) and
+     * does nothing for CPU-bound work; for that, cross a thread boundary with `parallelMapWorkers` or
+     * `AsyncSpliterator.asManyWorkers`, which take a module path precisely because a closure cannot.
+     *
+     * **Fusion barrier**, like {@linkcode flatMap}.
+     */
+    parallelMap<U>(fn: (value: T, counter: number) => U | PromiseLike<U>, { concurrency, signal }: ParallelMapSequenceOptions): AsyncSequence<U>;
+    /**
+     * Expose the sequence as a web stream, for interop with `pipeThrough`/`pipeTo` consumers.
+     */
+    toReadableStream(): ReadableStream<T>;
+    /**
+     * Pipe the sequence through a transform stream.
+     */
+    pipeThrough<U>(transform: ReadableWritablePair<U, T>, options?: StreamPipeOptions): ReadableStream<U>;
+    next(): Promise<IteratorResult<T>>;
+    /**
+     * Close the sequence and release the underlying source.
+     */
+    return(): Promise<IteratorResult<T>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+export {};
+//# sourceMappingURL=AsyncSequence.d.ts.map

package/out/lib/AsyncSequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncSequence.d.ts","sourceRoot":"","sources":["../../lib/AsyncSequence.ts"],"names":[],"mappings":"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"}