emdash 0.40.1 → 0.42.0

package/src/import/wxr-taxonomies.ts

@@ -179,60 +179,132 @@ export async function loadTaxonomyPlanFromDb(db: Kysely<Database>): Promise<Taxo
 	return state.plan;
 }
 
+interface TermDescriptor {
+	taxonomyName: string;
+	slug: string;
+	label: string;
+	description?: string;
+}
+
+function termKey(taxonomyName: string, slug: string): string {
+	return `${taxonomyName}\u0000${slug}`;
+}
+
 /**
- * Find or create a term in the given taxonomy. Returns the term id. Callers
- * must verify the taxonomy def exists before calling — this helper assumes
- * the def is present.
+ * Find or create many terms in a small number of batched SELECTs instead of
+ * one SELECT per term. This is the dominant fixed cost for WXR imports with
+ * large category/tag vocabularies: a site with 100+ categories would otherwise
+ * spend one D1 round-trip per category before writing any posts.
  *
- * Note: we don't resolve WordPress parent slugs into EmDash parent ids in
- * this pass. WXR exports list categories in arbitrary order, so a category's
- * parent may not exist yet when we first see it. Hierarchy is preserved at
- * the data level (the parent slug is on `WxrCategory.parent`) but flattens
- * in EmDash for now; restoring the tree is a follow-up improvement.
+ * Batching rules:
+ *   - Descriptors already resolved in `state.plan.termIdByNameAndSlug` are
+ *     skipped (same idempotency as the old per-term loop).
+ *   - Remaining descriptors are deduplicated by `(taxonomy, slug)`; the first
+ *     label/description seen wins, matching the old behaviour where the first
+ *     `ensureTerm` call cached the id.
+ *   - One batched SELECT resolves existing rows at the requested locale.
+ *   - One batched SELECT resolves any-locale rows for use as `translationOf`.
+ *   - Missing rows are still created one at a time because each insert needs
+ *     its own ULID/translation_group/sort_order bookkeeping, but the reads are
+ *     where the round-trip bottleneck lives.
  */
-async function ensureTerm(
-	repo: TaxonomyRepository,
+async function ensureTermsBatch(
+	db: Kysely<Database>,
 	state: TaxonomyImportState,
-	taxonomyName: string,
-	slug: string,
-	label: string,
-	description: string | undefined,
+	descriptors: TermDescriptor[],
 	locale: string | undefined,
-): Promise<string> {
-	// Already resolved in this run (e.g. seen in `wp:category` AND in a per-
-	// item `<category>` element).
-	const cached = state.plan.termIdByNameAndSlug.get(taxonomyName)?.get(slug);
-	if (cached) return cached;
-
-	const existing = await repo.findBySlug(taxonomyName, slug, locale);
-	if (existing) {
-		bump(state.plan.termsReused, taxonomyName);
-		rememberTerm(state, taxonomyName, slug, existing.id);
-		return existing.id;
+): Promise<void> {
+	if (descriptors.length === 0) return;
+
+	const repo = new TaxonomyRepository(db);
+
+	const needed: TermDescriptor[] = [];
+	const seenKeys = new Set<string>();
+	for (const d of descriptors) {
+		if (state.plan.termIdByNameAndSlug.get(d.taxonomyName)?.has(d.slug)) continue;
+		const key = termKey(d.taxonomyName, d.slug);
+		if (seenKeys.has(key)) continue;
+		seenKeys.add(key);
+		needed.push(d);
+	}
+	if (needed.length === 0) return;
+
+	// Resolve existing rows at the requested locale in one round-trip.
+	const existingAtLocale = await findExistingTerms(db, needed, locale);
+	for (const row of existingAtLocale) {
+		bump(state.plan.termsReused, row.name);
+		rememberTerm(state, row.name, row.slug, row.id);
+	}
+
+	// Build the list of descriptors that still need creation.
+	const stillNeeded: TermDescriptor[] = [];
+	for (const d of needed) {
+		if (!state.plan.termIdByNameAndSlug.get(d.taxonomyName)?.has(d.slug)) {
+			stillNeeded.push(d);
+		}
+	}
+	if (stillNeeded.length === 0) return;
+
+	// Resolve any-locale rows once for translationOf linking.
+	const anyLocaleRows = await findExistingTerms(db, stillNeeded, undefined);
+	const translationOfByKey = new Map<string, string>();
+	for (const row of anyLocaleRows) {
+		const key = termKey(row.name, row.slug);
+		if (!translationOfByKey.has(key)) translationOfByKey.set(key, row.id);
 	}
 
-	// No row at the requested locale. Before creating, check whether a
-	// `(name, slug)` row exists in some OTHER locale -- e.g. the admin
-	// pre-created an Arabic translation, and now an `en` import wants the
-	// canonical row. We need to mint the new row inside the existing row's
-	// `translation_group` so per-locale lookups across the family work.
-	// Without this, the mirror pass would later refuse to reconcile (it
-	// sees pre-existing rows in a different group as a no-op) and pivots
-	// would point at a group that has no row in the requested locale.
-	const anyLocale = await repo.findBySlug(taxonomyName, slug);
-	const translationOf = anyLocale?.id;
-
-	const created = await repo.create({
-		name: taxonomyName,
-		slug,
-		label,
-		data: description ? { description } : undefined,
-		locale,
-		translationOf,
-	});
-	bump(state.plan.termsCreated, taxonomyName);
-	rememberTerm(state, taxonomyName, slug, created.id);
-	return created.id;
+	for (const d of stillNeeded) {
+		const created = await repo.create({
+			name: d.taxonomyName,
+			slug: d.slug,
+			label: d.label,
+			data: d.description ? { description: d.description } : undefined,
+			locale,
+			translationOf: translationOfByKey.get(termKey(d.taxonomyName, d.slug)),
+		});
+		bump(state.plan.termsCreated, d.taxonomyName);
+		rememberTerm(state, d.taxonomyName, d.slug, created.id);
+	}
+}
+
+/**
+ * Batched lookup of term rows for a list of `(taxonomy, slug)` pairs.
+ * Chunks at `SQL_BATCH_SIZE / 2` because each pair consumes two bind
+ * parameters (`name` and `slug`). When `locale` is omitted, returns rows
+ * for all locales ordered by locale ascending so callers can pick the first
+ * row per pair (mirroring `TaxonomyRepository.findBySlug` without a locale
+ * argument).
+ */
+async function findExistingTerms(
+	db: Kysely<Database>,
+	descriptors: TermDescriptor[],
+	locale: string | undefined,
+): Promise<Array<{ id: string; name: string; slug: string }>> {
+	const { chunks, SQL_BATCH_SIZE } = await import("../utils/chunks.js");
+	const rows: Array<{ id: string; name: string; slug: string }> = [];
+	const seenKeys = new Set<string>();
+
+	// Each pair uses 2 bind params, so limit each batch to SQL_BATCH_SIZE / 2 pairs.
+	for (const batch of chunks(descriptors, Math.floor(SQL_BATCH_SIZE / 2))) {
+		const batchRows = await db
+			.selectFrom("taxonomies")
+			.select(["id", "name", "slug"])
+			.where((eb) =>
+				eb.or(batch.map((d) => eb.and([eb("name", "=", d.taxonomyName), eb("slug", "=", d.slug)]))),
+			)
+			.$if(locale !== undefined, (qb) => qb.where("locale", "=", locale!))
+			.orderBy("locale", "asc")
+			.execute();
+
+		for (const row of batchRows) {
+			const key = termKey(row.name, row.slug);
+			if (seenKeys.has(key)) continue;
+			seenKeys.add(key);
+			rows.push(row);
+		}
+	}
+
+	return rows;
 }
 
 /**
@@ -269,7 +341,6 @@ export async function preImportWxrTaxonomies(
 	locale: string | undefined,
 ): Promise<TaxonomyImportPlan> {
 	const state = makeState();
-	const repo = new TaxonomyRepository(db);
 
 	// Cache def lookups for the duration of the import. Keyed by name; value
 	// is `null` when we've already determined the taxonomy is missing (so we
@@ -287,38 +358,40 @@ export async function preImportWxrTaxonomies(
 		return def;
 	};
 
-	// Pass 1: top-level <wp:category> blocks -> EmDash `category` taxonomy.
+	// Pass 1-3: collect every term declared at the top of the WXR, then
+	// resolve them in a few batched queries instead of one round-trip per term.
 	const categoryDef = await lookupDef("category");
+	const tagDef = await lookupDef("tag");
+	const topLevel: TermDescriptor[] = [];
+
 	if (categoryDef) {
 		for (const cat of categories) {
-			const slug = cat.nicename;
-			const label = cat.name;
-			if (!slug || !label) continue;
-			await ensureTerm(repo, state, "category", slug, label, cat.description, locale);
+			if (!cat.nicename || !cat.name) continue;
+			topLevel.push({
+				taxonomyName: "category",
+				slug: cat.nicename,
+				label: cat.name,
+				description: cat.description,
+			});
 		}
 	} else if (categories.length > 0) {
-		// Seeded `category` def was deleted by the user — record so the
-		// import response can surface why none of the categories landed.
 		state.plan.missingTaxonomies.push("category");
 	}
 
-	// Pass 2: top-level <wp:tag> blocks -> EmDash `tag` taxonomy.
-	const tagDef = await lookupDef("tag");
 	if (tagDef) {
 		for (const tag of tags) {
-			const slug = tag.slug;
-			const label = tag.name;
-			if (!slug || !label) continue;
-			await ensureTerm(repo, state, "tag", slug, label, tag.description, locale);
+			if (!tag.slug || !tag.name) continue;
+			topLevel.push({
+				taxonomyName: "tag",
+				slug: tag.slug,
+				label: tag.name,
+				description: tag.description,
+			});
 		}
 	} else if (tags.length > 0) {
 		state.plan.missingTaxonomies.push("tag");
 	}
 
-	// Pass 3: <wp:term> blocks for custom taxonomies (genre, etc.). Skipped:
-	//   - `nav_menu`: menus are handled by `importMenusFromWxr`.
-	//   - `language`: Polylang's locale signal; promoted to `WxrPost.locale`
-	//     by the parser and not a content taxonomy in EmDash.
 	for (const term of terms) {
 		if (term.taxonomy === "nav_menu" || term.taxonomy === "language") continue;
 		// Normalize WordPress' `post_tag` synonym -> EmDash `tag`. WordPress
@@ -332,16 +405,23 @@ export async function preImportWxrTaxonomies(
 			}
 			continue;
 		}
-		await ensureTerm(repo, state, taxonomyName, term.slug, term.name, term.description, locale);
+		topLevel.push({
+			taxonomyName,
+			slug: term.slug,
+			label: term.name,
+			description: term.description,
+		});
 	}
 
+	await ensureTermsBatch(db, state, topLevel, locale);
+
 	// Pass 4: per-item assignments. Backfills terms missing from the top-
 	// level blocks (rare, but observed in hand-edited or partial exports).
-	// Labels come from the per-item `<category>` text body when the parser
-	// captured one; otherwise we fall back to the slug. This is the path
-	// for older exports that skip top-level `<wp:category>` definitions.
+	// Collect every assignment first so we can batch-resolve them too.
+	const fromPosts: TermDescriptor[] = [];
 	let recordedMissingCategoryFromPosts = false;
 	let recordedMissingTagFromPosts = false;
+
 	for (const post of posts) {
 		for (const slug of post.categories) {
 			if (!categoryDef) {
@@ -355,15 +435,11 @@ export async function preImportWxrTaxonomies(
 				break;
 			}
 			if (state.plan.termIdByNameAndSlug.get("category")?.has(slug)) continue;
-			await ensureTerm(
-				repo,
-				state,
-				"category",
+			fromPosts.push({
+				taxonomyName: "category",
 				slug,
-				labelFor(post, "category", slug),
-				undefined,
-				locale,
-			);
+				label: labelFor(post, "category", slug),
+			});
 		}
 		for (const slug of post.tags) {
 			if (!tagDef) {
@@ -374,13 +450,14 @@ export async function preImportWxrTaxonomies(
 				break;
 			}
 			if (state.plan.termIdByNameAndSlug.get("tag")?.has(slug)) continue;
-			await ensureTerm(repo, state, "tag", slug, labelFor(post, "tag", slug), undefined, locale);
+			fromPosts.push({
+				taxonomyName: "tag",
+				slug,
+				label: labelFor(post, "tag", slug),
+			});
 		}
 		if (post.customTaxonomies) {
 			for (const [rawName, slugs] of post.customTaxonomies) {
-				// `nav_menu` is handled by the menu importer; `language` is
-				// Polylang's per-post locale signal, already promoted by the
-				// parser.
 				if (rawName === "nav_menu" || rawName === "language") continue;
 				const taxonomyName = rawName === "post_tag" ? "tag" : rawName;
 				const def = await lookupDef(taxonomyName);
@@ -392,20 +469,18 @@ export async function preImportWxrTaxonomies(
 				}
 				for (const slug of slugs) {
 					if (state.plan.termIdByNameAndSlug.get(taxonomyName)?.has(slug)) continue;
-					await ensureTerm(
-						repo,
-						state,
+					fromPosts.push({
 						taxonomyName,
 						slug,
-						labelFor(post, taxonomyName, slug),
-						undefined,
-						locale,
-					);
+						label: labelFor(post, taxonomyName, slug),
+					});
 				}
 			}
 		}
 	}
 
+	await ensureTermsBatch(db, state, fromPosts, locale);
+
 	// `content_taxonomies` writes happen later in `attachPostTaxonomies`, but
 	// term inserts above already invalidate the in-memory "has any terms" probe.
 	// We flush once at the end of the pre-import to keep the runtime cache hot.

package/src/index.ts

@@ -151,6 +151,7 @@ export { decodeSlug, slugify } from "./utils/slugify.js";
 export {
 	getEmDashCollection,
 	getEmDashEntry,
+	getEmDashReferences,
 	getEditMeta,
 	getTranslations,
 	resolveEmDashPath,
@@ -163,8 +164,17 @@ export type {
 	EditFieldMeta,
 	EntryResult,
 	EmDashCollections,
+	EmDashCollectionReferences,
 	InferCollectionData,
+	InferCollectionReferences,
+	ReferencePage,
+	ReferencePages,
+	ReferenceQuery,
+	ReferenceResult,
+	ReferenceSelection,
 	ResolvePathResult,
+	SelectableReferences,
+	SelectedReferences,
 	TranslationSummary,
 	TranslationsResult,
 	WhereRange,
@@ -311,6 +321,7 @@ export {
 	createRedirectAccess,
 	RedirectAccessError,
 	createSchemaAccess,
+	createBylineAccess,
 	createMediaAccess,
 	DEFAULT_PLUGIN_MEDIA_READ_BYTES,
 	MAX_PLUGIN_MEDIA_READ_BYTES,
@@ -365,6 +376,11 @@ export type {
 	TaxonomyTermInfo,
 	TaxonomyTermCreateInput,
 	TaxonomyReadOptions,
+	BylineAccess,
+	BylineCreditInfo,
+	BylineInfo,
+	BylineListOptions,
+	EntryBylineCredits,
 	RedirectAccess,
 	RedirectAccessWithWrite,
 	RedirectCreateInput,
@@ -404,6 +420,10 @@ export type {
 	FieldWidgetConfig,
 	PortableTextBlockConfig,
 	PortableTextBlockField,
+	BylineAfterSaveEvent,
+	BylineAfterDeleteEvent,
+	BylineAfterSaveHandler,
+	BylineAfterDeleteHandler,
 	// Comment types
 	CommentBeforeCreateEvent,
 	CommentModerateEvent,

package/src/loader.ts

@@ -23,6 +23,7 @@ import { getI18nConfig } from "./i18n/config.js";
 import type { Database } from "./index.js";
 import { primeSeoPanel } from "./page/seo-panel.js";
 import { getRequestContext } from "./request-context.js";
+import { chunks, SQL_BATCH_SIZE } from "./utils/chunks.js";
 import { isMissingColumnError, isMissingTableError } from "./utils/db-errors.js";
 
 const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -64,6 +65,9 @@ const SEO_FOLDED_COLUMN = "_emdash_seo";
 /** Folded boolean field slugs used to restore SQLite integer values. */
 const BOOLEAN_FIELDS_FOLDED_COLUMN = "_emdash_boolean_fields";
 
+/** Rank of a row among its translation group's variants, in {@link loadEntriesByGroups}. */
+const VARIANT_RANK_COLUMN = "_emdash_variant_rank";
+
 /**
  * System columns excluded from entry.data
  * Note: slug is intentionally NOT excluded - it's useful as data.slug in templates
@@ -97,6 +101,7 @@ const SYSTEM_COLUMNS = new Set([
 	"_emdash_bylines_exist",
 	SEO_FOLDED_COLUMN,
 	BOOLEAN_FIELDS_FOLDED_COLUMN,
+	VARIANT_RANK_COLUMN,
 ]);
 
 /** Markers for byline/taxonomy hydration folded into the content query. */
@@ -567,6 +572,104 @@ function mapRowToData(
 	return data;
 }
 
+/**
+ * The entry id Astro addresses a row by: its slug, prefixed with the locale
+ * whenever i18n routing would prefix the URL. Shared by every path that builds
+ * a loader entry so a referenced entry carries the same id it would have been
+ * loaded under directly.
+ */
+function entryIdForRow(row: Record<string, unknown>): string {
+	const i18nConfig = virtualConfig?.i18n;
+	const slug = rowStr(row, "slug") || rowStr(row, "id");
+	const locale = rowStr(row, "locale");
+	const shouldPrefix =
+		i18nConfig &&
+		i18nConfig.locales.length > 1 &&
+		locale !== "" &&
+		(locale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
+	return shouldPrefix ? `${locale}/${slug}` : slug;
+}
+
+/** A loader entry as {@link emdashLoader} builds one, before the query layer wraps it. */
+export interface LoadedEntry {
+	id: string;
+	slug: string;
+	status: string;
+	data: Record<string, unknown>;
+	cacheHint: { tags: string[]; lastModified?: Date };
+}
+
+/**
+ * Load one locale variant of each translation group, in one query per
+ * `SQL_BATCH_SIZE` chunk of groups.
+ *
+ * A group's variant is the first of `localeChain` it has, or else its lowest
+ * locale code: a reference names a translation group, so a target that exists
+ * only outside the chain is still a real reference. Groups with no surviving
+ * variant are absent from the result.
+ *
+ * The rows go through the same {@link mapRowToData} as a direct entry load, so
+ * a referenced entry's `data` carries the same dates, booleans and normalized
+ * media values a caller would get from `getEmDashEntry`. Bylines and taxonomy
+ * terms are not hydrated; each would cost a correlated subquery per row.
+ */
+export async function loadEntriesByGroups(
+	type: string,
+	translationGroups: string[],
+	options: { publishedOnly?: boolean; localeChain?: readonly string[] } = {},
+): Promise<LoadedEntry[]> {
+	if (translationGroups.length === 0) return [];
+	const db = await getDb();
+	const tableName = getTableName(type);
+	const statusFilter = options.publishedOnly ? sql`AND status = ${"published"}` : sql``;
+	const booleanFieldsSelect = foldedBooleanFieldsSelect(db, type);
+	const localeChain = options.localeChain ?? [];
+	const chainPosition =
+		localeChain.length > 0
+			? sql`CASE locale ${sql.join(
+					localeChain.map((locale, index) => sql`WHEN ${locale} THEN ${sql.lit(index)}`),
+					sql` `,
+				)} ELSE ${sql.lit(localeChain.length)} END,`
+			: sql``;
+
+	const entries: LoadedEntry[] = [];
+	try {
+		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
+			const result = await sql<Record<string, unknown>>`
+				SELECT * FROM (
+					SELECT *, ${booleanFieldsSelect},
+						ROW_NUMBER() OVER (
+							PARTITION BY translation_group ORDER BY ${chainPosition} locale ASC
+						) AS ${sql.ref(VARIANT_RANK_COLUMN)}
+					FROM ${sql.ref(tableName)}
+					WHERE translation_group IN (${sql.join(chunk.map((group) => sql`${group}`))})
+					AND deleted_at IS NULL
+					${statusFilter}
+				) AS variants
+				WHERE ${sql.ref(VARIANT_RANK_COLUMN)} = 1
+				ORDER BY translation_group ASC
+			`.execute(db);
+			const booleanFields = parseFoldedBooleanFields(result.rows[0]);
+			for (const row of result.rows) {
+				entries.push({
+					id: entryIdForRow(row),
+					slug: rowStr(row, "slug"),
+					status: rowStr(row, "status", "draft"),
+					data: mapRowToData(row, booleanFields),
+					cacheHint: {
+						tags: [rowStr(row, "id")],
+						lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
+					},
+				});
+			}
+		}
+	} catch (error) {
+		if (isMissingTableError(error)) return [];
+		throw error;
+	}
+	return entries;
+}
+
 function parseFoldedBooleanFields(row: Record<string, unknown> | undefined): Set<string> {
 	const raw = row?.[BOOLEAN_FIELDS_FOLDED_COLUMN];
 	let values: unknown;
@@ -743,6 +846,48 @@ function isWhereRange(value: WhereValue): value is WhereRange {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
+/**
+ * Keys a `where` or `orderBy` can name that belong to the table rather than to
+ * a field. `slug` is one of them; {@link SYSTEM_COLUMNS} leaves it out because
+ * it is kept in `entry.data` for templates.
+ */
+const SYSTEM_QUERY_KEYS: ReadonlySet<string> = new Set([...SYSTEM_COLUMNS, "slug"]);
+
+/**
+ * The first of `keys` that names a reference field bound to a relation, or
+ * undefined.
+ *
+ * Such a field has no column: a `WHERE` on it fails with "no such column", which
+ * the catch below reads as an empty collection, and a field bound after its
+ * column existed answers from values it stopped writing. Both read to a template
+ * as "nothing matched", so the key has to be caught before the query is built.
+ *
+ * System columns are answered without a lookup, and the lookup itself is cached
+ * per request and in the schema object-cache namespace, so a render that filters
+ * by an ordinary field pays for this at most once between schema changes, and a
+ * render that filters by nothing never pays at all.
+ */
+async function findStoragelessQueryKey(
+	collection: string,
+	keys: string[],
+): Promise<string | undefined> {
+	const candidates = keys.filter((key) => !SYSTEM_QUERY_KEYS.has(key));
+	if (candidates.length === 0) return undefined;
+	const { getReferenceFieldMap } = await import("./references/field-map.js");
+	const bound = await getReferenceFieldMap(collection);
+	return candidates.find((key) => bound.has(key));
+}
+
+/**
+ * A boolean field owns an INTEGER column (`FIELD_TYPE_TO_COLUMN`) and its
+ * values are written as 0/1, so binding a native `true` against one is a type
+ * error on PostgreSQL. SQLite accepts the boolean and compares it as 1, which
+ * is why filtering by a boolean field only ever broke on one dialect.
+ */
+function bindableFilterValue(value: unknown): unknown {
+	return typeof value === "boolean" ? (value ? 1 : 0) : value;
+}
+
 /**
  * Build AND conditions for non-taxonomy field filters.
  * Returns an array of sql fragments; empty if no field filters apply.
@@ -763,16 +908,19 @@ function buildFieldConditions(
 		const ref = tablePrefix ? sql.ref(`${tablePrefix}.${key}`) : sql.ref(key);
 
 		if (isWhereRange(value)) {
-			if (value.gt !== undefined) conditions.push(sql`${ref} > ${value.gt}`);
-			if (value.gte !== undefined) conditions.push(sql`${ref} >= ${value.gte}`);
-			if (value.lt !== undefined) conditions.push(sql`${ref} < ${value.lt}`);
-			if (value.lte !== undefined) conditions.push(sql`${ref} <= ${value.lte}`);
+			const { gt, gte, lt, lte } = value;
+			if (gt !== undefined) conditions.push(sql`${ref} > ${bindableFilterValue(gt)}`);
+			if (gte !== undefined) conditions.push(sql`${ref} >= ${bindableFilterValue(gte)}`);
+			if (lt !== undefined) conditions.push(sql`${ref} < ${bindableFilterValue(lt)}`);
+			if (lte !== undefined) conditions.push(sql`${ref} <= ${bindableFilterValue(lte)}`);
 		} else if (Array.isArray(value)) {
 			if (value.length > 0) {
-				conditions.push(sql`${ref} IN (${sql.join(value.map((v) => sql`${v}`))})`);
+				conditions.push(
+					sql`${ref} IN (${sql.join(value.map((v) => sql`${bindableFilterValue(v)}`))})`,
+				);
 			}
 		} else {
-			conditions.push(sql`${ref} = ${value}`);
+			conditions.push(sql`${ref} = ${bindableFilterValue(value)}`);
 		}
 	}
 
@@ -952,7 +1100,14 @@ export function buildTaxonomyPivotQuery(
 	// by primary key, and short-circuit at `LIMIT`. A `CROSS JOIN` pin would
 	// force `content_taxonomies` as the outer table and require a temp sort,
 	// producing a full nested loop over the collection on D1.
-	const pivotContentJoin = sql`JOIN`;
+	//
+	// The temp-sort branch keeps the pin. Its `picked` collects every tagged
+	// entry with no `LIMIT`, so starting from `ec_*` can never stop early, and
+	// D1 does start there when `ANALYZE` has underestimated
+	// `deleted_at IS NULL` (a trash with many distinct deletion times): it
+	// walks the collection's `(deleted_at, status)` index and probes the pivot
+	// once per published row.
+	const pivotContentJoin = isPostgres(db) || isIndexedSort ? sql`JOIN` : sql`CROSS JOIN`;
 	const {
 		terms: termsSelect,
 		bylines: bylinesSelect,
@@ -1303,6 +1458,19 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					}
 				}
 
+				const storagelessKey = await findStoragelessQueryKey(type, [
+					...Object.keys(fieldFilters),
+					...Object.keys(orderBy ?? {}),
+				]);
+				if (storagelessKey) {
+					const message = `Cannot filter or sort "${type}" by "${storagelessKey}": it is a reference field bound to a relation, and its links are not stored on the entry. Read them with getEmDashEntry(..., { references }) or getEmDashReferences().`;
+					// Warned as well as returned, the way the missing-column catch
+					// below warns: a template that renders `entries` without reading
+					// `error` would otherwise see the same empty list this replaced.
+					console.warn(`[emdash] where filter: ${message}`);
+					return { error: new Error(message) };
+				}
+
 				// A byline or taxonomy filter with no values matches nothing —
 				// short-circuit before building SQL (an empty `IN ()` is invalid
 				// SQL on both dialects).
@@ -1440,17 +1608,9 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				const rows = hasMore ? result.rows.slice(0, limit) : result.rows;
 
 				// Map rows to entries
-				const i18nConfig = virtualConfig?.i18n;
-				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
 				const booleanFields = parseFoldedBooleanFields(rows[0]);
 				const entries = rows.map((row) => {
-					const slug = rowStr(row, "slug") || rowStr(row, "id");
-					const rowLocale = rowStr(row, "locale");
-					const shouldPrefix =
-						i18nEnabled &&
-						rowLocale !== "" &&
-						(rowLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
-					const id = shouldPrefix ? `${rowLocale}/${slug}` : slug;
+					const id = entryIdForRow(row);
 					const data = mapRowToData(row, booleanFields);
 					stashFolded(data, row);
 					return {
@@ -1612,13 +1772,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				const i18nConfig = virtualConfig?.i18n;
 				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
-				const entrySlug = rowStr(row, "slug") || rowStr(row, "id");
-				const entryLocale = rowStr(row, "locale");
-				const shouldPrefixEntry =
-					i18nEnabled &&
-					entryLocale !== "" &&
-					(entryLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
-				const entryId = shouldPrefixEntry ? `${entryLocale}/${entrySlug}` : entrySlug;
+				const entryId = entryIdForRow(row);
 
 				// Preview mode: override content fields with revision data,
 				// keeping system metadata from the content table row.