@zingage/scheduling 1.1.0 → 1.2.0

package/dist/batcher.js

@@ -0,0 +1,391 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { partition } from "es-toolkit";
+import { defaultLoggersByComponent } from "./logger.js";
+import { PendingPromisesTracker } from "./pending-promises-tracker.js";
+import { performanceNow } from "./performance-now.js";
+import { SchedulingContractError } from "./scheduling-contract-error.js";
+/**
+ * Throws a {@link SchedulingContractError} unless a batched call returned
+ * exactly one result per request.
+ */
+function assertResultCount(results, requestCount) {
+    if (results.length !== requestCount) {
+        throw new SchedulingContractError("Result count must match request count");
+    }
+}
+function asError(error) {
+    return error instanceof Error
+        ? error
+        : new Error("Batch dispatch failed", { cause: error });
+}
+/** Settles `result` with `outcome`. */
+export function settleResult(result, outcome) {
+    if (outcome.ok) {
+        result.resolve(outcome.value);
+    }
+    else {
+        // Cancellation can reject the result before anyone awaits it.
+        // oxlint-disable-next-line no-void -- Marks the rejection handled; the caller still gets the rejected promise.
+        void result.promise.catch(() => { });
+        result.reject(outcome.error);
+    }
+}
+/** The default `maxBatchSize`. */
+export const DEFAULT_MAX_BATCH_SIZE = 20;
+/**
+ * Queues work and dispatches it in batches. The batcher does not share work,
+ * and it knows nothing of `CollapsedTaskCreator`. To share work, compose the
+ * two: a creator's `schedule` enqueues one item per started task, for example
+ * `batcher.enqueue(toStart.map((view) => ({input: view, signal:
+ * view.signal})))`. Then `dispatch` receives each live view, and can read
+ * its `collapsedRequestCount` at dispatch time. For work that is never
+ * shared, such as a cache's reads from its store, use a batcher directly, so
+ * that each request gets its own entry.
+ *
+ * Entries wait in automatic batches, which follow DataLoader's rules. A new
+ * batch schedules its own dispatch with `batchScheduleFn` when it gets its
+ * first entry. Once it holds `maxBatchSize` queued entries, the next entry
+ * opens a new batch with its own scheduled dispatch. A full batch does not
+ * dispatch early: it waits for its own callback. A caller that wants its
+ * work run at once calls `dispatchNow` with its new items, and with the
+ * handles of queued entries it also waits for, such as entries from other
+ * callers' enqueues. That dispatch is never split, and its new items never
+ * wait in a batch.
+ *
+ * Cancellation removes a queued entry: when its item's signal aborts, the
+ * entry leaves the queue and its result rejects with the signal's reason.
+ * Dispatched work always completes.
+ *
+ * Shutdown has two steps, because an owner can still accept work after its
+ * shutdown starts:
+ *
+ * 1. `flush` sends every pending batch at once, and drops `batchScheduleFn`,
+ *    so later batches use the default schedule, which always fires. An owner
+ *    calls it when its shutdown starts, because its `batchScheduleFn` may
+ *    stop firing then.
+ * 2. `close` flushes too, and resolves once the batcher is idle. Then the
+ *    batcher is closed. An owner calls it after it stops accepting work. An
+ *    enqueue after that is a bug in the owner, so it logs a warning, but the
+ *    work still runs.
+ *
+ * Every entry's result settles, including on cancellation. So a caller that
+ * must hold a resource for an item's whole life acquires it before `enqueue`
+ * and releases it in a `.finally` on the item's result. The batcher has no
+ * hook for this.
+ */
+export class Batcher {
+    #maxBatchSize;
+    #preserveAsyncContext;
+    /** Set to undefined by {@link flush}. */
+    #batchScheduleFn;
+    #logger;
+    #dispatch;
+    /**
+     * The batch that new entries join while it has room. Undefined before the
+     * first enqueue, and after the open batch dispatches.
+     */
+    #openBatch;
+    /**
+     * Batches whose dispatch is scheduled and has not run, so `flush` and
+     * `#drain` can dispatch them early.
+     */
+    #pendingBatches = new Set();
+    /** Dispatches that have not settled, so `#drain` can wait for them. */
+    #running = new PendingPromisesTracker();
+    /**
+     * `"closing"` from the call to `close` until the batcher is idle. Then
+     * `"closed"`, and `enqueue` warns.
+     */
+    #status = "open";
+    /** The promise that `close` returns, so repeated calls share it. */
+    #closed;
+    constructor(options) {
+        const maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+        if (maxBatchSize !== Infinity &&
+            (!Number.isInteger(maxBatchSize) || maxBatchSize < 1)) {
+            throw new TypeError("maxBatchSize must be a positive integer");
+        }
+        this.#maxBatchSize = maxBatchSize;
+        this.#preserveAsyncContext = options.preserveAsyncContext ?? false;
+        this.#batchScheduleFn = options.batchScheduleFn;
+        this.#logger = options.logger ?? defaultLoggersByComponent.batcher;
+        this.#dispatch = options.dispatch;
+    }
+    /**
+     * Queues one entry per item, in order, and returns each item's result and
+     * handle.
+     *
+     * Each entry joins the open automatic batch, or opens a new one when that
+     * batch is full. An item whose signal already aborted is not queued: its
+     * result is rejected with the signal's reason, and it has no handle. The
+     * other items are not affected. After the batcher has closed, it also logs
+     * a warning.
+     */
+    enqueue(items) {
+        if (this.#status === "closed") {
+            this.#logger("batcher", "warn", "enqueue called after close", {
+                itemCount: items.length,
+            });
+        }
+        // Batches that this call opens. Their dispatches are scheduled only once
+        // every entry is in place: a `batchScheduleFn` that runs its callback
+        // synchronously would otherwise dispatch a batch before its entries
+        // joined, and strand them in a dispatched batch.
+        const opened = [];
+        // One call runs at one time, so its entries share it.
+        const enqueuedAt = performanceNow();
+        const enqueued = items.map((item) => {
+            // Like a queued entry that is cancelled, an item that is already
+            // cancelled is rejected, not sent.
+            if (item.signal?.aborted) {
+                const result = Promise.withResolvers();
+                settleResult(result, { ok: false, error: item.signal.reason });
+                return { result: result.promise, handle: undefined };
+            }
+            const { isNew: batchIsNew, batch } = this.#joinableBatch();
+            if (batchIsNew) {
+                // oxlint-disable-next-line zingage/no-restricted-syntax -- Collects the batches that this call opens, in order.
+                opened.push(batch);
+            }
+            const entry = this.#makeEntryInBatch(item, batch, enqueuedAt);
+            return { result: entry.result.promise, handle: entry };
+        });
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Schedules each opened batch for its side effect.
+        opened.forEach((batch) => this.#scheduleDispatch(batch));
+        return enqueued;
+    }
+    #makeEntryInBatch(item, batch, enqueuedAt) {
+        const entry = {
+            item,
+            batch,
+            enqueuedAt,
+            state: "queued",
+            result: Promise.withResolvers(),
+            cleanup: (() => {
+                const { signal } = item;
+                if (!signal)
+                    return undefined;
+                const onAbort = () => {
+                    if (entry.state !== "queued")
+                        return;
+                    this.#settle(entry, { ok: false, error: signal.reason });
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                return () => signal.removeEventListener("abort", onAbort);
+            })(),
+        };
+        // Each entry joins its batch here, so that `batch.entries` and
+        // `batch.queuedCount` agree from the moment `entry.batch` is set. A
+        // separate placement pass would leave a window in which a queued entry has
+        // no batch.
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- The batch owns its entry list, and the entry joins it here.
+        batch.entries.push(entry);
+        batch.queuedCount += 1;
+        return entry;
+    }
+    /**
+     * Dispatches the still-queued entries among `handles`, plus the new
+     * `items`, as one call, which is never split. It skips entries that are
+     * running or settled. A caller can pass handles from other callers'
+     * enqueues, so one dispatch covers all of the work it waits for.
+     *
+     * The new items never wait in a batch, so a `batchScheduleFn` cannot send
+     * them early. An item whose signal already aborted is rejected and not
+     * sent. Returns each item's result, in order. After close, it logs a
+     * warning when it gets items, as `enqueue` does.
+     *
+     * It drops repeated handles, because one call can hold the same handle
+     * more than once: two requests of a call that share one task get the same
+     * handle, and the entry must be sent once.
+     */
+    dispatchNow(handles, items = []) {
+        if (this.#status === "closed" && items.length > 0) {
+            this.#logger("batcher", "warn", "dispatchNow called after close", {
+                itemCount: items.length,
+            });
+        }
+        const results = items.map((it) => ({
+            result: Promise.withResolvers(),
+            signal: it.signal,
+            input: it.input,
+        }));
+        const [immediateItems, abortedItems] = partition(results, ({ signal }) => !signal?.aborted);
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Settles each aborted item for its side effect.
+        abortedItems.forEach(({ signal, result }) => {
+            settleResult(result, { ok: false, error: signal?.reason });
+        });
+        this.#send([
+            ...[...new Set(handles)].map((entry) => ({
+                kind: "entry",
+                entry,
+            })),
+            ...immediateItems.map(({ input, result }) => ({
+                kind: "immediate",
+                input,
+                result,
+            })),
+        ], false);
+        // oxlint-disable-next-line typescript/promise-function-async -- Returns the existing promises; an async wrapper would add new ones.
+        return results.map((r) => r.result.promise);
+    }
+    /**
+     * Dispatches every pending batch now, and drops `batchScheduleFn`, which
+     * the owner may stop during shutdown. Later batches use the default
+     * schedule. The batcher stays open: later enqueues do not warn.
+     */
+    flush() {
+        this.#batchScheduleFn = undefined;
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Dispatches each pending batch for its side effect.
+        this.#pendingBatches.forEach((batch) => batch.dispatch());
+    }
+    /**
+     * Flushes, then resolves when the batcher is idle. Then the batcher is
+     * closed, and later enqueues log a warning. Repeated calls return the same
+     * promise.
+     */
+    // oxlint-disable-next-line typescript/promise-function-async -- Repeated calls must return the same promise.
+    close() {
+        if (this.#closed)
+            return this.#closed;
+        this.#status = "closing";
+        this.flush();
+        this.#closed = this.#drain().then(() => {
+            this.#status = "closed";
+        });
+        return this.#closed;
+    }
+    /**
+     * Waits until no batch is pending and no dispatch is running. It loops
+     * because a dispatch can enqueue more work into this batcher before it
+     * settles, for example a producer that requests other keys from its own
+     * wrapper.
+     */
+    async #drain() {
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Loops until idle, because a dispatch can enqueue more work.
+        while (this.#running.size > 0 || this.#pendingBatches.size > 0) {
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Dispatches each pending batch for its side effect.
+            this.#pendingBatches.forEach((batch) => batch.dispatch());
+            await this.#running.drain();
+        }
+    }
+    /**
+     * Returns the open batch when it has room, as DataLoader's
+     * `getCurrentBatch` does. Otherwise it opens a new batch, and reports it as
+     * new: the caller schedules a new batch's dispatch.
+     */
+    #joinableBatch() {
+        const open = this.#openBatch;
+        if (open && open.queuedCount < this.#maxBatchSize) {
+            return { batch: open, isNew: false };
+        }
+        const dispatch = () => this.#dispatchBatch(batch);
+        const batch = {
+            entries: [],
+            queuedCount: 0,
+            dispatch: this.#preserveAsyncContext
+                ? AsyncLocalStorage.bind(dispatch)
+                : dispatch,
+        };
+        this.#openBatch = batch;
+        this.#pendingBatches.add(batch);
+        return { batch, isNew: true };
+    }
+    /** Schedules a batch's dispatch with `batchScheduleFn`, or the default. */
+    #scheduleDispatch(batch) {
+        const { dispatch } = batch;
+        if (this.#batchScheduleFn)
+            this.#batchScheduleFn(dispatch);
+        // oxlint-disable-next-line no-void -- Schedules the dispatch; nothing awaits it.
+        else
+            void Promise.resolve().then(() => process.nextTick(dispatch));
+    }
+    /**
+     * The only code that changes `entry.state` after `enqueue` creates the
+     * entry. Keep it that way: it keeps `Batch.queuedCount` correct. When the
+     * entry leaves the queued state, it frees the entry's slot in its batch.
+     * From any other state, it only sets the new state.
+     */
+    #setEntryState(entry, state) {
+        if (entry.state === "queued")
+            entry.batch.queuedCount -= 1;
+        entry.state = state;
+    }
+    /**
+     * Marks an entry settled, runs its cleanup, and settles its result with
+     * `outcome`. The outcome is explicit because an error can be any value,
+     * such as an abort reason that is a string.
+     */
+    #settle(entry, outcome) {
+        this.#setEntryState(entry, "settled");
+        entry.cleanup?.();
+        entry.cleanup = undefined;
+        settleResult(entry.result, outcome);
+    }
+    /**
+     * Sends a batch's still-queued entries, once. A batch leaves
+     * `#pendingBatches` only here, so membership marks it undispatched.
+     */
+    #dispatchBatch(batch) {
+        if (!this.#pendingBatches.delete(batch))
+            return;
+        if (this.#openBatch === batch)
+            this.#openBatch = undefined;
+        this.#send(batch.entries.map((entry) => ({ kind: "entry", entry })), true);
+        batch.entries.length = 0;
+    }
+    /**
+     * Sends `selected` as one call, in the current async context. It skips
+     * entries that are no longer queued, and sends every immediate item.
+     * `autoBatched` says whether an automatic batch sends them.
+     */
+    #send(selected, autoBatched) {
+        const toSend = selected.filter((it) => it.kind === "immediate" || it.entry.state === "queued");
+        if (toSend.length === 0)
+            return;
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Settles each sent item for its side effect.
+        toSend.forEach((it) => {
+            if (it.kind === "entry")
+                this.#setEntryState(it.entry, "running");
+        });
+        const settle = (it, outcome) => {
+            if (it.kind === "entry")
+                this.#settle(it.entry, outcome);
+            else
+                settleResult(it.result, outcome);
+        };
+        const now = performanceNow();
+        // oxlint-disable-next-line typescript/promise-function-async -- Promise.try adopts this promise; an async wrapper would delay settling by more microtasks.
+        const run = () => this.#dispatch(toSend.map((it) => it.kind === "entry"
+            ? {
+                input: it.entry.item.input,
+                queueWaitMs: now - it.entry.enqueuedAt,
+            }
+            : { input: it.input, queueWaitMs: 0 }), { autoBatched });
+        // Track the operation before `dispatch` runs. A `dispatch` that calls
+        // `close` synchronously must find this operation in `#running`, or `close`
+        // could resolve before the dispatch settles.
+        // oxlint-disable-next-line no-void -- The tracker keeps the operation for close; nothing else awaits it.
+        void this.#running.run(
+        // oxlint-disable-next-line typescript/promise-function-async -- Promise.try adopts the dispatch promise; an async wrapper would add microtasks.
+        () => Promise.try(run)
+            .then((results) => {
+            assertResultCount(results, toSend.length);
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Settles each sent item for its side effect.
+            toSend.forEach((it, index) => {
+                // oxlint-disable-next-line typescript/no-non-null-assertion -- assertResultCount checked the length. A runtime check would be wrong, because Result can include undefined.
+                const result = results[index];
+                settle(it, result instanceof Error
+                    ? { ok: false, error: result }
+                    : { ok: true, value: result });
+            });
+        })
+            .catch((error) => {
+            const failure = asError(error);
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Settles each sent item for its side effect.
+            toSend.forEach((it) => {
+                settle(it, { ok: false, error: failure });
+            });
+        }));
+    }
+}
+//# sourceMappingURL=batcher.js.map

package/dist/batcher.js.map

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

package/dist/collapsed-task-creator.d.ts

@@ -0,0 +1,235 @@
+/** A task as the creator shows it to `schedule`. */
+export type SharedTaskView<Input> = Readonly<Pick<TaskStart<Input>, "input" | "signal" | "collapsedRequestCount" | "startReason">>;
+type TaskRequest<Input> = {
+    input: Input;
+    signal?: AbortSignal | undefined;
+};
+/** What `startOrRideTasks` returns for one task request. */
+export type TaskRequestOutcome<Result, Handle> = {
+    readonly result: Promise<Result>;
+    /**
+     * The handle of the request's task. Undefined for a request that was
+     * already cancelled, which gets no task.
+     */
+    readonly handle: Handle | undefined;
+    readonly rode: boolean;
+};
+/**
+ * What `startOrRideTasks` returns: one outcome per task request, at the same
+ * position. A tuple of requests gives a tuple of outcomes of the same length.
+ */
+export type TaskRequestOutcomes<Requests extends readonly unknown[], Result, Handle> = {
+    -readonly [K in keyof Requests]: TaskRequestOutcome<Result, Handle>;
+};
+/**
+ * The `schedule` option of a {@link CollapsedTaskCreator}. `context` is the value the
+ * `startOrRideTasks` call passed.
+ */
+export type ScheduleTasks<Input, Result, Handle, Context = void> = (toStart: readonly SharedTaskView<Input>[], context: Context) => readonly Readonly<{
+    result: Promise<Result>;
+    handle: Handle;
+}>[];
+/**
+ * Why a task request started a task instead of riding one:
+ * - `noKey`: `makeKey` returned `undefined`, so the request never shares work.
+ * - `noPendingTask`: no task for its key was pending.
+ * - `pendingTaskTooOld`: the pending task for its key started more than
+ *   `collapseTasksMs` ago.
+ * - `pendingTaskCancelled`: the pending task for its key was cancelled.
+ */
+export type TaskStartReason = "noKey" | "noPendingTask" | "pendingTaskTooOld" | "pendingTaskCancelled";
+/** The parts of a task that exist before its `schedule` call returns. */
+type TaskStart<Input> = {
+    /**
+     * Why the task request that started the task did not ride one. It is for
+     * diagnostics, for example a log line that `schedule` writes.
+     */
+    readonly startReason: TaskStartReason;
+    /**
+     * Compared with `collapseTasksMs`, so no task request rides a task that is
+     * too old.
+     */
+    readonly startedAt: number;
+    /**
+     * The input of the task request that STARTED the task. Task requests that
+     * ride the task never replace it, so per-request labels such as a producer
+     * trigger keep the starting task request's value.
+     */
+    readonly input: Input;
+    /**
+     * Aborts when every request on the task is cancelled. A task request is
+     * cancelled when its own signal aborts. A task request without a signal can
+     * never be cancelled, so it keeps the task's signal from aborting. Its
+     * reason is the signal reason of the last request to be cancelled.
+     *
+     * Undefined when the request that started the task has no signal: the task
+     * can never be cancelled, so it needs no signal, and `schedule` skips any
+     * cancellation work. The converse does not hold. A defined signal can still
+     * never abort, when a later request without a signal makes the task
+     * uncancellable after `schedule` received the signal.
+     *
+     * The lookup in `startOrRideTasks` also reads it, so no request rides a
+     * cancelled task.
+     */
+    readonly signal: AbortSignal | undefined;
+    /**
+     * The number of task requests that have ridden the task so far. Each one is
+     * a request that sharing served without starting new work. The task request
+     * that started the task does not count, and a cancelled rider still does.
+     *
+     * `schedule` receives this object itself, not a copy, so a reader sees
+     * every ride up to the time it reads the field. A call records its rides
+     * only after its `schedule` returns, so `schedule` never sees its own
+     * call's rides. Only the creator writes it: `SharedTaskView` makes it
+     * readonly.
+     */
+    collapsedRequestCount: number;
+};
+/**
+ * Lets requests for the same work share one pending task, with optional
+ * cancellation.
+ *
+ * Imagine you have a function that, when called, kicks off a task, and
+ * returns a promise representing the result of the task. Now, suppose the task
+ * is expensive, but not effectful, like fetching from a REST API. If your code
+ * attempts to run this task many times in quick succession, or many times in
+ * parallel, this can be wasteful (if the result will always or likely be the
+ * same) and/or overload whatever's doing work as part of the task (eg the API).
+ *
+ * There are a large number of npm packages that make it easy to better schedule
+ * this work (e.g., queueing some parallel runs of the task behind others, if
+ * the number of tasks already running exceeds some concurrency limit) or to
+ * reuse the results of some runs of the task for others (by debouncing or
+ * throttling calls to the function that starts the task). However, none of them
+ * have quite the -- admittedly a bit quirky -- semantics that we want, and that
+ * we implement here.
+ *
+ * Specifically, a task request reuses a pending task, instead of starting a
+ * new one, if and only if: 1) its input has the same key as the task's input
+ * [a la memoize]; 2) the task started no more than `collapseTasksMs` ago [a la
+ * throttle]; and 3) the task is still running [unique], and is not cancelled.
+ * In other words, it memoizes task creation, but then reverts to starting a
+ * new task after a certain number of milliseconds or after the last-started
+ * task finishes, whichever is first. So it's sort of a combination of memoize,
+ * throttle, and promise chaining.
+ *
+ * Beyond that collapsing, it adds three things:
+ *
+ * - One `startOrRideTasks` call takes many task requests. Each task request
+ *   either starts a new task or rides a pending task for its input's key. The
+ *   tasks that one call starts are scheduled together, in one `schedule` call,
+ *   so a bulk caller's new inputs become one unit of work. Task requests that
+ *   ride start nothing.
+ * - Each task has an optional AbortSignal that aborts when every request on the
+ *   task is cancelled. `schedule` passes it to whatever runs the work, such as
+ *   a batcher's queue or a producer that supports cancellation. See
+ *   `SharedTaskView.signal`.
+ * - It counts the task requests that ride each task, for diagnostics.
+ *
+ * For the simple case, with one call per task request and no cancellation,
+ * `wrapWithTaskCollapsing` wraps a task-starting function with this class.
+ *
+ * Terms:
+ * - An input is the value that a task's work needs, such as a producer request.
+ *   `makeKey` derives its key.
+ * - A task request is one input plus an optional signal that cancels the task
+ *   request. It is one item of `startOrRideTasks`'s `taskRequests`.
+ * - A task request starts a task or rides one. A task's requests are the task
+ *   request that started it and every task request that rides it.
+ * - A task request is cancelled when its signal aborts. A task is cancelled
+ *   when all of its requests are cancelled.
+ *
+ * The creator itself does not queue, batch or limit work. The `schedule`
+ * callback owns that.
+ *
+ * A task stops being ridable when it settles, when it is cancelled, or when it
+ * started more than `collapseTasksMs` ago. A cancelled task can still be
+ * running, but a new task request must not ride work that is being cancelled.
+ */
+export declare class CollapsedTaskCreator<Input, Result, Handle, Key = string, Context = void> {
+    #private;
+    constructor(options: {
+        /**
+         * A task request rides a pending task for its input's key only if that
+         * task started no more than this many milliseconds ago.
+         */
+        collapseTasksMs: number;
+        /**
+         * Converts an input into the key that decides which pending task its task
+         * request may ride. Return `undefined` for an input that must not share
+         * work with any other, for example because its key cannot be computed.
+         * Its task request then starts its own task, which no task request can
+         * ride. Keys match as `Map` keys do (SameValueZero), so an object key
+         * matches only itself.
+         */
+        makeKey: (input: Input) => Key | undefined;
+        /**
+         * Schedules the tasks that one `startOrRideTasks` call starts, in task
+         * request order, as one unit of work. It returns one entry per task, in
+         * order: the task's result, and an opaque handle that every request on
+         * the task gets back.
+         *
+         * Every call uses this same function. It receives the `context` that the
+         * `startOrRideTasks` call passed, for example to learn how the caller
+         * wants the work run: batched with later calls, or at once. Usually it
+         * only queues the work and arms a flush. A caller that wants the work run
+         * at once then dispatches it, using the handles that `startOrRideTasks`
+         * returns. Those handles also cover the queued tasks the call rode, so
+         * one dispatch can cover all of the call's work.
+         *
+         * A `schedule` that runs work synchronously may call `startOrRideTasks`
+         * again, for example through a producer that reads other keys. See
+         * `startOrRideTasks` for the limit on that.
+         */
+        schedule: ScheduleTasks<Input, Result, Handle, Context>;
+    });
+    /**
+     * Each task request rides a pending task for its input's key, or starts a
+     * new task. Schedules the new tasks with one `schedule` call. When every
+     * task request rides, it does not call `schedule`.
+     *
+     * A task request whose signal is already aborted, or aborts during
+     * `makeKey`, starts and rides nothing. Its `result` rejects with the
+     * signal's reason, and the call's other task requests are not affected.
+     *
+     * It changes no state until `schedule` returns, except that it holds the
+     * tasks it rides. So when `makeKey` throws, `schedule` throws, or
+     * `schedule` returns the wrong number of entries, it releases those tasks,
+     * throws, and changes nothing else. It also holds
+     * each task it starts until it has recorded all of its task requests (see
+     * `Task.hold`).
+     *
+     * The tasks this call starts become ridable only after `schedule`
+     * returns. A `schedule` may call `startOrRideTasks` again, for example by
+     * running a producer that reads other keys. But a nested call that
+     * requests a key this call is starting throws a `SchedulingContractError`:
+     * that request depends on its own result.
+     *
+     * @param taskRequests Each task request's input, and an optional signal
+     *   that cancels the task request.
+     * @param context Passed unchanged to `schedule`, if this call starts any
+     *   task. A nested call passes its own context. A creator whose `schedule`
+     *   needs none keeps the default `Context`, `void`, so its callers omit
+     *   it. TypeScript lets a caller omit a trailing argument only when its
+     *   type accepts `void`; `undefined` does not count.
+     * @returns One entry per task request, in order. `result` is the task's
+     *   shared result. It does not reject when only this task request is
+     *   cancelled, because the task's other requests may still need the
+     *   result; a caller races its own signal. `handle` is the handle that the
+     *   task's `schedule` returned. A caller that wants its work run at once
+     *   can dispatch the still-queued tasks behind these handles, including
+     *   the tasks it rode. It is undefined for a cancelled task request.
+     *   `rode` is true when the task request rode a task that it did not
+     *   start.
+     */
+    startOrRideTasks<const Requests extends readonly Readonly<TaskRequest<Input>>[]>(taskRequests: Requests, context: Context): TaskRequestOutcomes<Requests, Result, Handle>;
+    /**
+     * Waits until every task has settled, including cancelled ones. It loops
+     * because work that settles can start new tasks, for example a producer
+     * that reads other keys. Those tasks join `#live` after the snapshot that
+     * one `allSettled` waits on.
+     */
+    drain(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=collapsed-task-creator.d.ts.map

package/dist/collapsed-task-creator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapsed-task-creator.d.ts","sourceRoot":"","sources":["../src/collapsed-task-creator.ts"],"names":[],"mappings":"AAGA,oDAAoD;AACpD,MAAM,MAAM,cAAc,CAAC,KAAK,IAAI,QAAQ,CAC1C,IAAI,CACF,SAAS,CAAC,KAAK,CAAC,EAChB,OAAO,GAAG,QAAQ,GAAG,uBAAuB,GAAG,aAAa,CAC7D,CACF,CAAC;AAEF,KAAK,WAAW,CAAC,KAAK,IAAI;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;CAAE,CAAC;AAE7E,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,CAAC,MAAM,EAAE,MAAM,IAAI;IAC/C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAC7B,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,MAAM,EACN,MAAM,IACJ;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,QAAQ,GAAG,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC;CAAE,CAAC;AAE5E;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,IAAI,CACjE,OAAO,EAAE,SAAS,cAAc,CAAC,KAAK,CAAC,EAAE,EACzC,OAAO,EAAE,OAAO,KACb,SAAS,QAAQ,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,eAAe,GACf,mBAAmB,GACnB,sBAAsB,CAAC;AAE3B,yEAAyE;AACzE,KAAK,SAAS,CAAC,KAAK,IAAI;IACtB;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC;;;;;;;;;;OAUG;IACH,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAyLF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,qBAAa,oBAAoB,CAC/B,KAAK,EACL,MAAM,EACN,MAAM,EACN,GAAG,GAAG,MAAM,EACZ,OAAO,GAAG,IAAI;;IAwCd,YAAY,OAAO,EAAE;QACnB;;;WAGG;QACH,eAAe,EAAE,MAAM,CAAC;QACxB;;;;;;;WAOG;QACH,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,GAAG,GAAG,SAAS,CAAC;QAC3C;;;;;;;;;;;;;;;;;WAiBG;QACH,QAAQ,EAAE,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;KACzD,EAIA;IAkDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,gBAAgB,CACd,KAAK,CAAC,QAAQ,SAAS,SAAS,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,EAE9D,YAAY,EAAE,QAAQ,EACtB,OAAO,EAAE,OAAO,GACf,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAwO/C;IAED;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAM3B;CACF"}