emdash 0.17.2 → 0.19.0

package/src/index.ts

@@ -46,6 +46,7 @@ export type {
 // API handlers
 export {
 	handleContentList,
+	handleContentAuthors,
 	handleContentGet,
 	handleContentGetIncludingTrashed,
 	handleContentCreate,
@@ -201,6 +202,8 @@ export {
 	PluginManager,
 	createPluginManager,
 	PluginRouteError,
+	// Scheduler (Node timer heartbeat — used by virtual:emdash/scheduler)
+	NodeCronScheduler,
 	// Sandbox
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
@@ -253,6 +256,10 @@ export type {
 	CollectionCommentSettings,
 	StoredComment,
 
+	// Scheduler types
+	CronScheduler,
+	SystemCleanupFn,
+
 	// Sandbox runtime types
 	SandboxRunner,
 	SandboxedPluginInstance,
@@ -406,7 +413,7 @@ export type {
 } from "./menus/types.js";
 
 // Bylines
-export { getByline, getBylineBySlug } from "./bylines/index.js";
+export { getByline, getBylineBySlug, getEntriesByByline } from "./bylines/index.js";
 export type { BylineSummary, ContentBylineCredit } from "./database/repositories/types.js";
 
 // Taxonomies

package/src/loader.ts

@@ -540,12 +540,16 @@ export interface CollectionFilter {
 	 */
 	cursor?: string;
 	/**
-	 * Filter by field values, taxonomy terms, or ranges.
+	 * Filter by field values, taxonomy terms, byline credits, or ranges.
 	 *
 	 * Taxonomy names are detected automatically and filtered via JOIN.
+	 * The reserved `byline` key filters by byline credit (any credit, not
+	 * just the primary one) via the `_emdash_content_bylines` junction
+	 * table; its value is one or more byline translation groups.
 	 * Other keys are treated as column filters on the content table.
 	 *
 	 * @example { category: 'news' } - taxonomy term
+	 * @example { byline: '01HXYZ...' } - entries credited to a byline (any position)
 	 * @example { series: 'main' } - exact match on a content field
 	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - date range
 	 */
@@ -673,13 +677,16 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Build cursor condition if cursor is provided
 				const cursorCondition = cursor ? buildCursorCondition(cursor, orderBy) : null;
-				const cursorConditionPrefixed = cursor
-					? buildCursorCondition(cursor, orderBy, tableName)
-					: null;
 
-				// Separate taxonomy filters from field filters
+				// Separate taxonomy / byline filters from field filters
 				let result: { rows: Record<string, unknown>[] };
 				let taxonomyFilter: { name: string; slugs: string[] } | null = null;
+				// A byline filter matches entries credited to any of the given
+				// byline translation groups via the `_emdash_content_bylines`
+				// junction table. `null` means no byline filter; an empty
+				// `groups` array means the filter was requested but matches
+				// nothing (short-circuited to an empty result below).
+				let bylineFilter: { groups: string[] } | null = null;
 				const fieldFilters: Record<string, WhereValue> = {};
 
 				if (where && Object.keys(where).length > 0) {
@@ -687,7 +694,16 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 					for (const [key, value] of Object.entries(where)) {
 						if (value == null) continue;
-						if (taxNames.has(key)) {
+						if (key === "byline") {
+							if (isWhereRange(value)) {
+								console.warn(
+									`[emdash] where filter: range operators are not supported on "byline", ignored`,
+								);
+								continue;
+							}
+							const groups = Array.isArray(value) ? value : [value];
+							bylineFilter = { groups };
+						} else if (taxNames.has(key)) {
 							if (isWhereRange(value)) {
 								console.warn(
 									`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`,
@@ -708,35 +724,27 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					}
 				}
 
-				if (taxonomyFilter) {
-					const orderByClause = buildOrderByClause(orderBy, tableName);
-					const statusCondition = buildStatusCondition(db, status, tableName);
-					const localeCondition = locale
-						? sql`AND ${sql.ref(tableName)}.locale = ${locale}`
-						: sql``;
-					const cursorCond = cursorConditionPrefixed ? sql`AND ${cursorConditionPrefixed}` : sql``;
-					const fieldConds = buildFieldConditions(fieldFilters, tableName);
-					const fieldCondsSQL =
-						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
+				// A byline or taxonomy filter with no values matches nothing —
+				// short-circuit before building SQL (an empty `IN ()` is invalid
+				// SQL on both dialects).
+				if (
+					(bylineFilter && bylineFilter.groups.length === 0) ||
+					(taxonomyFilter && taxonomyFilter.slugs.length === 0)
+				) {
+					return { entries: [], cacheHint: { tags: [type] } };
+				}
 
-					result = await sql<Record<string, unknown>>`
-						SELECT DISTINCT ${sql.ref(tableName)}.* FROM ${sql.ref(tableName)}
-						INNER JOIN content_taxonomies ct
-							ON ct.collection = ${type}
-							AND ct.entry_id = ${sql.ref(tableName)}.id
-						INNER JOIN taxonomies t
-							ON t.id = ct.taxonomy_id
-						WHERE ${sql.ref(tableName)}.deleted_at IS NULL
-							AND ${statusCondition}
-							${localeCondition}
-							${cursorCond}
-							AND t.name = ${taxonomyFilter.name}
-							AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
-							${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
-						${orderByClause}
-						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
-					`.execute(db);
-				} else {
+				{
+					// Taxonomy and byline filters are applied as correlated
+					// `EXISTS` semi-joins rather than `INNER JOIN ... DISTINCT`.
+					// A join fan-out would force `SELECT DISTINCT table.*`, and
+					// Postgres cannot apply DISTINCT to a row containing a `json`
+					// column (no equality operator), so the join approach throws
+					// there. EXISTS matches "credited/tagged at least once"
+					// without duplicating rows, needs no DISTINCT, and works on
+					// both SQLite and Postgres. The base query stays a single-
+					// table `SELECT *`, so all field/status/locale/cursor/order
+					// conditions reference unprefixed columns as before.
 					const orderByClause = buildOrderByClause(orderBy);
 					const statusCondition = buildStatusCondition(db, status);
 					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
@@ -745,12 +753,37 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					const fieldCondsSQL =
 						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
 
+					const taxonomyCond = taxonomyFilter
+						? sql`AND EXISTS (
+							SELECT 1 FROM content_taxonomies ct
+							INNER JOIN taxonomies t ON t.id = ct.taxonomy_id
+							WHERE ct.collection = ${type}
+								AND ct.entry_id = ${sql.ref(tableName)}.id
+								AND t.name = ${taxonomyFilter.name}
+								AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
+						)`
+						: sql``;
+
+					// `_emdash_content_bylines.byline_id` stores the byline's
+					// translation_group (migration 040), so a credit spans every
+					// locale variant of the byline and we match the group directly.
+					const bylineCond = bylineFilter
+						? sql`AND EXISTS (
+							SELECT 1 FROM _emdash_content_bylines cb
+							WHERE cb.collection_slug = ${type}
+								AND cb.content_id = ${sql.ref(tableName)}.id
+								AND cb.byline_id IN (${sql.join(bylineFilter.groups.map((g) => sql`${g}`))})
+						)`
+						: sql``;
+
 					result = await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.ref(tableName)}
 						WHERE deleted_at IS NULL
 						AND ${statusCondition}
 						${localeFilter}
 						${cursorCond}
+						${taxonomyCond}
+						${bylineCond}
 						${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
 						${orderByClause}
 						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}

package/src/media/responsive.ts

@@ -0,0 +1,125 @@
+/**
+ * Responsive image helpers shared by the public Image components.
+ *
+ * These build a `srcset` for locally-stored / R2-stored media by delegating to
+ * Astro's configured image service (`astro:assets`). On Cloudflare that is the
+ * Images binding; on Node it is sharp; if neither is available it is a no-op
+ * passthrough. The calling `.astro` component passes Astro's `getImage` in so
+ * this module stays free of the `astro:assets` virtual import (which only
+ * resolves inside an Astro project, not in this precompiled package).
+ */
+
+/** Standard responsive breakpoints. Matches CDN-provider srcset generation. */
+export const RESPONSIVE_BREAKPOINTS = [640, 750, 828, 960, 1080, 1280, 1600, 1920];
+
+/** Matches absolute http(s) URLs — the only shape Astro's image services optimize. */
+const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
+
+/**
+ * Pick the srcset widths to generate for an image rendered at `maxWidth`.
+ * Includes breakpoints up to 2x (retina) plus the rendered width itself, so the
+ * browser always has an exact-fit candidate.
+ */
+export function responsiveWidths(maxWidth: number): number[] {
+	const cap = maxWidth * 2;
+	const widths = new Set(RESPONSIVE_BREAKPOINTS.filter((w) => w <= cap));
+	widths.add(maxWidth);
+	return [...widths].toSorted((a, b) => a - b);
+}
+
+/** Build the `sizes` attribute for an image with a known display width. */
+export function responsiveSizes(width: number | undefined): string {
+	return width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
+}
+
+/**
+ * Make a same-origin media URL absolute so Astro's image service can optimize it.
+ *
+ * Astro only optimizes absolute http(s) URLs; a same-origin proxy path like
+ * `/_emdash/api/media/file/x.jpg` is otherwise treated as an unoptimizable
+ * public asset. Resolving it against the site's public origin (and authorizing
+ * that origin via `image.remotePatterns`) lets the service transform it.
+ *
+ * Only **same-origin** root-relative paths are resolved. Protocol-relative
+ * URLs (`//evil.com/x`) and backslash tricks (`/\evil.com`) also start with `/`
+ * but resolve to a different origin -- a classic SSRF vector once a
+ * remotePattern authorizes the media path -- so anything that escapes the
+ * origin is returned unchanged (and then skipped by `buildResponsiveImage`,
+ * which only accepts absolute http(s) URLs). Already-absolute URLs (CDN/public
+ * bucket) and non-path values (`data:`, `blob:`) are returned unchanged too.
+ */
+export function toAbsoluteMediaUrl(src: string, origin: string | undefined): string {
+	if (!src || !origin || !src.startsWith("/")) return src;
+	try {
+		const resolved = new URL(src, origin);
+		if (resolved.origin !== new URL(origin).origin) return src;
+		return resolved.href;
+	} catch {
+		return src;
+	}
+}
+
+/**
+ * Minimal structural subset of Astro's `getImage`. Astro's `ImageTransform`
+ * carries a `[key: string]: any` index signature, so the real `getImage` is
+ * assignable to this narrower type.
+ */
+export type GetImage = (options: {
+	src: string;
+	width?: number;
+	height?: number;
+	widths?: number[];
+	sizes?: string;
+}) => Promise<{ src: string; srcSet?: { attribute?: string } | undefined }>;
+
+export interface ResponsiveImage {
+	src: string;
+	srcset?: string;
+	sizes?: string;
+}
+
+/**
+ * Generate a responsive `src`/`srcset`/`sizes` for a media URL via Astro's
+ * configured image service.
+ *
+ * Astro's image services (sharp, Cloudflare `/cdn-cgi/image`, and the default
+ * Cloudflare `cloudflare-binding` service) only optimize **absolute** URLs whose
+ * host is authorized via `image.domains` / `image.remotePatterns`. Anything else
+ * is passed through unchanged, which would yield a useless srcset (the same URL
+ * at every width descriptor). We therefore only attempt optimization for
+ * absolute http(s) URLs and verify the service actually rewrote the URL.
+ *
+ * Returns `null` so callers fall back to a plain `<img>` when:
+ *  - dimensions are unknown (avoids an inferSize fetch on every render),
+ *  - the URL is relative (a same-origin proxy/public asset Astro won't optimize),
+ *  - the host isn't authorized (the service passed the URL through unchanged),
+ *  - no image service is configured / `getImage` throws.
+ */
+export async function buildResponsiveImage(
+	getImage: GetImage,
+	opts: { src: string; width?: number; height?: number },
+): Promise<ResponsiveImage | null> {
+	const { src, width, height } = opts;
+	if (!src || !width || !height) return null;
+	if (!ABSOLUTE_HTTP_URL.test(src)) return null;
+	try {
+		const sizes = responsiveSizes(width);
+		const result = await getImage({
+			src,
+			width,
+			height,
+			widths: responsiveWidths(width),
+			sizes,
+		});
+		// Passthrough: the service returned the source unchanged (unauthorized
+		// host or no optimization available). Don't emit a no-op srcset.
+		if (!result.src || result.src === src) return null;
+		return {
+			src: result.src,
+			srcset: result.srcSet?.attribute || undefined,
+			sizes,
+		};
+	} catch {
+		return null;
+	}
+}

package/src/menus/index.ts

@@ -136,15 +136,10 @@ async function buildMenuTree(
 		}
 	}
 
-	const urlPatterns = new Map<string, string | null>();
-	if (collectionSlugs.size > 0) {
-		const rows = await db
-			.selectFrom("_emdash_collections")
-			.select(["slug", "url_pattern"])
-			.where("slug", "in", [...collectionSlugs])
-			.execute();
-		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
-	}
+	const urlPatterns =
+		collectionSlugs.size > 0
+			? await getCollectionUrlPatterns(db, collectionSlugs)
+			: new Map<string, string | null>();
 
 	const resolvedItems = await Promise.all(
 		items.map((item) => resolveMenuItem(item, db, urlPatterns, locale)),
@@ -173,6 +168,29 @@ async function buildMenuTree(
 	return rootItems;
 }
 
+/**
+ * Look up the `url_pattern` for a set of collection slugs, request-cached so
+ * a page rendering several menus (header, footer, ...) only pays for the
+ * lookup once per distinct slug set. Callers must treat the returned map as
+ * read-only — it is shared across cache hits within the request.
+ */
+function getCollectionUrlPatterns(
+	db: Kysely<Database>,
+	collectionSlugs: Set<string>,
+): Promise<Map<string, string | null>> {
+	const key = `menu-collection-patterns:${[...collectionSlugs].toSorted().join(",")}`;
+	return requestCached(key, async () => {
+		const rows = await db
+			.selectFrom("_emdash_collections")
+			.select(["slug", "url_pattern"])
+			.where("slug", "in", [...collectionSlugs])
+			.execute();
+		const urlPatterns = new Map<string, string | null>();
+		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
+		return urlPatterns;
+	});
+}
+
 /**
  * Resolve a single menu item's URL. `reference_id` is a translation_group
  * (migration 036 remapped all existing references); we join it against

package/src/plugins/cron.ts

@@ -34,8 +34,9 @@ export type RescheduleFn = () => void;
 /**
  * Executes overdue cron tasks.
  *
- * Called by platform-specific schedulers (NodeCronScheduler, EmDashScheduler DO,
- * PiggybackScheduler). Stateless — all state lives in the database.
+ * Called by the platform driver: the NodeCronScheduler timer on Node, or the
+ * Worker's `scheduled()` handler (via runScheduledTasks) on Cloudflare.
+ * Stateless — all state lives in the database.
  */
 export class CronExecutor {
 	constructor(

package/src/plugins/hooks.ts

@@ -1297,6 +1297,13 @@ export interface ExclusiveHookResolutionOptions {
 	isActive: (pluginId: string) => boolean;
 	/** Read an option value from persistent storage. */
 	getOption: (key: string) => Promise<string | null>;
+	/**
+	 * Batch-read option values for many keys in a single round trip.
+	 * When provided, resolution reads all current selections through this
+	 * instead of one getOption() call per hook. Keys absent from the
+	 * returned map are treated as unset.
+	 */
+	getOptions?: (keys: string[]) => Promise<ReadonlyMap<string, string>>;
 	/** Write an option value to persistent storage. */
 	setOption: (key: string, value: string) => Promise<void>;
 	/** Delete an option from persistent storage. */
@@ -1322,8 +1329,26 @@ const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
  * 5. If multiple providers and no hint → leave unselected (admin must choose).
  */
 export async function resolveExclusiveHooks(opts: ExclusiveHookResolutionOptions): Promise<void> {
-	const { pipeline, isActive, getOption, setOption, deleteOption, preferredHints } = opts;
+	const { pipeline, isActive, getOption, getOptions, setOption, deleteOption, preferredHints } =
+		opts;
 	const exclusiveHookNames = pipeline.getRegisteredExclusiveHooks();
+	if (exclusiveHookNames.length === 0) return;
+
+	// Batch-read current selections in one round trip when the caller
+	// provides a batch reader (1 query instead of N sequential gets).
+	let batchedSelections: ReadonlyMap<string, string> | undefined;
+	if (getOptions) {
+		try {
+			batchedSelections = await getOptions(
+				exclusiveHookNames.map((hookName) => `${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`),
+			);
+		} catch {
+			// Options table may not be ready. Matches the per-key tolerance
+			// below: every hook's read would fail, so resolution is skipped
+			// entirely without touching any selection.
+			return;
+		}
+	}
 
 	for (const hookName of exclusiveHookNames) {
 		const providers = pipeline.getExclusiveHookProviders(hookName);
@@ -1333,11 +1358,15 @@ export async function resolveExclusiveHooks(opts: ExclusiveHookResolutionOptions
 
 		const key = `${EXCLUSIVE_HOOK_KEY_PREFIX}${hookName}`;
 		let currentSelection: string | null = null;
-		try {
-			currentSelection = await getOption(key);
-		} catch {
-			// Options table may not be ready
-			continue;
+		if (batchedSelections) {
+			currentSelection = batchedSelections.get(key) ?? null;
+		} else {
+			try {
+				currentSelection = await getOption(key);
+			} catch {
+				// Options table may not be ready
+				continue;
+			}
 		}
 
 		// If selection exists and the plugin is still active → keep it

package/src/plugins/index.ts

@@ -63,6 +63,11 @@ export type { RouteResult, InvokeRouteOptions } from "./routes.js";
 export { PluginManager, createPluginManager } from "./manager.js";
 export type { PluginManagerOptions, PluginState } from "./manager.js";
 
+// Scheduler (Node timer-based heartbeat; consumed by the generated
+// virtual:emdash/scheduler module on non-serverless adapters)
+export { NodeCronScheduler } from "./scheduler/node.js";
+export type { CronScheduler, SystemCleanupFn } from "./scheduler/types.js";
+
 // Sandbox
 export {
 	NoopSandboxRunner,

package/src/plugins/manager.ts

@@ -544,6 +544,7 @@ export class PluginManager {
 			pipeline: this.hookPipeline!,
 			isActive: (pluginId) => this.isActive(pluginId),
 			getOption: (key) => optionsRepo.get<string>(key),
+			getOptions: (keys) => optionsRepo.getMany<string>(keys),
 			setOption: (key, value) => optionsRepo.set(key, value),
 			deleteOption: async (key) => {
 				await optionsRepo.delete(key);

package/src/plugins/scheduler/node.ts

@@ -15,8 +15,15 @@ import type { CronScheduler, SystemCleanupFn } from "./types.js";
 /** Minimum polling interval (ms) — prevents tight loops if next_run_at is in the past */
 const MIN_INTERVAL_MS = 1000;
 
-/** Maximum polling interval (ms) — wake up periodically to check for stale locks */
-const MAX_INTERVAL_MS = 5 * 60 * 1000;
+/**
+ * Maximum polling interval (ms). Each wake runs the maintenance pass — stale
+ * lock recovery *and* the scheduled-publishing sweep + system cleanup. The cap
+ * is the worst-case latency for scheduled content when no plugin cron task is
+ * due sooner (`getNextDueTime()` only knows about cron tasks, not content
+ * `scheduled_at`). Held at 60s so Node publish latency matches the Cloudflare
+ * Cron Trigger cadence (`* * * * *`) rather than lagging up to five minutes.
+ */
+const MAX_INTERVAL_MS = 60 * 1000;
 
 export class NodeCronScheduler implements CronScheduler {
 	private timer: ReturnType<typeof setTimeout> | null = null;

package/src/query.ts

@@ -101,13 +101,19 @@ export interface CollectionFilter {
 	 */
 	cursor?: string;
 	/**
-	 * Filter by field values, taxonomy terms, or ranges.
+	 * Filter by field values, taxonomy terms, byline credits, or ranges.
 	 *
 	 * Taxonomy names are detected automatically and filtered via JOIN.
+	 * The reserved `byline` key filters by byline credit (any credit, not
+	 * just the primary one) via the `_emdash_content_bylines` junction
+	 * table; its value is one or more byline translation groups. This
+	 * matches co-authored entries, which `primary_byline_id` alone misses.
 	 * Other keys are treated as column filters on the content table.
 	 *
 	 * @example { category: 'news' } - Filter by taxonomy term
 	 * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
+	 * @example { byline: '01HXYZ...' } - Entries credited to a byline (any position)
+	 * @example { byline: ['01HXYZ...', '01HABC...'] } - Credited to any of these bylines (OR)
 	 * @example { series: 'main' } - Exact match on a content field
 	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - Date range
 	 */
@@ -533,7 +539,9 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	// round-trip cost on remote databases (D1 replicas, etc.).
 	await Promise.all([
 		hydrateEntryBylines(type, entriesWithEdit),
-		hydrateEntryTerms(type, entriesWithEdit),
+		// Hydrate terms in the same locale the content rows were resolved to,
+		// otherwise localized entries get default-locale taxonomy terms (#1441).
+		hydrateEntryTerms(type, entriesWithEdit, resolvedLocale),
 	]);
 
 	return { entries: entriesWithEdit, nextCursor, cacheHint: cacheHint ?? {} };
@@ -611,7 +619,17 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		wrapped: ContentEntry<D>,
 		opts: { isPreview: boolean; fallbackLocale?: string; cacheHint: CacheHint },
 	): Promise<EntryResult<D>> {
-		await Promise.all([hydrateEntryBylines(type, [wrapped]), hydrateEntryTerms(type, [wrapped])]);
+		// Hydrate terms in the entry's resolved locale (fallback-aware) so a
+		// localized entry never picks up default-locale taxonomy terms (#1441).
+		// When i18n is disabled we leave the locale unset to preserve the
+		// legacy "do not filter by locale" behaviour.
+		const termLocale = isI18nEnabled()
+			? dataStr(entryData(wrapped), "locale") || undefined
+			: undefined;
+		await Promise.all([
+			hydrateEntryBylines(type, [wrapped]),
+			hydrateEntryTerms(type, [wrapped], termLocale),
+		]);
 		return {
 			entry: wrapped,
 			isPreview: opts.isPreview,
@@ -788,9 +806,18 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
  * results and call getEntryTerms() per entry. With hydration, the list page
  * stays at a single round-trip for term data.
  *
+ * `locale` must be the locale the entries were resolved to. It is forwarded to
+ * `getAllTermsForEntries` so terms are returned in the entry's locale rather
+ * than falling back to the request-context / default locale (#1441). Pass
+ * `undefined` to keep the legacy "do not filter by locale" behaviour.
+ *
  * Fails silently if the taxonomy tables don't exist yet (pre-migration).
  */
-async function hydrateEntryTerms<D>(type: string, entries: ContentEntry<D>[]): Promise<void> {
+async function hydrateEntryTerms<D>(
+	type: string,
+	entries: ContentEntry<D>[],
+	locale?: string,
+): Promise<void> {
 	if (entries.length === 0) return;
 
 	try {
@@ -799,7 +826,7 @@ async function hydrateEntryTerms<D>(type: string, entries: ContentEntry<D>[]): P
 		const ids = entries.map((e) => dataStr(entryData(e), "id")).filter(Boolean);
 		if (ids.length === 0) return;
 
-		const termsMap = await getAllTermsForEntries(type, ids);
+		const termsMap = await getAllTermsForEntries(type, ids, { locale });
 
 		for (const entry of entries) {
 			const data = entryData(entry);