emdash 1.3.0 → 1.3.1

package/src/plugins/context.ts

@@ -403,8 +403,7 @@ export function createTaxonomyAccess(db: Kysely<Database>): TaxonomyAccess {
 
 	return {
 		async getAll(options?: TaxonomyReadOptions): Promise<TaxonomyDefInfo[]> {
-			let query = selectTaxonomyDefs(db);
-			if (options?.locale !== undefined) query = query.where("d.locale", "=", options.locale);
+			const query = selectTaxonomyDefs(db, options?.locale);
 			const rows = await query.orderBy("d.name", "asc").execute();
 			return rows.map((row) => ({
 				name: row.name,

package/src/plugins/storage-indexes.ts

@@ -135,19 +135,23 @@ export async function createStorageIndexes(
 			});
 			await createSql.execute(db);
 
-			// Track in _plugin_indexes table
+			// Track in _plugin_indexes table. Only rewrite the row when the stored
+			// fields differ from the declared ones so repeated identical syncs do
+			// not perform needless writes (see issue #4228).
+			const fieldsJson = JSON.stringify(fields);
 			await db
 				.insertInto("_plugin_indexes")
 				.values({
 					plugin_id: pluginId,
 					collection,
 					index_name: indexName,
-					fields: JSON.stringify(fields),
+					fields: fieldsJson,
 				})
 				.onConflict((oc) =>
 					oc
 						.columns(["plugin_id", "collection", "index_name"])
-						.doUpdateSet({ fields: JSON.stringify(fields) }),
+						.doUpdateSet({ fields: fieldsJson })
+						.whereRef("_plugin_indexes.fields", "!=", "excluded.fields"),
 				)
 				.execute();
 

package/src/query.ts

@@ -25,7 +25,14 @@
  */
 
 import type { ContentSeo } from "./database/repositories/types.js";
-import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./i18n/config.js";
+import {
+	getFallbackChain,
+	getI18nConfig,
+	getLocaleCandidates,
+	isI18nEnabled,
+	resolveConfiguredLocale,
+} from "./i18n/config.js";
+import { resolveLocale } from "./i18n/resolve.js";
 import {
 	creditsFromFoldedBylines,
 	CURSOR_RAW_VALUES,
@@ -781,7 +788,7 @@ function collectionCacheKey(type: string, filter?: CollectionFilter): string {
 		filter.offset ?? "",
 		filter.where ? stableStringify(filter.where) : "",
 		filter.orderBy ? JSON.stringify(filter.orderBy) : "",
-		filter.locale ?? "",
+		filter.locale === undefined ? "" : resolveConfiguredLocale(filter.locale),
 	];
 	return `collection:${type}:${parts.join("|")}`;
 }
@@ -915,11 +922,7 @@ function reviveEntry<D>(raw: unknown): ContentEntry<D> {
 
 /** Resolve the effective locale used by content reads, for the L2 cache key. */
 function effectiveLocaleKey(filter?: { locale?: string }): string {
-	const ctx = getRequestContext();
-	const i18nConfig = getI18nConfig();
-	return (
-		filter?.locale ?? ctx?.locale ?? (isI18nEnabled() ? i18nConfig!.defaultLocale : undefined) ?? ""
-	);
+	return resolveLocale(filter?.locale) ?? "";
 }
 
 async function getEmDashCollectionUncached<T extends string, D = InferCollectionData<T>>(
@@ -932,9 +935,7 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	// Resolve locale: explicit filter > ALS context > defaultLocale (when i18n enabled)
 	// Without this, queries return all locale rows, producing broken IDs
 	const ctx = getRequestContext();
-	const i18nConfig = getI18nConfig();
-	const resolvedLocale =
-		filter?.locale ?? ctx?.locale ?? (isI18nEnabled() ? i18nConfig!.defaultLocale : undefined);
+	const resolvedLocale = resolveLocale(filter?.locale);
 
 	const requestedLimit = filter?.limit;
 	// cursor and offset are mutually exclusive on the loader filter union, so
@@ -1197,7 +1198,8 @@ async function resolveEmDashEntry<T extends string, D = InferCollectionData<T>>(
 	const serveDrafts = isPreviewMode || isEditMode;
 
 	// Resolve locale: explicit option > ALS context > undefined (no filter)
-	const requestedLocale = options?.locale ?? ctx?.locale;
+	const rawLocale = options?.locale ?? ctx?.locale;
+	const requestedLocale = rawLocale === undefined ? undefined : resolveConfiguredLocale(rawLocale);
 	const references = options?.references;
 	const portableTextFields = isEditMode ? await getPortableTextFieldSlugs(type) : undefined;
 
@@ -1344,7 +1346,14 @@ async function resolveEmDashEntry<T extends string, D = InferCollectionData<T>>(
 			const locale = localeChain[i];
 			const fallbackLocale = i > 0 ? locale : undefined;
 
-			const { entry, error, cacheHint } = await getLiveEntry(COLLECTION_NAME, { type, id, locale });
+			const { entry, error, cacheHint } = await getLiveEntry(COLLECTION_NAME, {
+				type,
+				id,
+				locale,
+				...(locale !== undefined && getLocaleCandidates(locale).length > 1
+					? { publishedOnly: true }
+					: {}),
+			});
 			if (error) {
 				// Astro reports a missing entry as an error; try the next locale.
 				if (error.name === "LiveEntryNotFoundError") continue;
@@ -1446,7 +1455,8 @@ export async function getEmDashReferences<D = Record<string, unknown>>(
 	const ctx = getRequestContext();
 	const preview = ctx?.preview;
 	const isEditMode = ctx?.editMode ?? false;
-	const locale = options?.locale ?? ctx?.locale;
+	const rawLocale = options?.locale ?? ctx?.locale;
+	const locale = rawLocale === undefined ? undefined : resolveConfiguredLocale(rawLocale);
 
 	try {
 		const { getDb } = await import("./loader.js");

package/src/redirects/artifacts.ts

@@ -19,6 +19,7 @@ import { after } from "../after.js";
 import { RedirectRepository } from "../database/repositories/redirect.js";
 import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
+import { normalizeSiteSettingsVersion, siteSettingsVersionQuery } from "../settings/version.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 import {
@@ -296,12 +297,29 @@ function parseEntries(payload: string): ArtifactEntry[] | null {
 	}
 }
 
+function observeSiteSettingsVersion(
+	callback: ((version: string | null) => void) | undefined,
+	raw: string | null | undefined,
+): void {
+	if (!callback) return;
+	let version: string | null = null;
+	try {
+		if (raw) version = normalizeSiteSettingsVersion(raw);
+	} catch {
+		// A failed settings check must not prevent valid redirects from loading.
+	}
+	callback(version);
+}
+
 /**
  * Loads and verifies the active generation. Returns null when nothing is
  * published, the generation is stale, or any artifact is missing, altered, or
  * out of place.
  */
-async function loadPublishedRedirects(db: Kysely<Database>): Promise<RedirectRuleSet | null> {
+async function loadPublishedRedirects(
+	db: Kysely<Database>,
+	onSiteSettingsVersion?: (version: string | null) => void,
+): Promise<RedirectRuleSet | null> {
 	const rows = await db
 		.selectFrom("_emdash_redirect_state as state")
 		.leftJoin(
@@ -314,6 +332,7 @@ async function loadPublishedRedirects(db: Kysely<Database>): Promise<RedirectRul
 			"state.revision",
 			"state.generation",
 			"state.generation_revision",
+			...(onSiteSettingsVersion ? [siteSettingsVersionQuery(db).as("site_settings_version")] : []),
 			"link.position",
 			"link.digest",
 			"artifact.kind",
@@ -324,6 +343,7 @@ async function loadPublishedRedirects(db: Kysely<Database>): Promise<RedirectRul
 		.execute();
 
 	const state = rows[0];
+	observeSiteSettingsVersion(onSiteSettingsVersion, state?.site_settings_version);
 	if (!state?.generation) return null;
 	if (Number(state.revision) > Number(state.generation_revision)) return null;
 
@@ -432,14 +452,20 @@ function scheduleRedirectRepair(db: Kysely<Database>): void {
  * current and verifies, otherwise the rules table. Before the artifact tables exist the
  * rules table is read directly.
  */
-export function createRedirectSource(db: Kysely<Database>): RedirectSource {
+export function createRedirectSource(
+	db: Kysely<Database>,
+	onSiteSettingsVersion?: (version: string | null) => void,
+): RedirectSource {
 	return {
 		async load() {
 			let published: RedirectRuleSet | null;
 			try {
-				published = await loadPublishedRedirects(db);
+				published = await loadPublishedRedirects(db, onSiteSettingsVersion);
 			} catch (error) {
-				if (isMissingTableError(error)) return loadRulesTable(db);
+				if (isMissingTableError(error)) {
+					onSiteSettingsVersion?.(null);
+					return loadRulesTable(db);
+				}
 				throw error;
 			}
 			if (published) return published;
@@ -449,9 +475,17 @@ export function createRedirectSource(db: Kysely<Database>): RedirectSource {
 		async isCurrent(version) {
 			const state = await db
 				.selectFrom("_emdash_redirect_state")
-				.select(["revision", "generation", "generation_revision"])
+				.select([
+					"revision",
+					"generation",
+					"generation_revision",
+					...(onSiteSettingsVersion
+						? [siteSettingsVersionQuery(db).as("site_settings_version")]
+						: []),
+				])
 				.where("id", "=", 1)
 				.executeTakeFirst();
+			observeSiteSettingsVersion(onSiteSettingsVersion, state?.site_settings_version);
 			return (
 				state?.generation === version && Number(state.revision) <= Number(state.generation_revision)
 			);

package/src/references/field-map.ts

@@ -16,7 +16,7 @@ import type { Database } from "../database/types.js";
 import { getDb } from "../loader.js";
 import { cachedQuery, CacheNamespace } from "../object-cache/index.js";
 import { requestCached } from "../request-cache.js";
-import { isMissingTableError } from "../utils/db-errors.js";
+import { isMissingColumnError, isMissingTableError } from "../utils/db-errors.js";
 
 /** One reference field, as a render needs it. */
 export interface ReferenceFieldBinding {
@@ -43,7 +43,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 async function loadBindings(
 	db: Kysely<Database>,
 	collection: string,
-): Promise<ReferenceFieldBinding[]> {
+): Promise<ReferenceFieldBinding[] | null> {
 	// The relation's id joins in here rather than being looked up per field at
 	// render time: the field stores a slug, but the link table is keyed by id.
 	const relationSlug = jsonExtractExpr(db, "validation", "relation");
@@ -62,7 +62,8 @@ async function loadBindings(
 		`.execute(db);
 		rows = result.rows;
 	} catch (error) {
-		if (isMissingTableError(error)) return [];
+		// A partial schema is transient; don't retain its degraded result in cache.
+		if (isMissingTableError(error) || isMissingColumnError(error)) return null;
 		throw error;
 	}
 
@@ -109,7 +110,8 @@ export function getReferenceFieldMap(
 			namespace: CacheNamespace.SCHEMA,
 			key: `reference-field-map:${collection}`,
 			load: async () => loadBindings(await getDb(), collection),
+			cacheable: (value) => value !== null,
 		});
-		return new Map(bindings.map((binding) => [binding.slug, binding]));
+		return new Map((bindings ?? []).map((binding) => [binding.slug, binding]));
 	});
 }

package/src/request-context.ts

@@ -21,6 +21,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 import type { QueryRecorder } from "./database/instrumentation.js";
 import type { DeferredTaskTracker } from "./deferred-tasks.js";
+import type { SiteSettings } from "./settings/types.js";
 
 /**
  * Lightweight always-on counters surfaced in Server-Timing.
@@ -73,6 +74,13 @@ export interface EmDashRequestContext {
 	 * eventually-consistent object-cache snapshot.
 	 */
 	routeCacheFill?: boolean;
+	/** Shares verified settings with components that render after cache headers are sent. @internal */
+	siteSettings?: {
+		snapshot?: { data: Partial<SiteSettings>; version: string };
+		version?: string;
+		live?: boolean;
+		onRead: (version: string) => void;
+	};
 	/** Preview token info, if this is a preview request */
 	preview?: {
 		collection: string;

package/src/schema/collection-slugs-cache.ts

@@ -12,8 +12,9 @@
  *
  * Stored on globalThis behind a Symbol key (same pattern as the taxonomy-defs
  * cache in `taxonomies/index.ts`) so bundler chunk duplication cannot produce
- * two independent caches. The promise is cached, so concurrent cold readers
- * share one in-flight query; a rejection evicts the entry.
+ * two independent caches. It holds the resolved set behind a reclaimable
+ * single-flight lock, never an in-flight promise (see
+ * `utils/single-flight-cache.ts`).
  *
  * Freshness:
  * - Primed for free at isolate boot: runtime init's auto-seed gate already
@@ -37,23 +38,30 @@
 
 import type { Kysely } from "kysely";
 
+import { after } from "../after.js";
 import type { Database } from "../database/types.js";
 import { requestCached } from "../request-cache.js";
 import { getRequestContext } from "../request-context.js";
+import {
+	createSingleFlightCache,
+	invalidateSingleFlightCache,
+	type SingleFlightCache,
+	singleFlightCached,
+} from "../utils/single-flight-cache.js";
 
 interface SlugsHolder {
-	promise: Promise<Set<string>> | null;
-	/** When the cached promise was created; gates bounded revalidation. */
+	cache: SingleFlightCache<Set<string>>;
+	/** When the cached set was fetched; gates bounded revalidation. */
 	fetchedAt: number;
 }
 
-const HOLDER_KEY = Symbol.for("emdash:collection-slugs");
+const HOLDER_KEY = Symbol.for("emdash:collection-slugs@2");
 const g = globalThis as Record<symbol, unknown>;
 const holder: SlugsHolder =
 	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-cache.ts)
 	(g[HOLDER_KEY] as SlugsHolder | undefined) ??
 	(() => {
-		const h: SlugsHolder = { promise: null, fetchedAt: 0 };
+		const h: SlugsHolder = { cache: createSingleFlightCache(), fetchedAt: 0 };
 		g[HOLDER_KEY] = h;
 		return h;
 	})();
@@ -67,14 +75,15 @@ async function fetchSlugs(db: Kysely<Database>): Promise<Set<string>> {
 }
 
 function loadSlugs(db: Kysely<Database>): Promise<Set<string>> {
-	if (holder.promise) return holder.promise;
-	const promise = fetchSlugs(db).catch((error: unknown) => {
-		if (holder.promise === promise) holder.promise = null;
-		throw error;
-	});
-	holder.promise = promise;
-	holder.fetchedAt = Date.now();
-	return promise;
+	return singleFlightCached(
+		holder.cache,
+		async () => {
+			const slugs = await fetchSlugs(db);
+			holder.fetchedAt = Date.now();
+			return slugs;
+		},
+		{ anchor: (promise) => after(() => promise), ownerTimeoutMs: 30_000 },
+	);
 }
 
 /**
@@ -96,7 +105,9 @@ export async function filterToRegisteredCollections(
 	let slugs = await loadSlugs(db);
 	let present = collections.filter((slug) => slugs.has(slug));
 	if (present.length < collections.length && Date.now() - holder.fetchedAt > revalidateWindowMs) {
-		holder.promise = null;
+		// Stamped before the refetch so parallel readers of the stale set skip their own.
+		holder.fetchedAt = Date.now();
+		invalidateSingleFlightCache(holder.cache);
 		slugs = await loadSlugs(db);
 		present = collections.filter((slug) => slugs.has(slug));
 	}
@@ -109,7 +120,10 @@ export async function filterToRegisteredCollections(
  * auto-seed gate.
  */
 export function primeRegisteredCollections(slugs: readonly string[]): void {
-	holder.promise = Promise.resolve(new Set(slugs));
+	const { cache } = holder;
+	cache.value = new Set(slugs);
+	cache.hasValue = true;
+	cache.valueVersion = cache.version;
 	holder.fetchedAt = Date.now();
 }
 
@@ -119,7 +133,7 @@ export function primeRegisteredCollections(slugs: readonly string[]): void {
  * create/delete). Other isolates converge through bounded revalidation.
  */
 export function resetRegisteredCollectionsCache(): void {
-	holder.promise = null;
+	invalidateSingleFlightCache(holder.cache);
 	holder.fetchedAt = 0;
 }
 

package/src/schema/registry.ts

@@ -1324,6 +1324,7 @@ export class SchemaRegistry {
 		);
 
 		let schemaMutated = false;
+		let fieldStorageReady = false;
 		try {
 			const created = await withTransaction(this.db, async (trx) => {
 				// Insert field record
@@ -1367,6 +1368,8 @@ export class SchemaRegistry {
 					);
 				}
 
+				fieldStorageReady = true;
+
 				if (input.indexed) {
 					await this.createFieldIndex(collectionSlug, id, input.slug, trx);
 				}
@@ -1405,6 +1408,12 @@ export class SchemaRegistry {
 			return created;
 		} catch (error) {
 			if (schemaMutated) {
+				// D1 cannot roll back the insert when ADD COLUMN fails. Once storage
+				// exists, later failures must not remove its field metadata.
+				if (!fieldStorageReady) {
+					await this.db.deleteFrom("_emdash_fields").where("id", "=", id).execute();
+				}
+
 				if (activeCoverageInvalidated) {
 					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
 				} else {

package/src/schema/zod-generator.ts

@@ -164,6 +164,7 @@ function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodTy
 				id: z.string(),
 				src: z.string().optional(),
 				alt: z.string().optional(),
+				caption: z.string().optional(),
 				width: z.number().optional(),
 				height: z.number().optional(),
 				filename: z.string().optional(),
@@ -641,7 +642,7 @@ function fieldTypeToTypeScript(field: {
 
 		case "image": {
 			const media =
-				"{ id: string; src?: string; alt?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; focalX?: number; focalY?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
+				"{ id: string; src?: string; alt?: string; caption?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; focalX?: number; focalY?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
 			return `${media.slice(0, -2)}; darkVariant?: ${media} }`;
 		}
 

package/src/search/fts-manager.ts

@@ -27,6 +27,47 @@ function resolveSearchTokenizer(tokenize?: SearchTokenizer): SearchTokenizer {
 	return tokenize;
 }
 
+export interface CollectionSearchMetadata {
+	config: SearchConfig;
+	searchableFields: string[];
+	hasTitle: boolean;
+}
+
+function parseSearchConfig(searchConfig: string, titleField: string | null): SearchConfig | null {
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		if (
+			typeof parsed !== "object" ||
+			parsed === null ||
+			!("enabled" in parsed) ||
+			typeof parsed.enabled !== "boolean"
+		) {
+			return null;
+		}
+		const config: SearchConfig = { enabled: parsed.enabled };
+		if (titleField) config.titleField = titleField;
+		if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
+			// weights is a JSON-parsed object — safe to treat as Record<string, number>
+			const weights: Record<string, number> = {};
+			for (const [k, v] of Object.entries(parsed.weights)) {
+				if (typeof v === "number") {
+					weights[k] = v;
+				}
+			}
+			config.weights = weights;
+		}
+		if ("tokenize" in parsed) {
+			if (!isSearchTokenizer(parsed.tokenize)) {
+				return null;
+			}
+			config.tokenize = parsed.tokenize;
+		}
+		return config;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * FTS5 Manager
  *
@@ -394,38 +435,67 @@ export class FTSManager {
 			return null;
 		}
 
-		try {
-			const parsed: unknown = JSON.parse(result.search_config);
+		return parseSearchConfig(result.search_config, result.title_field);
+	}
+
+	/**
+	 * Load all metadata needed to search the requested collections in one round trip.
+	 * Omitted or empty slugs select all search-enabled collections.
+	 */
+	async getSearchMetadata(
+		collectionSlugs?: string[],
+	): Promise<Map<string, CollectionSearchMetadata>> {
+		if (!isSqlite(this.db)) return new Map();
+
+		let query = this.db
+			.selectFrom("_emdash_collections as c")
+			.select([
+				"c.slug",
+				"c.search_config",
+				"c.title_field",
+				// bm25 weights are positional, so use the index's physical column order.
+				sql<string>`(
+					SELECT json_group_array(name ORDER BY cid)
+					FROM pragma_table_info(${"_emdash_fts_"} || c.slug)
+					WHERE cid >= 2
+				)`.as("searchable_fields"),
+				sql<number>`EXISTS (
+					SELECT 1 FROM _emdash_fields WHERE collection_id = c.id AND slug = 'title'
+				)`.as("has_title"),
+			])
+			.where("c.search_config", "is not", null).where(sql<boolean>`EXISTS (
+				SELECT 1 FROM sqlite_master
+				WHERE type = 'table' AND name = ${"_emdash_fts_"} || c.slug
+			)`);
+
+		if (collectionSlugs?.length) {
+			query = query.where(
+				"c.slug",
+				"in",
+				sql<string>`(SELECT value FROM json_each(${JSON.stringify(collectionSlugs)}))`,
+			);
+		}
+
+		const metadata = new Map<string, CollectionSearchMetadata>();
+		for (const row of await query.execute()) {
+			const config = row.search_config
+				? parseSearchConfig(row.search_config, row.title_field)
+				: null;
+			if (!config?.enabled) continue;
+			const searchableFields: unknown = JSON.parse(row.searchable_fields);
 			if (
-				typeof parsed !== "object" ||
-				parsed === null ||
-				!("enabled" in parsed) ||
-				typeof parsed.enabled !== "boolean"
+				!Array.isArray(searchableFields) ||
+				!searchableFields.every((field: unknown) => typeof field === "string")
 			) {
-				return null;
-			}
-			const config: SearchConfig = { enabled: parsed.enabled };
-			if (result.title_field) config.titleField = result.title_field;
-			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
-				// weights is a JSON-parsed object — safe to treat as Record<string, number>
-				const weights: Record<string, number> = {};
-				for (const [k, v] of Object.entries(parsed.weights)) {
-					if (typeof v === "number") {
-						weights[k] = v;
-					}
-				}
-				config.weights = weights;
+				throw new Error("Invalid FTS field metadata");
 			}
-			if ("tokenize" in parsed) {
-				if (!isSearchTokenizer(parsed.tokenize)) {
-					return null;
-				}
-				config.tokenize = parsed.tokenize;
-			}
-			return config;
-		} catch {
-			return null;
+			metadata.set(row.slug, {
+				config,
+				searchableFields,
+				hasTitle: Boolean(row.has_title),
+			});
 		}
+		return metadata;
 	}
 
 	/**