emdash 0.25.1 → 0.27.0

package/src/loader.ts

@@ -25,15 +25,23 @@ import { isMissingColumnError, isMissingTableError } from "./utils/db-errors.js"
 const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
 /**
- * SEO columns joined in from `_emdash_seo` on the single-entry path, mapped to
- * aliased result keys. SEO lives in a side table, so a LEFT JOIN folds it into
- * the entry load at zero extra query cost; the result is surfaced as a nested
- * `data.seo` object (see extractSeo) rather than flat fields.
+ * SEO columns folded into the single-entry query as a single JSON column
+ * (`_emdash_seo` in the result set), then expanded onto the row under these
+ * aliases for `extractSeo()`. Surfacing SEO as one aggregated column keeps the
+ * result-set width bounded regardless of how many fields the collection has,
+ * which matters for D1: a flat `LEFT JOIN _emdash_seo` adds 5 alias columns to
+ * every row and pushes wide collections (common after WordPress / ACF imports)
+ * past D1's per-result-set column limit, surfacing as a silent null entry.
+ * One JSON column is one column, so the join stays safe at any schema width.
+ *
+ * The aliases mirror the strategy used by `foldedHydrationSelects` for byline
+ * and taxonomy hydration: aggregate in SQL, expand in JS. SEO is 1:1 with
+ * content, so the subquery uses `json_object` (not the array aggregator).
  *
  * The `_emdash_` prefix on the aliases guarantees they can never collide with
  * a content field. Field slugs must match `/^[a-z][a-z0-9_]*$/`, so a user can
- * legitimately define a `seo_title` field; selecting the joined column under
- * its bare name would shadow that field in the result set and drop the user's
+ * legitimately define a `seo_title` field; surfacing the SEO column under its
+ * bare name would shadow that field in the result set and drop the user's
  * value. The prefix (illegal as a leading slug char) sidesteps this entirely.
  */
 const SEO_COLUMN_ALIASES: Record<string, string> = {
@@ -47,6 +55,9 @@ const SEO_COLUMN_ALIASES: Record<string, string> = {
 /** Aliased SEO result keys — excluded from generic field mapping. */
 const SEO_ALIAS_COLUMNS = Object.values(SEO_COLUMN_ALIASES);
 
+/** Folded SEO JSON column name in the result set (expanded onto aliases in JS). */
+const SEO_FOLDED_COLUMN = "_emdash_seo";
+
 /**
  * System columns excluded from entry.data
  * Note: slug is intentionally NOT excluded - it's useful as data.slug in templates
@@ -67,15 +78,17 @@ const SYSTEM_COLUMNS = new Set([
 	"draft_revision_id",
 	"locale",
 	"translation_group",
-	// Aliased SEO columns joined from _emdash_seo on the single-entry path.
-	// Surfaced as a nested data.seo object (see extractSeo), never as flat
-	// fields. The aliases are _emdash_-prefixed so they can't shadow a user
-	// field named e.g. `seo_title`.
+	// Aliased SEO columns expanded from the folded _emdash_seo JSON column on
+	// the single-entry path. Surfaced as a nested data.seo object (see
+	// extractSeo), never as flat fields. The aliases are _emdash_-prefixed so
+	// they can't shadow a user field named e.g. `seo_title`.
 	...SEO_ALIAS_COLUMNS,
-	// Folded hydration JSON columns (see foldedHydrationSelects) — surfaced via
-	// the FOLDED_* markers, never as flat fields.
+	// Folded hydration JSON columns (see foldedHydrationSelects and
+	// foldedSeoSelect) — surfaced via the FOLDED_* markers or expanded onto
+	// SEO_ALIAS_COLUMNS, never as flat fields.
 	"_emdash_terms",
 	"_emdash_bylines",
+	SEO_FOLDED_COLUMN,
 ]);
 
 /** Markers for byline/taxonomy hydration folded into the content query. */
@@ -123,6 +136,62 @@ function foldedHydrationSelects(db: Kysely<any>, type: string, outer: string) {
 	return { terms, bylines };
 }
 
+/**
+ * Correlated JSON-object subquery that folds per-entry SEO into the content
+ * query without widening the result set: 1 row of `_emdash_seo` becomes 1 JSON
+ * column rather than 5 flat columns. The JSON column is expanded onto the row
+ * via {@link expandFoldedSeo} after the query runs, preserving the alias keys
+ * that {@link extractSeo} reads. Missing SEO row (no entry in `_emdash_seo`)
+ * yields NULL, which {@link expandFoldedSeo} treats as "no SEO" - identical to
+ * the prior LEFT JOIN miss behavior.
+ *
+ * Dialect-specific aggregation mirrors {@link foldedHydrationSelects}: SQLite
+ * `json_object` returns a JSON *string*, Postgres `json_build_object` returns
+ * parsed JSON; both branches are handled in expansion.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- any Kysely instance
+function foldedSeoSelect(db: Kysely<any>, type: string, outer: string) {
+	const o = sql.ref(outer);
+	const pg = isPostgres(db);
+	// Use raw column names (not aliases) as JSON keys: the JSON is expanded back
+	// onto SEO_COLUMN_ALIASES in JS, and keeping the keys matched to the
+	// underlying columns makes the SQL readable and the expansion 1-to-1.
+	const pairs =
+		"'seo_title', s.seo_title, 'seo_description', s.seo_description, 'seo_image', s.seo_image, 'seo_canonical', s.seo_canonical, 'seo_no_index', s.seo_no_index";
+	const obj = pg ? sql.raw(`json_build_object(${pairs})`) : sql.raw(`json_object(${pairs})`);
+	return sql`(SELECT ${obj} FROM ${sql.ref("_emdash_seo")} AS s WHERE s.collection = ${type} AND s.content_id = ${o}.id LIMIT 1) AS ${sql.ref(SEO_FOLDED_COLUMN)}`;
+}
+
+/**
+ * Expand the folded `_emdash_seo` JSON column onto the row using SEO_COLUMN_ALIASES,
+ * so {@link extractSeo} reads it transparently. SQLite returns a JSON string
+ * (parse it); Postgres returns already-parsed JSON. Missing/malformed/null is
+ * a no-op: {@link extractSeo} returns null when the aliases are absent.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function expandFoldedSeo(row: Record<string, unknown>): void {
+	const raw = row[SEO_FOLDED_COLUMN];
+	delete row[SEO_FOLDED_COLUMN];
+	let parsed: Record<string, unknown> | null = null;
+	if (typeof raw === "string") {
+		try {
+			const candidate: unknown = JSON.parse(raw);
+			if (isPlainObject(candidate)) parsed = candidate;
+		} catch {
+			return; // malformed JSON: leave the row without SEO aliases (extractSeo returns null)
+		}
+	} else if (isPlainObject(raw)) {
+		parsed = raw;
+	}
+	if (!parsed) return;
+	for (const [col, alias] of Object.entries(SEO_COLUMN_ALIASES)) {
+		row[alias] = parsed[col] ?? null;
+	}
+}
+
 /**
  * Stash folded hydration JSON (non-enumerable) for the query.ts fast paths.
  * SQLite returns a JSON string (parse it); Postgres returns already-parsed JSON.
@@ -227,6 +296,18 @@ async function getTaxonomyNames(db: Kysely<Database>): Promise<Set<string>> {
 	}
 }
 
+/**
+ * Reset the module-scoped taxonomy-names cache.
+ *
+ * Called from `invalidateTaxonomyDefsCache()` so that creating or seeding a
+ * taxonomy definition is reflected within the current isolate instead of
+ * waiting for the isolate to recycle. Keeps this cache consistent with the
+ * isolate-wide taxonomy-defs cache in `taxonomies/index.ts`.
+ */
+export function resetTaxonomyNamesCache(): void {
+	taxonomyNames = null;
+}
+
 /**
  * System columns to include in data (mapped to camelCase where needed)
  */
@@ -879,11 +960,12 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 									taxonomyFilters.map(
 										(f) => sql`AND EXISTS (
 							SELECT 1 FROM content_taxonomies ct
-							INNER JOIN taxonomies t ON t.id = ct.taxonomy_id
+							INNER JOIN taxonomies t ON t.translation_group = ct.taxonomy_id
 							WHERE ct.collection = ${type}
 								AND ct.entry_id = ${sql.ref(tableName)}.id
 								AND t.name = ${f.name}
 								AND t.slug IN (${sql.join(f.slugs.map((s) => sql`${s}`))})
+							${locale ? sql`AND t.locale = ${locale}` : sql``}
 						)`,
 									),
 									sql` `,
@@ -1050,31 +1132,25 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				// When locale is specified, prefer locale-scoped slug match,
 				// but IDs are globally unique so always check id without locale scope.
 				//
-				// LEFT JOIN _emdash_seo folds per-entry SEO (canonical, noindex,
-				// etc.) into this single query at zero extra round-trip cost. The
-				// joined columns are surfaced as a nested data.seo object via
-				// extractSeo() and excluded from the generic field mapping. SEO is
-				// 1:1 with content (PK on collection+content_id), so the join never
-				// multiplies rows.
-				const seoSelect = sql.join(
-					Object.entries(SEO_COLUMN_ALIASES).map(
-						([col, alias]) => sql`${sql.ref(`s.${col}`)} AS ${sql.ref(alias)}`,
-					),
-				);
-				// Fold byline + taxonomy hydration into the content query (see
-				// foldedHydrationSelects), removing the two separate hydration
-				// round trips per fetch.
+				// Byline + taxonomy hydration (foldedHydrationSelects) and per-entry
+				// SEO (foldedSeoSelect) are each surfaced as a single aggregated JSON
+				// column rather than flat columns. This keeps the result-set width
+				// bounded at any collection schema width: a flat `LEFT JOIN _emdash_seo`
+				// adds 5 alias columns to every row and pushes wide flat-schema
+				// collections (common after WordPress / ACF imports) past D1's
+				// per-result-set column limit, surfacing as a silent null entry. One
+				// JSON column is one column, so the join stays safe at any width and
+				// we keep the single round trip.
 				const { terms: termsSelect, bylines: bylinesSelect } = foldedHydrationSelects(
 					db,
 					type,
 					"c",
 				);
+				const seoSelect = foldedSeoSelect(db, type, "c");
 				const result = locale
 					? await sql<Record<string, unknown>>`
 							SELECT c.*, ${seoSelect}, ${termsSelect}, ${bylinesSelect}
 							FROM ${sql.ref(tableName)} AS c
-							LEFT JOIN ${sql.ref("_emdash_seo")} AS s
-								ON s.collection = ${type} AND s.content_id = c.id
 							WHERE c.deleted_at IS NULL
 							AND ((c.slug = ${id} AND c.locale = ${locale}) OR c.id = ${id})
 							LIMIT 1
@@ -1082,8 +1158,6 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					: await sql<Record<string, unknown>>`
 							SELECT c.*, ${seoSelect}, ${termsSelect}, ${bylinesSelect}
 							FROM ${sql.ref(tableName)} AS c
-							LEFT JOIN ${sql.ref("_emdash_seo")} AS s
-								ON s.collection = ${type} AND s.content_id = c.id
 							WHERE c.deleted_at IS NULL
 							AND (c.slug = ${id} OR c.id = ${id})
 							LIMIT 1
@@ -1094,6 +1168,11 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					return undefined;
 				}
 
+				// Expand the folded SEO JSON column onto SEO_COLUMN_ALIASES so
+				// extractSeo() reads it transparently. Missing/null SEO is a
+				// no-op: extractSeo() returns null when the aliases are absent.
+				expandFoldedSeo(row);
+
 				const i18nConfig = virtualConfig?.i18n;
 				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
 				const entrySlug = rowStr(row, "slug") || rowStr(row, "id");

package/src/media/usage/extractor.ts

@@ -0,0 +1,302 @@
+import { normalizeMime } from "../mime.js";
+import type {
+	ExtractedMediaUsageOccurrence,
+	ExtractMediaUsageOccurrencesInput,
+	MediaKind,
+	MediaUsageExtractionSubField,
+	MediaUsageReferenceType,
+} from "./types.js";
+
+const INTERNAL_MEDIA_PREFIX = "/_emdash/api/media/file/";
+const URL_LIKE_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+
+interface MediaRef {
+	mediaId: string | null;
+	provider: string;
+	providerAssetId: string;
+	mediaKind: MediaKind | null;
+	mimeType: string | null;
+}
+
+interface AddOccurrenceInput {
+	fieldSlug: string;
+	fieldPath: string;
+	referenceType: MediaUsageReferenceType;
+	value: unknown;
+	fallbackKind: MediaKind | null;
+}
+
+export function extractMediaUsageOccurrences({
+	fields,
+	data,
+}: ExtractMediaUsageOccurrencesInput): ExtractedMediaUsageOccurrence[] {
+	const occurrences: ExtractedMediaUsageOccurrence[] = [];
+	const seen = new Set<string>();
+
+	for (const field of fields) {
+		const value = data[field.slug];
+
+		if (field.type === "image") {
+			addOccurrence(occurrences, seen, {
+				fieldSlug: field.slug,
+				fieldPath: field.slug,
+				referenceType: "image_field",
+				value,
+				fallbackKind: "image",
+			});
+			continue;
+		}
+
+		if (field.type === "file") {
+			addOccurrence(occurrences, seen, {
+				fieldSlug: field.slug,
+				fieldPath: field.slug,
+				referenceType: "file_field",
+				value,
+				fallbackKind: null,
+			});
+			continue;
+		}
+
+		if (field.type === "repeater") {
+			extractRepeaterOccurrences(occurrences, seen, field.slug, value, field.validation?.subFields);
+			continue;
+		}
+
+		if (field.type === "portableText") {
+			extractPortableTextOccurrences(occurrences, seen, field.slug, value);
+		}
+	}
+
+	return occurrences;
+}
+
+function extractRepeaterOccurrences(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	fieldSlug: string,
+	value: unknown,
+	subFields: readonly MediaUsageExtractionSubField[] | undefined,
+): void {
+	if (!Array.isArray(value) || !Array.isArray(subFields)) return;
+
+	for (const [itemIndex, item] of value.entries()) {
+		if (!isRecord(item)) continue;
+
+		for (const subField of subFields) {
+			if (subField.type !== "image" && subField.type !== "file") continue;
+
+			addOccurrence(occurrences, seen, {
+				fieldSlug,
+				fieldPath: `${fieldSlug}[${itemIndex}].${subField.slug}`,
+				referenceType: subField.type === "image" ? "image_field" : "file_field",
+				value: item[subField.slug],
+				fallbackKind: subField.type === "image" ? "image" : null,
+			});
+		}
+	}
+}
+
+function extractPortableTextOccurrences(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	fieldSlug: string,
+	value: unknown,
+): void {
+	if (!Array.isArray(value)) return;
+
+	for (const [blockIndex, block] of value.entries()) {
+		if (!isRecord(block) || block._type !== "image" || !isRecord(block.asset)) continue;
+
+		const provider = normalizeProvider(block.asset.provider);
+		const ref = readPortableTextAssetRef(block.asset, provider);
+		if (!ref) 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",
+			}),
+		});
+	}
+}
+
+function addOccurrence(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	input: AddOccurrenceInput,
+): void {
+	const ref = readMediaRef(input.value, input.fallbackKind);
+	if (!ref) return;
+
+	addRefOccurrence(occurrences, seen, {
+		fieldSlug: input.fieldSlug,
+		fieldPath: input.fieldPath,
+		referenceType: input.referenceType,
+		ref,
+	});
+}
+
+function addRefOccurrence(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	input: {
+		fieldSlug: string;
+		fieldPath: string;
+		referenceType: MediaUsageReferenceType;
+		ref: MediaRef | null;
+	},
+): void {
+	if (!input.ref) return;
+
+	const occurrence: ExtractedMediaUsageOccurrence = {
+		fieldSlug: input.fieldSlug,
+		fieldPath: input.fieldPath,
+		occurrenceIndex: 0,
+		referenceType: input.referenceType,
+		mediaId: input.ref.mediaId,
+		provider: input.ref.provider,
+		providerAssetId: input.ref.providerAssetId,
+		mediaKind: input.ref.mediaKind,
+		mimeType: input.ref.mimeType,
+	};
+
+	const key = [
+		occurrence.fieldSlug,
+		occurrence.fieldPath,
+		occurrence.occurrenceIndex,
+		occurrence.referenceType,
+		occurrence.provider,
+		occurrence.providerAssetId,
+		occurrence.mediaId ?? "",
+	].join("\0");
+
+	if (seen.has(key)) return;
+	seen.add(key);
+	occurrences.push(occurrence);
+}
+
+function readMediaRef(value: unknown, fallbackKind: MediaKind | null): MediaRef | null {
+	if (typeof value === "string") {
+		const id = normalizeLocalMediaId(value);
+		return id ? buildMediaRef({ id, provider: "local", mimeType: null, fallbackKind }) : null;
+	}
+
+	if (!isRecord(value)) return null;
+
+	const provider = normalizeProvider(value.provider);
+	const id = provider === "local" ? normalizeLocalMediaId(value.id) : normalizeStableId(value.id);
+	if (!id) return null;
+
+	return buildMediaRef({
+		id,
+		provider,
+		mimeType: normalizeMimeValue(value.mimeType),
+		fallbackKind,
+	});
+}
+
+function buildMediaRef(input: {
+	id: string;
+	provider: string;
+	mimeType: string | null;
+	fallbackKind: MediaKind | null;
+}): MediaRef | null {
+	const provider = normalizeProvider(input.provider);
+	if (provider === "external") return null;
+
+	return {
+		mediaId: provider === "local" ? input.id : null,
+		provider,
+		providerAssetId: input.id,
+		mediaKind: mediaKindFromMime(input.mimeType) ?? input.fallbackKind,
+		mimeType: input.mimeType,
+	};
+}
+
+function readPortableTextAssetRef(
+	asset: Record<string, unknown>,
+	provider: string,
+): { key: "_ref" | "id"; id: string } | null {
+	const normalizeId = provider === "local" ? normalizeLocalMediaId : normalizeStableId;
+	const ref = normalizeId(asset._ref);
+	if (ref) return { key: "_ref", id: ref };
+
+	const id = normalizeId(asset.id);
+	if (id) return { key: "id", id };
+
+	return null;
+}
+
+function normalizeProvider(value: unknown): string {
+	const provider = readString(value)?.trim();
+	return provider || "local";
+}
+
+function normalizeLocalMediaId(value: unknown): string | null {
+	const id = normalizeStableId(value);
+	if (!id) return null;
+	return id.includes("/") ? null : id;
+}
+
+function normalizeStableId(value: unknown): string | null {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (URL_LIKE_RE.test(trimmed)) return null;
+	if (trimmed.startsWith(INTERNAL_MEDIA_PREFIX)) return null;
+	return trimmed;
+}
+
+function normalizeMimeValue(value: unknown): string | null {
+	if (typeof value !== "string") return null;
+	const normalized = normalizeMime(value);
+	return normalized.includes("/") ? normalized : null;
+}
+
+function mediaKindFromMime(mimeType: string | null): MediaKind | null {
+	if (!mimeType) return null;
+	if (mimeType.startsWith("image/")) return "image";
+	if (mimeType.startsWith("video/")) return "video";
+	if (mimeType.startsWith("audio/")) return "audio";
+	if (mimeType.startsWith("font/") || mimeType.startsWith("application/font-")) return "font";
+	if (mimeType.startsWith("text/")) return "text";
+	if (isDocumentMime(mimeType)) return "document";
+	if (isArchiveMime(mimeType)) return "archive";
+	return "other";
+}
+
+function isDocumentMime(mimeType: string): boolean {
+	return (
+		mimeType === "application/pdf" ||
+		mimeType === "application/msword" ||
+		mimeType === "application/rtf" ||
+		mimeType === "application/vnd.ms-excel" ||
+		mimeType === "application/vnd.ms-powerpoint" ||
+		mimeType.startsWith("application/vnd.openxmlformats-officedocument.")
+	);
+}
+
+function isArchiveMime(mimeType: string): boolean {
+	return (
+		mimeType === "application/zip" ||
+		mimeType === "application/gzip" ||
+		mimeType === "application/x-tar" ||
+		mimeType === "application/x-7z-compressed" ||
+		mimeType === "application/x-rar-compressed" ||
+		mimeType === "application/vnd.rar"
+	);
+}
+
+function readString(value: unknown): string | null {
+	return typeof value === "string" ? value : null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/media/usage/types.ts

@@ -0,0 +1,46 @@
+import type { FieldType } from "../../schema/types.js";
+
+export type MediaKind =
+	| "image"
+	| "video"
+	| "audio"
+	| "document"
+	| "archive"
+	| "font"
+	| "text"
+	| "other";
+
+export type MediaUsageReferenceType = "image_field" | "file_field" | "portable_text_image";
+
+export interface MediaUsageExtractionSubField {
+	slug: string;
+	type: FieldType;
+	label?: string;
+}
+
+export interface MediaUsageExtractionValidation {
+	subFields?: readonly MediaUsageExtractionSubField[];
+}
+
+export interface MediaUsageExtractionField {
+	slug: string;
+	type: FieldType;
+	validation?: MediaUsageExtractionValidation | null;
+}
+
+export interface ExtractMediaUsageOccurrencesInput {
+	fields: readonly MediaUsageExtractionField[];
+	data: Record<string, unknown>;
+}
+
+export interface ExtractedMediaUsageOccurrence {
+	fieldSlug: string;
+	fieldPath: string;
+	occurrenceIndex: number;
+	referenceType: MediaUsageReferenceType;
+	mediaId: string | null;
+	provider: string;
+	providerAssetId: string;
+	mediaKind: MediaKind | null;
+	mimeType: string | null;
+}

package/src/object-cache/index.ts

@@ -167,7 +167,7 @@ async function getBackend(): Promise<ObjectCacheBackend | null> {
 		} catch (error) {
 			// Importing the virtual module fails outside an Astro/Vite context
 			// (e.g. unit tests, CLI). Treat as "no cache configured".
-			if (import.meta.env.DEV) {
+			if (import.meta.env?.DEV) {
 				console.warn("[object-cache] backend unavailable:", error);
 			}
 			holder.backend = null;
@@ -378,7 +378,7 @@ export async function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T>
 				const encoded = encode({ e: currentEpochs, v: value } satisfies CacheEnvelope<T>);
 				await backend.set(fullKey, encoded, ttl);
 			} catch (error) {
-				if (import.meta.env.DEV) {
+				if (import.meta.env?.DEV) {
 					console.warn("[object-cache] set failed:", error);
 				}
 			}
@@ -388,6 +388,12 @@ export async function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T>
 	return value;
 }
 
+/** Whether object-cache reads are active for the current request. */
+export async function isObjectCacheActive(): Promise<boolean> {
+	const backend = await getBackend();
+	return backend !== null && !shouldBypass();
+}
+
 /**
  * Invalidate every cached value in `namespace` by bumping its epoch.
  *

package/src/page/metadata.ts

@@ -20,6 +20,10 @@ export interface ResolvedPageMetadata {
 	jsonld: Array<{ id?: string; json: string }>;
 }
 
+interface RenderPageMetadataOptions {
+	includeJsonLd?: boolean;
+}
+
 // ── Validation ──────────────────────────────────────────────────
 
 /** Schemes safe for use in link href attributes */
@@ -66,6 +70,16 @@ export function safeJsonLdSerialize(value: unknown): string {
 		.replace(JSONLD_U2029_RE, "\\u2029");
 }
 
+export async function createSha256CspHash(value: string): Promise<string> {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	const bytes = new Uint8Array(digest);
+	let binary = "";
+	for (const byte of bytes) {
+		binary += String.fromCharCode(byte);
+	}
+	return `sha256-${btoa(binary)}`;
+}
+
 // ── Merge / dedupe ──────────────────────────────────────────────
 
 /**
@@ -155,8 +169,12 @@ export function resolvePageMetadata(
 // ── HTML rendering ──────────────────────────────────────────────
 
 /** Render resolved metadata to an HTML string for embedding in <head> */
-export function renderPageMetadata(metadata: ResolvedPageMetadata): string {
+export function renderPageMetadata(
+	metadata: ResolvedPageMetadata,
+	options: RenderPageMetadataOptions = {},
+): string {
 	const parts: string[] = [];
+	const includeJsonLd = options.includeJsonLd ?? true;
 
 	for (const m of metadata.meta) {
 		parts.push(`<meta name="${escapeHtmlAttr(m.name)}" content="${escapeHtmlAttr(m.content)}">`);
@@ -177,8 +195,10 @@ export function renderPageMetadata(metadata: ResolvedPageMetadata): string {
 		parts.push(tag);
 	}
 
-	for (const j of metadata.jsonld) {
-		parts.push(`<script type="application/ld+json">${j.json}</script>`);
+	if (includeJsonLd) {
+		for (const j of metadata.jsonld) {
+			parts.push(`<script type="application/ld+json">${j.json}</script>`);
+		}
 	}
 
 	return parts.join("\n");

package/src/plugin-types.ts

@@ -51,12 +51,17 @@ import type {
 	ContentAfterPublishHandler,
 	ContentAfterRestoreHandler,
 	ContentAfterSaveHandler,
+	ContentAfterScheduleHandler,
 	ContentAfterUnpublishHandler,
+	ContentAfterUnscheduleHandler,
 	ContentBeforeDeleteHandler,
 	ContentBeforeSaveHandler,
 	ContentDeleteEvent,
 	ContentHookEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	CronEvent,
 	CronHandler,
 	EmailAfterSendEvent,
@@ -99,6 +104,8 @@ export interface HookHandlers {
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
 	"content:afterRestore": ContentAfterRestoreHandler;
+	"content:afterSchedule": ContentAfterScheduleHandler;
+	"content:afterUnschedule": ContentAfterUnscheduleHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;
@@ -228,6 +235,9 @@ export type {
 	ContentDeleteEvent,
 	ContentHookEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	CronEvent,
 	EmailAfterSendEvent,
 	EmailBeforeSendEvent,