emdash 0.41.0 → 0.42.0

package/dist/menus-DiuhXKWf.mjs

@@ -0,0 +1,3646 @@
+import { t as validateIdentifier } from "./validate-DANX1-Qi.mjs";
+import { t as OptionsRepository } from "./options-DhrI7eMv.mjs";
+import { n as cachedQuery, t as CacheNamespace } from "./object-cache-Bo6DGaC9.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-DBmkKmBH.mjs";
+import { r as requestCached } from "./request-cache-C4CIo5ad.mjs";
+import { i as sanitizeHref } from "./url-Dn3IStq8.mjs";
+import { t as CommentRepository } from "./comment-Cq1UYN8_.mjs";
+import { S as toBylineInfo, t as PluginContextFactory } from "./context-CtRvoSAj.mjs";
+import { a as resolveLocalizedContentRoutePath, i as resolveLocaleChain, r as resolveLocale } from "./resolve-D-kqyKns.mjs";
+import { n as inspectContentPolicyDecision } from "./content-policy-Dm32n9C6.mjs";
+import { t as menuTag } from "./chrome-tags-CKELm-bo.mjs";
+import { s as getDb } from "./loader-B_bcoE1h.mjs";
+import { a as normalizePluginCapabilities } from "./types-CsmwbOwa.mjs";
+import { a as sanitizeGalleryImages, i as resolveImageMedia } from "./apply-C1kq5l7p.mjs";
+import { r as setCronTasksEnabled } from "./cron-xe5XKqA-.mjs";
+import { t as PluginRouteRegistry } from "./routes-DTduBPzX.mjs";
+import { t as CommentReactionRepository } from "./comment-reaction-DPeGAfjd.mjs";
+import { sql } from "kysely";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "astro/zod";
+import { PLUGIN_CAPABILITIES, isJsonPostRouteContract } from "@emdash-cms/plugin-types";
+import { UnsafePortableTextTableError, portableTextTableToProseMirror, proseMirrorTableToPortableText } from "@emdash-cms/admin/portable-text-table";
+import { Extension, Mark, Node } from "@tiptap/core";
+
+//#region src/config/errors.ts
+/** A configuration failure whose message is safe to return from the API. */
+var EmDashConfigurationError = class extends Error {
+	constructor(message, code, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "EmDashConfigurationError";
+	}
+};
+
+//#endregion
+//#region src/fields/image.ts
+const mediaSchema = z.object({
+	id: z.string(),
+	src: z.string().optional(),
+	alt: z.string().optional(),
+	width: z.number().optional(),
+	height: z.number().optional(),
+	filename: z.string().optional(),
+	mimeType: z.string().optional(),
+	blurhash: z.string().optional(),
+	dominantColor: z.string().optional(),
+	focalX: z.number().optional(),
+	focalY: z.number().optional(),
+	provider: z.string().optional(),
+	previewUrl: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
+});
+const imageSchema = mediaSchema.extend({ darkVariant: mediaSchema.optional() });
+function image(options = {}) {
+	const validation = options.allowedTypes && options.allowedTypes.length > 0 ? { allowedMimeTypes: [...options.allowedTypes] } : void 0;
+	return {
+		type: "image",
+		columnType: "TEXT",
+		schema: options.required === false ? imageSchema.optional() : imageSchema,
+		options,
+		ui: { widget: "image" },
+		validation
+	};
+}
+
+//#endregion
+//#region src/fields/file.ts
+function file(options = {}) {
+	const fileObjSchema = z.object({
+		id: z.string(),
+		url: z.string().optional(),
+		src: z.string().optional(),
+		filename: z.string().optional(),
+		mimeType: z.string().optional(),
+		size: z.number().optional(),
+		provider: z.string().optional(),
+		meta: z.record(z.string(), z.unknown()).optional()
+	});
+	return {
+		type: "file",
+		columnType: "TEXT",
+		schema: options.required ? fileObjSchema : fileObjSchema.optional(),
+		options,
+		ui: {
+			widget: "file",
+			helpText: options.helpText,
+			maxSize: options.maxSize
+		},
+		validation: options.allowedTypes && options.allowedTypes.length > 0 ? { allowedMimeTypes: [...options.allowedTypes] } : void 0
+	};
+}
+
+//#endregion
+//#region src/fields/reference.ts
+/**
+* Reference field
+* References another content item by ID
+*/
+function reference(collection, options) {
+	const schema = z.string();
+	return {
+		type: "reference",
+		columnType: "TEXT",
+		schema: options?.required === false ? schema.optional() : schema,
+		options: {
+			...options,
+			collection
+		},
+		ui: { widget: "reference" }
+	};
+}
+
+//#endregion
+//#region src/fields/portable-text.ts
+/**
+* Portable Text block schema
+*/
+const portableTextBlockSchema = z.object({
+	_type: z.string(),
+	_key: z.string()
+}).loose();
+/**
+* Portable Text field
+* Stores structured content in Portable Text format
+*/
+function portableText(options) {
+	const schema = z.array(portableTextBlockSchema);
+	return {
+		type: "portableText",
+		columnType: "JSON",
+		schema: options?.required === false ? schema.optional() : schema,
+		options,
+		ui: { widget: "portableText" }
+	};
+}
+
+//#endregion
+//#region src/content/converters/mark-safety.ts
+const SUPPORTED_PORTABLE_TEXT_DECORATORS = new Set([
+	"strong",
+	"em",
+	"underline",
+	"strike-through",
+	"subscript",
+	"superscript",
+	"code"
+]);
+const SUPPORTED_PROSEMIRROR_MARKS = new Set([
+	"bold",
+	"strong",
+	"italic",
+	"em",
+	"underline",
+	"strike",
+	"strikethrough",
+	"subscript",
+	"superscript",
+	"code",
+	"link",
+	"emdashPortableTextSpan"
+]);
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectPortableTextMarks(value, inheritedMarkDefs, unsupported) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectPortableTextMarks(item, inheritedMarkDefs, unsupported);
+		return;
+	}
+	if (!isRecord$2(value)) return;
+	let markDefs = inheritedMarkDefs;
+	if (Array.isArray(value.markDefs)) {
+		const localMarkDefs = new Map(inheritedMarkDefs);
+		for (const markDef of value.markDefs) if (isRecord$2(markDef) && typeof markDef._key === "string") localMarkDefs.set(markDef._key, markDef);
+		markDefs = localMarkDefs;
+	}
+	if (value._type === "span" && Array.isArray(value.marks)) for (const mark of value.marks) {
+		if (typeof mark !== "string" || SUPPORTED_PORTABLE_TEXT_DECORATORS.has(mark)) continue;
+		const markDef = markDefs.get(mark);
+		if (markDef?._type === "link") continue;
+		unsupported.add(typeof markDef?._type === "string" ? markDef._type : mark);
+	}
+	for (const [key, child] of Object.entries(value)) if (key !== "markDefs") collectPortableTextMarks(child, markDefs, unsupported);
+}
+function collectProseMirrorMarks(node, unsupported) {
+	for (const mark of node.marks ?? []) if (!SUPPORTED_PROSEMIRROR_MARKS.has(mark.type)) unsupported.add(mark.type);
+	for (const child of node.content ?? []) collectProseMirrorMarks(child, unsupported);
+}
+var UnsupportedPortableTextMarksError = class extends Error {
+	marks;
+	constructor(marks) {
+		const sortedMarks = [...new Set(marks)].toSorted();
+		super(`Unsupported Portable Text marks: ${sortedMarks.join(", ")}`);
+		this.name = "UnsupportedPortableTextMarksError";
+		this.marks = sortedMarks;
+	}
+};
+function findUnsupportedPortableTextMarks(blocks) {
+	const unsupported = /* @__PURE__ */ new Set();
+	for (const block of blocks) if (block._type === "block" || block._type === "table") collectPortableTextMarks(block, /* @__PURE__ */ new Map(), unsupported);
+	return [...unsupported].toSorted();
+}
+function assertPortableTextMarksSupported(blocks) {
+	const unsupported = findUnsupportedPortableTextMarks(blocks);
+	if (unsupported.length > 0) throw new UnsupportedPortableTextMarksError(unsupported);
+}
+function assertProseMirrorMarksSupported(document) {
+	const unsupported = /* @__PURE__ */ new Set();
+	for (const node of document.content) collectProseMirrorMarks(node, unsupported);
+	if (unsupported.size > 0) throw new UnsupportedPortableTextMarksError(unsupported);
+}
+
+//#endregion
+//#region src/content/converters/numbered-list.ts
+const MAX_ORDERED_LIST_START = 2147483647;
+function normalizeListId(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= 128 ? normalized : void 0;
+}
+function normalizeListStart(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_ORDERED_LIST_START ? value : void 0;
+}
+function deriveLegacyListId(seed) {
+	const readable = `legacy:${seed}`;
+	if (readable.length <= 128) return readable;
+	let hash = 2166136261;
+	for (let i = 0; i < seed.length; i++) {
+		hash ^= seed.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `legacy:${seed.slice(0, 96)}:${(hash >>> 0).toString(36)}:${seed.length.toString(36)}`;
+}
+function readOrderedListMetadata(attrs, fallbackId) {
+	return {
+		listId: normalizeListId(attrs?.listId) ?? deriveLegacyListId(fallbackId),
+		listStart: normalizeListStart(attrs?.listStart) ?? normalizeListStart(attrs?.start) ?? 1
+	};
+}
+function collectProseMirrorOrderedLists(doc) {
+	const lists = [];
+	const visit = (node, path, depth, context) => {
+		if (node.type === "orderedList") lists.push({
+			node,
+			path,
+			depth,
+			context
+		});
+		for (const [index, child] of (node.content ?? []).entries()) {
+			const childPath = `${path}:${index}`;
+			visit(child, childPath, depth + 1, child.type === "listItem" ? `listItem:${childPath}` : context);
+		}
+	};
+	for (const [index, node] of doc.content.entries()) visit(node, `root:${index}`, 0, "root");
+	return lists;
+}
+function cloneProseMirrorNode(node) {
+	return {
+		...node,
+		attrs: node.attrs ? { ...node.attrs } : void 0,
+		content: node.content?.map(cloneProseMirrorNode),
+		marks: node.marks?.map((mark) => ({
+			...mark,
+			attrs: mark.attrs ? { ...mark.attrs } : void 0
+		}))
+	};
+}
+function createRepairId(sourceId, scope, attempt) {
+	const base = deriveLegacyListId(`repair:${sourceId}:${scope}`);
+	const suffix = `:${attempt.toString(36)}`;
+	return `${base.slice(0, 128 - suffix.length)}${suffix}`;
+}
+function normalizeProseMirrorOrderedListJson(doc) {
+	const normalized = {
+		...doc,
+		content: doc.content.map(cloneProseMirrorNode)
+	};
+	const canonicalBySourceScope = /* @__PURE__ */ new Map();
+	const assignedCanonicalIds = /* @__PURE__ */ new Set();
+	const lists = collectProseMirrorOrderedLists(normalized).map((list) => {
+		const sourceId = normalizeListId(list.node.attrs?.listId) ?? deriveLegacyListId(`pm-json:${list.path}:${list.depth}:${list.context}`);
+		const scope = JSON.stringify([list.depth, list.context]);
+		const sourceScope = JSON.stringify([sourceId, scope]);
+		let listId = canonicalBySourceScope.get(sourceScope);
+		if (!listId) {
+			if (!assignedCanonicalIds.has(sourceId)) listId = sourceId;
+			else {
+				let attempt = 0;
+				do
+					listId = createRepairId(sourceId, scope, attempt++);
+				while (assignedCanonicalIds.has(listId));
+			}
+			canonicalBySourceScope.set(sourceScope, listId);
+			assignedCanonicalIds.add(listId);
+		}
+		return {
+			...list,
+			listId,
+			scopeKey: JSON.stringify([
+				listId,
+				list.depth,
+				list.context
+			])
+		};
+	});
+	const bases = /* @__PURE__ */ new Map();
+	for (const list of lists) {
+		const listStart = normalizeListStart(list.node.attrs?.listStart);
+		if (listStart !== void 0 && !bases.has(list.scopeKey)) bases.set(list.scopeKey, listStart);
+	}
+	for (const list of lists) if (!bases.has(list.scopeKey)) bases.set(list.scopeKey, normalizeListStart(list.node.attrs?.start) ?? 1);
+	const counts = /* @__PURE__ */ new Map();
+	for (const list of lists) {
+		const listStart = bases.get(list.scopeKey);
+		const count = counts.get(list.scopeKey) ?? 0;
+		const start = normalizeListStart(listStart + count) ?? 1;
+		const directItemCount = list.node.content?.filter((node) => node.type === "listItem").length ?? 0;
+		counts.set(list.scopeKey, count + directItemCount);
+		list.node.attrs = {
+			...list.node.attrs,
+			listId: list.listId,
+			listStart,
+			start
+		};
+	}
+	return normalized;
+}
+
+//#endregion
+//#region src/content/converters/portable-text-identity.ts
+const PORTABLE_TEXT_BLOCK_NODE = "emdashPortableTextBlock";
+const PORTABLE_TEXT_BLOCK_ATTR = "emdashPortableTextBlock";
+const PORTABLE_TEXT_KEY_ATTR = "emdashPortableTextKey";
+const PORTABLE_TEXT_SPAN_MARK = "emdashPortableTextSpan";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function attrsWithPortableTextKey(attrs, key) {
+	return {
+		...attrs,
+		[PORTABLE_TEXT_KEY_ATTR]: key
+	};
+}
+function portableTextKeyFromAttrs(attrs) {
+	const key = attrs?.[PORTABLE_TEXT_KEY_ATTR];
+	return typeof key === "string" && key ? key : void 0;
+}
+function portableTextSpanKeyFromMarks(marks) {
+	for (const mark of marks ?? []) {
+		if (!isRecord$1(mark) || mark.type !== PORTABLE_TEXT_SPAN_MARK || !isRecord$1(mark.attrs)) continue;
+		const key = mark.attrs.key;
+		if (typeof key === "string" && key) return key;
+	}
+}
+function portableTextMarkDefsFromMarks(marks) {
+	const identity = (marks ?? []).find((mark) => isRecord$1(mark) && mark.type === PORTABLE_TEXT_SPAN_MARK && isRecord$1(mark.attrs));
+	if (!isRecord$1(identity) || !isRecord$1(identity.attrs) || !Array.isArray(identity.attrs.markDefs)) return [];
+	return identity.attrs.markDefs.filter((markDef) => isRecord$1(markDef) && typeof markDef._type === "string" && typeof markDef._key === "string");
+}
+function portableTextBlockFromAttrs(attrs) {
+	const block = attrs?.[PORTABLE_TEXT_BLOCK_ATTR];
+	if (!isRecord$1(block) || typeof block._type !== "string" || typeof block._key !== "string") return;
+	return {
+		...block,
+		_type: block._type,
+		_key: block._key
+	};
+}
+const PortableTextIdentityExtension = Extension.create({
+	name: "emdashPortableTextIdentity",
+	addGlobalAttributes() {
+		const hiddenAttribute = {
+			default: null,
+			rendered: false
+		};
+		return [{
+			types: [
+				"paragraph",
+				"heading",
+				"blockquote",
+				"codeBlock",
+				"htmlBlock",
+				"image",
+				"horizontalRule",
+				"gallery",
+				PORTABLE_TEXT_BLOCK_NODE
+			],
+			attributes: { [PORTABLE_TEXT_KEY_ATTR]: hiddenAttribute }
+		}];
+	}
+});
+const PortableTextSpanIdentity = Mark.create({
+	name: PORTABLE_TEXT_SPAN_MARK,
+	inclusive: false,
+	spanning: false,
+	addAttributes() {
+		return {
+			key: {
+				default: null,
+				rendered: false
+			},
+			markDefs: {
+				default: [],
+				rendered: false
+			}
+		};
+	},
+	parseHTML() {
+		return [];
+	},
+	renderHTML() {
+		return ["span", 0];
+	}
+});
+const PortableTextOpaqueBlock = Node.create({
+	name: PORTABLE_TEXT_BLOCK_NODE,
+	group: "block",
+	atom: true,
+	selectable: true,
+	draggable: true,
+	addAttributes() {
+		return { [PORTABLE_TEXT_BLOCK_ATTR]: {
+			default: null,
+			rendered: false
+		} };
+	},
+	parseHTML() {
+		return [{ tag: "div[data-emdash-portable-text-block]" }];
+	},
+	renderHTML({ node }) {
+		const blockType = portableTextBlockFromAttrs(node.attrs)?._type ?? "unknown";
+		return [
+			"div",
+			{
+				"data-emdash-portable-text-block": blockType,
+				contenteditable: "false"
+			},
+			`[Unknown block type: ${blockType}]`
+		];
+	}
+});
+const portableTextIdentityExtensions = [
+	PortableTextIdentityExtension,
+	PortableTextSpanIdentity,
+	PortableTextOpaqueBlock
+];
+
+//#endregion
+//#region src/content/converters/prosemirror-to-portable-text.ts
+/**
+* ProseMirror to Portable Text Converter
+*
+* Converts TipTap's ProseMirror JSON format to Portable Text for storage.
+*/
+/**
+* Generate a unique key for Portable Text blocks
+*/
+function generateKey$1() {
+	return Math.random().toString(36).substring(2, 11);
+}
+/**
+* Convert ProseMirror document to Portable Text
+*/
+function prosemirrorToPortableText(doc) {
+	if (!doc || doc.type !== "doc" || !doc.content) return [];
+	assertProseMirrorMarksSupported(doc);
+	const blocks = [];
+	const usedBlockKeys = /* @__PURE__ */ new Set();
+	for (const [i, node] of doc.content.entries()) {
+		if (i === doc.content.length - 1 && isUnkeyedEmptyParagraph(node)) continue;
+		const converted = convertNode(node, `root:${i}`);
+		for (const block of converted ? Array.isArray(converted) ? converted : [converted] : []) {
+			let key = block._key;
+			if (usedBlockKeys.has(key)) do
+				key = generateKey$1();
+			while (usedBlockKeys.has(key));
+			usedBlockKeys.add(key);
+			blocks.push(key === block._key ? block : {
+				...block,
+				_key: key
+			});
+		}
+	}
+	return blocks;
+}
+function isUnkeyedEmptyParagraph(node) {
+	return node.type === "paragraph" && (node.content?.length ?? 0) === 0 && portableTextKeyFromAttrs(node.attrs) === void 0;
+}
+/**
+* Convert a single ProseMirror node to Portable Text block(s)
+*/
+function convertNode(node, path) {
+	switch (node.type) {
+		case PORTABLE_TEXT_BLOCK_NODE: return portableTextBlockFromAttrs(node.attrs) ?? null;
+		case "paragraph": return convertParagraph(node);
+		case "heading": return convertHeading(node);
+		case "bulletList": return convertList$1(node, "bullet", path);
+		case "orderedList": return convertList$1(node, "number", path);
+		case "blockquote": return convertBlockquote(node);
+		case "codeBlock": return convertCodeBlock$1(node);
+		case "htmlBlock": return convertHtmlBlock(node);
+		case "image": return convertImage$1(node);
+		case "gallery": return convertGallery(node);
+		case "table": {
+			const result = proseMirrorTableToPortableText(node, {
+				path,
+				createKey: generateKey$1,
+				inlineToSpans: (content) => {
+					const { children, markDefs } = convertInlineContent(content, true);
+					return {
+						content: children,
+						markDefs
+					};
+				}
+			});
+			if (!result.ok) throw new UnsafePortableTextTableError(result.reason, result.raw, result.renderFallback);
+			return result.table;
+		}
+		case "horizontalRule": return {
+			_type: "break",
+			_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+			style: "lineBreak"
+		};
+		default: return {
+			_type: node.type,
+			_key: generateKey$1(),
+			...node.attrs,
+			_pmContent: node.content
+		};
+	}
+}
+/**
+* Convert paragraph to Portable Text block
+*/
+function convertParagraph(node) {
+	const { children, markDefs } = convertInlineContent(node.content || []);
+	if (children.length === 0) return null;
+	const ta = node.attrs?.textAlign;
+	const textAlign = ta === "center" || ta === "right" || ta === "justify" ? ta : void 0;
+	return {
+		_type: "block",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		style: "normal",
+		children,
+		...markDefs.length > 0 ? { markDefs } : {},
+		...textAlign ? { textAlign } : {}
+	};
+}
+/** Map heading level number to Portable Text style */
+function headingLevelToStyle(level) {
+	switch (level) {
+		case 1: return "h1";
+		case 2: return "h2";
+		case 3: return "h3";
+		case 4: return "h4";
+		case 5: return "h5";
+		case 6: return "h6";
+		default: return "h1";
+	}
+}
+/**
+* Convert heading to Portable Text block
+*/
+function convertHeading(node) {
+	const { children, markDefs } = convertInlineContent(node.content || []);
+	const style = headingLevelToStyle(typeof node.attrs?.level === "number" ? node.attrs.level : 1);
+	if (children.length === 0) return null;
+	const ta = node.attrs?.textAlign;
+	const textAlign = ta === "center" || ta === "right" || ta === "justify" ? ta : void 0;
+	return {
+		_type: "block",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		style,
+		children,
+		markDefs: markDefs.length > 0 ? markDefs : void 0,
+		...textAlign ? { textAlign } : {}
+	};
+}
+/**
+* Convert list to Portable Text blocks
+*/
+function convertList$1(node, listItem, path) {
+	const blocks = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : void 0;
+	for (const [i, item] of (node.content ?? []).entries()) if (item.type === "listItem") {
+		const itemBlocks = convertListItem$1(item, listItem, 1, `${path}:${i}`, metadata);
+		blocks.push(...itemBlocks);
+	}
+	return blocks;
+}
+/**
+* Convert list item to Portable Text blocks
+*/
+function convertListItem$1(item, listItem, level, path, metadata) {
+	const blocks = [];
+	for (const [i, child] of (item.content ?? []).entries()) if (child.type === "paragraph") {
+		const { children, markDefs } = convertInlineContent(child.content || []);
+		if (children.length > 0) blocks.push({
+			_type: "block",
+			_key: portableTextKeyFromAttrs(child.attrs) ?? generateKey$1(),
+			style: "normal",
+			listItem,
+			level,
+			...metadata,
+			children,
+			markDefs: markDefs.length > 0 ? markDefs : void 0
+		});
+	} else if (child.type === "bulletList") blocks.push(...convertListItemNested(child, "bullet", level + 1, `${path}:${i}`));
+	else if (child.type === "orderedList") blocks.push(...convertListItemNested(child, "number", level + 1, `${path}:${i}`));
+	return blocks;
+}
+/**
+* Convert nested list
+*/
+function convertListItemNested(node, listItem, level, path) {
+	const blocks = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : void 0;
+	for (const [i, item] of (node.content ?? []).entries()) if (item.type === "listItem") blocks.push(...convertListItem$1(item, listItem, level, `${path}:${i}`, metadata));
+	return blocks;
+}
+/**
+* Convert blockquote to Portable Text blocks
+*/
+function convertBlockquote(node) {
+	const blocks = [];
+	for (const child of node.content || []) if (child.type === "paragraph") {
+		const { children, markDefs } = convertInlineContent(child.content || []);
+		if (children.length > 0) blocks.push({
+			_type: "block",
+			_key: portableTextKeyFromAttrs(child.attrs) ?? portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+			style: "blockquote",
+			children,
+			markDefs: markDefs.length > 0 ? markDefs : void 0
+		});
+	}
+	return blocks.length === 1 ? blocks[0] : blocks.length > 0 ? blocks : null;
+}
+/**
+* Convert code block to Portable Text
+*/
+function convertCodeBlock$1(node) {
+	const code = node.content?.map((n) => n.text || "").join("") || "";
+	const language = typeof node.attrs?.language === "string" ? node.attrs.language : void 0;
+	return {
+		_type: "code",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		code,
+		language: language || void 0
+	};
+}
+/**
+* Convert HTML block to Portable Text
+*/
+function convertHtmlBlock(node) {
+	const rawHtml = node.attrs?.html;
+	return {
+		_type: "htmlBlock",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		html: typeof rawHtml === "string" ? rawHtml : ""
+	};
+}
+function imageDimension$1(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+/**
+* Convert image to Portable Text
+*/
+function convertImage$1(node) {
+	const attrs = node.attrs;
+	const provider = typeof attrs?.provider === "string" ? attrs.provider : void 0;
+	const mediaId = typeof attrs?.mediaId === "string" ? attrs.mediaId : void 0;
+	const src = typeof attrs?.src === "string" ? attrs.src : "";
+	const alt = typeof attrs?.alt === "string" ? attrs.alt : void 0;
+	const title = typeof attrs?.title === "string" ? attrs.title : void 0;
+	const caption = attrs && Object.hasOwn(attrs, "caption") ? typeof attrs.caption === "string" ? attrs.caption : void 0 : title;
+	const width = imageDimension$1(attrs?.width);
+	const height = imageDimension$1(attrs?.height);
+	const displayWidth = imageDimension$1(attrs?.displayWidth);
+	const displayHeight = imageDimension$1(attrs?.displayHeight);
+	const alignment = attrs?.alignment;
+	let link;
+	const rawLink = attrs?.link;
+	if (rawLink && typeof rawLink === "object") {
+		const linkObj = rawLink;
+		const href = typeof linkObj.href === "string" ? linkObj.href.trim() : "";
+		if (href) {
+			link = { href };
+			if (linkObj.blank === true) link.blank = true;
+		}
+	}
+	return {
+		_type: "image",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		asset: {
+			_ref: mediaId || src || "",
+			url: src || "",
+			provider: provider && provider !== "local" ? provider : void 0
+		},
+		alt: alt || void 0,
+		caption: caption || (title ? "" : void 0),
+		title: title || void 0,
+		width: width || void 0,
+		height: height || void 0,
+		displayWidth: displayWidth || void 0,
+		displayHeight: displayHeight || void 0,
+		alignment: alignment === "left" || alignment === "center" || alignment === "right" || alignment === "wide" || alignment === "full" ? alignment : void 0,
+		link
+	};
+}
+/**
+* Convert gallery node to Portable Text
+*/
+function convertGallery(node) {
+	const columns = node.attrs?.columns;
+	return {
+		_type: "gallery",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey$1(),
+		images: sanitizeGalleryImages(node.attrs?.images, generateKey$1),
+		...typeof columns === "number" ? { columns } : {}
+	};
+}
+/**
+* Convert inline content (text nodes with marks) to Portable Text spans
+*/
+function convertInlineContent(nodes, preserveHardBreakBoundary = false) {
+	const children = [];
+	const markDefs = [];
+	const markDefMap = /* @__PURE__ */ new Map();
+	const usedSpanKeys = /* @__PURE__ */ new Set();
+	const claimSpanKey = (preferred) => {
+		if (preferred && !usedSpanKeys.has(preferred)) {
+			usedSpanKeys.add(preferred);
+			return preferred;
+		}
+		let key;
+		do
+			key = generateKey$1();
+		while (usedSpanKeys.has(key));
+		usedSpanKeys.add(key);
+		return key;
+	};
+	for (const node of nodes) if (node.type === "text" && node.text) {
+		const marks = [];
+		const originalMarkDefs = portableTextMarkDefsFromMarks(node.marks);
+		for (const mark of node.marks || []) {
+			const markType = convertMark(mark, markDefs, markDefMap, originalMarkDefs);
+			if (markType) marks.push(markType);
+		}
+		const preferredKey = portableTextSpanKeyFromMarks(node.marks) ?? portableTextKeyFromAttrs(node.attrs);
+		const normalizedMarks = marks.length > 0 ? marks : void 0;
+		const previous = children.at(-1);
+		if (preferredKey && previous?._key === preferredKey && JSON.stringify(previous.marks) === JSON.stringify(normalizedMarks)) {
+			previous.text += node.text;
+			continue;
+		}
+		children.push({
+			_type: "span",
+			_key: claimSpanKey(preferredKey),
+			text: node.text,
+			marks: normalizedMarks
+		});
+	} else if (node.type === "hardBreak") if (children.length > 0 && !preserveHardBreakBoundary) {
+		const lastChild = children.at(-1);
+		lastChild.text += "\n";
+	} else children.push({
+		_type: "span",
+		_key: claimSpanKey(portableTextSpanKeyFromMarks(node.marks) ?? portableTextKeyFromAttrs(node.attrs)),
+		text: "\n"
+	});
+	if (children.length === 0) children.push({
+		_type: "span",
+		_key: claimSpanKey(),
+		text: ""
+	});
+	return {
+		children,
+		markDefs
+	};
+}
+/**
+* Convert a ProseMirror mark to Portable Text mark
+*/
+function convertMark(mark, markDefs, markDefMap, originalMarkDefs) {
+	switch (mark.type) {
+		case "bold":
+		case "strong": return "strong";
+		case "italic":
+		case "em": return "em";
+		case "underline": return "underline";
+		case "strike":
+		case "strikethrough": return "strike-through";
+		case "subscript": return "subscript";
+		case "superscript": return "superscript";
+		case "code": return "code";
+		case PORTABLE_TEXT_SPAN_MARK: return null;
+		case "link": {
+			const href = (typeof mark.attrs?.href === "string" ? mark.attrs.href : "") || "";
+			const blank = mark.attrs?.target === "_blank";
+			const originalMarkDef = originalMarkDefs.find((markDef) => markDef._type === "link");
+			const mapKey = originalMarkDef ? `key:${originalMarkDef._key}` : `value:${JSON.stringify([href, blank])}`;
+			if (markDefMap.has(mapKey)) return markDefMap.get(mapKey);
+			const key = originalMarkDef?._key || generateKey$1();
+			markDefs.push({
+				...originalMarkDef,
+				_type: "link",
+				_key: key,
+				href,
+				...originalMarkDef ? blank || Object.hasOwn(originalMarkDef, "blank") ? { blank } : {} : { blank }
+			});
+			markDefMap.set(mapKey, key);
+			return key;
+		}
+		default: throw new UnsupportedPortableTextMarksError([mark.type]);
+	}
+}
+
+//#endregion
+//#region src/content/converters/image-link.ts
+function normalizeImageLink(raw) {
+	if (typeof raw === "string") {
+		const href = raw.trim();
+		return href ? { href } : null;
+	}
+	if (typeof raw !== "object" || raw === null) return null;
+	const { href, blank } = raw;
+	if (typeof href !== "string") return null;
+	const trimmed = href.trim();
+	if (!trimmed) return null;
+	return blank === true ? {
+		href: trimmed,
+		blank: true
+	} : { href: trimmed };
+}
+
+//#endregion
+//#region src/content/converters/portable-text-to-prosemirror.ts
+/**
+* Portable Text to ProseMirror Converter
+*
+* Converts Portable Text to TipTap's ProseMirror JSON format for editing.
+*/
+function generateKey() {
+	return Math.random().toString(36).substring(2, 11);
+}
+/** Convert Portable Text to a ProseMirror document. */
+function portableTextToProsemirror(blocks, options = {}) {
+	if (!blocks || blocks.length === 0) return {
+		type: "doc",
+		content: [{ type: "paragraph" }]
+	};
+	assertPortableTextMarksSupported(blocks);
+	const preserveIdentity = options.preserveIdentity === true;
+	const content = [];
+	let i = 0;
+	while (i < blocks.length) {
+		const block = blocks[i];
+		if (isTextBlock(block) && block.listItem) {
+			const listBlocks = [];
+			const listType = block.listItem;
+			const runStart = i;
+			const rootId = listType === "number" ? normalizeListId(block.listId) : void 0;
+			while (i < blocks.length) {
+				const current = blocks[i];
+				if (!isTextBlock(current) || !current.listItem) break;
+				const level = current.level || 1;
+				const currentId = current.listItem === "number" ? normalizeListId(current.listId) : void 0;
+				const sameRootIdentity = listType !== "number" || level > 1 || (rootId ? currentId === rootId : currentId === void 0);
+				if (level > 1 || current.listItem === listType && sameRootIdentity) {
+					listBlocks.push(current);
+					i++;
+				} else break;
+			}
+			content.push(convertList(listBlocks, listType, `root:${runStart}`, preserveIdentity));
+		} else if (isTextBlock(block) && block.style === "blockquote") {
+			const quoteBlocks = [];
+			while (i < blocks.length) {
+				const current = blocks[i];
+				if (!isTextBlock(current) || current.style !== "blockquote" || current.listItem !== void 0) break;
+				quoteBlocks.push(current);
+				i++;
+			}
+			content.push({
+				type: "blockquote",
+				content: quoteBlocks.map((quoteBlock) => {
+					const paragraph = convertSpans(quoteBlock.children, quoteBlock.markDefs || [], preserveIdentity);
+					return {
+						type: "paragraph",
+						attrs: identityAttrs(void 0, quoteBlock._key, preserveIdentity),
+						content: paragraph.length > 0 ? paragraph : void 0
+					};
+				})
+			});
+		} else {
+			const converted = convertBlock(block, `root:${i}`, preserveIdentity);
+			if (converted) content.push(converted);
+			i++;
+		}
+	}
+	return normalizeProseMirrorOrderedListJson({
+		type: "doc",
+		content: content.length > 0 ? content : [{ type: "paragraph" }]
+	});
+}
+function identityAttrs(attrs, key, preserveIdentity) {
+	return preserveIdentity ? attrsWithPortableTextKey(attrs, key) : attrs;
+}
+function getListMetadata(item, fallbackSeed) {
+	const listId = normalizeListId(item.listId) ?? deriveLegacyListId(fallbackSeed);
+	const listStart = normalizeListStart(item.listStart);
+	return {
+		listId,
+		...listStart === void 0 ? {} : { listStart }
+	};
+}
+function belongsToNestedGroup(item, minLevel, parentListType, anchorType, anchorId) {
+	if ((item.level || 2) > minLevel) return true;
+	if ((item.listItem || parentListType) !== anchorType) return false;
+	if (anchorType !== "number") return true;
+	const itemId = normalizeListId(item.listId);
+	return anchorId ? itemId === anchorId : itemId === void 0;
+}
+/**
+* Type guard for text blocks
+*/
+function isTextBlock(block) {
+	return block._type === "block";
+}
+/**
+* Type guard for image blocks.
+* Checks both `_type` and that `asset` is a valid object — image blocks
+* without an `asset` wrapper (e.g. `{ _type: "image", url: "..." }`) are
+* malformed and should not be cast to `PortableTextImageBlock`.
+*/
+function isImageBlock(block) {
+	return block._type === "image" && "asset" in block && typeof block.asset === "object" && block.asset !== null;
+}
+/**
+* Type guard for gallery blocks that carry a usable `images` array.
+* Galleries without one are handled separately in `convertBlock`.
+*/
+function isGalleryBlock(block) {
+	return block._type === "gallery" && "images" in block && Array.isArray(block.images);
+}
+/**
+* Type guard for code blocks
+*/
+function isCodeBlock(block) {
+	return block._type === "code";
+}
+/**
+* Convert a single Portable Text block to ProseMirror node
+*/
+function convertBlock(block, path, preserveIdentity) {
+	if (isTextBlock(block)) return convertTextBlock(block, preserveIdentity);
+	if (isImageBlock(block)) return convertImage(block, preserveIdentity);
+	if (block._type === "image") return convertMalformedImage(block, preserveIdentity);
+	if (isGalleryBlock(block)) return {
+		type: "gallery",
+		attrs: identityAttrs({
+			images: sanitizeGalleryImages(block.images),
+			columns: typeof block.columns === "number" ? block.columns : void 0
+		}, block._key, preserveIdentity)
+	};
+	if (isCodeBlock(block)) return convertCodeBlock(block, preserveIdentity);
+	if (block._type === "htmlBlock") return {
+		type: "htmlBlock",
+		attrs: identityAttrs({ html: block.html || "" }, block._key, preserveIdentity)
+	};
+	if (block._type === "break") return {
+		type: "horizontalRule",
+		attrs: identityAttrs(void 0, block._key, preserveIdentity)
+	};
+	if (block._type === "gallery") {
+		if (preserveIdentity) return {
+			type: PORTABLE_TEXT_BLOCK_NODE,
+			attrs: { [PORTABLE_TEXT_BLOCK_ATTR]: block }
+		};
+		return {
+			type: "paragraph",
+			content: [{
+				type: "text",
+				text: `[Unknown block type: ${block._type}]`,
+				marks: [{ type: "code" }]
+			}]
+		};
+	}
+	if (preserveIdentity) return {
+		type: PORTABLE_TEXT_BLOCK_NODE,
+		attrs: { [PORTABLE_TEXT_BLOCK_ATTR]: block }
+	};
+	if (block._type === "table") {
+		const result = portableTextTableToProseMirror(block, {
+			path,
+			createKey: generateKey,
+			spansToInline: (content, markDefs) => convertSpans(content, markDefs, preserveIdentity)
+		});
+		if (!result.ok) throw new UnsafePortableTextTableError(result.reason, result.raw, result.renderFallback);
+		return result.node;
+	}
+	return {
+		type: "paragraph",
+		content: [{
+			type: "text",
+			text: `[Unknown block type: ${block._type}]`,
+			marks: [{ type: "code" }]
+		}]
+	};
+}
+/**
+* Convert text block to ProseMirror paragraph or heading
+*/
+function convertTextBlock(block, preserveIdentity) {
+	const { style = "normal", children, markDefs = [] } = block;
+	const content = convertSpans(children, markDefs, preserveIdentity);
+	switch (style) {
+		case "h1":
+		case "h2":
+		case "h3":
+		case "h4":
+		case "h5":
+		case "h6": return {
+			type: "heading",
+			attrs: identityAttrs({
+				level: parseInt(style.substring(1), 10),
+				...block.textAlign ? { textAlign: block.textAlign } : {}
+			}, block._key, preserveIdentity),
+			content: content.length > 0 ? content : void 0
+		};
+		case "blockquote": return {
+			type: "blockquote",
+			attrs: identityAttrs(void 0, block._key, preserveIdentity),
+			content: [{
+				type: "paragraph",
+				content: content.length > 0 ? content : void 0
+			}]
+		};
+		default: return {
+			type: "paragraph",
+			attrs: identityAttrs(block.textAlign ? { textAlign: block.textAlign } : void 0, block._key, preserveIdentity),
+			content: content.length > 0 ? content : void 0
+		};
+	}
+}
+/**
+* Convert list items to ProseMirror list
+*/
+function convertList(items, listType, context, preserveIdentity) {
+	const rootItems = [];
+	let i = 0;
+	while (i < items.length) {
+		const item = items[i];
+		if ((item.level || 1) === 1) {
+			const nestedItems = [];
+			i++;
+			while (i < items.length && (items[i].level || 1) > 1) {
+				nestedItems.push(items[i]);
+				i++;
+			}
+			rootItems.push(convertListItem(item, nestedItems, listType, `${context}:${rootItems.length}`, preserveIdentity));
+		} else {
+			rootItems.push(convertListItem(item, [], listType, `${context}:${rootItems.length}`, preserveIdentity));
+			i++;
+		}
+	}
+	const metadata = listType === "number" ? getListMetadata(items[0], `${context}:${items[0]._key}`) : void 0;
+	return {
+		type: listType === "bullet" ? "bulletList" : "orderedList",
+		attrs: metadata ? {
+			...metadata,
+			start: metadata.listStart ?? 1
+		} : void 0,
+		content: rootItems
+	};
+}
+/**
+* Convert a single list item to ProseMirror
+*/
+function convertListItem(item, nestedItems, parentListType, context, preserveIdentity) {
+	const content = [];
+	const spans = convertSpans(item.children, item.markDefs || [], preserveIdentity);
+	content.push({
+		type: "paragraph",
+		attrs: identityAttrs(void 0, item._key, preserveIdentity),
+		content: spans.length > 0 ? spans : void 0
+	});
+	if (nestedItems.length > 0) {
+		let minLevel = Infinity;
+		for (const ni of nestedItems) {
+			const level = ni.level || 2;
+			if (level < minLevel) minLevel = level;
+		}
+		let j = 0;
+		while (j < nestedItems.length) {
+			const anchorType = nestedItems[j].listItem || parentListType;
+			const anchorId = anchorType === "number" ? normalizeListId(nestedItems[j].listId) : void 0;
+			const nestedGroup = [];
+			do {
+				nestedGroup.push(nestedItems[j]);
+				j++;
+			} while (j < nestedItems.length && belongsToNestedGroup(nestedItems[j], minLevel, parentListType, anchorType, anchorId));
+			if (nestedGroup.length > 0) {
+				const adjustedGroup = nestedGroup.map((ni) => ({
+					...ni,
+					level: (ni.level || 2) - 1
+				}));
+				content.push(convertList(adjustedGroup, anchorType, `${context}:nested:${j - nestedGroup.length}`, preserveIdentity));
+			}
+		}
+	}
+	return {
+		type: "listItem",
+		content
+	};
+}
+/**
+* Convert Portable Text spans to ProseMirror text nodes
+*/
+function convertSpans(spans, markDefs, preserveIdentity) {
+	const nodes = [];
+	const markDefsMap = new Map(markDefs.map((md) => [md._key, md]));
+	for (const span of spans) {
+		if (span._type !== "span") continue;
+		const referencedMarkDefs = markDefs.filter((markDef) => span.marks?.includes(markDef._key));
+		const parts = span.text.split("\n");
+		for (let i = 0; i < parts.length; i++) {
+			const text = parts[i];
+			if (text.length > 0) {
+				const marks = convertMarks(span.marks || [], markDefsMap);
+				if (preserveIdentity) marks.push({
+					type: PORTABLE_TEXT_SPAN_MARK,
+					attrs: {
+						key: span._key,
+						markDefs: referencedMarkDefs
+					}
+				});
+				const node = {
+					type: "text",
+					text
+				};
+				if (marks.length > 0) node.marks = marks;
+				nodes.push(node);
+			}
+			if (i < parts.length - 1) nodes.push(preserveIdentity ? {
+				type: "hardBreak",
+				marks: [{
+					type: PORTABLE_TEXT_SPAN_MARK,
+					attrs: {
+						key: span._key,
+						markDefs: referencedMarkDefs
+					}
+				}]
+			} : { type: "hardBreak" });
+		}
+	}
+	return nodes;
+}
+/**
+* Convert Portable Text marks to ProseMirror marks
+*/
+function convertMarks(marks, markDefs) {
+	const pmMarks = [];
+	for (const mark of marks) switch (mark) {
+		case "strong":
+			pmMarks.push({ type: "bold" });
+			break;
+		case "em":
+			pmMarks.push({ type: "italic" });
+			break;
+		case "underline":
+			pmMarks.push({ type: "underline" });
+			break;
+		case "strike-through":
+			pmMarks.push({ type: "strike" });
+			break;
+		case "subscript":
+			pmMarks.push({ type: "subscript" });
+			break;
+		case "superscript":
+			pmMarks.push({ type: "superscript" });
+			break;
+		case "code":
+			pmMarks.push({ type: "code" });
+			break;
+		default: {
+			const markDef = markDefs.get(mark);
+			if (markDef?._type === "link") pmMarks.push({
+				type: "link",
+				attrs: {
+					href: markDef.href,
+					target: markDef.blank ? "_blank" : null
+				}
+			});
+			else throw new UnsupportedPortableTextMarksError([typeof markDef?._type === "string" ? markDef._type : mark]);
+			break;
+		}
+	}
+	return pmMarks;
+}
+function imageAlignment(value) {
+	return value === "left" || value === "center" || value === "right" || value === "wide" || value === "full" ? value : void 0;
+}
+function imageDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+/**
+* Convert image block to ProseMirror
+*/
+function convertImage(block, preserveIdentity) {
+	const { asset, alt, width, height } = resolveImageMedia(block);
+	return {
+		type: "image",
+		attrs: identityAttrs({
+			src: asset.url || asset._ref,
+			alt: alt || "",
+			title: block.title || "",
+			caption: Object.hasOwn(block, "caption") ? block.caption || "" : block.title || "",
+			mediaId: asset._ref,
+			provider: asset.provider,
+			width: imageDimension(width),
+			height: imageDimension(height),
+			displayWidth: imageDimension(block.displayWidth),
+			displayHeight: imageDimension(block.displayHeight),
+			alignment: imageAlignment(block.alignment),
+			link: normalizeImageLink(block.link)
+		}, block._key, preserveIdentity)
+	};
+}
+/**
+* Convert a malformed image block (missing `asset` wrapper) to ProseMirror.
+* Handles blocks like `{ _type: "image", url: "...", alt: "..." }` that may
+* originate from migrations or third-party imports.
+*/
+function convertMalformedImage(block, preserveIdentity) {
+	const url = "url" in block && typeof block.url === "string" ? block.url : "";
+	const alt = "alt" in block && typeof block.alt === "string" ? block.alt : "";
+	const title = "title" in block && typeof block.title === "string" ? block.title : "";
+	const rawCaption = "caption" in block ? block.caption : void 0;
+	return {
+		type: "image",
+		attrs: identityAttrs({
+			src: url,
+			alt,
+			title,
+			caption: Object.hasOwn(block, "caption") ? typeof rawCaption === "string" ? rawCaption : "" : title,
+			mediaId: void 0,
+			provider: void 0,
+			width: imageDimension("width" in block ? block.width : void 0),
+			height: imageDimension("height" in block ? block.height : void 0),
+			displayWidth: imageDimension("displayWidth" in block ? block.displayWidth : void 0),
+			displayHeight: imageDimension("displayHeight" in block ? block.displayHeight : void 0),
+			alignment: imageAlignment("alignment" in block ? block.alignment : void 0)
+		}, block._key, preserveIdentity)
+	};
+}
+/**
+* Convert code block to ProseMirror
+*/
+function convertCodeBlock(block, preserveIdentity) {
+	return {
+		type: "codeBlock",
+		attrs: identityAttrs({ language: block.language || null }, block._key, preserveIdentity),
+		content: block.code ? [{
+			type: "text",
+			text: block.code
+		}] : void 0
+	};
+}
+
+//#endregion
+//#region src/plugins/define-plugin.ts
+/**
+* definePlugin() Helper
+*
+* Native plugin authoring entry. Returns a fully-resolved
+* `ResolvedPlugin` ready for the host integration to mount.
+*
+* Sandboxed plugins do NOT use this function. They default-export
+* a bare `{ hooks?, routes? }` object with a `satisfies SandboxedPlugin`
+* annotation from `emdash/plugin`. See the `emdash` changeset for the
+* authoring shape.
+*/
+const MCP_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+/**
+* Define a native EmDash plugin.
+*
+* Native plugins ship as regular npm modules, get installed via
+* `pnpm add` + an `astro.config.mjs` edit, and run in the host
+* process. They have full access to the runtime — capabilities are
+* still enforced by `PluginContextFactory`, but there is no isolation
+* boundary.
+*
+* @example
+* ```typescript
+* import { definePlugin } from "emdash";
+*
+* export default definePlugin({
+*   id: "my-plugin",
+*   version: "1.0.0",
+*   capabilities: ["content:read"],
+*   hooks: {
+*     "content:beforeSave": async (event, ctx) => {
+*       ctx.log.info("Saving content", { collection: event.collection });
+*       return event.content;
+*     }
+*   },
+*   routes: {
+*     "sync": {
+*       handler: async (ctx) => {
+*         return { status: "ok" };
+*       }
+*     }
+*   }
+* });
+* ```
+*
+* Sandboxed-format plugins do not use `definePlugin`. They
+* default-export a bare `{ hooks?, routes? }` object with a
+* `satisfies SandboxedPlugin` annotation from `emdash/plugin`. Calling
+* `definePlugin` with an object that has no `id` throws at runtime
+* (the type system already rejects it at compile time — this check is
+* for callers that bypass typechecking). Passing a plugin descriptor
+* (an object with an `entrypoint`) also throws.
+*/
+function definePlugin(definition) {
+	if (typeof definition.id !== "string" || definition.id.length === 0) throw new Error(`definePlugin() requires \`id\` (got ${typeof definition.id}). For native plugins, make sure your definition has both \`id\` and \`version\`. For sandboxed plugins, drop \`definePlugin()\` entirely and \`export default { hooks, routes } satisfies SandboxedPlugin\` from "emdash/plugin" — identity comes from \`emdash-plugin.jsonc\`.`);
+	if ("entrypoint" in definition) throw new Error(`definePlugin() received a plugin descriptor for "${definition.id}" (it has an \`entrypoint\`). Pass the descriptor directly to the \`plugins\` array of the emdash() integration instead of wrapping it in definePlugin().`);
+	return defineNativePlugin(definition);
+}
+function definePluginRoute(route) {
+	return route;
+}
+/**
+* Internal: define a native-format plugin with full validation and normalization.
+*/
+function defineNativePlugin(definition) {
+	const SIMPLE_ID = /^[a-z0-9-]+$/;
+	const SCOPED_ID = /^@[a-z0-9-]+\/[a-z0-9-]+$/;
+	const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
+	const { id, version, capabilities = [], allowedHosts = [], hooks = {}, routes = {}, mcp = { tools: {} }, admin = {} } = definition;
+	const storage = definition.storage ?? {};
+	if (!SIMPLE_ID.test(id) && !SCOPED_ID.test(id)) throw new Error(`Invalid plugin id "${id}". Must be lowercase alphanumeric with dashes (e.g., "my-plugin" or "@scope/my-plugin").`);
+	if (!SEMVER_PATTERN.test(version)) throw new Error(`Invalid plugin version "${version}". Must be semver format (e.g., "1.0.0").`);
+	for (const [name, tool] of Object.entries(mcp.tools)) {
+		if (!MCP_TOOL_NAME_PATTERN.test(name)) throw new Error(`Invalid MCP tool name "${name}" in plugin "${id}".`);
+		const route = routes[tool.route];
+		if (!route) throw new Error(`MCP tool "${name}" references unknown route "${tool.route}".`);
+		if (route.public) throw new Error(`MCP tool "${name}" cannot reference a public route.`);
+		if (route.response === "raw") throw new Error(`MCP tool "${name}" cannot reference a raw response route.`);
+		if (!isJsonPostRouteContract(route)) throw new Error(`MCP tool "${name}" must reference a POST-compatible JSON route.`);
+		if (!route.permission) throw new Error(`MCP route "${tool.route}" must declare a permission.`);
+	}
+	for (const [kind, extensions] of [["editor panel", admin.editorPanels], ["editor action", admin.editorActions]]) for (const extension of extensions ?? []) {
+		const route = routes[extension.route];
+		if (!route) throw new Error(`Plugin ${kind} "${extension.id}" references unknown route "${extension.route}".`);
+		if (route.public) throw new Error(`Plugin ${kind} "${extension.id}" must reference a private route.`);
+		if (!isJsonPostRouteContract(route)) throw new Error(`Plugin ${kind} "${extension.id}" must reference a route that accepts POST JSON requests and returns JSON.`);
+	}
+	if ((admin.pages?.length ?? 0) > 0 || (admin.widgets?.length ?? 0) > 0) {
+		const adminRoute = routes.admin;
+		if (adminRoute && (adminRoute.public === true || !isJsonPostRouteContract(adminRoute))) throw new Error("Block Kit admin route must accept POST JSON requests and return JSON.");
+	}
+	const validCapabilities = new Set(PLUGIN_CAPABILITIES);
+	for (const cap of capabilities) if (!validCapabilities.has(cap)) throw new Error(`Invalid capability "${cap}" in plugin "${id}".`);
+	return {
+		id,
+		version,
+		capabilities: normalizePluginCapabilities(capabilities),
+		allowedHosts,
+		storage,
+		hooks: resolveHooks(hooks, id),
+		routes,
+		mcp,
+		admin
+	};
+}
+/**
+* Resolve hooks to normalized format with defaults.
+*
+* PluginHooks and ResolvedPluginHooks share the same keys — each input value is
+* `HookConfig<H> | H` and the output is `ResolvedHook<H>`.  TS can't narrow
+* the handler type through a dynamic key, so we assert at the loop boundary.
+*/
+function resolveHooks(hooks, pluginId) {
+	const resolved = {};
+	for (const key of Object.keys(hooks)) {
+		const hook = hooks[key];
+		if (hook) resolved[key] = resolveHook(hook, pluginId);
+	}
+	return resolved;
+}
+/**
+* Check if a hook value is a config object (has a `handler` property)
+*/
+function isHookConfig(hook) {
+	return typeof hook === "object" && hook !== null && "handler" in hook;
+}
+/**
+* Resolve a single hook to normalized format
+*/
+function resolveHook(hook, pluginId) {
+	if (isHookConfig(hook)) {
+		if (hook.exclusive !== void 0 && typeof hook.exclusive !== "boolean") throw new Error(`Invalid "exclusive" value in hook config for plugin "${pluginId}". Must be boolean.`);
+		return {
+			priority: hook.priority ?? 100,
+			timeout: hook.timeout ?? 5e3,
+			dependencies: hook.dependencies ?? [],
+			errorPolicy: hook.errorPolicy ?? "abort",
+			exclusive: hook.exclusive ?? false,
+			handler: hook.handler,
+			pluginId
+		};
+	}
+	return {
+		priority: 100,
+		timeout: 5e3,
+		dependencies: [],
+		errorPolicy: "abort",
+		exclusive: false,
+		handler: hook,
+		pluginId
+	};
+}
+
+//#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
+*
+*/
+const CONTENT_SAVE_HOOK_CONTEXT_KEY = Symbol.for("emdash:content-save-hook-context");
+const contentSaveHookContext = globalThis[CONTENT_SAVE_HOOK_CONTEXT_KEY] ?? new AsyncLocalStorage();
+globalThis[CONTENT_SAVE_HOOK_CONTEXT_KEY] = contentSaveHookContext;
+function getActiveContentSaveHookName() {
+	return contentSaveHookContext.getStore();
+}
+/**
+* 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;
+	}
+	/**
+	* 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:beforePublish");
+			this.registerPluginHook(plugin, "content:beforeSchedule");
+			this.registerPluginHook(plugin, "content:beforeUnpublish");
+			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, "byline:afterSave");
+			this.registerPluginHook(plugin, "byline:afterDelete");
+			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:beforePublish", "hooks.content-policy:register"],
+		["content:beforeSchedule", "hooks.content-policy:register"],
+		["content:beforeUnpublish", "hooks.content-policy:register"],
+		["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"],
+		["byline:afterSave", "bylines:read"],
+		["byline:afterDelete", "bylines: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((h) => h.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 {
+			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. `id` is the existing item's
+	* ID when updating. `actor` is the authenticated user that triggered the
+	* save, when one is available.
+	*/
+	async runContentBeforeSave(content, collection, isNew, id, actor) {
+		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
+			};
+			if (id !== void 0) event.id = id;
+			if (actor !== void 0) event.actor = { ...actor };
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const result = await contentSaveHookContext.run("content:beforeSave", () => 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, actor, excludePluginId) {
+		const hooks = this.getTypedHooks("content:afterSave");
+		const results = [];
+		for (const hook of hooks) {
+			if (hook.pluginId === excludePluginId) continue;
+			const { handler } = hook;
+			const event = {
+				content,
+				collection,
+				isNew
+			};
+			if (actor !== void 0) event.actor = { ...actor };
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				await contentSaveHookContext.run("content:afterSave", () => 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) {
+		const hooks = this.getTypedHooks("content:afterDelete");
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				id,
+				collection,
+				permanent
+			};
+			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;
+	}
+	async runContentPolicy(name, event) {
+		if (name === "content:beforeSchedule") {
+			if (!("scheduledAt" in event)) throw new Error("content:beforeSchedule requires scheduledAt");
+			return this.runContentPolicyHooks(name, this.getTypedHooks(name), event);
+		}
+		return this.runContentPolicyHooks(name, this.getTypedHooks(name), event);
+	}
+	async runContentPolicyHooks(name, hooks, event) {
+		const results = [];
+		for (const hook of hooks) {
+			const ctx = this.getContext(hook.pluginId);
+			const start = Date.now();
+			try {
+				const decision = inspectContentPolicyDecision(await this.executeWithTimeout(() => hook.handler(event, ctx), hook.timeout));
+				if (decision.kind === "invalid") throw new Error(`Plugin "${hook.pluginId}" returned an invalid ${name} decision`);
+				results.push({
+					success: true,
+					pluginId: hook.pluginId,
+					duration: Date.now() - start
+				});
+				if (decision.kind === "cancel") return {
+					cancellation: {
+						pluginId: hook.pluginId,
+						reason: decision.reason
+					},
+					results
+				};
+			} 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;
+				console.error(`[content-policy] Plugin "${hook.pluginId}" failed ${name}; continuing by policy`);
+			}
+		}
+		return { results };
+	}
+	/**
+	* Run content state-change hooks that all share the same event shape.
+	*/
+	async runContentStateChangeHook(name, content, collection) {
+		const hooks = this.getTypedHooks(name);
+		const results = [];
+		for (const hook of hooks) {
+			const { handler } = hook;
+			const event = {
+				content,
+				collection
+			};
+			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) {
+		return this.runContentStateChangeHook("content:afterPublish", content, collection);
+	}
+	/**
+	* Run content:afterUnpublish hooks (fire-and-forget).
+	*/
+	async runContentAfterUnpublish(content, collection) {
+		return this.runContentStateChangeHook("content:afterUnpublish", content, collection);
+	}
+	/**
+	* 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);
+	}
+	/**
+	* 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 byline:afterSave hooks. Errors are logged and never propagate. */
+	async runBylineAfterSave(byline, isNew) {
+		const event = {
+			byline: toBylineInfo(byline),
+			isNew
+		};
+		for (const hook of this.getTypedHooks("byline:afterSave")) await this.runLoggedHook("byline:afterSave", hook, (ctx) => hook.handler(event, ctx));
+	}
+	/** Run byline:afterDelete hooks. Errors are logged and never propagate. */
+	async runBylineAfterDelete(byline) {
+		const event = { byline: toBylineInfo(byline) };
+		for (const hook of this.getTypedHooks("byline:afterDelete")) await this.runLoggedHook("byline:afterDelete", hook, (ctx) => hook.handler(event, ctx));
+	}
+	async runLoggedHook(name, hook, run) {
+		try {
+			await this.executeWithTimeout(() => run(this.getContext(hook.pluginId)), hook.timeout);
+		} catch (error) {
+			console.error(`[${name}] 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 (e.g. `email:beforeSend`, `email:afterSend`), preserving priority
+	* order. Partitions with `getExclusiveHookProviders()`, which returns
+	* plugins whose registration is marked `exclusive: true`.
+	*/
+	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$1 = "emdash:exclusive_hook:";
+/**
+* Resolve exclusive hook selections.
+*
+* Shared algorithm used by both PluginManager and EmDashRuntime:
+* 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. Fallback
+*    providers are not counted when another provider is active, so a single
+*    plugin provider is selected over a built-in fallback. A fallback
+*    selection is kept in memory only.
+* 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, fallbackProviders } = opts;
+	const exclusiveHookNames = pipeline.getRegisteredExclusiveHooks();
+	if (exclusiveHookNames.length === 0) return;
+	let batchedSelections;
+	if (getOptions) try {
+		batchedSelections = await getOptions(exclusiveHookNames.map((hookName) => `${EXCLUSIVE_HOOK_KEY_PREFIX$1}${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$1}${hookName}`;
+		let currentSelection = null;
+		if (batchedSelections) currentSelection = batchedSelections.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 {}
+		const candidates = activeProviderIds.size > 1 && fallbackProviders ? [...activeProviderIds].filter((id) => !fallbackProviders.has(id)) : [...activeProviderIds];
+		if (candidates.length === 1) {
+			const [onlyProvider] = candidates;
+			if (!fallbackProviders?.has(onlyProvider)) 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/save-rejection.ts
+/**
+* Thrown by a `content:beforeSave` hook to reject a save with a message
+* that is safe to show to the editor. The runtime converts it into a
+* structured `SAVE_REJECTED` API error; any other exception thrown by the
+* hook cancels the save with a generic error that hides the exception
+* message.
+*/
+var ContentSaveRejectedError = class extends Error {
+	name = "ContentSaveRejectedError";
+};
+/**
+* Matches by name as well as by prototype: bundlers can duplicate this
+* module across SSR chunks, and an `instanceof` against the wrong copy of
+* the class would misreport a rejection as a plugin crash.
+*/
+function isContentSaveRejection(error) {
+	if (error instanceof ContentSaveRejectedError) return true;
+	return error instanceof Error && error.name === "ContentSaveRejectedError";
+}
+
+//#endregion
+//#region src/plugins/email.ts
+/**
+* Email Pipeline
+*
+* Orchestrates the three-stage email pipeline:
+* 1. email:beforeSend hooks (middleware — transform, validate, cancel)
+* 2. email:deliver hook (exclusive — exactly one provider delivers)
+* 3. email:afterSend hooks (logging, analytics, fire-and-forget)
+*
+* Security features:
+* - Recursion guard prevents re-entrant sends (e.g. plugin calling ctx.email.send from a hook)
+* - System emails (source="system") bypass email:beforeSend and email:afterSend hooks entirely
+*   to protect auth tokens from exfiltration by plugin hooks
+*
+*/
+/** Hook name for the exclusive email delivery hook */
+const EMAIL_DELIVER_HOOK = "email:deliver";
+/** Source value used for auth emails (magic links, invites, password resets) */
+const SYSTEM_SOURCE = "system";
+/**
+* Error thrown when ctx.email.send() is called but no provider is configured.
+*/
+var EmailNotConfiguredError = class extends Error {
+	constructor() {
+		super("No email provider is configured. Install and activate an email provider plugin, then select it in Settings > Email.");
+		this.name = "EmailNotConfiguredError";
+	}
+};
+/**
+* Error thrown when a recursive email send is detected.
+*/
+var EmailRecursionError = class extends Error {
+	constructor() {
+		super("Recursive email send detected. A plugin hook attempted to send an email from within the email pipeline, which would cause infinite recursion.");
+		this.name = "EmailRecursionError";
+	}
+};
+/**
+* Recursion guard using AsyncLocalStorage.
+*
+* EmailPipeline is a singleton (worker-lifetime cached via EmDashRuntime).
+* Instance state like `sendDepth` would false-positive under concurrent
+* requests because two unrelated sends would increment the same counter.
+* ALS scopes the guard to the current async execution context, so concurrent
+* requests each get their own independent recursion tracking.
+*/
+const emailSendALS = new AsyncLocalStorage();
+/**
+* EmailPipeline orchestrates email delivery through the plugin hook system.
+*
+* The pipeline runs in three stages:
+* 1. email:beforeSend — middleware hooks that can transform or cancel messages
+* 2. email:deliver — exclusive hook dispatching to the selected provider
+* 3. email:afterSend — fire-and-forget hooks for logging/analytics
+*/
+var EmailPipeline = class {
+	pipeline;
+	constructor(pipeline) {
+		this.pipeline = pipeline;
+	}
+	/**
+	* Replace the underlying hook pipeline.
+	*
+	* Called by the runtime when rebuilding the hook pipeline after a
+	* plugin is enabled or disabled, so the email pipeline dispatches
+	* to the current set of active hooks.
+	*/
+	setPipeline(pipeline) {
+		this.pipeline = pipeline;
+	}
+	/**
+	* Send an email through the full pipeline.
+	*
+	* @param message - The email to send
+	* @param source - Where the email originated ("system" for auth, plugin ID for plugins)
+	* @throws EmailNotConfiguredError if no provider is selected
+	* @throws EmailRecursionError if called re-entrantly from within a hook
+	* @throws Error if the provider handler throws
+	*/
+	async send(message, source) {
+		const store = emailSendALS.getStore();
+		if (store && store.depth > 0) throw new EmailRecursionError();
+		const run = () => this.sendInner(message, source);
+		if (store) {
+			store.depth++;
+			try {
+				await run();
+			} finally {
+				store.depth--;
+			}
+		} else await emailSendALS.run({ depth: 1 }, run);
+	}
+	/**
+	* Inner send implementation, separated from the recursion guard.
+	*/
+	async sendInner(message, source) {
+		if (!message || typeof message !== "object") throw new Error("Invalid email message: message must be an object");
+		if (!message.to || typeof message.to !== "string") throw new Error("Invalid email message: 'to' is required and must be a string");
+		if (message.cc !== void 0 && (!Array.isArray(message.cc) || message.cc.some((address) => typeof address !== "string"))) throw new Error("Invalid email message: 'cc' must be an array of strings");
+		if (message.replyTo !== void 0 && typeof message.replyTo !== "string") throw new Error("Invalid email message: 'replyTo' must be a string");
+		if (!message.subject || typeof message.subject !== "string") throw new Error("Invalid email message: 'subject' is required and must be a string");
+		if (!message.text || typeof message.text !== "string") throw new Error("Invalid email message: 'text' is required and must be a string");
+		const isSystemEmail = source === SYSTEM_SOURCE;
+		let finalMessage;
+		if (isSystemEmail) finalMessage = message;
+		else {
+			const beforeResult = await this.pipeline.runEmailBeforeSend(message, source);
+			if (beforeResult.message === false) {
+				const cancelledBy = beforeResult.results.find((r) => r.value === false)?.pluginId ?? "unknown";
+				console.info(`[email] Email to "${message.to}" cancelled by plugin "${cancelledBy}"`);
+				return;
+			}
+			finalMessage = beforeResult.message;
+		}
+		const deliverEvent = {
+			message: finalMessage,
+			source
+		};
+		const deliverResult = await this.pipeline.invokeExclusiveHook(EMAIL_DELIVER_HOOK, deliverEvent);
+		if (!deliverResult) throw new EmailNotConfiguredError();
+		if (deliverResult.error) {
+			console.error(`[email:deliver] Provider "${deliverResult.pluginId}" failed to send email to "${finalMessage.to}":`, deliverResult.error);
+			throw deliverResult.error;
+		}
+		if (!isSystemEmail) this.pipeline.runEmailAfterSend(finalMessage, source).catch((err) => console.error("[email] afterSend pipeline error:", err instanceof Error ? err.message : err));
+	}
+	/**
+	* Check if an email provider is configured and available.
+	*
+	* Returns true if an email:deliver provider is selected in the exclusive
+	* hook system. Plugins and auth code use this to decide whether to show
+	* "send invite" vs "copy invite link" UI.
+	*/
+	isAvailable() {
+		return this.pipeline.getExclusiveSelection(EMAIL_DELIVER_HOOK) !== void 0;
+	}
+};
+
+//#endregion
+//#region src/plugins/manager.ts
+/** Options table key prefix for exclusive hook DB reads via PluginManager */
+const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
+/**
+* Plugin Manager v2
+*
+* Manages the full lifecycle of plugins and coordinates hooks/routes.
+*/
+var PluginManager = class {
+	plugins = /* @__PURE__ */ new Map();
+	hookPipeline = null;
+	routeRegistry = null;
+	factoryOptions;
+	initialized = false;
+	constructor(options) {
+		this.options = options;
+		this.factoryOptions = {
+			db: options.db,
+			storage: options.storage,
+			getUploadUrl: options.getUploadUrl,
+			trustedProxyHeaders: options.trustedProxyHeaders
+		};
+	}
+	/**
+	* Set the email pipeline used when creating plugin contexts.
+	* Reinitializes routes/hooks if already initialized so ctx.email is available immediately.
+	*/
+	setEmailPipeline(pipeline) {
+		this.factoryOptions.emailPipeline = pipeline;
+		if (this.initialized) this.reinitialize();
+	}
+	/**
+	* Register a plugin definition
+	* This resolves the definition and adds it to the manager, but doesn't install it
+	*/
+	register(definition) {
+		const resolved = definePlugin(definition);
+		if (this.plugins.has(resolved.id)) throw new Error(`Plugin "${resolved.id}" is already registered`);
+		this.plugins.set(resolved.id, {
+			plugin: resolved,
+			state: "registered"
+		});
+		this.initialized = false;
+		return resolved;
+	}
+	/**
+	* Register multiple plugins
+	*/
+	registerAll(definitions) {
+		for (const def of definitions) this.register(def);
+	}
+	/**
+	* Unregister a plugin
+	* Plugin must be inactive or just registered
+	*/
+	unregister(pluginId) {
+		const entry = this.plugins.get(pluginId);
+		if (!entry) return false;
+		if (entry.state === "active") throw new Error(`Cannot unregister active plugin "${pluginId}". Deactivate it first.`);
+		this.plugins.delete(pluginId);
+		this.initialized = false;
+		return true;
+	}
+	/**
+	* Install a plugin (run install hooks, set up storage)
+	*/
+	async install(pluginId) {
+		const entry = this.plugins.get(pluginId);
+		if (!entry) throw new Error(`Plugin "${pluginId}" not found`);
+		if (entry.state !== "registered") throw new Error(`Plugin "${pluginId}" is already installed (state: ${entry.state})`);
+		this.ensureInitialized();
+		const results = await this.hookPipeline.runPluginInstall(pluginId);
+		const failed = results.find((r) => !r.success);
+		if (failed) throw new Error(`Plugin install failed: ${failed.error?.message ?? "Unknown error"}`);
+		entry.state = "installed";
+		return results;
+	}
+	/**
+	* Activate a plugin (run activate hooks, enable hooks/routes)
+	*/
+	async activate(pluginId) {
+		const entry = this.plugins.get(pluginId);
+		if (!entry) throw new Error(`Plugin "${pluginId}" not found`);
+		if (entry.state === "active") return [];
+		if (entry.state === "registered") await this.install(pluginId);
+		this.ensureInitialized();
+		const results = await this.hookPipeline.runPluginActivate(pluginId);
+		const failed = results.find((r) => !r.success);
+		if (failed) throw new Error(`Plugin activation failed: ${failed.error?.message ?? "Unknown error"}`);
+		entry.state = "active";
+		await setCronTasksEnabled(this.options.db, pluginId, true);
+		this.reinitialize();
+		await this.resolveExclusiveHooks();
+		return results;
+	}
+	/**
+	* Deactivate a plugin (run deactivate hooks, disable hooks/routes)
+	*/
+	async deactivate(pluginId) {
+		const entry = this.plugins.get(pluginId);
+		if (!entry) throw new Error(`Plugin "${pluginId}" not found`);
+		if (entry.state !== "active") return [];
+		this.ensureInitialized();
+		const results = await this.hookPipeline.runPluginDeactivate(pluginId);
+		await setCronTasksEnabled(this.options.db, pluginId, false);
+		entry.state = "inactive";
+		this.reinitialize();
+		await this.resolveExclusiveHooks();
+		return results;
+	}
+	/**
+	* Uninstall a plugin (run uninstall hooks, optionally delete data)
+	*/
+	async uninstall(pluginId, deleteData = false) {
+		const entry = this.plugins.get(pluginId);
+		if (!entry) throw new Error(`Plugin "${pluginId}" not found`);
+		if (entry.state === "active") await this.deactivate(pluginId);
+		this.ensureInitialized();
+		const results = await this.hookPipeline.runPluginUninstall(pluginId, deleteData);
+		await this.deleteCronTasks(pluginId);
+		this.plugins.delete(pluginId);
+		this.initialized = false;
+		await this.resolveExclusiveHooks();
+		return results;
+	}
+	/**
+	* Run content:beforeSave hooks across all active plugins
+	*/
+	async runContentBeforeSave(content, collection, isNew, id, actor) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentBeforeSave(content, collection, isNew, id, actor);
+	}
+	/**
+	* Run content:afterSave hooks across all active plugins
+	*/
+	async runContentAfterSave(content, collection, isNew, actor) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterSave(content, collection, isNew, actor);
+	}
+	/**
+	* Run content:beforeDelete hooks across all active plugins
+	*/
+	async runContentBeforeDelete(id, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentBeforeDelete(id, collection);
+	}
+	/**
+	* Run content:afterDelete hooks across all active plugins
+	*/
+	async runContentAfterDelete(id, collection, permanent) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterDelete(id, collection, permanent);
+	}
+	/**
+	* Run content:afterPublish hooks across all active plugins
+	*/
+	async runContentAfterPublish(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterPublish(content, collection);
+	}
+	/**
+	* Run content:afterUnpublish hooks across all active plugins
+	*/
+	async runContentAfterUnpublish(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterUnpublish(content, collection);
+	}
+	/**
+	* Run content:afterRestore hooks across all active plugins
+	*/
+	async runContentAfterRestore(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterRestore(content, collection);
+	}
+	/**
+	* Run content:afterSchedule hooks across all active plugins
+	*/
+	async runContentAfterSchedule(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterSchedule(content, collection);
+	}
+	/**
+	* Run content:afterUnschedule hooks across all active plugins
+	*/
+	async runContentAfterUnschedule(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterUnschedule(content, collection);
+	}
+	/**
+	* Run media:beforeUpload hooks across all active plugins
+	*/
+	async runMediaBeforeUpload(file) {
+		this.ensureInitialized();
+		return this.hookPipeline.runMediaBeforeUpload(file);
+	}
+	/**
+	* Run media:afterUpload hooks across all active plugins
+	*/
+	async runMediaAfterUpload(media) {
+		this.ensureInitialized();
+		return this.hookPipeline.runMediaAfterUpload(media);
+	}
+	/**
+	* Invoke the cron hook for a specific plugin (per-plugin dispatch).
+	* Used as the InvokeCronHookFn callback for CronExecutor.
+	*/
+	async invokeCronHook(pluginId, event) {
+		this.ensureInitialized();
+		const result = await this.hookPipeline.invokeCronHook(pluginId, event);
+		if (!result.success && result.error) throw result.error;
+	}
+	/**
+	* Invoke a plugin route
+	*/
+	async invokeRoute(pluginId, routeName, options) {
+		this.ensureInitialized();
+		return this.routeRegistry.invoke(pluginId, routeName, options);
+	}
+	/**
+	* Get all routes for a plugin
+	*/
+	getPluginRoutes(pluginId) {
+		this.ensureInitialized();
+		return this.routeRegistry.getRoutes(pluginId);
+	}
+	/**
+	* Get a plugin by ID
+	*/
+	getPlugin(pluginId) {
+		return this.plugins.get(pluginId)?.plugin;
+	}
+	/**
+	* Get plugin state
+	*/
+	getPluginState(pluginId) {
+		return this.plugins.get(pluginId)?.state;
+	}
+	/**
+	* Get all registered plugins
+	*/
+	getAllPlugins() {
+		return Array.from(this.plugins.values(), (entry) => ({
+			plugin: entry.plugin,
+			state: entry.state
+		}));
+	}
+	/**
+	* Get all active plugins
+	*/
+	getActivePlugins() {
+		return [...this.plugins.values()].filter((entry) => entry.state === "active").map((entry) => entry.plugin);
+	}
+	/**
+	* Check if a plugin exists
+	*/
+	hasPlugin(pluginId) {
+		return this.plugins.has(pluginId);
+	}
+	/**
+	* Check if a plugin is active
+	*/
+	isActive(pluginId) {
+		return this.plugins.get(pluginId)?.state === "active";
+	}
+	/**
+	* Get all plugins that registered a handler for an exclusive hook.
+	*/
+	getExclusiveHookProviders(hookName) {
+		this.ensureInitialized();
+		return this.hookPipeline.getExclusiveHookProviders(hookName).map((p) => {
+			const plugin = this.plugins.get(p.pluginId);
+			return {
+				pluginId: p.pluginId,
+				pluginName: plugin?.plugin.id ?? p.pluginId
+			};
+		});
+	}
+	/**
+	* Read the selected provider for an exclusive hook from the options table.
+	*/
+	async getExclusiveHookSelection(hookName) {
+		return new OptionsRepository(this.options.db).get(`${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`);
+	}
+	/**
+	* Set the selected provider for an exclusive hook in the options table.
+	* Pass null to clear the selection.
+	*/
+	async setExclusiveHookSelection(hookName, pluginId) {
+		const optionsRepo = new OptionsRepository(this.options.db);
+		const key = `${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`;
+		if (pluginId === null) {
+			await optionsRepo.delete(key);
+			this.hookPipeline?.clearExclusiveSelection(hookName);
+			return;
+		}
+		const entry = this.plugins.get(pluginId);
+		if (!entry) throw new Error(`Plugin "${pluginId}" not found`);
+		if (entry.state !== "active") throw new Error(`Plugin "${pluginId}" is not active`);
+		await optionsRepo.set(key, pluginId);
+		this.hookPipeline?.setExclusiveSelection(hookName, pluginId);
+	}
+	/**
+	* Resolution algorithm for exclusive hooks.
+	*
+	* Delegates to the shared resolveExclusiveHooks() function.
+	* See hooks.ts for the full algorithm description.
+	*/
+	async resolveExclusiveHooks(preferredHints) {
+		this.ensureInitialized();
+		const optionsRepo = new OptionsRepository(this.options.db);
+		await resolveExclusiveHooks({
+			pipeline: this.hookPipeline,
+			isActive: (pluginId) => this.isActive(pluginId),
+			getOption: (key) => optionsRepo.get(key),
+			getOptions: (keys) => optionsRepo.getMany(keys),
+			setOption: (key, value) => optionsRepo.set(key, value),
+			deleteOption: async (key) => {
+				await optionsRepo.delete(key);
+			},
+			preferredHints
+		});
+	}
+	/**
+	* Get all exclusive hooks with their providers and current selections.
+	* Used by the admin API.
+	*/
+	async getExclusiveHooksInfo() {
+		this.ensureInitialized();
+		const exclusiveHookNames = this.hookPipeline.getRegisteredExclusiveHooks();
+		const result = [];
+		for (const hookName of exclusiveHookNames) {
+			const providers = this.hookPipeline.getExclusiveHookProviders(hookName);
+			const selection = await this.getExclusiveHookSelection(hookName);
+			result.push({
+				hookName,
+				providers,
+				selectedPluginId: selection
+			});
+		}
+		return result;
+	}
+	/**
+	* Initialize or reinitialize the hook pipeline and route registry
+	*/
+	ensureInitialized() {
+		if (this.initialized) return;
+		const activePlugins = this.getActivePlugins();
+		this.hookPipeline = new HookPipeline(activePlugins, this.factoryOptions);
+		this.routeRegistry = new PluginRouteRegistry(this.factoryOptions);
+		for (const plugin of activePlugins) this.routeRegistry.register(plugin);
+		this.initialized = true;
+	}
+	/**
+	* Force reinitialization (useful after plugin state changes)
+	*/
+	reinitialize() {
+		this.initialized = false;
+		this.ensureInitialized();
+	}
+	/**
+	* Delete all cron tasks for a plugin.
+	* Used during uninstall.
+	*/
+	async deleteCronTasks(pluginId) {
+		try {
+			await sql`
+				DELETE FROM _emdash_cron_tasks
+				WHERE plugin_id = ${pluginId}
+			`.execute(this.options.db);
+		} catch {}
+	}
+};
+/**
+* Create a plugin manager
+*/
+function createPluginManager(options) {
+	return new PluginManager(options);
+}
+
+//#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). 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 * 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;
+		}
+		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();
+			}
+		});
+	}
+	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/sandbox/noop.ts
+/**
+* Error thrown when attempting to use sandboxing on an unsupported platform.
+*/
+var SandboxNotAvailableError = class extends Error {
+	constructor() {
+		super("Plugin sandboxing is not available. Configure a sandbox runner: use @emdash-cms/cloudflare/sandbox on Cloudflare, or @emdash-cms/sandbox-workerd/sandbox on Node.js (requires workerd). Without sandboxing, use trusted plugins (from config) instead.");
+		this.name = "SandboxNotAvailableError";
+	}
+};
+/**
+* No-op sandbox runner for platforms without isolation support.
+*
+* - `isAvailable()` returns false
+* - `load()` throws SandboxNotAvailableError
+* - `terminateAll()` is a no-op
+*
+* This is the default runner when no platform adapter is configured.
+*/
+var NoopSandboxRunner = class {
+	/**
+	* Always returns false - sandboxing is not available.
+	*/
+	isAvailable() {
+		return false;
+	}
+	/**
+	* Always returns false - no sandbox runtime to be healthy.
+	*/
+	isHealthy() {
+		return false;
+	}
+	/**
+	* Always throws - can't load sandboxed plugins without isolation.
+	*/
+	async load(_manifest, _code) {
+		throw new SandboxNotAvailableError();
+	}
+	/**
+	* No-op - sandboxing not available, email callback is irrelevant.
+	*/
+	setEmailSend() {}
+	/**
+	* No-op - nothing to terminate.
+	*/
+	async terminateAll() {}
+};
+/**
+* Create a no-op sandbox runner.
+* This is used as the default when no platform adapter is configured.
+*/
+function createNoopSandboxRunner(_options) {
+	return new NoopSandboxRunner();
+}
+
+//#endregion
+//#region src/plugins/sandbox/hook-result.ts
+/** Current wire-format version for sandbox hook result envelopes. */
+const SANDBOX_HOOK_RESULT_VERSION = 1;
+/** Maximum editor-facing rejection reason accepted from a sandboxed plugin. */
+const MAX_SANDBOX_SAVE_REJECTION_REASON_LENGTH = 500;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Validate and normalize an untrusted value returned across the sandbox boundary. */
+function inspectSandboxHookResult(value) {
+	if (!isRecord(value) || !Object.hasOwn(value, "__emdashSandboxHookResult")) return { kind: "value" };
+	if (value.__emdashSandboxHookResult !== true || value.version !== SANDBOX_HOOK_RESULT_VERSION || !isRecord(value.error) || value.error.code !== "SAVE_REJECTED" || typeof value.error.reason !== "string") return { kind: "malformed" };
+	const reason = value.error.reason.trim();
+	if (reason.length === 0 || reason.length > MAX_SANDBOX_SAVE_REJECTION_REASON_LENGTH) return { kind: "malformed" };
+	return {
+		kind: "error",
+		error: {
+			code: "SAVE_REJECTED",
+			reason
+		}
+	};
+}
+
+//#endregion
+//#region src/comments/ranking.ts
+/**
+* Comment ranking utilities (Tier 1 of the best-in-class comments RFC).
+*
+* Wilson score lower-bound (95% confidence) — the same primitive Reddit uses
+* for its "Best" comment sort. Ranks by the statistical lower bound of the
+* positive-reaction proportion rather than the raw count, so a comment with a
+* couple of reactions can't outrank a heavily-reacted one until it earns
+* confidence, and a late-but-popular comment still rises (submission time is
+* irrelevant).
+*
+* Positive-only reactions (the recommended default) degrade gracefully: with
+* `down = 0` the score still increases monotonically with `up` while penalising
+* low-sample comments — wilson(1,0) ≈ 0.21, wilson(10,0) ≈ 0.73,
+* wilson(200,0) ≈ 0.98.
+*/
+/** z for a 95% two-sided confidence interval. */
+const DEFAULT_Z = 1.96;
+/** Reactions that count against a comment when both signals are in use. */
+const NEGATIVE_REACTIONS = new Set(["dislike", "down"]);
+/**
+* Wilson score lower bound of the positive proportion.
+*
+* @param up   count of positive reactions
+* @param down count of negative reactions
+* @returns a score in [0, 1]; 0 when there are no reactions
+*/
+function wilsonLowerBound(up, down, z = DEFAULT_Z) {
+	const n = up + down;
+	if (n <= 0) return 0;
+	const phat = up / n;
+	const z2 = z * z;
+	const denom = 1 + z2 / n;
+	return (phat + z2 / (2 * n) - z * Math.sqrt((phat * (1 - phat) + z2 / (4 * n)) / n)) / denom;
+}
+/**
+* Reduce a per-reaction count map to a single rank score via the Wilson
+* lower bound. Any reaction not in {@link NEGATIVE_REACTIONS} is treated as
+* positive, so the positive-only default (just `like`) works without special
+* casing.
+*/
+function reactionScore(counts) {
+	let up = 0;
+	let down = 0;
+	for (const [reaction, count] of Object.entries(counts)) if (NEGATIVE_REACTIONS.has(reaction)) down += count;
+	else up += count;
+	return wilsonLowerBound(up, down);
+}
+
+//#endregion
+//#region src/comments/query.ts
+/**
+* Get approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getComments } from "emdash";
+*
+* const { items, total } = await getComments({
+*   collection: "posts",
+*   contentId: post.id,
+*   threaded: true,
+* });
+* ```
+*/
+async function getComments(options) {
+	const sort = options.sort ?? "oldest";
+	const withReactions = options.reactions || sort === "best";
+	const threaded = options.threaded ? "t" : "f";
+	return cachedQuery({
+		namespace: CacheNamespace.COMMENTS,
+		key: `comments:${options.collection}:${options.contentId}:${threaded}:${withReactions ? "r" : "n"}:${sort}`,
+		load: async () => {
+			return getCommentsWithDb(await getDb(), options);
+		}
+	});
+}
+/**
+* Get approved comments with an explicit db handle.
+*
+* @internal Use `getComments()` in templates. This variant is for routes
+* that already have a database handle.
+*/
+async function getCommentsWithDb(db, options) {
+	const repo = new CommentRepository(db);
+	const total = await repo.countByContent(options.collection, options.contentId, "approved");
+	const result = await repo.findByContent(options.collection, options.contentId, {
+		status: "approved",
+		limit: 500
+	});
+	const items = options.threaded ? CommentRepository.assembleThreads(result.items).map((c) => CommentRepository.toPublicComment(c)) : result.items.map((c) => CommentRepository.toPublicComment(c));
+	if (options.reactions || options.sort === "best") {
+		await attachReactions(db, items);
+		if (options.sort === "best") sortByBest(items);
+	}
+	return {
+		items,
+		total
+	};
+}
+/**
+* Attach aggregate reaction counts to a list of public comments (and their
+* replies), in a single batched query.
+*/
+async function attachReactions(db, items) {
+	const ids = [];
+	for (const comment of items) {
+		ids.push(comment.id);
+		if (comment.replies) for (const reply of comment.replies) ids.push(reply.id);
+	}
+	if (ids.length === 0) return;
+	const counts = await new CommentReactionRepository(db).countsForComments(ids);
+	const assign = (comment) => {
+		const reactions = counts.get(comment.id);
+		if (reactions) comment.reactions = reactions;
+	};
+	for (const comment of items) {
+		assign(comment);
+		comment.replies?.forEach(assign);
+	}
+}
+/**
+* Sort top-level comments by Wilson-scored reactions (descending), tie-broken
+* by oldest-first to keep ordering stable.
+*/
+function sortByBest(items) {
+	items.sort((a, b) => {
+		const scoreDelta = reactionScore(b.reactions ?? {}) - reactionScore(a.reactions ?? {});
+		if (scoreDelta !== 0) return scoreDelta;
+		if (a.createdAt < b.createdAt) return -1;
+		if (a.createdAt > b.createdAt) return 1;
+		return 0;
+	});
+}
+/**
+* Get the count of approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getCommentCount } from "emdash";
+*
+* const count = await getCommentCount("posts", post.id);
+* ```
+*/
+async function getCommentCount(collection, contentId) {
+	return getCommentCountWithDb(await getDb(), collection, contentId);
+}
+/**
+* Get comment count with an explicit db handle.
+*
+* @internal Use `getCommentCount()` in templates.
+*/
+async function getCommentCountWithDb(db, collection, contentId) {
+	return new CommentRepository(db).countByContent(collection, contentId, "approved");
+}
+
+//#endregion
+//#region src/menus/index.ts
+/**
+* Get a menu by name with resolved URLs.
+*
+* @example
+* ```ts
+* const menu = await getMenu("primary");
+* const menuEs = await getMenu("primary", { locale: "es" });
+* ```
+*/
+async function getMenu(name, options = {}) {
+	const locale = resolveLocale(options.locale);
+	const trailingSlash = options.trailingSlash ?? await getHostTrailingSlash();
+	return requestCached(`menu:${name}:${locale ?? "*"}:${trailingSlash}`, () => cachedQuery({
+		namespace: CacheNamespace.MENUS,
+		key: `${name}:${locale ?? "*"}:${trailingSlash}`,
+		load: async () => {
+			return getMenuWithDb(name, await getDb(), {
+				locale,
+				trailingSlash
+			});
+		}
+	}));
+}
+async function getHostTrailingSlash() {
+	try {
+		return (await import("virtual:emdash/config")).default?.trailingSlash ?? "ignore";
+	} catch {
+		return "ignore";
+	}
+}
+/**
+* Get menu by name with resolved URLs (with explicit db). Internal helper for
+* admin routes that already have a database handle.
+*/
+async function getMenuWithDb(name, db, options = {}) {
+	const chain = resolveLocaleChain(options.locale);
+	const selectMenu = () => db.selectFrom("_emdash_menus").selectAll().where("name", "=", name);
+	let menuRow;
+	if (chain.length === 0) menuRow = await selectMenu().orderBy("locale", "asc").executeTakeFirst();
+	else {
+		menuRow = void 0;
+		for (const locale of chain) {
+			menuRow = await selectMenu().where("locale", "=", locale).executeTakeFirst();
+			if (menuRow) break;
+		}
+	}
+	if (!menuRow) return null;
+	const items = await buildMenuTree(await db.selectFrom("_emdash_menu_items").selectAll().$castTo().where("menu_id", "=", menuRow.id).orderBy("sort_order", "asc").execute(), db, menuRow.locale, options.trailingSlash);
+	return {
+		id: menuRow.id,
+		name: menuRow.name,
+		label: menuRow.label,
+		items,
+		locale: menuRow.locale,
+		translationGroup: menuRow.translation_group
+	};
+}
+/**
+* Get all menus (without items, locale-filtered — for admin list / site nav
+* summaries). When no locale is configured, returns menus across all locales.
+*/
+async function getMenus(options = {}) {
+	return getMenusWithDb(await getDb(), options);
+}
+/**
+* Get all menus (with explicit db)
+*
+* @internal Use `getMenus()` in templates. This variant is for admin routes
+* that already have a database handle.
+*/
+async function getMenusWithDb(db, options = {}) {
+	const locale = resolveLocale(options.locale);
+	let query = db.selectFrom("_emdash_menus").select([
+		"id",
+		"name",
+		"label",
+		"locale"
+	]).orderBy("name", "asc");
+	if (locale !== void 0) query = query.where("locale", "=", locale);
+	return query.execute();
+}
+/**
+* Get a menu by name with a Workers edge-cache hint.
+*
+* Use the returned `cacheHint` with `Astro.cache.set()` so pages that render
+* this menu can be purged automatically when the menu is edited.
+*/
+async function getMenuWithCacheHint(name, options = {}) {
+	return {
+		data: await getMenu(name, options),
+		cacheHint: { tags: [menuTag(name)] }
+	};
+}
+/**
+* Build a hierarchical menu tree from a flat list of items. Items are
+* resolved against the given `locale` so references land on the right
+* per-locale content rows.
+*/
+async function buildMenuTree(items, db, locale, trailingSlash) {
+	const contentReferences = collectContentReferences(items);
+	const taxonomyReferences = new Set(items.flatMap((item) => item.type === "taxonomy" && item.reference_id ? [item.reference_id] : []));
+	const [urlPatterns, contentLookup, taxonomyLookup] = await Promise.all([
+		contentReferences.size > 0 ? getCollectionUrlPatterns(db, new Set(contentReferences.keys())) : /* @__PURE__ */ new Map(),
+		resolveContentReferences(db, contentReferences, locale),
+		resolveTaxonomyReferences(db, taxonomyReferences, locale)
+	]);
+	const validItems = (await Promise.all(items.map((item) => resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup, locale, trailingSlash)))).filter((item) => item !== null);
+	const itemMap = /* @__PURE__ */ new Map();
+	const rootItems = [];
+	for (const item of validItems) itemMap.set(item.id, {
+		...item,
+		children: []
+	});
+	for (const item of items) {
+		const menuItem = itemMap.get(item.id);
+		if (!menuItem) continue;
+		if (item.parent_id) {
+			const parent = itemMap.get(item.parent_id);
+			if (parent) parent.children.push(menuItem);
+			else rootItems.push(menuItem);
+		} else rootItems.push(menuItem);
+	}
+	return rootItems;
+}
+function collectContentReferences(items) {
+	const references = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const reference = getContentReference(item);
+		if (!reference) continue;
+		let ids = references.get(reference.collection);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			references.set(reference.collection, ids);
+		}
+		ids.add(reference.id);
+	}
+	return references;
+}
+function getContentReference(item) {
+	if (item.type === "page" || item.type === "post") {
+		if (!item.reference_id) return null;
+		return {
+			collection: item.reference_collection || `${item.type}s`,
+			id: item.reference_id
+		};
+	}
+	if (item.type === "collection") {
+		if (!item.reference_collection || !item.reference_id) return null;
+		return {
+			collection: item.reference_collection,
+			id: item.reference_id
+		};
+	}
+	if (item.type !== "custom" && item.type !== "taxonomy" && item.reference_collection && item.reference_id) return {
+		collection: item.reference_collection,
+		id: item.reference_id
+	};
+	return null;
+}
+/**
+* Look up the `url_pattern` for a set of collection slugs, request-cached so
+* a page rendering several menus (header, footer, ...) only pays for the
+* lookup once per distinct slug set. Callers must treat the returned map as
+* read-only — it is shared across cache hits within the request.
+*/
+function getCollectionUrlPatterns(db, collectionSlugs) {
+	return requestCached(`menu-collection-patterns:${[...collectionSlugs].toSorted().join(",")}`, async () => {
+		const rows = await db.selectFrom("_emdash_collections").select(["slug", "url_pattern"]).where("slug", "in", [...collectionSlugs]).execute();
+		const urlPatterns = /* @__PURE__ */ new Map();
+		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
+		return urlPatterns;
+	});
+}
+/**
+* Resolve a single menu item's URL. `reference_id` is a translation_group
+* (migration 036 remapped all existing references); we look it up against
+* the per-locale ec_* row or per-locale taxonomy row.
+*/
+async function resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup, locale, trailingSlash) {
+	let url;
+	switch (item.type) {
+		case "custom":
+			url = item.custom_url || "#";
+			break;
+		case "page":
+		case "post":
+			url = await resolveContentUrl(item.reference_collection || `${item.type}s`, item.reference_id, urlPatterns, contentLookup, locale, trailingSlash);
+			if (url === null) return null;
+			break;
+		case "taxonomy":
+			url = resolveTaxonomyUrl(item.reference_id, taxonomyLookup);
+			if (url === null) return null;
+			break;
+		case "collection":
+			if (!item.reference_collection) return null;
+			if (item.reference_id) {
+				url = await resolveContentUrl(item.reference_collection, item.reference_id, urlPatterns, contentLookup, locale, trailingSlash);
+				if (url === null) return null;
+			} else url = `/${item.reference_collection}/`;
+			break;
+		default: if (item.reference_collection && item.reference_id) {
+			url = await resolveContentUrl(item.reference_collection, item.reference_id, urlPatterns, contentLookup, locale, trailingSlash);
+			if (url === null) return null;
+		} else url = "#";
+	}
+	return {
+		id: item.id,
+		label: item.label,
+		url: sanitizeHref(url),
+		target: item.target || void 0,
+		titleAttr: item.title_attr || void 0,
+		cssClasses: item.css_classes || void 0,
+		children: []
+	};
+}
+async function resolveContentReferences(db, references, locale) {
+	const entries = await Promise.all(Array.from(references, async ([collection, referenceGroups]) => {
+		const lookup = /* @__PURE__ */ new Map();
+		const localized = /* @__PURE__ */ new Map();
+		try {
+			validateIdentifier(collection, "menu item collection");
+			for (const batch of chunks([...referenceGroups], SQL_BATCH_SIZE)) {
+				const result = await sql`
+						SELECT id, slug, published_at, locale, translation_group
+						FROM ${sql.ref(`ec_${collection}`)}
+						WHERE translation_group IN (${sql.join(batch)})
+					`.execute(db);
+				for (const row of result.rows) if (shouldPreferLocalizedRow(row, localized.get(row.translation_group), locale)) localized.set(row.translation_group, row);
+			}
+			for (const [referenceGroup, row] of localized) lookup.set(referenceGroup, {
+				id: row.id,
+				slug: row.slug,
+				publishedAt: row.published_at
+			});
+			const unresolved = [...referenceGroups].filter((id) => !lookup.has(id));
+			for (const batch of chunks(unresolved, SQL_BATCH_SIZE)) {
+				const result = await sql`
+						SELECT id, slug, published_at FROM ${sql.ref(`ec_${collection}`)}
+						WHERE id IN (${sql.join(batch)})
+					`.execute(db);
+				for (const row of result.rows) lookup.set(row.id, {
+					id: row.id,
+					slug: row.slug,
+					publishedAt: row.published_at
+				});
+			}
+		} catch (error) {
+			console.error(`Failed to resolve content URLs for ${collection}:`, error);
+		}
+		return [collection, lookup];
+	}));
+	return new Map(entries);
+}
+function shouldPreferLocalizedRow(candidate, existing, locale) {
+	if (!existing) return true;
+	if (candidate.locale === locale) return existing.locale !== locale || candidate.id < existing.id;
+	if (existing.locale === locale) return false;
+	return candidate.locale < existing.locale || candidate.locale === existing.locale && candidate.id < existing.id;
+}
+/**
+* Resolve the URL for a content reference. `referenceGroup` is the content
+* row's translation_group; we look up the row in the requested locale
+* (falling back to the source if no translation exists so the menu link is
+* still clickable).
+*/
+async function resolveContentUrl(collection, referenceGroup, urlPatterns, contentLookup, locale, trailingSlash) {
+	if (!referenceGroup) return null;
+	const row = contentLookup.get(collection)?.get(referenceGroup);
+	if (!row) return null;
+	return resolveLocalizedContentRoutePath({
+		pattern: urlPatterns.get(collection) ?? null,
+		collection,
+		slug: row.slug,
+		id: row.id,
+		date: row.publishedAt,
+		locale,
+		trailingSlash
+	});
+}
+async function resolveTaxonomyReferences(db, referenceGroups, locale) {
+	const lookup = /* @__PURE__ */ new Map();
+	const localized = /* @__PURE__ */ new Map();
+	try {
+		for (const batch of chunks([...referenceGroups], SQL_BATCH_SIZE)) {
+			const rows = await db.selectFrom("taxonomies").select([
+				"id",
+				"name",
+				"slug",
+				"locale",
+				"translation_group"
+			]).where("translation_group", "in", batch).$narrowType().execute();
+			for (const row of rows) if (shouldPreferLocalizedRow(row, localized.get(row.translation_group), locale)) localized.set(row.translation_group, row);
+		}
+		for (const [referenceGroup, row] of localized) lookup.set(referenceGroup, {
+			name: row.name,
+			slug: row.slug
+		});
+		const unresolved = [...referenceGroups].filter((id) => !lookup.has(id));
+		for (const batch of chunks(unresolved, SQL_BATCH_SIZE)) {
+			const rows = await db.selectFrom("taxonomies").select([
+				"id",
+				"name",
+				"slug"
+			]).where("id", "in", batch).execute();
+			for (const row of rows) lookup.set(row.id, {
+				name: row.name,
+				slug: row.slug
+			});
+		}
+	} catch (error) {
+		console.error("Failed to resolve taxonomy URLs:", error);
+	}
+	return lookup;
+}
+/**
+* Resolve URL for a taxonomy term reference. `referenceGroup` is the term's
+* translation_group; we pick the row in the active locale (or fall back).
+*/
+function resolveTaxonomyUrl(referenceGroup, taxonomyLookup) {
+	if (!referenceGroup) return null;
+	const taxonomy = taxonomyLookup.get(referenceGroup);
+	if (!taxonomy) return null;
+	return `/${taxonomy.name}/${taxonomy.slug}`;
+}
+
+//#endregion
+export { image as A, definePluginRoute as C, portableText as D, portableTextIdentityExtensions as E, reference as O, definePlugin as S, prosemirrorToPortableText as T, isContentSaveRejection as _, getComments as a, getActiveContentSaveHookName as b, inspectSandboxHookResult as c, createNoopSandboxRunner as d, NodeCronScheduler as f, ContentSaveRejectedError as g, EmailPipeline as h, getCommentCount as i, EmDashConfigurationError as j, file as k, NoopSandboxRunner as l, createPluginManager as m, getMenuWithCacheHint as n, MAX_SANDBOX_SAVE_REJECTION_REASON_LENGTH as o, PluginManager as p, getMenus as r, SANDBOX_HOOK_RESULT_VERSION as s, getMenu as t, SandboxNotAvailableError as u, HookPipeline as v, portableTextToProsemirror as w, resolveExclusiveHooks as x, createHookPipeline as y };
+//# sourceMappingURL=menus-DiuhXKWf.mjs.map