emdash 0.18.0 → 0.19.0

package/src/emdash-runtime.ts

@@ -24,7 +24,10 @@ import { isSqlite } from "./database/dialect-helpers.js";
 import { kyselyLogOption } from "./database/instrumentation.js";
 import { MIGRATION_RACE_WAIT_MS, runMigrations } from "./database/migrations/runner.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
-import type { ContentItem as ContentItemInternal } from "./database/repositories/types.js";
+import type {
+	ContentItem as ContentItemInternal,
+	ContentDateField,
+} from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
 import { normalizeMediaValue } from "./media/normalize.js";
 import type { MediaProvider, MediaProviderCapabilities } from "./media/types.js";
@@ -115,6 +118,7 @@ import { validateEncryptionKeyAtStartup } from "./config/secrets.js";
 import { OptionsRepository } from "./database/repositories/options.js";
 import {
 	handleContentList,
+	handleContentAuthors,
 	handleContentGet,
 	handleContentGetIncludingTrashed,
 	handleContentCreate,
@@ -158,13 +162,12 @@ import {
 import { normalizeManifestRoute } from "./plugins/manifest-schema.js";
 import { extractRequestMeta, sanitizeHeadersForSandbox } from "./plugins/request-meta.js";
 import { PluginRouteRegistry, type RouteMeta } from "./plugins/routes.js";
-import { NodeCronScheduler } from "./plugins/scheduler/node.js";
-import { PiggybackScheduler } from "./plugins/scheduler/piggyback.js";
 import type { CronScheduler } from "./plugins/scheduler/types.js";
 import { PluginStateRepository } from "./plugins/state.js";
 import { normalizeRegistryConfig } from "./registry/config.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
+import { publishDueContent, type PublishedRef } from "./scheduled-publish.js";
 import { FTSManager } from "./search/fts-manager.js";
 import { invalidateSiteSettingsCache } from "./settings/index.js";
 
@@ -237,6 +240,13 @@ export interface MediaProviderContext {
 	storage: Storage | null;
 }
 
+/**
+ * Builds the timer-based scheduler that drives cron ticks and maintenance.
+ * Injected via `virtual:emdash/scheduler` so the platform — not core — decides
+ * whether a long-lived heartbeat exists.
+ */
+export type CreateSchedulerFn = (executor: CronExecutor) => CronScheduler;
+
 /**
  * Dependencies injected from virtual modules (middleware reads these)
  */
@@ -250,6 +260,16 @@ export interface RuntimeDependencies {
 	sandboxEnabled: boolean;
 	/** sandbox: false escape hatch - load sandboxed plugins in-process */
 	sandboxBypassed?: boolean;
+	/**
+	 * Factory for the timer-based cron/maintenance heartbeat. Supplied by the
+	 * generated `virtual:emdash/scheduler` module: a `NodeCronScheduler` factory
+	 * on long-lived runtimes (Node/Bun), or `null` on serverless adapters where
+	 * an external driver (e.g. the Cloudflare Worker's `scheduled()` Cron
+	 * Trigger) calls `runScheduledTasks()` instead. When absent or null, the
+	 * runtime starts no scheduler. Keeping the platform decision in the
+	 * integration means core has no adapter-specific runtime checks.
+	 */
+	createScheduler?: CreateSchedulerFn | null;
 	/** Media provider entries from virtual module */
 	mediaProviderEntries?: MediaProviderEntry[];
 	sandboxedPluginEntries: SandboxedPluginEntry[];
@@ -479,14 +499,65 @@ export class EmDashRuntime {
 	}
 
 	/**
-	 * Tick the cron system from request context (piggyback mode).
-	 * Call this from middleware on each request to ensure cron tasks
-	 * execute even when no dedicated scheduler is available.
+	 * Publish any content whose scheduled time has passed.
+	 * Returns the items promoted so callers can invalidate their cache tags.
+	 */
+	async publishScheduled(): Promise<PublishedRef[]> {
+		return publishDueContent(this.db, {
+			publish: (collection, id, options) => this.handleContentPublish(collection, id, options),
+		});
+	}
+
+	/**
+	 * Run the full scheduled-maintenance batch: cron tasks, scheduled
+	 * publishing, and system cleanup. For request-less drivers — the
+	 * Cloudflare `scheduled()` handler invokes this from a Cron Trigger.
+	 * (On Node the timer-based scheduler drives the same work itself.)
+	 *
+	 * Each step is independent and non-fatal. Returns the content promoted
+	 * by the publishing sweep so the caller can purge edge-cache tags.
+	 *
+	 * `onPublished` (optional) is awaited after each collection's batch so a
+	 * request-less driver can invalidate edge-cache tags incrementally rather
+	 * than only after the whole sweep — bounding stale-cache exposure if the
+	 * runtime is killed mid-sweep.
 	 */
-	tickCron(): void {
-		if (this.cronScheduler instanceof PiggybackScheduler) {
-			this.cronScheduler.onRequest();
+	async runScheduledTasks(
+		options: {
+			onPublished?: (refs: PublishedRef[]) => Promise<void>;
+		} = {},
+	): Promise<{ published: PublishedRef[] }> {
+		if (this.cronExecutor) {
+			try {
+				await this.cronExecutor.tick();
+			} catch (error) {
+				console.error("[cron] Tick failed:", error);
+			}
+			try {
+				await this.cronExecutor.recoverStaleLocks();
+			} catch (error) {
+				console.error("[cron] Stale lock recovery failed:", error);
+			}
 		}
+
+		let published: PublishedRef[] = [];
+		try {
+			// Route through the runtime wrapper so content:afterPublish hooks fire.
+			published = await publishDueContent(this.db, {
+				publish: (collection, id, opts) => this.handleContentPublish(collection, id, opts),
+				onPublished: options.onPublished,
+			});
+		} catch (error) {
+			console.error("[scheduled-publish] Sweep failed:", error);
+		}
+
+		try {
+			await runSystemCleanup(this.db, this.storage ?? undefined);
+		} catch (error) {
+			console.error("[cleanup] System cleanup failed:", error);
+		}
+
+		return { published };
 	}
 
 	/**
@@ -1173,6 +1244,11 @@ export class EmDashRuntime {
 
 		let cronExecutor: CronExecutor | null = null;
 		let cronScheduler: CronScheduler | null = null;
+		// Populated with the constructed runtime just before this method returns,
+		// so the timer scheduler's cleanup can route scheduled publishing through
+		// the runtime wrapper (firing content:afterPublish hooks). The first tick
+		// is ≥1s out, well after the synchronous assignment below.
+		const runtimeRef: { current: EmDashRuntime | null } = { current: null };
 
 		await phase("rt.cron", "Cron init (recovery deferred post-response)", async () => {
 			try {
@@ -1198,46 +1274,57 @@ export class EmDashRuntime {
 					}
 				});
 
-				// Detect platform and create appropriate scheduler.
-				// On Cloudflare Workers, setTimeout is available but unreliable for
-				// long durations — use PiggybackScheduler as default.
-				// In Node/Bun, use NodeCronScheduler with real timers.
-				const isWorkersRuntime =
-					typeof globalThis.navigator !== "undefined" &&
-					globalThis.navigator.userAgent === "Cloudflare-Workers";
-
-				if (isWorkersRuntime) {
-					cronScheduler = new PiggybackScheduler(cronExecutor);
-				} else {
-					cronScheduler = new NodeCronScheduler(cronExecutor);
-				}
-
-				// Register system cleanup to run alongside each scheduler tick.
-				// Pass storage so cleanupPendingUploads can delete orphaned files.
-				cronScheduler.setSystemCleanup(async () => {
-					try {
-						await runSystemCleanup(db, storage ?? undefined);
-					} catch (error) {
-						// Non-fatal -- individual cleanup failures are already logged
-						// by runSystemCleanup. This catches unexpected errors.
-						console.error("[cleanup] System cleanup failed:", error);
-					}
-				});
+				// The platform decides whether a long-lived timer heartbeat exists.
+				// `createScheduler` is injected by the generated virtual:emdash/scheduler
+				// module: a NodeCronScheduler factory on Node/Bun, or null on serverless
+				// adapters (e.g. Cloudflare) where the Worker's `scheduled()` handler
+				// drives runScheduledTasks() instead. No adapter check lives here.
+				if (deps.createScheduler) {
+					const scheduler = deps.createScheduler(cronExecutor);
+					cronScheduler = scheduler;
+
+					// Run scheduled publishing and system cleanup alongside each tick.
+					// Pass storage so cleanupPendingUploads can delete orphaned files.
+					scheduler.setSystemCleanup(async () => {
+						try {
+							// Route through the runtime so content:afterPublish hooks fire.
+							// Falls back to the raw handler if (improbably) the tick beats
+							// the post-construction ref assignment.
+							const runtime = runtimeRef.current;
+							await publishDueContent(db, {
+								publish: runtime
+									? (collection, id, options) =>
+											runtime.handleContentPublish(collection, id, options)
+									: undefined,
+							});
+						} catch (error) {
+							console.error("[scheduled-publish] Sweep failed:", error);
+						}
+						try {
+							await runSystemCleanup(db, storage ?? undefined);
+						} catch (error) {
+							// Non-fatal -- individual cleanup failures are already logged
+							// by runSystemCleanup. This catches unexpected errors.
+							console.error("[cleanup] System cleanup failed:", error);
+						}
+					});
 
-				// Add cron reschedule callback (merges with existing factory options)
-				pipeline.setContextFactory({
-					cronReschedule: () => cronScheduler?.reschedule(),
-				});
+					// Add cron reschedule callback (merges with existing factory options)
+					pipeline.setContextFactory({
+						cronReschedule: () => cronScheduler?.reschedule(),
+					});
 
-				// Start the scheduler
-				await cronScheduler.start();
+					// start() is void on the timer scheduler but the interface
+					// allows a promise (alarm-backed schedulers); we don't block on it.
+					void scheduler.start();
+				}
 			} catch (error) {
 				console.warn("[cron] Failed to initialize cron system:", error);
 				// Non-fatal — CMS works without cron
 			}
 		});
 
-		return new EmDashRuntime({
+		const runtime = new EmDashRuntime({
 			db,
 			storage,
 			// Include bypassed sandboxed plugins in configuredPlugins so route
@@ -1260,6 +1347,10 @@ export class EmDashRuntime {
 			runtimeDeps: deps,
 			pipelineRef,
 		});
+		// Hand the constructed instance to the scheduler-cleanup closure so the
+		// timer-driven sweep can fire publish hooks (see runtimeRef above).
+		runtimeRef.current = runtime;
+		return runtime;
 	}
 
 	/**
@@ -2174,11 +2265,19 @@ export class EmDashRuntime {
 			order?: "asc" | "desc";
 			locale?: string;
 			q?: string;
+			authorId?: string;
+			dateField?: ContentDateField;
+			dateFrom?: string;
+			dateTo?: string;
 		},
 	) {
 		return handleContentList(this.db, collection, params);
 	}
 
+	async handleContentAuthors(collection: string) {
+		return handleContentAuthors(this.db, collection);
+	}
+
 	async handleContentGet(collection: string, id: string, locale?: string) {
 		const result = await handleContentGet(this.db, collection, id, locale);
 		return this.hydrateDraftData(result);
@@ -2553,7 +2652,7 @@ export class EmDashRuntime {
 	async handleContentPublish(
 		collection: string,
 		id: string,
-		options: { publishedAt?: string } = {},
+		options: { publishedAt?: string; requireScheduledDue?: boolean } = {},
 	) {
 		const result = await handleContentPublish(this.db, collection, id, options);
 

package/src/index.ts

@@ -46,6 +46,7 @@ export type {
 // API handlers
 export {
 	handleContentList,
+	handleContentAuthors,
 	handleContentGet,
 	handleContentGetIncludingTrashed,
 	handleContentCreate,
@@ -201,6 +202,8 @@ export {
 	PluginManager,
 	createPluginManager,
 	PluginRouteError,
+	// Scheduler (Node timer heartbeat — used by virtual:emdash/scheduler)
+	NodeCronScheduler,
 	// Sandbox
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
@@ -253,6 +256,10 @@ export type {
 	CollectionCommentSettings,
 	StoredComment,
 
+	// Scheduler types
+	CronScheduler,
+	SystemCleanupFn,
+
 	// Sandbox runtime types
 	SandboxRunner,
 	SandboxedPluginInstance,
@@ -406,7 +413,7 @@ export type {
 } from "./menus/types.js";
 
 // Bylines
-export { getByline, getBylineBySlug } from "./bylines/index.js";
+export { getByline, getBylineBySlug, getEntriesByByline } from "./bylines/index.js";
 export type { BylineSummary, ContentBylineCredit } from "./database/repositories/types.js";
 
 // Taxonomies

package/src/loader.ts

@@ -540,12 +540,16 @@ export interface CollectionFilter {
 	 */
 	cursor?: string;
 	/**
-	 * Filter by field values, taxonomy terms, or ranges.
+	 * Filter by field values, taxonomy terms, byline credits, or ranges.
 	 *
 	 * Taxonomy names are detected automatically and filtered via JOIN.
+	 * The reserved `byline` key filters by byline credit (any credit, not
+	 * just the primary one) via the `_emdash_content_bylines` junction
+	 * table; its value is one or more byline translation groups.
 	 * Other keys are treated as column filters on the content table.
 	 *
 	 * @example { category: 'news' } - taxonomy term
+	 * @example { byline: '01HXYZ...' } - entries credited to a byline (any position)
 	 * @example { series: 'main' } - exact match on a content field
 	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - date range
 	 */
@@ -673,13 +677,16 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Build cursor condition if cursor is provided
 				const cursorCondition = cursor ? buildCursorCondition(cursor, orderBy) : null;
-				const cursorConditionPrefixed = cursor
-					? buildCursorCondition(cursor, orderBy, tableName)
-					: null;
 
-				// Separate taxonomy filters from field filters
+				// Separate taxonomy / byline filters from field filters
 				let result: { rows: Record<string, unknown>[] };
 				let taxonomyFilter: { name: string; slugs: string[] } | null = null;
+				// A byline filter matches entries credited to any of the given
+				// byline translation groups via the `_emdash_content_bylines`
+				// junction table. `null` means no byline filter; an empty
+				// `groups` array means the filter was requested but matches
+				// nothing (short-circuited to an empty result below).
+				let bylineFilter: { groups: string[] } | null = null;
 				const fieldFilters: Record<string, WhereValue> = {};
 
 				if (where && Object.keys(where).length > 0) {
@@ -687,7 +694,16 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 					for (const [key, value] of Object.entries(where)) {
 						if (value == null) continue;
-						if (taxNames.has(key)) {
+						if (key === "byline") {
+							if (isWhereRange(value)) {
+								console.warn(
+									`[emdash] where filter: range operators are not supported on "byline", ignored`,
+								);
+								continue;
+							}
+							const groups = Array.isArray(value) ? value : [value];
+							bylineFilter = { groups };
+						} else if (taxNames.has(key)) {
 							if (isWhereRange(value)) {
 								console.warn(
 									`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`,
@@ -708,35 +724,27 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					}
 				}
 
-				if (taxonomyFilter) {
-					const orderByClause = buildOrderByClause(orderBy, tableName);
-					const statusCondition = buildStatusCondition(db, status, tableName);
-					const localeCondition = locale
-						? sql`AND ${sql.ref(tableName)}.locale = ${locale}`
-						: sql``;
-					const cursorCond = cursorConditionPrefixed ? sql`AND ${cursorConditionPrefixed}` : sql``;
-					const fieldConds = buildFieldConditions(fieldFilters, tableName);
-					const fieldCondsSQL =
-						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
+				// A byline or taxonomy filter with no values matches nothing —
+				// short-circuit before building SQL (an empty `IN ()` is invalid
+				// SQL on both dialects).
+				if (
+					(bylineFilter && bylineFilter.groups.length === 0) ||
+					(taxonomyFilter && taxonomyFilter.slugs.length === 0)
+				) {
+					return { entries: [], cacheHint: { tags: [type] } };
+				}
 
-					result = await sql<Record<string, unknown>>`
-						SELECT DISTINCT ${sql.ref(tableName)}.* FROM ${sql.ref(tableName)}
-						INNER JOIN content_taxonomies ct
-							ON ct.collection = ${type}
-							AND ct.entry_id = ${sql.ref(tableName)}.id
-						INNER JOIN taxonomies t
-							ON t.id = ct.taxonomy_id
-						WHERE ${sql.ref(tableName)}.deleted_at IS NULL
-							AND ${statusCondition}
-							${localeCondition}
-							${cursorCond}
-							AND t.name = ${taxonomyFilter.name}
-							AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
-							${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
-						${orderByClause}
-						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
-					`.execute(db);
-				} else {
+				{
+					// Taxonomy and byline filters are applied as correlated
+					// `EXISTS` semi-joins rather than `INNER JOIN ... DISTINCT`.
+					// A join fan-out would force `SELECT DISTINCT table.*`, and
+					// Postgres cannot apply DISTINCT to a row containing a `json`
+					// column (no equality operator), so the join approach throws
+					// there. EXISTS matches "credited/tagged at least once"
+					// without duplicating rows, needs no DISTINCT, and works on
+					// both SQLite and Postgres. The base query stays a single-
+					// table `SELECT *`, so all field/status/locale/cursor/order
+					// conditions reference unprefixed columns as before.
 					const orderByClause = buildOrderByClause(orderBy);
 					const statusCondition = buildStatusCondition(db, status);
 					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
@@ -745,12 +753,37 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					const fieldCondsSQL =
 						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
 
+					const taxonomyCond = taxonomyFilter
+						? sql`AND EXISTS (
+							SELECT 1 FROM content_taxonomies ct
+							INNER JOIN taxonomies t ON t.id = ct.taxonomy_id
+							WHERE ct.collection = ${type}
+								AND ct.entry_id = ${sql.ref(tableName)}.id
+								AND t.name = ${taxonomyFilter.name}
+								AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
+						)`
+						: sql``;
+
+					// `_emdash_content_bylines.byline_id` stores the byline's
+					// translation_group (migration 040), so a credit spans every
+					// locale variant of the byline and we match the group directly.
+					const bylineCond = bylineFilter
+						? sql`AND EXISTS (
+							SELECT 1 FROM _emdash_content_bylines cb
+							WHERE cb.collection_slug = ${type}
+								AND cb.content_id = ${sql.ref(tableName)}.id
+								AND cb.byline_id IN (${sql.join(bylineFilter.groups.map((g) => sql`${g}`))})
+						)`
+						: sql``;
+
 					result = await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.ref(tableName)}
 						WHERE deleted_at IS NULL
 						AND ${statusCondition}
 						${localeFilter}
 						${cursorCond}
+						${taxonomyCond}
+						${bylineCond}
 						${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
 						${orderByClause}
 						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}

package/src/media/responsive.ts

@@ -0,0 +1,125 @@
+/**
+ * Responsive image helpers shared by the public Image components.
+ *
+ * These build a `srcset` for locally-stored / R2-stored media by delegating to
+ * Astro's configured image service (`astro:assets`). On Cloudflare that is the
+ * Images binding; on Node it is sharp; if neither is available it is a no-op
+ * passthrough. The calling `.astro` component passes Astro's `getImage` in so
+ * this module stays free of the `astro:assets` virtual import (which only
+ * resolves inside an Astro project, not in this precompiled package).
+ */
+
+/** Standard responsive breakpoints. Matches CDN-provider srcset generation. */
+export const RESPONSIVE_BREAKPOINTS = [640, 750, 828, 960, 1080, 1280, 1600, 1920];
+
+/** Matches absolute http(s) URLs — the only shape Astro's image services optimize. */
+const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
+
+/**
+ * Pick the srcset widths to generate for an image rendered at `maxWidth`.
+ * Includes breakpoints up to 2x (retina) plus the rendered width itself, so the
+ * browser always has an exact-fit candidate.
+ */
+export function responsiveWidths(maxWidth: number): number[] {
+	const cap = maxWidth * 2;
+	const widths = new Set(RESPONSIVE_BREAKPOINTS.filter((w) => w <= cap));
+	widths.add(maxWidth);
+	return [...widths].toSorted((a, b) => a - b);
+}
+
+/** Build the `sizes` attribute for an image with a known display width. */
+export function responsiveSizes(width: number | undefined): string {
+	return width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
+}
+
+/**
+ * Make a same-origin media URL absolute so Astro's image service can optimize it.
+ *
+ * Astro only optimizes absolute http(s) URLs; a same-origin proxy path like
+ * `/_emdash/api/media/file/x.jpg` is otherwise treated as an unoptimizable
+ * public asset. Resolving it against the site's public origin (and authorizing
+ * that origin via `image.remotePatterns`) lets the service transform it.
+ *
+ * Only **same-origin** root-relative paths are resolved. Protocol-relative
+ * URLs (`//evil.com/x`) and backslash tricks (`/\evil.com`) also start with `/`
+ * but resolve to a different origin -- a classic SSRF vector once a
+ * remotePattern authorizes the media path -- so anything that escapes the
+ * origin is returned unchanged (and then skipped by `buildResponsiveImage`,
+ * which only accepts absolute http(s) URLs). Already-absolute URLs (CDN/public
+ * bucket) and non-path values (`data:`, `blob:`) are returned unchanged too.
+ */
+export function toAbsoluteMediaUrl(src: string, origin: string | undefined): string {
+	if (!src || !origin || !src.startsWith("/")) return src;
+	try {
+		const resolved = new URL(src, origin);
+		if (resolved.origin !== new URL(origin).origin) return src;
+		return resolved.href;
+	} catch {
+		return src;
+	}
+}
+
+/**
+ * Minimal structural subset of Astro's `getImage`. Astro's `ImageTransform`
+ * carries a `[key: string]: any` index signature, so the real `getImage` is
+ * assignable to this narrower type.
+ */
+export type GetImage = (options: {
+	src: string;
+	width?: number;
+	height?: number;
+	widths?: number[];
+	sizes?: string;
+}) => Promise<{ src: string; srcSet?: { attribute?: string } | undefined }>;
+
+export interface ResponsiveImage {
+	src: string;
+	srcset?: string;
+	sizes?: string;
+}
+
+/**
+ * Generate a responsive `src`/`srcset`/`sizes` for a media URL via Astro's
+ * configured image service.
+ *
+ * Astro's image services (sharp, Cloudflare `/cdn-cgi/image`, and the default
+ * Cloudflare `cloudflare-binding` service) only optimize **absolute** URLs whose
+ * host is authorized via `image.domains` / `image.remotePatterns`. Anything else
+ * is passed through unchanged, which would yield a useless srcset (the same URL
+ * at every width descriptor). We therefore only attempt optimization for
+ * absolute http(s) URLs and verify the service actually rewrote the URL.
+ *
+ * Returns `null` so callers fall back to a plain `<img>` when:
+ *  - dimensions are unknown (avoids an inferSize fetch on every render),
+ *  - the URL is relative (a same-origin proxy/public asset Astro won't optimize),
+ *  - the host isn't authorized (the service passed the URL through unchanged),
+ *  - no image service is configured / `getImage` throws.
+ */
+export async function buildResponsiveImage(
+	getImage: GetImage,
+	opts: { src: string; width?: number; height?: number },
+): Promise<ResponsiveImage | null> {
+	const { src, width, height } = opts;
+	if (!src || !width || !height) return null;
+	if (!ABSOLUTE_HTTP_URL.test(src)) return null;
+	try {
+		const sizes = responsiveSizes(width);
+		const result = await getImage({
+			src,
+			width,
+			height,
+			widths: responsiveWidths(width),
+			sizes,
+		});
+		// Passthrough: the service returned the source unchanged (unauthorized
+		// host or no optimization available). Don't emit a no-op srcset.
+		if (!result.src || result.src === src) return null;
+		return {
+			src: result.src,
+			srcset: result.srcSet?.attribute || undefined,
+			sizes,
+		};
+	} catch {
+		return null;
+	}
+}

package/src/plugins/cron.ts

@@ -34,8 +34,9 @@ export type RescheduleFn = () => void;
 /**
  * Executes overdue cron tasks.
  *
- * Called by platform-specific schedulers (NodeCronScheduler, EmDashScheduler DO,
- * PiggybackScheduler). Stateless — all state lives in the database.
+ * Called by the platform driver: the NodeCronScheduler timer on Node, or the
+ * Worker's `scheduled()` handler (via runScheduledTasks) on Cloudflare.
+ * Stateless — all state lives in the database.
  */
 export class CronExecutor {
 	constructor(

package/src/plugins/index.ts

@@ -63,6 +63,11 @@ export type { RouteResult, InvokeRouteOptions } from "./routes.js";
 export { PluginManager, createPluginManager } from "./manager.js";
 export type { PluginManagerOptions, PluginState } from "./manager.js";
 
+// Scheduler (Node timer-based heartbeat; consumed by the generated
+// virtual:emdash/scheduler module on non-serverless adapters)
+export { NodeCronScheduler } from "./scheduler/node.js";
+export type { CronScheduler, SystemCleanupFn } from "./scheduler/types.js";
+
 // Sandbox
 export {
 	NoopSandboxRunner,

package/src/plugins/scheduler/node.ts

@@ -15,8 +15,15 @@ import type { CronScheduler, SystemCleanupFn } from "./types.js";
 /** Minimum polling interval (ms) — prevents tight loops if next_run_at is in the past */
 const MIN_INTERVAL_MS = 1000;
 
-/** Maximum polling interval (ms) — wake up periodically to check for stale locks */
-const MAX_INTERVAL_MS = 5 * 60 * 1000;
+/**
+ * Maximum polling interval (ms). Each wake runs the maintenance pass — stale
+ * lock recovery *and* the scheduled-publishing sweep + system cleanup. The cap
+ * is the worst-case latency for scheduled content when no plugin cron task is
+ * due sooner (`getNextDueTime()` only knows about cron tasks, not content
+ * `scheduled_at`). Held at 60s so Node publish latency matches the Cloudflare
+ * Cron Trigger cadence (`* * * * *`) rather than lagging up to five minutes.
+ */
+const MAX_INTERVAL_MS = 60 * 1000;
 
 export class NodeCronScheduler implements CronScheduler {
 	private timer: ReturnType<typeof setTimeout> | null = null;