@byline/core 4.14.1 → 4.15.0

package/dist/scheduler/scheduled-publication.test.node.js

@@ -0,0 +1,109 @@
+/**
+ * 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 { runScheduledPublicationSweep } from './scheduled-publication.js';
+const logger = {
+    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 emptyCore() {
+    const claimDue = vi.fn().mockResolvedValue([]);
+    return {
+        core: {
+            db: { commands: { documents: { publishSchedules: { claimDue } } } },
+            logger,
+        },
+        claimDue,
+    };
+}
+function claim(documentId) {
+    const now = new Date('2026-08-22T12:00:00.000Z');
+    return {
+        documentId,
+        collectionId: 'unregistered-collection',
+        targetVersionId: `version-${documentId}`,
+        publishAt: now,
+        state: 'armed',
+        suspendedAt: null,
+        suspendedReason: null,
+        scheduledBy: null,
+        lastAuthorizedBy: null,
+        lastAuthorizedAt: now,
+        scheduledAt: now,
+        updatedAt: now,
+        executionToken: `token-${documentId}`,
+        executionExpiresAt: new Date(now.getTime() + 60_000),
+        lastAttemptAt: now,
+        nextAttemptAt: now,
+        attemptCount: 1,
+        lastError: null,
+        databaseNow: now,
+        recoveredExpiredClaim: false,
+    };
+}
+describe('runScheduledPublicationSweep', () => {
+    it('returns a drained summary when no schedules are due', async () => {
+        const { core, claimDue } = emptyCore();
+        await expect(runScheduledPublicationSweep(core, { batchSize: 10, budgetMs: 5_000 })).resolves.toEqual({ published: 0, failed: 0, workRemaining: false });
+        expect(claimDue).toHaveBeenCalledWith({ batchSize: 10, leaseMs: 300_000 });
+    });
+    it.each([
+        [{ batchSize: 0 }, 'batchSize'],
+        [{ batchSize: 1.5 }, 'batchSize'],
+        [{ budgetMs: -1 }, 'budgetMs'],
+        [{ budgetMs: Number.POSITIVE_INFINITY }, 'budgetMs'],
+    ])('rejects invalid operational limits: %o', async (options, expected) => {
+        const { core, claimDue } = emptyCore();
+        await expect(runScheduledPublicationSweep(core, options)).rejects.toThrow(expected);
+        expect(claimDue).not.toHaveBeenCalled();
+    });
+    it('honours an already-aborted signal before claiming work', async () => {
+        const { core, claimDue } = emptyCore();
+        const controller = new AbortController();
+        controller.abort(new Error('stopping'));
+        await expect(runScheduledPublicationSweep(core, { signal: controller.signal })).rejects.toThrow('stopping');
+        expect(claimDue).not.toHaveBeenCalled();
+    });
+    it('continues the batch when both cleanup and claim release fail for one item', async () => {
+        const first = claim('first');
+        const second = claim('second');
+        const claimDue = vi.fn().mockResolvedValue([first, second]);
+        const lockClaim = vi.fn(async ({ documentId }) => {
+            if (documentId === first.documentId)
+                throw new Error('cleanup unavailable');
+            return second;
+        });
+        const deleteClaim = vi.fn().mockResolvedValue(true);
+        const releaseClaim = vi.fn(async () => {
+            throw new Error('release unavailable');
+        });
+        const core = {
+            collections: [],
+            collectionRecords: new Map(),
+            db: {
+                withTransaction: async (fn) => fn(),
+                commands: {
+                    audit: { append: vi.fn().mockResolvedValue({ id: 'audit-1' }) },
+                    documents: {
+                        publishSchedules: { claimDue, lockClaim, deleteClaim, releaseClaim },
+                    },
+                },
+            },
+            logger,
+        };
+        await expect(runScheduledPublicationSweep(core, { batchSize: 10, budgetMs: 5_000 })).resolves.toEqual({ published: 0, failed: 1, workRemaining: false });
+        expect(releaseClaim).toHaveBeenCalledWith(expect.objectContaining({ documentId: first.documentId }));
+        expect(deleteClaim).toHaveBeenCalledWith(expect.objectContaining({ documentId: second.documentId }));
+    });
+});

package/dist/scheduler/scheduler-boot.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 {};

package/dist/scheduler/scheduler-boot.test.node.js

@@ -0,0 +1,103 @@
+/**
+ * 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 } from 'vitest';
+import { initBylineCore } from '../core.js';
+import { defineRecurringTask } from './define-recurring-task.js';
+// Boot-level coverage for the scheduler wiring inside `initBylineCore()`,
+// complementing the pure-function coverage in `validate-scheduler-config.test.node.ts`.
+// Collections are kept empty and `db` a minimal stub so init reaches the
+// scheduler gate without needing a real database — see `core.test.node.ts`
+// for the same pattern.
+function serverConfig(db) {
+    return {
+        routes: { admin: '/admin' },
+        collections: [],
+        db,
+        i18n: {
+            admin: { defaultLocale: 'en', locales: [] },
+            content: { defaultLocale: 'en', locales: [] },
+        },
+    };
+}
+const task = defineRecurringTask({
+    name: 'analytics.rollup',
+    intervalMs: 3_600_000,
+    leaseMs: 300_000,
+    run: async () => { },
+});
+describe('initBylineCore scheduler wiring', () => {
+    it('rejects recurring tasks registered against an adapter without the scheduler capability', async () => {
+        const config = serverConfig({});
+        config.recurringTasks = [task];
+        await expect(initBylineCore(config, {})).rejects.toThrow(/analytics\.rollup/);
+    });
+    it('gates scheduled publication on the scheduler capability and contributes its built-in task', async () => {
+        const unsupported = serverConfig({});
+        unsupported.scheduledPublication = { enabled: true };
+        await expect(initBylineCore(unsupported, {})).rejects.toThrow(/documents\.publish-scheduled/);
+        const capable = serverConfig({ scheduler: {} });
+        capable.scheduledPublication = { enabled: true };
+        capable.recurringTasks = [task];
+        const core = await initBylineCore(capable, {});
+        expect(core.recurringTasks.map((definition) => definition.name)).toEqual([
+            'analytics.rollup',
+            'documents.publish-scheduled',
+        ]);
+        expect(core.recurringTasks[1]).toMatchObject({
+            intervalMs: 60_000,
+            leaseMs: 300_000,
+        });
+    });
+    it('populates core.recurringTasks with the registered set when the adapter is capable', async () => {
+        const db = { scheduler: {} };
+        const config = serverConfig(db);
+        config.recurringTasks = [task];
+        const core = await initBylineCore(config, {});
+        expect(core.recurringTasks).toHaveLength(1);
+        const [registered] = core.recurringTasks;
+        expect(registered).toMatchObject({ name: 'analytics.rollup', intervalMs: 3_600_000 });
+    });
+    it('freezes the validated snapshot so post-init mutation of the caller input cannot alter it', async () => {
+        const db = { scheduler: {} };
+        const localTask = defineRecurringTask({
+            name: 'analytics.local',
+            intervalMs: 3_600_000,
+            leaseMs: 300_000,
+            run: async () => { },
+        });
+        const originalTasks = [localTask];
+        const config = serverConfig(db);
+        config.recurringTasks = originalTasks;
+        const core = await initBylineCore(config, {});
+        // Mutate the caller's own array and one of its definition objects after
+        // init has returned.
+        originalTasks.push(defineRecurringTask({
+            name: 'analytics.extra',
+            intervalMs: 3_600_000,
+            leaseMs: 300_000,
+            run: async () => { },
+        }));
+        localTask.intervalMs = 999;
+        // The snapshot on `core` is unaffected by either mutation.
+        expect(core.recurringTasks).toHaveLength(1);
+        const [snapshotTask] = core.recurringTasks;
+        expect(snapshotTask?.intervalMs).toBe(3_600_000);
+        expect(snapshotTask?.name).toBe('analytics.local');
+        // The snapshot array and its definition objects are themselves frozen.
+        // ES modules are always strict mode, so mutating a frozen array or
+        // object throws rather than silently no-op'ing.
+        expect(() => {
+            ;
+            core.recurringTasks.push('nope');
+        }).toThrow(TypeError);
+        expect(() => {
+            ;
+            snapshotTask.intervalMs = 1;
+        }).toThrow(TypeError);
+    });
+});

package/dist/scheduler/ticker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 '../logger/index.js';
+import type { ISchedulerStore, RecurringTaskDefinition } from './types.js';
+export interface SchedulerOptions {
+    tickIntervalMs?: number;
+    startupJitterMs?: number;
+    concurrency?: number;
+    owner?: string;
+    shutdownGraceMs?: number;
+}
+export interface SchedulerController {
+    stop(): Promise<void>;
+}
+interface SchedulerDeps extends SchedulerOptions {
+    store: ISchedulerStore;
+    tasks: readonly RecurringTaskDefinition[];
+    owner: string;
+    logger: BylineLogger;
+}
+/**
+ * Dependency-injected ticker used by unit tests. It is intentionally absent
+ * from the `@byline/core/scheduler` barrel.
+ */
+export declare function startSchedulerWithDeps(params: SchedulerDeps): SchedulerController;
+/** Start the opt-in, in-process ticker over the definitions vetted at boot. */
+export declare function startBylineScheduler(core: BylineCore, options?: SchedulerOptions): SchedulerController;
+export {};

package/dist/scheduler/ticker.js

@@ -0,0 +1,144 @@
+/**
+ * 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 { defaultOwner, runDueTasksWithDeps } from './run-due-tasks.js';
+const DEFAULT_TICK_INTERVAL_MS = 60_000;
+const DEFAULT_STARTUP_JITTER_MS = 30_000;
+const DEFAULT_SHUTDOWN_GRACE_MS = 5_000;
+function assertWholeNumber(params) {
+    const minimum = params.allowZero === true ? 0 : 1;
+    if (!Number.isSafeInteger(params.value) || params.value < minimum) {
+        throw new Error(`${params.name} must be a ${params.allowZero === true ? 'non-negative' : 'positive'} ` +
+            `whole number${params.unit ?? ''} (received ${params.value})`);
+    }
+}
+function unrefTimer(handle) {
+    handle.unref?.();
+}
+function startupDelay(maximumMs) {
+    if (maximumMs === 0)
+        return 0;
+    return Math.min(maximumMs, Math.floor(Math.random() * (maximumMs + 1)));
+}
+function waitForTickOrGrace(activeTick, graceMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(graceTimer);
+            resolve();
+        };
+        const graceTimer = setTimeout(finish, graceMs);
+        unrefTimer(graceTimer);
+        void activeTick.then(finish, finish);
+    });
+}
+/**
+ * Dependency-injected ticker used by unit tests. It is intentionally absent
+ * from the `@byline/core/scheduler` barrel.
+ */
+export function startSchedulerWithDeps(params) {
+    const tickIntervalMs = params.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS;
+    const startupJitterMs = params.startupJitterMs ?? DEFAULT_STARTUP_JITTER_MS;
+    const shutdownGraceMs = params.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS;
+    assertWholeNumber({ value: tickIntervalMs, name: 'tickIntervalMs', unit: ' of milliseconds' });
+    assertWholeNumber({
+        value: startupJitterMs,
+        name: 'startupJitterMs',
+        allowZero: true,
+        unit: ' of milliseconds',
+    });
+    assertWholeNumber({
+        value: shutdownGraceMs,
+        name: 'shutdownGraceMs',
+        allowZero: true,
+        unit: ' of milliseconds',
+    });
+    if (params.concurrency !== undefined) {
+        assertWholeNumber({ value: params.concurrency, name: 'concurrency' });
+    }
+    const owner = params.owner.slice(0, 255);
+    const controller = new AbortController();
+    let stopped = false;
+    let nextTimeout;
+    let activeTick;
+    const schedule = (delayMs) => {
+        if (stopped)
+            return;
+        nextTimeout = setTimeout(() => {
+            nextTimeout = undefined;
+            if (stopped)
+                return;
+            const currentTick = (async () => {
+                try {
+                    await runDueTasksWithDeps({
+                        store: params.store,
+                        tasks: params.tasks,
+                        owner,
+                        logger: params.logger,
+                        signal: controller.signal,
+                        concurrency: params.concurrency,
+                    });
+                }
+                catch (error) {
+                    params.logger.error({
+                        event: 'scheduler.tick-error',
+                        owner,
+                        durationMs: 0,
+                        err: error,
+                    }, 'Recurring task scheduler tick failed');
+                }
+            })();
+            activeTick = currentTick;
+            const finishTick = () => {
+                if (activeTick === currentTick)
+                    activeTick = undefined;
+                if (!stopped)
+                    schedule(tickIntervalMs);
+            };
+            void currentTick.then(finishTick, finishTick);
+        }, delayMs);
+        unrefTimer(nextTimeout);
+    };
+    schedule(startupDelay(startupJitterMs));
+    return {
+        stop: () => {
+            if (stopped)
+                return Promise.resolve();
+            stopped = true;
+            if (nextTimeout !== undefined) {
+                clearTimeout(nextTimeout);
+                nextTimeout = undefined;
+            }
+            controller.abort(new Error('Recurring task scheduler stopped'));
+            const tickAtStop = activeTick;
+            if (tickAtStop === undefined)
+                return Promise.resolve();
+            return waitForTickOrGrace(tickAtStop, shutdownGraceMs);
+        },
+    };
+}
+/** Start the opt-in, in-process ticker over the definitions vetted at boot. */
+export function startBylineScheduler(core, options = {}) {
+    const store = core.db.scheduler;
+    if (store === undefined) {
+        throw new Error('startBylineScheduler() requires a database adapter with the scheduler capability. ' +
+            'Use a canonical adapter (@byline/db-postgres or @byline/db-mysql).');
+    }
+    return startSchedulerWithDeps({
+        store,
+        tasks: core.recurringTasks,
+        owner: options.owner ?? defaultOwner(),
+        logger: core.logger,
+        tickIntervalMs: options.tickIntervalMs,
+        startupJitterMs: options.startupJitterMs,
+        concurrency: options.concurrency,
+        shutdownGraceMs: options.shutdownGraceMs,
+    });
+}

package/dist/scheduler/ticker.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 {};

package/dist/scheduler/ticker.test.node.js

@@ -0,0 +1,249 @@
+/**
+ * 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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { defineRecurringTask } from './define-recurring-task.js';
+import { startBylineScheduler, startSchedulerWithDeps } from './ticker.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 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 claimed(name) {
+    return {
+        name,
+        leaseToken: `token-${name}`,
+        scheduledFor: new Date('2026-08-22T00:00:00Z'),
+        databaseNow: new Date('2026-08-22T00:00:01Z'),
+        recoveredExpiredLease: false,
+    };
+}
+function task(name, run = async () => { }) {
+    return defineRecurringTask({ name, intervalMs: 60_000, leaseMs: 60_000, run });
+}
+describe('startBylineScheduler', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.spyOn(Math, 'random').mockReturnValue(0);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+    it('runs nothing before the startup jitter elapses', async () => {
+        vi.mocked(Math.random).mockReturnValue(1);
+        const store = fakeStore();
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 30_000,
+        });
+        await vi.advanceTimersByTimeAsync(29_999);
+        expect(store.reconcile).not.toHaveBeenCalled();
+        expect(store.claim).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(1);
+        expect(store.reconcile).toHaveBeenCalledTimes(1);
+        expect(store.claim).toHaveBeenCalledTimes(1);
+        await controller.stop();
+    });
+    it('unrefs the pending timeout so the ticker alone cannot keep Node alive', async () => {
+        vi.useRealTimers();
+        const probe = setTimeout(() => { }, 60_000);
+        const timerPrototype = Object.getPrototypeOf(probe);
+        const unref = vi.spyOn(timerPrototype, 'unref');
+        clearTimeout(probe);
+        const controller = startSchedulerWithDeps({
+            store: fakeStore(),
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 30_000,
+        });
+        expect(unref).toHaveBeenCalled();
+        await controller.stop();
+    });
+    it('reconciles before claims on every pass', async () => {
+        const operations = [];
+        const store = fakeStore({
+            reconcile: vi.fn(async () => {
+                operations.push('reconcile');
+            }),
+            claim: vi.fn(async () => {
+                operations.push('claim');
+                return null;
+            }),
+        });
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 0,
+            tickIntervalMs: 1_000,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        await vi.advanceTimersByTimeAsync(1_000);
+        expect(operations).toEqual(['reconcile', 'claim', 'reconcile', 'claim']);
+        await controller.stop();
+    });
+    it('does not overlap local ticks', async () => {
+        let releaseHandler;
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const recurringTask = task('a', () => new Promise((resolve) => {
+            releaseHandler = resolve;
+        }));
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 0,
+            tickIntervalMs: 1_000,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        await vi.advanceTimersByTimeAsync(5_000);
+        expect(store.reconcile).toHaveBeenCalledTimes(1);
+        expect(store.claim).toHaveBeenCalledTimes(1);
+        releaseHandler?.();
+        await vi.advanceTimersByTimeAsync(0);
+        await controller.stop();
+    });
+    it('stop prevents another tick and is idempotent', async () => {
+        const store = fakeStore();
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 0,
+            tickIntervalMs: 1_000,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        expect(store.claim).toHaveBeenCalledTimes(1);
+        await controller.stop();
+        await expect(controller.stop()).resolves.toBeUndefined();
+        await vi.advanceTimersByTimeAsync(5_000);
+        expect(store.claim).toHaveBeenCalledTimes(1);
+    });
+    it('stop aborts an in-flight handler without recording failure', async () => {
+        let handlerSignal;
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const recurringTask = defineRecurringTask({
+            name: 'a',
+            intervalMs: 60_000,
+            leaseMs: 60_000,
+            run: async (context) => {
+                handlerSignal = context.signal;
+                await new Promise((resolve) => {
+                    context.signal.addEventListener('abort', () => resolve(), { once: true });
+                });
+            },
+        });
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [recurringTask],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 0,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        expect(handlerSignal?.aborted).toBe(false);
+        await controller.stop();
+        expect(handlerSignal?.aborted).toBe(true);
+        expect(store.complete).not.toHaveBeenCalled();
+        expect(store.fail).not.toHaveBeenCalled();
+    });
+    it('stop resolves after its grace period when a handler ignores abort', async () => {
+        const store = fakeStore({ claim: vi.fn(async () => claimed('a')) });
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [task('a', () => new Promise(() => { }))],
+            owner: 'test',
+            logger: silentLogger,
+            startupJitterMs: 0,
+            shutdownGraceMs: 500,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        let stopped = false;
+        const stopping = controller.stop().then(() => {
+            stopped = true;
+        });
+        await vi.advanceTimersByTimeAsync(499);
+        expect(stopped).toBe(false);
+        await vi.advanceTimersByTimeAsync(1);
+        await stopping;
+        expect(stopped).toBe(true);
+        expect(store.complete).not.toHaveBeenCalled();
+        expect(store.fail).not.toHaveBeenCalled();
+    });
+    it('logs a rejected pass and retries on the next tick', async () => {
+        const error = new Error('database unavailable');
+        const logger = { ...silentLogger, error: vi.fn() };
+        const store = fakeStore({
+            reconcile: vi
+                .fn()
+                .mockRejectedValueOnce(error)
+                .mockResolvedValue(undefined),
+        });
+        const controller = startSchedulerWithDeps({
+            store,
+            tasks: [task('a')],
+            owner: 'test',
+            logger,
+            startupJitterMs: 0,
+            tickIntervalMs: 1_000,
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        expect(store.reconcile).toHaveBeenCalledTimes(1);
+        expect(store.claim).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(1_000);
+        expect(store.reconcile).toHaveBeenCalledTimes(2);
+        expect(store.claim).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ event: 'scheduler.tick-error', err: error }), expect.any(String));
+        await controller.stop();
+    });
+    it('uses core.recurringTasks and fails fast without a scheduler store', 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,
+        };
+        const controller = startBylineScheduler(core, {
+            startupJitterMs: 0,
+            owner: 'test',
+            tasks: [task('injected-task', injectedRun)],
+        });
+        await vi.advanceTimersByTimeAsync(0);
+        expect(coreRun).toHaveBeenCalledTimes(1);
+        expect(injectedRun).not.toHaveBeenCalled();
+        await controller.stop();
+        expect(() => startBylineScheduler({ ...core, db: {} }, {
+            startupJitterMs: 0,
+        })).toThrow(/scheduler capability/i);
+    });
+});