@zingage/scheduling 1.1.0 → 1.2.0

package/dist/collapsed-task-creator.js

@@ -0,0 +1,491 @@
+import { partition } from "es-toolkit";
+import { SchedulingContractError } from "./scheduling-contract-error.js";
+/**
+ * A task that its `schedule` call has scheduled. Only these tasks are in
+ * `#latestPendingTaskByKey` and `#live`, so a failed `schedule` call leaves no
+ * task behind.
+ */
+class Task {
+    /** The parts of the task that existed before its `schedule` call returned. */
+    start;
+    /**
+     * The handle that the task's `schedule` call returned. `startOrRideTasks`
+     * returns it to every request on the task.
+     */
+    handle;
+    /** The result that the task's `schedule` call returned. */
+    result;
+    /**
+     * Undefined once the task can never be cancelled: from the start when its
+     * starting request has no signal, after a later request without a signal
+     * (see `SharedTaskView.signal`), or once the task settles. In the last two
+     * cases, the task keeps the signal that `schedule` already received, but
+     * nothing can abort it any more.
+     */
+    #cancellation;
+    /**
+     * @param controller The controller whose signal is `start.signal`, or
+     *   undefined when the starting request has no signal.
+     * @param onSettle Called once, when `result` settles, after the task has
+     *   become uncancellable and removed its abort listeners.
+     */
+    constructor(start, controller, { result, handle }, onSettle) {
+        this.start = start;
+        this.#cancellation = controller && {
+            controller,
+            uncancelledRequests: 0,
+            lastCancelReason: undefined,
+            abortListeners: [],
+        };
+        this.handle = handle;
+        this.result = result;
+        // Handling both outcomes also marks a rejection as handled: every task
+        // request may be cancelled before anyone awaits the result.
+        const settle = () => {
+            this.#makeUncancelable();
+            onSettle();
+        };
+        // oxlint-disable-next-line no-void -- Runs settle bookkeeping; callers await the result themselves.
+        void result.then(settle, settle);
+    }
+    /**
+     * Keeps the task's signal from aborting until `release`, even if every
+     * request on the task is cancelled meanwhile. `startOrRideTasks` holds each
+     * task it starts or rides until it has recorded all of its requests, so a
+     * cancellation during `schedule`, or during another task's abort, cannot
+     * cancel a task that a request of the call will keep alive.
+     *
+     * A hold counts as one uncancelled request. Holds can nest, because a
+     * nested `startOrRideTasks` call can ride a task that an outer call holds.
+     * It is inert on an uncancellable task, which has no signal to abort.
+     */
+    hold() {
+        if (this.#cancellation)
+            this.#cancellation.uncancelledRequests += 1;
+    }
+    /**
+     * Ends one `hold`. Aborts the task's signal if no request keeps the task
+     * alive. Like `hold`, it is inert on an uncancellable task.
+     */
+    release() {
+        const cancellation = this.#cancellation;
+        if (cancellation === undefined)
+            return;
+        cancellation.uncancelledRequests -= 1;
+        if (cancellation.uncancelledRequests === 0) {
+            cancellation.controller.abort(cancellation.lastCancelReason);
+        }
+    }
+    /**
+     * Records a task request on this task, whether the request started the
+     * task or rides it. `signal` and `rode` are the request's. Call it only
+     * while holding the task: a request whose signal already aborted is not
+     * counted, so only `release` can abort the task for it.
+     */
+    addRequest(signal, rode) {
+        if (rode)
+            this.start.collapsedRequestCount += 1;
+        // An uncancellable task needs no count: no task request can cancel it.
+        const cancellation = this.#cancellation;
+        if (cancellation === undefined)
+            return;
+        // A request w/o a signal can never be cancelled, so neither can the task.
+        if (signal === undefined) {
+            this.#makeUncancelable();
+            return;
+        }
+        // `schedule` runs user code, so a signal can abort after `startOrRideTasks`
+        // checked it.
+        if (signal.aborted) {
+            cancellation.lastCancelReason = signal.reason;
+            return;
+        }
+        cancellation.uncancelledRequests += 1;
+        const listener = () => {
+            cancellation.lastCancelReason = signal.reason;
+            this.release();
+        };
+        signal.addEventListener("abort", listener, { once: true });
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- The task owns its listener list, and removes every listener later.
+        cancellation.abortListeners.push([signal, listener]);
+    }
+    /**
+     * Clears `#cancellation`, and removes its abort listeners, which can no
+     * longer abort the task. Calling it again does nothing.
+     */
+    #makeUncancelable() {
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Removes each listener for its side effect.
+        this.#cancellation?.abortListeners.forEach(([signal, listener]) => {
+            signal.removeEventListener("abort", listener);
+        });
+        this.#cancellation = undefined;
+    }
+}
+/**
+ * Builds a task's start, and the controller that aborts its signal. The
+ * controller stays out of the start because `schedule` receives the start,
+ * and only the task may abort its own signal.
+ */
+function newTaskStart(input, cancellable, now, startReason) {
+    const controller = cancellable ? new AbortController() : undefined;
+    return {
+        start: {
+            startReason,
+            startedAt: now,
+            input,
+            signal: controller?.signal,
+            collapsedRequestCount: 0,
+        },
+        controller,
+    };
+}
+/**
+ * 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 class CollapsedTaskCreator {
+    #collapseTasksMs;
+    #makeKey;
+    #schedule;
+    /**
+     * For each key, the newest pending task: the task that a new task request
+     * for that key rides, unless it is too old or cancelled. A cancelled task
+     * stays here until it settles or a newer task replaces it; the lookup in
+     * `startOrRideTasks` checks its signal, so no request rides it. A newer
+     * task replaces an older one whose start is outside `collapseTasksMs`, or
+     * a cancelled one; the replaced task keeps running, tracked only in
+     * `#live`.
+     */
+    #latestPendingTaskByKey = new Map();
+    /**
+     * Every task that has not settled. `#latestPendingTaskByKey` leaves out two
+     * kinds of unsettled task: tasks with no key, and tasks that a newer task
+     * replaced. `drain` must still wait for all of them.
+     */
+    #live = new Set();
+    /**
+     * The keys of the tasks that a running `schedule` call is starting. Those
+     * tasks enter `#latestPendingTaskByKey` only after `schedule` returns. So
+     * when `schedule` runs a producer synchronously, and that producer requests
+     * its own key, a nested call could not ride the task and would start it
+     * again, without end. The nested call throws instead.
+     *
+     * Tasks with no key are never reserved, because nothing can ride them. A
+     * key stays here only while its `schedule` call runs. The set holds keys
+     * from several calls only while `schedule` calls nest, with different keys.
+     */
+    #schedulingKeys = new Set();
+    constructor(options) {
+        this.#collapseTasksMs = options.collapseTasksMs;
+        this.#makeKey = options.makeKey;
+        this.#schedule = options.schedule;
+    }
+    /**
+     * Finds the pending task that a task request for `key` may ride, or says
+     * why there is none. A task that is both too old and cancelled reports
+     * `pendingTaskTooOld`.
+     */
+    #findRidable(now, key) {
+        const existing = this.#latestPendingTaskByKey.get(key);
+        if (!existing)
+            return { startReason: "noPendingTask" };
+        const { signal, startedAt } = existing.start;
+        if (now - startedAt > this.#collapseTasksMs) {
+            return { startReason: "pendingTaskTooOld" };
+        }
+        if (signal?.aborted)
+            return { startReason: "pendingTaskCancelled" };
+        return { ride: existing };
+    }
+    #setupNewTask(start, controller, scheduleResult, key) {
+        const task = new Task(start, controller, scheduleResult, () => {
+            this.#live.delete(task);
+            // Only remove this task if the map still holds it for its key. The map
+            // could hold a newer one if this task was replaced for being too old or
+            // cancelled.
+            if (key !== undefined && this.#latestPendingTaskByKey.get(key) === task) {
+                this.#latestPendingTaskByKey.delete(key);
+            }
+        });
+        this.#live.add(task);
+        // If the key is defined, this task can be the existing pending task
+        // for future requests with the same key, so register it.
+        if (key !== undefined) {
+            this.#latestPendingTaskByKey.set(key, task);
+        }
+        return task;
+    }
+    /**
+     * 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(taskRequests, context) {
+        // A cancelled task request needs no key. Signals are read again after
+        // every key: `makeKey` is user code and may abort a signal.
+        const keys = taskRequests.map(({ input, signal }) => signal?.aborted ? undefined : this.#makeKey(input));
+        // A cancelled task request starts and rides nothing, and gets only its
+        // own rejection. The split happens once, here, so that a later abort
+        // cannot change which requests this call treats as cancelled.
+        const [cancelled, live] = partition(taskRequests.map((request, i) => ({ request, i, key: keys[i] })), ({ request: { signal } }) => signal?.aborted === true);
+        if (live.some(({ key }) => key !== undefined && this.#schedulingKeys.has(key))) {
+            throw new SchedulingContractError("schedule requested a key that it is starting a task for");
+        }
+        // Group. Requests with the same key share one task, so each group
+        // is one task that this call touches.
+        const requestsByKey = Map.groupBy(live, ({ key }) => key);
+        // Decide. Each group rides the pending task for its key, or starts
+        // a new task. The group's first request decides, as if it came alone.
+        const now = Date.now();
+        const decisions = requestsByKey
+            .entries()
+            .flatMap(([key, reqs]) => {
+            if (key === undefined) {
+                return reqs.map(({ request: { input, signal }, i }) => ({
+                    type: "START",
+                    key: undefined,
+                    ...newTaskStart(input, signal !== undefined, now, "noKey"),
+                    indexes: [i],
+                }));
+            }
+            const ridableLookup = this.#findRidable(now, key);
+            if ("ride" in ridableLookup) {
+                return [
+                    {
+                        type: "RIDE",
+                        task: ridableLookup.ride,
+                        indexes: reqs.map(({ i }) => i),
+                    },
+                ];
+            }
+            // oxlint-disable-next-line typescript/no-non-null-assertion -- Map.groupBy never creates an empty group.
+            const { input, signal } = reqs[0].request;
+            return [
+                {
+                    type: "START",
+                    key,
+                    ...newTaskStart(input, signal !== undefined, now, ridableLookup.startReason),
+                    indexes: reqs.map(({ i }) => i),
+                },
+            ];
+        })
+            // Map.groupBy puts every request with no key in one group, at the
+            // position of the first one. Sort by first request, so that `schedule`
+            // receives the started tasks in task request order.
+            .toArray()
+            .toSorted((a, b) => a.indexes[0] - b.indexes[0]);
+        // Schedule the new tasks.
+        const startDecisions = decisions.filter((d) => d.type === "START");
+        const taskStarts = startDecisions.map((d) => d.start);
+        // Every task this call touches, held as `Task.hold` describes: the
+        // ridden tasks now, and each started task when its requests are
+        // recorded. All releases wait until the end, because a release can abort
+        // a task and run user code.
+        const heldTasks = new Set(decisions.filter((d) => d.type === "RIDE").map((d) => d.task));
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Holds each task for its side effect.
+        heldTasks.forEach((task) => task.hold());
+        try {
+            // Reserve keys for the tasks we're about to schedule (to prevent
+            // infinite loop on re-entrant calls).
+            const scheduled = (() => {
+                if (taskStarts.length === 0) {
+                    return [];
+                }
+                const scheduledKeys = new Set(startDecisions.map((d) => d.key).filter((key) => key !== undefined));
+                // oxlint-disable-next-line zingage/no-restricted-syntax -- Reserves each key for its side effect.
+                scheduledKeys.forEach((key) => this.#schedulingKeys.add(key));
+                try {
+                    return this.#schedule(taskStarts, context);
+                }
+                finally {
+                    // Free the keys before any release: a release can abort a
+                    // task, and its abort listeners may request those keys, which are
+                    // ridable by then.
+                    // oxlint-disable-next-line zingage/no-restricted-syntax -- Frees each key for its side effect.
+                    scheduledKeys.forEach((key) => this.#schedulingKeys.delete(key));
+                }
+            })();
+            if (scheduled.length !== taskStarts.length) {
+                throw new SchedulingContractError("schedule must return one scheduled task per task to start");
+            }
+            // Create a Task for each new task, and set up the initial bookkeeping
+            // for it. The map lets the record loop below, which walks RIDE and
+            // START decisions interleaved, find each START's new task.
+            const newTasksByStartDecision = new Map(startDecisions.map((startDecision, i) => {
+                const { start, controller, key } = startDecision;
+                const task = this.#setupNewTask(start, controller, 
+                // oxlint-disable-next-line typescript/no-non-null-assertion -- The length check above guarantees one entry per start decision.
+                scheduled[i], key);
+                return [start, task];
+            }));
+            // Record every request on its task, and build one entry per
+            // request, back in request order. Every request in a ridden group
+            // rode; in a started group, only the first did not.
+            const result = Array(taskRequests.length);
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Fills each cancelled request's result slot.
+            cancelled.forEach(({ request: { signal }, i }) => {
+                // An aborted signal's reason never changes.
+                // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- Rejects with the signal's abort reason, which can be any value.
+                const rejected = Promise.reject(signal?.reason);
+                // A caller may never await it.
+                // oxlint-disable-next-line no-void -- Marks the rejection handled; the caller still gets the rejected promise.
+                void rejected.catch(() => { });
+                result[i] = { result: rejected, handle: undefined, rode: false };
+            });
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Records each decision's requests for their side effects.
+            decisions.forEach((d) => {
+                switch (d.type) {
+                    case "RIDE": {
+                        const outcome = {
+                            result: d.task.result,
+                            handle: d.task.handle,
+                            rode: true,
+                        };
+                        // oxlint-disable-next-line zingage/no-restricted-syntax -- Records each request on its task for its side effect.
+                        d.indexes.forEach((reqIdx) => {
+                            // NB: task is still held from before schedule()
+                            // oxlint-disable-next-line typescript/no-non-null-assertion -- Each index comes from taskRequests.
+                            d.task.addRequest(taskRequests[reqIdx].signal, true);
+                            result[reqIdx] = outcome;
+                        });
+                        break;
+                    }
+                    case "START": {
+                        // oxlint-disable-next-line typescript/no-non-null-assertion -- The map holds a task for every start decision.
+                        const task = newTasksByStartDecision.get(d.start);
+                        // See `heldTasks`. Redundant when the key is undefined: that task
+                        // has exactly one request, and nothing can ride it.
+                        task.hold();
+                        heldTasks.add(task);
+                        // oxlint-disable-next-line zingage/no-restricted-syntax -- Records each request on its task for its side effect.
+                        d.indexes.forEach((reqIdx, i) => {
+                            const rode = i > 0;
+                            // oxlint-disable-next-line typescript/no-non-null-assertion -- Each index comes from taskRequests.
+                            task.addRequest(taskRequests[reqIdx].signal, rode);
+                            result[reqIdx] = {
+                                result: task.result,
+                                handle: task.handle,
+                                rode,
+                            };
+                        });
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unexpected decision: ${String(d)}`);
+                }
+            });
+            // The loop above fills every position of `result`, one per task
+            // request, but TS can't prove that it matches the mapped tuple type.
+            return result;
+        }
+        finally {
+            // oxlint-disable-next-line zingage/no-restricted-syntax -- Releases each task for its side effect.
+            heldTasks.forEach((task) => task.release());
+        }
+    }
+    /**
+     * 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.
+     */
+    async drain() {
+        // oxlint-disable-next-line zingage/no-restricted-syntax -- Loops until no task is live, because settling work can start new tasks.
+        while (this.#live.size > 0) {
+            // oxlint-disable-next-line typescript/promise-function-async -- Passes the existing promises; an async wrapper adds nothing.
+            await Promise.allSettled([...this.#live].map((task) => task.result));
+        }
+    }
+}
+//# sourceMappingURL=collapsed-task-creator.js.map

package/dist/collapsed-task-creator.js.map

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

package/dist/index.d.ts

@@ -1,4 +1,10 @@
 export { waitFor, timeSlicedFilter, timeSlicedFlatMap, timeSlicedForEach, timeSlicedGroupBy, timeSlicedMap, timeSlicedMapFromEntries, TimeSliceBudget, } from "./time-slicing.js";
 export { timeSlicedSort } from "./time-sliced-sort.js";
 export { timeSlicedFind, timeSlicedSome } from "./time-sliced-search.js";
+export { CollapsedTaskCreator, type ScheduleTasks, type SharedTaskView, type TaskRequestOutcome, type TaskRequestOutcomes, type TaskStartReason, } from "./collapsed-task-creator.js";
+export { wrapWithTaskCollapsing } from "./wrap-with-task-collapsing.js";
+export { Batcher, DEFAULT_MAX_BATCH_SIZE, type BatchHandle, type BatchItem, type BatchOptions, type DispatchedItem, type DispatchInfo, type Enqueued, } from "./batcher.js";
+export { PendingPromisesTracker } from "./pending-promises-tracker.js";
+export { SchedulingContractError } from "./scheduling-contract-error.js";
+export type { Logger, SchedulingComponentName } from "./logger.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EACL,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EACL,OAAO,EACP,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,QAAQ,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,YAAY,EAAE,MAAM,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -1,4 +1,9 @@
 export { waitFor, timeSlicedFilter, timeSlicedFlatMap, timeSlicedForEach, timeSlicedGroupBy, timeSlicedMap, timeSlicedMapFromEntries, TimeSliceBudget, } from "./time-slicing.js";
 export { timeSlicedSort } from "./time-sliced-sort.js";
 export { timeSlicedFind, timeSlicedSome } from "./time-sliced-search.js";
+export { CollapsedTaskCreator, } from "./collapsed-task-creator.js";
+export { wrapWithTaskCollapsing } from "./wrap-with-task-collapsing.js";
+export { Batcher, DEFAULT_MAX_BATCH_SIZE, } from "./batcher.js";
+export { PendingPromisesTracker } from "./pending-promises-tracker.js";
+export { SchedulingContractError } from "./scheduling-contract-error.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EACL,oBAAoB,GAMrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EACL,OAAO,EACP,sBAAsB,GAOvB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/logger.d.ts

@@ -0,0 +1,16 @@
+/** The components in this package that write log lines. */
+export type SchedulingComponentName = "batcher" | "collapsed-task-creator";
+/**
+ * The signature of a custom log function. `Batcher` and
+ * `wrapWithTaskCollapsing` accept one, and call it when they log a message.
+ *
+ * A logger that accepts more component names, such as a logger shared with
+ * other packages, is also a valid `Logger`.
+ */
+export type Logger = (component: SchedulingComponentName, level: "trace" | "debug" | "info" | "warn" | "error" | "fatal", message: string, data?: unknown) => void;
+/** The default logger of each component. */
+export declare const defaultLoggersByComponent: {
+    batcher: Logger;
+    "collapsed-task-creator": Logger;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,2DAA2D;AAC3D,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,wBAAwB,CAAC;AAE3E;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,CACnB,SAAS,EAAE,uBAAuB,EAClC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,EAC9D,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,KACX,IAAI,CAAC;AAUV,4CAA4C;AAC5C,eAAO,MAAM,yBAAyB;;;CAGa,CAAC"}

package/dist/logger.js

@@ -0,0 +1,14 @@
+import { default as debug } from "debug";
+/** A logger that writes to the `debug` namespace `@zingage/scheduling:<name>`. */
+function debugLogger(name) {
+    const write = debug(`@zingage/scheduling:${name}`);
+    return (_, level, message, data) => {
+        write(`(${level}) ${message} %O`, data);
+    };
+}
+/** The default logger of each component. */
+export const defaultLoggersByComponent = {
+    batcher: debugLogger("batcher"),
+    "collapsed-task-creator": debugLogger("collapsed-task-creator"),
+};
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,OAAO,CAAC;AAmBzC,kFAAkF;AAClF,SAAS,WAAW,CAAC,IAA6B;IAChD,MAAM,KAAK,GAAG,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAC;IACnD,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACjC,KAAK,CAAC,IAAI,KAAK,KAAK,OAAO,KAAK,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC,CAAC;AACJ,CAAC;AAED,4CAA4C;AAC5C,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC;IAC/B,wBAAwB,EAAE,WAAW,CAAC,wBAAwB,CAAC;CACd,CAAC"}

package/dist/pending-promises-tracker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tracks promises until they settle, so that an owner's `close` can wait for
+ * the work it accepted.
+ *
+ * Each tracked promise leaves the tracker when it settles. Tracking never
+ * creates an unhandled rejection: the tracker observes a rejection, but the
+ * caller still owns the promise and its rejection.
+ *
+ * The tracker has no closed state. Each owner decides what new work does
+ * after its own `close` starts, and in what order it drains its trackers.
+ */
+export declare class PendingPromisesTracker {
+    #private;
+    /** The number of tracked promises that have not settled yet. */
+    get size(): number;
+    /** Tracks `promise` until it settles, and returns it unchanged. */
+    track<T>(promise: Promise<T>): Promise<T>;
+    /**
+     * Calls `start` and tracks its result. The promise is tracked before
+     * `start` runs, so a `drain` that `start` itself triggers synchronously
+     * still waits for it. A synchronous throw from `start` becomes a rejection.
+     */
+    run<T>(start: () => Promise<T>): Promise<T>;
+    /**
+     * Resolves once no tracked promise is pending, including promises tracked
+     * while it waits. It loops because settling work can start more work, for
+     * example a producer that reads other keys from its own wrapper. It never
+     * rejects.
+     */
+    drain(): Promise<void>;
+}
+//# sourceMappingURL=pending-promises-tracker.d.ts.map

package/dist/pending-promises-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-promises-tracker.d.ts","sourceRoot":"","sources":["../src/pending-promises-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;;IAGjC,gEAAgE;IAChE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,mEAAmE;IAEnE,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAQxC;IAED;;;;OAIG;IAEH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAU1C;IAED;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAK3B;CACF"}