emdash 0.39.0 → 0.40.0

package/src/emdash-runtime.ts

@@ -28,7 +28,6 @@ import {
 	handleMediaUpload as uploadMedia,
 	type MediaUploadInput,
 } from "./api/handlers/media-upload.js";
-import { assertMediaUsageActivationWriteAllowed } from "./api/media-usage-write-fence.js";
 import { validateRev } from "./api/rev.js";
 import { getSiteBaseUrl } from "./api/site-url.js";
 import type {
@@ -58,6 +57,7 @@ import { CommentRepository } from "./database/repositories/comment.js";
 import type { CommentStatus } from "./database/repositories/comment.js";
 import { ContentRepository } from "./database/repositories/content.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
+import { selectTaxonomyDefs } from "./database/repositories/taxonomy-def.js";
 import { ContentMutationConflictError } from "./database/repositories/types.js";
 import type {
 	ContentItem as ContentItemInternal,
@@ -82,7 +82,7 @@ import {
 	type ScheduledPolicyRejection,
 } from "./plugins/content-policy.js";
 import { createCommentAccess, createTaxonomyAccessWithWrite } from "./plugins/context.js";
-import type { ContentActionCallbacks } from "./plugins/context.js";
+import type { ContentActionCallbacks, ContentWriteGuard } from "./plugins/context.js";
 import type { PluginContentCacheInvalidator } from "./plugins/routes.js";
 import {
 	createSandboxedPluginProxy,
@@ -233,6 +233,9 @@ import {
 	handleRevisionGet,
 	handleRevisionRestore,
 	SchemaRegistry,
+	SchemaError,
+	normalizeBlocksData,
+	resolveBlockTypes,
 	type Database,
 	type Storage,
 } from "./index.js";
@@ -275,8 +278,20 @@ import { getRequestContext } from "./request-context.js";
 import { publishDueContent, type PublishedRef } from "./scheduled-publish.js";
 import { FTSManager } from "./search/fts-manager.js";
 import { invalidateSiteSettingsCache } from "./settings/index.js";
-
-const DRAFT_ONLY_UPDATE_KEYS = new Set(["data", "slug", "locale", "skipRevision", "actor"]);
+import { assertSiteWriteAllowed } from "./transfer/fence.js";
+
+const DRAFT_ONLY_UPDATE_KEYS = new Set([
+	"data",
+	"slug",
+	"locale",
+	"skipRevision",
+	"actor",
+	"migrateBlocks",
+	"replaceBlocks",
+]);
+
+/** Field types whose schema is an array, so a stored blank string can never validate. */
+const ARRAY_FIELD_TYPES = new Set<string>(["portableText", "multiSelect", "repeater"]);
 const MAX_DRAFT_STAGE_ATTEMPTS = 32;
 const PLUGIN_INVOCATION_RELEASE_GRACE_MS = 60_000;
 
@@ -483,7 +498,7 @@ export interface EmDashRuntimeParts {
 	pipelineFactoryOptions: {
 		db: Kysely<Database>;
 		getDb?: () => Kysely<Database>;
-		beforeContentWrite?: () => Promise<void>;
+		beforeContentWrite?: ContentWriteGuard;
 		contentCreate?: PluginContentCreateCallback;
 		contentActions?: ContentActionCallbacks;
 		now?: () => Date;
@@ -770,7 +785,7 @@ export class EmDashRuntime {
 	private pipelineFactoryOptions: {
 		db: Kysely<Database>;
 		getDb?: () => Kysely<Database>;
-		beforeContentWrite?: () => Promise<void>;
+		beforeContentWrite?: ContentWriteGuard;
 		contentCreate?: PluginContentCreateCallback;
 		contentActions?: ContentActionCallbacks;
 		now?: () => Date;
@@ -866,9 +881,9 @@ export class EmDashRuntime {
 	private async publishScheduledWithFence(
 		onPublished?: (refs: PublishedRef[]) => Promise<void>,
 	): Promise<PublishedRef[]> {
-		await assertMediaUsageActivationWriteAllowed(this.db);
+		const recordWrite = await assertSiteWriteAllowed(this.db);
 		const currentTime = this.runtimeDeps.now?.() ?? new Date();
-		return publishDueContent(this.db, {
+		const published = await publishDueContent(this.db, {
 			publish: (collection, id, options) =>
 				this.handleContentPublish(collection, id, {
 					...options,
@@ -877,6 +892,8 @@ export class EmDashRuntime {
 			onPublished,
 			currentTime,
 		});
+		if (published.length > 0) await recordWrite();
+		return published;
 	}
 
 	/**
@@ -1004,14 +1021,27 @@ export class EmDashRuntime {
 	async setPluginStatus(pluginId: string, status: "active" | "inactive"): Promise<void> {
 		this.pluginStates.set(pluginId, status);
 		if (status === "active") {
+			this.setSandboxedPluginActive(pluginId, true);
 			this.enabledPlugins.add(pluginId);
 			await this.rebuildHookPipeline();
 			await this._hooks.runPluginActivate(pluginId);
 		} else {
-			// Fire deactivate on the current pipeline while the plugin is still in it
-			await this._hooks.runPluginDeactivate(pluginId);
-			this.enabledPlugins.delete(pluginId);
-			await this.rebuildHookPipeline();
+			try {
+				// Deactivate hooks retain access until their cleanup has finished.
+				await this._hooks.runPluginDeactivate(pluginId);
+			} finally {
+				this.setSandboxedPluginActive(pluginId, false);
+				this.enabledPlugins.delete(pluginId);
+				await this.rebuildHookPipeline();
+			}
+		}
+	}
+
+	private setSandboxedPluginActive(pluginId: string, active: boolean): void {
+		for (const [key, plugin] of this.sandboxedPlugins) {
+			if (key.slice(0, key.lastIndexOf(":")) === pluginId) {
+				plugin.setActive?.(active);
+			}
 		}
 	}
 
@@ -1673,8 +1703,13 @@ export class EmDashRuntime {
 						const seed = await loadSeed();
 						const validation = validateSeed(seed);
 						if (validation.valid) {
-							await applySeed(db, seed, { onConflict: "skip" });
+							const seedResult = await applySeed(db, seed, { onConflict: "skip" });
 							console.log("Auto-seeded default collections");
+							if (seedResult.taxonomies.skipped > 0) {
+								console.warn(
+									`[auto-seed] Kept ${seedResult.taxonomies.skipped} existing taxonomy definition(s) instead of the seed's. Edit them in the admin, or run \`emdash seed <file> --on-conflict update\` to replace them (this also overwrites other seeded records).`,
+								);
+							}
 						}
 						seedHolder.done.add(seedKey);
 						return true;
@@ -1741,8 +1776,9 @@ export class EmDashRuntime {
 		}
 
 		// Register built-in default comment moderator.
-		// Always present — auto-selected as the sole comment:moderate provider
-		// unless a plugin (e.g. AI moderation) provides its own.
+		// Always present as a fallback: exclusive hook resolution selects a
+		// single plugin moderator (e.g. AI moderation) over it unless the site
+		// has already stored a comment:moderate selection.
 		try {
 			const defaultModeratorPlugin = definePlugin({
 				id: DEFAULT_COMMENT_MODERATOR_PLUGIN_ID,
@@ -1813,6 +1849,11 @@ export class EmDashRuntime {
 		const sandboxedPluginPool = await phase("rt.sandbox", "Sandboxed plugins", () =>
 			EmDashRuntime.loadSandboxedPlugins(deps, db, storage, siteInfo),
 		);
+		for (const [key, plugin] of sandboxedPluginPool) {
+			const pluginId = key.slice(0, key.lastIndexOf(":"));
+			const status = pluginStates.get(pluginId);
+			plugin.setActive?.(status === undefined || status === "active");
+		}
 
 		// Cold-start: load marketplace- and registry-installed plugins from
 		// site R2 via the sandbox runner. The two tiers only depend on the
@@ -1945,7 +1986,7 @@ export class EmDashRuntime {
 		const pipelineFactoryOptions = {
 			db,
 			getDb: resolveDb,
-			beforeContentWrite: () => assertMediaUsageActivationWriteAllowed(resolveDb()),
+			beforeContentWrite: () => assertSiteWriteAllowed(resolveDb()),
 			contentActions,
 			now: deps.now,
 			storage: storage ?? undefined,
@@ -2069,8 +2110,8 @@ export class EmDashRuntime {
 							if (runtime) {
 								await runtime.publishScheduled();
 							} else {
-								await assertMediaUsageActivationWriteAllowed(db);
-								await publishDueContent(db);
+								const recordWrite = await assertSiteWriteAllowed(db);
+								if ((await publishDueContent(db)).length > 0) await recordWrite();
 							}
 						} catch (error) {
 							console.error("[scheduled-publish] Sweep failed:", error);
@@ -2431,7 +2472,7 @@ export class EmDashRuntime {
 				createSandboxRunnerOptions(
 					{
 						db,
-						beforeContentWrite: () => assertMediaUsageActivationWriteAllowed(db),
+						beforeContentWrite: () => assertSiteWriteAllowed(db),
 						taxonomyWrite: createTaxonomyAccessWithWrite(db),
 						now: deps.now,
 						mediaStorage: mediaStorage
@@ -2590,7 +2631,7 @@ export class EmDashRuntime {
 				createSandboxRunnerOptions(
 					{
 						db,
-						beforeContentWrite: () => assertMediaUsageActivationWriteAllowed(db),
+						beforeContentWrite: () => assertSiteWriteAllowed(db),
 						taxonomyWrite: createTaxonomyAccessWithWrite(db),
 						now: deps.now,
 						mediaStorage: {
@@ -2831,6 +2872,7 @@ export class EmDashRuntime {
 				await optionsRepo.delete(key);
 			},
 			preferredHints,
+			fallbackProviders: new Set([DEFAULT_COMMENT_MODERATOR_PLUGIN_ID]),
 		});
 	}
 
@@ -3008,11 +3050,7 @@ export class EmDashRuntime {
 		}> = [];
 		let taxonomyDefinitionLocales: string[] = [];
 		try {
-			const rows = await this.db
-				.selectFrom("_emdash_taxonomy_defs")
-				.selectAll()
-				.orderBy("name")
-				.execute();
+			const rows = await selectTaxonomyDefs(this.db).orderBy("d.name").execute();
 			taxonomyDefinitionLocales = rows.map((row) => row.locale);
 			manifestTaxonomies = rows.map((row) => ({
 				id: row.id,
@@ -3279,6 +3317,8 @@ export class EmDashRuntime {
 			translationOf?: string;
 			taxonomies?: Record<string, string[]>;
 			actor?: ActorInfo;
+			migrateBlocks?: boolean;
+			replaceBlocks?: boolean;
 		},
 		options: { skipSaveHooks?: boolean; excludeAfterSavePluginId?: string } = {},
 	) {
@@ -3359,9 +3399,43 @@ export class EmDashRuntime {
 				}
 			}
 		}
+		const collectionInfo = await this.schemaRegistry
+			.getCollectionWithFields(collection)
+			.catch(() => null);
+		const resolvedBlockTypes = collectionInfo?.fields.some((field) => field.type === "blocks")
+			? await resolveBlockTypes(this.db)
+			: undefined;
+		if (collectionInfo) {
+			try {
+				processedData = await normalizeBlocksData(
+					this.db,
+					collectionInfo,
+					processedData,
+					translationSource?.data,
+					{
+						migrateBlocks: body.migrateBlocks,
+						replaceBlocks: body.replaceBlocks,
+					},
+					false,
+					resolvedBlockTypes,
+				);
+			} catch (error) {
+				if (error instanceof SchemaError) {
+					return {
+						success: false as const,
+						error: { code: error.code, message: error.message, details: error.details },
+					};
+				}
+				throw error;
+			}
+		}
 
-		// Normalize media fields (fill dimensions, storageKey, etc.)
-		processedData = await this.normalizeMediaFields(collection, processedData);
+		processedData = await this.normalizeFieldValues(
+			collection,
+			processedData,
+			collectionInfo,
+			resolvedBlockTypes,
+		);
 
 		// Validate against the collection schema. Hook output is validated
 		// rather than `body.data` so plugins that mutate field values can't
@@ -3378,8 +3452,14 @@ export class EmDashRuntime {
 		}
 
 		// Create the content
+		const {
+			actor: _discardedActor,
+			migrateBlocks: _discardedMigrateBlocks,
+			replaceBlocks: _discardedReplaceBlocks,
+			...contentBody
+		} = body;
 		const result = await handleContentCreate(this.db, collection, {
-			...body,
+			...contentBody,
 			data: processedData,
 			locale,
 			authorId: body.authorId,
@@ -3430,6 +3510,8 @@ export class EmDashRuntime {
 			 * passed to content hooks; never changes entry ownership.
 			 */
 			actor?: ActorInfo;
+			migrateBlocks?: boolean;
+			replaceBlocks?: boolean;
 		},
 	) {
 		const actor = body.actor ? { ...body.actor } : undefined;
@@ -3457,7 +3539,14 @@ export class EmDashRuntime {
 				};
 			}
 		}
-		const { _rev: _discardedRev, actor: _discardedActor, ...bodyWithoutRev } = body;
+		const {
+			_rev: _discardedRev,
+			actor: _discardedActor,
+			migrateBlocks,
+			replaceBlocks,
+			...bodyWithoutRev
+		} = body;
+		const blockWriteOptions = { migrateBlocks, replaceBlocks };
 
 		// Loaded once and threaded through normalization, the stale-key drop and the draft
 		// merge below: each of those needs the field list and the registry does not cache.
@@ -3468,6 +3557,7 @@ export class EmDashRuntime {
 
 		// Run beforeSave hooks if data is provided
 		let processedData = bodyWithoutRev.data;
+		let resolvedBlockTypes: Awaited<ReturnType<typeof resolveBlockTypes>> | undefined;
 		if (bodyWithoutRev.data) {
 			if (this.hooks.hasHooks("content:beforeSave")) {
 				try {
@@ -3484,8 +3574,13 @@ export class EmDashRuntime {
 				}
 			}
 
-			// Normalize media fields (fill dimensions, storageKey, etc.)
-			processedData = await this.normalizeMediaFields(collection, processedData!, collectionInfo);
+			processedData = await this.normalizeFieldValues(
+				collection,
+				processedData!,
+				collectionInfo,
+				undefined,
+				false,
+			);
 
 			// Drop unknown field keys the entry already stores (e.g. a deleted field
 			// stranded in a draft revision) before validation, while still rejecting
@@ -3497,18 +3592,52 @@ export class EmDashRuntime {
 					knownFieldSlugs,
 				);
 			}
+			if (
+				collectionInfo?.fields.some(
+					(field) => field.type === "blocks" && Object.hasOwn(processedData!, field.slug),
+				)
+			) {
+				resolvedBlockTypes = await resolveBlockTypes(this.db);
+			}
 
-			// Validate field-level shape BEFORE the draft-revision write so
-			// invalid updates can't silently land in revision history.
-			const { validateContentData } = await import("./api/handlers/validation.js");
-			const validation = await validateContentData(this.db, collection, processedData, {
-				partial: true,
-			});
-			if (!validation.ok) {
-				return {
-					success: false as const,
-					error: validation.error,
-				};
+			if (!collectionInfo?.supports?.includes("revisions")) {
+				if (collectionInfo) {
+					try {
+						processedData = await normalizeBlocksData(
+							this.db,
+							collectionInfo,
+							processedData,
+							resolvedItem?.data,
+							blockWriteOptions,
+							true,
+							resolvedBlockTypes,
+						);
+						processedData = await this.normalizeFieldValues(
+							collection,
+							processedData,
+							collectionInfo,
+							resolvedBlockTypes,
+						);
+					} catch (error) {
+						if (error instanceof SchemaError) {
+							return {
+								success: false as const,
+								error: { code: error.code, message: error.message, details: error.details },
+							};
+						}
+						throw error;
+					}
+				}
+				const { validateContentData } = await import("./api/handlers/validation.js");
+				const validation = await validateContentData(this.db, collection, processedData, {
+					partial: true,
+				});
+				if (!validation.ok) {
+					return {
+						success: false as const,
+						error: validation.error,
+					};
+				}
 			}
 		}
 
@@ -3531,13 +3660,46 @@ export class EmDashRuntime {
 					} else {
 						baseData = existing.data;
 					}
+					let attemptData = processedData;
+					try {
+						attemptData = await normalizeBlocksData(
+							this.db,
+							collectionInfo,
+							processedData,
+							baseData,
+							blockWriteOptions,
+							true,
+							resolvedBlockTypes,
+						);
+						attemptData = await this.normalizeFieldValues(
+							collection,
+							attemptData,
+							collectionInfo,
+							resolvedBlockTypes,
+						);
+					} catch (error) {
+						if (error instanceof SchemaError) {
+							return {
+								success: false as const,
+								error: { code: error.code, message: error.message, details: error.details },
+							};
+						}
+						throw error;
+					}
+					const { validateContentData } = await import("./api/handlers/validation.js");
+					const validation = await validateContentData(this.db, collection, attemptData, {
+						partial: true,
+					});
+					if (!validation.ok) {
+						return { success: false as const, error: validation.error };
+					}
 
 					// Written without the keys the collection has no field for, so an entry
 					// carrying a deleted field's value sheds it on its next save instead of
 					// carrying it through every revision that follows.
 					const mergedData = collectionInfo?.fields
-						? keepKnownFields({ ...baseData, ...processedData }, knownFieldSlugs)
-						: { ...baseData, ...processedData };
+						? keepKnownFields({ ...baseData, ...attemptData }, knownFieldSlugs)
+						: { ...baseData, ...attemptData };
 					if (bodyWithoutRev.slug !== undefined) {
 						mergedData._slug = bodyWithoutRev.slug;
 					}
@@ -3585,6 +3747,7 @@ export class EmDashRuntime {
 					}
 
 					draftStorageChanged = true;
+					processedData = attemptData;
 
 					if (bodyWithoutRev.skipRevision && existing.draftRevisionId) {
 						try {
@@ -3812,7 +3975,7 @@ export class EmDashRuntime {
 			}
 			invocationInvalidator = this.pluginInvocationCacheInvalidators.get(invocationKey);
 		}
-		await assertMediaUsageActivationWriteAllowed(this.db);
+		const recordWrite = await assertSiteWriteAllowed(this.db);
 		const repo = new ContentRepository(this.db);
 		const item =
 			action === "restore"
@@ -3828,6 +3991,7 @@ export class EmDashRuntime {
 		this.retainPluginContentAction(key);
 		try {
 			const result = await fn(resolvedId);
+			await recordWrite();
 			const invalidator =
 				invalidateContentCache ?? invocationInvalidator ?? this.pluginContentCacheInvalidator;
 			if (invalidator) {
@@ -4501,7 +4665,7 @@ export class EmDashRuntime {
 	}
 
 	async handleMediaDelete(id: string) {
-		const result = await handleMediaDelete(this.db, id);
+		const result = await handleMediaDelete(this.db, id, this.storage);
 		// Same reasoning as `handleMediaUpdate`: if the deleted media row
 		// was referenced by a setting, the cached resolved URL now points
 		// at a 404. Invalidation is unconditional on success — cheaper than
@@ -5473,13 +5637,16 @@ export class EmDashRuntime {
 	}
 
 	/**
-	 * Normalize image/file fields in content data.
-	 * Fills missing dimensions, storageKey, mimeType, and filename from providers.
+	 * Normalize field values in content data before validation.
+	 * Turns a blank string in an array-valued field into `null`, and fills
+	 * missing image/file dimensions, storageKey, mimeType, and filename from providers.
 	 */
-	private async normalizeMediaFields(
+	private async normalizeFieldValues(
 		collection: string,
 		data: Record<string, unknown>,
 		preloaded?: CollectionWithFields | null,
+		preloadedBlockTypes?: Awaited<ReturnType<typeof resolveBlockTypes>>,
+		includeBlocks = true,
 	): Promise<Record<string, unknown>> {
 		let collectionInfo = preloaded;
 		if (collectionInfo === undefined) {
@@ -5491,6 +5658,14 @@ export class EmDashRuntime {
 		}
 		if (!collectionInfo?.fields) return data;
 
+		const result = { ...data };
+		for (const field of collectionInfo.fields) {
+			const value = result[field.slug];
+			if (ARRAY_FIELD_TYPES.has(field.type) && typeof value === "string" && !value.trim()) {
+				result[field.slug] = null;
+			}
+		}
+
 		const imageFields = collectionInfo.fields.filter(
 			(f) => f.type === "image" || f.type === "file",
 		);
@@ -5500,10 +5675,14 @@ export class EmDashRuntime {
 		const repeaterFields = collectionInfo.fields.filter(
 			(f) => f.type === "repeater" && Array.isArray(f.validation?.subFields),
 		);
-		if (imageFields.length === 0 && repeaterFields.length === 0) return data;
+		const blockFields = includeBlocks
+			? collectionInfo.fields.filter((field) => field.type === "blocks")
+			: [];
+		if (imageFields.length === 0 && repeaterFields.length === 0 && blockFields.length === 0) {
+			return result;
+		}
 
 		const getProvider = (id: string) => this.getMediaProvider(id);
-		const result = { ...data };
 
 		for (const field of imageFields) {
 			const value = result[field.slug];
@@ -5554,6 +5733,63 @@ export class EmDashRuntime {
 			);
 		}
 
+		if (blockFields.length > 0) {
+			const blockTypes = preloadedBlockTypes ?? (await resolveBlockTypes(this.db));
+			for (const field of blockFields) {
+				const value = result[field.slug];
+				if (!Array.isArray(value)) continue;
+				result[field.slug] = await Promise.all(
+					value.map(async (block) => {
+						if (!isRecord(block) || typeof block._type !== "string") return block;
+						const type = blockTypes.get(block._type);
+						const version = type?.versions.find(
+							(candidate) => candidate.version === block._version,
+						);
+						if (!version || version.unsupportedTypes?.length) return block;
+						const normalizedBlock: Record<string, unknown> = { ...block };
+						for (const nestedField of version.fields) {
+							const nestedValue = normalizedBlock[nestedField.slug];
+							if (nestedValue == null) continue;
+							try {
+								if (nestedField.type === "image") {
+									const normalized = await normalizeImageValue(nestedValue, getProvider);
+									if (normalized) normalizedBlock[nestedField.slug] = normalized;
+								} else if (nestedField.type === "file") {
+									const normalized = await normalizeMediaValue(nestedValue, getProvider);
+									if (normalized) normalizedBlock[nestedField.slug] = normalized;
+								} else if (nestedField.type === "repeater" && Array.isArray(nestedValue)) {
+									const imageSlugs = (nestedField.validation?.subFields ?? [])
+										.filter((subField) => subField.type === "image")
+										.map((subField) => subField.slug);
+									normalizedBlock[nestedField.slug] = await Promise.all(
+										nestedValue.map(async (item) => {
+											if (!isRecord(item)) return item;
+											const normalizedItem = { ...item };
+											for (const slug of imageSlugs) {
+												try {
+													const normalized = await normalizeImageValue(
+														normalizedItem[slug],
+														getProvider,
+													);
+													if (normalized) normalizedItem[slug] = normalized;
+												} catch {
+													continue;
+												}
+											}
+											return normalizedItem;
+										}),
+									);
+								}
+							} catch {
+								continue;
+							}
+						}
+						return normalizedBlock;
+					}),
+				);
+			}
+		}
+
 		return result;
 	}
 

package/src/import/utils.ts

@@ -347,7 +347,14 @@ export function relativizeContentLinks(blocks: PortableTextBlock[], siteUrl: str
 				break;
 			case "image":
 				// asset.url stays absolute (media pass), only the click-through link
-				if (block.link) block.link = relativizeUrl(block.link, sourceHost) ?? block.link;
+				if (typeof block.link === "string") {
+					block.link = relativizeUrl(block.link, sourceHost) ?? block.link;
+				} else if (block.link?.href) {
+					block.link = {
+						...block.link,
+						href: relativizeUrl(block.link.href, sourceHost) ?? block.link.href,
+					};
+				}
 				break;
 			case "table":
 				for (const row of block.rows) {