@byline/core 4.14.0 → 4.15.0

package/dist/@types/db-types.d.ts

@@ -1,6 +1,7 @@
 import type { RequestContext } from '@byline/auth';
 import type { CollectionDefinition } from '@byline/core';
 import type { DbErrorClassification } from '../lib/errors.js';
+import type { ISchedulerStore } from '../scheduler/types.js';
 /**
  * Read mode for document queries.
  *
@@ -250,6 +251,13 @@ export interface IDbAdapter {
      * Canonical adapters (db-postgres, db-mysql) implement it.
      */
     classifyError?(err: unknown): DbErrorClassification;
+    /**
+     * Optional recurring-task scheduler storage. Present on the canonical
+     * adapters; absent adapters simply cannot run recurring tasks, which
+     * `initBylineCore()` reports at boot rather than failing silently later.
+     * See specs/2026-08-22-scheduler.md.
+     */
+    scheduler?: ISchedulerStore;
 }
 /**
  * The realm of the actor that performed an audited change. `'admin'` for
@@ -482,7 +490,218 @@ export interface TreeDeleteMutationResult {
     removed: TreeMutationResult;
     promoted: TreePromotionChange[];
 }
+/** Durable state of one document-grain scheduled-publication intent. */
+export type DocumentPublishScheduleState = 'armed' | 'needs_reconfirm';
+/** Why an armed schedule stopped being executable. */
+type DocumentPublishScheduleSuspendedReason = 'content_edited';
+/**
+ * Adapter-neutral representation of `byline_document_publish_schedules`.
+ *
+ * Dates are always real `Date` instances. Canonical adapters must normalize
+ * raw driver strings before returning this shape; callers must never need to
+ * know whether the backing engine uses `timestamptz` or `datetime(6)`.
+ */
+export interface DocumentPublishSchedule {
+    documentId: string;
+    collectionId: string;
+    targetVersionId: string;
+    publishAt: Date;
+    state: DocumentPublishScheduleState;
+    suspendedAt: Date | null;
+    suspendedReason: DocumentPublishScheduleSuspendedReason | null;
+    /** Historical creator. Preserved across reschedule and re-confirmation. */
+    scheduledBy: string | null;
+    /** Actor whose authorization the currently armed intent rests on. */
+    lastAuthorizedBy: string | null;
+    lastAuthorizedAt: Date;
+    scheduledAt: Date;
+    updatedAt: Date;
+    executionToken: string | null;
+    executionExpiresAt: Date | null;
+    lastAttemptAt: Date | null;
+    nextAttemptAt: Date;
+    attemptCount: number;
+    /** Sanitized, stack-free, and capped at 2 KiB by the adapter. */
+    lastError: string | null;
+}
+/** A due schedule successfully fenced for one sweep execution. */
+export interface ClaimedDocumentPublishSchedule extends DocumentPublishSchedule {
+    executionToken: string;
+    executionExpiresAt: Date;
+    lastAttemptAt: Date;
+    /** Database time used for the claim, exposed for diagnostics and tests. */
+    databaseNow: Date;
+    /** True when this claim replaced an execution token whose lease had expired. */
+    recoveredExpiredClaim: boolean;
+}
+export type ScheduleDocumentPublishResult = {
+    status: 'scheduled';
+    schedule: DocumentPublishSchedule;
+    /** Null on first creation; the locked prior row on a reschedule. */
+    previous: DocumentPublishSchedule | null;
+} | {
+    status: 'document_not_found' | 'version_mismatch' | 'publish_at_not_future' | 'execution_in_progress';
+};
+export type ConfirmDocumentPublishScheduleResult = {
+    status: 'confirmed';
+    schedule: DocumentPublishSchedule;
+    previousTargetVersionId: string;
+} | {
+    status: 'schedule_not_found' | 'not_suspended' | 'version_mismatch';
+};
+export type SuspendDocumentPublishScheduleResult = {
+    status: 'suspended';
+    schedule: DocumentPublishSchedule;
+} | {
+    status: 'schedule_not_found' | 'already_suspended';
+};
+export interface DocumentPublishSchedulePage {
+    schedules: DocumentPublishSchedule[];
+    total: number;
+}
+/**
+ * Transaction-aware scheduled-publication writes attached to the document
+ * command surface. They are storage primitives, not lifecycle or public SDK
+ * operations: core owns abilities, workflow validation, hooks, and audit.
+ */
+export interface IDocumentPublishScheduleCommands {
+    /**
+     * Create or reschedule one document's intent.
+     *
+     * The command locks the logical document and any existing schedule. It
+     * succeeds only when `expectedVersionId` is the current live version for
+     * `documentId`/`collectionId`, and when `publishAt` is strictly later than
+     * database time. A live execution claim returns `execution_in_progress`;
+     * an expired claim may be replaced by the reschedule.
+     *
+     * First creation stamps both actor columns. Rescheduling preserves
+     * `scheduledBy`, rewrites `lastAuthorizedBy`/`lastAuthorizedAt`, returns the
+     * row to `armed`, and clears all suspension, attempt, error, and execution
+     * state. `nextAttemptAt` becomes `publishAt`.
+     *
+     * Call inside `IDbAdapter.withTransaction` so the row and lifecycle audit
+     * append share the ambient transaction. The canonical adapters' tests pin
+     * that rollback behaviour.
+     */
+    schedule(params: {
+        documentId: string;
+        collectionId: string;
+        expectedVersionId: string;
+        publishAt: Date;
+        actorId: string | null;
+    }): Promise<ScheduleDocumentPublishResult>;
+    /**
+     * Re-authorize a `needs_reconfirm` row against the current live version.
+     * Preserves `publishAt` and `scheduledBy`, including when `publishAt` is now
+     * in the past; rewrites the current authorization and clears suspension,
+     * attempt, error, and execution state. `nextAttemptAt` becomes `publishAt`.
+     * Must run inside the caller's ambient transaction.
+     */
+    confirm(params: {
+        documentId: string;
+        collectionId: string;
+        expectedVersionId: string;
+        actorId: string | null;
+    }): Promise<ConfirmDocumentPublishScheduleResult>;
+    /**
+     * Lock and delete the document's row regardless of whether it currently
+     * carries an execution token. Cancellation and token-guarded publication
+     * therefore have one database-lock winner. Returns the deleted snapshot or
+     * null. Must run inside the caller's ambient transaction.
+     */
+    cancel(params: {
+        documentId: string;
+        collectionId: string;
+    }): Promise<DocumentPublishSchedule | null>;
+    /**
+     * Move an armed row to `needs_reconfirm` after a content-version write,
+     * preserving its pinned target and authorization while clearing any claim.
+     * Repeated edits of an already-suspended row report `already_suspended`.
+     * Must run inside the version write's ambient transaction.
+     */
+    suspendForContentEdit(params: {
+        documentId: string;
+        collectionId: string;
+    }): Promise<SuspendDocumentPublishScheduleResult>;
+    /**
+     * Atomically claim up to `batchSize` due rows, oldest `publishAt` first.
+     * Eligibility is derived only from database time: `armed`, both
+     * `publishAt` and `nextAttemptAt` due, and no live execution claim. Each
+     * winner receives its own fresh token; claim records database-now in
+     * `lastAttemptAt`, increments `attemptCount`, and sets the expiry.
+     * Concurrent callers skip locked rows rather than serializing the batch.
+     * This operation owns its short claim transaction and must not be wrapped
+     * in a lifecycle transaction.
+     */
+    claimDue(params: {
+        batchSize: number;
+        leaseMs: number;
+    }): Promise<ClaimedDocumentPublishSchedule[]>;
+    /**
+     * Lock and return a token-matched row inside the publication transition's
+     * ambient transaction. Expiry alone does not invalidate a still-matching
+     * token: it becomes stale only when another claimant replaces it. A
+     * malformed or stale token returns null, never a driver error.
+     */
+    lockClaim(params: {
+        documentId: string;
+        executionToken: string;
+    }): Promise<DocumentPublishSchedule | null>;
+    /**
+     * Delete a token-matched row inside the caller's ambient transaction.
+     * Returns false for malformed or stale tokens without mutating the row.
+     */
+    deleteClaim(params: {
+        documentId: string;
+        executionToken: string;
+    }): Promise<boolean>;
+    /**
+     * Token-matched form of edit suspension for the fire-time version race.
+     * Clears the execution claim and attempt/error state. Returns false for a
+     * stale token without mutating the newer claimant's row.
+     */
+    suspendClaimForContentEdit(params: {
+        documentId: string;
+        executionToken: string;
+    }): Promise<boolean>;
+    /**
+     * Release a failed token-matched attempt. Clears the execution claim,
+     * stores a sanitized error capped at 2 KiB, and sets `nextAttemptAt` from
+     * database time using the already-incremented `attemptCount`: 1, 2, 4, 8,
+     * then 15 minutes for the fifth and later attempts. Returns false for a
+     * malformed or stale token without overwriting a newer claimant.
+     */
+    releaseClaim(params: {
+        documentId: string;
+        executionToken: string;
+        error: string;
+    }): Promise<boolean>;
+}
+/** Actor-agnostic scheduled-publication reads attached to document queries. */
+export interface IDocumentPublishScheduleQueries {
+    /** Return one collection-scoped schedule, or null. */
+    get(params: {
+        documentId: string;
+        collectionId: string;
+    }): Promise<DocumentPublishSchedule | null>;
+    /**
+     * Return a deterministic page ordered by `publishAt`, then `documentId`.
+     * The adapter must enforce `collectionIds` with `IN (...)`; an empty
+     * allowlist returns `{ schedules: [], total: 0 }` without issuing SQL.
+     * Optional state/authorizer filters are storage predicates only—ability
+     * resolution remains in core.
+     */
+    list(params: {
+        collectionIds: readonly string[];
+        states?: readonly DocumentPublishScheduleState[];
+        lastAuthorizedBy?: string;
+        page: number;
+        pageSize: number;
+    }): Promise<DocumentPublishSchedulePage>;
+}
 export interface IDocumentCommands {
+    /** Scheduled-publication storage primitives; lifecycle rules remain in core. */
+    publishSchedules: IDocumentPublishScheduleCommands;
     createDocumentVersion(params: {
         documentId?: string;
         collectionId: string;
@@ -708,6 +927,8 @@ export interface ICollectionQueries {
     getCollectionById(id: string): Promise<any>;
 }
 export interface IDocumentQueries {
+    /** Scheduled-publication reads; callers resolve collection abilities above storage. */
+    publishSchedules: IDocumentPublishScheduleQueries;
     /**
      * Lock a logical document as the transaction mutex for its non-versioned
      * system fields, then return their authoritative current values. Must be
@@ -1124,3 +1345,4 @@ export interface IDocumentQueries {
         order_key: string;
     }>>;
 }
+export {};

package/dist/@types/site-config.d.ts

@@ -6,6 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { SessionProvider } from '@byline/auth';
+import type { RecurringTaskDefinition } from '../scheduler/types.js';
 import type { SlugifierFn } from '../utils/slugify.js';
 import type { FilenameSlugifierFn } from '../utils/slugify-filename.js';
 import type { BlockAdminConfig, CollectionAdminConfig, CollectionGroupDefinition } from './admin-types.js';
@@ -241,6 +242,15 @@ export interface ServerHooksConfig {
     collections?: Record<string, CollectionHooks | CollectionHooksLoader>;
     uploads?: Record<string, UploadHooks | UploadHooksLoader>;
 }
+/** Installation-wide switch for Byline's scheduled-publication subsystem. */
+export interface ScheduledPublicationConfig {
+    /**
+     * Register the built-in `documents.publish-scheduled` recurring task and
+     * signal host/admin integrations to expose the feature. Registration
+     * remains inert until the host explicitly starts the scheduler.
+     */
+    enabled: boolean;
+}
 /**
  * Server-side configuration. Extends BaseConfig with database and storage
  * adapters. Deliberately does NOT extend AdminConfig — the server has no
@@ -444,6 +454,20 @@ export interface ServerConfig<TAdminStore = unknown> extends BaseConfig {
      * ```
      */
     search?: SearchProvider;
+    /**
+     * Optional delayed-publication subsystem. Enabling it contributes the
+     * built-in recurring task to `BylineCore.recurringTasks`; it never starts a
+     * timer during `initBylineCore()`.
+     */
+    scheduledPublication?: ScheduledPublicationConfig;
+    /**
+     * Recurring background tasks (`defineRecurringTask()`), validated and gated
+     * against the configured adapter's optional scheduler capability by
+     * `initBylineCore()`. Registration is not execution — the validated set is
+     * exposed as `BylineCore.recurringTasks` for `runDueTasks()` /
+     * `startBylineScheduler()` to consume; nothing here starts a timer.
+     */
+    recurringTasks?: readonly RecurringTaskDefinition[];
 }
 /** Server config returned after boundary validation and canonicalization. */
 export type ResolvedServerConfig<TAdminStore = unknown> = Omit<ServerConfig<TAdminStore>, 'routes'> & {

package/dist/codegen/index.test.node.js

@@ -243,6 +243,6 @@ describe('emitCollectionTypes', () => {
             import: './dist/codegen/index.js',
             require: './dist/codegen/index.js',
         });
-        expect(rootSource).not.toMatch(/codegen/);
+        expect(rootSource).not.toMatch(/['"]\.\/codegen(?:\/[^'"]*)?['"]/u);
     });
 });

package/dist/core.d.ts

@@ -10,6 +10,7 @@ import type { Logger as PinoLogger } from 'pino';
 import { type BylineLogger } from './lib/logger.js';
 import { type CollectionRecord } from './services/collection-bootstrap.js';
 import type { CollectionDefinition, IDbAdapter, IStorageProvider, ResolvedServerConfig, ServerConfig } from './@types/index.js';
+import type { RecurringTaskDefinition } from './scheduler/types.js';
 export interface BylineCore<TAdminStore = unknown> {
     config: ResolvedServerConfig<TAdminStore>;
     collections: readonly CollectionDefinition[];
@@ -63,6 +64,13 @@ export interface BylineCore<TAdminStore = unknown> {
      * Undefined when the installation does not configure admin.
      */
     adminStore: TAdminStore | undefined;
+    /**
+     * Validated recurring-task definitions (`ServerConfig.recurringTasks`),
+     * empty when none are configured. `runDueTasks(core)` and
+     * `startBylineScheduler(core)` read this vetted set so no caller can
+     * substitute another; `initBylineCore()` does not start a timer.
+     */
+    recurringTasks: readonly RecurringTaskDefinition[];
 }
 /**
  * Initialize Byline CMS core services via the typed registry.

package/dist/core.js

@@ -10,6 +10,8 @@ import { registerCollectionAbilities } from './auth/register-collection-abilitie
 import { defineBylineCore, getBylineCoreUnsafe, registerServerConfig, resolveServerConfig, } from './config/config.js';
 import { createBylineLogger, defineLogger } from './lib/logger.js';
 import { Registry } from './lib/registry.js';
+import { SCHEDULED_PUBLICATION_INTERVAL_MS, SCHEDULED_PUBLICATION_LEASE_MS, SCHEDULED_PUBLICATION_TASK_NAME, } from './scheduler/scheduled-publication-constants.js';
+import { validateSchedulerConfig } from './scheduler/validate-scheduler-config.js';
 import { ensureCollections } from './services/collection-bootstrap.js';
 import { discoverCounterGroups } from './services/discover-counter-groups.js';
 import { validateTreeAuditCapability } from './services/document-lifecycle/audit.js';
@@ -41,6 +43,7 @@ export const initBylineCore = async (config, pinoLogger) => {
         .addValue('storage', resolvedConfig.storage)
         .addFactory('logger', createBylineLogger);
     const composed = registry.compose({ pinoLogger });
+    let initializedCore;
     // Validate richText field flags against the registered server adapter
     // before any DB work. Fail-fast surfaces unrenderable configurations
     // (both flags off) and missing-adapter cases at boot rather than at
@@ -55,6 +58,40 @@ export const initBylineCore = async (config, pinoLogger) => {
     validateSearchConfig(composed.collections, {
         provider: resolvedConfig.search != null,
     });
+    // Validate recurring-task configuration: a task registered against an
+    // adapter that does not implement the optional scheduler capability would
+    // silently never run. Fail-fast at boot, same posture as search above. This
+    // only validates and gates — it does not start anything.
+    const configuredTasks = [...(resolvedConfig.recurringTasks ?? [])];
+    if (resolvedConfig.scheduledPublication?.enabled === true) {
+        configuredTasks.push({
+            name: SCHEDULED_PUBLICATION_TASK_NAME,
+            intervalMs: SCHEDULED_PUBLICATION_INTERVAL_MS,
+            leaseMs: SCHEDULED_PUBLICATION_LEASE_MS,
+            run: async (context) => {
+                if (initializedCore === undefined) {
+                    throw new Error('scheduled publication task ran before Byline core initialization');
+                }
+                const { runScheduledPublicationSweep } = await import('./scheduler/scheduled-publication.js');
+                const result = await runScheduledPublicationSweep(initializedCore, {
+                    signal: context.signal,
+                    heartbeat: context.heartbeat,
+                    logger: context.logger,
+                });
+                return { workRemaining: result.workRemaining };
+            },
+        });
+    }
+    validateSchedulerConfig({ tasks: configuredTasks, adapter: composed.db });
+    // Freeze a snapshot of the validated task set: a new array of new, frozen
+    // objects, then freeze the array itself. Without this, `core.recurringTasks`
+    // would hold the caller's own array and definition objects, so a caller
+    // could `push()` a task or mutate `intervalMs` after `initBylineCore()`
+    // returns and bypass validation entirely. Both `core.recurringTasks` and
+    // the resolved config's `recurringTasks` are assigned this same snapshot so
+    // no path exposes the caller's originals.
+    const recurringTasks = Object.freeze(configuredTasks.map((task) => Object.freeze({ ...task })));
+    resolvedConfig.recurringTasks = recurringTasks;
     // Tree edges are unversioned metadata and may only run on adapters that can
     // lock, mutate, and append audit rows in one transaction.
     validateTreeAuditCapability(composed.collections, composed.db);
@@ -141,7 +178,9 @@ export const initBylineCore = async (config, pinoLogger) => {
         getAbilitiesByGroup: () => abilities.byGroup(),
         sessionProvider: composed.config.sessionProvider,
         adminStore: composed.config.adminStore,
+        recurringTasks,
     };
+    initializedCore = core;
     // Commit globals only after the replacement core has fully initialized. A
     // failed reinitialization leaves the prior config, logger, and core intact.
     registerServerConfig(resolvedConfig);

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { AsyncRegistry, type RegisteredServices, Registry } from './lib/registry
 export * from './patches/index.js';
 export * from './paths/index.js';
 export { mergePredicates, type ParseContext, type ParsedSort, type ParsedWhere, parsePredicateFilters, parseSort, parseWhere, } from './query/parse-where.js';
+export { defineRecurringTask, MIN_INTERVAL_MS, MIN_LEASE_MS, } from './scheduler/define-recurring-task.js';
 export { getCollectionSchemasForPath } from './schemas/zod/cache.js';
 export * from './services/index.js';
 export * from './storage/index.js';
@@ -23,3 +24,4 @@ export { formatTextValue, looksLikeISODate, type SlugifierFn, type SlugifyContex
 export { type FilenameSlugifierFn, type FilenameSlugifyContext, resolveUploadFilename, slugifyFilename, } from './utils/slugify-filename.js';
 export { getUploadFields, hasUploadField, isUploadField } from './utils/storage-utils.js';
 export * from './workflow/index.js';
+export type { ClaimedRecurringTask, ISchedulerStore, ReconcileTaskInput, RecurringTaskContext, RecurringTaskDefinition, RecurringTaskHealth, RecurringTaskResult, RecurringTaskStatus, } from './scheduler/types.js';

package/dist/index.js

@@ -1,18 +1,14 @@
 // ---------------------------------------------------------------------------
 // @byline/core public surface.
 //
-// Subpath exports (see `package.json`):
-//   - `.`             — main entry (this file); published
-//   - `./zod-schemas`, `./logger`, `./package.json` — published
-//   - `./patches`, `./workflow`, `./services` — NOT published
+// The main entry (this file) is browser-safe. Capability-specific surfaces use
+// the explicit subpaths declared in `package.json`, such as `./codegen` and
+// the server-only `./scheduler` entry.
 //
-// The three unpublished subpaths are in-monorepo boundaries used by
-// the admin server fns and the `@byline/client` SDK. They are
-// registered in the main `exports` map (so workspace consumers and
-// `tsc` can resolve them) but deliberately omitted from
-// `publishConfig.exports` — they are not stable surface and should
-// not be imported by external npm consumers. External access goes
-// through this main entry or `@byline/client`.
+// Every key in the package's `exports` map is included in the published npm
+// package and may be imported by external consumers. A subpath's primary use
+// inside this monorepo does not make it private; removing or renaming one is a
+// breaking package-surface change.
 // ---------------------------------------------------------------------------
 export * from './@types/index.js';
 export { applyBeforeRead, assertActorCanPerform, bindReadContextAuthority, COLLECTION_ABILITY_VERBS, collectionAbilityKey, compileBeforeReadFilters, filterReadableCollections, registerCollectionAbilities, } from './auth/index.js';
@@ -31,6 +27,7 @@ export { AsyncRegistry, Registry } from './lib/registry.js';
 export * from './patches/index.js';
 export * from './paths/index.js';
 export { mergePredicates, parsePredicateFilters, parseSort, parseWhere, } from './query/parse-where.js';
+export { defineRecurringTask, MIN_INTERVAL_MS, MIN_LEASE_MS, } from './scheduler/define-recurring-task.js';
 export { getCollectionSchemasForPath } from './schemas/zod/cache.js';
 export * from './services/index.js';
 export * from './storage/index.js';

package/dist/scheduler/define-recurring-task.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { RecurringTaskDefinition } from './types.js';
+/** Shortest permitted interval between runs, and shortest permitted lease. */
+export declare const MIN_INTERVAL_MS = 60000;
+export declare const MIN_LEASE_MS = 60000;
+/** Maximum bounded retry delay after repeated failures. */
+export declare const MAX_BACKOFF_MS: number;
+/**
+ * Identity helper that gives a task definition its type without starting
+ * anything. Registration is not execution: timers begin only when the host
+ * calls `startBylineScheduler()`.
+ */
+export declare function defineRecurringTask(definition: RecurringTaskDefinition): RecurringTaskDefinition;

package/dist/scheduler/define-recurring-task.js

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+/** Shortest permitted interval between runs, and shortest permitted lease. */
+export const MIN_INTERVAL_MS = 60_000;
+export const MIN_LEASE_MS = 60_000;
+/** Maximum bounded retry delay after repeated failures. */
+export const MAX_BACKOFF_MS = 15 * 60_000;
+/**
+ * Identity helper that gives a task definition its type without starting
+ * anything. Registration is not execution: timers begin only when the host
+ * calls `startBylineScheduler()`.
+ */
+export function defineRecurringTask(definition) {
+    return definition;
+}

package/dist/scheduler/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+/**
+ * `@byline/core/scheduler` — the server-only executable surface of the
+ * recurring-task scheduler. The inert types and `defineRecurringTask()` are
+ * also re-exported from the package root; the runner and ticker are here so
+ * importing browser-safe core code never pulls in Node timers.
+ */
+export { defineRecurringTask, MAX_BACKOFF_MS, MIN_INTERVAL_MS, MIN_LEASE_MS, } from './define-recurring-task.js';
+export { type RunDueTasksOptions, type RunDueTasksSummary, runDueTasks } from './run-due-tasks.js';
+export { runScheduledPublicationSweep, type ScheduledPublicationSweepOptions, type ScheduledPublicationSweepResult, } from './scheduled-publication.js';
+export { type SchedulerController, type SchedulerOptions, startBylineScheduler, } from './ticker.js';
+export { validateRecurringTasks } from './validate-tasks.js';
+export type { ClaimedRecurringTask, ISchedulerStore, ReconcileTaskInput, RecurringTaskContext, RecurringTaskDefinition, RecurringTaskHealth, RecurringTaskResult, RecurringTaskStatus, } from './types.js';

package/dist/scheduler/index.js

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+/**
+ * `@byline/core/scheduler` — the server-only executable surface of the
+ * recurring-task scheduler. The inert types and `defineRecurringTask()` are
+ * also re-exported from the package root; the runner and ticker are here so
+ * importing browser-safe core code never pulls in Node timers.
+ */
+export { defineRecurringTask, MAX_BACKOFF_MS, MIN_INTERVAL_MS, MIN_LEASE_MS, } from './define-recurring-task.js';
+export { runDueTasks } from './run-due-tasks.js';
+export { runScheduledPublicationSweep, } from './scheduled-publication.js';
+export { startBylineScheduler, } from './ticker.js';
+export { validateRecurringTasks } from './validate-tasks.js';

package/dist/scheduler/run-due-tasks.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 RunDueTasksOptions {
+    signal?: AbortSignal;
+    concurrency?: number;
+    owner?: string;
+}
+export interface RunDueTasksSummary {
+    claimed: number;
+    succeeded: number;
+    failed: number;
+    aborted: number;
+}
+interface RunDueTasksDeps {
+    store: ISchedulerStore;
+    tasks: readonly RecurringTaskDefinition[];
+    owner: string;
+    logger: BylineLogger;
+    signal?: AbortSignal;
+    concurrency?: number;
+}
+/** A bounded, non-secret diagnostic label. Correctness never depends on it. */
+export declare function defaultOwner(): string;
+/**
+ * Dependency-injected implementation used by the ticker and unit tests. It is
+ * intentionally absent from the `@byline/core/scheduler` barrel.
+ */
+export declare function runDueTasksWithDeps(params: RunDueTasksDeps): Promise<RunDueTasksSummary>;
+/** Run one claim-and-run pass over the task definitions vetted at core boot. */
+export declare function runDueTasks(core: BylineCore, options?: RunDueTasksOptions): Promise<RunDueTasksSummary>;
+export {};