velocious 1.0.606 → 1.0.607

package/build/src/background-jobs/local-dispatcher.d.ts

@@ -0,0 +1,185 @@
+export type LocalBackgroundJobAcknowledgement = {
+    type: "completed";
+} | {
+    type: "failed";
+    error: ReturnType<typeof JSON.parse>;
+} | {
+    type: "rescheduled";
+    delayMs: number;
+};
+export type PendingLocalBackgroundJobAcknowledgement = {
+    /**
+     * - Durable transition still owned by this dispatcher.
+     */
+    acknowledgement: LocalBackgroundJobAcknowledgement;
+    /**
+     * - Fenced handoff being acknowledged.
+     */
+    handoff: import("./types.js").BackgroundJobHandoff;
+    /**
+     * - Claimed job snapshot.
+     */
+    job: import("./types.js").BackgroundJobRow;
+};
+/** Configuration-owned, event-driven in-process local dispatcher. */
+export default class LocalBackgroundJobsDispatcher {
+    clock: import("./types.js").LocalBackgroundJobsClock;
+    configuration: import("../configuration.js").default;
+    registry: import("./local-job-registry.js").default;
+    store: import("./local-store.js").default;
+    _accepting: boolean;
+    _started: boolean;
+    /** @type {Promise<void> | null} */
+    _startPromise: Promise<void> | null;
+    /** @type {Promise<void> | null} */
+    _drainPromise: Promise<void> | null;
+    _redrain: boolean;
+    _wakeQueued: boolean;
+    /** @type {Set<Promise<void>>} */
+    _inFlight: Set<Promise<void>>;
+    /** @type {Map<string, PendingLocalBackgroundJobAcknowledgement>} */
+    _pendingAcknowledgements: Map<string, PendingLocalBackgroundJobAcknowledgement>;
+    /** @type {Set<() => void>} */
+    _idleWaiters: Set<() => void>;
+    /** @type {ReturnType<typeof setTimeout> | number | undefined} */
+    _scheduledTimer: ReturnType<typeof setTimeout> | number | undefined;
+    /** @type {ReturnType<typeof setTimeout> | number | undefined} */
+    _recoveryTimer: ReturnType<typeof setTimeout> | number | undefined;
+    /**
+     * Creates a dispatcher owned by one configuration and local store.
+     * @param {object} args - Dispatcher options.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {import("./types.js").LocalBackgroundJobsClock} args.clock - Dispatcher clock.
+     * @param {import("./local-job-registry.js").default} args.registry - Static job registry.
+     * @param {import("./local-store.js").default} args.store - Durable local store.
+     */
+    constructor({ configuration, clock, registry, store }: {
+        configuration: import("../configuration.js").default;
+        clock: import("./types.js").LocalBackgroundJobsClock;
+        registry: import("./local-job-registry.js").default;
+        store: import("./local-store.js").default;
+    });
+    /**
+     * Starts, recovers, and catches up the local dispatcher.
+     * @returns {Promise<void>} - Resolves after admission starts.
+     */
+    start(): Promise<void>;
+    /**
+     * Coalesces a dispatcher wake onto one tracked microtask.
+     * @returns {void} - No return value.
+     */
+    wake(): void;
+    /**
+     * Fills local capacity with short durable claims.
+     * @returns {Promise<void>} - Resolves after one stable drain pass.
+     */
+    _drain(): Promise<void>;
+    /**
+     * Runs one claimed performance without retaining its claim transaction connection.
+     * @param {{handoff: import("./types.js").BackgroundJobHandoff, job: import("./types.js").BackgroundJobRow}} args - Claimed job.
+     * @returns {void} - No return value.
+     */
+    _startPerformance({ handoff, job }: {
+        handoff: import("./types.js").BackgroundJobHandoff;
+        job: import("./types.js").BackgroundJobRow;
+    }): void;
+    /**
+     * Performs and acknowledges one durable handoff.
+     * @param {{handoff: import("./types.js").BackgroundJobHandoff, job: import("./types.js").BackgroundJobRow}} args - Claimed job.
+     * @returns {Promise<void>} - Resolves after acknowledgement.
+     */
+    _perform({ handoff, job }: {
+        handoff: import("./types.js").BackgroundJobHandoff;
+        job: import("./types.js").BackgroundJobRow;
+    }): Promise<void>;
+    /**
+     * Applies one fenced durable acknowledgement.
+     * @param {PendingLocalBackgroundJobAcknowledgement} args - Owned acknowledgement.
+     * @returns {Promise<void>} - Resolves after the durable transition is settled.
+     */
+    _acknowledge({ acknowledgement, handoff, job }: PendingLocalBackgroundJobAcknowledgement): Promise<void>;
+    /**
+     * Replays each retained acknowledgement once at an event-driven wake boundary.
+     * @param {{throwOnError?: boolean}} [args] - Recovery behavior.
+     * @returns {Promise<void>} - Resolves after one bounded recovery pass.
+     */
+    _retryPendingAcknowledgements({ throwOnError }?: {
+        throwOnError?: boolean;
+    }): Promise<void>;
+    /**
+     * Arms the exact next future job timer, chunking platform-sized delays.
+     * @returns {Promise<void>} - Resolves after timer reconciliation.
+     */
+    _armScheduledTimer(): Promise<void>;
+    /**
+     * Arms one bounded retry after an unexpected drain failure.
+     * @returns {void} - No return value.
+     */
+    _armRecoveryTimer(): void;
+    /**
+     * Waits for admission and every in-flight acknowledgement without polling.
+     * @returns {Promise<void>} - Resolves when idle.
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Stops claims and waits for in-flight acknowledgement.
+     * @returns {Promise<void>} - Resolves after a graceful stop.
+     */
+    stop(): Promise<void>;
+    /**
+     * Reports whether dispatcher admission has started.
+     * @returns {boolean} - Whether dispatcher admission has started.
+     */
+    isReady(): boolean;
+    /**
+     * Reads the configuration-owned in-process performance cap.
+     * @returns {number} - Configuration-owned in-process performance cap.
+     */
+    _maxConcurrentJobs(): number;
+    /**
+     * Counts performances whose durable acknowledgement is still owned locally.
+     * @returns {number} - Active or pending-acknowledgement performances.
+     */
+    _ownedPerformanceCount(): number;
+    /**
+     * Reports whether no admission or acknowledgement work remains.
+     * @returns {boolean} - Whether the dispatcher is idle.
+     */
+    _isIdle(): boolean;
+    /**
+     * Resolves event-based idle waiters at a stable idle boundary.
+     * @returns {void} - No return value.
+     */
+    _resolveIdleWaiters(): void;
+    /**
+     * Emits an expected job failure through the standard job/all-error channels.
+     * @param {{error: ReturnType<typeof JSON.parse>, job: import("./types.js").BackgroundJobRow}} args - Failure transition.
+     * @returns {void} - No return value.
+     */
+    _emitBackgroundJobFailed({ error, job }: {
+        error: ReturnType<typeof JSON.parse>;
+        job: import("./types.js").BackgroundJobRow;
+    }): void;
+    /**
+     * Reports one failed durable acknowledgement attempt with its fence context.
+     * @param {PendingLocalBackgroundJobAcknowledgement & {error: ReturnType<typeof JSON.parse>}} args - Failed acknowledgement.
+     * @returns {void} - No return value.
+     */
+    _reportAcknowledgementError({ acknowledgement, error, handoff, job }: PendingLocalBackgroundJobAcknowledgement & {
+        error: ReturnType<typeof JSON.parse>;
+    }): void;
+    /**
+     * Reports an unexpected dispatcher failure through framework channels.
+     * @param {object} args - Unexpected failure.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.context] - Additional failure context.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Unexpected error.
+     * @param {string} args.stage - Dispatcher stage.
+     * @returns {void} - No return value.
+     */
+    _reportFrameworkError({ context, error, stage }: {
+        context?: Record<string, ReturnType<typeof JSON.parse>>;
+        error: ReturnType<typeof JSON.parse>;
+        stage: string;
+    }): void;
+}
+//# sourceMappingURL=local-dispatcher.d.ts.map

package/build/src/background-jobs/local-dispatcher.d.ts.map

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

package/build/src/background-jobs/local-dispatcher.js

@@ -0,0 +1,383 @@
+// @ts-check
+import BackgroundJobRescheduleSignal from "./reschedule-signal.js";
+import performBackgroundJob from "./perform-job.js";
+/** @typedef {{type: "completed"} | {type: "failed", error: ReturnType<typeof JSON.parse>} | {type: "rescheduled", delayMs: number}} LocalBackgroundJobAcknowledgement */
+/**
+ * @typedef {object} PendingLocalBackgroundJobAcknowledgement
+ * @property {LocalBackgroundJobAcknowledgement} acknowledgement - Durable transition still owned by this dispatcher.
+ * @property {import("./types.js").BackgroundJobHandoff} handoff - Fenced handoff being acknowledged.
+ * @property {import("./types.js").BackgroundJobRow} job - Claimed job snapshot.
+ */
+const MAX_TIMER_MS = 2_147_483_647;
+const ERROR_RECOVERY_DELAY_MS = 1_000;
+/** Configuration-owned, event-driven in-process local dispatcher. */
+export default class LocalBackgroundJobsDispatcher {
+    /**
+     * Creates a dispatcher owned by one configuration and local store.
+     * @param {object} args - Dispatcher options.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {import("./types.js").LocalBackgroundJobsClock} args.clock - Dispatcher clock.
+     * @param {import("./local-job-registry.js").default} args.registry - Static job registry.
+     * @param {import("./local-store.js").default} args.store - Durable local store.
+     */
+    constructor({ configuration, clock, registry, store }) {
+        this.clock = clock;
+        this.configuration = configuration;
+        this.registry = registry;
+        this.store = store;
+        this._accepting = false;
+        this._started = false;
+        /** @type {Promise<void> | null} */
+        this._startPromise = null;
+        /** @type {Promise<void> | null} */
+        this._drainPromise = null;
+        this._redrain = false;
+        this._wakeQueued = false;
+        /** @type {Set<Promise<void>>} */
+        this._inFlight = new Set();
+        /** @type {Map<string, PendingLocalBackgroundJobAcknowledgement>} */
+        this._pendingAcknowledgements = new Map();
+        /** @type {Set<() => void>} */
+        this._idleWaiters = new Set();
+        /** @type {ReturnType<typeof setTimeout> | number | undefined} */
+        this._scheduledTimer = undefined;
+        /** @type {ReturnType<typeof setTimeout> | number | undefined} */
+        this._recoveryTimer = undefined;
+    }
+    /**
+     * Starts, recovers, and catches up the local dispatcher.
+     * @returns {Promise<void>} - Resolves after admission starts.
+     */
+    async start() {
+        if (this._started)
+            return;
+        if (this._startPromise)
+            return await this._startPromise;
+        this._startPromise = (async () => {
+            this.configuration.setCurrent();
+            this.registry.ensureReady();
+            await this.configuration.initialize({ type: "local-background-jobs" });
+            await this.store.ensureReady();
+            await this.store.reconcileQueueConcurrency();
+            const recoveredJobs = await this.store.recoverHandedOffJobs();
+            for (const job of recoveredJobs) {
+                this._emitBackgroundJobFailed({
+                    error: new Error(job.lastError || "Local background job recovered after an interrupted dispatcher"),
+                    job
+                });
+            }
+            this._accepting = true;
+            this._started = true;
+            this.wake();
+        })();
+        try {
+            await this._startPromise;
+        }
+        catch (error) {
+            this._reportFrameworkError({ error, stage: "local-background-jobs-start" });
+            throw error;
+        }
+        finally {
+            this._startPromise = null;
+        }
+    }
+    /**
+     * Coalesces a dispatcher wake onto one tracked microtask.
+     * @returns {void} - No return value.
+     */
+    wake() {
+        if (!this._accepting)
+            return;
+        if (this._drainPromise || this._wakeQueued) {
+            this._redrain = true;
+            return;
+        }
+        this._wakeQueued = true;
+        const drain = Promise.resolve().then(async () => {
+            this._wakeQueued = false;
+            await this._drain();
+        });
+        const drainPromise = drain
+            .catch((error) => {
+            this._reportFrameworkError({ error, stage: "local-background-jobs-drain" });
+            this._armRecoveryTimer();
+        })
+            .finally(() => {
+            if (this._drainPromise === drainPromise)
+                this._drainPromise = null;
+            if (this._redrain && this._accepting) {
+                this._redrain = false;
+                this.wake();
+            }
+            else {
+                this._resolveIdleWaiters();
+            }
+        });
+        this._drainPromise = drainPromise;
+    }
+    /**
+     * Fills local capacity with short durable claims.
+     * @returns {Promise<void>} - Resolves after one stable drain pass.
+     */
+    async _drain() {
+        await this._retryPendingAcknowledgements();
+        while (this._accepting && this._ownedPerformanceCount() < this._maxConcurrentJobs()) {
+            const job = await this.store.nextAvailableJob();
+            if (!job)
+                break;
+            const handoff = await this.store.markHandedOff({ jobId: job.id });
+            if (!handoff) {
+                this._redrain = true;
+                break;
+            }
+            this._startPerformance({ handoff, job });
+        }
+        await this._armScheduledTimer();
+    }
+    /**
+     * Runs one claimed performance without retaining its claim transaction connection.
+     * @param {{handoff: import("./types.js").BackgroundJobHandoff, job: import("./types.js").BackgroundJobRow}} args - Claimed job.
+     * @returns {void} - No return value.
+     */
+    _startPerformance({ handoff, job }) {
+        const performance = this._perform({ handoff, job });
+        this._inFlight.add(performance);
+        void performance
+            .catch((error) => this._reportFrameworkError({ error, stage: "local-background-jobs-performance" }))
+            .finally(() => {
+            this._inFlight.delete(performance);
+            if (this._accepting)
+                this.wake();
+            this._resolveIdleWaiters();
+        });
+    }
+    /**
+     * Performs and acknowledges one durable handoff.
+     * @param {{handoff: import("./types.js").BackgroundJobHandoff, job: import("./types.js").BackgroundJobRow}} args - Claimed job.
+     * @returns {Promise<void>} - Resolves after acknowledgement.
+     */
+    async _perform({ handoff, job }) {
+        /** @type {LocalBackgroundJobAcknowledgement} */
+        let acknowledgement = { type: "completed" };
+        try {
+            const JobClass = this.registry.resolve(job.jobName);
+            await performBackgroundJob({
+                configuration: this.configuration,
+                JobClass,
+                jobArgs: job.args,
+                name: `Local background job: ${job.jobName}`
+            });
+        }
+        catch (error) {
+            if (error instanceof BackgroundJobRescheduleSignal) {
+                acknowledgement = { delayMs: error.delayMs, type: "rescheduled" };
+            }
+            else {
+                acknowledgement = { error, type: "failed" };
+            }
+        }
+        try {
+            await this._acknowledge({ acknowledgement, handoff, job });
+        }
+        catch (error) {
+            this._pendingAcknowledgements.set(job.id, { acknowledgement, handoff, job });
+            this._reportAcknowledgementError({ acknowledgement, error, handoff, job });
+        }
+    }
+    /**
+     * Applies one fenced durable acknowledgement.
+     * @param {PendingLocalBackgroundJobAcknowledgement} args - Owned acknowledgement.
+     * @returns {Promise<void>} - Resolves after the durable transition is settled.
+     */
+    async _acknowledge({ acknowledgement, handoff, job }) {
+        if (acknowledgement.type === "rescheduled") {
+            await this.store.markRescheduled({ delayMs: acknowledgement.delayMs, handoffId: handoff.handoffId, jobId: job.id });
+            return;
+        }
+        if (acknowledgement.type === "failed") {
+            const updatedJob = await this.store.markFailed({ error: acknowledgement.error, handoffId: handoff.handoffId, jobId: job.id });
+            if (updatedJob)
+                this._emitBackgroundJobFailed({ error: acknowledgement.error, job: updatedJob });
+            return;
+        }
+        await this.store.markCompleted({ handoffId: handoff.handoffId, jobId: job.id });
+    }
+    /**
+     * Replays each retained acknowledgement once at an event-driven wake boundary.
+     * @param {{throwOnError?: boolean}} [args] - Recovery behavior.
+     * @returns {Promise<void>} - Resolves after one bounded recovery pass.
+     */
+    async _retryPendingAcknowledgements({ throwOnError = false } = {}) {
+        for (const [jobId, pendingAcknowledgement] of [...this._pendingAcknowledgements]) {
+            try {
+                await this._acknowledge(pendingAcknowledgement);
+                this._pendingAcknowledgements.delete(jobId);
+            }
+            catch (error) {
+                this._reportAcknowledgementError({ ...pendingAcknowledgement, error });
+                if (throwOnError)
+                    throw error;
+                this._armRecoveryTimer();
+            }
+        }
+    }
+    /**
+     * Arms the exact next future job timer, chunking platform-sized delays.
+     * @returns {Promise<void>} - Resolves after timer reconciliation.
+     */
+    async _armScheduledTimer() {
+        if (this._scheduledTimer !== undefined) {
+            this.clock.clearTimeout(this._scheduledTimer);
+            this._scheduledTimer = undefined;
+        }
+        if (!this._accepting)
+            return;
+        const nextJob = await this.store.nextScheduledJob();
+        if (!nextJob || nextJob.scheduledAtMs === null)
+            return;
+        const delayMs = Math.max(0, Math.min(nextJob.scheduledAtMs - this.clock.now(), MAX_TIMER_MS));
+        this._scheduledTimer = this.clock.setTimeout(() => {
+            this._scheduledTimer = undefined;
+            this.wake();
+        }, delayMs);
+    }
+    /**
+     * Arms one bounded retry after an unexpected drain failure.
+     * @returns {void} - No return value.
+     */
+    _armRecoveryTimer() {
+        if (!this._accepting || this._recoveryTimer !== undefined)
+            return;
+        this._recoveryTimer = this.clock.setTimeout(() => {
+            this._recoveryTimer = undefined;
+            this.wake();
+        }, ERROR_RECOVERY_DELAY_MS);
+    }
+    /**
+     * Waits for admission and every in-flight acknowledgement without polling.
+     * @returns {Promise<void>} - Resolves when idle.
+     */
+    async waitForIdle() {
+        if (this._isIdle())
+            return;
+        await new Promise((resolve) => this._idleWaiters.add(() => resolve(undefined)));
+    }
+    /**
+     * Stops claims and waits for in-flight acknowledgement.
+     * @returns {Promise<void>} - Resolves after a graceful stop.
+     */
+    async stop() {
+        this._accepting = false;
+        this._redrain = false;
+        if (this._scheduledTimer !== undefined) {
+            this.clock.clearTimeout(this._scheduledTimer);
+            this._scheduledTimer = undefined;
+        }
+        if (this._recoveryTimer !== undefined) {
+            this.clock.clearTimeout(this._recoveryTimer);
+            this._recoveryTimer = undefined;
+        }
+        if (this._drainPromise)
+            await this._drainPromise;
+        if (this._inFlight.size > 0)
+            await Promise.all([...this._inFlight]);
+        await this._retryPendingAcknowledgements({ throwOnError: true });
+        this._wakeQueued = false;
+        this._started = false;
+        this._resolveIdleWaiters();
+    }
+    /**
+     * Reports whether dispatcher admission has started.
+     * @returns {boolean} - Whether dispatcher admission has started.
+     */
+    isReady() { return this._started && this._accepting; }
+    /**
+     * Reads the configuration-owned in-process performance cap.
+     * @returns {number} - Configuration-owned in-process performance cap.
+     */
+    _maxConcurrentJobs() { return this.configuration.getBackgroundJobsConfig().maxConcurrentInlineJobs; }
+    /**
+     * Counts performances whose durable acknowledgement is still owned locally.
+     * @returns {number} - Active or pending-acknowledgement performances.
+     */
+    _ownedPerformanceCount() { return this._inFlight.size + this._pendingAcknowledgements.size; }
+    /**
+     * Reports whether no admission or acknowledgement work remains.
+     * @returns {boolean} - Whether the dispatcher is idle.
+     */
+    _isIdle() {
+        return !this._wakeQueued && !this._drainPromise && this._inFlight.size === 0 && this._pendingAcknowledgements.size === 0;
+    }
+    /**
+     * Resolves event-based idle waiters at a stable idle boundary.
+     * @returns {void} - No return value.
+     */
+    _resolveIdleWaiters() {
+        if (!this._isIdle())
+            return;
+        const waiters = [...this._idleWaiters];
+        this._idleWaiters.clear();
+        for (const resolve of waiters)
+            resolve();
+    }
+    /**
+     * Emits an expected job failure through the standard job/all-error channels.
+     * @param {{error: ReturnType<typeof JSON.parse>, job: import("./types.js").BackgroundJobRow}} args - Failure transition.
+     * @returns {void} - No return value.
+     */
+    _emitBackgroundJobFailed({ error, job }) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        const payload = {
+            context: {
+                attempts: job.attempts,
+                jobArgs: job.args,
+                jobId: job.id,
+                jobName: job.jobName,
+                maxRetries: job.maxRetries,
+                stage: "background-job-failed",
+                status: job.status,
+                terminal: job.status === "failed",
+                willRetry: job.status === "queued",
+                workerId: "local"
+            },
+            error: normalizedError
+        };
+        const errorEvents = this.configuration.getErrorEvents();
+        errorEvents.emit("background-job-failed", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "background-job-failed" });
+    }
+    /**
+     * Reports one failed durable acknowledgement attempt with its fence context.
+     * @param {PendingLocalBackgroundJobAcknowledgement & {error: ReturnType<typeof JSON.parse>}} args - Failed acknowledgement.
+     * @returns {void} - No return value.
+     */
+    _reportAcknowledgementError({ acknowledgement, error, handoff, job }) {
+        this._reportFrameworkError({
+            context: {
+                acknowledgementType: acknowledgement.type,
+                handoffId: handoff.handoffId,
+                jobId: job.id,
+                jobName: job.jobName,
+                workerId: "local"
+            },
+            error,
+            stage: "local-background-jobs-acknowledgement"
+        });
+    }
+    /**
+     * Reports an unexpected dispatcher failure through framework channels.
+     * @param {object} args - Unexpected failure.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.context] - Additional failure context.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Unexpected error.
+     * @param {string} args.stage - Dispatcher stage.
+     * @returns {void} - No return value.
+     */
+    _reportFrameworkError({ context = {}, error, stage }) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        const payload = { context: { ...context, stage }, error: normalizedError };
+        const errorEvents = this.configuration.getErrorEvents();
+        errorEvents.emit("framework-error", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-dispatcher.js","sourceRoot":"","sources":["../../../src/background-jobs/local-dispatcher.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BackgroundJobRescheduleSignal from \"./reschedule-signal.js\"\nimport performBackgroundJob from \"./perform-job.js\"\n\n/** @typedef {{type: \"completed\"} | {type: \"failed\", error: ReturnType<typeof JSON.parse>} | {type: \"rescheduled\", delayMs: number}} LocalBackgroundJobAcknowledgement */\n\n/**\n * @typedef {object} PendingLocalBackgroundJobAcknowledgement\n * @property {LocalBackgroundJobAcknowledgement} acknowledgement - Durable transition still owned by this dispatcher.\n * @property {import(\"./types.js\").BackgroundJobHandoff} handoff - Fenced handoff being acknowledged.\n * @property {import(\"./types.js\").BackgroundJobRow} job - Claimed job snapshot.\n */\n\nconst MAX_TIMER_MS = 2_147_483_647\nconst ERROR_RECOVERY_DELAY_MS = 1_000\n\n/** Configuration-owned, event-driven in-process local dispatcher. */\nexport default class LocalBackgroundJobsDispatcher {\n  /**\n   * Creates a dispatcher owned by one configuration and local store.\n   * @param {object} args - Dispatcher options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {import(\"./types.js\").LocalBackgroundJobsClock} args.clock - Dispatcher clock.\n   * @param {import(\"./local-job-registry.js\").default} args.registry - Static job registry.\n   * @param {import(\"./local-store.js\").default} args.store - Durable local store.\n   */\n  constructor({configuration, clock, registry, store}) {\n    this.clock = clock\n    this.configuration = configuration\n    this.registry = registry\n    this.store = store\n    this._accepting = false\n    this._started = false\n    /** @type {Promise<void> | null} */\n    this._startPromise = null\n    /** @type {Promise<void> | null} */\n    this._drainPromise = null\n    this._redrain = false\n    this._wakeQueued = false\n    /** @type {Set<Promise<void>>} */\n    this._inFlight = new Set()\n    /** @type {Map<string, PendingLocalBackgroundJobAcknowledgement>} */\n    this._pendingAcknowledgements = new Map()\n    /** @type {Set<() => void>} */\n    this._idleWaiters = new Set()\n    /** @type {ReturnType<typeof setTimeout> | number | undefined} */\n    this._scheduledTimer = undefined\n    /** @type {ReturnType<typeof setTimeout> | number | undefined} */\n    this._recoveryTimer = undefined\n  }\n\n  /**\n   * Starts, recovers, and catches up the local dispatcher.\n   * @returns {Promise<void>} - Resolves after admission starts.\n   */\n  async start() {\n    if (this._started) return\n    if (this._startPromise) return await this._startPromise\n\n    this._startPromise = (async () => {\n      this.configuration.setCurrent()\n      this.registry.ensureReady()\n      await this.configuration.initialize({type: \"local-background-jobs\"})\n      await this.store.ensureReady()\n      await this.store.reconcileQueueConcurrency()\n\n      const recoveredJobs = await this.store.recoverHandedOffJobs()\n\n      for (const job of recoveredJobs) {\n        this._emitBackgroundJobFailed({\n          error: new Error(job.lastError || \"Local background job recovered after an interrupted dispatcher\"),\n          job\n        })\n      }\n\n      this._accepting = true\n      this._started = true\n      this.wake()\n    })()\n\n    try {\n      await this._startPromise\n    } catch (error) {\n      this._reportFrameworkError({error, stage: \"local-background-jobs-start\"})\n      throw error\n    } finally {\n      this._startPromise = null\n    }\n  }\n\n  /**\n   * Coalesces a dispatcher wake onto one tracked microtask.\n   * @returns {void} - No return value.\n   */\n  wake() {\n    if (!this._accepting) return\n\n    if (this._drainPromise || this._wakeQueued) {\n      this._redrain = true\n      return\n    }\n\n    this._wakeQueued = true\n    const drain = Promise.resolve().then(async () => {\n      this._wakeQueued = false\n      await this._drain()\n    })\n    const drainPromise = drain\n      .catch((error) => {\n        this._reportFrameworkError({error, stage: \"local-background-jobs-drain\"})\n        this._armRecoveryTimer()\n      })\n      .finally(() => {\n        if (this._drainPromise === drainPromise) this._drainPromise = null\n\n        if (this._redrain && this._accepting) {\n          this._redrain = false\n          this.wake()\n        } else {\n          this._resolveIdleWaiters()\n        }\n      })\n\n    this._drainPromise = drainPromise\n  }\n\n  /**\n   * Fills local capacity with short durable claims.\n   * @returns {Promise<void>} - Resolves after one stable drain pass.\n   */\n  async _drain() {\n    await this._retryPendingAcknowledgements()\n\n    while (this._accepting && this._ownedPerformanceCount() < this._maxConcurrentJobs()) {\n      const job = await this.store.nextAvailableJob()\n\n      if (!job) break\n\n      const handoff = await this.store.markHandedOff({jobId: job.id})\n\n      if (!handoff) {\n        this._redrain = true\n        break\n      }\n\n      this._startPerformance({handoff, job})\n    }\n\n    await this._armScheduledTimer()\n  }\n\n  /**\n   * Runs one claimed performance without retaining its claim transaction connection.\n   * @param {{handoff: import(\"./types.js\").BackgroundJobHandoff, job: import(\"./types.js\").BackgroundJobRow}} args - Claimed job.\n   * @returns {void} - No return value.\n   */\n  _startPerformance({handoff, job}) {\n    const performance = this._perform({handoff, job})\n\n    this._inFlight.add(performance)\n    void performance\n      .catch((error) => this._reportFrameworkError({error, stage: \"local-background-jobs-performance\"}))\n      .finally(() => {\n        this._inFlight.delete(performance)\n        if (this._accepting) this.wake()\n        this._resolveIdleWaiters()\n      })\n  }\n\n  /**\n   * Performs and acknowledges one durable handoff.\n   * @param {{handoff: import(\"./types.js\").BackgroundJobHandoff, job: import(\"./types.js\").BackgroundJobRow}} args - Claimed job.\n   * @returns {Promise<void>} - Resolves after acknowledgement.\n   */\n  async _perform({handoff, job}) {\n    /** @type {LocalBackgroundJobAcknowledgement} */\n    let acknowledgement = {type: \"completed\"}\n\n    try {\n      const JobClass = this.registry.resolve(job.jobName)\n\n      await performBackgroundJob({\n        configuration: this.configuration,\n        JobClass,\n        jobArgs: job.args,\n        name: `Local background job: ${job.jobName}`\n      })\n    } catch (error) {\n      if (error instanceof BackgroundJobRescheduleSignal) {\n        acknowledgement = {delayMs: error.delayMs, type: \"rescheduled\"}\n      } else {\n        acknowledgement = {error, type: \"failed\"}\n      }\n    }\n\n    try {\n      await this._acknowledge({acknowledgement, handoff, job})\n    } catch (error) {\n      this._pendingAcknowledgements.set(job.id, {acknowledgement, handoff, job})\n      this._reportAcknowledgementError({acknowledgement, error, handoff, job})\n    }\n  }\n\n  /**\n   * Applies one fenced durable acknowledgement.\n   * @param {PendingLocalBackgroundJobAcknowledgement} args - Owned acknowledgement.\n   * @returns {Promise<void>} - Resolves after the durable transition is settled.\n   */\n  async _acknowledge({acknowledgement, handoff, job}) {\n    if (acknowledgement.type === \"rescheduled\") {\n      await this.store.markRescheduled({delayMs: acknowledgement.delayMs, handoffId: handoff.handoffId, jobId: job.id})\n      return\n    }\n\n    if (acknowledgement.type === \"failed\") {\n      const updatedJob = await this.store.markFailed({error: acknowledgement.error, handoffId: handoff.handoffId, jobId: job.id})\n\n      if (updatedJob) this._emitBackgroundJobFailed({error: acknowledgement.error, job: updatedJob})\n      return\n    }\n\n    await this.store.markCompleted({handoffId: handoff.handoffId, jobId: job.id})\n  }\n\n  /**\n   * Replays each retained acknowledgement once at an event-driven wake boundary.\n   * @param {{throwOnError?: boolean}} [args] - Recovery behavior.\n   * @returns {Promise<void>} - Resolves after one bounded recovery pass.\n   */\n  async _retryPendingAcknowledgements({throwOnError = false} = {}) {\n    for (const [jobId, pendingAcknowledgement] of [...this._pendingAcknowledgements]) {\n      try {\n        await this._acknowledge(pendingAcknowledgement)\n        this._pendingAcknowledgements.delete(jobId)\n      } catch (error) {\n        this._reportAcknowledgementError({...pendingAcknowledgement, error})\n        if (throwOnError) throw error\n        this._armRecoveryTimer()\n      }\n    }\n  }\n\n  /**\n   * Arms the exact next future job timer, chunking platform-sized delays.\n   * @returns {Promise<void>} - Resolves after timer reconciliation.\n   */\n  async _armScheduledTimer() {\n    if (this._scheduledTimer !== undefined) {\n      this.clock.clearTimeout(this._scheduledTimer)\n      this._scheduledTimer = undefined\n    }\n    if (!this._accepting) return\n\n    const nextJob = await this.store.nextScheduledJob()\n\n    if (!nextJob || nextJob.scheduledAtMs === null) return\n\n    const delayMs = Math.max(0, Math.min(nextJob.scheduledAtMs - this.clock.now(), MAX_TIMER_MS))\n\n    this._scheduledTimer = this.clock.setTimeout(() => {\n      this._scheduledTimer = undefined\n      this.wake()\n    }, delayMs)\n  }\n\n  /**\n   * Arms one bounded retry after an unexpected drain failure.\n   * @returns {void} - No return value.\n   */\n  _armRecoveryTimer() {\n    if (!this._accepting || this._recoveryTimer !== undefined) return\n\n    this._recoveryTimer = this.clock.setTimeout(() => {\n      this._recoveryTimer = undefined\n      this.wake()\n    }, ERROR_RECOVERY_DELAY_MS)\n  }\n\n  /**\n   * Waits for admission and every in-flight acknowledgement without polling.\n   * @returns {Promise<void>} - Resolves when idle.\n   */\n  async waitForIdle() {\n    if (this._isIdle()) return\n\n    await new Promise((resolve) => this._idleWaiters.add(() => resolve(undefined)))\n  }\n\n  /**\n   * Stops claims and waits for in-flight acknowledgement.\n   * @returns {Promise<void>} - Resolves after a graceful stop.\n   */\n  async stop() {\n    this._accepting = false\n    this._redrain = false\n\n    if (this._scheduledTimer !== undefined) {\n      this.clock.clearTimeout(this._scheduledTimer)\n      this._scheduledTimer = undefined\n    }\n    if (this._recoveryTimer !== undefined) {\n      this.clock.clearTimeout(this._recoveryTimer)\n      this._recoveryTimer = undefined\n    }\n\n    if (this._drainPromise) await this._drainPromise\n    if (this._inFlight.size > 0) await Promise.all([...this._inFlight])\n    await this._retryPendingAcknowledgements({throwOnError: true})\n\n    this._wakeQueued = false\n    this._started = false\n    this._resolveIdleWaiters()\n  }\n\n  /**\n   * Reports whether dispatcher admission has started.\n   * @returns {boolean} - Whether dispatcher admission has started.\n   */\n  isReady() { return this._started && this._accepting }\n\n  /**\n   * Reads the configuration-owned in-process performance cap.\n   * @returns {number} - Configuration-owned in-process performance cap.\n   */\n  _maxConcurrentJobs() { return this.configuration.getBackgroundJobsConfig().maxConcurrentInlineJobs }\n\n  /**\n   * Counts performances whose durable acknowledgement is still owned locally.\n   * @returns {number} - Active or pending-acknowledgement performances.\n   */\n  _ownedPerformanceCount() { return this._inFlight.size + this._pendingAcknowledgements.size }\n\n  /**\n   * Reports whether no admission or acknowledgement work remains.\n   * @returns {boolean} - Whether the dispatcher is idle.\n   */\n  _isIdle() {\n    return !this._wakeQueued && !this._drainPromise && this._inFlight.size === 0 && this._pendingAcknowledgements.size === 0\n  }\n\n  /**\n   * Resolves event-based idle waiters at a stable idle boundary.\n   * @returns {void} - No return value.\n   */\n  _resolveIdleWaiters() {\n    if (!this._isIdle()) return\n\n    const waiters = [...this._idleWaiters]\n\n    this._idleWaiters.clear()\n    for (const resolve of waiters) resolve()\n  }\n\n  /**\n   * Emits an expected job failure through the standard job/all-error channels.\n   * @param {{error: ReturnType<typeof JSON.parse>, job: import(\"./types.js\").BackgroundJobRow}} args - Failure transition.\n   * @returns {void} - No return value.\n   */\n  _emitBackgroundJobFailed({error, job}) {\n    const normalizedError = error instanceof Error ? error : new Error(String(error))\n    const payload = {\n      context: {\n        attempts: job.attempts,\n        jobArgs: job.args,\n        jobId: job.id,\n        jobName: job.jobName,\n        maxRetries: job.maxRetries,\n        stage: \"background-job-failed\",\n        status: job.status,\n        terminal: job.status === \"failed\",\n        willRetry: job.status === \"queued\",\n        workerId: \"local\"\n      },\n      error: normalizedError\n    }\n    const errorEvents = this.configuration.getErrorEvents()\n\n    errorEvents.emit(\"background-job-failed\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"background-job-failed\"})\n  }\n\n  /**\n   * Reports one failed durable acknowledgement attempt with its fence context.\n   * @param {PendingLocalBackgroundJobAcknowledgement & {error: ReturnType<typeof JSON.parse>}} args - Failed acknowledgement.\n   * @returns {void} - No return value.\n   */\n  _reportAcknowledgementError({acknowledgement, error, handoff, job}) {\n    this._reportFrameworkError({\n      context: {\n        acknowledgementType: acknowledgement.type,\n        handoffId: handoff.handoffId,\n        jobId: job.id,\n        jobName: job.jobName,\n        workerId: \"local\"\n      },\n      error,\n      stage: \"local-background-jobs-acknowledgement\"\n    })\n  }\n\n  /**\n   * Reports an unexpected dispatcher failure through framework channels.\n   * @param {object} args - Unexpected failure.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.context] - Additional failure context.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Unexpected error.\n   * @param {string} args.stage - Dispatcher stage.\n   * @returns {void} - No return value.\n   */\n  _reportFrameworkError({context = {}, error, stage}) {\n    const normalizedError = error instanceof Error ? error : new Error(String(error))\n    const payload = {context: {...context, stage}, error: normalizedError}\n    const errorEvents = this.configuration.getErrorEvents()\n\n    errorEvents.emit(\"framework-error\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n  }\n}\n"]}