emdash 0.33.0 → 0.34.0

package/src/i18n/taxonomy-locale-diagnostic.ts

@@ -0,0 +1,47 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+
+const REPAIR_GUIDE =
+	"https://docs.emdashcms.com/guides/internationalization/#repairing-taxonomy-locale-mismatches";
+
+interface TaxonomyLocaleMismatch {
+	source: "definitions" | "terms";
+	locale: string;
+}
+
+export async function warnAboutUnconfiguredTaxonomyLocales(
+	db: Kysely<Database>,
+	configuredLocales: readonly string[],
+	definitionLocales?: readonly string[],
+): Promise<void> {
+	const supportedLocales = configuredLocales.length > 0 ? configuredLocales : ["en"];
+	const definitionRows =
+		definitionLocales === undefined
+			? await db
+					.selectFrom("_emdash_taxonomy_defs")
+					.select("locale")
+					.distinct()
+					.where("locale", "not in", supportedLocales)
+					.execute()
+			: [...new Set(definitionLocales)]
+					.filter((locale) => !supportedLocales.includes(locale))
+					.map((locale) => ({ locale }));
+	const termRows = await db
+		.selectFrom("taxonomies")
+		.select("locale")
+		.distinct()
+		.where("locale", "not in", supportedLocales)
+		.execute();
+	const mismatches: TaxonomyLocaleMismatch[] = [
+		...definitionRows.map(({ locale }) => ({ source: "definitions" as const, locale })),
+		...termRows.map(({ locale }) => ({ source: "terms" as const, locale })),
+	].toSorted((a, b) => a.source.localeCompare(b.source) || a.locale.localeCompare(b.locale));
+	if (mismatches.length === 0) return;
+
+	const details = mismatches.map(({ source, locale }) => `${source}: ${locale}`).join("; ");
+	console.warn(
+		`EmDash: Taxonomy rows use locales outside the configured locales (${supportedLocales.join(", ")}): ${details}. ` +
+			`Locale-scoped reads may not return these rows. Review and repair them explicitly: ${REPAIR_GUIDE}`,
+	);
+}

package/src/import/wxr-taxonomies.ts

@@ -549,26 +549,21 @@ export async function attachPostTaxonomies(
 ): Promise<number> {
 	const repo = new TaxonomyRepository(db);
 	const resolved = resolvePostTermAssignments(collection, post, plan);
-
-	let attached = 0;
+	const groups = new Set<string>();
 	for (const [, termIds] of resolved) {
 		for (const termId of termIds) {
-			const wrote = await attachToEntryCountingInserts(db, repo, plan, collection, entryId, termId);
-			if (wrote) attached++;
+			const group = await termTranslationGroup(repo, plan, termId);
+			if (group) groups.add(group);
 		}
 	}
-	return attached;
+	return repo.attachGroupsToEntry(collection, entryId, [...groups]);
 }
 
 /**
  * Replace assignments per-taxonomy from a parsed WXR post. Used for
- * translations: WPML's "Translate Independently" mode lets translators
- * override term assignments per-taxonomy, not per-post. A translation that
- * overrides `category` shouldn't lose its inherited `tag` or `genre`. We
- * only call `setTermsForEntry(name, ids)` for taxonomies where the
- * translation actually resolved at least one term -- taxonomies with no
- * resolvable+permitted terms are left alone so inherited rows from
- * `copyEntryTerms` stay intact.
+ * translations. Assignments belong to the content translation_group, so a
+ * translated item's explicit taxonomy replaces that taxonomy for every
+ * locale. Taxonomies with no resolvable permitted terms are left unchanged.
  *
  * Returns the number of pivot rows after replacement (sum of `termIds`
  * lists across taxonomies actually touched). Note this counts logical
@@ -612,41 +607,6 @@ async function termTranslationGroup(
 	return group;
 }
 
-/**
- * Wrapper around `TaxonomyRepository.attachToEntry` that returns whether
- * an actual row was inserted (vs. silently skipped by the `ON CONFLICT DO
- * NOTHING` branch). Lets the importer's `assignments` counter reflect real
- * writes rather than re-import no-ops.
- *
- * Best-effort: we check pivot existence first, then call `attachToEntry`.
- * A concurrent insert between the check and the attach would make us
- * report `false` while a row was in fact inserted -- the count is for
- * summary display only, never correctness.
- */
-async function attachToEntryCountingInserts(
-	db: Kysely<Database>,
-	repo: TaxonomyRepository,
-	plan: TaxonomyImportPlan,
-	collection: string,
-	entryId: string,
-	termId: string,
-): Promise<boolean> {
-	const group = await termTranslationGroup(repo, plan, termId);
-	if (!group) return false;
-
-	const existing = await db
-		.selectFrom("content_taxonomies")
-		.select("collection")
-		.where("collection", "=", collection)
-		.where("entry_id", "=", entryId)
-		.where("taxonomy_id", "=", group)
-		.executeTakeFirst();
-	if (existing) return false;
-
-	await repo.attachToEntry(collection, entryId, termId);
-	return true;
-}
-
 /**
  * Mirror every term in the plan into each additional locale used by the
  * incoming posts. New rows share the canonical term's `translation_group`

package/src/index.ts

@@ -27,6 +27,13 @@ export type {
 	FindManyOptions,
 	FindManyResult,
 } from "./database/repositories/index.js";
+export type {
+	ContentFieldFilterScalar,
+	ContentFieldFilterValue,
+	ContentFieldFilters,
+	ContentFieldInFilter,
+	ContentFieldRangeFilter,
+} from "./content-list-query.js";
 export type { MediaItem, CreateMediaInput } from "./database/repositories/media.js";
 export type { CompoundSelectLimitedAdapter } from "./database/dialect-helpers.js";
 
@@ -109,7 +116,7 @@ export type {
 export { ulid } from "ulidx";
 export { computeContentHash, hashString } from "./utils/hash.js";
 export { sanitizeHref, isSafeHref } from "./utils/url.js";
-export { decodeSlug } from "./utils/slugify.js";
+export { decodeSlug, slugify } from "./utils/slugify.js";
 
 // Live Collections query functions (loader is in emdash/runtime)
 export {
@@ -144,7 +151,12 @@ export { after } from "./after.js";
 export type { WaitUntilFn } from "./after.js";
 
 // i18n configuration (from Astro config)
-export { getI18nConfig, isI18nEnabled, getFallbackChain } from "./i18n/config.js";
+export {
+	getI18nConfig,
+	isI18nEnabled,
+	getFallbackChain,
+	resolveContentCreateLocale,
+} from "./i18n/config.js";
 export type { I18nConfig } from "./i18n/config.js";
 
 // Visual editing
@@ -231,6 +243,10 @@ export {
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
 	SandboxUnavailableError,
+	createSandboxRouteError,
+	createSandboxRouteErrorEnvelope,
+	getSandboxRouteErrorDetails,
+	getSandboxRouteErrorEnvelope,
 	createNoopSandboxRunner,
 	// HTTP access for plugins (shared between in-process, Cloudflare, and workerd runners)
 	createHttpAccess,
@@ -245,6 +261,7 @@ export type {
 	StorageCollection,
 	KVAccess,
 	ContentAccess,
+	ContentCreateOptions,
 	MediaAccess,
 	HttpAccess,
 	LogAccess,
@@ -300,6 +317,9 @@ export type {
 	PluginManifest,
 	ValidatedPluginManifest,
 	SerializedRequest,
+	SandboxRouteErrorCode,
+	SandboxRouteErrorDetails,
+	SandboxRouteErrorEnvelope,
 } from "./plugins/index.js";
 
 // Capability normalization (legacy → canonical alias layer)
@@ -550,4 +570,7 @@ export type {
 	SqliteConfig,
 	LibsqlConfig,
 	PostgresConfig,
+	CollectionDeletionGuardInput,
+	CollectionDeletionGuardResult,
+	ExecuteCollectionDeletionGuard,
 } from "./db/adapters.js";

package/src/loader.ts

@@ -18,6 +18,7 @@ import { buildStatusCondition, isPostgres } from "./database/dialect-helpers.js"
 import { kyselyLogOption } from "./database/instrumentation.js";
 import { decodeCursor, encodeCursor } from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
+import { getI18nConfig } from "./i18n/config.js";
 import type { Database } from "./index.js";
 import { getRequestContext } from "./request-context.js";
 import { isMissingColumnError, isMissingTableError } from "./utils/db-errors.js";
@@ -123,23 +124,22 @@ function foldedHydrationSelects(db: Kysely<any>, type: string, outer: string) {
 	const agg = (inner: RawBuilder<unknown>) =>
 		pg ? sql`coalesce(json_agg(${inner}), '[]'::json)` : sql`json_group_array(${inner})`;
 
-	// Pin the join order for the per-entry hydration subqueries on SQLite (#1722).
-	// SQLite honours `CROSS JOIN` ordering, forcing the join to drive from the
-	// pivot (`content_taxonomies` / `_emdash_content_bylines`) by
-	// `(collection, entry_id)` and probe the term/byline table by
-	// `translation_group`. Without it, a stats-blind D1 planner (D1 never runs
-	// ANALYZE / maintains `sqlite_stat1`) is free to drive the correlated
-	// subquery from `taxonomies`/`_emdash_bylines` by `locale`, scanning every
-	// row in the locale per emitted entry. Postgres keeps statistics and rejects
-	// `CROSS JOIN … ON`, so it stays a plain `JOIN` there.
+	// Pin the byline join order on SQLite (#1722). Taxonomy hydration uses
+	// LEFT JOINs below, whose order is already fixed by SQL semantics. SQLite
+	// honours `CROSS JOIN` ordering, forcing the byline subquery to drive from
+	// its pivot by content reference and probe by translation_group. Postgres
+	// keeps statistics and rejects `CROSS JOIN … ON`, so it stays a plain JOIN.
 	const foldJoin = pg ? sql`JOIN` : sql`CROSS JOIN`;
 
 	const termObj = obj(
-		"'id', t.id, 'name', t.name, 'slug', t.slug, 'label', t.label, 'parent_id', t.parent_id, 'locale', t.locale, 'translation_group', t.translation_group",
+		"'id', coalesce(exact_term.id, default_term.id), 'name', coalesce(exact_term.name, default_term.name), 'slug', coalesce(exact_term.slug, default_term.slug), 'label', coalesce(exact_term.label, default_term.label), 'parent_id', coalesce(exact_term.parent_id, default_term.parent_id), 'locale', coalesce(exact_term.locale, default_term.locale), 'translation_group', coalesce(exact_term.translation_group, default_term.translation_group)",
 	);
-	// Filter terms to the entry's own locale (matches #1441: terms render in the
-	// entry's resolved locale, not all locale variants of the attached group).
-	const terms = sql`(SELECT ${agg(termObj)} FROM ${sql.ref("content_taxonomies")} AS ct ${foldJoin} ${sql.ref("taxonomies")} AS t ON t.translation_group = ct.taxonomy_id WHERE ct.collection = ${type} AND ct.entry_id = ${o}.id AND t.locale = ${o}.locale) AS ${sql.ref("_emdash_terms")}`;
+	const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
+	const selectedTermId = sql`coalesce(exact_term.id, default_term.id)`;
+	const termAgg = pg
+		? sql`coalesce(json_agg(${termObj}) FILTER (WHERE ${selectedTermId} IS NOT NULL), '[]'::json)`
+		: sql`json_group_array(${termObj}) FILTER (WHERE ${selectedTermId} IS NOT NULL)`;
+	const terms = sql`(SELECT ${termAgg} FROM ${sql.ref("content_taxonomies")} AS ct LEFT JOIN ${sql.ref("taxonomies")} AS exact_term ON exact_term.translation_group = ct.taxonomy_id AND exact_term.locale = ${o}.locale LEFT JOIN ${sql.ref("taxonomies")} AS default_term ON default_term.translation_group = ct.taxonomy_id AND default_term.locale = ${defaultLocale} WHERE ct.collection = ${type} AND ct.entry_id = ${o}.translation_group) AS ${sql.ref("_emdash_terms")}`;
 
 	const bylineInner = obj(
 		"'id', b.id, 'slug', b.slug, 'displayName', b.display_name, 'bio', b.bio, 'avatarMediaId', b.avatar_media_id, 'avatarStorageKey', m.storage_key, 'avatarAlt', m.alt, 'avatarBlurhash', m.blurhash, 'avatarDominantColor', m.dominant_color, 'websiteUrl', b.website_url, 'userId', b.user_id, 'isGuest', b.is_guest, 'createdAt', b.created_at, 'updatedAt', b.updated_at, 'locale', b.locale, 'translationGroup', b.translation_group",
@@ -215,6 +215,26 @@ function expandFoldedSeo(row: Record<string, unknown>): void {
 	}
 }
 
+export function creditsFromFoldedBylines(folded: unknown[]) {
+	return folded
+		.map((raw) => {
+			const credit = isPlainObject(raw) ? raw : {};
+			const byline = isPlainObject(credit.byline) ? credit.byline : {};
+			return {
+				roleLabel: typeof credit.roleLabel === "string" ? credit.roleLabel : null,
+				sortOrder: Number(credit.sortOrder ?? 0),
+				source: "explicit" as const,
+				byline: {
+					...byline,
+					isGuest: Boolean(byline.isGuest),
+					// Folded rows omit custom-field values.
+					customFields: {},
+				},
+			};
+		})
+		.toSorted((a, b) => a.sortOrder - b.sortOrder);
+}
+
 /**
  * Stash folded hydration JSON (non-enumerable) for the query.ts fast paths.
  * SQLite returns a JSON string (parse it); Postgres returns already-parsed JSON.
@@ -249,6 +269,12 @@ function stashFolded(data: Record<string, unknown>, row: Record<string, unknown>
 			configurable: true,
 		});
 	}
+
+	const foldedBylines = Reflect.get(data, FOLDED_BYLINES);
+	if (!Array.isArray(foldedBylines)) return;
+	const credits = creditsFromFoldedBylines(foldedBylines);
+	data.bylines = credits;
+	data.byline = credits[0]?.byline ?? null;
 }
 
 /** Resolved SEO shape attached to `entry.data.seo`. Mirrors `ContentSeo`. */
@@ -293,44 +319,81 @@ function getTableName(type: string): string {
 }
 
 /**
- * Cache for taxonomy names (only used for the primary database).
- * Skipped when a per-request DB override is active (e.g. preview mode)
+ * Cache for taxonomy names by collection (only used for the primary database).
+ * Stored on globalThis so Vite SSR chunk duplication cannot create independent
+ * caches. Skipped when a per-request DB override is active (e.g. preview mode)
  * because the override DB may have different taxonomies.
  */
-let taxonomyNames: Set<string> | null = null;
+interface TaxonomyNamesHolder {
+	cache: Map<string, Set<string>> | null;
+}
+
+const TAXONOMY_NAMES_CACHE_KEY = Symbol.for("emdash:taxonomy-names");
+const taxonomyNamesStore = globalThis as Record<symbol, unknown>;
+const taxonomyNamesHolder: TaxonomyNamesHolder =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see taxonomies/index.ts)
+	(taxonomyNamesStore[TAXONOMY_NAMES_CACHE_KEY] as TaxonomyNamesHolder | undefined) ??
+	(() => {
+		const holder: TaxonomyNamesHolder = { cache: null };
+		taxonomyNamesStore[TAXONOMY_NAMES_CACHE_KEY] = holder;
+		return holder;
+	})();
+
+function setTaxonomyNamesCache(cache: Map<string, Set<string>> | null): void {
+	taxonomyNamesHolder.cache = cache;
+}
 
 /**
- * Get all taxonomy names (cached for the primary DB, bypassed only when
- * the per-request DB is an isolated instance — playground / DO preview).
- * Plain D1 Sessions routing shares schema with the singleton, so the
- * module-scoped cache stays valid.
+ * Get taxonomy names attached to a collection (cached for the primary DB,
+ * bypassed only when the per-request DB is an isolated instance — playground /
+ * DO preview). Plain D1 Sessions routing shares schema with the singleton, so
+ * the isolate-wide cache stays valid.
  */
-async function getTaxonomyNames(db: Kysely<Database>): Promise<Set<string>> {
+async function getTaxonomyNames(db: Kysely<Database>, collection: string): Promise<Set<string>> {
 	const hasIsolatedDb = getRequestContext()?.dbIsIsolated === true;
 
-	if (!hasIsolatedDb && taxonomyNames) {
-		return taxonomyNames;
+	if (!hasIsolatedDb && taxonomyNamesHolder.cache) {
+		return taxonomyNamesHolder.cache.get(collection) ?? new Set();
 	}
 
 	try {
-		const defs = await db.selectFrom("_emdash_taxonomy_defs").select("name").execute();
-		const names = new Set(defs.map((d) => d.name));
+		const defs = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.select(["name", "collections"])
+			.execute();
+		const namesByCollection = new Map<string, Set<string>>();
+		for (const def of defs) {
+			let collections: unknown;
+			try {
+				collections = JSON.parse(def.collections ?? "[]");
+			} catch {
+				continue;
+			}
+			if (!Array.isArray(collections)) continue;
+			for (const attachedCollection of collections) {
+				if (typeof attachedCollection !== "string") continue;
+				const names = namesByCollection.get(attachedCollection) ?? new Set<string>();
+				names.add(def.name);
+				namesByCollection.set(attachedCollection, names);
+			}
+		}
 		if (!hasIsolatedDb) {
-			taxonomyNames = names;
+			setTaxonomyNamesCache(namesByCollection);
 		}
-		return names;
-	} catch {
-		// Table doesn't exist yet, return empty set
+		return namesByCollection.get(collection) ?? new Set();
+	} catch (error) {
+		if (!isMissingTableError(error) && !isMissingColumnError(error)) throw error;
+
 		const empty = new Set<string>();
 		if (!hasIsolatedDb) {
-			taxonomyNames = empty;
+			setTaxonomyNamesCache(new Map());
 		}
 		return empty;
 	}
 }
 
 /**
- * Reset the module-scoped taxonomy-names cache.
+ * Reset the isolate-wide taxonomy-names cache.
  *
  * Called from `invalidateTaxonomyDefsCache()` so that creating or seeding a
  * taxonomy definition is reflected within the current isolate instead of
@@ -338,7 +401,7 @@ async function getTaxonomyNames(db: Kysely<Database>): Promise<Set<string>> {
  * isolate-wide taxonomy-defs cache in `taxonomies/index.ts`.
  */
 export function resetTaxonomyNamesCache(): void {
-	taxonomyNames = null;
+	setTaxonomyNamesCache(null);
 }
 
 /**
@@ -764,18 +827,13 @@ export interface TaxonomyPivotQueryOptions {
 /**
  * Build the pivot-driven taxonomy listing query (#1834).
  *
- * Drives from a pivot-only CTE (`picked`) that carries the sort column, seeks
- * the term on a `(taxonomy_id, collection, deleted_at, [locale,] <sort> DESC,
- * entry_id DESC)` index, and lets `LIMIT` short-circuit; then joins `ec_*` by primary
- * key to hydrate the page **and re-checks the real filter predicates on the
- * joined row** — the pivot columns are advisory (non-atomic re-stamp on D1), so
- * `ec_*` is authoritative for membership. Ordering stays pivot-driven to keep
- * the early-`LIMIT`.
+ * Drives from the term pivot and joins content translations through their
+ * shared translation_group. Content columns remain authoritative for locale,
+ * visibility, sorting, and cursor predicates.
  *
  * Two shapes:
  * - **Indexed sort** (`published_at`/`created_at`, single sort field): the
- *   pivot index is covering for `(entry_id, sortval)`, so `LIMIT` lives in
- *   `picked` and short-circuits.
+ *   `LIMIT` lives in `picked`.
  * - **Temp-sort** (`updated_at` or any other field, or multi-field sort): no
  *   pivot sort index applies, so `picked` collects the tagged candidate set and
  *   the outer query sorts the joined rows. Bounded to tagged rows — no
@@ -813,14 +871,6 @@ export function buildTaxonomyPivotQuery(
 	const restGroups = groupSets.slice(1);
 	const multiGroup = firstGroups.length > 1;
 
-	// Pivot-local narrowing predicates (advisory — re-checked on `ec_*` below).
-	// `status === undefined` means an all-statuses shape (admin), so the status
-	// condition is dropped entirely.
-	const deletedCt = deletedIsNull ? sql`ct.deleted_at IS NULL` : sql`ct.deleted_at IS NOT NULL`;
-	const statusCt =
-		status !== undefined ? sql`AND ${buildStatusCondition(db, status, "ct")}` : sql``;
-	const localeCt = locale ? sql`AND ct.locale = ${locale}` : sql``;
-
 	// Multi-term AND: one residual pivot-PK EXISTS per additional taxonomy.
 	const residual =
 		restGroups.length > 0
@@ -837,17 +887,18 @@ export function buildTaxonomyPivotQuery(
 				)}`
 			: sql``;
 
-	// Byline filter keeps its EXISTS, correlated on `ct.entry_id`.
+	// Byline assignments remain keyed to a locale-specific content row.
 	const bylineCt = bylineGroups
 		? sql`AND EXISTS (
 				SELECT 1 FROM _emdash_content_bylines cb
 				WHERE cb.collection_slug = ${collection}
-					AND cb.content_id = ct.entry_id
+					AND cb.content_id = r.id
 					AND cb.byline_id IN (${sql.join(bylineGroups.map((g) => sql`${g}`))})
 			)`
 		: sql``;
 
 	const firstGroupCond = pivotGroupCondition("ct.taxonomy_id", firstGroups);
+	const pivotContentJoin = isPostgres(db) ? sql`JOIN` : sql`CROSS JOIN`;
 	const {
 		terms: termsSelect,
 		bylines: bylinesSelect,
@@ -860,15 +911,15 @@ export function buildTaxonomyPivotQuery(
 	const localeR = locale ? sql`AND r.locale = ${locale}` : sql``;
 
 	if (isIndexedSort) {
-		const sortRef = sql.ref(`ct.${primary.field}`);
+		const sortRef = sql.ref(`r.${primary.field}`);
 		const sortval = multiGroup ? sql`MAX(${sortRef})` : sortRef;
-		const groupByClause = multiGroup ? sql`GROUP BY ct.entry_id` : sql``;
+		const groupByClause = multiGroup ? sql`GROUP BY r.id` : sql``;
 
 		let cursorClause = sql``;
 		let havingClause = sql``;
 		if (cursor) {
 			const { orderValue, id } = decodeCursor(cursor);
-			const cond = sql`(${sortval} ${cmp} ${orderValue} OR (${sortval} = ${orderValue} AND ct.entry_id ${cmp} ${id}))`;
+			const cond = sql`(${sortval} ${cmp} ${orderValue} OR (${sortval} = ${orderValue} AND r.id ${cmp} ${id}))`;
 			// A GROUP BY makes `sortval` an aggregate → cursor goes in HAVING.
 			if (multiGroup) havingClause = sql`HAVING ${cond}`;
 			else cursorClause = sql`AND ${cond}`;
@@ -878,19 +929,20 @@ export function buildTaxonomyPivotQuery(
 
 		return sql<Record<string, unknown>>`
 			WITH picked AS (
-				SELECT ct.entry_id AS entry_id, ${sortval} AS sortval
+				SELECT r.id AS entry_id, ${sortval} AS sortval
 				FROM content_taxonomies ct
+				${pivotContentJoin} ${sql.ref(tableName)} AS r ON r.translation_group = ct.entry_id
 				WHERE ct.collection = ${collection}
 					AND ${firstGroupCond}
-					AND ${deletedCt}
-					${statusCt}
-					${localeCt}
+					AND ${deletedR}
+					${statusR}
+					${localeR}
 					${residual}
 					${bylineCt}
 					${cursorClause}
 				${groupByClause}
 				${havingClause}
-				ORDER BY sortval ${dir}, ct.entry_id ${dir}
+				ORDER BY sortval ${dir}, r.id ${dir}
 				${limitClause}
 			)
 			SELECT r.*, ${termsSelect}, ${bylinesSelect}, ${bylinesExistSelect}
@@ -906,13 +958,14 @@ export function buildTaxonomyPivotQuery(
 	const limitClause = buildPivotLimitOffset(db, fetchLimit, offset);
 	return sql<Record<string, unknown>>`
 		WITH picked AS (
-			SELECT DISTINCT ct.entry_id AS entry_id
+			SELECT DISTINCT r.id AS entry_id
 			FROM content_taxonomies ct
+			${pivotContentJoin} ${sql.ref(tableName)} AS r ON r.translation_group = ct.entry_id
 			WHERE ct.collection = ${collection}
 				AND ${firstGroupCond}
-				AND ${deletedCt}
-				${statusCt}
-				${localeCt}
+				AND ${deletedR}
+				${statusR}
+				${localeR}
 				${residual}
 				${bylineCt}
 		)
@@ -1153,7 +1206,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				const fieldFilters: Record<string, WhereValue> = {};
 
 				if (where && Object.keys(where).length > 0) {
-					const taxNames = await getTaxonomyNames(db);
+					const taxNames = await getTaxonomyNames(db, type);
 
 					for (const [key, value] of Object.entries(where)) {
 						if (value == null) continue;
@@ -1256,7 +1309,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 							SELECT 1 FROM content_taxonomies ct
 							INNER JOIN taxonomies t ON t.translation_group = ct.taxonomy_id
 							WHERE ct.collection = ${type}
-								AND ct.entry_id = ${sql.ref(tableName)}.id
+								AND ct.entry_id = ${sql.ref(tableName)}.translation_group
 								AND t.name = ${f.name}
 								AND t.slug IN (${sql.join(f.slugs.map((s) => sql`${s}`))})
 							${locale ? sql`AND t.locale = ${locale}` : sql``}
@@ -1519,6 +1572,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 						};
 						const revSeo = extractSeo(row);
 						if (revSeo) revEntryData.seo = revSeo;
+						stashFolded(revEntryData, row);
 						return {
 							id: revId,
 							slug,