emdash 1.3.1 → 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/query.ts

@@ -34,9 +34,11 @@ import {
 } 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,
@@ -316,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>({
@@ -325,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] } };
 				},
 			}),
 		);
@@ -626,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) {
@@ -1096,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)),
@@ -1109,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;
@@ -1385,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) {
@@ -1499,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)) };
@@ -1558,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
@@ -1582,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/schema/types.ts

@@ -282,10 +282,11 @@ export interface Collection {
 	/** Whether published entries require a public slug. Defaults to true. */
 	routable?: boolean;
 	/**
-	 * Omit this collection's auto-generated sidebar entry and dashboard quick
-	 * action. The collection stays fully functional everywhere else (API, MCP,
-	 * hooks, direct `/content/:collection` URLs), so a plugin that owns the
-	 * collection can point editors at its own admin UI.
+	 * Omit this collection's auto-generated sidebar entry, dashboard quick
+	 * action, and dashboard Content card row. The collection stays fully
+	 * functional everywhere else (API, MCP, hooks, direct `/content/:collection`
+	 * URLs), so a plugin that owns the collection can point editors at its own
+	 * admin UI.
 	 */
 	hidden: boolean;
 	/**
@@ -358,7 +359,7 @@ export interface CreateCollectionInput {
 	urlPattern?: string;
 	routable?: boolean;
 	hasSeo?: boolean;
-	/** Omit the auto-generated sidebar entry and dashboard quick action (defaults to false) */
+	/** Omit the auto-generated sidebar entry, dashboard quick action, and dashboard Content card row (defaults to false) */
 	hidden?: boolean;
 	/** Explicit admin sidebar position (omit for the alphabetical fallback) */
 	sortOrder?: number | null;
@@ -382,7 +383,7 @@ export interface UpdateCollectionInput {
 	urlPattern?: string | null;
 	routable?: boolean;
 	hasSeo?: boolean;
-	/** Omit the auto-generated sidebar entry and dashboard quick action */
+	/** Omit the auto-generated sidebar entry, dashboard quick action, and dashboard Content card row */
 	hidden?: boolean;
 	/** Explicit admin sidebar position; `null` clears it back to alphabetical */
 	sortOrder?: number | null;

package/src/search/fts-manager.ts

@@ -10,6 +10,7 @@ import { sql } from "kysely";
 import { isSqlite, tableExists as dialectTableExists } from "../database/dialect-helpers.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { isStoragelessFieldRow } from "../schema/types.js";
 import { SEARCH_TOKENIZERS } from "./types.js";
 import type { SearchConfig, SearchTokenizer } from "./types.js";
 
@@ -513,7 +514,8 @@ export class FTSManager {
 	}
 
 	/**
-	 * Get searchable fields for a collection
+	 * Get searchable fields for a collection. Fields that store no column (bound
+	 * reference fields) are left out: the index triggers read each field's column.
 	 */
 	async getSearchableFields(collectionSlug: string): Promise<string[]> {
 		const collection = await this.db
@@ -528,12 +530,12 @@ export class FTSManager {
 
 		const fields = await this.db
 			.selectFrom("_emdash_fields")
-			.select("slug")
+			.select(["slug", "type", "validation"])
 			.where("collection_id", "=", collection.id)
 			.where("searchable", "=", 1)
 			.execute();
 
-		return fields.map((f) => f.slug);
+		return fields.filter((f) => !isStoragelessFieldRow(f)).map((f) => f.slug);
 	}
 
 	/**

package/src/seed/apply.ts

@@ -44,7 +44,11 @@ import { getI18nConfig, getLocaleRank, resolveConfiguredLocale } from "../i18n/c
 import { localeMatches, localeOrder } from "../i18n/query.js";
 import { ssrfSafeFetch, validateExternalUrl } from "../import/ssrf.js";
 import { markContentMediaUsageCollectionStaleSafely } from "../media/usage/content-refresh.js";
-import { coalesceObjectCacheWrites, invalidateMenuObjectCache } from "../object-cache/index.js";
+import {
+	coalesceObjectCacheWrites,
+	invalidateMenuObjectCache,
+	invalidateWidgetObjectCache,
+} from "../object-cache/index.js";
 import { BlockTypeRegistry } from "../schema/block-type-registry.js";
 import { normalizeBlocksData, resolveBlockTypes } from "../schema/block-values.js";
 import { SchemaError, SchemaRegistry } from "../schema/registry.js";
@@ -1259,54 +1263,58 @@ async function applySeedWrites(
 
 	// 10. Widget Areas and Widgets
 	if (seed.widgetAreas) {
-		const areaIds: string[] = [];
-		const widgetRows: Insertable<WidgetTable>[] = [];
-		for (const area of seed.widgetAreas) {
-			// Check if area exists
-			const lookup = db
-				.selectFrom("_emdash_widget_areas")
-				.selectAll()
-				.where("name", "=", area.name);
-			const existingArea = await lookup.executeTakeFirst();
-
-			let areaId: string;
-
-			if (existingArea) {
-				areaId = existingArea.id;
-			} else {
-				// Create area
-				areaId = ulid();
-				const inserted = await db
-					.insertInto("_emdash_widget_areas")
-					.values({
-						id: areaId,
-						name: area.name,
-						label: area.label,
-						description: area.description ?? null,
-					})
-					.onConflict((conflict) => conflict.column("name").doNothing())
-					.returning("id")
-					.executeTakeFirst();
-				if (inserted) {
-					result.widgetAreas.created++;
+		try {
+			const areaIds: string[] = [];
+			const widgetRows: Insertable<WidgetTable>[] = [];
+			for (const area of seed.widgetAreas) {
+				// Check if area exists
+				const lookup = db
+					.selectFrom("_emdash_widget_areas")
+					.selectAll()
+					.where("name", "=", area.name);
+				const existingArea = await lookup.executeTakeFirst();
+
+				let areaId: string;
+
+				if (existingArea) {
+					areaId = existingArea.id;
 				} else {
-					areaId = (await lookup.executeTakeFirstOrThrow()).id;
+					// Create area
+					areaId = ulid();
+					const inserted = await db
+						.insertInto("_emdash_widget_areas")
+						.values({
+							id: areaId,
+							name: area.name,
+							label: area.label,
+							description: area.description ?? null,
+						})
+						.onConflict((conflict) => conflict.column("name").doNothing())
+						.returning("id")
+						.executeTakeFirst();
+					if (inserted) {
+						result.widgetAreas.created++;
+					} else {
+						areaId = (await lookup.executeTakeFirstOrThrow()).id;
+					}
 				}
-			}
 
-			areaIds.push(areaId);
-			for (let i = 0; i < area.widgets.length; i++) {
-				const widget = area.widgets[i];
-				widgetRows.push(createSeedWidgetRow(areaId, widget, i));
-				result.widgetAreas.widgets++;
+				areaIds.push(areaId);
+				for (let i = 0; i < area.widgets.length; i++) {
+					const widget = area.widgets[i];
+					widgetRows.push(createSeedWidgetRow(areaId, widget, i));
+					result.widgetAreas.widgets++;
+				}
 			}
+			await replaceSeedChildren(db, "_emdash_widget_areas", areaIds, (target) => [
+				...areaIds.map((id) => target.deleteFrom("_emdash_widgets").where("area_id", "=", id)),
+				...chunks(widgetRows, SEED_WIDGET_INSERT_BATCH_SIZE).map((rows) =>
+					target.insertInto("_emdash_widgets").values(rows),
+				),
+			]);
+		} finally {
+			invalidateWidgetObjectCache();
 		}
-		await replaceSeedChildren(db, "_emdash_widget_areas", areaIds, (target) => [
-			...areaIds.map((id) => target.deleteFrom("_emdash_widgets").where("area_id", "=", id)),
-			...chunks(widgetRows, SEED_WIDGET_INSERT_BATCH_SIZE).map((rows) =>
-				target.insertInto("_emdash_widgets").values(rows),
-			),
-		]);
 	}
 
 	// 11. Sections

package/src/seed/types.ts

@@ -98,9 +98,9 @@ export interface SeedCollection {
 	/** Require a slug before an entry can be published. Defaults to true. */
 	routable?: boolean;
 	/**
-	 * Omit this collection from the admin sidebar and the dashboard quick
-	 * actions. It stays reachable through the API, MCP, plugin hooks, and
-	 * direct `/content/:collection` URLs.
+	 * Omit this collection from the admin sidebar, the dashboard quick
+	 * actions, and the dashboard Content card. It stays reachable through the
+	 * API, MCP, plugin hooks, and direct `/content/:collection` URLs.
 	 */
 	hidden?: boolean;
 	/**

package/src/taxonomies/index.ts

@@ -12,7 +12,6 @@
 
 import { sql, type Kysely } from "kysely";
 
-import { after } from "../after.js";
 import { taxonomyTag } from "../cache/chrome-tags.js";
 import {
 	parseTaxonomyCollections,
@@ -42,11 +41,11 @@ import { getRequestContext } from "../request-context.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 import {
-	createSingleFlightCache,
-	invalidateSingleFlightCache,
-	type SingleFlightCache,
-	singleFlightCached,
-} from "../utils/single-flight-cache.js";
+	createRevalidatingCache,
+	invalidateRevalidatingCache,
+	revalidatingCached,
+	type RevalidatingCache,
+} from "../utils/revalidating-cache.js";
 import { fetchVisibleTermCounts } from "./term-counts.js";
 import type { TaxonomyDef, TaxonomyTerm, TaxonomyTermRow } from "./types.js";
 
@@ -143,38 +142,17 @@ export function invalidateTermCache(): void {
 }
 
 /**
- * Worker-isolate cache for taxonomy definitions: every locale's rows, resolved
- * per locale in memory.
- *
- * Taxonomy *definitions* (the "category"/"tag" taxonomies themselves, not
- * their terms) are read on every public render that hydrates entry terms —
- * `getAllTermsForEntries` → `getCollectionTaxonomyNames` → `getTaxonomyDefs` —
- * but change extremely rarely: they're written only by the admin API and by
- * seed application. Caching them across the isolate lifetime drops the
- * per-render `SELECT * FROM _emdash_taxonomy_defs` to once-per-isolate.
- *
- * Stored on globalThis behind a Symbol key (same pattern as
- * `settings/index.ts`) so the bundler duplicating this module across SSR
- * chunks can't produce two independent caches. It holds the resolved rows
- * behind a reclaimable single-flight lock, never an in-flight promise (see
- * `utils/single-flight-cache.ts`).
- *
- * When the distributed object cache is configured, it is authoritative and this
- * fallback is bypassed so cross-isolate epoch invalidation cannot be undercut
- * by stale per-isolate data on an object-cache miss.
- *
- * **Isolated databases bypass the cache.** Playground / DO preview requests
- * set `requestContext.dbIsIsolated`; they point at a divergent schema, so we
- * skip both reading and writing the global holder and fall back to the
- * per-request cache (same precedent as `getTaxonomyNames` / byline field defs).
+ * Every locale's definition rows, revalidated in the background after 30 seconds.
+ * The optional object cache remains authoritative when configured; isolated
+ * databases bypass the isolate snapshot.
  */
-const TAXONOMY_DEFS_CACHE_KEY = Symbol.for("emdash:taxonomy-defs@2");
+const TAXONOMY_DEFS_CACHE_KEY = Symbol.for("emdash:taxonomy-defs:swr");
 const taxonomyDefsStore = globalThis as Record<symbol, unknown>;
-const defsCache: SingleFlightCache<TaxonomyDef[]> =
-	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see settings/index.ts)
-	(taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] as SingleFlightCache<TaxonomyDef[]> | undefined) ??
+const defsCache =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern
+	(taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] as RevalidatingCache<TaxonomyDef[]> | undefined) ??
 	(() => {
-		const c = createSingleFlightCache<TaxonomyDef[]>();
+		const c = createRevalidatingCache<TaxonomyDef[]>();
 		taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] = c;
 		return c;
 	})();
@@ -183,22 +161,17 @@ const defsCache: SingleFlightCache<TaxonomyDef[]> =
  * Invalidate the isolate-wide taxonomy-definitions cache (and the related
  * loader taxonomy-names cache). Called from every taxonomy-def write path
  * (`handleTaxonomyCreate`/`Update`/`Delete`, seed application). Other isolates
- * refresh on their next recycle — staleness bounded by isolate lifetime.
+ * pick up remote changes through background revalidation.
  */
 export function invalidateTaxonomyDefsCache(): void {
-	invalidateSingleFlightCache(defsCache);
+	invalidateRevalidatingCache(defsCache);
 	resetTaxonomyNamesCache();
 	invalidateTaxonomyObjectCache();
 }
 
-/**
- * Test/internal helper: clear the per-isolate taxonomy-defs cache. Useful for
- * unit tests that insert defs directly and need to force a refetch without
- * going through a write path. Production code should rely on
- * `invalidateTaxonomyDefsCache()`.
- */
+/** @internal Clear the isolate snapshot between test databases. */
 export function resetTaxonomyDefsCacheForTests(): void {
-	invalidateSingleFlightCache(defsCache);
+	invalidateRevalidatingCache(defsCache);
 }
 
 /** Every locale's definition rows, straight from the database (no caching). */
@@ -216,13 +189,11 @@ async function fetchTaxonomyDefRows(): Promise<TaxonomyDef[]> {
  * for isolated databases.
  */
 function loadTaxonomyDefRows(): Promise<TaxonomyDef[]> {
-	if (getRequestContext()?.dbIsIsolated === true) {
-		return fetchTaxonomyDefRows();
-	}
-	return singleFlightCached(defsCache, fetchTaxonomyDefRows, {
-		anchor: (promise) => after(() => promise),
-		ownerTimeoutMs: 30_000,
-	});
+	const context = getRequestContext();
+	if (context?.dbIsIsolated) return fetchTaxonomyDefRows();
+	return revalidatingCached(defsCache, fetchTaxonomyDefRows, (error) =>
+		console.error("[emdash:taxonomies] revalidating taxonomy definitions failed:", error),
+	);
 }
 
 /**

package/src/transfer/import/advance.ts

@@ -45,7 +45,12 @@ import { TransferStage } from "../staging/stage.js";
 import { ImportContext } from "./context.js";
 import { runRebuild } from "./rebuild.js";
 import { clearScaffold, declaredScaffold } from "./scaffold.js";
-import { firstPosition, ImportCancelledSignal, runRecordStage } from "./stages.js";
+import {
+	firstPosition,
+	ImportCancelledSignal,
+	ImportCollectionDeletionSignal,
+	runRecordStage,
+} from "./stages.js";
 
 /** Delay the caller should wait before advancing again after a retry-later step. */
 export const IMPORT_RETRY_MS = 2000;
@@ -212,6 +217,12 @@ async function advanceClaimed(
 		if (error instanceof ImportCancelledSignal) {
 			return result(await ops.finishCancelled(operation.id, leaseToken), 0);
 		}
+		if (error instanceof ImportCollectionDeletionSignal) {
+			return result(
+				await ops.releaseUnlessCancelled(operation.id, leaseToken, "running"),
+				error.waiting ? IMPORT_RETRY_MS : 0,
+			);
+		}
 		if (isTransferError(error) && LEASE_CODES.has(error.code)) throw error;
 		const code: TransferErrorCode = isTransferError(error) ? error.code : "TRANSFER_IMPORT_ERROR";
 		const detail = isTransferError(error) ? error.detail : undefined;

package/src/transfer/import/scaffold.ts

@@ -8,7 +8,10 @@
 import { sql } from "kysely";
 
 import { processDueMediaUsageCollectionDeletions } from "../../media/usage/collection-deletion-processor.js";
-import { invalidateMenuObjectCache } from "../../object-cache/index.js";
+import {
+	invalidateMenuObjectCache,
+	invalidateWidgetObjectCache,
+} from "../../object-cache/index.js";
 import { SchemaError, SchemaRegistry } from "../../schema/registry.js";
 import { TransferError } from "../errors.js";
 import type { ImportTransformation } from "../format/transformations.js";
@@ -46,6 +49,7 @@ export async function clearScaffold(
 	const items = declaredScaffold(context);
 	let next = step;
 	let removedMenus = false;
+	let removedWidgets = false;
 	try {
 		while (next < items.length) {
 			const item = items[next];
@@ -56,11 +60,13 @@ export async function clearScaffold(
 			context.budget.start();
 			await removeItem(context, item);
 			if (item.type === "menu" || item.type === "menu_item") removedMenus = true;
+			if (item.type === "widget" || item.type === "widget_area") removedWidgets = true;
 			next++;
 			await checkpoint(next);
 		}
 	} finally {
 		if (removedMenus) invalidateMenuObjectCache();
+		if (removedWidgets) invalidateWidgetObjectCache();
 	}
 
 	const collectionIds = items.flatMap((item) => (item.type === "collection" ? [item.id] : []));