emdash 0.28.1 → 0.30.0

package/src/api/openapi/document.ts

@@ -37,13 +37,22 @@ import {
 	contentUpdateBody,
 	trashedContentListResponseSchema,
 } from "../schemas/content.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,
@@ -151,6 +160,7 @@ function standardErrors(
 		403: "Forbidden",
 		404: "Not Found",
 		409: "Conflict",
+		413: "Payload Too Large",
 		500: "Internal Server Error",
 	};
 	for (const code of codes) {
@@ -659,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),
 				},
 			},
 		},
@@ -675,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: {
@@ -722,6 +739,52 @@ 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",
+				summary: "Repair media usage indexes",
+				description:
+					"Repairs content media usage indexes for one collection or all collections. The request succeeds with HTTP 200 when a structured repair result is produced; inspect `data.status` because it may be `failed` or `stale`.",
+				tags: ["Media"],
+				requestBody: {
+					required: true,
+					content: { [JSON_CONTENT]: { schema: mediaUsageRepairBody } },
+				},
+				responses: {
+					"200": {
+						description: "Media usage repair result",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaUsageRepairResponseSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 413, 500),
+				},
+			},
+		},
 		"/_emdash/api/media/upload-url": {
 			post: {
 				operationId: "getMediaUploadUrl",
@@ -2326,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: [
 			{
@@ -2392,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

@@ -104,7 +104,7 @@ function validate<T extends z.ZodType>(schema: T, data: unknown): ParseResult<z.
 	const result = schema.safeParse(data);
 
 	if (result.success) {
-		return result.data as z.infer<T>;
+		return result.data;
 	}
 
 	// Format Zod errors into a readable structure
@@ -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/comments.ts

@@ -12,6 +12,12 @@ export const createCommentBody = z
 		parentId: z.string().optional(),
 		/** Honeypot field — hidden in the form, filled only by bots */
 		website_url: z.string().optional(),
+		/**
+		 * Turnstile response token from the form widget. Verified
+		 * server-side when a Turnstile secret key is configured.
+		 * Turnstile tokens can be up to 2048 characters.
+		 */
+		turnstileToken: z.string().max(2048).optional(),
 	})
 	.meta({ id: "CreateCommentBody" });
 

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/content.ts

@@ -59,6 +59,10 @@ export const contentCreateBody = z
 		locale: localeCode.optional(),
 		translationOf: z.string().optional(),
 		seo: contentSeoInput.optional(),
+		taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({
+			description:
+				"Taxonomy term assignments as { taxonomyName: [termSlug, ...] }, resolved in the entry's locale.",
+		}),
 		publishedAt: contentDateOverride,
 		createdAt: contentDateOverride,
 	})
@@ -77,6 +81,10 @@ export const contentUpdateBody = z
 			.meta({ description: "Opaque revision token for optimistic concurrency" }),
 		skipRevision: z.boolean().optional(),
 		seo: contentSeoInput.optional(),
+		taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({
+			description:
+				"Replace taxonomy assignments as { taxonomyName: [termSlug, ...] }. Only named taxonomies are touched; pass an empty array to clear a taxonomy.",
+		}),
 		publishedAt: contentDateOverride,
 	})
 	.meta({ id: "ContentUpdateBody" });

package/src/api/schemas/index.ts

@@ -1,6 +1,7 @@
 export * from "./common.js";
 export * from "./content.js";
 export * from "./media.js";
+export * from "./media-usage.js";
 export * from "./schema.js";
 export * from "./comments.js";
 export * from "./auth.js";
@@ -16,3 +17,4 @@ export * from "./widgets.js";
 export * from "./redirects.js";
 export * from "./bylines.js";
 export * from "./byline-fields.js";
+export * from "./relations.js";

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

@@ -0,0 +1,120 @@
+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" });
+
+const mediaUsageRepairCollectionBody = z
+	.object({
+		scope: z.literal("collection"),
+		collection: z.string().min(1).max(63).regex(slugPattern, "Invalid collection slug"),
+	})
+	.strict();
+
+const mediaUsageRepairAllBody = z.object({ scope: z.literal("all") }).strict();
+
+export const mediaUsageRepairBody = z
+	.discriminatedUnion("scope", [mediaUsageRepairCollectionBody, mediaUsageRepairAllBody])
+	.meta({ id: "MediaUsageRepairBody" });
+
+export const mediaUsageRepairCollectionSummarySchema = z
+	.object({
+		collection: z.string(),
+		status: mediaUsageRepairStatusSchema,
+		indexedSourceCount: z.number().int().min(0),
+		failedSourceCount: z.number().int().min(0),
+		skippedSourceCount: z.number().int().min(0),
+		deletedSourceCount: z.number().int().min(0),
+		lastErrorCode: z.string().nullable(),
+		startedAt: z.string(),
+		completedAt: z.string().nullable(),
+	})
+	.meta({ id: "MediaUsageRepairCollectionSummary" });
+
+export const mediaUsageRepairResponseSchema = z
+	.object({
+		status: mediaUsageRepairStatusSchema,
+		indexedSourceCount: z.number().int().min(0),
+		failedSourceCount: z.number().int().min(0),
+		skippedSourceCount: z.number().int().min(0),
+		deletedSourceCount: z.number().int().min(0),
+		collections: z.array(mediaUsageRepairCollectionSummarySchema),
+	})
+	.meta({ id: "MediaUsageRepairResponse" });
+
+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/api/schemas/relations.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+
+const slugPattern = /^[a-z][a-z0-9_]*$/;
+const collectionSlug = z
+	.string()
+	.min(1)
+	.max(63)
+	.regex(slugPattern, "Invalid collection slug format");
+
+export const createRelationBody = z
+	.object({
+		name: z
+			.string()
+			.min(1)
+			.max(63)
+			.regex(slugPattern, "Name must be lowercase alphanumeric with underscores"),
+		parentCollection: collectionSlug.optional(),
+		childCollection: collectionSlug.optional(),
+		parentLabel: z.string().min(1).max(200),
+		childLabel: z.string().min(1).max(200),
+		locale: z.string().min(1).optional(),
+		translationOf: z.string().min(1).optional(),
+	})
+	// A translation inherits its structural fields (name, parentCollection,
+	// childCollection) from the source relation, so the handler ignores any
+	// collections supplied alongside `translationOf`. Require them only when
+	// minting a base relation, so callers aren't forced to pass discarded values.
+	.refine(
+		(body) =>
+			body.translationOf !== undefined ||
+			(body.parentCollection !== undefined && body.childCollection !== undefined),
+		{ message: "parentCollection and childCollection are required unless translationOf is set" },
+	)
+	.meta({ id: "CreateRelationBody" });
+
+export const updateRelationBody = z
+	.object({
+		parentLabel: z.string().min(1).max(200).optional(),
+		childLabel: z.string().min(1).max(200).optional(),
+	})
+	// Reject empty payloads: an update touching no field is a client mistake, not
+	// a successful no-op. Without this, `{}` validates and the handler returns 200
+	// with the unchanged row, so a typo'd payload looks like it landed.
+	.refine((body) => body.parentLabel !== undefined || body.childLabel !== undefined, {
+		message: "At least one of parentLabel or childLabel is required",
+	})
+	.meta({ id: "UpdateRelationBody" });
+
+export const setReferenceChildrenBody = z
+	.object({ childIds: z.array(z.string().min(1)).max(1000) })
+	.meta({ id: "SetReferenceChildrenBody" });
+
+export const relationDefSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		parentCollection: z.string(),
+		childCollection: z.string(),
+		parentLabel: z.string(),
+		childLabel: z.string(),
+		locale: z.string(),
+		translationGroup: z.string(),
+	})
+	.meta({ id: "RelationDef" });
+
+export const relationListResponseSchema = z
+	.object({ relations: z.array(relationDefSchema) })
+	.meta({ id: "RelationListResponse" });
+
+export const relationResponseSchema = z
+	.object({ relation: relationDefSchema })
+	.meta({ id: "RelationResponse" });
+
+export const relationTranslationsSchema = z
+	.object({
+		translationGroup: z.string(),
+		translations: z.array(
+			z.object({
+				id: z.string(),
+				name: z.string(),
+				locale: z.string(),
+				parentLabel: z.string(),
+				childLabel: z.string(),
+			}),
+		),
+	})
+	.meta({ id: "RelationTranslations" });
+
+export const entryRefSchema = z
+	.object({
+		id: z.string(),
+		slug: z.string().nullable(),
+		collection: z.string(),
+		// The actual locale of the resolved variant. When no variant matches the
+		// requesting entry's locale, the ref falls back to another locale's row;
+		// this field makes that substitution explicit instead of silently
+		// presenting a wrong-locale entry under the requested context.
+		locale: z.string().nullable(),
+		sortOrder: z.number().int().optional(),
+	})
+	.meta({ id: "ReferenceEntryRef" });
+
+export const referenceChildrenResponseSchema = z
+	.object({ children: z.array(entryRefSchema), nextCursor: z.string().optional() })
+	.meta({ id: "ReferenceChildrenResponse" });
+
+export const referenceParentsResponseSchema = z
+	.object({ parents: z.array(entryRefSchema), nextCursor: z.string().optional() })
+	.meta({ id: "ReferenceParentsResponse" });

package/src/api/schemas/search.ts

@@ -13,6 +13,7 @@ export const searchQuery = z
 		status: z.string().optional(),
 		locale: localeCode.optional(),
 		limit: z.coerce.number().int().min(1).max(100).optional(),
+		cursor: z.string().optional(),
 	})
 	.meta({ id: "SearchQuery" });
 

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`;
@@ -350,6 +378,7 @@ export function emdash(config: EmDashConfig = {}): AstroIntegration {
 		trustedProxyHeaders: resolvedConfig.trustedProxyHeaders,
 		maxUploadSize: resolvedConfig.maxUploadSize,
 		admin: resolvedConfig.admin,
+		toolbar: resolvedConfig.toolbar,
 	};
 
 	// Determine auth mode for route injection
@@ -380,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) {
@@ -555,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