emdash 0.39.0 → 0.40.0

package/src/client/index.ts

@@ -20,6 +20,15 @@
 import mime from "mime/lite";
 
 import type { ContentFieldFilters } from "../content-list-query.js";
+import type {
+	BlockType,
+	CreateBlockTypeInput,
+	UpdateBlockTypeInput,
+} from "../schema/block-types.js";
+import type { Sha256Digest } from "../transfer/format/digest.js";
+import type { SiteImportDecisionsInput, SiteImportPlan } from "../transfer/format/plan.js";
+import type { SiteImportReceipt } from "../transfer/format/receipt.js";
+import type { PublicTransferOperation } from "../transfer/ops/operations.js";
 import type { FieldSchema } from "./portable-text.js";
 import { convertDataForRead, convertDataForWrite } from "./portable-text.js";
 import type { Interceptor } from "./transport.js";
@@ -33,6 +42,8 @@ import {
 
 // Regex patterns for client utilities
 const TRAILING_SLASH_PATTERN = /\/$/;
+const DECIMAL_PATTERN = /^\d+$/;
+const SHA256_ETAG_PATTERN = /^"([0-9a-f]{64})"$/;
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -42,6 +53,23 @@ function mimeFromFilename(filename: string): string {
 	return mime.getType(filename) ?? "application/octet-stream";
 }
 
+function idempotencyHeader(request: { idempotencyKey?: string }): Record<string, string> {
+	return request.idempotencyKey === undefined ? {} : { "Idempotency-Key": request.idempotencyKey };
+}
+
+function pageQuery(options?: { limit?: number; cursor?: string }): string {
+	const params = new URLSearchParams();
+	if (options?.limit !== undefined) params.set("limit", String(options.limit));
+	if (options?.cursor !== undefined) params.set("cursor", options.cursor);
+	const qs = params.toString();
+	return qs ? `?${qs}` : "";
+}
+
+/** Encode a site package path (`records/post/000000.ndjson`) segment by segment */
+function encodePackagePath(path: string): string {
+	return path.split("/").map(encodeURIComponent).join("/");
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -126,6 +154,8 @@ export interface Field {
 	widget?: string;
 	options?: unknown;
 	sortOrder?: number;
+	blockTypes?: BlockType[];
+	blockTypeFingerprint?: string;
 }
 
 /** Aggregate trust state for media usage reads */
@@ -177,10 +207,16 @@ export interface MediaUsageEntryDetail {
 	sources: MediaUsageSourceDetail[];
 }
 
+/** A site setting that selects a media item */
+export interface MediaUsageSiteSettingDetail {
+	setting: "logo" | "favicon" | "seo.defaultOgImage";
+}
+
 /** Entry-grouped media usage details */
 export interface MediaUsageDetailsResponse {
 	items: MediaUsageEntryDetail[];
 	nextCursor?: string;
+	siteSettings: MediaUsageSiteSettingDetail[];
 	coverage: MediaUsageCoverage;
 }
 
@@ -435,6 +471,92 @@ export interface Manifest {
 	>;
 }
 
+/** User as listed by the admin users API */
+export interface UserSummary {
+	id: string;
+	email: string;
+	name: string | null;
+	role: number;
+	disabled: boolean;
+}
+
+/** A site transfer operation (export or import) */
+export type TransferOperation = PublicTransferOperation;
+
+/** Site transfer capabilities of an instance */
+export interface TransferCapabilities {
+	formatVersions: string[];
+	features: string[];
+	optionalFeatures: string[];
+	limits: {
+		manifestBytes: number;
+		recordLineBytes: number;
+		chunkBytes: number;
+		chunkRecords: number;
+		totalRecords: number;
+		totalFiles: number;
+		indexChunks: number;
+		jsonDepth: number;
+		maxBlobBytes: number;
+	};
+	portableDomain: {
+		empty: boolean;
+		blockers: Array<Record<string, string>>;
+		seededScaffold: Array<Record<string, string>>;
+	};
+}
+
+/** Result of one bounded `advance` step */
+export interface TransferAdvanceResult {
+	operation: TransferOperation;
+	/** Milliseconds until the next step should be requested, or null once the operation has ended. */
+	nextRequestInMs: number | null;
+}
+
+/** A package file the import has declared but not yet received */
+export interface TransferPackageFile {
+	path: string;
+	bytes: number;
+	sha256: string;
+}
+
+export interface TransferImportCreateResult {
+	operation: TransferOperation;
+	created: boolean;
+	missing: ListResult<TransferPackageFile>;
+}
+
+export interface TransferFileUploadResult {
+	path: string;
+	bytes: number;
+	/** True when the file was already stored and the uploaded bytes matched it. */
+	alreadyVerified: boolean;
+	/** Declared files still to upload. */
+	remaining: number;
+}
+
+export interface TransferImportAnalyzeResult {
+	operation: TransferOperation;
+	plan?: SiteImportPlan;
+	planDigest?: Sha256Digest;
+	/** Milliseconds until the next step should be requested, or null once analysis has ended. */
+	nextRequestInMs: number | null;
+}
+
+export interface TransferImportStatus {
+	operation: TransferOperation;
+	files: { declared: number; verified: number };
+}
+
+/** A downloaded export file, streamed */
+export interface TransferFileDownload {
+	body: ReadableStream<Uint8Array>;
+	/** Size from `Content-Length`, when sent */
+	bytes: number | null;
+	/** Hex SHA-256 from the `ETag`, when sent */
+	sha256: string | null;
+}
+
 // ---------------------------------------------------------------------------
 // Client errors
 // ---------------------------------------------------------------------------
@@ -525,12 +647,52 @@ export class EmDashClient {
 		if (col.fields) {
 			this.fieldSchemaCache.set(
 				slug,
-				col.fields.map((f) => ({ slug: f.slug, type: f.type })),
+				col.fields.map((f) => ({ slug: f.slug, type: f.type, blockTypes: f.blockTypes })),
 			);
 		}
 		return col;
 	}
 
+	async blockTypes(): Promise<BlockType[]> {
+		const data = await this.request<{ items: BlockType[] }>("GET", "/schema/block-types");
+		return data.items;
+	}
+
+	async blockType(slug: string): Promise<BlockType> {
+		const data = await this.request<{ item: BlockType }>(
+			"GET",
+			`/schema/block-types/${encodeURIComponent(slug)}`,
+		);
+		return data.item;
+	}
+
+	async createBlockType(input: CreateBlockTypeInput): Promise<BlockType> {
+		const data = await this.request<{ item: BlockType }>("POST", "/schema/block-types", input);
+		return data.item;
+	}
+
+	async updateBlockType(slug: string, input: UpdateBlockTypeInput): Promise<BlockType> {
+		const data = await this.request<{ item: BlockType }>(
+			"PUT",
+			`/schema/block-types/${encodeURIComponent(slug)}`,
+			input,
+		);
+		return data.item;
+	}
+
+	async activateBlockTypeVersion(
+		slug: string,
+		version: number,
+		expectedFingerprint: string,
+	): Promise<BlockType> {
+		const data = await this.request<{ item: BlockType }>(
+			"POST",
+			`/schema/block-types/${encodeURIComponent(slug)}/versions/${version}/activate`,
+			{ expectedFingerprint },
+		);
+		return data.item;
+	}
+
 	/** Create a collection */
 	async createCollection(input: {
 		slug: string;
@@ -705,6 +867,8 @@ export class EmDashClient {
 			status?: string;
 			locale?: string;
 			translationOf?: string;
+			migrateBlocks?: boolean;
+			replaceBlocks?: boolean;
 		},
 	): Promise<ContentItem> {
 		// Convert markdown strings to PT for portableText fields
@@ -733,6 +897,8 @@ export class EmDashClient {
 			status?: string;
 			_rev?: string;
 			locale?: string;
+			migrateBlocks?: boolean;
+			replaceBlocks?: boolean;
 			/** Write even though another editor holds this entry's edit lock. */
 			overrideLock?: boolean;
 		},
@@ -748,6 +914,8 @@ export class EmDashClient {
 			data,
 			slug: input.slug,
 			status: input.status,
+			migrateBlocks: input.migrateBlocks,
+			replaceBlocks: input.replaceBlocks,
 			...(input._rev ? { _rev: input._rev } : {}),
 			...(input.overrideLock ? { overrideLock: true } : {}),
 		};
@@ -1170,24 +1338,243 @@ export class EmDashClient {
 		return this.request<MenuWithItems>("GET", `/menus/${encodeURIComponent(name)}`);
 	}
 
+	// -----------------------------------------------------------------------
+	// Users
+	// -----------------------------------------------------------------------
+
+	/** List users (admin only) */
+	async users(options?: {
+		search?: string;
+		limit?: number;
+		cursor?: string;
+	}): Promise<ListResult<UserSummary>> {
+		const params = new URLSearchParams();
+		if (options?.search) params.set("search", options.search);
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.cursor) params.set("cursor", options.cursor);
+		const qs = params.toString();
+		return this.request<ListResult<UserSummary>>("GET", `/admin/users${qs ? `?${qs}` : ""}`);
+	}
+
+	// -----------------------------------------------------------------------
+	// Site transfer
+	// -----------------------------------------------------------------------
+
+	/** Formats, features, limits, and whether this site can receive an import */
+	async transferCapabilities(): Promise<TransferCapabilities> {
+		return this.request<TransferCapabilities>("GET", "/admin/transfer/capabilities");
+	}
+
+	/**
+	 * Start a site export. With an idempotency key, repeating the call returns
+	 * the export first created with that key.
+	 */
+	async transferExportCreate(
+		options: { comments?: boolean } = {},
+		request: { idempotencyKey?: string } = {},
+	): Promise<{ operation: TransferOperation; created: boolean }> {
+		return this.request("POST", "/admin/transfer/exports", options, idempotencyHeader(request));
+	}
+
+	/** List exports, newest first */
+	async transferExportList(options?: {
+		limit?: number;
+		cursor?: string;
+	}): Promise<ListResult<TransferOperation>> {
+		return this.request("GET", `/admin/transfer/exports${pageQuery(options)}`);
+	}
+
+	async transferExportGet(id: string): Promise<{ operation: TransferOperation }> {
+		return this.request("GET", `/admin/transfer/exports/${encodeURIComponent(id)}`);
+	}
+
+	/** Run one bounded export step */
+	async transferExportAdvance(id: string): Promise<TransferAdvanceResult> {
+		return this.request("POST", `/admin/transfer/exports/${encodeURIComponent(id)}/advance`);
+	}
+
+	/** The complete export's `manifest.json`, byte for byte */
+	async transferExportManifest(id: string): Promise<Uint8Array> {
+		const response = await this.requestRaw(
+			"GET",
+			`/admin/transfer/exports/${encodeURIComponent(id)}/manifest`,
+		);
+		await this.assertOk(response);
+		return new Uint8Array(await response.arrayBuffer());
+	}
+
+	/**
+	 * Stream one file of a complete export. The server ends the stream with an
+	 * error if the stored bytes no longer match the export, so callers must
+	 * still check the size and digest of what they receive.
+	 */
+	async transferExportFile(id: string, path: string): Promise<TransferFileDownload> {
+		const response = await this.requestRaw(
+			"GET",
+			`/admin/transfer/exports/${encodeURIComponent(id)}/files/${encodePackagePath(path)}`,
+		);
+		await this.assertOk(response);
+		if (!response.body) throw new EmDashClientError(`Empty response for ${path}`);
+		const length = response.headers.get("Content-Length");
+		const etag = response.headers.get("ETag");
+		return {
+			body: response.body,
+			bytes: length !== null && DECIMAL_PATTERN.test(length) ? Number(length) : null,
+			sha256: etag ? (SHA256_ETAG_PATTERN.exec(etag)?.[1] ?? null) : null,
+		};
+	}
+
+	/**
+	 * Create an import from a package's `manifest.json` bytes. With an
+	 * idempotency key, repeating the call with the same manifest returns the
+	 * import first created with that key.
+	 */
+	async transferImportCreate(
+		manifest: Uint8Array,
+		request: { idempotencyKey?: string } = {},
+	): Promise<TransferImportCreateResult> {
+		const response = await this.send("POST", "/admin/transfer/imports", {
+			body: manifest,
+			headers: { "Content-Type": "application/json", ...idempotencyHeader(request) },
+		});
+		await this.assertOk(response);
+		const json = (await response.json()) as { data: TransferImportCreateResult };
+		return json.data;
+	}
+
+	/** List imports, newest first */
+	async transferImportList(options?: {
+		limit?: number;
+		cursor?: string;
+	}): Promise<ListResult<TransferOperation>> {
+		return this.request("GET", `/admin/transfer/imports${pageQuery(options)}`);
+	}
+
+	async transferImportGet(id: string): Promise<TransferImportStatus> {
+		return this.request("GET", `/admin/transfer/imports/${encodeURIComponent(id)}`);
+	}
+
+	/** Declared package files not uploaded yet, in path order */
+	async transferImportMissing(
+		id: string,
+		options?: { limit?: number; cursor?: string },
+	): Promise<ListResult<TransferPackageFile>> {
+		return this.request(
+			"GET",
+			`/admin/transfer/imports/${encodeURIComponent(id)}/missing${pageQuery(options)}`,
+		);
+	}
+
+	/**
+	 * Upload one declared package file. `bytes` must be the file's exact size;
+	 * a stream body is sent with that `Content-Length`.
+	 */
+	async transferImportUploadFile(
+		id: string,
+		path: string,
+		body: Uint8Array | ReadableStream<Uint8Array>,
+		bytes: number,
+	): Promise<TransferFileUploadResult> {
+		const response = await this.send(
+			"PUT",
+			`/admin/transfer/imports/${encodeURIComponent(id)}/files/${encodePackagePath(path)}`,
+			{
+				body,
+				headers: {
+					"Content-Type": "application/octet-stream",
+					"Content-Length": String(bytes),
+				},
+			},
+		);
+		await this.assertOk(response);
+		const json = (await response.json()) as { data: TransferFileUploadResult };
+		return json.data;
+	}
+
+	/**
+	 * Run one bounded analysis step. Once the import is planned the result
+	 * carries the plan; `decisions` are then applied, producing a new plan
+	 * digest.
+	 */
+	async transferImportAnalyze(
+		id: string,
+		decisions?: SiteImportDecisionsInput,
+	): Promise<TransferImportAnalyzeResult> {
+		return this.request(
+			"POST",
+			`/admin/transfer/imports/${encodeURIComponent(id)}/analyze`,
+			decisions === undefined ? undefined : { decisions },
+		);
+	}
+
+	async transferImportPlan(
+		id: string,
+	): Promise<{ plan: SiteImportPlan; planDigest: Sha256Digest }> {
+		return this.request("GET", `/admin/transfer/imports/${encodeURIComponent(id)}/plan`);
+	}
+
+	/** Start a planned import. Both digests must match the reviewed package and plan. */
+	async transferImportExecute(
+		id: string,
+		input: { packageDigest: string; planDigest: string },
+	): Promise<{ operation: TransferOperation }> {
+		return this.request("POST", `/admin/transfer/imports/${encodeURIComponent(id)}/execute`, {
+			packageDigest: input.packageDigest,
+			planDigest: input.planDigest,
+		});
+	}
+
+	/** Run one bounded step of an executing import */
+	async transferImportAdvance(id: string): Promise<TransferAdvanceResult> {
+		return this.request("POST", `/admin/transfer/imports/${encodeURIComponent(id)}/advance`);
+	}
+
+	async transferImportReceipt(id: string): Promise<{ receipt: SiteImportReceipt }> {
+		return this.request("GET", `/admin/transfer/imports/${encodeURIComponent(id)}/receipt`);
+	}
+
+	/**
+	 * Cancel an import. An idle import is cancelled at once; a step in
+	 * progress stops after its current batch, so the returned operation may
+	 * still be executing with `cancelRequestedAt` set.
+	 */
+	async transferImportCancel(id: string): Promise<{ operation: TransferOperation }> {
+		return this.request("POST", `/admin/transfer/imports/${encodeURIComponent(id)}/cancel`);
+	}
+
+	/**
+	 * Abandon a failed or cancelled import, lifting the site write fence it
+	 * holds. Data the import already wrote stays in place.
+	 */
+	async transferImportAbandon(id: string): Promise<{ operation: TransferOperation }> {
+		return this.request("POST", `/admin/transfer/imports/${encodeURIComponent(id)}/abandon`);
+	}
+
 	// -----------------------------------------------------------------------
 	// Internal helpers
 	// -----------------------------------------------------------------------
 
 	/** Make a typed JSON request to the API */
-	private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
-		const response = await this.requestRaw(method, path, body);
+	private async request<T>(
+		method: string,
+		path: string,
+		body?: unknown,
+		extraHeaders?: Record<string, string>,
+	): Promise<T> {
+		const response = await this.requestRaw(method, path, body, extraHeaders);
 		await this.assertOk(response);
 		const json = (await response.json()) as { data: T };
 		return json.data;
 	}
 
 	/** Make a raw request — caller handles response */
-	private async requestRaw(method: string, path: string, body?: unknown): Promise<Response> {
-		const url = `${this.baseUrl}/_emdash/api${path}`;
-		const headers: Record<string, string> = {
-			Accept: "application/json",
-		};
+	private async requestRaw(
+		method: string,
+		path: string,
+		body?: unknown,
+		extraHeaders?: Record<string, string>,
+	): Promise<Response> {
+		const headers: Record<string, string> = { ...extraHeaders };
 
 		let requestBody: string | undefined;
 		if (body !== undefined) {
@@ -1195,10 +1582,24 @@ export class EmDashClient {
 			requestBody = JSON.stringify(body);
 		}
 
+		return this.send(method, path, { body: requestBody, headers });
+	}
+
+	/** Send a request with an arbitrary body; the caller handles the response */
+	private async send(
+		method: string,
+		path: string,
+		init: {
+			body?: string | Uint8Array | ReadableStream<Uint8Array>;
+			headers?: Record<string, string>;
+		},
+	): Promise<Response> {
+		const url = `${this.baseUrl}/_emdash/api${path}`;
 		const request = new Request(url, {
 			method,
-			headers,
-			body: requestBody,
+			headers: { Accept: "application/json", ...init.headers },
+			body: init.body as BodyInit | undefined,
+			...(init.body instanceof ReadableStream ? { duplex: "half" } : {}),
 		});
 
 		return this.transport.fetch(request);
@@ -1236,7 +1637,7 @@ export class EmDashClient {
 
 		try {
 			const col = await this.collection(collection);
-			cached = col.fields.map((f) => ({ slug: f.slug, type: f.type }));
+			cached = col.fields.map((f) => ({ slug: f.slug, type: f.type, blockTypes: f.blockTypes }));
 			this.fieldSchemaCache.set(collection, cached);
 			return cached;
 		} catch {
@@ -1251,6 +1652,8 @@ type _MediaRepairUsageRequiresExplicitInput = _AssertTrue<
 	Parameters<EmDashClient["mediaRepairUsage"]> extends [MediaUsageRepairInput] ? true : false
 >;
 
+export type { SiteImportDecisionsInput, SiteImportPlan, SiteImportReceipt, Sha256Digest };
+
 // Re-export transport types for interceptor authors
 export type { Interceptor } from "./transport.js";
 export {

package/src/client/portable-text.ts

@@ -373,6 +373,43 @@ export function resetKeyCounter(): void {
 export interface FieldSchema {
 	slug: string;
 	type: string;
+	blockTypes?: Array<{
+		slug: string;
+		currentVersion: number;
+		versions: Array<{
+			version: number;
+			fields: Array<{ slug: string; type: string }>;
+		}>;
+	}>;
+}
+
+function convertNestedBlockPortableText(
+	value: unknown,
+	field: FieldSchema,
+	direction: "read" | "write",
+): unknown {
+	if (!Array.isArray(value)) return value;
+	return value.map((block) => {
+		if (!block || typeof block !== "object" || Array.isArray(block)) return block;
+		const record = { ...block };
+		const type = typeof record._type === "string" ? record._type : undefined;
+		const version = typeof record._version === "number" ? record._version : undefined;
+		const blockType = field.blockTypes?.find((candidate) => candidate.slug === type);
+		const definition = blockType?.versions.find(
+			(candidate) => candidate.version === (version ?? blockType.currentVersion),
+		);
+		if (!definition) return block;
+		for (const nestedField of definition.fields) {
+			if (nestedField.type !== "portableText") continue;
+			const nestedValue = record[nestedField.slug];
+			if (direction === "read" && Array.isArray(nestedValue)) {
+				record[nestedField.slug] = portableTextToMarkdown(nestedValue as PortableTextBlock[]);
+			} else if (direction === "write" && typeof nestedValue === "string") {
+				record[nestedField.slug] = markdownToPortableText(nestedValue);
+			}
+		}
+		return record;
+	});
 }
 
 /**
@@ -390,6 +427,8 @@ export function convertDataForRead(
 	for (const field of fields) {
 		if (field.type === "portableText" && Array.isArray(result[field.slug])) {
 			result[field.slug] = portableTextToMarkdown(result[field.slug] as PortableTextBlock[]);
+		} else if (field.type === "blocks") {
+			result[field.slug] = convertNestedBlockPortableText(result[field.slug], field, "read");
 		}
 	}
 	return result;
@@ -407,6 +446,8 @@ export function convertDataForWrite(
 	for (const field of fields) {
 		if (field.type === "portableText" && typeof result[field.slug] === "string") {
 			result[field.slug] = markdownToPortableText(result[field.slug] as string);
+		} else if (field.type === "blocks") {
+			result[field.slug] = convertNestedBlockPortableText(result[field.slug], field, "write");
 		}
 	}
 	return result;

package/src/comments/public-submission.ts

@@ -1,11 +1,12 @@
 import { sql, type Kysely } from "kysely";
 
 import { apiError, apiSuccess, handleError } from "../api/error.js";
-import { checkRateLimit, hashIp } from "../api/handlers/comments.js";
+import { hashIp } from "../api/handlers/comments.js";
 import { isParseError, parseBody } from "../api/parse.js";
 import { createCommentBody } from "../api/schemas/comments.js";
 import { getSiteBaseUrl } from "../api/site-url.js";
 import type { EmDashConfig } from "../astro/integration/runtime.js";
+import { checkRateLimit } from "../auth/rate-limit.js";
 import { resolveSecretsCached } from "../config/secrets.js";
 import { CommentRepository } from "../database/repositories/comment.js";
 import type { Database } from "../database/types.js";
@@ -101,16 +102,6 @@ export async function submitPublicComment(
 		}
 
 		const meta = extractRequestMeta(request, runtime.config);
-		const { ipSalt } = await resolveSecretsCached(runtime.db);
-		const ipHash = meta.ip ? await hashIp(meta.ip, ipSalt) : "unknown";
-		const rateLimited = await checkRateLimit(
-			runtime.db,
-			ipHash,
-			ipHash === "unknown" ? 20 : undefined,
-		);
-		if (rateLimited) {
-			return apiError("RATE_LIMITED", "Too many comments. Please try again later.", 429);
-		}
 
 		const { getTurnstileSecretKey, verifyTurnstileToken } = await import("./turnstile.js");
 		const turnstileSecretKey = getTurnstileSecretKey();
@@ -121,6 +112,23 @@ export async function submitPublicComment(
 			return apiError("TURNSTILE_FAILED", "CAPTCHA verification failed", 403);
 		}
 
+		// Counted after the CAPTCHA so unverified requests can't use up the
+		// shared bucket for visitors without a trusted IP.
+		const { ipSalt } = await resolveSecretsCached(runtime.db);
+		const ipHash = meta.ip ? await hashIp(meta.ip, ipSalt) : "unknown";
+		const rateLimit = await checkRateLimit(
+			runtime.db,
+			ipHash,
+			"comments/submit",
+			ipHash === "unknown" ? 20 : 5,
+			600,
+		);
+		if (!rateLimit.allowed) {
+			const response = apiError("RATE_LIMITED", "Too many comments. Please try again later.", 429);
+			response.headers.set("Retry-After", "600");
+			return response;
+		}
+
 		const settings: CollectionCommentSettings = {
 			commentsEnabled: true,
 			commentsModeration: parseCommentModeration(collectionRow.comments_moderation),

package/src/components/Blocks.astro

@@ -0,0 +1,46 @@
+---
+import type {
+	BlockComponent,
+	BlockComponents,
+	BlockValue,
+} from "./blocks.js";
+import { resolveBlockRenderer } from "./blocks.js";
+
+export interface Props<T extends BlockValue = BlockValue> {
+	value?: readonly T[] | null;
+	components?: Partial<BlockComponents<T>>;
+	fallback?: BlockComponent<T>;
+}
+
+const { value, components = {}, fallback } = Astro.props;
+const blocks = Array.isArray(value) ? value : [];
+const entries = blocks.map((block, index) => ({
+	block,
+	index,
+	resolution: resolveBlockRenderer(block, components, fallback, import.meta.env.DEV),
+}));
+
+if (import.meta.env.DEV) {
+	for (const { block, resolution } of entries) {
+		if (resolution.kind === "diagnostic") {
+			console.warn(`[emdash] No component was provided for block type "${block._type}".`);
+		}
+	}
+}
+---
+
+{entries.map(({ block, index, resolution }) => {
+	const props = { value: block, index, blockKey: block._key };
+	if (resolution.kind === "component" || resolution.kind === "fallback") {
+		const Component = resolution.component;
+		return <Component {...props} />;
+	}
+	if (resolution.kind === "diagnostic") {
+		return (
+			<div role="alert" data-emdash-missing-block={block._type}>
+				No component was provided for block type “{block._type}”.
+			</div>
+		);
+	}
+	return null;
+})}