emdash 0.33.0 → 0.34.0

package/src/astro/middleware.ts

@@ -5,10 +5,13 @@
  * All heavy lifting happens in EmDashRuntime.
  */
 
+import type { APIContext } from "astro";
 import { defineMiddleware } from "astro:middleware";
 import type { Kysely } from "kysely";
 // Import from virtual modules (populated by integration at build time)
 // @ts-ignore - virtual module
+import { buildTime as virtualBuildTime } from "virtual:emdash/build";
+// @ts-ignore - virtual module
 import virtualConfig from "virtual:emdash/config";
 // @ts-ignore - virtual module
 import {
@@ -36,9 +39,11 @@ import {
 	flushRecorder,
 	isInstrumentationEnabled,
 } from "../database/instrumentation.js";
+import { createDeferredTaskTracker } from "../deferred-tasks.js";
 import {
 	DB_INIT_DEADLINE_MS,
 	EmDashRuntime,
+	type MediaUsageMaintenanceResult,
 	type RuntimeDependencies,
 	type SandboxedPluginEntry,
 	type MediaProviderEntry,
@@ -284,6 +289,12 @@ export async function runScheduledTasks(
 	return runOutsideRequest(config, (runtime) => runtime.runScheduledTasks(options));
 }
 
+export async function runScheduledMediaUsageTasks(): Promise<MediaUsageMaintenanceResult> {
+	const config = getConfig();
+	if (!config) return { outcome: "inactive", taskClass: null, turn: null };
+	return runOutsideRequest(config, (runtime) => runtime.runScheduledMediaUsageTasks());
+}
+
 /**
  * Run a callback against the EmDash runtime outside any HTTP request — from a
  * Cloudflare Queue consumer, a `scheduled()` handler, or any other
@@ -334,23 +345,50 @@ export async function withEmDashRuntime<T>(
 /**
  * Shared plumbing for request-free entry points (`runScheduledTasks`,
  * `withEmDashRuntime`): resolve the runtime singleton, then run the callback
- * under an event-scoped db connection when the adapter needs one.
+ * under an event-scoped db when the adapter needs one.
  *
  * Connection-backed adapters (e.g. Postgres over Hyperdrive) cannot reuse
  * the per-isolate singleton from a platform event: its socket belongs to the
  * request that opened it, and workerd rejects cross-event I/O. Open an
  * event-scoped connection and run the callback under it in ALS — the
  * runtime's db getter, the cron executor, and plugin contexts all resolve
- * the connection from ALS — then close it. Gated on the adapter being
- * connection-backed (it exposes `close()`); stateless adapters (D1, Node
- * SQLite) return null or a close-less scope and keep using the singleton.
+ * the connection from ALS — then close it when required. Stateless adapters
+ * that need primary routing can return a close-less scope; adapters with no
+ * event scoping return null and keep using the singleton.
  */
 async function runOutsideRequest<T>(
 	config: EmDashConfig,
 	fn: (runtime: EmDashRuntime) => Promise<T>,
 ): Promise<T> {
-	const runtime = await getRuntime(config);
+	if (getRequestContext()) {
+		const runtime = await getRuntime(config);
+		return runOutsideRequestWithRuntime(config, runtime, fn);
+	}
+
+	const deferredTasks = createDeferredTaskTracker(() => {});
+	const context = {
+		editMode: false,
+		metrics: createRequestMetrics(performance.now()),
+		deferredTasks,
+	};
+	return runWithContext(context, async () => {
+		const runtime = await (async () => {
+			try {
+				return await getRuntime(config);
+			} finally {
+				deferredTasks.settle();
+				await deferredTasks.settled;
+			}
+		})();
+		return runOutsideRequestWithRuntime(config, runtime, fn);
+	});
+}
 
+async function runOutsideRequestWithRuntime<T>(
+	config: EmDashConfig,
+	runtime: EmDashRuntime,
+	fn: (runtime: EmDashRuntime) => Promise<T>,
+): Promise<T> {
 	const scoped = createRequestScopedDb({
 		config: config.database?.config,
 		isAuthenticated: false,
@@ -361,9 +399,8 @@ async function runOutsideRequest<T>(
 		cookies: NOOP_COOKIE_JAR,
 		url: CRON_EVENT_URL,
 	});
-	if (!scoped?.close) {
-		// Stateless adapter (or no per-request scoping): the singleton is safe
-		// outside a request. Any close-less scope created above is discarded.
+	if (!scoped) {
+		// This adapter needs no event-specific routing or connection.
 		return fn(runtime);
 	}
 	const { closed, deferredTasks, lifecycle } = coordinateScopedDbLifecycle(scoped);
@@ -509,6 +546,34 @@ function createRequestScopedDb(
 	return fn(opts);
 }
 
+const buildDate = virtualBuildTime ? new Date(virtualBuildTime) : null;
+
+/**
+ * Fold the build timestamp into the route cache validator.
+ *
+ * `CacheHint.lastModified` describes the content, but the response also depends
+ * on the build: `/_astro/*` names are content-hashed, and a deployment only
+ * serves its own. Without the build dimension a code-only deploy answers a
+ * returning visitor's conditional request with 304, leaving them on HTML whose
+ * assets 404.
+ *
+ * Prerendered pages are served by the host's static layer, which manages its
+ * own validators — only on-demand responses need the build dimension.
+ *
+ * Only forward moves are covered. `Last-Modified` expresses newer, not
+ * different, so after a rollback the earlier build still answers a conditional
+ * request with 304 and the browser stays on the newer build's HTML.
+ *
+ * Must run before next(): Astro keeps the later of two dates, so a route's own
+ * hint still wins when content is newer, and a route that opts out with
+ * `Astro.cache.set(false)` stays opted out — calling set() afterwards would
+ * clear that opt-out.
+ */
+function applyBuildValidator(context: APIContext): void {
+	if (context.isPrerendered || !buildDate || !context.cache?.enabled) return;
+	context.cache.set({ lastModified: buildDate });
+}
+
 export const onRequest = defineMiddleware(async (context, next) => {
 	const { request, locals, cookies } = context;
 	const url = context.url;
@@ -527,6 +592,8 @@ export const onRequest = defineMiddleware(async (context, next) => {
 		}
 	}
 
+	applyBuildValidator(context);
+
 	const queryRecorder = isInstrumentationEnabled()
 		? createRecorder(url.pathname, request.method, request.headers.get("x-perf-phase") ?? "default")
 		: undefined;

package/src/astro/routes/api/admin/media-usage/collection-deletions/index.ts

@@ -0,0 +1,22 @@
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleMediaUsageCollectionDeletionList } from "#api/handlers/media-usage-work.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { mediaUsageCollectionDeletionListQuery } from "#api/schemas.js";
+import { requireScope } from "#auth/scopes.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ request, locals }) => {
+	const dbErr = requireDb(locals.emdash?.db);
+	if (dbErr) return dbErr;
+	const denied = requirePerm(locals.user, "schema:manage");
+	if (denied) return denied;
+	const scopeDenied = requireScope(locals, "admin");
+	if (scopeDenied) return scopeDenied;
+	const query = parseQuery(new URL(request.url), mediaUsageCollectionDeletionListQuery);
+	if (isParseError(query)) return query;
+	return unwrapResult(await handleMediaUsageCollectionDeletionList(locals.emdash.db, query));
+};

package/src/astro/routes/api/admin/media-usage/collection-deletions/retry.ts

@@ -0,0 +1,22 @@
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleMediaUsageCollectionDeletionRetry } from "#api/handlers/media-usage-work.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { mediaUsageCollectionDeletionRetryBody } from "#api/schemas.js";
+import { requireScope } from "#auth/scopes.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const dbErr = requireDb(locals.emdash?.db);
+	if (dbErr) return dbErr;
+	const denied = requirePerm(locals.user, "schema:manage");
+	if (denied) return denied;
+	const scopeDenied = requireScope(locals, "admin");
+	if (scopeDenied) return scopeDenied;
+	const body = await parseBody(request, mediaUsageCollectionDeletionRetryBody);
+	if (isParseError(body)) return body;
+	return unwrapResult(await handleMediaUsageCollectionDeletionRetry(locals.emdash.db, body));
+};

package/src/astro/routes/api/admin/media-usage/work/index.ts

@@ -0,0 +1,26 @@
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleMediaUsageWorkList } from "#api/handlers/media-usage-work.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { mediaUsageWorkListQuery } from "#api/schemas.js";
+import { requireScope } from "#auth/scopes.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+	const scopeDenied = requireScope(locals, "admin");
+	if (scopeDenied) return scopeDenied;
+
+	const query = parseQuery(new URL(request.url), mediaUsageWorkListQuery);
+	if (isParseError(query)) return query;
+
+	return unwrapResult(await handleMediaUsageWorkList(emdash.db, query));
+};

package/src/astro/routes/api/admin/media-usage/work/retry.ts

@@ -0,0 +1,26 @@
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleMediaUsageWorkRetry } from "#api/handlers/media-usage-work.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { mediaUsageWorkRetryBody } from "#api/schemas.js";
+import { requireScope } from "#auth/scopes.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+	const scopeDenied = requireScope(locals, "admin");
+	if (scopeDenied) return scopeDenied;
+
+	const body = await parseBody(request, mediaUsageWorkRetryBody);
+	if (isParseError(body)) return body;
+
+	return unwrapResult(await handleMediaUsageWorkRetry(emdash.db, body));
+};

package/src/astro/routes/api/admin/plugins/[id]/disable.ts

@@ -9,6 +9,7 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, unwrapResult } from "#api/error.js";
 import { handlePluginDisable } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { setCronTasksEnabled } from "#plugins/cron.js";
 
 export const prerender = false;
@@ -24,6 +25,9 @@ export const POST: APIRoute = async ({ params, locals }) => {
 	const denied = requirePerm(user, "plugins:manage");
 	if (denied) return denied;
 
+	const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+	if (activationFence) return activationFence;
+
 	if (!id) {
 		return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 	}

package/src/astro/routes/api/admin/plugins/[id]/enable.ts

@@ -9,6 +9,7 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, unwrapResult } from "#api/error.js";
 import { handlePluginEnable } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { setCronTasksEnabled } from "#plugins/cron.js";
 
 export const prerender = false;
@@ -24,6 +25,9 @@ export const POST: APIRoute = async ({ params, locals }) => {
 	const denied = requirePerm(user, "plugins:manage");
 	if (denied) return denied;
 
+	const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+	if (activationFence) return activationFence;
+
 	if (!id) {
 		return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 	}

package/src/astro/routes/api/admin/plugins/[id]/uninstall.ts

@@ -10,6 +10,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, unwrapResult } from "#api/error.js";
 import { handleMarketplaceUninstall } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 
 export const prerender = false;
@@ -29,6 +30,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "plugins:manage");
 	if (denied) return denied;
 
+	const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+	if (activationFence) return activationFence;
+
 	if (!id) {
 		return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 	}

package/src/astro/routes/api/admin/plugins/[id]/update.ts

@@ -10,6 +10,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, unwrapResult } from "#api/error.js";
 import { handleMarketplaceUpdate } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 
 export const prerender = false;
@@ -32,6 +33,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "plugins:manage");
 	if (denied) return denied;
 
+	const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+	if (activationFence) return activationFence;
+
 	if (!id) {
 		return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 	}

package/src/astro/routes/api/admin/plugins/marketplace/[id]/install.ts

@@ -10,6 +10,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, unwrapResult } from "#api/error.js";
 import { handleMarketplaceInstall } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 
 export const prerender = false;
@@ -31,6 +32,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		const denied = requirePerm(user, "plugins:manage");
 		if (denied) return denied;
 
+		const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+		if (activationFence) return activationFence;
+
 		if (!id) {
 			return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 		}

package/src/astro/routes/api/admin/plugins/registry/[id]/uninstall.ts

@@ -13,6 +13,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, unwrapResult } from "#api/error.js";
 import { handleRegistryUninstall } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 
 export const prerender = false;
@@ -32,6 +33,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "plugins:manage");
 	if (denied) return denied;
 
+	const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+	if (activationFence) return activationFence;
+
 	if (!id) {
 		return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 	}

package/src/astro/routes/api/admin/plugins/registry/[id]/update.ts

@@ -16,6 +16,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, unwrapResult } from "#api/error.js";
 import { handleRegistryUpdate } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 
 import { VERSION } from "../../../../../../../version.js";
@@ -51,6 +52,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		const denied = requirePerm(user, "plugins:manage");
 		if (denied) return denied;
 
+		const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+		if (activationFence) return activationFence;
+
 		if (!id) {
 			return apiError("INVALID_REQUEST", "Plugin ID required", 400);
 		}

package/src/astro/routes/api/admin/plugins/registry/install.ts

@@ -19,6 +19,7 @@ import { z } from "zod";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, unwrapResult } from "#api/error.js";
 import { handleRegistryInstall } from "#api/index.js";
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
 import { isParseError, parseBody } from "#api/parse.js";
 
 import { VERSION } from "../../../../../../version.js";
@@ -71,6 +72,9 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		const denied = requirePerm(user, "plugins:manage");
 		if (denied) return denied;
 
+		const activationFence = await checkMediaUsageActivationWriteFence(emdash.db);
+		if (activationFence) return activationFence;
+
 		const body = await parseBody(request, installBodySchema);
 		if (isParseError(body)) return body;
 

package/src/astro/routes/api/content/[collection]/[id]/terms/[taxonomy].ts

@@ -12,11 +12,48 @@ import { apiError, apiSuccess, handleError, requireDb } from "#api/error.js";
 import { parseBody, isParseError } from "#api/parse.js";
 import { contentTermsBody } from "#api/schemas.js";
 import { ContentRepository } from "#db/repositories/content.js";
-import { TaxonomyRepository } from "#db/repositories/taxonomy.js";
+import {
+	TaxonomyRepository,
+	type TaxonomyAssignmentResolution,
+} from "#db/repositories/taxonomy.js";
 import { invalidateTermCache } from "#taxonomies/index.js";
 
+import { getI18nConfig } from "../../../../../../../i18n/config.js";
+
 export const prerender = false;
 
+function assignmentResponse(assignments: TaxonomyAssignmentResolution[], entryLocale: string) {
+	const config = getI18nConfig();
+	const defaultLocale = config?.defaultLocale ?? "en";
+	return {
+		terms: assignments.flatMap(({ term }) =>
+			term
+				? [
+						{
+							id: term.id,
+							name: term.name,
+							slug: term.slug,
+							label: term.label,
+							parentId: term.parentId,
+							locale: term.locale,
+							translationGroup: term.translationGroup,
+						},
+					]
+				: [],
+		),
+		unresolved: assignments
+			.filter(({ term }) => term === null)
+			.map(({ translationGroup, availableLocales, translations }) => ({
+				translationGroup,
+				availableLocales,
+				translations,
+			})),
+		entryLocale,
+		defaultLocale,
+		implicitDefaultLocale: config === null,
+	};
+}
+
 /**
  * Get terms assigned to an entry
  */
@@ -34,26 +71,24 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	}
 
 	try {
-		// Terms are stored against the per-locale entry row but their
-		// translation_group spans every locale. Resolve the entry's own locale
-		// server-side (deterministic, not client-spoofable) so only the matching
-		// term variant is returned — see issue #1218.
+		// Assignments store content and term translation groups. Resolve the
+		// entry's locale server-side so the response includes only that locale's
+		// term variant.
 		const entry = await new ContentRepository(emdash.db).findByIdOrSlug(collection, id);
 		if (!entry) return apiError("NOT_FOUND", "Content not found", 404);
-		const locale = entry.locale ?? undefined;
+		const locale = entry.locale || getI18nConfig()?.defaultLocale || "en";
+		const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
 
 		const repo = new TaxonomyRepository(emdash.db);
-		const terms = await repo.getTermsForEntry(collection, entry.id, taxonomy, locale);
-
-		return apiSuccess({
-			terms: terms.map((t) => ({
-				id: t.id,
-				name: t.name,
-				slug: t.slug,
-				label: t.label,
-				parentId: t.parentId,
-			})),
-		});
+		const assignments = await repo.getTermAssignmentsForEntry(
+			collection,
+			entry.id,
+			taxonomy,
+			locale,
+			defaultLocale,
+		);
+
+		return apiSuccess(assignmentResponse(assignments, locale));
 	} catch (error) {
 		return handleError(error, "Failed to get entry terms", "TERMS_GET_ERROR");
 	}
@@ -108,9 +143,12 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	// Resolve the canonical content ID from the handler result.
 	// The URL `id` param may be a slug; we must use the real ID for term storage.
 	const canonicalId = typeof existingItem?.id === "string" ? existingItem.id : id;
-	// The entry is per-locale; scope the term read to its locale so only the
-	// matching translation variant is returned in the response — see #1218.
-	const entryLocale = typeof existingItem?.locale === "string" ? existingItem.locale : undefined;
+	// The assignment spans the content translation group, while the response
+	// includes only the term variant matching this entry's locale.
+	const entryLocale =
+		typeof existingItem?.locale === "string"
+			? existingItem.locale
+			: (getI18nConfig()?.defaultLocale ?? "en");
 
 	try {
 		const body = await parseBody(request, contentTermsBody);
@@ -142,17 +180,15 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		invalidateTermCache();
 
 		// Get the updated terms using the canonical ID, scoped to the entry locale
-		const terms = await repo.getTermsForEntry(collection, canonicalId, taxonomy, entryLocale);
-
-		return apiSuccess({
-			terms: terms.map((t) => ({
-				id: t.id,
-				name: t.name,
-				slug: t.slug,
-				label: t.label,
-				parentId: t.parentId,
-			})),
-		});
+		const assignments = await repo.getTermAssignmentsForEntry(
+			collection,
+			canonicalId,
+			taxonomy,
+			entryLocale,
+			getI18nConfig()?.defaultLocale ?? "en",
+		);
+
+		return apiSuccess(assignmentResponse(assignments, entryLocale));
 	} catch (error) {
 		return handleError(error, "Failed to set entry terms", "TERMS_SET_ERROR");
 	}

package/src/astro/routes/api/import/wordpress/execute.ts

@@ -395,16 +395,9 @@ export async function importContent(
 				// Anchors (no `translationOf`) get an additive attach -- the
 				// row is fresh, no inherited pivots to consider.
 				//
-				// Translations get per-taxonomy replace semantics. WPML's
-				// "Translate Independently" mode is per-taxonomy, not per-
-				// post: a translation that overrides `category` shouldn't
-				// lose its inherited `tag` or `genre`. The replace path
-				// only touches taxonomies the translation actually carries
-				// AND that resolve to at least one term that survives the
-				// def's `collections` filter; taxonomies with no resolved
-				// terms (missing-def, dropped by filter, or just absent
-				// from the WXR) fall through with the inherited set intact
-				// from `copyEntryTerms`.
+				// Translations replace only taxonomies they explicitly carry.
+				// Since assignments belong to the content translation_group,
+				// that replacement is reflected in every sibling locale.
 				if (createdItem) {
 					try {
 						const written = translationOf

package/src/astro/routes/api/mcp.ts

@@ -48,6 +48,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 				scopes: [],
 				extra: {
 					emdash,
+					user,
 					userId: user.id,
 					userRole: user.role,
 					tokenScopes: locals.tokenScopes,

package/src/astro/routes/api/plugins/[pluginId]/[...path].ts

@@ -73,7 +73,13 @@ const handleRequest: APIRoute = async ({ params, request, locals }) => {
 		}
 	}
 
-	const result = await emdash.handlePluginApiRoute(pluginId, method, `/${path}`, request);
+	// Forward the caller only for private routes: it was validated by the
+	// requirePerm/requireScope checks above, so plugins can trust ctx.user.
+	// Public routes skip auth, so no caller is bound even when an ambient
+	// session happens to exist.
+	const caller = routeMeta.public ? undefined : user;
+
+	const result = await emdash.handlePluginApiRoute(pluginId, method, `/${path}`, request, caller);
 
 	if (!result.success) {
 		const code = result.error?.code ?? "PLUGIN_ERROR";

package/src/astro/routes/api/schema/collections/[slug]/index.ts

@@ -17,7 +17,6 @@ import {
 } from "#api/index.js";
 import { parseBody, parseQuery, isParseError } from "#api/parse.js";
 import { collectionGetQuery, updateCollectionBody } from "#api/schemas.js";
-import type { UpdateCollectionInput } from "#schema/types.js";
 
 export const prerender = false;
 
@@ -53,12 +52,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const body = await parseBody(request, updateCollectionBody);
 	if (isParseError(body)) return body;
 
-	const result = await handleSchemaCollectionUpdate(
-		emdash.db,
-		slug,
-		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- parseBody validates via Zod
-		body as UpdateCollectionInput,
-	);
+	const result = await handleSchemaCollectionUpdate(emdash.db, slug, body);
 	emdash.invalidateUrlPatternCache();
 	return unwrapResult(result);
 };

package/src/astro/routes/api/taxonomies/[name]/terms/index.ts

@@ -36,6 +36,7 @@ export const GET: APIRoute = async ({ params, request, locals }) => {
 		const result = await handleTermList(emdash.db, name, {
 			locale: query.locale,
 			includeCounts: query.includeCounts,
+			resolveFallback: query.resolveFallback,
 		});
 		return unwrapResult(result);
 	} catch (error) {

package/src/astro/routes/api/taxonomies/[name]/translations.ts

@@ -0,0 +1,48 @@
+/**
+ * Taxonomy definition translation endpoints
+ *
+ * GET /_emdash/api/taxonomies/:name/translations[?locale=xx]
+ *
+ * Creating a translation goes through `POST /_emdash/api/taxonomies` with
+ * `translationOf`, so there is no POST here.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleTaxonomyDefTranslations, handleTaxonomyGet } from "#api/handlers/taxonomies.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { localeFilterQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { name } = params;
+	if (!name) return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "taxonomies:read");
+	if (denied) return denied;
+
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
+	try {
+		// Any locale's row will do — they share the translation_group the list is
+		// built from.
+		const anchor = await handleTaxonomyGet(emdash.db, name, { locale: query.locale });
+		if (!anchor.success) return unwrapResult(anchor);
+		const result = await handleTaxonomyDefTranslations(emdash.db, anchor.data.taxonomy.id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(
+			error,
+			"Failed to list taxonomy translations",
+			"TAXONOMY_TRANSLATIONS_ERROR",
+		);
+	}
+};