emdash 0.29.0 → 0.30.0

package/src/api/handlers/plugins.ts

@@ -29,6 +29,8 @@ export interface PluginInfo {
 	hasAdminPages: boolean;
 	hasDashboardWidgets: boolean;
 	hasHooks: boolean;
+	/** True when the plugin declares `admin.settingsSchema` (auto-generated settings form) */
+	hasSettings: boolean;
 	installedAt?: string;
 	activatedAt?: string;
 	deactivatedAt?: string;
@@ -36,6 +38,14 @@ export interface PluginInfo {
 	description?: string;
 	/** URL to the plugin icon on the marketplace */
 	iconUrl?: string;
+	mcpToolsEnabled: boolean;
+	mcpTools: Array<{
+		name: string;
+		description: string;
+		route: string;
+		permission: string;
+		destructive: boolean;
+	}>;
 }
 
 export interface PluginListResponse {
@@ -78,12 +88,28 @@ function buildPluginInfo(
 		hasAdminPages: (plugin.admin.pages?.length ?? 0) > 0,
 		hasDashboardWidgets: (plugin.admin.widgets?.length ?? 0) > 0,
 		hasHooks: Object.keys(plugin.hooks ?? {}).length > 0,
+		hasSettings: Object.keys(plugin.admin.settingsSchema ?? {}).length > 0,
 		installedAt: state?.installedAt?.toISOString(),
 		activatedAt: state?.activatedAt?.toISOString() ?? undefined,
 		deactivatedAt: state?.deactivatedAt?.toISOString() ?? undefined,
 		description: state?.description ?? undefined,
 		iconUrl:
 			isMarketplace && marketplaceUrl ? marketplaceIconUrl(marketplaceUrl, plugin.id) : undefined,
+		mcpToolsEnabled: state?.mcpToolsEnabled ?? false,
+		mcpTools: Object.entries(plugin.mcp?.tools ?? {}).flatMap(([name, tool]) => {
+			const permission = plugin.routes[tool.route]?.permission;
+			return permission
+				? [
+						{
+							name,
+							description: tool.description,
+							route: tool.route,
+							permission,
+							destructive: tool.destructive ?? false,
+						},
+					]
+				: [];
+		}),
 	};
 }
 
@@ -110,10 +136,13 @@ function buildSandboxedPluginInfo(
 		hasAdminPages: (entry.adminPages?.length ?? 0) > 0,
 		hasDashboardWidgets: (entry.adminWidgets?.length ?? 0) > 0,
 		hasHooks: false,
+		hasSettings: Object.keys(entry.settingsSchema ?? {}).length > 0,
 		installedAt: state?.installedAt?.toISOString(),
 		activatedAt: state?.activatedAt?.toISOString() ?? undefined,
 		deactivatedAt: state?.deactivatedAt?.toISOString() ?? undefined,
 		description: state?.description ?? undefined,
+		mcpToolsEnabled: state?.mcpToolsEnabled ?? false,
+		mcpTools: entry.mcp?.tools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool) ?? [],
 	};
 }
 
@@ -125,6 +154,12 @@ export async function handlePluginList(
 	configuredPlugins: ResolvedPlugin[],
 	sandboxedPluginEntries: SandboxedPluginEntry[],
 	marketplaceUrl?: string,
+	/**
+	 * Settings-schema lookup for runtime-installed (marketplace/registry)
+	 * plugins, which aren't in either build-time list. Typically
+	 * `EmDashRuntime.getRuntimePluginSettingsSchema`.
+	 */
+	runtimeSettingsSchemaLookup?: (pluginId: string) => Record<string, unknown> | null,
 ): Promise<ApiResult<PluginListResponse>> {
 	try {
 		const stateRepo = new PluginStateRepository(db);
@@ -166,6 +201,7 @@ export async function handlePluginList(
 				hasAdminPages: false,
 				hasDashboardWidgets: false,
 				hasHooks: false,
+				hasSettings: Object.keys(runtimeSettingsSchemaLookup?.(state.pluginId) ?? {}).length > 0,
 				installedAt: state.installedAt?.toISOString(),
 				activatedAt: state.activatedAt?.toISOString() ?? undefined,
 				deactivatedAt: state.deactivatedAt?.toISOString() ?? undefined,
@@ -174,6 +210,8 @@ export async function handlePluginList(
 					state.source === "marketplace" && marketplaceUrl
 						? marketplaceIconUrl(marketplaceUrl, state.pluginId)
 						: undefined,
+				mcpToolsEnabled: state.mcpToolsEnabled,
+				mcpTools: [],
 			});
 		}
 
@@ -266,10 +304,13 @@ function buildStateOnlyPluginInfo(
 		hasAdminPages: false,
 		hasDashboardWidgets: false,
 		hasHooks: false,
+		hasSettings: false,
 		installedAt: state.installedAt?.toISOString(),
 		activatedAt: state.activatedAt?.toISOString() ?? undefined,
 		deactivatedAt: state.deactivatedAt?.toISOString() ?? undefined,
 		description: state.description ?? undefined,
+		mcpToolsEnabled: state.mcpToolsEnabled,
+		mcpTools: [],
 	};
 }
 

package/src/api/handlers/registry.ts

@@ -121,6 +121,7 @@ export interface RegistryInstallInput {
 	 * surface a consent UI before posting (e.g. CI scripts) opt out.
 	 */
 	acknowledgedDeclaredAccess?: unknown;
+	acknowledgedMcpTools?: unknown;
 }
 
 export interface RegistryInstallResult {
@@ -1098,6 +1099,22 @@ export async function handleRegistryInstall(
 			}
 		}
 
+		const actualMcpTools = (bundle.manifest.mcp?.tools ?? []).map(
+			({ inputSchema: _, outputSchema: __, ...tool }) => tool,
+		);
+		if (actualMcpTools.length > 0) {
+			if (JSON.stringify(input.acknowledgedMcpTools) !== JSON.stringify(actualMcpTools)) {
+				return {
+					success: false,
+					error: {
+						code: "MCP_TOOL_CONSENT_REQUIRED",
+						message: "Plugin MCP tools require explicit consent",
+						details: { mcpTools: actualMcpTools },
+					},
+				};
+			}
+		}
+
 		// Step 7: store in R2 under the registry prefix.
 		await storeBundleInR2(storage, pluginId, version, bundle, "registry");
 
@@ -1318,6 +1335,7 @@ export async function handleRegistryUpdate(
 		version?: string;
 		confirmCapabilityChanges?: boolean;
 		confirmRouteVisibilityChanges?: boolean;
+		confirmMcpTools?: boolean;
 		hostEnv?: HostEnv;
 	},
 ): Promise<ApiResult<RegistryUpdateResult>> {
@@ -1590,6 +1608,25 @@ export async function handleRegistryUpdate(
 			};
 		}
 
+		const oldMcpTools = [...(oldBundle?.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+		const newMcpTools = [...(bundle.manifest.mcp?.tools ?? [])].toSorted((a, b) =>
+			a.name.localeCompare(b.name),
+		);
+		if (JSON.stringify(oldMcpTools) !== JSON.stringify(newMcpTools) && !opts?.confirmMcpTools) {
+			return {
+				success: false,
+				error: {
+					code: "MCP_TOOL_CONSENT_REQUIRED",
+					message: "Plugin update changes its MCP tools",
+					details: {
+						mcpTools: newMcpTools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool),
+					},
+				},
+			};
+		}
+
 		// Store new bundle. R2 prefix is deterministic per (pluginId, version),
 		// so a retry of the same update is idempotent.
 		await storeBundleInR2(storage, pluginId, newVersion, bundle, "registry");
@@ -1605,6 +1642,8 @@ export async function handleRegistryUpdate(
 			registrySlug: slug,
 			displayName: existing.displayName ?? slug,
 			description: existing.description ?? undefined,
+			mcpToolsEnabled: false,
+			mcpToolsConsent: null,
 		});
 
 		// Best-effort cleanup of the old bundle. Failures here don't roll

package/src/api/handlers/snapshot.ts

@@ -218,10 +218,19 @@ interface ColumnInfo {
 }
 
 export interface GenerateSnapshotOptions {
-	/** Include draft and trashed content (default: false) */
+	/** Include draft and scheduled content (default: false) */
 	includeDrafts?: boolean;
+	/** Include trashed content (deleted_at set). Used by backups (default: false) */
+	includeTrashed?: boolean;
 	/** Origin URL for absolutizing local media URLs (e.g. "https://mysite.com") */
 	origin?: string;
+	/**
+	 * Allowlist of options-table key prefixes to include (default:
+	 * `SAFE_OPTIONS_PREFIXES`). Callers widening this must never include a
+	 * prefix that matches secrets (`emdash:preview_secret`, `plugin:`,
+	 * `emdash:passkey_pending:`) — the output may be user-downloadable.
+	 */
+	optionPrefixes?: string[];
 }
 
 /**
@@ -235,6 +244,8 @@ export async function generateSnapshot(
 	options?: GenerateSnapshotOptions,
 ): Promise<Snapshot> {
 	const includeDrafts = options?.includeDrafts ?? false;
+	const includeTrashed = options?.includeTrashed ?? false;
+	const optionPrefixes = options?.optionPrefixes ?? SAFE_OPTIONS_PREFIXES;
 
 	// Discover all ec_* content tables
 	const tableResult = await sql<{ name: string }>`
@@ -280,7 +291,14 @@ export async function generateSnapshot(
 			let rows: Record<string, unknown>[];
 
 			if (tableName.startsWith("ec_")) {
-				if (includeDrafts) {
+				if (includeTrashed) {
+					// Everything, including trash — full-fidelity backup export
+					rows = (
+						await sql<Record<string, unknown>>`
+						SELECT * FROM ${sql.raw(`"${tableName}"`)}
+					`.execute(db)
+					).rows;
+				} else if (includeDrafts) {
 					// Include all non-deleted content (published, draft, scheduled)
 					rows = (
 						await sql<Record<string, unknown>>`
@@ -307,7 +325,7 @@ export async function generateSnapshot(
 				`.execute(db)
 				).rows.filter((row) => {
 					const name = typeof row.name === "string" ? row.name : "";
-					return SAFE_OPTIONS_PREFIXES.some((prefix) => name.startsWith(prefix));
+					return optionPrefixes.some((prefix) => name.startsWith(prefix));
 				});
 			} else {
 				rows = (

package/src/api/openapi/document.ts

@@ -37,14 +37,22 @@ import {
 	contentUpdateBody,
 	trashedContentListResponseSchema,
 } from "../schemas/content.js";
-import { mediaUsageRepairBody, mediaUsageRepairResponseSchema } from "../schemas/media-usage.js";
+import {
+	mediaUsageDetailsQuery,
+	mediaUsageDetailsResponseSchema,
+	mediaUsageRepairBody,
+	mediaUsageRepairResponseSchema,
+} from "../schemas/media-usage.js";
 import {
 	DEFAULT_MAX_UPLOAD_SIZE,
 	mediaConfirmBody,
 	mediaConfirmResponseSchema,
 	mediaExistingResponseSchema,
+	mediaGetQuery,
 	mediaListQuery,
+	mediaListReadResponseSchema,
 	mediaListResponseSchema,
+	mediaReadResponseSchema,
 	mediaResponseSchema,
 	mediaUpdateBody,
 	mediaUploadUrlBody,
@@ -661,15 +669,19 @@ function buildMediaPaths(maxUploadSize: number) {
 			get: {
 				operationId: "listMedia",
 				summary: "List media items",
+				description:
+					"Lists media items. Set `includeUsage=1` to attach coverage-aware advisory usage counts; a count may be null when the caller cannot read draft-derived usage.",
 				tags: ["Media"],
 				requestParams: { query: mediaListQuery },
 				responses: {
 					"200": {
 						description: "Media list",
-						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaListResponseSchema) } },
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaListReadResponseSchema) },
+						},
 					},
 					...authErrors,
-					...standardErrors(500),
+					...standardErrors(400, 500),
 				},
 			},
 		},
@@ -677,17 +689,20 @@ function buildMediaPaths(maxUploadSize: number) {
 			get: {
 				operationId: "getMedia",
 				summary: "Get a media item",
+				description:
+					"Gets a media item. Set `includeUsage=1` to attach a coverage-aware advisory usage count; the count may be null when the caller cannot read draft-derived usage.",
 				tags: ["Media"],
 				requestParams: {
 					path: z.object({ id: z.string().meta({ description: "Media ID" }) }),
+					query: mediaGetQuery,
 				},
 				responses: {
 					"200": {
 						description: "Media item",
-						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaResponseSchema) } },
+						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaReadResponseSchema) } },
 					},
 					...authErrors,
-					...standardErrors(404, 500),
+					...standardErrors(400, 404, 500),
 				},
 			},
 			put: {
@@ -724,6 +739,29 @@ function buildMediaPaths(maxUploadSize: number) {
 				},
 			},
 		},
+		"/_emdash/api/media/{id}/usage": {
+			get: {
+				operationId: "getMediaUsage",
+				summary: "Get media usage details",
+				description:
+					"Returns paginated content entry groups whose current indexed sources reference a local media item. Results include aggregate coverage and are advisory during concurrent writes. Requires media read and draft-content read permission; token-authenticated callers also require admin scope.",
+				tags: ["Media"],
+				requestParams: {
+					path: z.object({ id: z.string().meta({ description: "Media ID" }) }),
+					query: mediaUsageDetailsQuery,
+				},
+				responses: {
+					"200": {
+						description: "Entry-grouped media usage details",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaUsageDetailsResponseSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 404, 500),
+				},
+			},
+		},
 		"/_emdash/api/admin/media-usage/repair": {
 			post: {
 				operationId: "repairMediaUsage",
@@ -2351,7 +2389,7 @@ export function generateOpenApiDocument(
 			title: "EmDash CMS API",
 			version: "0.1.0",
 			description:
-				"REST API for the EmDash CMS. All endpoints require authentication and return responses wrapped in a `{ data }` envelope.",
+				"REST API for the EmDash CMS. All endpoints require authentication and return responses wrapped in a `{ success, data }` envelope.",
 		},
 		servers: [
 			{
@@ -2417,6 +2455,10 @@ export function generateOpenApiDocument(
 			},
 		],
 		components: {
+			schemas: {
+				// Preserve the previously published component while media reads use richer schemas.
+				MediaListResponse: mediaListResponseSchema,
+			},
 			securitySchemes: {
 				session: {
 					type: "apiKey",

package/src/api/parse.ts

@@ -113,21 +113,7 @@ function validate<T extends z.ZodType>(schema: T, data: unknown): ParseResult<z.
 		message: issue.message,
 	}));
 
-	return Response.json(
-		{
-			error: {
-				code: "VALIDATION_ERROR",
-				message: "Invalid request data",
-				details: { issues },
-			},
-		},
-		{
-			status: 400,
-			headers: {
-				"Cache-Control": "private, no-store",
-			},
-		},
-	);
+	return apiError("VALIDATION_ERROR", "Invalid request data", 400, { issues });
 }
 
 /**

package/src/api/public-url.ts

@@ -22,8 +22,10 @@ interface SiteUrlConfig {
  * the build. Container deployments set env vars at runtime, so we must read
  * process.env which Vite leaves untouched.
  *
- * On Cloudflare Workers process.env is unavailable (returns undefined),
- * so the fallback chain continues to url.origin.
+ * On Cloudflare Workers process.env is empty by default, so the fallback
+ * chain continues to url.origin — unless the Worker enables the
+ * `nodejs_compat_populate_process_env` compatibility flag, in which case
+ * `vars`/secrets (e.g. EMDASH_SITE_URL) are readable here too.
  *
  * Caches after first call.
  */

package/src/api/schemas/common.ts

@@ -73,6 +73,7 @@ export const localeFilterQuery = z
 /** Standard API error response */
 export const apiErrorSchema = z
 	.object({
+		success: z.literal(false).meta({ description: "Discriminant: always false for errors" }),
 		error: z.object({
 			code: z.string().meta({ description: "Machine-readable error code", example: "NOT_FOUND" }),
 			message: z.string().meta({ description: "Human-readable error message" }),
@@ -80,9 +81,12 @@ export const apiErrorSchema = z
 	})
 	.meta({ id: "ApiError" });
 
-/** Wrap a data schema in the standard success envelope: { data: T } */
+/** Wrap a data schema in the standard success envelope: { success: true, data: T } */
 export function successEnvelope<T extends z.ZodType>(dataSchema: T) {
-	return z.object({ data: dataSchema });
+	return z.object({
+		success: z.literal(true).meta({ description: "Discriminant: always true for success" }),
+		data: dataSchema,
+	});
 }
 
 /** Standard delete response */

package/src/api/schemas/media-usage.ts

@@ -2,6 +2,71 @@ import { z } from "zod";
 
 import { slugPattern } from "./common.js";
 
+export const mediaUsageCoverageStatusSchema = z
+	.enum(["complete", "never", "running", "partial", "failed", "stale", "unknown"])
+	.meta({ id: "MediaUsageCoverageStatus" });
+
+export const mediaUsageCoverageSchema = z
+	.object({
+		scope: z.literal("all_content_collections"),
+		status: mediaUsageCoverageStatusSchema,
+	})
+	.meta({ id: "MediaUsageCoverage" });
+
+export const mediaUsageSummarySchema = z
+	.object({
+		count: z.number().int().min(0).nullable(),
+		coverage: mediaUsageCoverageSchema,
+	})
+	.meta({ id: "MediaUsageSummary" });
+
+export const mediaUsageDetailsQuery = z.object({
+	cursor: z.string().min(1).max(2048).optional().meta({
+		description: "Opaque content-entry-group cursor",
+	}),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({
+		description: "Maximum number of content entry groups to return (1-100, default 50)",
+	}),
+});
+
+export const mediaUsageOccurrenceDetailSchema = z
+	.object({
+		fieldSlug: z.string(),
+		fieldPath: z.string(),
+		occurrenceIndex: z.number().int().min(0),
+		referenceType: z.enum(["image_field", "file_field", "portable_text_image", "unknown"]),
+	})
+	.meta({ id: "MediaUsageOccurrenceDetail" });
+
+export const mediaUsageSourceDetailSchema = z
+	.object({
+		variant: z.enum(["columns", "draft_overlay"]),
+		occurrences: z.array(mediaUsageOccurrenceDetailSchema),
+	})
+	.meta({ id: "MediaUsageSourceDetail" });
+
+export const mediaUsageEntryDetailSchema = z
+	.object({
+		collection: z.string(),
+		contentId: z.string(),
+		title: z.string().nullable(),
+		slug: z.string().nullable(),
+		locale: z.string().nullable(),
+		status: z.string().nullable(),
+		scheduledAt: z.string().nullable(),
+		deletedAt: z.string().nullable(),
+		sources: z.array(mediaUsageSourceDetailSchema),
+	})
+	.meta({ id: "MediaUsageEntryDetail" });
+
+export const mediaUsageDetailsResponseSchema = z
+	.object({
+		items: z.array(mediaUsageEntryDetailSchema),
+		nextCursor: z.string().optional(),
+		coverage: mediaUsageCoverageSchema,
+	})
+	.meta({ id: "MediaUsageDetailsResponse" });
+
 export const mediaUsageRepairStatusSchema = z
 	.enum(["complete", "partial", "failed", "stale"])
 	.meta({ id: "MediaUsageRepairStatus" });
@@ -46,3 +111,10 @@ export const mediaUsageRepairResponseSchema = z
 
 export type MediaUsageRepairRequest = z.infer<typeof mediaUsageRepairBody>;
 export type MediaUsageRepairResponse = z.infer<typeof mediaUsageRepairResponseSchema>;
+export type MediaUsageCoverageStatus = z.infer<typeof mediaUsageCoverageStatusSchema>;
+export type MediaUsageCoverage = z.infer<typeof mediaUsageCoverageSchema>;
+export type MediaUsageSummary = z.infer<typeof mediaUsageSummarySchema>;
+export type MediaUsageOccurrenceDetail = z.infer<typeof mediaUsageOccurrenceDetailSchema>;
+export type MediaUsageSourceDetail = z.infer<typeof mediaUsageSourceDetailSchema>;
+export type MediaUsageEntryDetail = z.infer<typeof mediaUsageEntryDetailSchema>;
+export type MediaUsageDetailsResponse = z.infer<typeof mediaUsageDetailsResponseSchema>;

package/src/api/schemas/media.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { cursorPaginationQuery } from "./common.js";
+import { mediaUsageSummarySchema } from "./media-usage.js";
 
 // ---------------------------------------------------------------------------
 // Media: Input schemas
@@ -23,9 +24,20 @@ export const mediaListQuery = cursorPaginationQuery
 		mimeType: mimeTypeFilter,
 		/** Case-insensitive filename substring search (also matches extensions). */
 		q: z.string().trim().min(1).max(200).optional(),
+		includeUsage: z.literal("1").optional().meta({
+			description: "Include a coverage-aware usage summary on each media item",
+		}),
 	})
 	.meta({ id: "MediaListQuery" });
 
+export const mediaGetQuery = z
+	.object({
+		includeUsage: z.literal("1").optional().meta({
+			description: "Include a coverage-aware usage summary on the media item",
+		}),
+	})
+	.meta({ id: "MediaGetQuery" });
+
 export const mediaUpdateBody = z
 	.object({
 		alt: z.string().optional(),
@@ -46,7 +58,7 @@ export function formatFileSize(bytes: number): string {
 
 // Matches a full MIME type (type/subtype) with an optional semicolon-delimited
 // parameter section. Forbids CR/LF to prevent header injection.
-const CONTENT_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]+(\s*;[^\r\n]*)?$/i;
+export const CONTENT_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]+(\s*;[^\r\n]*)?$/i;
 
 export function mediaUploadUrlBody(maxSize: number) {
 	if (!Number.isFinite(maxSize) || maxSize <= 0) {
@@ -115,6 +127,25 @@ export const mediaResponseSchema = z
 	.object({ item: mediaItemSchema })
 	.meta({ id: "MediaResponse" });
 
+export const mediaReadItemSchema = mediaItemSchema
+	.extend({ usage: mediaUsageSummarySchema.optional() })
+	.meta({ id: "MediaReadItem" });
+
+export const mediaReadResponseSchema = z
+	.object({ item: mediaReadItemSchema })
+	.meta({ id: "MediaReadResponse" });
+
+export const mediaListReadItemSchema = mediaReadItemSchema
+	.extend({ url: z.string() })
+	.meta({ id: "MediaListReadItem" });
+
+export const mediaListReadResponseSchema = z
+	.object({
+		items: z.array(mediaListReadItemSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "MediaListReadResponse" });
+
 export const mediaListResponseSchema = z
 	.object({
 		items: z.array(mediaItemSchema),

package/src/astro/integration/index.ts

@@ -195,6 +195,34 @@ export function resolveImageEndpoint(opts: {
 	};
 }
 
+/**
+ * Warn when `@astrojs/react` is not registered in the host's `integrations`.
+ *
+ * The admin SPA is a React app hydrated via `client:only="react"`. Without the
+ * React integration the build succeeds and the admin route returns 200, but the
+ * bundle never hydrates -- the page sits on "Loading EmDash..." forever with no
+ * error anywhere (#962). Checked in `astro:config:done` so integrations added
+ * by other integrations are visible too.
+ *
+ * @internal Exported for unit testing.
+ */
+export function missingReactIntegrationWarning(
+	integrations: readonly { name: string }[],
+): string | undefined {
+	if (integrations.some((integration) => integration.name === "@astrojs/react")) {
+		return undefined;
+	}
+	return (
+		`@astrojs/react is not registered in your Astro config. The EmDash admin UI ` +
+		`will not hydrate without it (the page stays on "Loading EmDash..."). ` +
+		`Add it to your integrations:\n\n` +
+		`  import react from "@astrojs/react";\n` +
+		`  export default defineConfig({\n` +
+		`    integrations: [react(), emdash({ ... })],\n` +
+		`  });`
+	);
+}
+
 // Terminal formatting
 const dim = (s: string) => `\x1b[2m${s}\x1b[22m`;
 const bold = (s: string) => `\x1b[1m${s}\x1b[22m`;
@@ -381,6 +409,12 @@ export function emdash(config: EmDashConfig = {}): AstroIntegration {
 				if (astroVersion !== undefined) {
 					serializableConfig.astroVersion = astroVersion;
 				}
+				// EmDashHead must not access Astro.csp when the host has disabled
+				// Astro's built-in CSP runtime; Astro logs a warning for that access.
+				serializableConfig.astroCspEnabled = Boolean(astroConfig.security.csp);
+				// Expose Astro's trailingSlash routing policy so plugins can build
+				// URLs (sitemap/canonical/hreflang) that match what the site serves.
+				serializableConfig.trailingSlash = astroConfig.trailingSlash;
 				// Extract i18n config from Astro config
 				// Astro locales can be strings OR { path, codes } objects — normalize to paths
 				if (astroConfig.i18n) {
@@ -556,6 +590,10 @@ export function emdash(config: EmDashConfig = {}): AstroIntegration {
 				// dev server is listening (see astro:server:setup), since the
 				// port isn't known yet here. Nothing useful to print for build.
 			},
+			"astro:config:done": ({ config: finalConfig, logger }) => {
+				const warning = missingReactIntegrationWarning(finalConfig.integrations);
+				if (warning) logger.warn(warning);
+			},
 			"astro:server:setup": ({ server, logger }) => {
 				// Print route info with absolute, clickable URLs once the server
 				// is listening. Only in `astro dev` -- the dev-bypass shortcut is

package/src/astro/integration/routes.ts

@@ -213,6 +213,11 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/media/[id].ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/media/[id]/usage",
+		entrypoint: resolveRoute("api/media/[id]/usage.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/media/[id]/confirm",
 		entrypoint: resolveRoute("api/media/[id]/confirm.ts"),
@@ -346,6 +351,27 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/settings/email.ts"),
 	});
 
+	// Backup routes
+	injectRoute({
+		pattern: "/_emdash/api/settings/backups",
+		entrypoint: resolveRoute("api/settings/backups/index.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/settings/backups/export",
+		entrypoint: resolveRoute("api/settings/backups/export.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/settings/backups/archives",
+		entrypoint: resolveRoute("api/settings/backups/archives/index.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/settings/backups/archives/[name]",
+		entrypoint: resolveRoute("api/settings/backups/archives/[name].ts"),
+	});
+
 	// Snapshot route (for DO preview database population)
 	injectRoute({
 		pattern: "/_emdash/api/snapshot",
@@ -398,6 +424,15 @@ export function injectCoreRoutes(
 		pattern: "/_emdash/api/admin/plugins/[id]/disable",
 		entrypoint: resolveRoute("api/admin/plugins/[id]/disable.ts"),
 	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/plugins/[id]/mcp",
+		entrypoint: resolveRoute("api/admin/plugins/[id]/mcp.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/admin/plugins/[id]/settings",
+		entrypoint: resolveRoute("api/admin/plugins/[id]/settings.ts"),
+	});
 
 	// Marketplace plugin routes
 	injectRoute({