emdash 0.25.1 → 0.27.0

package/src/plugins/define-plugin.ts

@@ -22,11 +22,6 @@ import type {
 	PluginStorageConfig,
 } from "./types.js";
 
-// Plugin ID validation patterns
-const SIMPLE_ID = /^[a-z0-9-]+$/;
-const SCOPED_ID = /^@[a-z0-9-]+\/[a-z0-9-]+$/;
-const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
-
 /**
  * Define a native EmDash plugin.
  *
@@ -94,6 +89,20 @@ export function definePlugin<TStorage extends PluginStorageConfig>(
 function defineNativePlugin<TStorage extends PluginStorageConfig>(
 	definition: PluginDefinition<TStorage>,
 ): ResolvedPlugin<TStorage> {
+	// Declared function-local (not module scope) on purpose. Under
+	// `ssr.noExternal` the worker entry can instantiate native plugins during a
+	// circular module init, reaching this function before module-scope consts
+	// initialize -> "Cannot access 'SIMPLE_ID' before initialization" -> every
+	// route 500s on Cloudflare Workers. Call-time consts evaluate after the
+	// literals are parsed, so the temporal dead zone cannot occur regardless of
+	// bundle ordering. See #1370.
+	// oxlint-disable-next-line e18e/prefer-static-regex -- call-time on purpose (see #1370)
+	const SIMPLE_ID = /^[a-z0-9-]+$/;
+	// oxlint-disable-next-line e18e/prefer-static-regex -- call-time on purpose (see #1370)
+	const SCOPED_ID = /^@[a-z0-9-]+\/[a-z0-9-]+$/;
+	// oxlint-disable-next-line e18e/prefer-static-regex -- call-time on purpose (see #1370)
+	const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
+
 	const {
 		id,
 		version,

package/src/plugins/hooks.ts

@@ -17,7 +17,7 @@ import type {
 	PluginContext,
 	ContentHookEvent,
 	ContentDeleteEvent,
-	ContentPublishStateChangeEvent,
+	ContentStateChangeEvent,
 	MediaUploadEvent,
 	MediaAfterUploadEvent,
 	LifecycleEvent,
@@ -33,7 +33,9 @@ import type {
 	ContentAfterDeleteHandler,
 	ContentAfterPublishHandler,
 	ContentAfterRestoreHandler,
+	ContentAfterScheduleHandler,
 	ContentAfterUnpublishHandler,
+	ContentAfterUnscheduleHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
 	LifecycleHandler,
@@ -68,6 +70,8 @@ type HookNameV2 =
 	| "content:afterPublish"
 	| "content:afterUnpublish"
 	| "content:afterRestore"
+	| "content:afterSchedule"
+	| "content:afterUnschedule"
 	| "media:beforeUpload"
 	| "media:afterUpload"
 	| "cron"
@@ -84,6 +88,13 @@ type HookNameV2 =
 /**
  * Map from hook name to handler type — used for type-safe hook retrieval
  */
+type ContentStateChangeHookName =
+	| "content:afterPublish"
+	| "content:afterUnpublish"
+	| "content:afterRestore"
+	| "content:afterSchedule"
+	| "content:afterUnschedule";
+
 interface HookHandlerMap {
 	"plugin:install": LifecycleHandler;
 	"plugin:activate": LifecycleHandler;
@@ -96,6 +107,8 @@ interface HookHandlerMap {
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
 	"content:afterRestore": ContentAfterRestoreHandler;
+	"content:afterSchedule": ContentAfterScheduleHandler;
+	"content:afterUnschedule": ContentAfterUnscheduleHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;
@@ -224,6 +237,8 @@ export class HookPipeline {
 			this.registerPluginHook(plugin, "content:afterPublish");
 			this.registerPluginHook(plugin, "content:afterUnpublish");
 			this.registerPluginHook(plugin, "content:afterRestore");
+			this.registerPluginHook(plugin, "content:afterSchedule");
+			this.registerPluginHook(plugin, "content:afterUnschedule");
 			this.registerPluginHook(plugin, "media:beforeUpload");
 			this.registerPluginHook(plugin, "media:afterUpload");
 			this.registerPluginHook(plugin, "cron");
@@ -269,6 +284,8 @@ export class HookPipeline {
 		["content:afterPublish", "content:read"],
 		["content:afterUnpublish", "content:read"],
 		["content:afterRestore", "content:read"],
+		["content:afterSchedule", "content:read"],
+		["content:afterUnschedule", "content:read"],
 		// Media
 		["media:beforeUpload", "media:write"],
 		["media:afterUpload", "media:read"],
@@ -653,18 +670,19 @@ export class HookPipeline {
 	}
 
 	/**
-	 * Run content:afterPublish hooks (fire-and-forget).
+	 * Run content state-change hooks that all share the same event shape.
 	 */
-	async runContentAfterPublish(
+	private async runContentStateChangeHook(
+		name: ContentStateChangeHookName,
 		content: Record<string, unknown>,
 		collection: string,
 	): Promise<HookResult<void>[]> {
-		const hooks = this.getTypedHooks("content:afterPublish");
+		const hooks = this.getTypedHooks(name);
 		const results: HookResult<void>[] = [];
 
 		for (const hook of hooks) {
 			const { handler } = hook;
-			const event: ContentPublishStateChangeEvent = { content, collection };
+			const event: ContentStateChangeEvent = { content, collection };
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 
@@ -692,6 +710,16 @@ export class HookPipeline {
 		return results;
 	}
 
+	/**
+	 * Run content:afterPublish hooks (fire-and-forget).
+	 */
+	async runContentAfterPublish(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterPublish", content, collection);
+	}
+
 	/**
 	 * Run content:afterUnpublish hooks (fire-and-forget).
 	 */
@@ -699,37 +727,7 @@ export class HookPipeline {
 		content: Record<string, unknown>,
 		collection: string,
 	): Promise<HookResult<void>[]> {
-		const hooks = this.getTypedHooks("content:afterUnpublish");
-		const results: HookResult<void>[] = [];
-
-		for (const hook of hooks) {
-			const { handler } = hook;
-			const event: ContentPublishStateChangeEvent = { content, collection };
-			const ctx = this.getContext(hook.pluginId);
-			const start = Date.now();
-
-			try {
-				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
-				results.push({
-					success: true,
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
-			} catch (error) {
-				results.push({
-					success: false,
-					error: error instanceof Error ? error : new Error(String(error)),
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
-
-				if (hook.errorPolicy === "abort") {
-					throw error;
-				}
-			}
-		}
-
-		return results;
+		return this.runContentStateChangeHook("content:afterUnpublish", content, collection);
 	}
 
 	/**
@@ -739,37 +737,27 @@ export class HookPipeline {
 		content: Record<string, unknown>,
 		collection: string,
 	): Promise<HookResult<void>[]> {
-		const hooks = this.getTypedHooks("content:afterRestore");
-		const results: HookResult<void>[] = [];
-
-		for (const hook of hooks) {
-			const { handler } = hook;
-			const event: ContentPublishStateChangeEvent = { content, collection };
-			const ctx = this.getContext(hook.pluginId);
-			const start = Date.now();
-
-			try {
-				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
-				results.push({
-					success: true,
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
-			} catch (error) {
-				results.push({
-					success: false,
-					error: error instanceof Error ? error : new Error(String(error)),
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
+		return this.runContentStateChangeHook("content:afterRestore", content, collection);
+	}
 
-				if (hook.errorPolicy === "abort") {
-					throw error;
-				}
-			}
-		}
+	/**
+	 * Run content:afterSchedule hooks (fire-and-forget).
+	 */
+	async runContentAfterSchedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterSchedule", content, collection);
+	}
 
-		return results;
+	/**
+	 * Run content:afterUnschedule hooks (fire-and-forget).
+	 */
+	async runContentAfterUnschedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterUnschedule", content, collection);
 	}
 
 	// =========================================================================

package/src/plugins/index.ts

@@ -128,6 +128,9 @@ export type {
 	ContentHookEvent,
 	ContentDeleteEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	MediaUploadEvent,
 	MediaAfterUploadEvent,
 	LifecycleEvent,
@@ -149,6 +152,8 @@ export type {
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
 	ContentAfterRestoreHandler,
+	ContentAfterScheduleHandler,
+	ContentAfterUnscheduleHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
 	LifecycleHandler,

package/src/plugins/manager.ts

@@ -381,6 +381,28 @@ export class PluginManager {
 		return this.hookPipeline!.runContentAfterRestore(content, collection);
 	}
 
+	/**
+	 * Run content:afterSchedule hooks across all active plugins
+	 */
+	async runContentAfterSchedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		this.ensureInitialized();
+		return this.hookPipeline!.runContentAfterSchedule(content, collection);
+	}
+
+	/**
+	 * Run content:afterUnschedule hooks across all active plugins
+	 */
+	async runContentAfterUnschedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		this.ensureInitialized();
+		return this.hookPipeline!.runContentAfterUnschedule(content, collection);
+	}
+
 	/**
 	 * Run media:beforeUpload hooks across all active plugins
 	 */

package/src/plugins/manifest-schema.ts

@@ -98,6 +98,8 @@ export const HOOK_NAMES = [
 	"content:afterPublish",
 	"content:afterUnpublish",
 	"content:afterRestore",
+	"content:afterSchedule",
+	"content:afterUnschedule",
 	"media:beforeUpload",
 	"media:afterUpload",
 	"cron",

package/src/plugins/types.ts

@@ -725,13 +725,29 @@ export interface ContentDeleteEvent {
 }
 
 /**
- * Content publish state change hook event (fired after publish or unpublish)
+ * Content state-change hook event (fired after publish, unpublish, restore,
+ * schedule, or unschedule).
  */
-export interface ContentPublishStateChangeEvent {
+export interface ContentStateChangeEvent {
 	content: Record<string, unknown>;
 	collection: string;
 }
 
+/**
+ * Content publish/unpublish hook event.
+ */
+export type ContentPublishStateChangeEvent = ContentStateChangeEvent;
+
+/**
+ * Content restore hook event.
+ */
+export type ContentRestoreStateChangeEvent = ContentStateChangeEvent;
+
+/**
+ * Content schedule/unschedule hook event.
+ */
+export type ContentScheduleStateChangeEvent = ContentStateChangeEvent;
+
 /**
  * Media hook event
  */
@@ -792,7 +808,17 @@ export type ContentAfterUnpublishHandler = (
 ) => Promise<void>;
 
 export type ContentAfterRestoreHandler = (
-	event: ContentPublishStateChangeEvent,
+	event: ContentRestoreStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
+export type ContentAfterScheduleHandler = (
+	event: ContentScheduleStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
+export type ContentAfterUnscheduleHandler = (
+	event: ContentScheduleStateChangeEvent,
 	ctx: PluginContext,
 ) => Promise<void>;
 
@@ -982,6 +1008,10 @@ export interface PluginHooks {
 		| HookConfig<ContentAfterUnpublishHandler>
 		| ContentAfterUnpublishHandler;
 	"content:afterRestore"?: HookConfig<ContentAfterRestoreHandler> | ContentAfterRestoreHandler;
+	"content:afterSchedule"?: HookConfig<ContentAfterScheduleHandler> | ContentAfterScheduleHandler;
+	"content:afterUnschedule"?:
+		| HookConfig<ContentAfterUnscheduleHandler>
+		| ContentAfterUnscheduleHandler;
 
 	// Media hooks
 	"media:beforeUpload"?: HookConfig<MediaBeforeUploadHandler> | MediaBeforeUploadHandler;
@@ -1302,6 +1332,8 @@ export interface ResolvedPluginHooks {
 	"content:afterPublish"?: ResolvedHook<ContentAfterPublishHandler>;
 	"content:afterUnpublish"?: ResolvedHook<ContentAfterUnpublishHandler>;
 	"content:afterRestore"?: ResolvedHook<ContentAfterRestoreHandler>;
+	"content:afterSchedule"?: ResolvedHook<ContentAfterScheduleHandler>;
+	"content:afterUnschedule"?: ResolvedHook<ContentAfterUnscheduleHandler>;
 	"media:beforeUpload"?: ResolvedHook<MediaBeforeUploadHandler>;
 	"media:afterUpload"?: ResolvedHook<MediaAfterUploadHandler>;
 	cron?: ResolvedHook<CronHandler>;

package/src/schema/zod-generator.ts

@@ -86,7 +86,15 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 			return z.preprocess((v) => (v === 0 || v === 1 ? Boolean(v) : v), z.boolean());
 
 		case "datetime":
-			return z.string().datetime().or(z.string().date());
+			// Accept every value that legitimately round-trips through the admin
+			// and seeds: ISO with `Z`, ISO with a timezone offset, a naive
+			// datetime (`YYYY-MM-DDTHH:mm[:ss]` -- what `<input type="datetime-local">`
+			// and many seeds produce), and a date-only value. The admin re-sends
+			// every loaded field on autosave, so a stored naive datetime must
+			// validate or the entry becomes unsavable through its own editor
+			// (#1368; same class as #867). `z.iso.*` retains semantic validation,
+			// so impossible dates are still rejected.
+			return z.iso.datetime({ offset: true, local: true }).or(z.iso.date());
 
 		case "select": {
 			const options = field.validation?.options;

package/src/search/query.ts

@@ -359,10 +359,12 @@ export async function getSuggestions(
 		try {
 			results = await sql<{
 				id: string;
+				slug: string | null;
 				title: string;
 			}>`
 				SELECT 
 					c.id,
+					c.slug,
 					c.title
 				FROM "${sql.raw(ftsTable)}" f
 				JOIN "${sql.raw(contentTable)}" c ON f.id = c.id
@@ -389,6 +391,7 @@ export async function getSuggestions(
 			suggestions.push({
 				collection,
 				id: row.id,
+				slug: row.slug,
 				title: row.title,
 			});
 		}

package/src/search/types.ts

@@ -101,6 +101,8 @@ export interface Suggestion {
 	collection: string;
 	/** Entry ID */
 	id: string;
+	/** Entry slug, when available */
+	slug?: string | null;
 	/** Entry title */
 	title: string;
 }

package/src/seed/apply.ts

@@ -296,7 +296,7 @@ export async function applySeed(
 				defSeedIdMap.set(taxonomy.id, { id: defId, translationGroup: defTranslationGroup });
 
 			// Create terms (if provided)
-			if (taxonomy.terms && taxonomy.terms.length > 0) {
+			if (includeContent && taxonomy.terms && taxonomy.terms.length > 0) {
 				const termRepo = new TaxonomyRepository(db);
 
 				if (taxonomy.hierarchical) {
@@ -346,10 +346,16 @@ export async function applySeed(
 				}
 			}
 		}
+
+		// Seeded/updated defs change which taxonomies exist — clear the
+		// isolate-wide defs + names caches so later reads in this isolate
+		// (e.g. an auto-seed triggered mid-request) reflect them immediately.
+		const { invalidateTaxonomyDefsCache } = await import("../taxonomies/index.js");
+		invalidateTaxonomyDefsCache();
 	}
 
 	// 6. Bylines
-	if (seed.bylines) {
+	if (includeContent && seed.bylines) {
 		const bylineRepo = new BylineRepository(db);
 		for (const byline of seed.bylines) {
 			const existing = await bylineRepo.findBySlug(byline.slug);

package/src/seed/types.ts

@@ -288,7 +288,12 @@ export interface SeedBylineCredit {
  * Options for applying a seed
  */
 export interface SeedApplyOptions {
-	/** Include sample content (default: false) */
+	/**
+	 * Include sample data: content entries, bylines, and taxonomy terms
+	 * (default: false). Schema and structure (collections, fields, taxonomy
+	 * definitions, menus, settings, redirects, widget areas, sections) are
+	 * always applied.
+	 */
 	includeContent?: boolean;
 
 	/** How to handle conflicts (default: "skip") */

package/src/taxonomies/index.ts

@@ -12,14 +12,16 @@
  */
 
 import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
-import { getDb } from "../loader.js";
+import { getDb, resetTaxonomyNamesCache } from "../loader.js";
 import {
 	cachedQuery,
 	CacheNamespace,
 	contentNamespace,
 	invalidateTaxonomyObjectCache,
+	isObjectCacheActive,
 } from "../object-cache/index.js";
 import { peekRequestCache, requestCached, setRequestCacheEntry } from "../request-cache.js";
+import { getRequestContext } from "../request-context.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 import type { TaxonomyDef, TaxonomyTerm, TaxonomyTermRow } from "./types.js";
@@ -28,35 +30,136 @@ export interface TaxonomyQueryOptions {
 	locale?: string;
 }
 
+/** Invalidate cached taxonomy term data and any content that hydrates terms. */
+export function invalidateTermCache(): void {
+	invalidateTaxonomyObjectCache();
+}
+
 /**
- * Invalidate cached taxonomy data in the distributed object cache (and any
- * content that hydrates taxonomy terms). The legacy in-isolate term cache was
- * removed, so this used to be a no-op; it now drives object-cache invalidation.
+ * Worker-isolate cache for taxonomy definitions, keyed by resolved locale.
+ *
+ * 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 created via the admin API or applied
+ * from a seed, and there is no edit/delete-def path. 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.
+ *
+ * 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).
  */
-export function invalidateTermCache(): void {
+interface TaxonomyDefsHolder {
+	version: number;
+	/** locale key ("*" for "all locales") → { version it was fetched at, promise }. */
+	cache: Map<string, { version: number; promise: Promise<TaxonomyDef[]> }>;
+}
+
+const TAXONOMY_DEFS_CACHE_KEY = Symbol.for("emdash:taxonomy-defs");
+const taxonomyDefsStore = globalThis as Record<symbol, unknown>;
+const defsHolder: TaxonomyDefsHolder =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see settings/index.ts)
+	(taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] as TaxonomyDefsHolder | undefined) ??
+	(() => {
+		const h: TaxonomyDefsHolder = { version: 0, cache: new Map() };
+		taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] = h;
+		return h;
+	})();
+
+/**
+ * Invalidate the isolate-wide taxonomy-definitions cache (and the related
+ * loader taxonomy-names cache). Called from every taxonomy-def write path
+ * (`handleTaxonomyCreate`, seed application). Other isolates refresh on their
+ * next recycle — staleness bounded by isolate lifetime.
+ */
+export function invalidateTaxonomyDefsCache(): void {
+	defsHolder.version++;
+	defsHolder.cache.clear();
+	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()`.
+ */
+export function resetTaxonomyDefsCacheForTests(): void {
+	defsHolder.version++;
+	defsHolder.cache.clear();
+}
+
+/**
+ * Fetch taxonomy definitions straight from the database (no caching).
+ */
+async function fetchTaxonomyDefs(locale: string | undefined): Promise<TaxonomyDef[]> {
+	const db = await getDb();
+	let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
+	if (locale !== undefined) query = query.where("locale", "=", locale);
+	const rows = await query.execute();
+	return rows.map(rowToTaxonomyDef);
+}
+
+/**
+ * Resolve taxonomy defs through the isolate fallback cache, bypassing it for
+ * isolated databases. The returned promise is cached (not the resolved value)
+ * so concurrent cold-isolate readers share one in-flight query; a rejection
+ * evicts the entry so the next caller retries.
+ */
+function loadTaxonomyDefs(localeKey: string, locale: string | undefined): Promise<TaxonomyDef[]> {
+	if (getRequestContext()?.dbIsIsolated === true) {
+		return fetchTaxonomyDefs(locale);
+	}
+	const existing = defsHolder.cache.get(localeKey);
+	if (existing && existing.version === defsHolder.version) {
+		return existing.promise;
+	}
+	const version = defsHolder.version;
+	const promise = fetchTaxonomyDefs(locale).catch((error: unknown) => {
+		const current = defsHolder.cache.get(localeKey);
+		if (current && current.promise === promise) {
+			defsHolder.cache.delete(localeKey);
+		}
+		throw error;
+	});
+	defsHolder.cache.set(localeKey, { version, promise });
+	return promise;
+}
+
 /**
  * Get every taxonomy definition. Definitions are per-locale (one row per
  * locale inside the same translation_group) — by default we resolve to the
  * active locale.
+ *
+ * Two-tier cache: per-request via `requestCached` (so a single render that
+ * hydrates terms for several collections pays at most one call), then
+ * per-isolate via the global holder (so warm renders issue zero queries).
+ * The `requestCached` key is unchanged so `getTaxonomyDef`'s peek still hits.
  */
 export async function getTaxonomyDefs(options: TaxonomyQueryOptions = {}): Promise<TaxonomyDef[]> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`taxonomy-defs:${locale ?? "*"}`, () =>
-		cachedQuery({
-			namespace: CacheNamespace.TAXONOMIES,
-			key: `defs:${locale ?? "*"}`,
-			load: async () => {
-				const db = await getDb();
-				let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
-				if (locale !== undefined) query = query.where("locale", "=", locale);
-				const rows = await query.execute();
-				return rows.map(rowToTaxonomyDef);
-			},
-		}),
-	);
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-defs:${localeKey}`, async () => {
+		if (await isObjectCacheActive()) {
+			return cachedQuery({
+				namespace: CacheNamespace.TAXONOMIES,
+				key: `defs:${localeKey}`,
+				load: () => fetchTaxonomyDefs(locale),
+			});
+		}
+		return loadTaxonomyDefs(localeKey, locale);
+	});
 }
 
 /**