emdash 0.17.2 → 0.19.0

package/dist/astro/middleware.mjs

@@ -1,70 +1,70 @@
-import { r as runMigrations } from "../runner-BiuUfx-V.mjs";
+import { i as runMigrations, t as MIGRATION_RACE_WAIT_MS } from "../runner--4wMWwKM.mjs";
 import { t as validateIdentifier } from "../validate-VPnKoIzW.mjs";
 import { o as isSqlite } from "../dialect-helpers-DRI5pyY3.mjs";
 import { i as setI18nConfig } from "../config-CVssduLe.mjs";
-import { _ as definePlugin, f as PluginRouteRegistry, g as resolveExclusiveHooks, h as createHookPipeline, p as EmailPipeline, v as after } from "../menus-CIdZ_Q6U.mjs";
-import { r as RevisionRepository } from "../content-C7aJ7keg.mjs";
+import { _ as resolveExclusiveHooks, g as createHookPipeline, m as EmailPipeline, p as PluginRouteRegistry, v as definePlugin, y as after } from "../menus-Dp9xporj.mjs";
+import { r as RevisionRepository, t as ContentRepository } from "../content-BIlVx-RX.mjs";
 import "../base64-CqR-7kqF.mjs";
-import "../types-CfyYQ7eY.mjs";
-import { t as MediaRepository } from "../media-Cyz5BhSN.mjs";
-import "../user-tLdHUEXV.mjs";
-import "../taxonomy-Db5xwphL.mjs";
-import "../comment-DkAfGX9E.mjs";
-import { t as OptionsRepository } from "../options-BL4X94qY.mjs";
-import "../context-Ca0HkaIh.mjs";
-import "../menus-PFp8FDuO.mjs";
-import "../redirect-C-FeA4j9.mjs";
+import "../types-BXSUSAjt.mjs";
+import { t as MediaRepository } from "../media-JOf3pNkw.mjs";
+import "../user-C0um7wrg.mjs";
+import "../taxonomy-CdllE4oq.mjs";
+import "../comment-sqQxNpN3.mjs";
+import { t as OptionsRepository } from "../options-BPCVnesz.mjs";
+import "../context-GG52SPgh.mjs";
+import "../menus-DX4_E01q.mjs";
+import "../redirect-CRWIt8Zj.mjs";
 import { createRequestMetrics, getRequestContext, runWithContext } from "../request-context.mjs";
-import { r as requestCached } from "../request-cache-BYMs-BGX.mjs";
-import "../byline-registry-CxK5g559.mjs";
-import "../byline-CAhk4FrG.mjs";
-import { t as normalizeMediaValue } from "../normalize-DVV8nbrL.mjs";
+import { r as requestCached } from "../request-cache-D32LpnmI.mjs";
+import "../byline-registry-CWP7I71B.mjs";
+import "../byline-DUx48sJp.mjs";
+import { n as normalizeMediaValue } from "../normalize-CK5o04zr.mjs";
 import "../placeholder-BZxr8W1j.mjs";
-import "../seo-CKr7pLfA.mjs";
+import "../seo-B5e6y9Wk.mjs";
 import { n as isMissingTableError } from "../db-errors-CtzxKBxe.mjs";
-import { $ as handleContentGetIncludingTrashed, B as handleMediaUpdate, G as handleContentCompare, H as handleRevisionList, I as handleMediaCreate, J as handleContentCreate, K as handleContentCountScheduled, L as handleMediaDelete, Q as handleContentGet, R as handleMediaGet, S as PluginStateRepository, U as handleRevisionRestore, V as handleRevisionGet, X as handleContentDiscardDraft, Y as handleContentDelete, Z as handleContentDuplicate, _ as loadBundleFromR2, at as handleContentSchedule, ct as handleContentUnschedule, et as handleContentList, it as handleContentRestore, lt as handleContentUpdate, nt as handleContentPermanentDelete, ot as handleContentTranslations, q as handleContentCountTrashed, rt as handleContentPublish, s as normalizeRegistryConfig, st as handleContentUnpublish, tt as handleContentListTrashed, ut as validateRev, z as handleMediaList } from "../api-B7GATEYo.mjs";
-import "../dashboard-BrfLIsX1.mjs";
+import { $ as handleContentGet, B as handleMediaUpdate, G as handleContentAuthors, H as handleRevisionList, I as handleMediaCreate, J as handleContentCountTrashed, K as handleContentCompare, L as handleMediaDelete, Q as handleContentDuplicate, R as handleMediaGet, S as PluginStateRepository, U as handleRevisionRestore, V as handleRevisionGet, X as handleContentDelete, Y as handleContentCreate, Z as handleContentDiscardDraft, _ as loadBundleFromR2, at as handleContentRestore, ct as handleContentUnpublish, dt as validateRev, et as handleContentGetIncludingTrashed, it as handleContentPublish, lt as handleContentUnschedule, nt as handleContentListTrashed, ot as handleContentSchedule, q as handleContentCountScheduled, rt as handleContentPermanentDelete, s as normalizeRegistryConfig, st as handleContentTranslations, tt as handleContentList, ut as handleContentUpdate, z as handleMediaList } from "../api-BZ6bhjYs.mjs";
+import "../dashboard-2JgAMWxK.mjs";
 import { n as hashString } from "../hash-9w3pd3-m.mjs";
-import { t as FTSManager } from "../fts-manager-XpDfbIKo.mjs";
-import { n as SchemaRegistry } from "../registry-C-T_PWgp.mjs";
+import { t as FTSManager } from "../fts-manager-1RgHmopc.mjs";
+import { n as SchemaRegistry } from "../registry-brYh-rAT.mjs";
 import { createRecorder, flushRecorder, isInstrumentationEnabled, kyselyLogOption } from "../database/instrumentation.mjs";
-import { r as getDb } from "../loader-BxyvbrZP.mjs";
-import "../schema-BpCJh2lU.mjs";
-import "../zod-generator-MMm56Prt.mjs";
+import { r as getDb } from "../loader-CpZKpFz0.mjs";
+import "../schema-CS7Eg5gh.mjs";
+import "../zod-generator-Djo_VHCt.mjs";
 import "../seo-DfjLvu8i.mjs";
-import "../sections-8DEa-dWt.mjs";
-import { o as invalidateSiteSettingsCache } from "../settings-Jro4YcUb.mjs";
-import "../settings-DYVzINdn.mjs";
+import "../sections-DhsZ0ns9.mjs";
+import { o as invalidateSiteSettingsCache } from "../settings-B1p-gPUK.mjs";
+import "../settings-DIsbHTRE.mjs";
 import "../resolve-BqYMVG0D.mjs";
-import "../taxonomies-CGD6y79Q.mjs";
-import "../taxonomies-C0bVme_m.mjs";
+import "../taxonomies-BEW7S5AI.mjs";
+import "../taxonomies-UusDXv3C.mjs";
 import { r as normalizeManifestRoute } from "../manifest-schema-Cj-YrzrF.mjs";
 import "../types-Cj2S6FuC.mjs";
 import "../ssrf-BsVGIE0Z.mjs";
-import "../error-Bk9s3Ism.mjs";
-import "../parse-B-K21lvm.mjs";
-import "../redirects-C0L9JUk4.mjs";
-import "../byline-fields-Dr-xcb6S.mjs";
-import { a as invalidateUrlPatternCache } from "../query-Cc649nDl.mjs";
+import "../error-RwM4dD35.mjs";
+import "../parse-CrGndy1A.mjs";
+import "../redirects-DEygMrRO.mjs";
+import "../byline-fields-51kg6Vuv.mjs";
+import { a as invalidateUrlPatternCache } from "../query-BFQ029Ts.mjs";
 import "../import-Dh8bWmyq.mjs";
 import { t as getTrustedProxyHeaders } from "../trusted-proxy-B4AfnoAp.mjs";
 import { n as sanitizeHeadersForSandbox, t as extractRequestMeta } from "../request-meta-7ByVLxB-.mjs";
 import "../ssrf-BvgVcfNQ.mjs";
-import { n as CronExecutor } from "../cron-DZovZUnC.mjs";
+import { n as CronExecutor } from "../cron-BJ2ClIlj.mjs";
 import { r as devConsoleEmailDeliver, t as DEV_CONSOLE_EMAIL_PLUGIN_ID } from "../email-console-DHT2Fbpj.mjs";
 import "../utils-C4Ih4DML.mjs";
 import "../tokens-Bx2afeT-.mjs";
 import "../preview-BfuRkVKW.mjs";
-import "../bylines-DCczH3AV.mjs";
-import "../widgets-DzlINGI6.mjs";
-import "../apply-BrVqULFe.mjs";
-import "../load-CF5oETkh.mjs";
-import "../search-BrF7k0Ho.mjs";
+import "../bylines-wurS258E.mjs";
+import "../widgets-ClEnYQCH.mjs";
+import "../apply-hQkKKBCf.mjs";
+import "../load-B84ohfBk.mjs";
+import "../search-o-aQzHI1.mjs";
 import "../index.mjs";
-import { n as VERSION, t as COMMIT } from "../version-CgcnMvqS.mjs";
+import { n as VERSION, t as COMMIT } from "../version-Dw0JXu45.mjs";
 import { t as getAuthMode } from "../mode-BjlXswIw.mjs";
 import { t as cleanupExpiredChallenges } from "../challenge-store-DGwuCc4R.mjs";
-import { a as validateEncryptionKeyAtStartup } from "../secrets-YYbTgB1w.mjs";
+import { a as validateEncryptionKeyAtStartup } from "../secrets-C_ZtRos3.mjs";
 import { Kysely, sql } from "kysely";
 import { defineMiddleware } from "astro:middleware";
 import virtualConfig from "virtual:emdash/config";
@@ -73,9 +73,64 @@ import { mediaProviders } from "virtual:emdash/media-providers";
 import { plugins } from "virtual:emdash/plugins";
 import * as virtualSandboxRunnerModule from "virtual:emdash/sandbox-runner";
 import { sandboxedPlugins } from "virtual:emdash/sandboxed-plugins";
+import { createScheduler } from "virtual:emdash/scheduler";
 import { createStorage } from "virtual:emdash/storage";
 import { createKyselyAdapter } from "@emdash-cms/auth/adapters/kysely";
 
+//#region src/utils/init-lock.ts
+function createInitLock() {
+	return {
+		ownerStartedAt: null,
+		generation: 0
+	};
+}
+const DEFAULT_DEADLINE_MS = 15e3;
+const DEFAULT_POLL_MS = 50;
+const MAX_WAIT_HEADROOM_MS = 15e3;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Return the cached value if present, otherwise initialize it under the
+* lock. `init` is responsible for storing the value so that `getCached`
+* returns it on subsequent calls — waiters re-check `getCached` after the
+* owner finishes rather than sharing the owner's promise.
+*
+* `init` receives an `isCurrentClaim` predicate and must gate its cache
+* publication on it: a slow init that was reclaimed past the deadline
+* must not overwrite the value published by the reclaimer (for the
+* runtime singleton that would orphan the reclaimer's active cron
+* scheduler). A losing init should also tear down any side resources it
+* started, since its result will never be published.
+*/
+async function initWithLock(lock, getCached, init, options) {
+	const deadlineMs = options?.deadlineMs ?? DEFAULT_DEADLINE_MS;
+	const pollMs = options?.pollMs ?? DEFAULT_POLL_MS;
+	const maxWaitMs = options?.maxWaitMs ?? deadlineMs + MAX_WAIT_HEADROOM_MS;
+	const waitStart = Date.now();
+	for (;;) {
+		const cached = getCached();
+		if (cached !== null && cached !== void 0) return cached;
+		const ownerStartedAt = lock.ownerStartedAt;
+		if (ownerStartedAt === null || Date.now() - ownerStartedAt > deadlineMs) {
+			lock.generation += 1;
+			const claim = lock.generation;
+			lock.ownerStartedAt = Date.now();
+			try {
+				const isCurrentClaim = () => lock.generation === claim;
+				const initPromise = Promise.resolve().then(() => init(isCurrentClaim));
+				options?.anchor?.(initPromise.then(() => void 0, () => void 0));
+				return await initPromise;
+			} finally {
+				if (lock.generation === claim) lock.ownerStartedAt = null;
+			}
+		}
+		if (Date.now() - waitStart > maxWaitMs) throw new Error(`initWithLock: timed out after ${maxWaitMs}ms waiting for initialization`);
+		await sleep(pollMs);
+	}
+}
+
+//#endregion
 //#region src/cleanup.ts
 /**
 * System cleanup
@@ -195,115 +250,70 @@ async function defaultCommentModerate(event, _ctx) {
 }
 
 //#endregion
-//#region src/plugins/scheduler/node.ts
-/** Minimum polling interval (ms) — prevents tight loops if next_run_at is in the past */
-const MIN_INTERVAL_MS = 1e3;
-/** Maximum polling interval (ms) — wake up periodically to check for stale locks */
-const MAX_INTERVAL_MS = 300 * 1e3;
-var NodeCronScheduler = class {
-	timer = null;
-	running = false;
-	systemCleanup = null;
-	constructor(executor) {
-		this.executor = executor;
-	}
-	setSystemCleanup(fn) {
-		this.systemCleanup = fn;
-	}
-	start() {
-		this.running = true;
-		this.arm();
-	}
-	stop() {
-		this.running = false;
-		if (this.timer) {
-			clearTimeout(this.timer);
-			this.timer = null;
-		}
-	}
-	reschedule() {
-		if (!this.running) return;
-		if (this.timer) {
-			clearTimeout(this.timer);
-			this.timer = null;
+//#region src/scheduled-publish.ts
+/**
+* Default cap on items promoted per collection in a single sweep. Bounds the
+* publish/webhook fan-out of one tick so a large backlog can't exhaust a Worker
+* invocation's CPU/subrequest budget; the remainder drains on later ticks.
+*/
+const SCHEDULED_PUBLISH_BATCH_LIMIT = 100;
+/**
+* Publish every content item whose `scheduled_at` is in the past.
+*
+* Iterates all collections, finds due items (`findReadyToPublish` returns both
+* scheduled drafts and published entries with pending scheduled changes), and
+* publishes each. `publish()` clears `scheduled_at`, so a second sweep is a
+* no-op — safe to run on every tick.
+*
+* Bounded per collection by `limit` (default `SCHEDULED_PUBLISH_BATCH_LIMIT`):
+* a large backlog drains across successive ticks rather than in one unbounded
+* pass. After each collection's batch, `onPublished` (if given) is awaited so
+* cache-tag invalidation happens incrementally, not just at the very end.
+*
+* Returns every item it promoted so request-less callers (the Cloudflare
+* `scheduled()` handler) can also act on the full set.
+*/
+async function publishDueContent(db, options = {}) {
+	const { publish, onPublished, limit = SCHEDULED_PUBLISH_BATCH_LIMIT } = options;
+	const published = [];
+	let collections;
+	try {
+		collections = await new SchemaRegistry(db).listCollections();
+	} catch (error) {
+		console.error("[scheduled-publish] Failed to list collections:", error);
+		return published;
+	}
+	const repo = new ContentRepository(db);
+	const doPublish = publish ?? ((collection, id, opts) => handleContentPublish(db, collection, id, opts));
+	const batchLimit = limit > 0 ? limit : void 0;
+	for (const collection of collections) try {
+		const due = await repo.findReadyToPublish(collection.slug, batchLimit);
+		const batch = [];
+		for (const item of due) {
+			const publishedAt = item.publishedAt == null ? item.scheduledAt ?? void 0 : void 0;
+			const result = await doPublish(collection.slug, item.id, {
+				publishedAt,
+				requireScheduledDue: true
+			});
+			if (result.success) batch.push({
+				collection: collection.slug,
+				id: item.id
+			});
+			else if (result.error?.code === "NOT_DUE") {} else console.error(`[scheduled-publish] Failed to publish ${collection.slug}/${item.id}:`, result.error);
 		}
-		this.arm();
-	}
-	arm() {
-		if (!this.running) return;
-		this.executor.getNextDueTime().then((nextDue) => {
-			if (!this.running) return void 0;
-			let delayMs;
-			if (nextDue) {
-				const dueAt = new Date(nextDue).getTime();
-				delayMs = Math.max(dueAt - Date.now(), MIN_INTERVAL_MS);
-				delayMs = Math.min(delayMs, MAX_INTERVAL_MS);
-			} else delayMs = MAX_INTERVAL_MS;
-			this.timer = setTimeout(() => {
-				if (!this.running) return;
-				this.executeTick();
-			}, delayMs);
-			if (this.timer && typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
-		}).catch((error) => {
-			console.error("[cron:node] Failed to get next due time:", error);
-			if (this.running) {
-				this.timer = setTimeout(() => this.arm(), MAX_INTERVAL_MS);
-				if (this.timer && typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
+		if (batch.length > 0) {
+			published.push(...batch);
+			if (onPublished) try {
+				await onPublished(batch);
+			} catch (error) {
+				console.error(`[scheduled-publish] onPublished failed after "${collection.slug}" batch:`, error);
 			}
-		});
-	}
-	executeTick() {
-		if (!this.running) return;
-		const tasks = [this.executor.tick(), this.executor.recoverStaleLocks()];
-		if (this.systemCleanup) tasks.push(this.systemCleanup());
-		Promise.allSettled(tasks).then((results) => {
-			for (const r of results) if (r.status === "rejected") console.error("[cron:node] Tick task failed:", r.reason);
-		}).finally(() => {
-			if (this.running) this.arm();
-		});
-	}
-};
-
-//#endregion
-//#region src/plugins/scheduler/piggyback.ts
-/** Minimum interval between tick attempts (ms) */
-const DEBOUNCE_MS = 60 * 1e3;
-var PiggybackScheduler = class {
-	lastTickAt = 0;
-	running = false;
-	systemCleanup = null;
-	constructor(executor) {
-		this.executor = executor;
-	}
-	setSystemCleanup(fn) {
-		this.systemCleanup = fn;
-	}
-	start() {
-		this.running = true;
-	}
-	stop() {
-		this.running = false;
-	}
-	/**
-	* No-op for piggyback — tick happens on next request.
-	*/
-	reschedule() {}
-	/**
-	* Call this from middleware on each request.
-	* Debounced: only actually ticks if enough time has passed.
-	*/
-	onRequest() {
-		if (!this.running) return;
-		const now = Date.now();
-		if (now - this.lastTickAt < DEBOUNCE_MS) return;
-		this.lastTickAt = now;
-		const tasks = [this.executor.tick(), this.executor.recoverStaleLocks()];
-		if (this.systemCleanup) tasks.push(this.systemCleanup());
-		Promise.allSettled(tasks).then((results) => {
-			for (const r of results) if (r.status === "rejected") console.error("[cron:piggyback] Tick task failed:", r.reason);
-		});
+		}
+	} catch (error) {
+		console.error(`[scheduled-publish] Sweep failed for "${collection.slug}":`, error);
 	}
-};
+	return published;
+}
 
 //#endregion
 //#region src/emdash-runtime.ts
@@ -381,8 +391,35 @@ const FIELD_TYPE_TO_KIND = {
 function contentItemToRecord(item) {
 	return { ...item };
 }
-const dbCache = /* @__PURE__ */ new Map();
-let dbInitPromise = null;
+/**
+* Db init lock reclaim deadline. Derived from the migration race wait so
+* they can't drift apart: a healthy init can legitimately block for the
+* full MIGRATION_RACE_WAIT_MS inside waitForConcurrentMigrator, plus cold
+* connect and migrator work, before it should be presumed dead. The outer
+* runtime init lock (middleware.ts) must use a strictly larger deadline —
+* it wraps create() → getDatabase() → this lock, and equal deadlines would
+* let the outer reclaim while the inner is legitimately still working.
+*/
+const DB_INIT_DEADLINE_MS = MIGRATION_RACE_WAIT_MS + 2e4;
+/**
+* Db cache + its init lock live on globalThis behind a Symbol: the bundler
+* can duplicate this module across SSR chunks (same reasoning as
+* request-cache.ts), and a duplicated cache/lock would mean concurrent
+* independent db inits — and duplicate migrators — per isolate.
+*/
+const DB_HOLDER_KEY = Symbol.for("emdash:db-cache");
+const globalSymbolStore = globalThis;
+function getDbHolder() {
+	let holder = globalSymbolStore[DB_HOLDER_KEY];
+	if (!holder) {
+		holder = {
+			cache: /* @__PURE__ */ new Map(),
+			lock: createInitLock()
+		};
+		globalSymbolStore[DB_HOLDER_KEY] = holder;
+	}
+	return holder;
+}
 const storageCache = /* @__PURE__ */ new Map();
 const sandboxedPluginCache = /* @__PURE__ */ new Map();
 /**
@@ -495,12 +532,54 @@ var EmDashRuntime = class EmDashRuntime {
 		return this.runtimeDeps.sandboxBypassed === true;
 	}
 	/**
-	* 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.
 	*/
-	tickCron() {
-		if (this.cronScheduler instanceof PiggybackScheduler) this.cronScheduler.onRequest();
+	async publishScheduled() {
+		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.
+	*/
+	async runScheduledTasks(options = {}) {
+		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 = [];
+		try {
+			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 ?? void 0);
+		} catch (error) {
+			console.error("[cleanup] System cleanup failed:", error);
+		}
+		return { published };
 	}
 	/**
 	* Stop the cron scheduler gracefully.
@@ -795,19 +874,13 @@ var EmDashRuntime = class EmDashRuntime {
 		await phase("rt.secrets", "Validate encryption key", () => validateEncryptionKeyAtStartup());
 		const storage = EmDashRuntime.getStorage(deps);
 		let pluginStates = /* @__PURE__ */ new Map();
-		await phase("rt.plugins", "Plugin states", async () => {
+		let siteInfo;
+		await Promise.all([phase("rt.plugins", "Plugin states", async () => {
 			try {
 				const states = await db.selectFrom("_plugin_state").select(["plugin_id", "status"]).execute();
 				pluginStates = new Map(states.map((s) => [s.plugin_id, s.status]));
 			} catch {}
-		});
-		const enabledPlugins = /* @__PURE__ */ new Set();
-		for (const plugin of deps.plugins) {
-			const status = pluginStates.get(plugin.id);
-			if (status === void 0 || status === "active") enabledPlugins.add(plugin.id);
-		}
-		let siteInfo;
-		await phase("rt.site", "Site info options", async () => {
+		}), phase("rt.site", "Site info options", async () => {
 			try {
 				const siteOpts = await new OptionsRepository(db).getMany([
 					"emdash:site_title",
@@ -820,7 +893,12 @@ var EmDashRuntime = class EmDashRuntime {
 					locale: siteOpts.get("emdash:locale") ?? void 0
 				};
 			} catch {}
-		});
+		})]);
+		const enabledPlugins = /* @__PURE__ */ new Set();
+		for (const plugin of deps.plugins) {
+			const status = pluginStates.get(plugin.id);
+			if (status === void 0 || status === "active") enabledPlugins.add(plugin.id);
+		}
 		const allPipelinePlugins = [...deps.plugins];
 		const bypassedPluginsList = [];
 		if (import.meta.env.DEV) try {
@@ -881,8 +959,10 @@ var EmDashRuntime = class EmDashRuntime {
 		};
 		const pipeline = createHookPipeline(enabledPluginList, pipelineFactoryOptions);
 		const sandboxedPlugins = await phase("rt.sandbox", "Sandboxed plugins", () => EmDashRuntime.loadSandboxedPlugins(deps, db, storage));
-		if (deps.config.marketplace && storage && !deps.sandboxBypassed) await phase("rt.market", "Marketplace plugins", () => EmDashRuntime.loadInstalledSandboxedPlugins("marketplace", db, storage, deps, sandboxedPlugins));
-		if (deps.config.experimental?.registry && storage) await phase("rt.registry", "Registry plugins", () => EmDashRuntime.loadInstalledSandboxedPlugins("registry", db, storage, deps, sandboxedPlugins));
+		const installedTierPhases = [];
+		if (deps.config.marketplace && storage && !deps.sandboxBypassed) installedTierPhases.push(phase("rt.market", "Marketplace plugins", () => EmDashRuntime.loadInstalledSandboxedPlugins("marketplace", db, storage, deps, sandboxedPlugins)));
+		if (deps.config.experimental?.registry && storage) installedTierPhases.push(phase("rt.registry", "Registry plugins", () => EmDashRuntime.loadInstalledSandboxedPlugins("registry", db, storage, deps, sandboxedPlugins)));
+		if (installedTierPhases.length > 0) await Promise.all(installedTierPhases);
 		const mediaProviders = /* @__PURE__ */ new Map();
 		const mediaProviderEntries = deps.mediaProviderEntries ?? [];
 		const providerContext = {
@@ -909,6 +989,7 @@ var EmDashRuntime = class EmDashRuntime {
 		});
 		let cronExecutor = null;
 		let cronScheduler = null;
+		const runtimeRef = { current: null };
 		await phase("rt.cron", "Cron init (recovery deferred post-response)", async () => {
 			try {
 				cronExecutor = new CronExecutor(db, invokeCronHook);
@@ -921,22 +1002,30 @@ var EmDashRuntime = class EmDashRuntime {
 						console.error("[cron] Failed to recover stale task locks:", error);
 					}
 				});
-				if (typeof globalThis.navigator !== "undefined" && globalThis.navigator.userAgent === "Cloudflare-Workers") cronScheduler = new PiggybackScheduler(cronExecutor);
-				else cronScheduler = new NodeCronScheduler(cronExecutor);
-				cronScheduler.setSystemCleanup(async () => {
-					try {
-						await runSystemCleanup(db, storage ?? void 0);
-					} catch (error) {
-						console.error("[cleanup] System cleanup failed:", error);
-					}
-				});
-				pipeline.setContextFactory({ cronReschedule: () => cronScheduler?.reschedule() });
-				await cronScheduler.start();
+				if (deps.createScheduler) {
+					const scheduler = deps.createScheduler(cronExecutor);
+					cronScheduler = scheduler;
+					scheduler.setSystemCleanup(async () => {
+						try {
+							const runtime = runtimeRef.current;
+							await publishDueContent(db, { publish: runtime ? (collection, id, options) => runtime.handleContentPublish(collection, id, options) : void 0 });
+						} catch (error) {
+							console.error("[scheduled-publish] Sweep failed:", error);
+						}
+						try {
+							await runSystemCleanup(db, storage ?? void 0);
+						} catch (error) {
+							console.error("[cleanup] System cleanup failed:", error);
+						}
+					});
+					pipeline.setContextFactory({ cronReschedule: () => cronScheduler?.reschedule() });
+					scheduler.start();
+				}
 			} catch (error) {
 				console.warn("[cron] Failed to initialize cron system:", error);
 			}
 		});
-		return new EmDashRuntime({
+		const runtime = new EmDashRuntime({
 			db,
 			storage,
 			configuredPlugins: [...deps.plugins, ...bypassedPluginsList],
@@ -956,6 +1045,8 @@ var EmDashRuntime = class EmDashRuntime {
 			runtimeDeps: deps,
 			pipelineRef
 		});
+		runtimeRef.current = runtime;
+		return runtime;
 	}
 	/**
 	* Get a media provider by ID
@@ -987,10 +1078,8 @@ var EmDashRuntime = class EmDashRuntime {
 			throw new Error("EmDash database not configured. Either configure database in astro.config.mjs or use emdashLoader in live.config.ts");
 		}
 		const cacheKey = dbConfig.entrypoint;
-		const cached = dbCache.get(cacheKey);
-		if (cached) return cached;
-		if (dbInitPromise) return dbInitPromise;
-		dbInitPromise = (async () => {
+		const holder = getDbHolder();
+		return initWithLock(holder.lock, () => holder.cache.get(cacheKey), async (isCurrentClaim) => {
 			const db = new Kysely({
 				dialect: deps.createDialect(dbConfig.config),
 				log: kyselyLogOption()
@@ -1006,9 +1095,9 @@ var EmDashRuntime = class EmDashRuntime {
 					}
 				})();
 				if (collectionCount.count === 0 && !setupDone) {
-					const { applySeed } = await import("../apply-BrVqULFe.mjs").then((n) => n.n);
-					const { loadSeed } = await import("../load-CF5oETkh.mjs").then((n) => n.r);
-					const { validateSeed } = await import("../validate-DWmnRg6E.mjs").then((n) => n.n);
+					const { applySeed } = await import("../apply-hQkKKBCf.mjs").then((n) => n.n);
+					const { loadSeed } = await import("../load-B84ohfBk.mjs").then((n) => n.r);
+					const { validateSeed } = await import("../validate-ZP9Dvg0P.mjs").then((n) => n.n);
 					const seed = await loadSeed();
 					if (validateSeed(seed).valid) {
 						await applySeed(db, seed, { onConflict: "skip" });
@@ -1016,14 +1105,12 @@ var EmDashRuntime = class EmDashRuntime {
 					}
 				}
 			} catch {}
-			dbCache.set(cacheKey, db);
+			if (isCurrentClaim()) holder.cache.set(cacheKey, db);
 			return db;
-		})();
-		try {
-			return await dbInitPromise;
-		} finally {
-			dbInitPromise = null;
-		}
+		}, {
+			deadlineMs: DB_INIT_DEADLINE_MS,
+			anchor: (promise) => after(() => promise)
+		});
 	}
 	/**
 	* Get or create storage instance
@@ -1282,6 +1369,7 @@ var EmDashRuntime = class EmDashRuntime {
 			pipeline,
 			isActive: () => true,
 			getOption: (key) => optionsRepo.get(key),
+			getOptions: (keys) => optionsRepo.getMany(keys),
 			setOption: (key, value) => optionsRepo.set(key, value),
 			deleteOption: async (key) => {
 				await optionsRepo.delete(key);
@@ -1484,6 +1572,9 @@ var EmDashRuntime = class EmDashRuntime {
 	async handleContentList(collection, params) {
 		return handleContentList(this.db, collection, params);
 	}
+	async handleContentAuthors(collection) {
+		return handleContentAuthors(this.db, collection);
+	}
 	async handleContentGet(collection, id, locale) {
 		const result = await handleContentGet(this.db, collection, id, locale);
 		return this.hydrateDraftData(result);
@@ -1540,7 +1631,7 @@ var EmDashRuntime = class EmDashRuntime {
 		if (this.hooks.hasHooks("content:beforeSave")) processedData = (await this.hooks.runContentBeforeSave(body.data, collection, true)).content;
 		processedData = await this.runSandboxedBeforeSave(processedData, collection, true);
 		processedData = await this.normalizeMediaFields(collection, processedData);
-		const { validateContentData } = await import("../validation-BQ_TP-On.mjs");
+		const { validateContentData } = await import("../validation-CE5i4q0c.mjs");
 		const validation = await validateContentData(this.db, collection, processedData, { partial: false });
 		if (!validation.ok) return {
 			success: false,
@@ -1556,7 +1647,7 @@ var EmDashRuntime = class EmDashRuntime {
 		return result;
 	}
 	async handleContentUpdate(collection, id, body) {
-		const { ContentRepository } = await import("../content-C7aJ7keg.mjs").then((n) => n.n);
+		const { ContentRepository } = await import("../content-BIlVx-RX.mjs").then((n) => n.n);
 		const repo = new ContentRepository(this.db);
 		const resolvedItem = await repo.findByIdOrSlug(collection, id, body.locale);
 		const resolvedId = resolvedItem?.id ?? id;
@@ -1583,7 +1674,7 @@ var EmDashRuntime = class EmDashRuntime {
 			if (this.hooks.hasHooks("content:beforeSave")) processedData = (await this.hooks.runContentBeforeSave(bodyWithoutRev.data, collection, false)).content;
 			processedData = await this.runSandboxedBeforeSave(processedData, collection, false);
 			processedData = await this.normalizeMediaFields(collection, processedData);
-			const { validateContentData } = await import("../validation-BQ_TP-On.mjs");
+			const { validateContentData } = await import("../validation-CE5i4q0c.mjs");
 			const validation = await validateContentData(this.db, collection, processedData, { partial: true });
 			if (!validation.ok) return {
 				success: false,
@@ -2123,6 +2214,70 @@ function createPublicMediaUrlResolver(storage) {
 	return (key) => resolvePublicMediaUrl(storage, key);
 }
 
+//#endregion
+//#region src/astro/middleware/stream-end-metrics.ts
+/**
+* Stream-end metrics
+*
+* Server-Timing db.* counters are snapshotted when middleware's next()
+* returns — but at that point only the response *headers* are final.
+* Astro streams the body afterwards, and components rendered during
+* streaming issue further DB queries that the headers can never report.
+*
+* This module wraps the response body in an identity TransformStream and
+* snapshots the request metrics in flush(), i.e. when the body actually
+* finishes streaming. The metrics object lives on the request context
+* (AsyncLocalStorage) and is mutated in-place by the Kysely log hook, so
+* a reference captured before wrapping observes every post-header query.
+* The snapshot is emitted as prefixed NDJSON on stdout (same transport as
+* [emdash-query-log] — console.log works in both Node and workerd).
+*
+* Gated on isInstrumentationEnabled() (EMDASH_QUERY_LOG=1): zero overhead
+* in normal production traffic.
+*/
+const STREAM_END_PREFIX = "[emdash-stream-end]";
+/**
+* Astro attaches AstroCookies to outgoing responses via a well-known global
+* symbol. Constructing a new Response drops non-header metadata, so the
+* symbol must be forwarded explicitly or `cookies.set()` calls are silently
+* dropped. Same pattern as finalizeResponse in ../middleware.ts.
+*/
+const ASTRO_COOKIES_SYMBOL$1 = Symbol.for("astro.cookies");
+/**
+* Wrap a response body so the FINAL request metrics are emitted when the
+* body finishes streaming. Returns the response unchanged when
+* instrumentation is disabled, the body is null, or no request metrics
+* are attached (e.g. outside the middleware's ALS context).
+*/
+function wrapBodyForStreamMetrics(response) {
+	if (!isInstrumentationEnabled()) return response;
+	if (!response.body) return response;
+	const ctx = getRequestContext();
+	const metrics = ctx?.metrics;
+	if (!metrics) return response;
+	const recorder = ctx?.queryRecorder;
+	const transform = new TransformStream({ flush() {
+		const snapshot = {
+			route: recorder?.route,
+			method: recorder?.method,
+			phase: recorder?.phase,
+			totalMs: performance.now() - metrics.start,
+			dbCount: metrics.dbCount,
+			dbTotalMs: metrics.dbTotalMs,
+			dbFirstOffset: metrics.dbFirstOffset,
+			dbLastOffset: metrics.dbLastOffset,
+			cacheHits: metrics.cacheHits,
+			cacheMisses: metrics.cacheMisses
+		};
+		console.log(`${STREAM_END_PREFIX} ${JSON.stringify(snapshot)}`);
+	} });
+	const wrapped = new Response(response.body.pipeThrough(transform), response);
+	const astroCookies = Reflect.get(response, ASTRO_COOKIES_SYMBOL$1);
+	if (astroCookies !== void 0) Reflect.set(wrapped, ASTRO_COOKIES_SYMBOL$1, astroCookies);
+	wrapped.headers.delete("Content-Length");
+	return wrapped;
+}
+
 //#endregion
 //#region src/astro/public-plugin-api-routes.ts
 function pluginRouteNotFound() {
@@ -2149,10 +2304,14 @@ function createPublicPluginApiRouteHandler(runtime) {
 * Thin wrapper that initializes EmDashRuntime and attaches it to locals.
 * All heavy lifting happens in EmDashRuntime.
 */
-let runtimeInstance = null;
-let runtimeInitializing = false;
-/** Whether i18n config has been initialized from the virtual module */
-let i18nInitialized = false;
+/**
+* Runtime init lock reclaim deadline. Must be strictly larger than the db
+* init deadline: this lock wraps EmDashRuntime.create() → getDatabase() →
+* the db init lock, and equal deadlines would let this outer lock reclaim
+* (spawning a second cron scheduler and sandbox runner) while the inner db
+* init is legitimately still working through a contended migration.
+*/
+const RUNTIME_INIT_DEADLINE_MS = DB_INIT_DEADLINE_MS + 15e3;
 /**
 * Whether we've verified the database has been set up.
 * On a fresh deployment the first request may hit a public page, bypassing
@@ -2177,6 +2336,27 @@ function markSetupVerified() {
 	setupFlagStore[SETUP_VERIFIED_KEY] = true;
 }
 /**
+* The runtime singleton and its init lock live on globalThis behind a
+* Symbol — same reasoning as SETUP_VERIFIED_KEY above: the bundler can
+* duplicate this module across SSR chunks, and a duplicated instance/lock
+* would mean multiple runtimes (each with its own cron scheduler) per
+* isolate, initializing and reclaiming independently.
+*/
+const RUNTIME_HOLDER_KEY = Symbol.for("emdash:runtime-holder");
+function getRuntimeHolder() {
+	let holder = setupFlagStore[RUNTIME_HOLDER_KEY];
+	if (!holder) {
+		holder = {
+			instance: null,
+			lock: createInitLock()
+		};
+		setupFlagStore[RUNTIME_HOLDER_KEY] = holder;
+	}
+	return holder;
+}
+/** Whether i18n config has been initialized from the virtual module */
+let i18nInitialized = false;
+/**
 * Get EmDash configuration from virtual module
 */
 function getConfig() {
@@ -2207,6 +2387,7 @@ function buildDependencies(config) {
 		plugins: getPlugins(),
 		createDialect,
 		createStorage,
+		createScheduler,
 		sandboxEnabled: sandboxModule.sandboxEnabled,
 		sandboxBypassed: sandboxModule.sandboxBypassed ?? false,
 		sandboxedPluginEntries: sandboxedPlugins || [],
@@ -2223,20 +2404,38 @@ function buildDependencies(config) {
 * as "warm, nothing to report".
 */
 async function getRuntime(config, initTimings) {
-	if (runtimeInstance) return runtimeInstance;
-	if (runtimeInitializing) {
-		await new Promise((resolve) => setTimeout(resolve, 50));
-		return getRuntime(config, initTimings);
-	}
-	runtimeInitializing = true;
-	try {
+	const holder = getRuntimeHolder();
+	return initWithLock(holder.lock, () => holder.instance, async (isCurrentClaim) => {
 		const deps = buildDependencies(config);
 		const runtime = await EmDashRuntime.create(deps, initTimings);
-		runtimeInstance = runtime;
+		if (isCurrentClaim()) holder.instance = runtime;
+		else runtime.stopCron().catch((error) => {
+			console.error("[emdash] failed to stop superseded runtime's cron:", error);
+		});
 		return runtime;
-	} finally {
-		runtimeInitializing = false;
-	}
+	}, {
+		deadlineMs: RUNTIME_INIT_DEADLINE_MS,
+		anchor: (promise) => after(() => promise)
+	});
+}
+/**
+* Run scheduled maintenance (cron tasks, scheduled publishing, system cleanup)
+* outside any request. Resolves the runtime from the build-time virtual config
+* and the cached singleton — the same instance request handlers use.
+*
+* Wired into a platform heartbeat that is not a request: the Cloudflare Worker's
+* `scheduled()` handler (Cron Trigger) calls this. On Node the runtime's own
+* timer-based scheduler already drives the same work, so this isn't needed there.
+*
+* Returns the content promoted by the publishing sweep so the caller can purge
+* edge-cache tags for it. `onPublished` (optional) is awaited after each
+* collection's batch so the caller can invalidate edge-cache tags incrementally
+* rather than only after the whole sweep.
+*/
+async function runScheduledTasks(options = {}) {
+	const config = getConfig();
+	if (!config) return { published: [] };
+	return (await getRuntime(config)).runScheduledTasks(options);
 }
 /**
 * Astro attaches AstroCookies to outgoing responses via a well-known global
@@ -2342,7 +2541,7 @@ const onRequest = defineMiddleware(async (context, next) => {
 				if (!isSetupVerified()) {
 					const t0 = performance.now();
 					try {
-						const { getDb } = await import("../loader-BxyvbrZP.mjs").then((n) => n.i);
+						const { getDb } = await import("../loader-CpZKpFz0.mjs").then((n) => n.i);
 						await (await getDb()).selectFrom("_emdash_migrations").selectAll().limit(1).execute();
 						markSetupVerified();
 					} catch (error) {
@@ -2397,7 +2596,7 @@ const onRequest = defineMiddleware(async (context, next) => {
 						desc: "Total middleware"
 					});
 					pushMetricsTimings(timings, metrics);
-					return finalizeResponse(response, timings);
+					return wrapBodyForStreamMetrics(finalizeResponse(response, timings));
 				};
 				if (anonScoped) {
 					const parent = getRequestContext();
@@ -2511,7 +2710,7 @@ const onRequest = defineMiddleware(async (context, next) => {
 					desc: "Total middleware"
 				});
 				pushMetricsTimings(timings, metrics);
-				return finalizeResponse(response, timings);
+				return wrapBodyForStreamMetrics(finalizeResponse(response, timings));
 			};
 			if (scoped) {
 				const parent = getRequestContext();
@@ -2559,5 +2758,5 @@ const onRequest = defineMiddleware(async (context, next) => {
 });
 
 //#endregion
-export { onRequest as default, onRequest };
+export { onRequest as default, onRequest, runScheduledTasks };
 //# sourceMappingURL=middleware.mjs.map