dineway 0.2.40 → 0.2.42

package/dist/{briefing-COw-WcYz.mjs → briefing-CaeEFvkD.mjs}

@@ -1,10 +1,13 @@
 import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
-import { i as encodeCursor, r as decodeCursor } from "./types-RFzE_V1M.mjs";
-import { t as SiteActivityRepository } from "./site-activity-DU0UPDji.mjs";
-import { r as ReviewRequestRepository } from "./review-requests-CUVn0RBl.mjs";
-import { n as isSiteContextType, t as SITE_CONTEXT_TYPES } from "./context-types-CPWAJRs5.mjs";
-import { n as SchemaRegistry } from "./registry-Dclv9iHv.mjs";
-import { a as getSiteSettingsWithDb } from "./settings-DsBzKeUQ.mjs";
+import { i as getContentStorageRuntime } from "./runtime-Ch5G-tnG.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BI3ULB3A.mjs";
+import { o as contentStorageHookSchema } from "./content-BNeuaVCS.mjs";
+import { t as SiteActivityRepository } from "./site-activity-hpfJkmxQ.mjs";
+import { r as ReviewRequestRepository } from "./review-requests-DZYM51yI.mjs";
+import { t as PluginContextFactory } from "./context-Cjz0y4Al.mjs";
+import { n as isSiteContextType, t as SITE_CONTEXT_TYPES } from "./context-types-DDIJhGLs.mjs";
+import { n as SchemaRegistry } from "./registry-B-HULaJI.mjs";
+import { a as getSiteSettingsWithDb } from "./settings-DDOB3gW1.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -319,6 +322,975 @@ function clampLimit$1(value) {
 	return Math.min(Math.max(1, value ?? 50), 100);
 }
 
+//#endregion
+//#region src/plugins/hooks.ts
+/**
+* Plugin Hooks System v2
+*
+* Uses the unified PluginContext for all hooks.
+* Manages lifecycle hooks with:
+* - Deterministic ordering via priority + dependencies
+* - Timeout enforcement
+* - Error isolation
+* - Observability
+*
+*/
+/**
+* Hook pipeline for executing hooks in order
+*/
+var HookPipeline = class HookPipeline {
+	hooks = /* @__PURE__ */ new Map();
+	pluginMap = /* @__PURE__ */ new Map();
+	contextFactory = null;
+	/** Stored so setContextFactory can merge incrementally. */
+	contextFactoryOptions = {};
+	/** Hook names where at least one handler declared exclusive: true */
+	exclusiveHookNames = /* @__PURE__ */ new Set();
+	/**
+	* Selected provider plugin ID for each exclusive hook.
+	* Set by the PluginManager after resolution.
+	*/
+	exclusiveSelections = /* @__PURE__ */ new Map();
+	constructor(plugins, factoryOptions) {
+		if (factoryOptions) {
+			this.contextFactory = new PluginContextFactory(factoryOptions);
+			this.contextFactoryOptions = { ...factoryOptions };
+		}
+		for (const plugin of plugins) this.pluginMap.set(plugin.id, plugin);
+		this.registerPlugins(plugins);
+	}
+	/**
+	* Set or update the context factory options.
+	*
+	* When called on a pipeline that already has a factory, the new options
+	* are merged on top of the existing ones so that callers don't need to
+	* repeat every field (e.g. adding `cronReschedule` without losing
+	* `storage` / `getUploadUrl`).
+	*/
+	setContextFactory(options) {
+		const merged = {
+			...this.contextFactoryOptions,
+			...options
+		};
+		this.contextFactory = new PluginContextFactory(merged);
+		this.contextFactoryOptions = merged;
+	}
+	/**
+	* Get context for a plugin
+	*/
+	getContext(pluginId) {
+		const plugin = this.pluginMap.get(pluginId);
+		if (!plugin) throw new Error(`Plugin "${pluginId}" not found`);
+		if (!this.contextFactory) throw new Error("Context factory not initialized - call setContextFactory first");
+		return this.contextFactory.createContext(plugin);
+	}
+	/**
+	* Get typed hooks for a specific hook name.
+	* The internal map stores ResolvedHook<unknown>, but we know each name
+	* maps to a specific handler type via HookHandlerMap.
+	*
+	* Exclusive hooks that have a selected provider are filtered out — they
+	* should only run via invokeExclusiveHook(), not in the regular pipeline.
+	*/
+	getTypedHooks(name) {
+		const all = this.hooks.get(name) ?? [];
+		if (this.exclusiveSelections.has(name)) return all.filter((h) => !h.exclusive);
+		return all;
+	}
+	assertContentStorageHooks() {
+		this.contentStorageTargets(contentStorageHookSchema.options);
+	}
+	contentStorageTargets(names) {
+		return names.flatMap((name) => this.getTypedHooks(name).map((hook) => {
+			if (hook.idempotent !== true) throw new Error(`Plugin ${hook.pluginId} must declare ${name} idempotent and handle its event key before content storage routing can be enabled.`);
+			return {
+				hook: name,
+				pluginId: hook.pluginId,
+				timeoutMs: hook.timeout
+			};
+		}));
+	}
+	async deliverContentStorageHook(target, event) {
+		const hook = this.getTypedHooks(target.hook).find((value) => value.pluginId === target.pluginId);
+		if (!hook || hook.idempotent !== true) throw new Error("The durable content subscriber is unavailable or no longer declares idempotent delivery.");
+		await this.executeWithTimeout(() => hook.handler(event, this.getContext(hook.pluginId)), Math.min(target.timeoutMs, hook.timeout));
+	}
+	/**
+	* Register all hooks from plugins.
+	*
+	* Registers each hook name individually to preserve type safety. The
+	* internal map stores ResolvedHook<unknown> since it's keyed by string,
+	* but getTypedHooks() restores the correct handler type on retrieval.
+	*/
+	registerPlugins(plugins) {
+		for (const plugin of plugins) {
+			this.registerPluginHook(plugin, "plugin:install");
+			this.registerPluginHook(plugin, "plugin:activate");
+			this.registerPluginHook(plugin, "plugin:deactivate");
+			this.registerPluginHook(plugin, "plugin:uninstall");
+			this.registerPluginHook(plugin, "content:beforeSave");
+			this.registerPluginHook(plugin, "content:afterSave");
+			this.registerPluginHook(plugin, "content:beforeDelete");
+			this.registerPluginHook(plugin, "content:afterDelete");
+			this.registerPluginHook(plugin, "content:afterPublish");
+			this.registerPluginHook(plugin, "content:afterUnpublish");
+			this.registerPluginHook(plugin, "content:afterRestore");
+			this.registerPluginHook(plugin, "content:afterSchedule");
+			this.registerPluginHook(plugin, "content:afterUnschedule");
+			this.registerPluginHook(plugin, "media:beforeUpload");
+			this.registerPluginHook(plugin, "media:afterUpload");
+			this.registerPluginHook(plugin, "cron");
+			this.registerPluginHook(plugin, "email:beforeSend");
+			this.registerPluginHook(plugin, "email:deliver");
+			this.registerPluginHook(plugin, "email:afterSend");
+			this.registerPluginHook(plugin, "comment:beforeCreate");
+			this.registerPluginHook(plugin, "comment:moderate");
+			this.registerPluginHook(plugin, "comment:afterCreate");
+			this.registerPluginHook(plugin, "comment:afterModerate");
+			this.registerPluginHook(plugin, "page:metadata");
+			this.registerPluginHook(plugin, "page:fragments");
+		}
+		for (const [hookName, hooks] of this.hooks) this.hooks.set(hookName, this.sortHooks(hooks));
+	}
+	/**
+	* Maps hook names to the capability required to register them.
+	*
+	* Hooks not listed here have no capability requirement (e.g. lifecycle
+	* hooks, cron). Any plugin declaring a listed hook without the required
+	* capability will have that hook silently skipped at registration time.
+	*/
+	static HOOK_REQUIRED_CAPABILITY = new Map([
+		["email:beforeSend", "hooks.email-events:register"],
+		["email:afterSend", "hooks.email-events:register"],
+		["email:deliver", "hooks.email-transport:register"],
+		["content:beforeSave", "content:write"],
+		["content:afterSave", "content:read"],
+		["content:beforeDelete", "content:read"],
+		["content:afterDelete", "content:read"],
+		["content:afterPublish", "content:read"],
+		["content:afterUnpublish", "content:read"],
+		["content:afterRestore", "content:read"],
+		["content:afterSchedule", "content:read"],
+		["content:afterUnschedule", "content:read"],
+		["media:beforeUpload", "media:write"],
+		["media:afterUpload", "media:read"],
+		["comment:beforeCreate", "users:read"],
+		["comment:moderate", "users:read"],
+		["comment:afterCreate", "users:read"],
+		["comment:afterModerate", "users:read"],
+		["page:fragments", "hooks.page-fragments:register"]
+	]);
+	/**
+	* Register a single plugin's hook by name
+	*/
+	registerPluginHook(plugin, name) {
+		const hook = plugin.hooks[name];
+		if (!hook) return;
+		const requiredCapability = HookPipeline.HOOK_REQUIRED_CAPABILITY.get(name);
+		if (requiredCapability && !plugin.capabilities.includes(requiredCapability)) {
+			console.warn(`[hooks] Plugin "${plugin.id}" declares ${name} hook without ${requiredCapability} capability — skipping`);
+			return;
+		}
+		if (hook.exclusive) this.exclusiveHookNames.add(name);
+		this.registerHook(name, hook);
+	}
+	/**
+	* Register a single hook
+	*/
+	registerHook(name, hook) {
+		const existing = this.hooks.get(name) || [];
+		existing.push(hook);
+		this.hooks.set(name, existing);
+	}
+	/**
+	* Sort hooks by priority and dependencies
+	*/
+	sortHooks(hooks) {
+		const sorted = [];
+		const remaining = [...hooks];
+		while (remaining.length > 0) {
+			const ready = remaining.filter((hook) => hook.dependencies.every((dep) => sorted.some((s) => s.pluginId === dep)));
+			if (ready.length === 0) {
+				const pluginIds = remaining.map((hook) => hook.pluginId).join(", ");
+				console.warn(`[hooks] Hook dependency cycle or missing dependency detected among plugins: ${pluginIds}. Falling back to priority order.`);
+				remaining.sort((a, b) => a.priority - b.priority);
+				sorted.push(...remaining);
+				break;
+			}
+			ready.sort((a, b) => a.priority - b.priority);
+			const next = ready[0];
+			sorted.push(next);
+			remaining.splice(remaining.indexOf(next), 1);
+		}
+		return sorted;
+	}
+	/**
+	* Execute a hook with timeout
+	*/
+	async executeWithTimeout(fn, timeout) {
+		let timer;
+		const timeoutPromise = new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Hook timeout after ${timeout}ms`)), timeout);
+		});
+		try {
+			return await Promise.race([fn(), timeoutPromise]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	/**
+	* Run plugin:install hooks
+	*/
+	async runPluginInstall(pluginId) {
+		return this.runLifecycleHook("plugin:install", pluginId);
+	}
+	/**
+	* Run plugin:activate hooks
+	*/
+	async runPluginActivate(pluginId) {
+		return this.runLifecycleHook("plugin:activate", pluginId);
+	}
+	/**
+	* Run plugin:deactivate hooks
+	*/
+	async runPluginDeactivate(pluginId) {
+		return this.runLifecycleHook("plugin:deactivate", pluginId);
+	}
+	/**
+	* Run plugin:uninstall hooks
+	*/
+	async runPluginUninstall(pluginId, deleteData) {
+		const hooks = this.getTypedHooks("plugin:uninstall");
+		const results = [];
+		const hook = hooks.find((h) => h.pluginId === pluginId);
+		if (!hook) return results;
+		const { handler } = hook;
+		const event = { deleteData };
+		const ctx = this.getContext(pluginId);
+		const start = Date.now();
+		try {
+			await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+			results.push({
+				success: true,
+				pluginId: hook.pluginId,
+				duration: Date.now() - start
+			});
+		} catch (error) {
+			results.push({
+				success: false,
+				error: error instanceof Error ? error : new Error(String(error)),
+				pluginId: hook.pluginId,
+				duration: Date.now() - start
+			});
+		}
+		return results;
+	}
+	async runLifecycleHook(hookName, pluginId) {
+		const hooks = this.getTypedHooks(hookName);
+		const results = [];
+		const hook = hooks.find((h) => h.pluginId === pluginId);
+		if (!hook) return results;
+		const { handler } = hook;
+		const event = {};
+		const ctx = this.getContext(pluginId);
+		const start = Date.now();
+		try {
+			await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+			results.push({
+				success: true,
+				pluginId: hook.pluginId,
+				duration: Date.now() - start
+			});
+		} catch (error) {
+			results.push({
+				success: false,
+				error: error instanceof Error ? error : new Error(String(error)),
+				pluginId: hook.pluginId,
+				duration: Date.now() - start
+			});
+		}
+		return results;
+	}
+	/**
+	* Run content:beforeSave hooks
+	* Returns modified content from the pipeline
+	*/
+	async runContentBeforeSave(content, collection, isNew) {
+		const hooks = this.getTypedHooks("content:beforeSave");
+		const results = [];
+		let currentContent = content;
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				content: currentContent,
+				collection,
+				isNew
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				if (result !== void 0) currentContent = result;
+				results.push({
+					success: true,
+					value: currentContent,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return {
+			content: currentContent,
+			results
+		};
+	}
+	/**
+	* Run content:afterSave hooks
+	*/
+	async runContentAfterSave(content, collection, isNew, previousContent) {
+		const hooks = this.getTypedHooks("content:afterSave");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				content,
+				collection,
+				isNew,
+				...previousContent ? { previousContent } : {}
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return results;
+	}
+	/**
+	* Run content:beforeDelete hooks
+	* Returns whether deletion is allowed
+	*/
+	async runContentBeforeDelete(id, collection) {
+		const hooks = this.getTypedHooks("content:beforeDelete");
+		const results = [];
+		let allowed = true;
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				id,
+				collection,
+				permanent: false
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				if (result === false) allowed = false;
+				results.push({
+					success: true,
+					value: result !== false,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return {
+			allowed,
+			results
+		};
+	}
+	/**
+	* Run content:afterDelete hooks
+	*/
+	async runContentAfterDelete(id, collection, permanent, previousContent) {
+		const hooks = this.getTypedHooks("content:afterDelete");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				id,
+				collection,
+				permanent,
+				...previousContent ? { previousContent } : {}
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return results;
+	}
+	/**
+	* Run content:afterPublish hooks (fire-and-forget).
+	*/
+	async runContentAfterPublish(content, collection, previousContent) {
+		return this.runContentStateChangeHook("content:afterPublish", content, collection, previousContent);
+	}
+	/**
+	* Run content:afterUnpublish hooks (fire-and-forget).
+	*/
+	async runContentAfterUnpublish(content, collection, previousContent) {
+		return this.runContentStateChangeHook("content:afterUnpublish", content, collection, previousContent);
+	}
+	/**
+	* Run content:afterRestore hooks (fire-and-forget).
+	*/
+	async runContentAfterRestore(content, collection) {
+		return this.runContentStateChangeHook("content:afterRestore", content, collection);
+	}
+	/**
+	* Run content:afterSchedule hooks (fire-and-forget).
+	*/
+	async runContentAfterSchedule(content, collection) {
+		return this.runContentStateChangeHook("content:afterSchedule", content, collection);
+	}
+	/**
+	* Run content:afterUnschedule hooks (fire-and-forget).
+	*/
+	async runContentAfterUnschedule(content, collection) {
+		return this.runContentStateChangeHook("content:afterUnschedule", content, collection);
+	}
+	async runContentStateChangeHook(name, content, collection, previousContent) {
+		const hooks = this.getTypedHooks(name);
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				content,
+				collection,
+				...previousContent ? { previousContent } : {}
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return results;
+	}
+	/**
+	* Run media:beforeUpload hooks
+	*/
+	async runMediaBeforeUpload(file) {
+		const hooks = this.getTypedHooks("media:beforeUpload");
+		const results = [];
+		let currentFile = file;
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = { file: currentFile };
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				if (result !== void 0) currentFile = result;
+				results.push({
+					success: true,
+					value: currentFile,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return {
+			file: currentFile,
+			results
+		};
+	}
+	/**
+	* Run media:afterUpload hooks
+	*/
+	async runMediaAfterUpload(media) {
+		const hooks = this.getTypedHooks("media:afterUpload");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = { media };
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return results;
+	}
+	/**
+	* Invoke the cron hook for a specific plugin.
+	*
+	* Unlike other hooks which broadcast to all plugins, the cron hook is
+	* dispatched only to the target plugin — the one that owns the task.
+	*/
+	async invokeCronHook(pluginId, event) {
+		const hook = this.getTypedHooks("cron").find((h) => h.pluginId === pluginId);
+		if (!hook) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Plugin "${pluginId}" has no cron hook registered`),
+			pluginId,
+			duration: 0
+		};
+		const { handler } = hook;
+		const ctx = this.getContext(pluginId);
+		const start = Date.now();
+		try {
+			await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+			return {
+				success: true,
+				pluginId,
+				duration: Date.now() - start
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error : new Error(String(error)),
+				pluginId,
+				duration: Date.now() - start
+			};
+		}
+	}
+	/**
+	* Run email:beforeSend hooks (middleware pipeline).
+	*
+	* Each handler receives the message and returns a modified message or
+	* `false` to cancel delivery. The pipeline chains message transformations —
+	* each handler receives the output of the previous one.
+	*/
+	async runEmailBeforeSend(message, source) {
+		const hooks = this.getTypedHooks("email:beforeSend");
+		const results = [];
+		let currentMessage = message;
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				message: { ...currentMessage },
+				source
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				if (result === false) {
+					results.push({
+						success: true,
+						value: false,
+						pluginId: hook.pluginId,
+						duration: Date.now() - start
+					});
+					return {
+						message: false,
+						results
+					};
+				}
+				if (result && typeof result === "object") currentMessage = result;
+				results.push({
+					success: true,
+					value: currentMessage,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return {
+			message: currentMessage,
+			results
+		};
+	}
+	/**
+	* Run email:afterSend hooks (fire-and-forget).
+	*
+	* Errors are logged but don't propagate — they don't affect the caller.
+	*/
+	async runEmailAfterSend(message, source) {
+		const hooks = this.getTypedHooks("email:afterSend");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				message,
+				source
+			};
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			} catch (error) {
+				console.error(`[email:afterSend] Plugin "${hook.pluginId}" error:`, error instanceof Error ? error.message : error);
+				results.push({
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error)),
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+			}
+		}
+		return results;
+	}
+	/**
+	* Run comment:beforeCreate hooks (middleware pipeline).
+	*
+	* Each handler receives the event and returns a modified event or
+	* `false` to reject the comment. The pipeline chains transformations —
+	* each handler receives the output of the previous one.
+	*/
+	async runCommentBeforeCreate(event) {
+		const hooks = this.getTypedHooks("comment:beforeCreate");
+		let currentEvent = event;
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await this.executeWithTimeout(() => handler({ ...currentEvent }, ctx), hook.timeout);
+				if (result === false) return false;
+				if (result && typeof result === "object") currentEvent = result;
+			} catch (error) {
+				console.error(`[comment:beforeCreate] Plugin "${hook.pluginId}" error (${Date.now() - start}ms):`, error instanceof Error ? error.message : error);
+				if (hook.errorPolicy === "abort") throw error;
+			}
+		}
+		return currentEvent;
+	}
+	/**
+	* Run comment:afterCreate hooks (fire-and-forget).
+	*
+	* Errors are logged but don't propagate — they don't affect the caller.
+	*/
+	async runCommentAfterCreate(event) {
+		const hooks = this.getTypedHooks("comment:afterCreate");
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const ctx = this.getContext(hook.pluginId);
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+			} catch (error) {
+				console.error(`[comment:afterCreate] Plugin "${hook.pluginId}" error:`, error instanceof Error ? error.message : error);
+			}
+		}
+	}
+	/**
+	* Run comment:afterModerate hooks (fire-and-forget).
+	*
+	* Errors are logged but don't propagate — they don't affect the caller.
+	*/
+	async runCommentAfterModerate(event) {
+		const hooks = this.getTypedHooks("comment:afterModerate");
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const ctx = this.getContext(hook.pluginId);
+			try {
+				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
+			} catch (error) {
+				console.error(`[comment:afterModerate] Plugin "${hook.pluginId}" error:`, error instanceof Error ? error.message : error);
+			}
+		}
+	}
+	/**
+	* Run page:metadata hooks. Each handler returns contributions that are
+	* merged by the metadata collector. Errors are logged but don't propagate.
+	*/
+	async runPageMetadata(event) {
+		const hooks = this.getTypedHooks("page:metadata");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const ctx = this.getContext(hook.pluginId);
+			try {
+				const result = await this.executeWithTimeout(() => Promise.resolve(handler(event, ctx)), hook.timeout);
+				if (result != null) {
+					const contributions = Array.isArray(result) ? result : [result];
+					results.push({
+						pluginId: hook.pluginId,
+						contributions
+					});
+				}
+			} catch (error) {
+				console.error(`[page:metadata] Plugin "${hook.pluginId}" error:`, error instanceof Error ? error.message : error);
+			}
+		}
+		return results;
+	}
+	/**
+	* Run page:fragments hooks. Only trusted plugins should be registered
+	* for this hook. Errors are logged but don't propagate.
+	*/
+	async runPageFragments(event) {
+		const hooks = this.getTypedHooks("page:fragments");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const ctx = this.getContext(hook.pluginId);
+			try {
+				const result = await this.executeWithTimeout(() => Promise.resolve(handler(event, ctx)), hook.timeout);
+				if (result != null) {
+					const contributions = Array.isArray(result) ? result : [result];
+					results.push({
+						pluginId: hook.pluginId,
+						contributions
+					});
+				}
+			} catch (error) {
+				console.error(`[page:fragments] Plugin "${hook.pluginId}" error:`, error instanceof Error ? error.message : error);
+			}
+		}
+		return results;
+	}
+	/**
+	* Check if any hooks are registered for a given name
+	*/
+	hasHooks(name) {
+		const hooks = this.hooks.get(name);
+		return hooks !== void 0 && hooks.length > 0;
+	}
+	/**
+	* Get hook count for debugging
+	*/
+	getHookCount(name) {
+		return this.hooks.get(name)?.length || 0;
+	}
+	/**
+	* Get all registered hook names
+	*/
+	getRegisteredHooks() {
+		return [...this.hooks.keys()];
+	}
+	/**
+	* Returns hook names where at least one handler declared exclusive: true
+	*/
+	getRegisteredExclusiveHooks() {
+		return [...this.exclusiveHookNames];
+	}
+	/**
+	* Check if a hook is exclusive
+	*/
+	isExclusiveHook(name) {
+		return this.exclusiveHookNames.has(name);
+	}
+	/**
+	* Set the selected provider for an exclusive hook.
+	* Called by PluginManager after resolution.
+	*/
+	setExclusiveSelection(hookName, pluginId) {
+		this.exclusiveSelections.set(hookName, pluginId);
+	}
+	/**
+	* Clear the selected provider for an exclusive hook.
+	*/
+	clearExclusiveSelection(hookName) {
+		this.exclusiveSelections.delete(hookName);
+	}
+	/**
+	* Get the selected provider for an exclusive hook (if any).
+	*/
+	getExclusiveSelection(hookName) {
+		return this.exclusiveSelections.get(hookName);
+	}
+	/**
+	* Get all plugins that registered a handler for a given exclusive hook.
+	*/
+	getExclusiveHookProviders(hookName) {
+		return (this.hooks.get(hookName) ?? []).filter((h) => h.exclusive).map((h) => ({ pluginId: h.pluginId }));
+	}
+	/**
+	* Get all plugins that registered a non-exclusive handler for a given hook,
+	* preserving priority order. This partitions with getExclusiveHookProviders().
+	*/
+	getHookProviders(hookName) {
+		return (this.hooks.get(hookName) ?? []).filter((h) => !h.exclusive).map((h) => ({ pluginId: h.pluginId }));
+	}
+	/**
+	* Invoke an exclusive hook — dispatch only to the selected provider.
+	* Returns null if no provider is selected or if the selected hook
+	* is not found in the pipeline.
+	*
+	* This is a generic dispatch used by the email pipeline and other
+	* exclusive hook consumers. The handler type is unknown — callers
+	* must know the expected signature.
+	*
+	* Errors are isolated: a failing handler returns an error result
+	* instead of propagating the exception to the caller.
+	*/
+	async invokeExclusiveHook(hookName, event) {
+		const selectedPluginId = this.exclusiveSelections.get(hookName);
+		if (!selectedPluginId) return null;
+		const hook = (this.hooks.get(hookName) ?? []).find((h) => h.pluginId === selectedPluginId && h.exclusive);
+		if (!hook) return null;
+		const start = Date.now();
+		try {
+			const ctx = this.getContext(selectedPluginId);
+			const handler = hook.handler;
+			return {
+				result: await this.executeWithTimeout(() => handler(event, ctx), hook.timeout),
+				pluginId: selectedPluginId,
+				duration: Date.now() - start
+			};
+		} catch (error) {
+			return {
+				result: void 0,
+				pluginId: selectedPluginId,
+				error: error instanceof Error ? error : new Error(String(error)),
+				duration: Date.now() - start
+			};
+		}
+	}
+};
+/**
+* Create a hook pipeline from plugins
+*/
+function createHookPipeline(plugins, factoryOptions) {
+	return new HookPipeline(plugins, factoryOptions);
+}
+/** Options table key prefix for exclusive hook selections */
+const EXCLUSIVE_HOOK_KEY_PREFIX = "dineway:exclusive_hook:";
+/**
+* Resolve exclusive hook selections.
+*
+* Shared algorithm used by both PluginManager and DinewayRuntime:
+* 1. If a DB selection exists and that plugin is active → keep it.
+* 2. If DB selection is stale (plugin inactive/gone) → clear it.
+* 3. If no selection and only one active provider → auto-select it.
+* 4. If preferred hints match an active provider → first match wins.
+* 5. If multiple providers and no hint → leave unselected (admin must choose).
+*/
+async function resolveExclusiveHooks(opts) {
+	const { pipeline, isActive, getOption, getOptions, setOption, deleteOption, preferredHints } = opts;
+	const exclusiveHookNames = pipeline.getRegisteredExclusiveHooks();
+	if (exclusiveHookNames.length === 0) return;
+	let currentSelections;
+	if (getOptions) try {
+		currentSelections = await getOptions(exclusiveHookNames.map((hookName) => `${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`));
+	} catch {
+		return;
+	}
+	for (const hookName of exclusiveHookNames) {
+		const providers = pipeline.getExclusiveHookProviders(hookName);
+		const activeProviderIds = new Set(providers.map((p) => p.pluginId).filter((id) => isActive(id)));
+		const key = `${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`;
+		let currentSelection = null;
+		if (currentSelections) currentSelection = currentSelections.get(key) ?? null;
+		else try {
+			currentSelection = await getOption(key);
+		} catch {
+			continue;
+		}
+		if (currentSelection && activeProviderIds.has(currentSelection)) {
+			pipeline.setExclusiveSelection(hookName, currentSelection);
+			continue;
+		}
+		if (currentSelection) try {
+			await deleteOption(key);
+		} catch {}
+		if (activeProviderIds.size === 1) {
+			const [onlyProvider] = activeProviderIds;
+			try {
+				await setOption(key, onlyProvider);
+			} catch {}
+			pipeline.setExclusiveSelection(hookName, onlyProvider);
+			continue;
+		}
+		if (preferredHints) {
+			let found = false;
+			for (const [pluginId, hooks] of preferredHints) if (hooks.includes(hookName) && activeProviderIds.has(pluginId)) {
+				try {
+					await setOption(key, pluginId);
+				} catch {}
+				pipeline.setExclusiveSelection(hookName, pluginId);
+				found = true;
+				break;
+			}
+			if (found) continue;
+		}
+		pipeline.clearExclusiveSelection(hookName);
+	}
+}
+
 //#endregion
 //#region src/plugins/state.ts
 function toPluginStatus(value) {
@@ -587,6 +1559,22 @@ async function handlePluginGet(db, configuredPlugins, sandboxedPluginEntries, pl
 */
 async function handlePluginEnable(db, configuredPlugins, sandboxedPluginEntries, pluginId) {
 	try {
+		const routing = getContentStorageRuntime(db)?.config;
+		if (routing && Object.keys(routing.rules).length) {
+			const candidate = configuredPlugins.find((plugin) => plugin.id === pluginId);
+			try {
+				if (candidate) new HookPipeline([candidate], { db }).assertContentStorageHooks();
+				else if (sandboxedPluginEntries.some((plugin) => plugin.id === pluginId)) throw new Error("Sandboxed plugins are not supported with content storage routing.");
+			} catch {
+				return {
+					success: false,
+					error: {
+						code: "PLUGIN_INCOMPATIBLE",
+						message: "This plugin does not declare safe retry support for content storage routing. Update the plugin before enabling it."
+					}
+				};
+			}
+		}
 		const stateRepo = new PluginStateRepository(db);
 		const plugin = configuredPlugins.find((p) => p.id === pluginId);
 		if (plugin) return {
@@ -1360,4 +2348,4 @@ function isCollectionSlug(value) {
 }
 
 //#endregion
-export { selectActiveBriefingContextEntries as a, handlePluginGet as c, ContextRepository as d, parseSiteBriefingScope as i, handlePluginList as l, SiteBriefingError as n, handlePluginDisable as o, formatSiteBriefingText as r, handlePluginEnable as s, SiteBriefingAssembler as t, PluginStateRepository as u };
+export { selectActiveBriefingContextEntries as a, handlePluginGet as c, HookPipeline as d, createHookPipeline as f, parseSiteBriefingScope as i, handlePluginList as l, ContextRepository as m, SiteBriefingError as n, handlePluginDisable as o, resolveExclusiveHooks as p, formatSiteBriefingText as r, handlePluginEnable as s, SiteBriefingAssembler as t, PluginStateRepository as u };