@aphexcms/cms-core 9.5.2 → 9.7.0

package/dist/hooks.js

@@ -9,6 +9,7 @@ import { PluginSettingsService } from './services/plugin-settings-service.js';
 import { createCMS } from './engine.js';
 import { createLocalAPI } from './local-api/index.js';
 import { createPartResolver } from './plugins/resolver.js';
+import { startEmbeddedJobRunner } from './jobs/embedded-runner.js';
 import { createAphexApi, mountAphexBuiltins, toHonoHandler } from './server/api/index.js';
 /**
  * Wrap a plugin route handler so it enforces `requiredCapabilities` before running.
@@ -35,6 +36,9 @@ let schemaError = null;
 let initPromise = null;
 let activeConfig = null;
 let configDirty = false;
+// Started once per process (not per request, and not restarted on schema-HMR re-init): the loop
+// resolves the live `cmsInstances` at each tick, so a rebuilt instance is picked up automatically.
+let embeddedRunner = null;
 /**
  * Called by the Vite HMR plugin (`@aphexcms/cms-core/vite`) when schema
  * files or `aphex.config.ts` change. Replaces the captured config with the
@@ -200,6 +204,17 @@ export function createCMSHook(config) {
                 apiApp,
                 partResolver
             };
+            // Start the embedded in-process job loop once, if opted in. It drives the queue
+            // directly (no HTTP, no worker secret) so scheduled publishes and event consumers
+            // run with zero setup — ideal for dev and single-instance self-hosting. It reads
+            // the live `cmsInstances` at each tick, so it survives schema-HMR re-init.
+            if (currentConfig.jobs?.embedded && !embeddedRunner) {
+                embeddedRunner = startEmbeddedJobRunner({
+                    intervalMs: currentConfig.jobs.embeddedIntervalMs,
+                    logger: cmsLogger,
+                    getServices: () => cmsInstances
+                });
+            }
             resolveInit();
         }
         // Attach schema error to instances so it can be accessed in load functions

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export * from './field-validation/rule.js';
 export * from './field-validation/utils.js';
 export { createContentHash, hasUnpublishedChanges } from './utils/content-hash.js';
 export * from './schema-utils/index.js';
+export * from './events/index.js';
+export * from './forms/index.js';
 export * from './theme/index.js';
 export * from './plugins/index.js';
 export * from './utils/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAkBA,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGjG,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGhF,cAAc,sBAAsB,CAAC;AAGrC,cAAc,eAAe,CAAC;AAI9B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAkBA,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGjG,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGhF,cAAc,sBAAsB,CAAC;AAIrC,cAAc,gBAAgB,CAAC;AAI/B,cAAc,eAAe,CAAC;AAG9B,cAAc,eAAe,CAAC;AAI9B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -23,6 +23,12 @@ export * from './field-validation/utils.js';
 export { createContentHash, hasUnpublishedChanges } from './utils/content-hash.js';
 // Schema utilities
 export * from './schema-utils/index.js';
+// Event catalog — defineEvent() + built-in event definitions (document.published, …).
+// Plain TS (zod only), safe for the universal barrel.
+export * from './events/index.js';
+// Forms primitives — defineForm(), InferForm, validateFormData. Plain TS, reuses the field
+// model + validation engine, safe for the universal barrel.
+export * from './forms/index.js';
 // Theme design-system tokens — plain TS (Svelte-free), safe for the universal barrel.
 export * from './theme/index.js';
 // Plugin API — definePlugin(), part types, part resolver. Runtime is plain JS

package/dist/jobs/document-jobs.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { LocalAPI } from '../local-api/index.js';
+import type { JobHandlerMap } from './types.js';
+/** Reserved built-in job types. Scheduling uses these; the worker maps them to the handlers below. */
+export declare const DOCUMENT_PUBLISH_JOB = "document.publish";
+export declare const DOCUMENT_UNPUBLISH_JOB = "document.unpublish";
+/** Payload for document.publish / document.unpublish jobs — identifiers only, never content. */
+export declare const documentJobPayload: z.ZodObject<{
+    documentId: z.ZodString;
+    documentType: z.ZodString;
+}, z.core.$strip>;
+export type DocumentJobPayload = z.infer<typeof documentJobPayload>;
+export interface DocumentJobDeps {
+    localAPI: LocalAPI;
+}
+/**
+ * Built-in handlers for scheduled publish/unpublish.
+ *
+ * Runs as the system (override access) — the permission check already happened when the
+ * job was scheduled. Publish routes through `CollectionAPI.publish`, so it re-runs
+ * validation + reference guards + cache invalidation and emits `document.published`
+ * inside the publish transaction, exactly like a manual publish. A handler throw is a
+ * job failure: the runner retries with backoff or dead-letters it (e.g. a doc whose
+ * references became unpublished before the scheduled time fails validation and retries).
+ */
+export declare function createDocumentJobHandlers(deps: DocumentJobDeps): JobHandlerMap;
+//# sourceMappingURL=document-jobs.d.ts.map

package/dist/jobs/document-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-jobs.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/document-jobs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,sGAAsG;AACtG,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AACvD,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAE3D,gGAAgG;AAChG,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE,QAAQ,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,CAgB9E"}

package/dist/jobs/document-jobs.js

@@ -0,0 +1,42 @@
+// Built-in job types for the scheduled document workflow: publish / unpublish at a
+// future `runAt`. The handlers are provided by core but DI'd with the request-scoped
+// LocalAPI at the worker endpoint (the runner itself only knows the database adapter).
+import { z } from 'zod';
+import { systemContext } from '../local-api/auth-helpers.js';
+/** Reserved built-in job types. Scheduling uses these; the worker maps them to the handlers below. */
+export const DOCUMENT_PUBLISH_JOB = 'document.publish';
+export const DOCUMENT_UNPUBLISH_JOB = 'document.unpublish';
+/** Payload for document.publish / document.unpublish jobs — identifiers only, never content. */
+export const documentJobPayload = z.object({
+    documentId: z.string(),
+    documentType: z.string()
+});
+/**
+ * Built-in handlers for scheduled publish/unpublish.
+ *
+ * Runs as the system (override access) — the permission check already happened when the
+ * job was scheduled. Publish routes through `CollectionAPI.publish`, so it re-runs
+ * validation + reference guards + cache invalidation and emits `document.published`
+ * inside the publish transaction, exactly like a manual publish. A handler throw is a
+ * job failure: the runner retries with backoff or dead-letters it (e.g. a doc whose
+ * references became unpublished before the scheduled time fails validation and retries).
+ */
+export function createDocumentJobHandlers(deps) {
+    const { localAPI } = deps;
+    return {
+        [DOCUMENT_PUBLISH_JOB]: async ({ job }) => {
+            const { documentId, documentType } = documentJobPayload.parse(job.payload);
+            const collection = localAPI.getCollection(documentType);
+            if (!collection)
+                throw new Error(`Unknown collection "${documentType}" for job ${job.id}`);
+            await collection.publish(systemContext(job.organizationId), documentId);
+        },
+        [DOCUMENT_UNPUBLISH_JOB]: async ({ job }) => {
+            const { documentId, documentType } = documentJobPayload.parse(job.payload);
+            const collection = localAPI.getCollection(documentType);
+            if (!collection)
+                throw new Error(`Unknown collection "${documentType}" for job ${job.id}`);
+            await collection.unpublish(systemContext(job.organizationId), documentId);
+        }
+    };
+}

package/dist/jobs/embedded-runner.d.ts

@@ -0,0 +1,25 @@
+import type { JobRunnerServices } from './run-batch.js';
+import type { Logger } from '../utils/logger.js';
+/** Handle for a running embedded loop. Call `stop()` to clear the interval. */
+export interface EmbeddedJobRunner {
+    stop(): void;
+}
+export interface EmbeddedJobRunnerOptions {
+    /** Milliseconds between ticks. Default 3000. */
+    intervalMs?: number;
+    logger: Logger;
+    /**
+     * Resolve the live services at tick time (rather than capturing them once), so a schema-HMR
+     * re-init that rebuilds the CMS instances is picked up automatically. Return `null` to skip a
+     * tick (e.g. the app hasn't finished initializing yet).
+     */
+    getServices: () => JobRunnerServices | null;
+}
+/**
+ * Start the loop. Ticks NEVER overlap: while a tick is in flight the next interval fire is
+ * skipped, so a slow batch can't stack runs on top of each other. A thrown error in a tick is
+ * logged and swallowed — the loop must survive a transient DB blip and keep going. The interval
+ * is `unref`'d where supported so it never keeps the process alive on its own.
+ */
+export declare function startEmbeddedJobRunner(options: EmbeddedJobRunnerOptions): EmbeddedJobRunner;
+//# sourceMappingURL=embedded-runner.d.ts.map

package/dist/jobs/embedded-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-runner.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/embedded-runner.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,aAAa,CAAC;AAEzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IACjC,IAAI,IAAI,IAAI,CAAC;CACb;AAED,MAAM,WAAW,wBAAwB;IACxC,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAC;CAC5C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CAyC3F"}

package/dist/jobs/embedded-runner.js

@@ -0,0 +1,46 @@
+import { runJobsBatch } from './run-batch.js';
+/**
+ * Start the loop. Ticks NEVER overlap: while a tick is in flight the next interval fire is
+ * skipped, so a slow batch can't stack runs on top of each other. A thrown error in a tick is
+ * logged and swallowed — the loop must survive a transient DB blip and keep going. The interval
+ * is `unref`'d where supported so it never keeps the process alive on its own.
+ */
+export function startEmbeddedJobRunner(options) {
+    const intervalMs = options.intervalMs ?? 3000;
+    const { logger, getServices } = options;
+    let running = false;
+    let stopped = false;
+    const tick = async () => {
+        if (running || stopped)
+            return; // no overlap; nothing after stop()
+        const services = getServices();
+        if (!services)
+            return; // not initialized yet — try again next interval
+        running = true;
+        try {
+            const result = await runJobsBatch(services, {
+                workerId: 'embedded'
+            });
+            // Only surface a tick that actually did something, so an idle dev server stays quiet.
+            if (result.claimed > 0 || result.relay.enqueued > 0) {
+                logger.debug(`[jobs:embedded] relayed=${result.relay.enqueued} claimed=${result.claimed} completed=${result.completed} failed=${result.failed} retried=${result.retried}`);
+            }
+        }
+        catch (error) {
+            logger.error('[jobs:embedded] tick failed:', error);
+        }
+        finally {
+            running = false;
+        }
+    };
+    const handle = setInterval(tick, intervalMs);
+    // Don't let the loop hold the process open by itself (Node/Bun); harmless where unsupported.
+    handle.unref?.();
+    logger.info(`[jobs:embedded] in-process job loop started (every ${intervalMs}ms)`);
+    return {
+        stop() {
+            stopped = true;
+            clearInterval(handle);
+        }
+    };
+}

package/dist/jobs/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './run-due-jobs.js';
+export * from './relay.js';
+export * from './run-batch.js';
+export * from './document-jobs.js';
+export * from './embedded-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/jobs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC"}

package/dist/jobs/index.js

@@ -0,0 +1,8 @@
+// Job execution — the durable spine's runner. Plain TS (no Svelte), safe to import
+// from the server barrel. Handlers and scheduling are wired via `CMSConfig.jobs`.
+export * from './types.js';
+export * from './run-due-jobs.js';
+export * from './relay.js';
+export * from './run-batch.js';
+export * from './document-jobs.js';
+export * from './embedded-runner.js';

package/dist/jobs/relay.d.ts

@@ -0,0 +1,27 @@
+import type { Logger } from '../utils/logger.js';
+import type { DatabaseAdapter } from '../db/interfaces/index.js';
+import type { PartResolver } from '../plugins/resolver.js';
+/** The slice of the service container the relay needs — a structural subset of `JobRunnerServices`. */
+export interface RelayServices {
+    databaseAdapter: DatabaseAdapter;
+    logger: Logger;
+    partResolver: PartResolver;
+}
+export interface RelayOutboxOptions {
+    /** Scope to one tenant; omit to relay across all orgs (worker context, override access). */
+    organizationId?: string;
+    /** Max outbox rows drained this pass. Default 100 (fan-out is cheap; relay generously). */
+    batchSize?: number;
+}
+export interface RelayOutboxResult {
+    /** Outbox rows processed this pass. */
+    relayed: number;
+    /** Delivery jobs enqueued (deduped enqueues still count as one each). */
+    enqueued: number;
+}
+/**
+ * Drain one bounded batch of the outbox, fanning each event out to its subscribed consumers.
+ * Runs one pass and returns — the caller (the same tick as `runJobsBatch`) owns cadence.
+ */
+export declare function relayOutbox(services: RelayServices, options?: RelayOutboxOptions): Promise<RelayOutboxResult>;
+//# sourceMappingURL=relay.d.ts.map

package/dist/jobs/relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/relay.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,uGAAuG;AACvG,MAAM,WAAW,aAAa;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IAClC,4FAA4F;IAC5F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2FAA2F;IAC3F,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IACjC,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;CACjB;AAID;;;GAGG;AACH,wBAAsB,WAAW,CAChC,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,kBAAuB,GAC9B,OAAO,CAAC,iBAAiB,CAAC,CA6D5B"}

package/dist/jobs/relay.js

@@ -0,0 +1,60 @@
+import { consumerJobType, toDeliveryPayload } from '../events/consumer.js';
+const DEFAULT_RELAY_BATCH_SIZE = 100;
+/**
+ * Drain one bounded batch of the outbox, fanning each event out to its subscribed consumers.
+ * Runs one pass and returns — the caller (the same tick as `runJobsBatch`) owns cadence.
+ */
+export async function relayOutbox(services, options = {}) {
+    const { databaseAdapter, logger, partResolver } = services;
+    const batchSize = options.batchSize ?? DEFAULT_RELAY_BATCH_SIZE;
+    const rows = await databaseAdapter.listUnprocessedOutbox({
+        organizationId: options.organizationId,
+        limit: batchSize
+    });
+    const result = { relayed: 0, enqueued: 0 };
+    for (const row of rows) {
+        const consumers = partResolver.consumersForEvent(row.eventType);
+        // A row with no subscribers is still marked processed — the relay's contract is "every
+        // event is considered", not "every event produces a job". Nobody listening is a valid
+        // outcome, and leaving it pending would re-scan it forever.
+        const event = {
+            id: row.eventId,
+            type: row.eventType,
+            organizationId: row.organizationId,
+            payload: row.payload,
+            correlationId: row.correlationId,
+            causationId: row.causationId,
+            createdBy: row.createdBy,
+            createdAt: row.createdAt
+        };
+        const payload = toDeliveryPayload(event);
+        try {
+            await databaseAdapter.withTransaction(async (tx) => {
+                for (const consumer of consumers) {
+                    await tx.scheduleJob({
+                        organizationId: row.organizationId,
+                        type: consumerJobType(consumer.id),
+                        payload,
+                        // Exactly-once per (event, consumer): a repeated key returns the existing job.
+                        idempotencyKey: `evt:${row.eventId}:${consumer.id}`,
+                        maxAttempts: consumer.maxAttempts,
+                        correlationId: row.correlationId,
+                        // The event is the cause of every delivery it spawns — chain it for tracing.
+                        causationId: row.eventId,
+                        createdBy: row.createdBy
+                    });
+                }
+                await tx.markOutboxProcessed(row.organizationId, row.id);
+            });
+            result.relayed++;
+            result.enqueued += consumers.length;
+        }
+        catch (err) {
+            // Leave the row unprocessed; the next pass retries it. Idempotent enqueue makes a
+            // partial failure safe to redo. Log and continue so one bad row can't stall the batch.
+            const message = err instanceof Error ? err.message : String(err);
+            logger.error('[relay]', `Failed to relay event ${row.eventId} (${row.eventType}); will retry next pass: ${message}`);
+        }
+    }
+    return result;
+}

package/dist/jobs/run-batch.d.ts

@@ -0,0 +1,52 @@
+import type { DatabaseAdapter } from '../db/interfaces/index.js';
+import type { EmailAdapter } from '../email/interfaces/email.js';
+import type { Logger } from '../utils/logger.js';
+import type { CMSConfig } from '../types/config.js';
+import type { LocalAPI } from '../local-api/index.js';
+import type { PartResolver } from '../plugins/resolver.js';
+import { type RunDueJobsResult } from './run-due-jobs.js';
+import { type RelayOutboxResult } from './relay.js';
+import { type PluginSettingsReader } from '../events/consumer.js';
+/**
+ * The slice of the CMS service container the runner needs. Structurally a subset
+ * of `CMSInstances`, so callers can pass `event.locals.aphexCMS` (or `c.var.aphexCMS`)
+ * straight through — no adapter, no cast.
+ */
+export interface JobRunnerServices {
+    config: CMSConfig;
+    databaseAdapter: DatabaseAdapter;
+    logger: Logger;
+    localAPI: LocalAPI;
+    partResolver: PartResolver;
+    /** Injected into event-consumer deliveries so a consumer can read its own decrypted settings. */
+    pluginSettingsService: PluginSettingsReader;
+    /** Handed to event consumers that send notifications; `null`/absent when email isn't configured. */
+    emailAdapter?: EmailAdapter | null;
+}
+export interface RunJobsBatchOptions {
+    /** Lease-owner label written to `cms_jobs.lease_owner` (crash-recovery visibility). */
+    workerId?: string;
+    /** Scope to one tenant; omit to claim across all orgs (worker context, override access). */
+    organizationId?: string;
+}
+/** One tick's combined outcome: the relay fan-out plus the job execution that followed. */
+export interface RunJobsBatchResult extends RunDueJobsResult {
+    /** Outbox fan-out done at the top of this tick (events → delivery jobs). */
+    relay: RelayOutboxResult;
+}
+/**
+ * Run one full worker tick: relay the outbox, then run one bounded batch of due jobs with the
+ * fully-assembled handler map.
+ *
+ * Relaying FIRST means a delivery job an event spawns this tick is already `pending` when the
+ * job pass runs, so a just-published document's consumers can fire in the same tick rather than
+ * waiting for the next — at the cost of nothing, since a slow consumer is still its own job.
+ *
+ * Handler precedence (later wins): core's built-in handlers (scheduled publish/unpublish) →
+ * plugin event-consumer deliveries (`aphex/consumer:<id>`) → plugin job handlers
+ * (`aphex/job/handler`) → the app's `config.jobs.handlers`. So an app can override a plugin,
+ * and a plugin can override a built-in — the app always has the final say. Consumer delivery
+ * types are namespaced, so they can't actually collide with the others.
+ */
+export declare function runJobsBatch(services: JobRunnerServices, options?: RunJobsBatchOptions): Promise<RunJobsBatchResult>;
+//# sourceMappingURL=run-batch.d.ts.map

package/dist/jobs/run-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-batch.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/run-batch.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE9D,OAAO,EAGN,KAAK,oBAAoB,EACzB,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,SAAS,CAAC;IAClB,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,iGAAiG;IACjG,qBAAqB,EAAE,oBAAoB,CAAC;IAC5C,oGAAoG;IACpG,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IACnC,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4FAA4F;IAC5F,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,2FAA2F;AAC3F,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC3D,4EAA4E;IAC5E,KAAK,EAAE,iBAAiB,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CACjC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAqC7B"}

package/dist/jobs/run-batch.js

@@ -0,0 +1,61 @@
+// The shared job-runner seam. Both the protected HTTP endpoint
+// (`POST /api/internal/workers/run`) and the embedded in-process poll loop call
+// THIS — never `runDueJobs` directly — so the handler wiring (built-in document
+// jobs + app-registered handlers) is constructed in exactly one place and can
+// never drift between the two invocation modes.
+//
+// `runDueJobs` is the pure engine (claim → run → settle, one batch). This wrapper
+// is the only thing that knows *which* handlers exist and pulls the per-run knobs
+// off `CMSConfig.jobs`.
+import { randomUUID } from 'node:crypto';
+import { runDueJobs } from './run-due-jobs.js';
+import { relayOutbox } from './relay.js';
+import { createDocumentJobHandlers } from './document-jobs.js';
+import { consumerJobType, toConsumerJobHandler } from '../events/consumer.js';
+/**
+ * Run one full worker tick: relay the outbox, then run one bounded batch of due jobs with the
+ * fully-assembled handler map.
+ *
+ * Relaying FIRST means a delivery job an event spawns this tick is already `pending` when the
+ * job pass runs, so a just-published document's consumers can fire in the same tick rather than
+ * waiting for the next — at the cost of nothing, since a slow consumer is still its own job.
+ *
+ * Handler precedence (later wins): core's built-in handlers (scheduled publish/unpublish) →
+ * plugin event-consumer deliveries (`aphex/consumer:<id>`) → plugin job handlers
+ * (`aphex/job/handler`) → the app's `config.jobs.handlers`. So an app can override a plugin,
+ * and a plugin can override a built-in — the app always has the final say. Consumer delivery
+ * types are namespaced, so they can't actually collide with the others.
+ */
+export async function runJobsBatch(services, options = {}) {
+    const { config, databaseAdapter, logger, localAPI, partResolver, pluginSettingsService } = services;
+    const emailAdapter = services.emailAdapter ?? null;
+    const relay = await relayOutbox(services, {
+        organizationId: options.organizationId,
+        batchSize: config.jobs?.relayBatchSize
+    });
+    // Turn each registered consumer into a delivery job handler, keyed by its reserved job type.
+    // Built here (not in the resolver) because the wrapper injects live services — the settings
+    // reader that lets a consumer read its own decrypted config.
+    const consumerHandlers = {};
+    for (const consumer of partResolver.eventConsumers()) {
+        consumerHandlers[consumerJobType(consumer.id)] = toConsumerJobHandler(consumer.handler, {
+            pluginSettingsService,
+            emailAdapter
+        });
+    }
+    const jobs = await runDueJobs({
+        databaseAdapter,
+        handlers: {
+            ...createDocumentJobHandlers({ localAPI }),
+            ...consumerHandlers,
+            ...partResolver.jobHandlers(),
+            ...(config.jobs?.handlers ?? {})
+        },
+        logger,
+        workerId: options.workerId ?? `runner-${randomUUID()}`,
+        organizationId: options.organizationId,
+        batchSize: config.jobs?.batchSize,
+        leaseMs: config.jobs?.leaseMs
+    });
+    return { ...jobs, relay };
+}

package/dist/jobs/run-due-jobs.d.ts

@@ -0,0 +1,30 @@
+import type { DatabaseAdapter } from '../db/interfaces/index.js';
+import type { Logger } from '../utils/logger.js';
+import type { JobHandlerMap } from './types.js';
+export interface RunDueJobsOptions {
+    databaseAdapter: DatabaseAdapter;
+    handlers: JobHandlerMap;
+    logger: Logger;
+    /** Identifies the lease owner in `cms_jobs.lease_owner` (for crash-recovery visibility). */
+    workerId: string;
+    /** Scope to one tenant; omit to claim across all orgs (worker context, override access). */
+    organizationId?: string;
+    /** Max jobs claimed this batch. Default 10. */
+    batchSize?: number;
+    /** Lease duration (ms) before a claimed-but-unfinished job is reclaimable. Default 30000. */
+    leaseMs?: number;
+    /** First-retry delay (ms); doubles per attempt. Default 1000. */
+    baseBackoffMs?: number;
+    /** Backoff ceiling (ms). Default 1h. */
+    maxBackoffMs?: number;
+    /** Injectable clock (tests). Default `new Date()`. */
+    now?: Date;
+}
+export interface RunDueJobsResult {
+    claimed: number;
+    completed: number;
+    retried: number;
+    failed: number;
+}
+export declare function runDueJobs(options: RunDueJobsOptions): Promise<RunDueJobsResult>;
+//# sourceMappingURL=run-due-jobs.d.ts.map

package/dist/jobs/run-due-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-due-jobs.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/run-due-jobs.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,iBAAiB;IACjC,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,GAAG,CAAC,EAAE,IAAI,CAAC;CACX;AAED,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CACf;AAkBD,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmEtF"}

package/dist/jobs/run-due-jobs.js

@@ -0,0 +1,69 @@
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_LEASE_MS = 30_000;
+const DEFAULT_BASE_BACKOFF_MS = 1_000;
+const DEFAULT_MAX_BACKOFF_MS = 60 * 60 * 1_000;
+/**
+ * Exponential backoff with jitter. `attempts` is 1-based (the claim already bumped it),
+ * so the first retry waits ~base, the second ~2×base, capped at `max`. Up to 25% of
+ * extra jitter spreads retries so a batch that failed together doesn't re-thunder as one.
+ */
+function backoffMs(attempts, base, max) {
+    const exp = Math.min(max, base * 2 ** (attempts - 1));
+    const jitter = Math.random() * exp * 0.25;
+    return Math.min(max, exp + jitter);
+}
+export async function runDueJobs(options) {
+    const { databaseAdapter, handlers, logger, workerId, organizationId } = options;
+    const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+    const baseBackoffMs = options.baseBackoffMs ?? DEFAULT_BASE_BACKOFF_MS;
+    const maxBackoffMs = options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    const now = options.now ?? new Date();
+    const claimed = await databaseAdapter.claimDueJobs({
+        organizationId,
+        limit: batchSize,
+        workerId,
+        leaseMs,
+        now
+    });
+    const result = {
+        claimed: claimed.length,
+        completed: 0,
+        retried: 0,
+        failed: 0
+    };
+    for (const job of claimed) {
+        const handler = handlers[job.type];
+        // Unknown type can never become runnable — dead-letter it now rather than burn retries.
+        if (!handler) {
+            logger.error('[jobs]', `No handler registered for job type "${job.type}" (job ${job.id}); dead-lettering.`);
+            await databaseAdapter.failJob(job.organizationId, job.id, {
+                error: `No handler registered for job type "${job.type}"`
+            });
+            result.failed++;
+            continue;
+        }
+        try {
+            await handler({ job, databaseAdapter, logger });
+            await databaseAdapter.completeJob(job.organizationId, job.id);
+            result.completed++;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // `attempts` was incremented by the claim, so it already counts this run.
+            if (job.attempts >= job.maxAttempts) {
+                logger.error('[jobs]', `Job ${job.id} (${job.type}) failed permanently after ${job.attempts}/${job.maxAttempts} attempts: ${message}`);
+                await databaseAdapter.failJob(job.organizationId, job.id, { error: message });
+                result.failed++;
+            }
+            else {
+                const delay = backoffMs(job.attempts, baseBackoffMs, maxBackoffMs);
+                const runAt = new Date(now.getTime() + delay);
+                logger.warn('[jobs]', `Job ${job.id} (${job.type}) failed (attempt ${job.attempts}/${job.maxAttempts}); retrying in ${Math.round(delay)}ms: ${message}`);
+                await databaseAdapter.retryJob(job.organizationId, job.id, { runAt, error: message });
+                result.retried++;
+            }
+        }
+    }
+    return result;
+}

package/dist/jobs/types.d.ts

@@ -0,0 +1,18 @@
+import type { DatabaseAdapter } from '../db/interfaces/index.js';
+import type { Job } from '../types/events.js';
+import type { Logger } from '../utils/logger.js';
+/** What a job handler receives. `databaseAdapter` is the live adapter (org-scoped calls still take an org id). */
+export interface JobContext {
+    job: Job;
+    databaseAdapter: DatabaseAdapter;
+    logger: Logger;
+}
+/**
+ * Runs one job. Resolve to complete it; throw to signal failure — the runner
+ * then retries with backoff (attempts remain) or dead-letters it (attempts exhausted).
+ * Handlers must be idempotent: at-least-once delivery means a job can run more than once.
+ */
+export type JobHandler = (ctx: JobContext) => Promise<void>;
+/** Map of job `type` → handler. A claimed job whose type has no handler is dead-lettered. */
+export type JobHandlerMap = Record<string, JobHandler>;
+//# sourceMappingURL=types.d.ts.map

package/dist/jobs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C,kHAAkH;AAClH,MAAM,WAAW,UAAU;IAC1B,GAAG,EAAE,GAAG,CAAC;IACT,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5D,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC"}

package/dist/jobs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/api/documents.d.ts

@@ -46,6 +46,31 @@ export declare class DocumentsApi {
      * Unpublish document (revert to draft only)
      */
     static unpublish(id: string): Promise<ApiResponse<DocumentDTO>>;
+    /**
+     * Schedule a publish/unpublish for a future time (ISO-8601 `runAt`).
+     * Enqueues a job the worker runs at that time — the permission check happens now.
+     */
+    static schedule(id: string, body: {
+        action: 'publish' | 'unpublish';
+        runAt: string;
+    }): Promise<ApiResponse<{
+        jobId: string;
+        type: string;
+        runAt: string;
+        status: string;
+    }>>;
+    /** Pending scheduled publish/unpublish for a document (for the editor's schedule indicator). */
+    static getSchedule(id: string): Promise<ApiResponse<Array<{
+        jobId: string;
+        type: string;
+        runAt: string;
+        status: string;
+        createdAt: string;
+    }>>>;
+    /** Cancel the pending schedule for a document. */
+    static cancelSchedule(id: string): Promise<ApiResponse<{
+        cancelled: number;
+    }>>;
     /**
      * Delete document by ID
      */
@@ -84,6 +109,9 @@ export declare const documents: {
     updateById: typeof DocumentsApi.updateById;
     publish: typeof DocumentsApi.publish;
     unpublish: typeof DocumentsApi.unpublish;
+    schedule: typeof DocumentsApi.schedule;
+    getSchedule: typeof DocumentsApi.getSchedule;
+    cancelSchedule: typeof DocumentsApi.cancelSchedule;
     deleteById: typeof DocumentsApi.deleteById;
     getByType: typeof DocumentsApi.getByType;
     getPublished: typeof DocumentsApi.getPublished;

package/dist/lib/api/documents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../src/lib/api/documents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EACX,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,MAAM,qBAAqB,CAAC;AAI7B,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,CAAC;AAEpD,qBAAa,YAAY;IACxB;;;OAGG;WACU,IAAI,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;IAUvF;;OAEG;WACU,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAInE;;;;OAIG;WACU,iBAAiB,CAC7B,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC,CAAC;IAMnF;;;;;OAKG;WACU,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;IAKxE;;OAEG;WACU,MAAM,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAInF;;;;OAIG;WACU,UAAU,CACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,qBAAqB,GACzB,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAIpC;;OAEG;WACU,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAInE;;OAEG;WACU,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAIrE;;OAEG;WACU,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAI/D;;OAEG;WACU,SAAS,CACrB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAM,GAC9C,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;IAItC;;OAEG;WACU,YAAY,CACxB,MAAM,GAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAM,GAC7C,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;IAItC;;OAEG;WACU,SAAS,CACrB,MAAM,GAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAM,GAC7C,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC;IAItC;;OAEG;WACU,YAAY,CACxB,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,iBAAiB,GACxB,OAAO,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC,CAAC;IAI1C;;OAEG;WACU,UAAU,CACtB,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;IAIxC;;OAEG;WACU,cAAc,CAC1B,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;CAGpC;AAGD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;CAgBrB,CAAC"}
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../src/lib/api/documents.ts"],"names":[],"mappings":"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"}