emdash 0.37.0 → 0.39.0

package/src/media/responsive.ts

@@ -32,6 +32,29 @@ export function responsiveSizes(width: number | undefined): string {
 	return width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
 }
 
+/** Column count `Gallery.astro` uses when a gallery block does not set one. */
+export const GALLERY_DEFAULT_COLUMNS = 3;
+
+/**
+ * Build the `sizes` attribute for one cell of a Portable Text gallery.
+ *
+ * Mirrors the gallery's CSS: `columns` equal cells with a `1rem` gap, and two
+ * columns at `640px` and below. Each cell is estimated against the viewport, so
+ * a gallery inside a narrower content column still gets a larger slot than it
+ * renders at; pass `sizes` to `Gallery` when the container width is known.
+ */
+export function gallerySizes(columns: number | undefined): string {
+	const count =
+		typeof columns === "number" && Number.isInteger(columns) && columns > 0
+			? columns
+			: GALLERY_DEFAULT_COLUMNS;
+	return `(max-width: 640px) ${galleryCell(2)}, ${galleryCell(count)}`;
+}
+
+function galleryCell(columns: number): string {
+	return columns === 1 ? "100vw" : `calc((100vw - ${columns - 1}rem) / ${columns})`;
+}
+
 /**
  * Make a same-origin media URL absolute so Astro's image service can optimize it.
  *

package/src/media/usage/content-refresh.ts

@@ -868,6 +868,7 @@ export async function findNonTranslatableSiblingContentIds(
 	updatedContentId: string,
 	translationGroup: string | null | undefined,
 	updatedData: Record<string, unknown> | undefined,
+	options: { absentAsCleared?: boolean } = {},
 ): Promise<string[]> {
 	if (!isI18nEnabled() || !updatedData || !translationGroup) return [];
 
@@ -887,7 +888,7 @@ export async function findNonTranslatableSiblingContentIds(
 		.execute();
 
 	const touchedNonTranslatableSlugs = fields
-		.filter((field) => field.slug in updatedData)
+		.filter((field) => options.absentAsCleared || field.slug in updatedData)
 		.map((field) => field.slug);
 	if (touchedNonTranslatableSlugs.length === 0) return [];
 

package/src/media/usage/extractor.ts

@@ -125,26 +125,61 @@ function extractPortableTextOccurrences(
 	if (!Array.isArray(value)) return;
 
 	for (const [blockIndex, block] of value.entries()) {
-		if (!isRecord(block) || block._type !== "image" || !isRecord(block.asset)) continue;
+		if (!isRecord(block)) continue;
 
-		const provider = normalizeProvider(block.asset.provider);
-		const ref = readPortableTextAssetRef(block.asset, provider);
-		if (!ref) continue;
+		if (block._type === "image") {
+			addPortableTextAssetOccurrence(
+				occurrences,
+				seen,
+				fieldSlug,
+				`${fieldSlug}[${blockIndex}]`,
+				block.asset,
+			);
+			continue;
+		}
 
-		addRefOccurrence(occurrences, seen, {
-			fieldSlug,
-			fieldPath: `${fieldSlug}[${blockIndex}].asset.${ref.key}`,
-			referenceType: "portable_text_image",
-			ref: buildMediaRef({
-				id: ref.id,
-				provider,
-				mimeType: normalizeMimeValue(block.asset.mimeType),
-				fallbackKind: "image",
-			}),
-		});
+		// A gallery block holds its images in `images[]`, each with its own asset.
+		if (block._type === "gallery" && Array.isArray(block.images)) {
+			for (const [imageIndex, image] of block.images.entries()) {
+				if (!isRecord(image)) continue;
+				addPortableTextAssetOccurrence(
+					occurrences,
+					seen,
+					fieldSlug,
+					`${fieldSlug}[${blockIndex}].images[${imageIndex}]`,
+					image.asset,
+				);
+			}
+		}
 	}
 }
 
+function addPortableTextAssetOccurrence(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	fieldSlug: string,
+	pathPrefix: string,
+	asset: unknown,
+): void {
+	if (!isRecord(asset)) return;
+
+	const provider = normalizeProvider(asset.provider);
+	const ref = readPortableTextAssetRef(asset, provider);
+	if (!ref) return;
+
+	addRefOccurrence(occurrences, seen, {
+		fieldSlug,
+		fieldPath: `${pathPrefix}.asset.${ref.key}`,
+		referenceType: "portable_text_image",
+		ref: buildMediaRef({
+			id: ref.id,
+			provider,
+			mimeType: normalizeMimeValue(asset.mimeType),
+			fallbackKind: "image",
+		}),
+	});
+}
+
 function addOccurrence(
 	occurrences: ExtractedMediaUsageOccurrence[],
 	seen: Set<string>,

package/src/media/usage/types.ts

@@ -1,6 +1,6 @@
 import type { FieldType } from "../../schema/types.js";
 
-export const CONTENT_SOURCE_SCHEMA_VERSION = 1;
+export const CONTENT_SOURCE_SCHEMA_VERSION = 2;
 
 export type MediaKind =
 	| "image"

package/src/menus/index.ts

@@ -14,7 +14,11 @@ import { sql } from "kysely";
 import { menuTag } from "../cache/chrome-tags.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
-import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
+import {
+	resolveLocalizedContentRoutePath,
+	resolveLocale,
+	resolveLocaleChain,
+} from "../i18n/resolve.js";
 import { getDb } from "../loader.js";
 import { cachedQuery, CacheNamespace } from "../object-cache/index.js";
 import type { CacheHint } from "../query.js";
@@ -27,6 +31,8 @@ export interface MenuQueryOptions {
 	/** Override the locale used for the lookup. When omitted, the locale comes
 	 * from the request context or the configured defaultLocale. */
 	locale?: string;
+	/** Astro's route trailing-slash policy for resolved content links. */
+	trailingSlash?: "always" | "never" | "ignore";
 }
 
 /**
@@ -38,20 +44,32 @@ export interface MenuQueryOptions {
  * const menuEs = await getMenu("primary", { locale: "es" });
  * ```
  */
-export function getMenu(name: string, options: MenuQueryOptions = {}): Promise<Menu | null> {
+export async function getMenu(name: string, options: MenuQueryOptions = {}): Promise<Menu | null> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`menu:${name}:${locale ?? "*"}`, () =>
+	const trailingSlash = options.trailingSlash ?? (await getHostTrailingSlash());
+	return requestCached(`menu:${name}:${locale ?? "*"}:${trailingSlash}`, () =>
 		cachedQuery({
 			namespace: CacheNamespace.MENUS,
-			key: `${name}:${locale ?? "*"}`,
+			key: `${name}:${locale ?? "*"}:${trailingSlash}`,
 			load: async () => {
 				const db = await getDb();
-				return getMenuWithDb(name, db, { locale });
+				return getMenuWithDb(name, db, { locale, trailingSlash });
 			},
 		}),
 	);
 }
 
+async function getHostTrailingSlash(): Promise<"always" | "never" | "ignore"> {
+	try {
+		const config = (await import("virtual:emdash/config")) as {
+			default?: { trailingSlash?: "always" | "never" | "ignore" };
+		};
+		return config.default?.trailingSlash ?? "ignore";
+	} catch {
+		return "ignore";
+	}
+}
+
 /**
  * Get menu by name with resolved URLs (with explicit db). Internal helper for
  * admin routes that already have a database handle.
@@ -86,7 +104,7 @@ export async function getMenuWithDb(
 		.orderBy("sort_order", "asc")
 		.execute();
 
-	const items = await buildMenuTree(itemRows, db, menuRow.locale);
+	const items = await buildMenuTree(itemRows, db, menuRow.locale, options.trailingSlash);
 
 	return {
 		id: menuRow.id,
@@ -151,6 +169,7 @@ async function buildMenuTree(
 	items: MenuItemRow[],
 	db: Kysely<Database>,
 	locale: string,
+	trailingSlash?: "always" | "never" | "ignore",
 ): Promise<MenuItem[]> {
 	const contentReferences = collectContentReferences(items);
 	const taxonomyReferences = new Set(
@@ -166,8 +185,10 @@ async function buildMenuTree(
 		resolveTaxonomyReferences(db, taxonomyReferences, locale),
 	]);
 
-	const resolvedItems = items.map((item) =>
-		resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup),
+	const resolvedItems = await Promise.all(
+		items.map((item) =>
+			resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup, locale, trailingSlash),
+		),
 	);
 	const validItems = resolvedItems.filter((item): item is MenuItem => item !== null);
 
@@ -259,12 +280,14 @@ function getCollectionUrlPatterns(
  * (migration 036 remapped all existing references); we look it up against
  * the per-locale ec_* row or per-locale taxonomy row.
  */
-function resolveMenuItem(
+async function resolveMenuItem(
 	item: MenuItemRow,
 	urlPatterns: Map<string, string | null>,
 	contentLookup: ContentReferenceLookup,
 	taxonomyLookup: TaxonomyReferenceLookup,
-): MenuItem | null {
+	locale: string,
+	trailingSlash?: "always" | "never" | "ignore",
+): Promise<MenuItem | null> {
 	let url: string | null;
 
 	switch (item.type) {
@@ -274,11 +297,13 @@ function resolveMenuItem(
 
 		case "page":
 		case "post":
-			url = resolveContentUrl(
+			url = await resolveContentUrl(
 				item.reference_collection || `${item.type}s`,
 				item.reference_id,
 				urlPatterns,
 				contentLookup,
+				locale,
+				trailingSlash,
 			);
 			if (url === null) return null;
 			break;
@@ -295,11 +320,13 @@ function resolveMenuItem(
 			// slug. Entry references resolve like page/post items.
 			if (!item.reference_collection) return null;
 			if (item.reference_id) {
-				url = resolveContentUrl(
+				url = await resolveContentUrl(
 					item.reference_collection,
 					item.reference_id,
 					urlPatterns,
 					contentLookup,
+					locale,
+					trailingSlash,
 				);
 				if (url === null) return null;
 			} else {
@@ -309,11 +336,13 @@ function resolveMenuItem(
 
 		default:
 			if (item.reference_collection && item.reference_id) {
-				url = resolveContentUrl(
+				url = await resolveContentUrl(
 					item.reference_collection,
 					item.reference_id,
 					urlPatterns,
 					contentLookup,
+					locale,
+					trailingSlash,
 				);
 				if (url === null) return null;
 			} else {
@@ -332,21 +361,10 @@ function resolveMenuItem(
 	};
 }
 
-const SLUG_PLACEHOLDER = /\{slug\}/g;
-const ID_PLACEHOLDER = /\{id\}/g;
-
-/**
- * Interpolate a URL pattern with entry data
- *
- * Replaces `{slug}` and `{id}` placeholders.
- */
-function interpolateUrlPattern(pattern: string, slug: string, id: string): string {
-	return pattern.replace(SLUG_PLACEHOLDER, slug).replace(ID_PLACEHOLDER, id);
-}
-
 interface ContentReferenceRow {
 	id: string;
 	slug: string;
+	published_at: string | null;
 	locale: string;
 	translation_group: string;
 }
@@ -354,6 +372,7 @@ interface ContentReferenceRow {
 interface ResolvedContentReference {
 	id: string;
 	slug: string;
+	publishedAt: string | null;
 }
 
 type ContentReferenceLookup = Map<string, Map<string, ResolvedContentReference>>;
@@ -371,7 +390,7 @@ async function resolveContentReferences(
 				validateIdentifier(collection, "menu item collection");
 				for (const batch of chunks([...referenceGroups], SQL_BATCH_SIZE)) {
 					const result = await sql<ContentReferenceRow>`
-						SELECT id, slug, locale, translation_group
+						SELECT id, slug, published_at, locale, translation_group
 						FROM ${sql.ref(`ec_${collection}`)}
 						WHERE translation_group IN (${sql.join(batch)})
 					`.execute(db);
@@ -383,16 +402,18 @@ async function resolveContentReferences(
 					}
 				}
 				for (const [referenceGroup, row] of localized) {
-					lookup.set(referenceGroup, { id: row.id, slug: row.slug });
+					lookup.set(referenceGroup, { id: row.id, slug: row.slug, publishedAt: row.published_at });
 				}
 
 				const unresolved = [...referenceGroups].filter((id) => !lookup.has(id));
 				for (const batch of chunks(unresolved, SQL_BATCH_SIZE)) {
-					const result = await sql<ResolvedContentReference>`
-						SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
+					const result = await sql<Pick<ContentReferenceRow, "id" | "slug" | "published_at">>`
+						SELECT id, slug, published_at FROM ${sql.ref(`ec_${collection}`)}
 						WHERE id IN (${sql.join(batch)})
 					`.execute(db);
-					for (const row of result.rows) lookup.set(row.id, row);
+					for (const row of result.rows) {
+						lookup.set(row.id, { id: row.id, slug: row.slug, publishedAt: row.published_at });
+					}
 				}
 			} catch (error) {
 				console.error(`Failed to resolve content URLs for ${collection}:`, error);
@@ -428,18 +449,26 @@ function shouldPreferLocalizedRow(
  * (falling back to the source if no translation exists so the menu link is
  * still clickable).
  */
-function resolveContentUrl(
+async function resolveContentUrl(
 	collection: string,
 	referenceGroup: string | null,
 	urlPatterns: Map<string, string | null>,
 	contentLookup: ContentReferenceLookup,
-): string | null {
+	locale: string,
+	trailingSlash?: "always" | "never" | "ignore",
+): Promise<string | null> {
 	if (!referenceGroup) return null;
 	const row = contentLookup.get(collection)?.get(referenceGroup);
 	if (!row) return null;
-	const pattern = urlPatterns.get(collection);
-	if (pattern) return interpolateUrlPattern(pattern, row.slug, row.id);
-	return `/${collection}/${row.slug}`;
+	return resolveLocalizedContentRoutePath({
+		pattern: urlPatterns.get(collection) ?? null,
+		collection,
+		slug: row.slug,
+		id: row.id,
+		date: row.publishedAt,
+		locale,
+		trailingSlash,
+	});
 }
 
 interface TaxonomyReferenceRow {

package/src/migrations/direct-executor.ts

@@ -1,5 +1,6 @@
 import { type Dialect, Kysely } from "kysely";
 
+import { clearMigrationLock, readMigrationLock } from "../database/migration-lock.js";
 import {
 	getExactMigrationStatus,
 	runMigrations,
@@ -20,18 +21,47 @@ export interface DirectMigrationExecutorOptions {
 	createDialect: () => Dialect | Promise<Dialect>;
 }
 
+const LOCK_ID_PATTERN = /^[1-9]\d{0,15}$/;
+
 function createReport(
 	target: MigrationTarget,
 	status: ExactMigrationStatus,
 	executed: readonly string[],
+	lockHeldSince: number | null = null,
 ): MigrationReport {
-	return {
+	const report: MigrationReport = {
 		target,
 		knownApplied: [...status.knownApplied],
 		pending: [...status.pending],
 		unknownApplied: [...status.unknownApplied],
 		executed: [...executed],
 	};
+	if (lockHeldSince !== null) {
+		report.lock = {
+			id: String(lockHeldSince),
+			heldSince: new Date(lockHeldSince).toISOString(),
+		};
+	}
+	return report;
+}
+
+async function releaseLock(db: Kysely<Database>, lockId: string | undefined): Promise<void> {
+	if (!lockId || !LOCK_ID_PATTERN.test(lockId)) {
+		throw new Error("Releasing the migration lock requires the lock id reported by status.");
+	}
+	const lock = Number(lockId);
+	// Read before writing: on Postgres the lock column is a 32-bit integer that
+	// a lock id does not fit, and no Postgres lock is ever held in it.
+	const heldSince = await readMigrationLock(db);
+	if (heldSince === lock && (await clearMigrationLock(db, lock))) return;
+	const current = heldSince === lock ? await readMigrationLock(db) : heldSince;
+	// No lock ids here: the CLI's redaction can rewrite digits that match an
+	// environment value.
+	throw new Error(
+		current === null
+			? "The migration lock is not held."
+			: "The migration lock has a different id now. Check the status again before releasing it.",
+	);
 }
 
 async function verifyRequest(request: MigrationRequest): Promise<void> {
@@ -53,6 +83,10 @@ async function executeRequest(
 ): Promise<MigrationReport> {
 	const initialStatus = await getExactMigrationStatus(db);
 	if (request.action === "check") {
+		return createReport(target, initialStatus, [], await readMigrationLock(db));
+	}
+	if (request.action === "release-lock") {
+		await releaseLock(db, request.lockId);
 		return createReport(target, initialStatus, []);
 	}
 
@@ -96,7 +130,11 @@ export function createDirectMigrationExecutor(
 			}
 			used = true;
 
-			if (request.action !== "check" && request.action !== "apply") {
+			if (
+				request.action !== "check" &&
+				request.action !== "apply" &&
+				request.action !== "release-lock"
+			) {
 				throw new Error("Unsupported migration action.");
 			}
 			await verifyRequest(request);

package/src/migrations/index.ts

@@ -12,6 +12,7 @@ export type {
 	MigrationExecutorFactory,
 	MigrationExecutorFactoryContext,
 	MigrationExecutorModule,
+	MigrationLockReport,
 	MigrationReport,
 	MigrationRequest,
 	MigrationTarget,

package/src/migrations/protocol.ts

@@ -1,6 +1,6 @@
 import type { I18nConfig } from "../i18n/config.js";
 
-export type MigrationAction = "check" | "apply";
+export type MigrationAction = "check" | "apply" | "release-lock";
 
 export interface MigrationRequest {
 	action: MigrationAction;
@@ -9,6 +9,14 @@ export interface MigrationRequest {
 		emdashVersion: string;
 		migrationSetFingerprint: string;
 	};
+	/** For `release-lock`: the lock id a `check` reported. Another lock is left alone. */
+	lockId?: string;
+}
+
+export interface MigrationLockReport {
+	id: string;
+	/** ISO 8601 time the lock was taken. */
+	heldSince: string;
 }
 
 export interface MigrationTarget {
@@ -26,6 +34,8 @@ export interface MigrationReport {
 	pending: string[];
 	unknownApplied: string[];
 	executed: string[];
+	/** Present on `check` while a migration lock is held. */
+	lock?: MigrationLockReport;
 }
 
 export interface MigrationExecutor {

package/src/page/seo-contributions.ts

@@ -5,15 +5,22 @@
  * `[...plugin, ...site, ...base]` and feeds it to `resolvePageMetadata()`,
  * which is first-wins. That ordering means plugin contributions override
  * site-level ones override base ones for any given key — base values are
- * the fallback, not the source of truth.
+ * the fallback, not the source of truth. For content pages, the entry's
+ * SEO panel values are overlaid onto the page context before the base
+ * contributions (and JSON-LD) are generated, so editor-set values
+ * override the template-provided fields.
  *
  * This replaces the per-template SEO.astro components, eliminating
  * the class of XSS bugs where templates hand-rolled JSON-LD serialization.
  */
 
+import type { ContentSeo } from "../database/repositories/types.js";
 import type { PageMetadataContribution, PublicPageContext } from "../plugins/types.js";
+import { buildSeoImageUrl, resolveSeoCanonicalUrl } from "../seo/media-url.js";
+import { getSiteSettings } from "../settings/index.js";
 import type { SeoSettings } from "../settings/types.js";
 import { buildBlogPostingJsonLd, buildWebSiteJsonLd } from "./jsonld.js";
+import { peekSeoPanel } from "./seo-panel.js";
 
 /**
  * Generate base metadata contributions from a page context's SEO data.
@@ -147,6 +154,76 @@ export function generateBaseSeoContributions(
 	return contributions;
 }
 
+/**
+ * Resolve the page context for rendering: overlay the entry's SEO panel
+ * values when they were primed for this request.
+ *
+ * Used by `<EmDashHead>`, `<EmDashBodyStart>`, and `<EmDashBodyEnd>` so
+ * head tags, JSON-LD, and every plugin hook — head and body fragments
+ * alike — see the same overlaid context. Returns the context unchanged
+ * for non-content pages or when nothing was primed. The peek is a
+ * request-cache read; site settings are only consulted when a panel
+ * exists (and are request-cached themselves), so this adds no queries.
+ */
+export async function resolveSeoPanelPage(
+	page: PublicPageContext,
+	siteUrl?: string,
+): Promise<PublicPageContext> {
+	if (!page.content) return page;
+	const seo = await peekSeoPanel(page.content.collection, page.content.id);
+	if (!seo) return page;
+	const resolvedSiteUrl =
+		siteUrl ||
+		page.siteUrl ||
+		(await getSiteSettings()).url ||
+		(URL.canParse(page.url) ? new URL(page.url).origin : "");
+	return applySeoPanelToPageContext(page, seo, { siteUrl: resolvedSiteUrl });
+}
+
+/**
+ * Overlay a content entry's SEO panel data onto the page context.
+ *
+ * `<EmDashHead>` applies this overlay before anything consumes the context:
+ * editor-set panel values override whatever the template passed in, and
+ * because the overlaid context feeds plugin hooks, the base contributions,
+ * and the JSON-LD builders alike, structured data and head tags always
+ * agree. Plugins still override the rendered output via first-wins dedup.
+ *
+ * The `<title>` element itself stays the template's responsibility —
+ * head components can't replace it — so `seo.title` feeds
+ * `og:title` / `twitter:title` / the JSON-LD headline only. Templates that
+ * want the panel title in `<title>` keep using `getSeoMeta()`.
+ *
+ * Unset panel fields fall back to the template-provided values, so pages
+ * without SEO data are unaffected.
+ */
+export function applySeoPanelToPageContext(
+	page: PublicPageContext,
+	seo: ContentSeo,
+	options: { siteUrl?: string | null } = {},
+): PublicPageContext {
+	const siteUrl = options.siteUrl ?? undefined;
+	const image = seo.image ? buildSeoImageUrl(seo.image, siteUrl) : null;
+	const canonical = seo.canonical ? resolveSeoCanonicalUrl(seo.canonical, siteUrl) : null;
+
+	return {
+		...page,
+		description: seo.description || page.description,
+		canonical: canonical || page.canonical,
+		// Mirror the resolved image into the top-level field too, so consumers
+		// reading page.image (e.g. page:metadata hooks) agree with og:image and
+		// the JSON-LD graph.
+		image: image || page.image,
+		seo: {
+			...page.seo,
+			ogTitle: seo.title || page.seo?.ogTitle,
+			ogDescription: seo.description || page.seo?.ogDescription,
+			ogImage: image || page.seo?.ogImage,
+			robots: seo.noIndex ? "noindex, nofollow" : page.seo?.robots,
+		},
+	};
+}
+
 /**
  * Generate site-level SEO metadata contributions from SiteSettings.seo.
  *

package/src/page/seo-panel.ts

@@ -0,0 +1,47 @@
+/**
+ * Request-scoped hand-off of SEO panel data from the entry query to the
+ * render components.
+ *
+ * The loader's single-entry path already folds the `_emdash_seo` row into
+ * the entry query as a JSON subselect, so the panel data is in hand when an
+ * entry is fetched — it primes this cache, and `<EmDashHead>` (plus the body
+ * fragment components) pick the data up with a plain map read. No code path
+ * here ever queries the database.
+ *
+ * Kept as a leaf module (request-cache only) so the loader and the query
+ * layer can prime without importing the page-context machinery, which pulls
+ * in site settings and would create an import cycle back into the loader.
+ */
+
+import type { ContentSeo } from "../database/repositories/types.js";
+import { peekRequestCache, setRequestCacheEntry } from "../request-cache.js";
+
+function seoPanelCacheKey(collection: string, id: string): string {
+	return `seo-panel:${collection}:${id}`;
+}
+
+/**
+ * Prime the request-scoped SEO panel cache for a content entry.
+ *
+ * Called wherever an entry's folded SEO data materializes: the loader's
+ * single-entry path (fresh query) and the object-cache revive path in
+ * `getEmDashEntry` (warm hit, where the loader never runs). No-ops outside
+ * a request context; never overwrites an already-primed value.
+ */
+export function primeSeoPanel(collection: string, id: string, seo: ContentSeo): void {
+	setRequestCacheEntry(seoPanelCacheKey(collection, id), seo);
+}
+
+/**
+ * Read the SEO panel data primed for a content entry in this request.
+ *
+ * Returns `null` when nothing was primed — either the entry has no SEO
+ * row, or it was not fetched through an EmDash loader in this request
+ * (e.g. prerendered pages, or a hand-rolled query). Callers treat null as
+ * "no overlay"; this never falls back to a database lookup, so the
+ * logged-out hot path gains zero queries.
+ */
+export async function peekSeoPanel(collection: string, id: string): Promise<ContentSeo | null> {
+	const primed = peekRequestCache<ContentSeo>(seoPanelCacheKey(collection, id));
+	return primed ? await primed : null;
+}

package/src/plugin-test-runtime.ts

@@ -0,0 +1,17 @@
+export { EmDashRuntime } from "./emdash-runtime.js";
+export type { RuntimeDependencies } from "./emdash-runtime.js";
+export {
+	dispatchPluginApiRequest,
+	dispatchPluginEditorExtensionApiRequest,
+} from "./plugins/http-route-dispatch.js";
+export {
+	handlePluginSettingsGet,
+	handlePluginSettingsUpdate,
+} from "./api/handlers/plugin-settings.js";
+export type { PluginApiRequestContext } from "./plugins/http-route-dispatch.js";
+export { validateEditorDraftPatch, validateEditorDraftRequest } from "./plugins/editor-draft.js";
+export type { UserInfo } from "./plugins/types.js";
+export { getI18nConfig, setI18nConfig } from "./i18n/config.js";
+export { RedirectRepository } from "./database/repositories/redirect.js";
+export { BylineRepository } from "./database/repositories/byline.js";
+export { TaxonomyRepository } from "./database/repositories/taxonomy.js";