emdash 0.32.0 → 0.34.0

package/src/api/schemas/schema.ts

@@ -1,15 +1,41 @@
 import { z } from "zod";
 
+import { MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
+import { compileUrlPattern } from "../../schema/url-pattern.js";
 import { slugPattern } from "./common.js";
 
 // ---------------------------------------------------------------------------
 // Schema (collections & fields): Input schemas
 // ---------------------------------------------------------------------------
 
-const collectionSupportValues = z.enum(["drafts", "revisions", "preview", "scheduling", "search"]);
+const collectionSupportValues = z.enum([
+	"drafts",
+	"revisions",
+	"preview",
+	"scheduling",
+	"search",
+	"seo",
+]);
 
 const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
 
+const collectionListColumns = z.array(
+	z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format"),
+);
+
+const collectionAdminInputConfig = z.object({
+	listColumns: collectionListColumns
+		.max(
+			MAX_COLLECTION_LIST_COLUMNS,
+			`At most ${MAX_COLLECTION_LIST_COLUMNS} list columns are allowed`,
+		)
+		.optional(),
+});
+
+const collectionAdminResponseConfig = z.object({
+	listColumns: collectionListColumns.optional(),
+});
+
 const fieldTypeValues = z.enum([
 	"string",
 	"text",
@@ -49,6 +75,17 @@ const repeaterSubFieldSchema = z.object({
 	options: z.array(z.string()).optional(),
 });
 
+const urlPatternValue = z.string().superRefine((pattern, ctx) => {
+	try {
+		compileUrlPattern(pattern);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Invalid URL pattern",
+		});
+	}
+});
+
 const fieldValidation = z
 	.object({
 		required: z.boolean().optional(),
@@ -71,6 +108,35 @@ const fieldValidation = z
 			.max(64, "allowedMimeTypes may contain at most 64 entries")
 			.optional(),
 	})
+	.superRefine((validation, ctx) => {
+		for (const [minimum, maximum] of [
+			["min", "max"],
+			["minLength", "maxLength"],
+			["minItems", "maxItems"],
+		] as const) {
+			const minimumValue = validation[minimum];
+			const maximumValue = validation[maximum];
+			if (minimumValue !== undefined && maximumValue !== undefined && minimumValue > maximumValue) {
+				ctx.addIssue({
+					code: "custom",
+					path: [maximum],
+					message: `${maximum} must be greater than or equal to ${minimum}`,
+				});
+			}
+		}
+
+		if (validation.pattern !== undefined) {
+			try {
+				RegExp(validation.pattern);
+			} catch {
+				ctx.addIssue({
+					code: "custom",
+					path: ["pattern"],
+					message: "Invalid validation pattern",
+				});
+			}
+		}
+	})
 	.optional();
 
 const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
@@ -82,10 +148,14 @@ export const createCollectionBody = z
 		labelSingular: z.string().optional(),
 		description: z.string().optional(),
 		icon: z.string().optional(),
+		admin: collectionAdminInputConfig.optional(),
 		supports: z.array(collectionSupportValues).optional(),
 		source: z.string().regex(collectionSourcePattern).optional(),
-		urlPattern: z.string().optional(),
+		urlPattern: urlPatternValue.optional(),
+		routable: z.boolean().optional(),
 		hasSeo: z.boolean().optional(),
+		hidden: z.boolean().optional(),
+		sortOrder: z.number().int().nullish(),
 	})
 	.meta({ id: "CreateCollectionBody" });
 
@@ -95,9 +165,13 @@ export const updateCollectionBody = z
 		labelSingular: z.string().optional(),
 		description: z.string().optional(),
 		icon: z.string().optional(),
+		admin: collectionAdminInputConfig.optional(),
 		supports: z.array(collectionSupportValues).optional(),
-		urlPattern: z.string().nullish(),
+		urlPattern: urlPatternValue.nullish(),
+		routable: z.boolean().optional(),
 		hasSeo: z.boolean().optional(),
+		hidden: z.boolean().optional(),
+		sortOrder: z.number().int().nullish(),
 		commentsEnabled: z.boolean().optional(),
 		commentsModeration: z.enum(["all", "first_time", "none"]).optional(),
 		commentsClosedAfterDays: z.number().int().min(0).optional(),
@@ -118,6 +192,7 @@ export const createFieldBody = z
 		options: fieldWidgetOptions,
 		sortOrder: z.number().int().min(0).optional(),
 		searchable: z.boolean().optional(),
+		indexed: z.boolean().optional(),
 		translatable: z.boolean().optional(),
 	})
 	.meta({ id: "CreateFieldBody" });
@@ -134,6 +209,7 @@ export const updateFieldBody = z
 		options: fieldWidgetOptions,
 		sortOrder: z.number().int().min(0).optional(),
 		searchable: z.boolean().optional(),
+		indexed: z.boolean().optional(),
 		translatable: z.boolean().optional(),
 	})
 	.meta({ id: "UpdateFieldBody" });
@@ -144,6 +220,13 @@ export const fieldReorderBody = z
 	})
 	.meta({ id: "FieldReorderBody" });
 
+export const collectionReorderBody = z
+	.object({
+		/** Full desired sidebar order. Collections left out fall back to alphabetical. */
+		slugs: z.array(z.string().min(1)),
+	})
+	.meta({ id: "CollectionReorderBody" });
+
 export const orphanRegisterBody = z
 	.object({
 		label: z.string().optional(),
@@ -175,10 +258,14 @@ export const collectionSchema = z
 		labelSingular: z.string().nullable(),
 		description: z.string().nullable(),
 		icon: z.string().nullable(),
+		admin: collectionAdminResponseConfig.optional(),
 		supports: z.array(z.string()),
 		source: z.string().nullable(),
 		urlPattern: z.string().nullable(),
+		routable: z.boolean(),
 		hasSeo: z.boolean(),
+		hidden: z.boolean(),
+		sortOrder: z.number().int().nullable(),
 		createdAt: z.string(),
 		updatedAt: z.string(),
 	})
@@ -199,6 +286,7 @@ export const fieldSchema = z
 		options: z.record(z.string(), z.unknown()).nullable(),
 		sortOrder: z.number().int(),
 		searchable: z.boolean(),
+		indexed: z.boolean(),
 		translatable: z.boolean(),
 		createdAt: z.string(),
 		updatedAt: z.string(),

package/src/api/schemas/search.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { SEARCH_TOKENIZERS } from "../../search/types.js";
 import { localeCode } from "./common.js";
 
 // ---------------------------------------------------------------------------
@@ -37,6 +38,7 @@ export const searchEnableBody = z
 		collection: z.string().min(1),
 		enabled: z.boolean(),
 		weights: z.record(z.string(), z.number()).optional(),
+		tokenize: z.enum(SEARCH_TOKENIZERS).optional(),
 	})
 	.meta({ id: "SearchEnableBody" });
 

package/src/api/schemas/taxonomies.ts

@@ -9,6 +9,12 @@ import { localeCode } from "./common.js";
 /** Collection slug format: lowercase alphanumeric + underscores, starts with letter */
 const collectionSlugPattern = /^[a-z][a-z0-9_]*$/;
 
+const collectionSlug = z
+	.string()
+	.min(1)
+	.max(63)
+	.regex(collectionSlugPattern, "Invalid collection slug format");
+
 export const createTaxonomyDefBody = z
 	.object({
 		name: z
@@ -19,25 +25,38 @@ export const createTaxonomyDefBody = z
 		label: z.string().min(1).max(200),
 		labelSingular: z.string().min(1).max(200).optional(),
 		hierarchical: z.boolean().optional().default(false),
-		collections: z
-			.array(
-				z.string().min(1).max(63).regex(collectionSlugPattern, "Invalid collection slug format"),
-			)
-			.max(100)
-			.optional()
-			.default([]),
+		collections: z.array(collectionSlug).max(100).optional().default([]),
 		locale: localeCode.optional(),
 		translationOf: z.string().min(1).optional(),
 	})
 	.meta({ id: "CreateTaxonomyDefBody" });
 
+/**
+ * `name` and `locale` are absent on purpose: both identify the definition row
+ * being written, and `.strict()` turns an attempt to change either into a 400
+ * rather than a silently ignored field.
+ */
+export const updateTaxonomyDefBody = z
+	.object({
+		label: z.string().min(1).max(200).optional(),
+		labelSingular: z.string().min(1).max(200).nullish(),
+		hierarchical: z.boolean().optional(),
+		collections: z.array(collectionSlug).max(100).optional(),
+	})
+	.strict()
+	.meta({ id: "UpdateTaxonomyDefBody" });
+
 // ---------------------------------------------------------------------------
 // Taxonomy terms: Input schemas
 // ---------------------------------------------------------------------------
 
 export const createTermBody = z
 	.object({
-		slug: z.string().min(1),
+		slug: z
+			.string()
+			.min(1)
+			.optional()
+			.meta({ description: "Term slug. Omit to derive a unique slug from the label." }),
 		label: z.string().min(1),
 		parentId: z.string().nullish(),
 		description: z.string().optional(),
@@ -55,6 +74,20 @@ export const updateTermBody = z
 	})
 	.meta({ id: "UpdateTermBody" });
 
+export const reorderTermsBody = z
+	.object({
+		parentId: z.string().min(1).nullish().meta({
+			description:
+				"Parent term whose children are being ordered (translation_group or row id). Omit or null for the top level, which for a flat taxonomy is every term.",
+		}),
+		ids: z.array(z.string().min(1)).max(100).meta({
+			description:
+				"Terms to move, in the desired order — each a row id or translation_group. May be a subset of the group: the listed terms are permuted within the positions they already occupy and every other member keeps its place. An id outside the group is rejected with REORDER_MISMATCH.",
+		}),
+	})
+	.strict()
+	.meta({ id: "ReorderTermsBody" });
+
 export const termListQuery = z
 	.object({
 		locale: localeCode.optional(),
@@ -67,6 +100,15 @@ export const termListQuery = z
 				description:
 					"Include each term's visible-usage count. Pass false to skip the aggregate; `count` is then absent from every term.",
 			}),
+		resolveFallback: z
+			.enum(["true", "false"])
+			.transform((value) => value === "true")
+			.optional()
+			.default(false)
+			.meta({
+				description:
+					"Resolve one term per translation group, preferring the requested locale and then the configured default locale.",
+			}),
 	})
 	.meta({ id: "TermListQuery" });
 
@@ -105,6 +147,10 @@ export const taxonomyListResponseSchema = z
 	.object({ taxonomies: z.array(taxonomyDefSchema) })
 	.meta({ id: "TaxonomyListResponse" });
 
+export const taxonomyResponseSchema = z
+	.object({ taxonomy: taxonomyDefSchema })
+	.meta({ id: "TaxonomyResponse" });
+
 export const termSchema = z
 	.object({
 		id: z.string(),
@@ -153,6 +199,10 @@ export const termListResponseSchema = z
 
 export const termResponseSchema = z.object({ term: termSchema }).meta({ id: "TermResponse" });
 
+export const termReorderResponseSchema = z
+	.object({ reordered: z.literal(true) })
+	.meta({ id: "TermReorderResponse" });
+
 export const termGetResponseSchema = z
 	.object({
 		term: termSchema.extend({

package/src/api/site-url.ts

@@ -1,19 +1,29 @@
 /**
  * Resolve the canonical site base URL for use in outbound links (emails, etc.).
  *
- * Uses the stored `emdash:site_url` (set during setup on the real domain)
- * so that Host header spoofing in later requests cannot redirect users to
- * attacker-controlled domains.
- *
- * Falls back to the request URL only if no stored value exists (pre-setup).
+ * Precedence mirrors `getPublicOrigin`: the operator-configured origin
+ * (`config.siteUrl`, then the `EMDASH_SITE_URL`/`SITE_URL` env vars) wins,
+ * then the stored `emdash:site_url` option (written once during setup on the
+ * real domain), and only before setup completes does the request URL fill in.
+ * A configured or stored value always beats the request, so Host header
+ * spoofing cannot redirect users to attacker-controlled domains.
  */
 
 import type { Kysely } from "kysely";
 
 import { OptionsRepository } from "../database/repositories/options.js";
 import type { Database } from "../database/types.js";
+import { getConfiguredOrigin, type SiteUrlConfig } from "./public-url.js";
 
-export async function getSiteBaseUrl(db: Kysely<Database>, request: Request): Promise<string> {
+export async function getSiteBaseUrl(
+	db: Kysely<Database>,
+	request: Request,
+	config?: SiteUrlConfig,
+): Promise<string> {
+	const configured = getConfiguredOrigin(config);
+	if (configured) {
+		return `${configured}/_emdash`;
+	}
 	const options = new OptionsRepository(db);
 	const storedUrl = await options.get<string>("emdash:site_url");
 	if (storedUrl) {

package/src/api/types.ts

@@ -41,6 +41,7 @@ export interface ManifestResponse {
 			label: string;
 			labelSingular: string;
 			supports: string[];
+			routable?: boolean;
 			fields: Record<string, FieldDescriptor>;
 		}
 	>;

package/src/astro/integration/index.ts

@@ -12,7 +12,7 @@
 
 import { createRequire } from "node:module";
 
-import type { AstroIntegration, AstroIntegrationLogger } from "astro";
+import type { AstroIntegration, AstroIntegrationLogger, AstroIntegrationMiddleware } from "astro";
 
 import { validateAllowedOrigins, validateOriginShape } from "../../auth/allowed-origins.js";
 import { INTERNAL_MEDIA_PREFIX } from "../../media/normalize.js";
@@ -253,6 +253,58 @@ function printDevServerInfo(baseUrl: string, mcpEnabled: boolean): void {
 	console.log("");
 }
 
+export function buildMiddlewareEntries(
+	config: Pick<EmDashConfig, "middleware" | "playground">,
+	root: URL,
+): AstroIntegrationMiddleware[] {
+	const entries: AstroIntegrationMiddleware[] = [];
+
+	if (config.middleware !== undefined) {
+		const configuredEntrypoint = config.middleware?.outer;
+		if (
+			(typeof configuredEntrypoint !== "string" && !(configuredEntrypoint instanceof URL)) ||
+			(typeof configuredEntrypoint === "string" && configuredEntrypoint.trim() === "")
+		) {
+			throw new Error("middleware.outer must be a non-empty module specifier string or URL.");
+		}
+		const entrypoint =
+			typeof configuredEntrypoint === "string" &&
+			(configuredEntrypoint.startsWith("./") || configuredEntrypoint.startsWith("../"))
+				? new URL(configuredEntrypoint, root)
+				: configuredEntrypoint;
+		entries.push({
+			entrypoint,
+			order: "pre",
+		});
+	}
+
+	if (config.playground) {
+		entries.push({
+			entrypoint: config.playground.middlewareEntrypoint,
+			order: "pre",
+		});
+	}
+
+	entries.push(
+		{ entrypoint: "emdash/middleware", order: "pre" },
+		{ entrypoint: "emdash/middleware/redirect", order: "pre" },
+	);
+
+	if (!config.playground) {
+		entries.push(
+			{ entrypoint: "emdash/middleware/setup", order: "pre" },
+			{ entrypoint: "emdash/middleware/auth", order: "pre" },
+		);
+	}
+
+	entries.push(
+		{ entrypoint: "emdash/middleware/media-usage-write-fence", order: "pre" },
+		{ entrypoint: "emdash/middleware/request-context", order: "pre" },
+	);
+
+	return entries;
+}
+
 /**
  * Create the EmDash Astro integration
  */
@@ -543,49 +595,10 @@ export function emdash(config: EmDashConfig = {}): AstroIntegration {
 					injectMcpRoute(injectRoute);
 				}
 
-				// In playground mode, inject the playground middleware FIRST.
-				// It sets up a per-session DO database in ALS before anything
-				// else runs, so the runtime init middleware sees a real DB.
-				if (resolvedConfig.playground) {
-					addMiddleware({
-						entrypoint: resolvedConfig.playground.middlewareEntrypoint,
-						order: "pre",
-					});
-				}
-
-				// Add middleware to provide database and manifest
-				addMiddleware({
-					entrypoint: "emdash/middleware",
-					order: "pre",
-				});
-
-				// Add redirect middleware (runs after runtime init, before setup/auth)
-				addMiddleware({
-					entrypoint: "emdash/middleware/redirect",
-					order: "pre",
-				});
-
-				// Skip setup and auth in playground mode -- the playground middleware
-				// handles session creation and injects an anonymous admin user.
-				if (!resolvedConfig.playground) {
-					addMiddleware({
-						entrypoint: "emdash/middleware/setup",
-						order: "pre",
-					});
-
-					addMiddleware({
-						entrypoint: "emdash/middleware/auth",
-						order: "pre",
-					});
+				for (const middleware of buildMiddlewareEntries(resolvedConfig, astroConfig.root)) {
+					addMiddleware(middleware);
 				}
 
-				// Add request context middleware (runs after auth, on ALL routes)
-				// Sets up ALS-based context for query functions (edit mode, preview)
-				addMiddleware({
-					entrypoint: "emdash/middleware/request-context",
-					order: "pre",
-				});
-
 				// Route info is printed with absolute, clickable URLs once the
 				// dev server is listening (see astro:server:setup), since the
 				// port isn't known yet here. Nothing useful to print for build.

package/src/astro/integration/routes.ts

@@ -249,6 +249,24 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/admin/media-usage/repair.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work",
+		entrypoint: resolveRoute("api/admin/media-usage/work/index.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/work/retry.ts"),
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/index.ts"),
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/retry.ts"),
+	});
+
 	// Import API routes
 	injectRoute({
 		pattern: "/_emdash/api/import/probe",
@@ -313,6 +331,15 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/schema/collections/index.ts"),
 	});
 
+	// Order matters: the static `reorder` route must precede the dynamic
+	// `[slug]` route so Astro's resolver dispatches POST
+	// /schema/collections/reorder to the reorder handler instead of treating
+	// "reorder" as a collection slug.
+	injectRoute({
+		pattern: "/_emdash/api/schema/collections/reorder",
+		entrypoint: resolveRoute("api/schema/collections/reorder.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/schema/collections/[slug]",
 		entrypoint: resolveRoute("api/schema/collections/[slug]/index.ts"),
@@ -389,6 +416,21 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/taxonomies/index.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]",
+		entrypoint: resolveRoute("api/taxonomies/[name].ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]/translations",
+		entrypoint: resolveRoute("api/taxonomies/[name]/translations.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]/reorder",
+		entrypoint: resolveRoute("api/taxonomies/[name]/reorder.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/taxonomies/[name]/terms",
 		entrypoint: resolveRoute("api/taxonomies/[name]/terms/index.ts"),
@@ -842,10 +884,12 @@ export function injectCoreRoutes(
 		});
 	}
 
-	injectRoute({
-		pattern: "/sitemap-[collection].xml",
-		entrypoint: resolveRoute("sitemap-[collection].xml.ts"),
-	});
+	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "sitemap-[collection].xml")) {
+		injectRoute({
+			pattern: "/sitemap-[collection].xml",
+			entrypoint: resolveRoute("sitemap-[collection].xml.ts"),
+		});
+	}
 
 	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "robots.txt")) {
 		injectRoute({

package/src/astro/integration/runtime.ts

@@ -7,6 +7,8 @@
  * DO NOT import Node.js-only modules here (fs, path, module, etc.)
  */
 
+import type { ManifestHookEntry, ManifestRouteEntry } from "@emdash-cms/plugin-types";
+
 import type { AuthDescriptor, AuthProviderDescriptor } from "../../auth/types.js";
 import type { DatabaseDescriptor } from "../../db/adapters.js";
 import type { MediaProviderDescriptor } from "../../media/types.js";
@@ -137,6 +139,17 @@ export interface PluginDescriptor<TOptions = Record<string, unknown>> {
 	storage?: Record<string, StorageCollectionDeclaration>;
 	/** Serialized MCP declarations emitted by the plugin build. */
 	mcp?: PluginMcpManifestConfig;
+	/**
+	 * Route declarations for sandboxed config-declared plugins. Mirrors
+	 * definePlugin({ routes }) and drives route auth decisions; omitted routes
+	 * default to non-public.
+	 */
+	routes?: Array<ManifestRouteEntry | string>;
+	/**
+	 * Hook declarations for sandboxed config-declared plugins. Mirrors
+	 * definePlugin({ hooks }).
+	 */
+	hooks?: Array<ManifestHookEntry | string>;
 }
 
 /**
@@ -465,6 +478,21 @@ export interface EmDashConfig {
 	 */
 	trustedProxyHeaders?: string[];
 
+	/**
+	 * User middleware that wraps the complete EmDash request pipeline.
+	 *
+	 * Before `next()` it runs before EmDash initializes its runtime or database,
+	 * so `locals.emdash`, the authenticated user, and request-scoped EmDash state
+	 * are unavailable. This allows cached responses and request gates to return
+	 * without paying initialization cost. When it calls `next()`, the resolved
+	 * response includes EmDash HTML injection and all other response mutations,
+	 * allowing the middleware to finalize caching and response headers safely.
+	 */
+	middleware?: {
+		/** Astro middleware module entrypoint. */
+		outer: string | URL;
+	};
+
 	/**
 	 * Enable playground mode for ephemeral "try EmDash" sites.
 	 *

package/src/astro/integration/virtual-modules.ts

@@ -72,6 +72,9 @@ export const RESOLVED_VIRTUAL_SCHEDULER_ID = "\0" + VIRTUAL_SCHEDULER_ID;
 export const VIRTUAL_ENV_ID = "virtual:emdash/env";
 export const RESOLVED_VIRTUAL_ENV_ID = "\0" + VIRTUAL_ENV_ID;
 
+export const VIRTUAL_BUILD_ID = "virtual:emdash/build";
+export const RESOLVED_VIRTUAL_BUILD_ID = "\0" + VIRTUAL_BUILD_ID;
+
 /**
  * Generates the config virtual module.
  */
@@ -97,14 +100,17 @@ export function generateDialectModule(opts: {
 	type?: string;
 	supportsRequestScope: boolean;
 	supportsCoalescing: boolean;
+	supportsCollectionDeletionGuard: boolean;
 }): string {
-	const { entrypoint, supportsRequestScope, supportsCoalescing } = opts;
+	const { entrypoint, supportsRequestScope, supportsCoalescing, supportsCollectionDeletionGuard } =
+		opts;
 	if (!entrypoint) {
 		return [
 			`export const createDialect = undefined;`,
 			`export const dialectType = "sqlite";`,
 			`export const createRequestScopedDb = (_opts) => null;`,
 			`export const createCoalescingDialect = undefined;`,
+			`export const executeCollectionDeletionGuard = undefined;`,
 		].join("\n");
 	}
 	const type = opts.type ?? "sqlite";
@@ -113,12 +119,16 @@ export function generateDialectModule(opts: {
 		? `import { createCoalescingDialect as _createCoalescingDialect } from "${entrypoint}";
 export const createCoalescingDialect = _createCoalescingDialect;`
 		: `export const createCoalescingDialect = undefined;`;
+	const collectionDeletionExport = supportsCollectionDeletionGuard
+		? `export { executeCollectionDeletionGuard } from "${entrypoint}";`
+		: `export const executeCollectionDeletionGuard = undefined;`;
 
 	if (supportsRequestScope) {
 		return `
 import { createDialect as _createDialect } from "${entrypoint}";
 export { createRequestScopedDb } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 `;
@@ -127,6 +137,7 @@ export const dialectType = ${JSON.stringify(type)};
 	return `
 import { createDialect as _createDialect } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 export const createRequestScopedDb = (_opts) => null;
@@ -497,6 +508,19 @@ export function generateEnvModule(adapterName: string | undefined): string {
 	return `export const env = undefined;`;
 }
 
+/**
+ * Generates the build virtual module.
+ *
+ * Content-hashed `/_astro/*` names make the response depend on the build, not
+ * only on the content. Exposing the build timestamp lets the middleware fold
+ * that dimension into the cache validator, so a code-only deploy stops
+ * answering conditional requests with 304 while the assets the cached HTML
+ * references are already gone.
+ */
+export function generateBuildModule(buildTime: number): string {
+	return `export const buildTime = ${buildTime};`;
+}
+
 /**
  * Generates the scheduler virtual module.
  *
@@ -673,6 +697,8 @@ export const sandboxedPlugins = [];
     allowedHosts: ${JSON.stringify(descriptor.allowedHosts ?? [])},
     storage: ${JSON.stringify(descriptor.storage ?? {})},
     mcp: ${JSON.stringify(descriptor.mcp)},
+    routes: ${JSON.stringify(descriptor.routes ?? [])},
+    hooks: ${JSON.stringify(descriptor.hooks ?? [])},
     adminPages: ${JSON.stringify(descriptor.adminPages ?? [])},
     adminWidgets: ${JSON.stringify(descriptor.adminWidgets ?? [])},
     settingsSchema: ${JSON.stringify(descriptor.settingsSchema)},