emdash 1.3.0 → 1.4.0

package/src/object-cache/index.ts

@@ -525,6 +525,20 @@ export interface CachedQueryOptions<T> {
  * failing `set` is dropped.
  */
 export async function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T> {
+	return cachedQueryWithEpochs(options);
+}
+
+/**
+ * {@link cachedQuery} that also passes `onEpochs` the namespace epochs the read
+ * is checked against and stored under, in namespace order, before the cached
+ * value is returned or `load` runs. Not called when the cache is disabled or
+ * bypassed.
+ *
+ * @internal
+ */
+export async function cachedQueryWithEpochs<T>(
+	options: CachedQueryOptions<T> & { onEpochs?: (epochs: readonly number[]) => void },
+): Promise<T> {
 	const backend = await getBackend();
 	if (!backend || shouldBypass()) {
 		return options.load();
@@ -545,6 +559,7 @@ export async function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T>
 		() => null,
 	);
 	const currentEpochs = await epochsPromise;
+	options.onEpochs?.(currentEpochs);
 	const raw = await rawPromise;
 	if (raw !== null) {
 		const decoded = decode(raw);
@@ -777,6 +792,8 @@ export const CacheNamespace = {
 	SCHEMA: "schema",
 	/** Public (approved) comments. */
 	COMMENTS: "comments",
+	/** Widget areas and their widgets. */
+	WIDGETS: "widgets",
 } as const;
 
 /** Namespace for a content collection's cached queries. */
@@ -835,6 +852,11 @@ export function invalidateMenuObjectCache(): void {
 	invalidateObjectCache(CacheNamespace.MENUS);
 }
 
+/** Invalidate cached widget areas. */
+export function invalidateWidgetObjectCache(): void {
+	invalidateObjectCache(CacheNamespace.WIDGETS);
+}
+
 /** Invalidate cached collection schema/metadata reads (e.g. getCollectionInfo). */
 export function invalidateSchemaObjectCache(): void {
 	invalidateObjectCache(CacheNamespace.SCHEMA);

package/src/plugin-test-runtime.ts

@@ -1,4 +1,5 @@
 export { EmDashRuntime } from "./emdash-runtime.js";
+export { waitForDeferredTasks } from "./deferred-tasks.js";
 export type { RuntimeDependencies } from "./emdash-runtime.js";
 export {
 	dispatchPluginApiRequest,

package/src/plugins/byline-access.ts

@@ -8,6 +8,7 @@ import {
 } from "../database/repositories/types.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { localeMatches } from "../i18n/query.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import type { BylineAccess, BylineCreditInfo, BylineInfo } from "./types.js";
 
@@ -116,7 +117,8 @@ export function createBylineAccess(db: Kysely<Database>): BylineAccess {
 				.orderBy("created_at", "desc")
 				.orderBy("id", "desc")
 				.limit(limit + 1);
-			if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
+			if (options?.locale !== undefined)
+				query = query.where(localeMatches("locale", options.locale));
 			if (options?.cursor) {
 				const decoded = decodeCursor(options.cursor);
 				query = query.where((eb) =>

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,11 +25,20 @@
  */
 
 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 {
+	creditFromFoldedAuthorByline,
 	creditsFromFoldedBylines,
 	CURSOR_RAW_VALUES,
 	encodeSortCursor,
+	FOLDED_AUTHOR_BYLINE,
 	FOLDED_BYLINES,
 	FOLDED_BYLINES_EXIST,
 	FOLDED_TERMS,
@@ -309,7 +318,7 @@ export async function getPublishedDates(
 	options?: { locale?: string },
 ): Promise<PublishedDatesResult> {
 	const locale = effectiveLocaleKey(options) || undefined;
-	const key = `publishedDates:${JSON.stringify([type, locale])}`;
+	const key = `publishedDates:v2:${JSON.stringify([type, locale])}`;
 	try {
 		return await requestCached(key, () =>
 			cachedQuery<PublishedDatesResult>({
@@ -318,20 +327,13 @@ export async function getPublishedDates(
 				load: async () => {
 					const rows = await loadPublishedDates(type, locale);
 					const dates: Date[] = [];
-					let lastModified: Date | undefined;
 					for (const row of rows) {
 						if (row.published_at) {
 							const date = new Date(row.published_at);
 							if (!Number.isNaN(date.getTime())) dates.push(date);
 						}
-						if (row.updated_at) {
-							const modified = new Date(row.updated_at);
-							if (!Number.isNaN(modified.getTime()) && (!lastModified || modified > lastModified)) {
-								lastModified = modified;
-							}
-						}
 					}
-					return { dates, cacheHint: { tags: [type], lastModified } };
+					return { dates, cacheHint: { tags: [type] } };
 				},
 			}),
 		);
@@ -619,7 +621,7 @@ async function loadCollectionCached<T extends string, D = InferCollectionData<T>
 ): Promise<CollectionResult<D>> {
 	const snapshot = await cachedQuery<ContentSnapshot<CachedCollectionValue>>({
 		namespace: contentNamespaces(type),
-		key: `collection:${collectionCacheKey(type, filter)}|loc=${effectiveLocaleKey(filter)}`,
+		key: `collection:v2:${collectionCacheKey(type, filter)}|loc=${effectiveLocaleKey(filter)}`,
 		load: async () => {
 			const result = await getEmDashCollectionUncached<T, D>(type, filter);
 			if (result.error) {
@@ -781,7 +783,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 +917,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 +930,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
@@ -1095,12 +1091,9 @@ async function attachReferences<D>(
 
 	const references: ReferencePages = {};
 	const tags: string[] = [];
-	let lastModified: Date | undefined;
 	for (const [field, page] of Object.entries(pages)) {
 		for (const child of page.entries) {
 			tags.push(...child.cacheHint.tags);
-			const modified = child.cacheHint.lastModified;
-			if (modified && (!lastModified || modified > lastModified)) lastModified = modified;
 		}
 		references[field] = {
 			entries: page.entries.map((child) => wrapReferencedEntry(page.collection, child)),
@@ -1108,16 +1101,16 @@ async function attachReferences<D>(
 		};
 	}
 	entry.references = references;
-	return { tags, ...(lastModified ? { lastModified } : {}) };
+	return { tags };
 }
 
 /**
  * Fold the children's cache hint into the entry's own.
  *
  * A render that shows a referenced entry has read that row, so the route's tags
- * have to name it and its `Last-Modified` has to move when it changes. Without
- * this the route cache's `invalidate({ tags: [collection, id] })` on a child
- * write would never reach the pages that render the child.
+ * have to name it. Without this the route cache's
+ * `invalidate({ tags: [collection, id] })` on a child write would never reach
+ * the pages that render the child.
  */
 function mergeCacheHints(base: CacheHint, extra: CacheHint): CacheHint {
 	if (!extra.tags?.length && !extra.lastModified) return base;
@@ -1197,7 +1190,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 +1338,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;
@@ -1376,7 +1377,7 @@ async function resolveEmDashEntry<T extends string, D = InferCollectionData<T>>(
 
 	const snapshot = await cachedQuery<ContentSnapshot<CachedEntryValue>>({
 		namespace: namespaces,
-		key: `entry:${id}|loc=${requestedLocale ?? ""}${referenceKey}`,
+		key: `entry:v2:${id}|loc=${requestedLocale ?? ""}${referenceKey}`,
 		load: async () => {
 			const result = await resolveNormal();
 			if (result.error) {
@@ -1446,7 +1447,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");
@@ -1489,17 +1491,14 @@ export async function getEmDashReferences<D = Record<string, unknown>>(
 		if (!page) return { entries: [] };
 
 		const tags: string[] = [];
-		let lastModified: Date | undefined;
 		for (const child of page.entries) {
 			tags.push(...child.cacheHint.tags);
-			const modified = child.cacheHint.lastModified;
-			if (modified && (!lastModified || modified > lastModified)) lastModified = modified;
 		}
 
 		return {
 			entries: page.entries.map((child) => wrapReferencedEntry<D>(page.collection, child)),
 			...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
-			cacheHint: { tags, ...(lastModified ? { lastModified } : {}) },
+			cacheHint: { tags },
 		};
 	} catch (error) {
 		return { entries: [], error: error instanceof Error ? error : new Error(String(error)) };
@@ -1548,17 +1547,30 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
 	if (entries.length === 0) return;
 
 	// Fast path: bylines were folded into the content query. Parse the JSON
-	// (no extra round trip) for the common case — explicit credits, no byline
-	// custom fields, no author fallback. The query path below handles the rest:
-	//  - author fallback (entry has authorId but no explicit credit), and
-	//  - custom byline fields (can't be expressed in the folded subquery).
+	// (no extra round trip): explicit credits, plus the author-fallback byline
+	// for an entry with none. Custom byline field values can't be expressed in
+	// the folded subquery, so when any credit resolves they are loaded for the
+	// folded bylines in one batched pass. The query path below handles only
+	// what the fold can't vouch for.
 	if (entries.every((e) => FOLDED_BYLINES in entryData(e))) {
 		const parsed = entries.map((entry) => {
 			const data = entryData(entry);
 			const folded = Reflect.get(data, FOLDED_BYLINES);
 			const rows = Array.isArray(folded) ? folded : [];
 			const credits = creditsFromFoldedBylines(rows);
-			return { data, credits };
+			// The fold is complete for an entry with no explicit credit when its
+			// author fallback was folded too and it has a locale: the query path
+			// resolves the fallback in that same locale (`(user_id, locale)` is
+			// unique), and a `primaryBylineId` without an explicit credit
+			// resolves to no byline on both paths.
+			const authorFolded = FOLDED_AUTHOR_BYLINE in data && dataStr(data, "locale") !== "";
+			if (credits.length === 0 && authorFolded && dataStr(data, "primaryBylineId") === "") {
+				const author = Reflect.get(data, FOLDED_AUTHOR_BYLINE);
+				if (dataStr(data, "authorId") !== "" && isRecord(author)) {
+					credits.push(creditFromFoldedAuthorByline(author));
+				}
+			}
+			return { data, credits, complete: credits.length > 0 || authorFolded };
 		});
 
 		// An empty `_emdash_bylines` table makes an empty fold authoritative: no
@@ -1572,34 +1584,36 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
 
 		// Fall back to the full query path when the fold can't be trusted to be
 		// complete: an entry with a byline reference (explicit primary, or an
-		// author for the author-fallback) but no folded credits — e.g. a credit
-		// in a different locale than the row, which the locale-correlated subquery
-		// skips, or the author-fallback path which the fold doesn't express.
+		// author for the author-fallback) but no folded credits, and no folded
+		// author fallback either — e.g. a row read without the author column,
+		// or an entry with no locale, which the locale-correlated subqueries
+		// can't match.
 		let needsQueryPath =
 			!knownEmpty &&
 			parsed.some(
 				(p) =>
-					p.credits.length === 0 &&
+					!p.complete &&
 					(dataStr(p.data, "authorId") !== "" || dataStr(p.data, "primaryBylineId") !== ""),
 			);
-		let hasCustomFields = false;
-		if (!needsQueryPath && !knownEmpty) {
+
+		// Custom byline fields: only bylines that resolved need their values, so
+		// an entry set with no credits skips the field-definition probe too.
+		const summaries = parsed.flatMap((p) => p.credits.map((c) => c.byline));
+		if (!needsQueryPath && summaries.length > 0) {
 			try {
 				const { getDb } = await import("./loader.js");
-				const db = await getDb();
-				const { getBylineFieldDefs } = await import("./bylines/field-defs-cache.js");
-				hasCustomFields = (await getBylineFieldDefs(db)).length > 0;
+				const { BylineRepository } = await import("./database/repositories/byline.js");
+				await new BylineRepository(await getDb()).hydrateBylineCustomFields(summaries);
 			} catch (error) {
 				// A missing table is expected pre-migration and means there are no
 				// custom fields — the fold's values are complete. Any other error
-				// (lock-init failure, dialect error) means the probe can't be
-				// trusted, so fall back to the query path rather than risk serving
-				// folded bylines with empty customFields.
+				// means the values can't be trusted, so fall back to the query
+				// path rather than risk serving bylines with empty customFields.
 				if (!isMissingTableError(error)) needsQueryPath = true;
 			}
 		}
 
-		if (!needsQueryPath && !hasCustomFields) {
+		if (!needsQueryPath) {
 			for (const p of parsed) {
 				p.data.bylines = p.credits;
 				p.data.byline = p.credits[0]?.byline ?? null;

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;
 }