enqiu 0.1.0

package/dist/memory.js

@@ -0,0 +1,1201 @@
+export class JobFailedError extends Error {
+    jobId;
+    constructor(jobId, message, options) {
+        super(message, options);
+        this.name = "JobFailedError";
+        this.jobId = jobId;
+    }
+}
+export class JobCancelledError extends Error {
+    jobId;
+    constructor(jobId, message = "Job was cancelled") {
+        super(message);
+        this.name = "JobCancelledError";
+        this.jobId = jobId;
+    }
+}
+export class JobTimeoutError extends Error {
+    jobId;
+    timeout;
+    constructor(jobId, timeout) {
+        super(`Job "${jobId}" timed out after ${timeout}ms`);
+        this.name = "JobTimeoutError";
+        this.jobId = jobId;
+        this.timeout = timeout;
+    }
+}
+export class JobExpiredError extends Error {
+    jobId;
+    constructor(jobId) {
+        super(`Job "${jobId}" expired before it could start`);
+        this.name = "JobExpiredError";
+        this.jobId = jobId;
+    }
+}
+export class QueueClosedError extends Error {
+    constructor(name) {
+        super(`Queue "${name}" is closed`);
+        this.name = "QueueClosedError";
+    }
+}
+class JobHandle {
+    owner;
+    job;
+    deduplicated;
+    constructor(owner, job, deduplicated) {
+        this.owner = owner;
+        this.job = job;
+        this.deduplicated = deduplicated;
+    }
+    get id() {
+        return this.job.id;
+    }
+    get name() {
+        return this.job.name;
+    }
+    get input() {
+        return this.job.input;
+    }
+    get status() {
+        return this.job.status;
+    }
+    get result() {
+        return this.owner.resultFor(this.job);
+    }
+    get accepted() {
+        return Promise.resolve();
+    }
+    cancel(reason) {
+        return this.owner.cancel(this.id, reason);
+    }
+    snapshot() {
+        return snapshot(this.job);
+    }
+    then(onFulfilled, onRejected) {
+        return this.result.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.result.catch(onRejected);
+    }
+    finally(onFinally) {
+        return this.result.finally(onFinally ?? undefined);
+    }
+}
+/**
+ * A zero-dependency, single-process job queue with strongly typed named jobs.
+ *
+ * State is intentionally kept in memory. MemoryQueue is ideal for local background
+ * work, concurrency control, API throttling, and tests. It is not durable or
+ * distributed; use a database-backed queue when jobs must survive restarts.
+ */
+export class MemoryQueue {
+    name;
+    handlers;
+    records = new Map();
+    keys = new Map();
+    activeKeys = new Map();
+    throttleStates = new Map();
+    debounceStates = new Map();
+    ready = new BinaryHeap(readyBefore);
+    delayed = new BinaryHeap(delayedBefore);
+    listeners = new Map();
+    defaultRetry;
+    defaultTimeout;
+    rateLimit;
+    historyLimit;
+    logLimit;
+    starts = [];
+    idleWaiters = new Set();
+    sizeWaiters = new Set();
+    _concurrency;
+    runningCount = 0;
+    sequence = 0;
+    started;
+    closed = false;
+    idleNotified = true;
+    pumpQueued = false;
+    timer;
+    policyWakeAt;
+    constructor(handlers, options = {}) {
+        if (Object.keys(handlers).length === 0) {
+            throw new TypeError("At least one job handler is required");
+        }
+        this.name = options.name?.trim() || "default";
+        this._concurrency = options.concurrency ?? Number.POSITIVE_INFINITY;
+        this.defaultRetry = normalizeRetry(options.retry);
+        this.defaultTimeout = options.timeout;
+        this.rateLimit = options.rateLimit;
+        this.historyLimit = options.historyLimit ?? 1000;
+        this.logLimit = options.logLimit ?? 100;
+        this.started = options.autoStart ?? true;
+        this.handlers = handlers;
+        validatePositiveIntegerOrInfinity("concurrency", this._concurrency);
+        validateTimeout(this.defaultTimeout);
+        validateHistoryLimit(this.historyLimit);
+        validateHistoryLimit(this.logLimit);
+        if (this.rateLimit) {
+            validatePositiveInteger("rateLimit.limit", this.rateLimit.limit);
+            validatePositiveNumber("rateLimit.interval", this.rateLimit.interval);
+        }
+    }
+    get concurrency() {
+        return this._concurrency;
+    }
+    set concurrency(value) {
+        validatePositiveIntegerOrInfinity("concurrency", value);
+        this._concurrency = value;
+        this.requestPump();
+    }
+    /** Jobs waiting to start, including scheduled jobs. */
+    get size() {
+        let count = 0;
+        for (const job of this.records.values()) {
+            if (job.status === "queued" || job.status === "scheduled") {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    /** Jobs currently running. */
+    get pending() {
+        return this.runningCount;
+    }
+    get isPaused() {
+        return !this.started && !this.closed;
+    }
+    get isRateLimited() {
+        if (!this.rateLimit || this.size === 0) {
+            return false;
+        }
+        this.pruneStarts(Date.now());
+        return this.starts.length >= this.rateLimit.limit;
+    }
+    get isSaturated() {
+        return (this.size > 0 &&
+            (this.runningCount >= this._concurrency || this.isRateLimited));
+    }
+    get stats() {
+        const value = {
+            queued: 0,
+            scheduled: 0,
+            running: 0,
+            succeeded: 0,
+            failed: 0,
+            cancelled: 0,
+            expired: 0,
+            total: 0,
+        };
+        for (const job of this.records.values()) {
+            value[job.status] += 1;
+            value.total += 1;
+        }
+        return value;
+    }
+    add(name, input, options = {}) {
+        this.assertOpen();
+        const handler = this.handlers[name];
+        if (typeof handler !== "function") {
+            throw new TypeError(`Unknown job "${name}"`);
+        }
+        const now = Date.now();
+        this.prunePolicyState(now);
+        validateExecutionOptions(options);
+        const key = options.key ? `${String(name)}:${options.key}` : undefined;
+        if (key) {
+            const existing = this.keys.get(key);
+            if (existing) {
+                if (!isTerminal(existing.status) ||
+                    (existing.keyExpiresAt !== undefined &&
+                        existing.keyExpiresAt > now)) {
+                    return this.handle(existing, true);
+                }
+                this.keys.delete(key);
+            }
+        }
+        const debounceKey = options.debounce
+            ? `${String(name)}:${options.debounce.key}`
+            : undefined;
+        const debounceState = debounceKey
+            ? this.debounceStates.get(debounceKey)
+            : undefined;
+        if (debounceState && options.debounce) {
+            if (options.debounce.mode === "leading" &&
+                debounceState.until > now) {
+                return this.handle(debounceState.job, true);
+            }
+            if (options.debounce.mode === "trailing" &&
+                (debounceState.job.status === "queued" ||
+                    debounceState.job.status === "scheduled")) {
+                this.updateTrailingDebounce(debounceState, input, options, now);
+                return this.handle(debounceState.job, true);
+            }
+        }
+        const id = options.id ?? this.createId(String(name), now);
+        if (!id) {
+            throw new TypeError("Job ID must not be empty");
+        }
+        if (this.records.has(id)) {
+            throw new Error(`Job ID "${id}" already exists`);
+        }
+        const requestedRunAt = normalizeRunAt(options.delay, now);
+        const runAt = options.debounce?.mode === "trailing"
+            ? Math.max(requestedRunAt, now + options.debounce.wait)
+            : requestedRunAt;
+        const priority = options.priority ?? 0;
+        const retry = options.retry === undefined
+            ? this.defaultRetry
+            : normalizeRetry(options.retry);
+        const timeout = options.timeout ?? this.defaultTimeout;
+        const expiresAt = options.expiresIn === undefined ? undefined : now + options.expiresIn;
+        if (!Number.isFinite(priority)) {
+            throw new RangeError("priority must be a finite number");
+        }
+        validateTimeout(timeout);
+        if (options.expiresIn !== undefined) {
+            validatePositiveNumber("expiresIn", options.expiresIn);
+        }
+        const job = {
+            id,
+            name: String(name),
+            input,
+            status: runAt > now ? "scheduled" : "queued",
+            priority,
+            attempt: 0,
+            retry,
+            timeout,
+            key,
+            keyRetention: options.keyRetention ?? 0,
+            keyExpiresAt: undefined,
+            concurrency: options.concurrency,
+            throttle: options.throttle,
+            debounceKey,
+            createdAt: now,
+            runAt,
+            expiresAt,
+            startedAt: undefined,
+            finishedAt: undefined,
+            progress: undefined,
+            output: undefined,
+            error: undefined,
+            errorCause: undefined,
+            logs: [],
+            sequence: this.sequence++,
+            controller: undefined,
+            completion: deferred(),
+            externalSignal: options.signal,
+            abortListener: undefined,
+        };
+        this.records.set(id, job);
+        this.idleNotified = false;
+        if (key) {
+            this.keys.set(key, job);
+        }
+        if (debounceKey && options.debounce) {
+            this.debounceStates.set(debounceKey, {
+                job,
+                until: now + options.debounce.wait,
+                mode: options.debounce.mode,
+            });
+        }
+        if (job.status === "scheduled") {
+            this.delayed.push(job);
+        }
+        else {
+            this.ready.push(job);
+        }
+        this.emit("added", snapshot(job));
+        this.connectSignal(job);
+        this.notifySizeWaiters();
+        this.requestPump();
+        return this.handle(job, false);
+    }
+    updateTrailingDebounce(state, input, options, now) {
+        const job = state.job;
+        this.ready.remove(job);
+        this.delayed.remove(job);
+        this.disconnectSignal(job);
+        job.input = input;
+        job.status = "scheduled";
+        job.priority = options.priority ?? job.priority;
+        job.retry =
+            options.retry === undefined
+                ? job.retry
+                : normalizeRetry(options.retry);
+        job.timeout = options.timeout ?? job.timeout;
+        job.runAt = Math.max(normalizeRunAt(options.delay, now), now + (options.debounce?.wait ?? 0));
+        job.expiresAt =
+            options.expiresIn === undefined ? undefined : now + options.expiresIn;
+        job.concurrency = options.concurrency;
+        job.throttle = options.throttle;
+        job.sequence = this.sequence++;
+        job.externalSignal = options.signal;
+        state.until = now + (options.debounce?.wait ?? 0);
+        this.delayed.push(job);
+        this.connectSignal(job);
+        this.emit("added", snapshot(job));
+        this.requestPump();
+    }
+    addMany(name, inputs, options) {
+        return inputs.map((input) => this.add(name, input, options));
+    }
+    get(id) {
+        const job = this.records.get(id);
+        return job ? snapshot(job) : undefined;
+    }
+    list(status) {
+        const jobs = [];
+        for (const job of this.records.values()) {
+            if (!status || job.status === status) {
+                jobs.push(snapshot(job));
+            }
+        }
+        return jobs.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    cancel(id, reason = "Job was cancelled") {
+        const job = this.records.get(id);
+        if (!job || isTerminal(job.status)) {
+            return false;
+        }
+        const error = new JobCancelledError(id, reason);
+        job.status = "cancelled";
+        job.finishedAt = Date.now();
+        job.error = serializeError(error);
+        job.errorCause = error;
+        job.controller?.abort(error);
+        this.finish(job, "cancelled");
+        this.notifySizeWaiters();
+        this.requestPump();
+        return true;
+    }
+    clear(reason = "Queue was cleared") {
+        let count = 0;
+        for (const job of this.records.values()) {
+            if ((job.status === "queued" || job.status === "scheduled") &&
+                this.cancel(job.id, reason)) {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    retry(id) {
+        this.assertOpen();
+        const job = this.records.get(id);
+        if (!job ||
+            (job.status !== "failed" &&
+                job.status !== "cancelled" &&
+                job.status !== "expired")) {
+            return undefined;
+        }
+        job.status = "queued";
+        job.attempt = 0;
+        job.runAt = Date.now();
+        job.expiresAt = undefined;
+        job.startedAt = undefined;
+        job.finishedAt = undefined;
+        job.progress = undefined;
+        job.output = undefined;
+        job.error = undefined;
+        job.errorCause = undefined;
+        job.logs = [];
+        job.sequence = this.sequence++;
+        job.controller = undefined;
+        job.completion = deferred();
+        this.idleNotified = false;
+        if (job.key) {
+            this.keys.set(job.key, job);
+        }
+        this.ready.push(job);
+        this.connectSignal(job);
+        this.notifySizeWaiters();
+        this.requestPump();
+        return this.handle(job, false);
+    }
+    pause() {
+        this.assertOpen();
+        this.started = false;
+        this.clearTimer();
+        return this;
+    }
+    start() {
+        this.assertOpen();
+        this.started = true;
+        this.requestPump();
+        return this;
+    }
+    async onIdle() {
+        if (this.size === 0 && this.runningCount === 0) {
+            return;
+        }
+        await new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    async onSizeLessThan(limit) {
+        if (!Number.isInteger(limit) || limit < 1) {
+            throw new RangeError("limit must be a positive integer");
+        }
+        if (this.size < limit) {
+            return;
+        }
+        await new Promise((resolve) => this.sizeWaiters.add({ limit, resolve }));
+    }
+    cleanup(options = {}) {
+        const olderThan = options.olderThan ?? 0;
+        const limit = options.limit ?? Number.POSITIVE_INFINITY;
+        if (!Number.isFinite(olderThan) || olderThan < 0) {
+            throw new RangeError("olderThan must be a non-negative finite number");
+        }
+        if ((!Number.isInteger(limit) && limit !== Number.POSITIVE_INFINITY) ||
+            limit < 0) {
+            throw new RangeError("limit must be a non-negative integer or Infinity");
+        }
+        const threshold = Date.now() - olderThan;
+        const removed = [];
+        for (const [id, job] of this.records) {
+            if (removed.length >= limit ||
+                !isTerminal(job.status) ||
+                (job.finishedAt ?? Number.POSITIVE_INFINITY) > threshold) {
+                continue;
+            }
+            this.records.delete(id);
+            removed.push(id);
+        }
+        return removed;
+    }
+    async close(options = {}) {
+        if (this.closed) {
+            return;
+        }
+        if (options.drain ?? true) {
+            this.started = true;
+            this.requestPump();
+            await this.onIdle();
+        }
+        else {
+            this.clear("Queue closed");
+            for (const job of this.records.values()) {
+                if (job.status === "running") {
+                    this.cancel(job.id, "Queue closed");
+                }
+            }
+            if (this.runningCount > 0) {
+                await new Promise((resolve) => this.idleWaiters.add(resolve));
+            }
+        }
+        this.started = false;
+        this.closed = true;
+        this.clearTimer();
+    }
+    on(event, listener) {
+        let group = this.listeners.get(event);
+        if (!group) {
+            group = new Set();
+            this.listeners.set(event, group);
+        }
+        group.add(listener);
+        return () => {
+            group?.delete(listener);
+        };
+    }
+    /** @internal Used by the awaitable job handle. */
+    async resultFor(job) {
+        const result = isTerminal(job.status)
+            ? snapshot(job)
+            : await job.completion.promise;
+        if (result.status === "succeeded") {
+            return result.output;
+        }
+        if (result.status === "cancelled") {
+            throw new JobCancelledError(job.id, result.error?.message);
+        }
+        if (result.status === "expired") {
+            throw new JobExpiredError(job.id);
+        }
+        throw new JobFailedError(job.id, result.error?.message ?? `Job "${job.id}" failed`, job.errorCause ? { cause: job.errorCause } : undefined);
+    }
+    handle(job, deduplicated) {
+        return new JobHandle(this, job, deduplicated);
+    }
+    createId(name, now) {
+        return `${this.name}:${name}:${now.toString(36)}:${this.sequence.toString(36)}`;
+    }
+    connectSignal(job) {
+        this.disconnectSignal(job);
+        const signal = job.externalSignal;
+        if (!signal) {
+            return;
+        }
+        const abort = () => {
+            this.cancel(job.id, abortMessage(signal.reason));
+        };
+        job.abortListener = abort;
+        if (signal.aborted) {
+            abort();
+        }
+        else {
+            signal.addEventListener("abort", abort, { once: true });
+        }
+    }
+    disconnectSignal(job) {
+        if (job.externalSignal && job.abortListener) {
+            job.externalSignal.removeEventListener("abort", job.abortListener);
+            job.abortListener = undefined;
+        }
+    }
+    requestPump() {
+        if (this.pumpQueued || !this.started || this.closed) {
+            return;
+        }
+        this.pumpQueued = true;
+        queueMicrotask(() => {
+            this.pumpQueued = false;
+            this.pump();
+        });
+    }
+    pump() {
+        if (!this.started || this.closed) {
+            return;
+        }
+        this.clearTimer();
+        const now = Date.now();
+        this.policyWakeAt = undefined;
+        this.prunePolicyState(now);
+        this.expireWaiting(now);
+        this.promoteDelayed(now);
+        this.pruneStarts(now);
+        while (this.runningCount < this._concurrency &&
+            this.hasRateCapacity()) {
+            const job = this.popReady(now);
+            if (!job) {
+                break;
+            }
+            this.beginExecutionPolicy(job, now);
+            if (this.rateLimit) {
+                this.starts.push(Date.now());
+            }
+            void this.execute(job);
+        }
+        this.scheduleNextWake();
+        this.notifyIdle();
+    }
+    promoteDelayed(now) {
+        while (true) {
+            const job = this.peekDelayed();
+            if (!job || job.runAt > now) {
+                return;
+            }
+            this.delayed.pop();
+            if (job.status === "scheduled") {
+                job.status = "queued";
+                this.ready.push(job);
+            }
+        }
+    }
+    expireWaiting(now) {
+        for (const job of this.records.values()) {
+            if ((job.status === "queued" || job.status === "scheduled") &&
+                job.expiresAt !== undefined &&
+                job.expiresAt <= now) {
+                const error = new JobExpiredError(job.id);
+                job.status = "expired";
+                job.finishedAt = now;
+                job.error = serializeError(error);
+                job.errorCause = error;
+                this.finish(job, "expired");
+            }
+        }
+    }
+    peekDelayed() {
+        while (true) {
+            const job = this.delayed.peek();
+            if (!job || job.status === "scheduled") {
+                return job;
+            }
+            this.delayed.pop();
+        }
+    }
+    popReady(now) {
+        const blocked = [];
+        let selected;
+        while (!selected) {
+            const job = this.ready.pop();
+            if (!job) {
+                break;
+            }
+            if (job.status !== "queued") {
+                continue;
+            }
+            if (this.canStart(job, now)) {
+                selected = job;
+                break;
+            }
+            blocked.push(job);
+        }
+        for (const job of blocked) {
+            this.ready.push(job);
+        }
+        return selected;
+    }
+    canStart(job, now) {
+        if (job.concurrency) {
+            const active = this.activeKeys.get(job.concurrency.key) ?? 0;
+            if (active >= job.concurrency.limit) {
+                return false;
+            }
+        }
+        if (job.throttle) {
+            const state = this.refillThrottle(job.throttle, now);
+            if (state.tokens < 1) {
+                const refillPerMs = job.throttle.limit / job.throttle.interval;
+                const wakeAt = now + Math.ceil((1 - state.tokens) / refillPerMs);
+                this.policyWakeAt =
+                    this.policyWakeAt === undefined
+                        ? wakeAt
+                        : Math.min(this.policyWakeAt, wakeAt);
+                return false;
+            }
+        }
+        return true;
+    }
+    beginExecutionPolicy(job, now) {
+        if (job.concurrency) {
+            this.activeKeys.set(job.concurrency.key, (this.activeKeys.get(job.concurrency.key) ?? 0) + 1);
+        }
+        if (job.throttle) {
+            const state = this.refillThrottle(job.throttle, now);
+            state.tokens = Math.max(0, state.tokens - 1);
+        }
+    }
+    releaseExecutionPolicy(job) {
+        if (!job.concurrency) {
+            return;
+        }
+        const active = (this.activeKeys.get(job.concurrency.key) ?? 1) - 1;
+        if (active <= 0) {
+            this.activeKeys.delete(job.concurrency.key);
+        }
+        else {
+            this.activeKeys.set(job.concurrency.key, active);
+        }
+    }
+    refillThrottle(policy, now) {
+        let state = this.throttleStates.get(policy.key);
+        if (!state) {
+            state = { tokens: policy.burst, updatedAt: now };
+            this.throttleStates.set(policy.key, state);
+            return state;
+        }
+        const elapsed = Math.max(0, now - state.updatedAt);
+        state.tokens = Math.min(policy.burst, state.tokens + elapsed * (policy.limit / policy.interval));
+        state.updatedAt = now;
+        return state;
+    }
+    hasReady() {
+        while (true) {
+            const job = this.ready.peek();
+            if (!job) {
+                return false;
+            }
+            if (job.status === "queued") {
+                return true;
+            }
+            this.ready.pop();
+        }
+    }
+    hasRateCapacity() {
+        return !this.rateLimit || this.starts.length < this.rateLimit.limit;
+    }
+    pruneStarts(now) {
+        if (!this.rateLimit) {
+            return;
+        }
+        const threshold = now - this.rateLimit.interval;
+        while (this.starts.length > 0 && this.starts[0] <= threshold) {
+            this.starts.shift();
+        }
+    }
+    scheduleNextWake() {
+        let wakeAt;
+        const delayed = this.peekDelayed();
+        if (delayed) {
+            wakeAt = delayed.runAt;
+        }
+        if (this.rateLimit &&
+            this.hasReady() &&
+            !this.hasRateCapacity() &&
+            this.starts[0] !== undefined) {
+            const rateWake = this.starts[0] + this.rateLimit.interval;
+            wakeAt = wakeAt === undefined ? rateWake : Math.min(wakeAt, rateWake);
+        }
+        if (this.policyWakeAt !== undefined) {
+            wakeAt =
+                wakeAt === undefined
+                    ? this.policyWakeAt
+                    : Math.min(wakeAt, this.policyWakeAt);
+        }
+        for (const job of this.records.values()) {
+            if ((job.status === "queued" || job.status === "scheduled") &&
+                job.expiresAt !== undefined) {
+                wakeAt =
+                    wakeAt === undefined
+                        ? job.expiresAt
+                        : Math.min(wakeAt, job.expiresAt);
+            }
+        }
+        if (wakeAt === undefined || this.runningCount >= this._concurrency) {
+            return;
+        }
+        const delay = Math.max(0, wakeAt - Date.now());
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.requestPump();
+        }, Math.min(delay, 2_147_483_647));
+    }
+    async execute(job) {
+        const handler = this.handlers[job.name];
+        if (typeof handler !== "function" || job.status !== "queued") {
+            return;
+        }
+        job.status = "running";
+        job.attempt += 1;
+        job.startedAt = Date.now();
+        job.controller = new AbortController();
+        this.runningCount += 1;
+        this.emit("started", snapshot(job));
+        this.notifySizeWaiters();
+        let timeoutTimer;
+        try {
+            const context = {
+                id: job.id,
+                name: job.name,
+                attempt: job.attempt,
+                signal: job.controller.signal,
+                progress: (value) => {
+                    if (job.status === "running") {
+                        job.progress = value;
+                        this.emit("progress", snapshot(job));
+                    }
+                },
+                log: (entry) => {
+                    if (job.status !== "running" || this.logLimit === 0) {
+                        return;
+                    }
+                    job.logs.push(entry);
+                    if (job.logs.length > this.logLimit) {
+                        job.logs.splice(0, job.logs.length - this.logLimit);
+                    }
+                    this.emit("log", { job: snapshot(job), entry });
+                },
+            };
+            const execution = Promise.resolve(handler(job.input, context));
+            const output = job.timeout === undefined
+                ? await execution
+                : await Promise.race([
+                    execution,
+                    new Promise((_, reject) => {
+                        timeoutTimer = setTimeout(() => {
+                            const error = new JobTimeoutError(job.id, job.timeout);
+                            job.controller?.abort(error);
+                            reject(error);
+                        }, job.timeout);
+                    }),
+                ]);
+            if (!isCancelled(job)) {
+                job.status = "succeeded";
+                job.output = output;
+                job.error = undefined;
+                job.errorCause = undefined;
+                job.finishedAt = Date.now();
+                this.finish(job, "succeeded");
+            }
+        }
+        catch (cause) {
+            if (!isCancelled(job)) {
+                try {
+                    await this.handleFailure(job, toError(cause));
+                }
+                catch (policyCause) {
+                    const policyError = toError(policyCause);
+                    job.error = serializeError(policyError);
+                    job.errorCause = policyError;
+                    job.status = "failed";
+                    job.finishedAt = Date.now();
+                    this.finish(job, "failed");
+                }
+            }
+        }
+        finally {
+            if (timeoutTimer !== undefined) {
+                clearTimeout(timeoutTimer);
+            }
+            job.controller = undefined;
+            this.releaseExecutionPolicy(job);
+            this.runningCount -= 1;
+            this.notifyIdle();
+            this.requestPump();
+        }
+    }
+    async handleFailure(job, error) {
+        job.error = serializeError(error);
+        job.errorCause = error;
+        const shouldRetry = job.attempt <= job.retry.retries &&
+            (job.retry.when ? await job.retry.when(error, job.attempt) : true);
+        if (!shouldRetry) {
+            job.status = "failed";
+            job.finishedAt = Date.now();
+            this.finish(job, "failed");
+            return;
+        }
+        const delay = await backoffDelay(job.retry.backoff, job.attempt, error);
+        job.runAt = Date.now() + delay;
+        job.sequence = this.sequence++;
+        job.status = delay > 0 ? "scheduled" : "queued";
+        if (job.status === "scheduled") {
+            this.delayed.push(job);
+        }
+        else {
+            this.ready.push(job);
+        }
+        this.emit("retry", { job: snapshot(job), error, delay });
+    }
+    finish(job, event) {
+        this.disconnectSignal(job);
+        if (job.key && this.keys.get(job.key) === job) {
+            if (job.keyRetention > 0) {
+                job.keyExpiresAt = Date.now() + job.keyRetention;
+            }
+            else {
+                this.keys.delete(job.key);
+            }
+        }
+        const value = snapshot(job);
+        job.completion.resolve(value);
+        this.emit(event, value);
+        this.pruneHistory();
+        this.notifyIdle();
+    }
+    pruneHistory() {
+        let finished = 0;
+        for (const job of this.records.values()) {
+            if (isTerminal(job.status)) {
+                finished += 1;
+            }
+        }
+        let remove = finished - this.historyLimit;
+        if (remove <= 0) {
+            return;
+        }
+        for (const [id, job] of this.records) {
+            if (remove <= 0) {
+                return;
+            }
+            if (isTerminal(job.status)) {
+                if (job.key && this.keys.get(job.key) === job) {
+                    this.keys.delete(job.key);
+                }
+                this.records.delete(id);
+                remove -= 1;
+            }
+        }
+    }
+    prunePolicyState(now) {
+        for (const [key, job] of this.keys) {
+            if (isTerminal(job.status) &&
+                (job.keyExpiresAt === undefined || job.keyExpiresAt <= now)) {
+                this.keys.delete(key);
+            }
+        }
+        for (const [key, state] of this.debounceStates) {
+            if (state.until <= now &&
+                (state.mode === "leading" || isTerminal(state.job.status))) {
+                this.debounceStates.delete(key);
+            }
+        }
+    }
+    notifyIdle() {
+        if (this.size !== 0 || this.runningCount !== 0) {
+            this.idleNotified = false;
+            return;
+        }
+        for (const resolve of this.idleWaiters) {
+            resolve();
+        }
+        this.idleWaiters.clear();
+        if (!this.idleNotified) {
+            this.idleNotified = true;
+            this.emit("idle", this.stats);
+        }
+    }
+    notifySizeWaiters() {
+        const size = this.size;
+        for (const waiter of this.sizeWaiters) {
+            if (size < waiter.limit) {
+                waiter.resolve();
+                this.sizeWaiters.delete(waiter);
+            }
+        }
+    }
+    emit(event, payload) {
+        const group = this.listeners.get(event);
+        if (!group) {
+            return;
+        }
+        for (const listener of group) {
+            try {
+                listener(payload);
+            }
+            catch {
+                // Observers cannot break queue processing.
+            }
+        }
+    }
+    clearTimer() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new QueueClosedError(this.name);
+        }
+    }
+}
+/** Create a strongly typed queue from a map of named handlers. */
+export function memoryQueue(handlers, options) {
+    return new MemoryQueue(handlers, options);
+}
+class BinaryHeap {
+    before;
+    values = [];
+    constructor(before) {
+        this.before = before;
+    }
+    peek() {
+        return this.values[0];
+    }
+    push(value) {
+        this.values.push(value);
+        let index = this.values.length - 1;
+        while (index > 0) {
+            const parent = Math.floor((index - 1) / 2);
+            if (!this.before(value, this.values[parent])) {
+                break;
+            }
+            this.values[index] = this.values[parent];
+            index = parent;
+        }
+        this.values[index] = value;
+    }
+    pop() {
+        const first = this.values[0];
+        const last = this.values.pop();
+        if (first === undefined || last === undefined || this.values.length === 0) {
+            return first;
+        }
+        let index = 0;
+        this.values[0] = last;
+        while (true) {
+            const left = index * 2 + 1;
+            const right = left + 1;
+            let next = index;
+            if (left < this.values.length &&
+                this.before(this.values[left], this.values[next])) {
+                next = left;
+            }
+            if (right < this.values.length &&
+                this.before(this.values[right], this.values[next])) {
+                next = right;
+            }
+            if (next === index) {
+                break;
+            }
+            [this.values[index], this.values[next]] = [
+                this.values[next],
+                this.values[index],
+            ];
+            index = next;
+        }
+        return first;
+    }
+    remove(value) {
+        const filtered = this.values.filter((entry) => entry !== value);
+        if (filtered.length === this.values.length) {
+            return;
+        }
+        this.values.length = 0;
+        for (const entry of filtered) {
+            this.push(entry);
+        }
+    }
+}
+function readyBefore(left, right) {
+    return (left.priority > right.priority ||
+        (left.priority === right.priority && left.sequence < right.sequence));
+}
+function delayedBefore(left, right) {
+    return (left.runAt < right.runAt ||
+        (left.runAt === right.runAt && readyBefore(left, right)));
+}
+function deferred() {
+    let resolvePromise;
+    const promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    return {
+        promise,
+        resolve(value) {
+            resolvePromise?.(value);
+        },
+    };
+}
+function snapshot(job) {
+    return {
+        id: job.id,
+        name: job.name,
+        input: job.input,
+        status: job.status,
+        priority: job.priority,
+        attempt: job.attempt,
+        retries: job.retry.retries,
+        createdAt: job.createdAt,
+        runAt: job.runAt,
+        expiresAt: job.expiresAt,
+        startedAt: job.startedAt,
+        finishedAt: job.finishedAt,
+        progress: job.progress,
+        output: job.output,
+        error: job.error,
+        logs: [...job.logs],
+    };
+}
+function normalizeRetry(retry) {
+    if (retry === undefined) {
+        return { retries: 0, backoff: undefined, when: undefined };
+    }
+    if (typeof retry === "number") {
+        validateNonNegativeInteger("retry", retry);
+        return { retries: retry, backoff: undefined, when: undefined };
+    }
+    validateNonNegativeInteger("retry.retries", retry.retries);
+    return {
+        retries: retry.retries,
+        backoff: retry.backoff,
+        when: retry.when,
+    };
+}
+async function backoffDelay(strategy, attempt, error) {
+    if (strategy === undefined) {
+        return 0;
+    }
+    if (typeof strategy === "function") {
+        return normalizeBackoff(await strategy(attempt, error));
+    }
+    if (typeof strategy === "number") {
+        return normalizeBackoff(strategy);
+    }
+    const base = strategy.type === "exponential"
+        ? strategy.delay * 2 ** Math.max(0, attempt - 1)
+        : strategy.delay;
+    const jitter = Math.min(1, Math.max(0, strategy.jitter ?? 0));
+    return normalizeBackoff(base * (1 - Math.random() * jitter));
+}
+function normalizeBackoff(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new RangeError("backoff delay must be a non-negative finite number");
+    }
+    return value;
+}
+function normalizeRunAt(delay, now) {
+    if (delay instanceof Date) {
+        const value = delay.getTime();
+        if (!Number.isFinite(value)) {
+            throw new RangeError("delay date must be valid");
+        }
+        return Math.max(now, value);
+    }
+    if (delay === undefined) {
+        return now;
+    }
+    if (!Number.isFinite(delay) || delay < 0) {
+        throw new RangeError("delay must be a non-negative finite number");
+    }
+    return now + delay;
+}
+function validateTimeout(value) {
+    if (value !== undefined) {
+        validatePositiveNumber("timeout", value);
+    }
+}
+function validateExecutionOptions(options) {
+    if (options.keyRetention !== undefined) {
+        if (!Number.isFinite(options.keyRetention) || options.keyRetention < 0) {
+            throw new RangeError("keyRetention must be a non-negative finite number");
+        }
+    }
+    if (options.concurrency) {
+        validatePositiveInteger("concurrency.limit", options.concurrency.limit);
+        validatePolicyKey("concurrency.key", options.concurrency.key);
+    }
+    if (options.throttle) {
+        validatePositiveInteger("throttle.limit", options.throttle.limit);
+        validatePositiveNumber("throttle.interval", options.throttle.interval);
+        validatePositiveInteger("throttle.burst", options.throttle.burst);
+        validatePolicyKey("throttle.key", options.throttle.key);
+    }
+    if (options.debounce) {
+        validatePositiveNumber("debounce.wait", options.debounce.wait);
+        validatePolicyKey("debounce.key", options.debounce.key);
+    }
+}
+function validatePolicyKey(name, value) {
+    if (!value.trim()) {
+        throw new TypeError(`${name} must not be empty`);
+    }
+}
+function validateHistoryLimit(value) {
+    validateNonNegativeInteger("historyLimit", value);
+}
+function validatePositiveInteger(name, value) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new RangeError(`${name} must be a positive integer`);
+    }
+}
+function validateNonNegativeInteger(name, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative integer`);
+    }
+}
+function validatePositiveNumber(name, value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive finite number`);
+    }
+}
+function validatePositiveIntegerOrInfinity(name, value) {
+    if (value !== Number.POSITIVE_INFINITY) {
+        validatePositiveInteger(name, value);
+    }
+}
+function isTerminal(status) {
+    return (status === "succeeded" ||
+        status === "failed" ||
+        status === "cancelled" ||
+        status === "expired");
+}
+function isCancelled(job) {
+    return job.status === "cancelled";
+}
+function serializeError(error) {
+    return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+    };
+}
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function abortMessage(reason) {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    return reason === undefined ? "Job was aborted" : String(reason);
+}