emdash 0.24.1 → 0.26.0

package/src/media/placeholder.ts

@@ -9,6 +9,8 @@
 import { encode } from "blurhash";
 import { imageSize } from "image-size";
 
+import { normalizeMime } from "./mime.js";
+
 export interface PlaceholderData {
 	blurhash: string;
 	dominantColor: string;
@@ -85,8 +87,12 @@ function extractDominantColor(data: Uint8Array, width: number, height: number):
 
 /**
  * Read image dimensions from headers without decoding pixel data.
+ * Returns null when the header cannot be parsed.
+ *
+ * Shared by every caller that needs pixel dimensions so the header is parsed
+ * once per buffer, not re-read inside generatePlaceholder.
  */
-function getImageDimensions(buffer: Uint8Array): { width: number; height: number } | null {
+export function readDimensions(buffer: Uint8Array): { width: number; height: number } | null {
 	try {
 		const result = imageSize(buffer);
 		if (result.width != null && result.height != null) {
@@ -102,23 +108,37 @@ function getImageDimensions(buffer: Uint8Array): { width: number; height: number
  * Generate blurhash and dominant color from an image buffer.
  * Returns null for non-image MIME types or on failure.
  *
- * @param dimensions - Optional pre-known dimensions. Used as a fallback when
- *   image-size cannot parse the buffer (e.g. truncated headers). When the
- *   decoded size (width * height * 4) exceeds MAX_DECODED_BYTES, placeholder
- *   generation is skipped to avoid OOM on memory-constrained runtimes.
+ * @param dimensions - Optional pre-known dimensions. When present they are
+ *   trusted verbatim (the caller has typically already read them via
+ *   readDimensions); otherwise dimensions are read from this buffer's header.
+ *   Generation is skipped (returns null) when no dimensions are available at
+ *   all, or when the decoded size (width * height * 4) exceeds
+ *   MAX_DECODED_BYTES — both guards avoid OOM from unbounded decodes on
+ *   memory-constrained runtimes.
  */
 export async function generatePlaceholder(
 	buffer: Uint8Array,
 	mimeType: string,
 	dimensions?: { width: number; height: number },
 ): Promise<PlaceholderData | null> {
-	const format = SUPPORTED_TYPES[mimeType];
+	const format = SUPPORTED_TYPES[normalizeMime(mimeType)];
 	if (!format) return null;
 
 	try {
-		// Safety net: skip decode if the image would exceed the memory budget
-		const dims = getImageDimensions(buffer) ?? dimensions;
-		if (dims && dims.width * dims.height * 4 > MAX_DECODED_BYTES) {
+		// Trust caller-supplied dimensions when present (the caller has usually
+		// already read them via readDimensions); otherwise read them from this
+		// buffer. The header is parsed at most once per call.
+		const dims = dimensions ?? readDimensions(buffer);
+
+		// Safety net: the decoders allocate the full RGBA buffer with no internal
+		// cap, so refuse to decode unless we can bound the output size. When we
+		// have no parseable header AND no known dimensions, the decoded size is
+		// unbounded — a crafted/truncated PNG whose header image-size can't read
+		// could still be decodable by upng-js, so we must bail to avoid OOM on
+		// memory-constrained runtimes. LQIP is progressive enhancement; missing
+		// it is preferable to crashing the request.
+		if (!dims) return null;
+		if (dims.width * dims.height * 4 > MAX_DECODED_BYTES) {
 			return null;
 		}
 

package/src/media/types.ts

@@ -85,6 +85,10 @@ export interface MediaProviderItem {
 	/** Dimensions (for images/video) */
 	width?: number;
 	height?: number;
+	/** LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
 	/** Accessibility text */
 	alt?: string;
 	/** Preview URL for admin UI thumbnail */
@@ -126,6 +130,10 @@ export interface ImageEmbed {
 	sizes?: string;
 	width?: number;
 	height?: number;
+	/** LQIP blurhash placeholder for rendering before the image loads */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color */
+	dominantColor?: string;
 	alt?: string;
 	/** Base URL without transforms, for responsive image generation */
 	cdnBaseUrl?: string;
@@ -256,6 +264,10 @@ export interface MediaValue {
 	mimeType?: string;
 	width?: number;
 	height?: number;
+	/** Cached LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** Cached LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
 	alt?: string;
 
 	/** Provider-specific data needed for embedding */
@@ -273,6 +285,8 @@ export function mediaItemToValue(providerId: string, item: MediaProviderItem): M
 		mimeType: item.mimeType,
 		width: item.width,
 		height: item.height,
+		blurhash: item.blurhash,
+		dominantColor: item.dominantColor,
 		alt: item.alt,
 		meta: item.meta,
 	};

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

@@ -49,13 +49,19 @@ import type {
 	CommentModerateHandler,
 	ContentAfterDeleteHandler,
 	ContentAfterPublishHandler,
+	ContentAfterRestoreHandler,
 	ContentAfterSaveHandler,
+	ContentAfterScheduleHandler,
 	ContentAfterUnpublishHandler,
+	ContentAfterUnscheduleHandler,
 	ContentBeforeDeleteHandler,
 	ContentBeforeSaveHandler,
 	ContentDeleteEvent,
 	ContentHookEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	CronEvent,
 	CronHandler,
 	EmailAfterSendEvent,
@@ -97,6 +103,9 @@ export interface HookHandlers {
 	"content:afterDelete": ContentAfterDeleteHandler;
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
+	"content:afterRestore": ContentAfterRestoreHandler;
+	"content:afterSchedule": ContentAfterScheduleHandler;
+	"content:afterUnschedule": ContentAfterUnscheduleHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;
@@ -226,6 +235,9 @@ export type {
 	ContentDeleteEvent,
 	ContentHookEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	CronEvent,
 	EmailAfterSendEvent,
 	EmailBeforeSendEvent,

package/src/plugins/context.ts

@@ -21,6 +21,7 @@ import {
 	SsrfError,
 	stripCredentialHeaders,
 } from "../import/ssrf.js";
+import { enrichImageMetadata } from "../media/enrich.js";
 import { invalidateSiteSettingsCache } from "../settings/index.js";
 import type { Storage } from "../storage/types.js";
 import { CronAccessImpl } from "./cron.js";
@@ -508,6 +509,9 @@ export function createMediaAccessWithWrite(
 				contentType,
 			});
 
+			// Derive dimensions + LQIP placeholders (no-op for non-images).
+			const enriched = await enrichImageMetadata(new Uint8Array(bytes), contentType);
+
 			// Create DB record — clean up storage on failure
 			let media;
 			try {
@@ -517,6 +521,10 @@ export function createMediaAccessWithWrite(
 					size: bytes.byteLength,
 					storageKey,
 					status: "ready",
+					width: enriched.width,
+					height: enriched.height,
+					blurhash: enriched.blurhash,
+					dominantColor: enriched.dominantColor,
 				});
 			} catch (error) {
 				try {

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,