emdash 1.0.1 → 1.2.0

package/src/components/Video.astro

@@ -0,0 +1,100 @@
+---
+/**
+ * Portable Text video block component
+ *
+ * Plays a Media Library video in the browser's own player, or a media
+ * provider's video from the provider's embed. An empty block, and a `video`
+ * block of another shape, which belongs to a plugin, render nothing.
+ */
+import { isPortableTextVideoBlock } from "../content/converters/video.js";
+import { getMediaProvider } from "../media/provider-loader.js";
+import type { VideoEmbed } from "../media/types.js";
+import { buildRenderMediaUrl } from "../media/url.js";
+
+export interface Props {
+	node: {
+		_type: "video";
+		_key: string;
+		asset?: { _ref: string; url?: string; provider?: string };
+		caption?: string;
+		width?: number;
+		height?: number;
+	};
+}
+
+const { node } = Astro.props;
+
+const asset = isPortableTextVideoBlock(node) ? node.asset : undefined;
+if (!asset) {
+	return null;
+}
+
+const { caption, width, height } = node;
+const providerId = asset.provider && asset.provider !== "local" ? asset.provider : undefined;
+
+let embed: VideoEmbed | undefined;
+if (providerId) {
+	try {
+		const provider = await getMediaProvider(providerId);
+		const result = await provider?.getEmbed(
+			{ provider: providerId, id: asset._ref, width, height },
+			{ width, height },
+		);
+		if (result?.type === "video" && (result.src || result.sources?.length)) embed = result;
+	} catch (error) {
+		console.warn(`Failed to get embed for video ${asset._ref}:`, error);
+	}
+} else {
+	// Only the file URL can play: the file route takes a storage key, not the
+	// media id in `_ref`.
+	const src = buildRenderMediaUrl(Astro.locals.emdash?.getPublicMediaUrl, { url: asset.url });
+	if (src) embed = { type: "video", src, width, height, controls: true, preload: "metadata" };
+}
+
+if (!embed) {
+	return null;
+}
+
+// Astro leaves `<` and `>` unescaped in attributes. Middleware that finds
+// `</body>` by searching the page's text could then match one in a URL.
+// Browsers percent-encode them in URLs anyway, so this changes no address.
+const url = (value: string | undefined) => value?.replaceAll("<", "%3C").replaceAll(">", "%3E");
+---
+
+<figure class="emdash-video">
+	<video
+		src={embed.sources?.length ? undefined : url(embed.src)}
+		poster={url(embed.poster)}
+		width={embed.width ?? width}
+		height={embed.height ?? height}
+		controls={embed.controls ?? true}
+		autoplay={embed.autoplay}
+		muted={embed.muted}
+		loop={embed.loop}
+		playsinline={embed.playsinline ?? true}
+		preload={embed.preload ?? "metadata"}
+		crossorigin={embed.crossorigin}
+	>
+		{embed.src && embed.sources?.length ? <source src={url(embed.src)} /> : null}
+		{embed.sources?.map((source) => <source src={url(source.src)} type={source.type} />)}
+	</video>
+	{caption && <figcaption>{caption}</figcaption>}
+</figure>
+
+<style>
+	.emdash-video {
+		margin: 1.5rem 0;
+	}
+	.emdash-video video {
+		display: block;
+		width: 100%;
+		height: auto;
+		max-height: 70vh;
+	}
+	.emdash-video figcaption {
+		font-size: 0.875rem;
+		color: var(--emdash-caption-color, var(--color-muted, #666));
+		margin-top: 0.5rem;
+		text-align: center;
+	}
+</style>

package/src/components/WebMcpSearch.astro

@@ -0,0 +1,80 @@
+---
+/**
+ * WebMcpSearch - Lets AI agents in the visitor's browser search the site
+ *
+ * Registers a read-only `search_site` tool through WebMCP
+ * (`document.modelContext`) in browsers that support it, and does nothing in
+ * others. The tool calls the public search API only when an agent uses it.
+ *
+ * ```astro
+ * ---
+ * import WebMcpSearch from "emdash/ui/webmcp-search";
+ * ---
+ * <WebMcpSearch collections={["posts", "pages"]} routeMap={{ posts: "/blog/:slug" }} />
+ * ```
+ */
+
+export interface Props {
+	/** Collections to search (defaults to all searchable collections) */
+	collections?: string[];
+	/**
+	 * Locale to restrict results to. Defaults to `Astro.currentLocale`.
+	 * Pass `null` to search across every locale.
+	 */
+	locale?: string | null;
+	/** Maximum results per search, from 1 to 100 (defaults to 10) */
+	limit?: number;
+	/** Per-collection URL templates, e.g. { posts: "/blog/:path" } */
+	routeMap?: Record<string, string>;
+}
+
+const {
+	collections,
+	locale = Astro.currentLocale ?? null,
+	limit = 10,
+	routeMap = {},
+} = Astro.props;
+
+const config = {
+	collections: collections?.join(",") ?? "",
+	locale: locale ?? "",
+	limit,
+	routeMap,
+};
+---
+
+<emdash-webmcp-search data-config={JSON.stringify(config)} hidden></emdash-webmcp-search>
+
+<script>
+	import {
+		registerSiteSearchTool,
+		resolveModelContext,
+		type SiteSearchToolConfig,
+		type WithModelContext,
+	} from "./webmcp-search.js";
+
+	class EmDashWebMcpSearch extends HTMLElement {
+		private controller: AbortController | null = null;
+
+		connectedCallback() {
+			const modelContext = resolveModelContext(
+				document as WithModelContext,
+				navigator as WithModelContext,
+			);
+			if (!modelContext) return;
+
+			const config = JSON.parse(this.dataset.config ?? "{}") as SiteSearchToolConfig;
+			this.controller = new AbortController();
+			registerSiteSearchTool(modelContext, config, location.origin, this.controller.signal);
+		}
+
+		disconnectedCallback() {
+			this.controller?.abort();
+			this.controller = null;
+		}
+	}
+
+	if (!customElements.get("emdash-webmcp-search")) {
+		customElements.define("emdash-webmcp-search", EmDashWebMcpSearch);
+	}
+</script>

package/src/components/index.ts

@@ -50,6 +50,8 @@ export { default as Gallery } from "./Gallery.astro";
 export { default as Columns } from "./Columns.astro";
 export { default as Break } from "./Break.astro";
 export { default as HtmlBlock } from "./HtmlBlock.astro";
+export { default as Iframe } from "./Iframe.astro";
+export { default as Video } from "./Video.astro";
 export { default as Table } from "./Table.astro";
 export { default as Button } from "./Button.astro";
 export { default as Buttons } from "./Buttons.astro";
@@ -76,12 +78,14 @@ import EmbedComponent from "./Embed.astro";
 import FileComponent from "./File.astro";
 import GalleryComponent from "./Gallery.astro";
 import HtmlBlockComponent from "./HtmlBlock.astro";
+import IframeComponent from "./Iframe.astro";
 // Pre-configured components object for PortableText
 import ImageComponent from "./Image.astro";
 import { emdashMarkComponents } from "./marks.js";
 import OrderedListComponent from "./OrderedList.astro";
 import PullquoteComponent from "./Pullquote.astro";
 import TableComponent from "./Table.astro";
+import VideoComponent from "./Video.astro";
 
 /**
  * Pre-configured components for EmDash Portable Text content
@@ -89,8 +93,8 @@ import TableComponent from "./Table.astro";
  * Includes renderers for:
  * - Block styles: paragraph, h1..h6, blockquote — with `textAlign` honoured
  *   as a WordPress-style `has-text-align-{value}` class (#1201)
- * - Block types: image, code, embed, gallery, columns, break, htmlBlock, table,
- *   button, buttons, cover, file, pullquote
+ * - Block types: image, code, embed, gallery, columns, break, htmlBlock, iframe,
+ *   video, table, button, buttons, cover, file, pullquote
  * - Marks: superscript, subscript, underline, strike-through, link
  */
 export const emdashComponents = {
@@ -107,6 +111,8 @@ export const emdashComponents = {
 		columns: ColumnsComponent,
 		break: BreakComponent,
 		htmlBlock: HtmlBlockComponent,
+		iframe: IframeComponent,
+		video: VideoComponent,
 		table: TableComponent,
 		button: ButtonComponent,
 		buttons: ButtonsComponent,

package/src/components/inline-code-block.tsx

@@ -458,6 +458,14 @@ export const InlineCodeBlockExtension = CodeBlockLowlight.extend({
 
 		return {
 			...shortcuts,
+			"Mod-a": () => {
+				if (!selectionIsInCodeBlock()) return false;
+				const { $from } = this.editor.state.selection;
+				return this.editor.commands.setTextSelection({
+					from: $from.start(),
+					to: $from.end(),
+				});
+			},
 			Tab: (props) => (selectionIsInCodeBlock() ? (shortcuts.Tab?.(props) ?? false) : false),
 			"Shift-Tab": (props) =>
 				selectionIsInCodeBlock() ? (shortcuts["Shift-Tab"]?.(props) ?? false) : false,

package/src/components/webmcp-search.ts

@@ -0,0 +1,138 @@
+import { buildLiveSearchResultUrl, type LiveSearchRouteMap } from "./live-search-routing.js";
+
+export interface SiteSearchToolConfig {
+	/** Comma-separated collection slugs, or `""` for every searchable collection. */
+	collections: string;
+	/** Locale to search, or `""` for every locale. */
+	locale: string;
+	/** Default and maximum number of results per call. */
+	limit: number;
+	routeMap: LiveSearchRouteMap;
+}
+
+interface SiteSearchToolResult {
+	title: string;
+	url: string;
+	collection: string;
+	excerpt?: string;
+}
+
+interface WebMcpTool {
+	name: string;
+	description: string;
+	inputSchema: Record<string, unknown>;
+	annotations: { readOnlyHint: boolean; untrustedContentHint: boolean };
+	/**
+	 * WebMCP serializes the fulfilled value to JSON for the agent and reports only a
+	 * rejection as a failed call, so errors must throw rather than resolve.
+	 */
+	execute: (input: { query?: unknown; limit?: unknown }) => Promise<SiteSearchToolResult[]>;
+}
+
+export interface ModelContextLike {
+	registerTool: (tool: WebMcpTool, options?: { signal?: AbortSignal }) => unknown;
+}
+
+export interface WithModelContext {
+	modelContext?: ModelContextLike;
+}
+
+interface SearchApiResult {
+	collection: string;
+	id: string;
+	slug: string | null;
+	title?: string;
+	snippet?: string;
+}
+
+const MARK_RE = /<\/?mark>/g;
+const MAX_LIMIT = 100;
+
+/** Turns a search snippet (escaped text with `<mark>` highlights) into plain text. */
+function snippetToText(snippet: string): string {
+	return snippet
+		.replace(MARK_RE, "")
+		.replaceAll("&lt;", "<")
+		.replaceAll("&gt;", ">")
+		.replaceAll("&quot;", '"')
+		.replaceAll("&#39;", "'")
+		.replaceAll("&amp;", "&");
+}
+
+export function createSiteSearchTool(
+	config: SiteSearchToolConfig,
+	origin: string,
+	fetchImpl: typeof fetch = fetch,
+): WebMcpTool {
+	const maxLimit = Math.min(Math.max(Math.floor(config.limit) || 1, 1), MAX_LIMIT);
+	return {
+		name: "search_site",
+		description:
+			"Search this site's published content. Returns matching pages with their title, URL, and a text excerpt.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				query: { type: "string", description: "Words to search for" },
+				limit: {
+					type: "integer",
+					minimum: 1,
+					maximum: maxLimit,
+					description: `Maximum number of results (default ${maxLimit})`,
+				},
+			},
+			required: ["query"],
+		},
+		annotations: { readOnlyHint: true, untrustedContentHint: true },
+		async execute(input) {
+			const query = typeof input.query === "string" ? input.query.trim() : "";
+			if (!query) throw new Error("Provide a search query.");
+			const requested = typeof input.limit === "number" ? Math.floor(input.limit) : maxLimit;
+			const limit = Math.min(Math.max(requested, 1), maxLimit);
+
+			const params = new URLSearchParams({ q: query, limit: String(limit) });
+			if (config.collections) params.set("collections", config.collections);
+			if (config.locale) params.set("locale", config.locale);
+
+			const response = await fetchImpl(`${origin}/_emdash/api/search?${params}`);
+			if (!response.ok) throw new Error(`Search failed (HTTP ${response.status}).`);
+			const body: { data?: { items?: SearchApiResult[] } } = await response.json();
+			return (body.data?.items ?? []).map((item) => ({
+				title: item.title ?? item.slug ?? item.id,
+				url: new URL(buildLiveSearchResultUrl(item, config.routeMap), origin).href,
+				collection: item.collection,
+				...(item.snippet ? { excerpt: snippetToText(item.snippet) } : {}),
+			}));
+		},
+	};
+}
+
+function warnRegistrationFailed(error: unknown): void {
+	console.warn("[emdash] Could not register the WebMCP search tool:", error);
+}
+
+/** Returns the browser's WebMCP model context, preferring `document` over the deprecated `navigator` location. */
+export function resolveModelContext(
+	doc?: WithModelContext,
+	nav?: WithModelContext,
+): ModelContextLike | undefined {
+	return doc?.modelContext ?? nav?.modelContext;
+}
+
+/** Registers the site search tool when the browser supports WebMCP. */
+export function registerSiteSearchTool(
+	modelContext: ModelContextLike | undefined,
+	config: SiteSearchToolConfig,
+	origin: string,
+	signal?: AbortSignal,
+): boolean {
+	if (!modelContext) return false;
+	try {
+		Promise.resolve(
+			modelContext.registerTool(createSiteSearchTool(config, origin), { signal }),
+		).catch(warnRegistrationFailed);
+		return true;
+	} catch (error) {
+		warnRegistrationFailed(error);
+		return false;
+	}
+}

package/src/components/widgets/RecentPosts.astro

@@ -1,47 +1,87 @@
 ---
 import { getEmDashCollection } from "../../query.js";
+import { getI18nConfig } from "../../i18n/config.js";
+import { getSiteSettings } from "../../settings/index.js";
+import { sanitizeHref } from "../../utils/url.js";
+import EmDashImage from "../EmDashImage.astro";
+import { buildLiveSearchResultUrl } from "../live-search-routing.js";
+import {
+	createPublishedDateFormatter,
+	isThumbnailImage,
+	toPublishedDate,
+} from "../../widgets/recent-posts.js";
 
 interface Props {
 	count?: number;
 	showThumbnails?: boolean;
 	showDate?: boolean;
+	/** URL template for post links, e.g. "/blog/:slug" (tokens: :collection, :id, :slug, :path) */
+	urlTemplate?: string;
 }
 
-const { count = 5, showThumbnails = false, showDate = true } = Astro.props;
+const { count = 5, showThumbnails = false, showDate = true, urlTemplate } = Astro.props;
 
-const { entries: posts } = await getEmDashCollection("posts", {
-	limit: count,
-	orderBy: { published_at: "desc" },
+const [{ entries: posts }, settings] = await Promise.all([
+	getEmDashCollection("posts", {
+		limit: count,
+		orderBy: { published_at: "desc" },
+	}),
+	showDate ? getSiteSettings() : undefined,
+]);
+
+const dateFormatter = createPublishedDateFormatter({
+	locale: Astro.currentLocale ?? getI18nConfig()?.defaultLocale,
+	timezone: settings?.timezone,
 });
 
-// Helper to get typed values from dynamic data
-function getString(data: Record<string, unknown>, key: string): string | undefined {
-	const val = data[key];
-	return typeof val === "string" ? val : undefined;
+function getTitle(data: Record<string, unknown>): string | undefined {
+	return typeof data.title === "string" ? data.title : undefined;
 }
 ---
 
 <ul class="widget-recent-posts">
 	{
 		posts.map((post) => {
-			const publishedAt = getString(post.data, "publishedAt");
-			const featuredImage = getString(post.data, "featured_image");
-			const title = getString(post.data, "title");
+			const title = getTitle(post.data);
+			const publishedAt = toPublishedDate(post.data.publishedAt);
+			const featuredImage = post.data.featured_image;
+			// Without a template, keep the widget's long-standing default:
+			// `post.id` is the loader's slug (or `locale/slug` with i18n
+			// prefixing), so the locale prefix is preserved. With a template,
+			// use the same token semantics as LiveSearch's routeMap — `:id`
+			// is the content ULID (`data.id`), `:slug` the bare slug.
+			const href = urlTemplate
+				? sanitizeHref(
+						buildLiveSearchResultUrl(
+							{
+								collection: "posts",
+								id: typeof post.data.id === "string" ? post.data.id : post.id,
+								slug: typeof post.data.slug === "string" ? post.data.slug : post.id,
+							},
+							{ posts: urlTemplate },
+						),
+					)
+				: `/posts/${post.id}`;
 			return (
 				<li>
-					{showThumbnails && featuredImage && (
-						<img
-							src={featuredImage}
+					{showThumbnails && isThumbnailImage(featuredImage) && (
+						<EmDashImage
+							image={featuredImage}
 							alt=""
+							width={96}
+							height={96}
 							class="widget-recent-posts__thumbnail"
 						/>
 					)}
-					<a href={`/posts/${post.id}`} class="widget-recent-posts__link">
+					<a href={href} class="widget-recent-posts__link">
 						{title}
 					</a>
 					{showDate && publishedAt && (
-						<time datetime={publishedAt} class="widget-recent-posts__date">
-							{new Date(publishedAt).toLocaleDateString()}
+						<time
+							datetime={publishedAt.toISOString()}
+							class="widget-recent-posts__date"
+						>
+							{dateFormatter.format(publishedAt)}
 						</time>
 					)}
 				</li>

package/src/config/secrets.ts

@@ -34,6 +34,7 @@ import type { Kysely } from "kysely";
 
 import { after } from "../after.js";
 import { OptionsRepository } from "../database/repositories/options.js";
+import { isRequestScopedDb } from "../database/request-scoped.js";
 import type { Database } from "../database/types.js";
 import { decodeBase64url, encodeBase64url } from "../utils/base64.js";
 import {
@@ -382,17 +383,22 @@ export async function validateEncryptionKeyAtStartup(env?: SecretsEnv): Promise<
 }
 
 /**
- * Per-DB cache of resolved secrets, keyed by Kysely instance identity.
+ * Per-DB cache of resolved secrets. Request-scoped views of the configured
+ * database (see `database/request-scoped.ts`) share one entry; any other
+ * Kysely instance is keyed by its identity.
  *
  * The resolved values are stable for the lifetime of the deployment (env
  * vars don't change without a restart, and DB-stored values are written
  * once via `setIfAbsent`). Caching avoids one options-table read per
- * request on the hot paths (preview verification, comment hashing).
+ * request on the hot paths (preview verification, comment hashing). A
+ * deleted row is regenerated only by a process or isolate that has not
+ * cached the old value, so rotating a DB-stored secret needs a restart or
+ * redeploy.
  *
  * Lives on `globalThis` so module-duplication during SSR bundling can't
  * fragment the cache. See `request-context.ts` for the same pattern.
  *
- * Each db gets its own poison-immune single-flight cache (see
+ * Each entry is a poison-immune single-flight cache (see
  * `utils/single-flight-cache.ts`): the resolved *value* is cached, never an
  * in-flight promise, so a request cancelled mid-resolve can't strand later
  * preview/comment requests on the isolate.
@@ -405,9 +411,10 @@ const SECRETS_CACHE_KEY = Symbol.for("@emdash-cms/core/secrets-cache@2");
 
 interface SecretsCacheHolder {
 	cache: WeakMap<Kysely<Database>, SingleFlightCache<ResolvedSecrets>>;
+	requestScoped?: SingleFlightCache<ResolvedSecrets>;
 }
 
-function getSecretsCache(): WeakMap<Kysely<Database>, SingleFlightCache<ResolvedSecrets>> {
+function getSecretsCache(db: Kysely<Database>): SingleFlightCache<ResolvedSecrets> {
 	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern
 	const holder = globalThis as Record<symbol, SecretsCacheHolder | undefined>;
 	let entry = holder[SECRETS_CACHE_KEY];
@@ -415,7 +422,16 @@ function getSecretsCache(): WeakMap<Kysely<Database>, SingleFlightCache<Resolved
 		entry = { cache: new WeakMap() };
 		holder[SECRETS_CACHE_KEY] = entry;
 	}
-	return entry.cache;
+	if (isRequestScopedDb(db)) {
+		entry.requestScoped ??= createSingleFlightCache<ResolvedSecrets>();
+		return entry.requestScoped;
+	}
+	let cache = entry.cache.get(db);
+	if (!cache) {
+		cache = createSingleFlightCache<ResolvedSecrets>();
+		entry.cache.set(db, cache);
+	}
+	return cache;
 }
 
 /**
@@ -423,18 +439,14 @@ function getSecretsCache(): WeakMap<Kysely<Database>, SingleFlightCache<Resolved
  * paths (preview verification, comment IP hashing) so they don't reread
  * env / re-query options on every request.
  *
- * The cache is keyed by `Kysely` instance, so playground / per-DO / per-test
- * databases each get their own resolution. Concurrent cold callers coalesce
- * onto one resolution via the single-flight lock; a failed resolution
- * propagates to the caller and releases the lock so the next caller retries.
+ * Request-scoped views of the configured database share one resolution;
+ * playground / DO preview / per-test databases each get their own.
+ * Concurrent cold callers coalesce onto one resolution via the single-flight
+ * lock; a failed resolution propagates to the caller and releases the lock so
+ * the next caller retries.
  */
 export function resolveSecretsCached(db: Kysely<Database>): Promise<ResolvedSecrets> {
-	const caches = getSecretsCache();
-	let cache = caches.get(db);
-	if (!cache) {
-		cache = createSingleFlightCache<ResolvedSecrets>();
-		caches.set(db, cache);
-	}
+	const cache = getSecretsCache(db);
 	return singleFlightCached(cache, () => resolveSecrets({ db }), {
 		anchor: (promise) => after(() => promise),
 		ownerTimeoutMs: 30_000,

package/src/content/converters/mark-safety.ts

@@ -1,4 +1,4 @@
-import type { PortableTextBlock, ProseMirrorDocument, ProseMirrorNode } from "./types.js";
+import type { ProseMirrorDocument, ProseMirrorNode } from "./types.js";
 
 const SUPPORTED_PORTABLE_TEXT_DECORATORS = new Set([
 	"strong",
@@ -93,7 +93,7 @@ export class UnsupportedPortableTextMarksError extends Error {
 	}
 }
 
-export function findUnsupportedPortableTextMarks(blocks: PortableTextBlock[]): string[] {
+export function findUnsupportedPortableTextMarks(blocks: readonly { _type: string }[]): string[] {
 	const unsupported = new Set<string>();
 	for (const block of blocks) {
 		if (block._type === "block" || block._type === "table") {
@@ -103,7 +103,7 @@ export function findUnsupportedPortableTextMarks(blocks: PortableTextBlock[]): s
 	return [...unsupported].toSorted();
 }
 
-export function assertPortableTextMarksSupported(blocks: PortableTextBlock[]): void {
+export function assertPortableTextMarksSupported(blocks: readonly { _type: string }[]): void {
 	const unsupported = findUnsupportedPortableTextMarks(blocks);
 	if (unsupported.length > 0) {
 		throw new UnsupportedPortableTextMarksError(unsupported);

package/src/content/converters/portable-text-identity.ts

@@ -70,7 +70,9 @@ export const PortableTextIdentityExtension = Extension.create({
 					"blockquote",
 					"codeBlock",
 					"htmlBlock",
+					"iframeBlock",
 					"image",
+					"videoBlock",
 					"horizontalRule",
 					"gallery",
 					PORTABLE_TEXT_BLOCK_NODE,

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -4,6 +4,7 @@
  * Converts Portable Text to TipTap's ProseMirror JSON format for editing.
  */
 
+import { htmlBlockFields } from "@emdash-cms/admin/html-block";
 import {
 	UnsafePortableTextTableError,
 	portableTextTableToProseMirror,
@@ -38,7 +39,9 @@ import type {
 	PortableTextImageBlock,
 	PortableTextGalleryBlock,
 	PortableTextCodeBlock,
+	PortableTextIframeBlock,
 } from "./types.js";
+import { isPortableTextVideoBlock, videoNodeAttrs } from "./video.js";
 
 function generateKey(): string {
 	return Math.random().toString(36).substring(2, 11);
@@ -222,6 +225,35 @@ function isGalleryBlock(block: PortableTextBlock): block is PortableTextGalleryB
 	return block._type === "gallery" && "images" in block && Array.isArray(block.images);
 }
 
+const isString = (value: unknown) => typeof value === "string";
+const isFrameDimension = (value: unknown) =>
+	typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 10_000;
+
+const IFRAME_BLOCK_FIELDS = new Map<string, (value: unknown) => boolean>([
+	["_type", () => true],
+	["_key", () => true],
+	["src", isString],
+	["title", isString],
+	["width", isFrameDimension],
+	["height", isFrameDimension],
+	["allow", isString],
+	["allowFullscreen", (value) => typeof value === "boolean"],
+]);
+
+/**
+ * An `iframe` block with other fields, or with values of other types, belongs
+ * to a plugin and stays a generic block.
+ */
+function isIframeBlock(block: PortableTextBlock): block is PortableTextIframeBlock {
+	return (
+		block._type === "iframe" &&
+		typeof block.src === "string" &&
+		Object.entries(block).every(
+			([key, value]) => value === undefined || (IFRAME_BLOCK_FIELDS.get(key)?.(value) ?? false),
+		)
+	);
+}
+
 /**
  * Type guard for code blocks
  */
@@ -264,10 +296,19 @@ function convertBlock(
 		return convertCodeBlock(block, preserveIdentity);
 	}
 	if (block._type === "htmlBlock") {
-		const hb = block as PortableTextBlock & { html?: string };
 		return {
 			type: "htmlBlock",
-			attrs: identityAttrs({ html: hb.html || "" }, block._key, preserveIdentity),
+			attrs: identityAttrs({ ...htmlBlockFields(block) }, block._key, preserveIdentity),
+		};
+	}
+	if (isIframeBlock(block)) {
+		const { _type, _key, ...attrs } = block;
+		return { type: "iframeBlock", attrs: identityAttrs(attrs, _key, preserveIdentity) };
+	}
+	if (isPortableTextVideoBlock(block)) {
+		return {
+			type: "videoBlock",
+			attrs: identityAttrs(videoNodeAttrs(block), block._key, preserveIdentity),
 		};
 	}
 	if (block._type === "break") {