@byline/core 4.14.1 → 4.16.0

package/dist/scheduler/run-due-tasks.test.node.js

@@ -0,0 +1,396 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { defineRecurringTask } from './define-recurring-task.js';
+import { runDueTasks, runDueTasksWithDeps } from './run-due-tasks.js';
+const silentLogger = {
+    log: vi.fn(),
+    fatal: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+    trace: vi.fn(),
+    silent: vi.fn(),
+};
+function claimed(name, recoveredExpiredLease = false) {
+    return {
+        name,
+        leaseToken: `token-${name}`,
+        scheduledFor: new Date('2026-08-22T00:00:00Z'),
+        databaseNow: new Date('2026-08-22T00:00:01Z'),
+        recoveredExpiredLease,
+    };
+}
+function fakeStore(overrides = {}) {
+    return {
+        reconcile: vi.fn(async () => { }),
+        claim: vi.fn(async () => null),
+        renew: vi.fn(async () => true),
+        complete: vi.fn(async () => true),
+        fail: vi.fn(async () => true),
+        health: vi.fn(async () => []),
+        ...overrides,
+    };
+}
+function task(name, run = async () => { }) {
+    return defineRecurringTask({
+        name,
+        intervalMs: 60_000,
+        leaseMs: 60_000,
+        run,
+    });
+}
+describe('runDueTasks', () => {
+    it('does nothing when no task is due', async () => {
+        const run = vi.fn(async () => { });
+        const store = fakeStore();
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [task('a', run)],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(run).not.toHaveBeenCalled();
+        expect(summary).toEqual({ claimed: 0, succeeded: 0, failed: 0, aborted: 0 });
+    });
+    it('reconciles the registered definitions before attempting claims', async () => {
+        const operations = [];
+        const store = fakeStore({
+            reconcile: vi.fn(async (definitions) => {
+                operations.push('reconcile');
+                expect(definitions).toEqual([{ name: 'a', intervalMs: 60_000 }]);
+            }),
+            claim: vi.fn(async () => {
+                operations.push('claim');
+                return null;
+            }),
+        });
+        await runDueTasksWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(operations).toEqual(['reconcile', 'claim']);
+    });
+    it('rejects a pass when reconciliation fails so external cron observes the outage', async () => {
+        const error = new Error('reconcile unavailable');
+        const logger = { ...silentLogger, error: vi.fn() };
+        const store = fakeStore({
+            reconcile: vi.fn(async () => {
+                throw error;
+            }),
+        });
+        await expect(runDueTasksWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger,
+        })).rejects.toBe(error);
+        expect(store.claim).not.toHaveBeenCalled();
+        expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ event: 'scheduler.reconcile-error', err: error }), expect.any(String));
+    });
+    it('runs a claimed task and completes it', async () => {
+        const run = vi.fn(async () => { });
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [task('a', run)],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(run).toHaveBeenCalledTimes(1);
+        expect(store.complete).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'a',
+            leaseToken: 'token-a',
+            durationMs: expect.any(Number),
+            workRemaining: false,
+        }));
+        expect(summary).toEqual({ claimed: 1, succeeded: 1, failed: 0, aborted: 0 });
+    });
+    it('passes workRemaining through to complete', async () => {
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const recurringTask = defineRecurringTask({
+            name: 'a',
+            intervalMs: 3_600_000,
+            leaseMs: 60_000,
+            run: async () => ({ workRemaining: true }),
+        });
+        await runDueTasksWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(store.complete).toHaveBeenCalledWith(expect.objectContaining({ workRemaining: true }));
+    });
+    it('sanitizes and bounds a handler error before recording failure', async () => {
+        const error = new Error(`boom\u0000${'x'.repeat(3_000)}\nstack-like detail`);
+        const logger = { ...silentLogger, error: vi.fn() };
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const recurringTask = task('a', async () => {
+            throw error;
+        });
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger,
+        });
+        const failure = vi.mocked(store.fail).mock.calls[0]?.[0];
+        expect(failure?.error).toHaveLength(2_048);
+        expect(failure?.error).not.toContain('\u0000');
+        expect(failure?.error).not.toContain('\r');
+        expect(failure?.error).not.toContain('\n');
+        expect(failure?.error).not.toContain('stack-like detail');
+        expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ err: error, name: 'a', owner: 'test' }), expect.any(String));
+        expect(summary).toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+    });
+    it('continues other tasks when a handler fails', async () => {
+        const ranB = vi.fn(async () => { });
+        const store = fakeStore({ claim: vi.fn(async ({ name }) => claimed(name)) });
+        const tasks = [
+            task('a', async () => {
+                throw new Error('boom');
+            }),
+            task('b', ranB),
+        ];
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks,
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(ranB).toHaveBeenCalledTimes(1);
+        expect(summary).toEqual({ claimed: 2, succeeded: 1, failed: 1, aborted: 0 });
+    });
+    it('contains and counts store failures without rejecting the pass', async () => {
+        const ranB = vi.fn(async () => { });
+        const store = fakeStore({
+            claim: vi.fn(async ({ name }) => {
+                if (name === 'a')
+                    throw new Error('db down');
+                return claimed(name);
+            }),
+        });
+        await expect(runDueTasksWithDeps({
+            store,
+            tasks: [task('a'), task('b', ranB)],
+            owner: 'test',
+            logger: silentLogger,
+        })).resolves.toEqual({ claimed: 1, succeeded: 1, failed: 1, aborted: 0 });
+        expect(ranB).toHaveBeenCalledTimes(1);
+    });
+    it('contains a completion-store rejection without attempting fail', async () => {
+        const store = fakeStore({
+            claim: vi.fn(async () => claimed('a')),
+            complete: vi.fn(async () => {
+                throw new Error('completion unavailable');
+            }),
+        });
+        await expect(runDueTasksWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+        })).resolves.toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+        expect(store.fail).not.toHaveBeenCalled();
+    });
+    it('contains a failure-store rejection without rejecting the pass', async () => {
+        const store = fakeStore({
+            claim: vi.fn(async () => claimed('a')),
+            fail: vi.fn(async () => {
+                throw new Error('failure recorder unavailable');
+            }),
+        });
+        await expect(runDueTasksWithDeps({
+            store,
+            tasks: [
+                task('a', async () => {
+                    throw new Error('handler failed');
+                }),
+            ],
+            owner: 'test',
+            logger: silentLogger,
+        })).resolves.toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+    });
+    it('aborts before heartbeat rejects and never finalizes a known-lost lease', async () => {
+        const store = fakeStore({
+            claim: vi.fn(async () => claimed('a')),
+            renew: vi.fn(async () => false),
+        });
+        let abortedWhenHeartbeatRejected = false;
+        const recurringTask = defineRecurringTask({
+            name: 'a',
+            intervalMs: 3_600_000,
+            leaseMs: 60_000,
+            run: async (context) => {
+                try {
+                    await context.heartbeat();
+                }
+                catch {
+                    abortedWhenHeartbeatRejected = context.signal.aborted;
+                }
+            },
+        });
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(abortedWhenHeartbeatRejected).toBe(true);
+        expect(store.complete).not.toHaveBeenCalled();
+        expect(store.fail).not.toHaveBeenCalled();
+        expect(summary).toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+    });
+    it('aborts and avoids finalization when the heartbeat store call rejects', async () => {
+        const store = fakeStore({
+            claim: vi.fn(async () => claimed('a')),
+            renew: vi.fn(async () => {
+                throw new Error('renew unavailable');
+            }),
+        });
+        let heartbeatRejectedAfterAbort = false;
+        const recurringTask = defineRecurringTask({
+            name: 'a',
+            intervalMs: 60_000,
+            leaseMs: 60_000,
+            run: async (context) => {
+                try {
+                    await context.heartbeat();
+                }
+                catch {
+                    heartbeatRejectedAfterAbort = context.signal.aborted;
+                }
+            },
+        });
+        await expect(runDueTasksWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+        })).resolves.toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+        expect(heartbeatRejectedAfterAbort).toBe(true);
+        expect(store.complete).not.toHaveBeenCalled();
+        expect(store.fail).not.toHaveBeenCalled();
+    });
+    it('does not finalize after the incoming signal aborts an active handler', async () => {
+        const controller = new AbortController();
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const recurringTask = defineRecurringTask({
+            name: 'a',
+            intervalMs: 60_000,
+            leaseMs: 60_000,
+            run: async (context) => {
+                controller.abort();
+                expect(context.signal.aborted).toBe(true);
+            },
+        });
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+            signal: controller.signal,
+        });
+        expect(store.complete).not.toHaveBeenCalled();
+        expect(store.fail).not.toHaveBeenCalled();
+        expect(summary).toEqual({ claimed: 1, succeeded: 0, failed: 0, aborted: 1 });
+    });
+    it('stops claiming new definitions after the incoming signal aborts', async () => {
+        const controller = new AbortController();
+        const store = fakeStore({
+            claim: vi.fn(async ({ name }) => {
+                controller.abort();
+                return claimed(name);
+            }),
+        });
+        await runDueTasksWithDeps({
+            store,
+            tasks: [task('a'), task('b')],
+            owner: 'test',
+            logger: silentLogger,
+            signal: controller.signal,
+            concurrency: 1,
+        });
+        expect(store.claim).toHaveBeenCalledTimes(1);
+        expect(store.claim).toHaveBeenCalledWith({ name: 'a', leaseMs: 60_000, owner: 'test' });
+    });
+    it('defaults to two concurrent handlers while still attempting every definition', async () => {
+        let active = 0;
+        let maximumActive = 0;
+        const releases = [];
+        const store = fakeStore({ claim: vi.fn(async ({ name }) => claimed(name)) });
+        const tasks = ['a', 'b', 'c', 'd'].map((name) => task(name, () => new Promise((resolve) => {
+            active += 1;
+            maximumActive = Math.max(maximumActive, active);
+            releases.push(() => {
+                active -= 1;
+                resolve();
+            });
+        })));
+        const pass = runDueTasksWithDeps({
+            store,
+            tasks,
+            owner: 'test',
+            logger: silentLogger,
+        });
+        await vi.waitFor(() => expect(releases).toHaveLength(2));
+        releases.shift()?.();
+        await vi.waitFor(() => expect(releases).toHaveLength(2));
+        releases.shift()?.();
+        await vi.waitFor(() => expect(releases).toHaveLength(2));
+        releases.splice(0).forEach((release) => {
+            release();
+        });
+        await expect(pass).resolves.toEqual({ claimed: 4, succeeded: 4, failed: 0, aborted: 0 });
+        expect(maximumActive).toBe(2);
+        expect(store.claim).toHaveBeenCalledTimes(4);
+    });
+    it('treats a rejected completion fence as lease loss without calling fail', async () => {
+        const store = fakeStore({
+            claim: vi.fn(async () => claimed('a')),
+            complete: vi.fn(async () => false),
+        });
+        const summary = await runDueTasksWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+        });
+        expect(store.fail).not.toHaveBeenCalled();
+        expect(summary).toEqual({ claimed: 1, succeeded: 0, failed: 1, aborted: 0 });
+    });
+    it('logs recovery when a claim takes over an expired lease', async () => {
+        const logger = { ...silentLogger, warn: vi.fn() };
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a', true)) });
+        await runDueTasksWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger,
+        });
+        expect(logger.warn).toHaveBeenCalledWith(expect.objectContaining({ event: 'scheduler.recovered-expired-lease', name: 'a' }), expect.any(String));
+    });
+    it('uses only core.recurringTasks and reports a missing scheduler capability', async () => {
+        const coreRun = vi.fn(async () => { });
+        const injectedRun = vi.fn(async () => { });
+        const store = fakeStore({ claim: vi.fn(async ({ name }) => claimed(name)) });
+        const core = {
+            db: { scheduler: store },
+            recurringTasks: [task('core-task', coreRun)],
+            logger: silentLogger,
+        };
+        await runDueTasks(core, { owner: 'test', tasks: [task('injected-task', injectedRun)] });
+        expect(coreRun).toHaveBeenCalledTimes(1);
+        expect(injectedRun).not.toHaveBeenCalled();
+        await expect(runDueTasks({ ...core, db: {} }, { owner: 'test' })).rejects.toThrow(/scheduler capability/i);
+    });
+});

package/dist/scheduler/scheduled-publication-constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/** Inert built-in task metadata, safe for core initialization to import. */
+export declare const SCHEDULED_PUBLICATION_TASK_NAME = "documents.publish-scheduled";
+export declare const SCHEDULED_PUBLICATION_INTERVAL_MS = 60000;
+export declare const SCHEDULED_PUBLICATION_LEASE_MS: number;

package/dist/scheduler/scheduled-publication-constants.js

@@ -0,0 +1,11 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/** Inert built-in task metadata, safe for core initialization to import. */
+export const SCHEDULED_PUBLICATION_TASK_NAME = 'documents.publish-scheduled';
+export const SCHEDULED_PUBLICATION_INTERVAL_MS = 60_000;
+export const SCHEDULED_PUBLICATION_LEASE_MS = 5 * 60_000;

package/dist/scheduler/scheduled-publication.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { BylineCore } from '../core.js';
+import type { BylineLogger } from '../lib/logger.js';
+export interface ScheduledPublicationSweepOptions {
+    /** Abort before claiming another batch. */
+    signal?: AbortSignal;
+    /** Stop claiming new work after this process-time budget. */
+    budgetMs?: number;
+    /** Maximum schedules claimed per batch. */
+    batchSize?: number;
+    /** Renew an enclosing scheduler lease between batches. */
+    heartbeat?: () => Promise<void>;
+    logger?: BylineLogger;
+}
+export interface ScheduledPublicationSweepResult {
+    published: number;
+    failed: number;
+    workRemaining: boolean;
+}
+/**
+ * Drain due publication schedules without depending on the in-process ticker.
+ * Database claims provide the execution fence, so independent external
+ * orchestrators may invoke this operation concurrently.
+ */
+export declare function runScheduledPublicationSweep(core: BylineCore, options?: ScheduledPublicationSweepOptions): Promise<ScheduledPublicationSweepResult>;

package/dist/scheduler/scheduled-publication.js

@@ -0,0 +1,198 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { createSuperAdminContext } from '@byline/auth';
+import { AUDIT_ACTIONS, requireAuditCapability } from '../services/document-lifecycle/audit.js';
+import { publishScheduleAuditValue } from '../services/document-lifecycle/publish-schedule-consistency.js';
+import { publishClaimedScheduledDocument } from '../services/document-lifecycle/scheduled-publish.js';
+import { SCHEDULED_PUBLICATION_LEASE_MS } from './scheduled-publication-constants.js';
+const DEFAULT_BATCH_SIZE = 25;
+const DEFAULT_BUDGET_MS = 45_000;
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    if (signal.reason instanceof Error)
+        throw signal.reason;
+    throw new DOMException('scheduled publication sweep aborted', 'AbortError');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function resolveCollection(core, collectionId) {
+    for (const definition of core.collections) {
+        const record = core.collectionRecords.get(definition.path);
+        if (record?.collectionId === collectionId)
+            return { definition, version: record.version };
+    }
+    return null;
+}
+function buildSystemContext(core, claim, logger) {
+    const collection = resolveCollection(core, claim.collectionId);
+    if (collection === null)
+        return null;
+    return {
+        db: core.db,
+        definition: collection.definition,
+        collectionId: claim.collectionId,
+        collectionVersion: collection.version,
+        collectionPath: collection.definition.path,
+        storage: core.storage,
+        logger,
+        defaultLocale: core.config.i18n.content.defaultLocale,
+        slugifier: core.config.slugifier,
+        requestContext: createSuperAdminContext({ id: 'scheduled-publication' }),
+    };
+}
+async function finalizeClaim(params) {
+    const audit = requireAuditCapability(params.core.db);
+    return audit.withTransaction(async () => {
+        const locked = await params.core.db.commands.documents.publishSchedules.lockClaim({
+            documentId: params.claim.documentId,
+            executionToken: params.claim.executionToken,
+        });
+        if (locked === null)
+            return false;
+        const changed = params.outcome === 'suspend'
+            ? await params.core.db.commands.documents.publishSchedules.suspendClaimForContentEdit({
+                documentId: params.claim.documentId,
+                executionToken: params.claim.executionToken,
+            })
+            : await params.core.db.commands.documents.publishSchedules.deleteClaim({
+                documentId: params.claim.documentId,
+                executionToken: params.claim.executionToken,
+            });
+        if (!changed)
+            return false;
+        await audit.append({
+            documentId: params.claim.documentId,
+            collectionId: params.claim.collectionId,
+            actorRealm: 'system',
+            action: params.outcome === 'suspend'
+                ? AUDIT_ACTIONS.publishScheduleSuspended
+                : AUDIT_ACTIONS.publishScheduleDiscarded,
+            field: 'scheduled_publish',
+            before: publishScheduleAuditValue(locked),
+            after: params.outcome === 'suspend'
+                ? { state: 'needs_reconfirm', reason: params.reason }
+                : { reason: params.reason },
+        });
+        return true;
+    });
+}
+async function processClaim(params) {
+    try {
+        const ctx = buildSystemContext(params.core, params.claim, params.logger);
+        if (ctx === null) {
+            await finalizeClaim({
+                core: params.core,
+                claim: params.claim,
+                outcome: 'discard',
+                reason: 'collection_not_registered',
+            });
+            params.logger.warn({ documentId: params.claim.documentId, collectionId: params.claim.collectionId }, 'discarded scheduled publication for an unregistered collection');
+            return 'handled';
+        }
+        const result = await publishClaimedScheduledDocument(ctx, {
+            documentId: params.claim.documentId,
+            executionToken: params.claim.executionToken,
+        });
+        if (result.status === 'published')
+            return 'published';
+        if (result.status === 'claim_lost')
+            return 'handled';
+        if (result.status === 'target_changed') {
+            await finalizeClaim({
+                core: params.core,
+                claim: params.claim,
+                outcome: 'suspend',
+                reason: 'content_edited',
+            });
+            return 'handled';
+        }
+        await finalizeClaim({
+            core: params.core,
+            claim: params.claim,
+            outcome: 'discard',
+            reason: result.reason,
+        });
+        params.logger.warn({ documentId: params.claim.documentId, reason: result.reason }, 'discarded terminal scheduled publication');
+        return 'handled';
+    }
+    catch (error) {
+        try {
+            params.logger.error({ err: error, documentId: params.claim.documentId }, 'scheduled publication attempt failed');
+        }
+        catch {
+            // A logger failure must not prevent release of the execution claim.
+        }
+        const released = await params.core.db.commands.documents.publishSchedules.releaseClaim({
+            documentId: params.claim.documentId,
+            executionToken: params.claim.executionToken,
+            error: errorMessage(error),
+        });
+        return released ? 'failed' : 'handled';
+    }
+}
+/**
+ * Drain due publication schedules without depending on the in-process ticker.
+ * Database claims provide the execution fence, so independent external
+ * orchestrators may invoke this operation concurrently.
+ */
+export async function runScheduledPublicationSweep(core, options = {}) {
+    const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    const budgetMs = options.budgetMs ?? DEFAULT_BUDGET_MS;
+    if (!Number.isInteger(batchSize) || batchSize < 1) {
+        throw new TypeError('scheduled publication batchSize must be a positive integer');
+    }
+    if (!Number.isFinite(budgetMs) || budgetMs < 0) {
+        throw new TypeError('scheduled publication budgetMs must be a finite non-negative number');
+    }
+    const logger = options.logger ?? core.logger;
+    const startedAt = performance.now();
+    let published = 0;
+    let failed = 0;
+    let completedBatch = false;
+    while (true) {
+        throwIfAborted(options.signal);
+        if (performance.now() - startedAt >= budgetMs) {
+            return { published, failed, workRemaining: true };
+        }
+        if (completedBatch)
+            await options.heartbeat?.();
+        const claims = await core.db.commands.documents.publishSchedules.claimDue({
+            batchSize,
+            leaseMs: SCHEDULED_PUBLICATION_LEASE_MS,
+        });
+        if (claims.length === 0)
+            return { published, failed, workRemaining: false };
+        for (const claim of claims) {
+            try {
+                const result = await processClaim({ core, claim, logger });
+                if (result === 'published')
+                    published++;
+                if (result === 'failed')
+                    failed++;
+            }
+            catch (error) {
+                // Claim recovery is best effort. A database outage may make both the
+                // document operation and its token release fail; the claim then
+                // expires naturally, but the rest of this batch must still run.
+                failed++;
+                try {
+                    logger.error({ err: error, documentId: claim.documentId }, 'scheduled publication failure could not release its execution claim');
+                }
+                catch {
+                    // Diagnostic logging cannot turn one item into a batch failure.
+                }
+            }
+        }
+        completedBatch = true;
+        if (claims.length < batchSize) {
+            return { published, failed, workRemaining: false };
+        }
+    }
+}

package/dist/scheduler/scheduled-publication.test.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};