emdash 0.39.0 → 0.40.0

package/src/api/errors.ts

@@ -6,6 +6,8 @@
  * instead of using ad-hoc strings.
  */
 
+import { TransferErrorCode, transferErrorStatus } from "../transfer/errors.js";
+
 export const ErrorCode = {
 	// Shared (used across domains)
 	NOT_FOUND: "NOT_FOUND",
@@ -69,6 +71,10 @@ export const ErrorCode = {
 	SCHEMA_FIELD_UPDATE_ERROR: "SCHEMA_FIELD_UPDATE_ERROR",
 	SCHEMA_FIELD_DELETE_ERROR: "SCHEMA_FIELD_DELETE_ERROR",
 	SCHEMA_FIELD_REORDER_ERROR: "SCHEMA_FIELD_REORDER_ERROR",
+	BLOCK_TYPE_NOT_FOUND: "BLOCK_TYPE_NOT_FOUND",
+	BLOCK_TYPE_EXISTS: "BLOCK_TYPE_EXISTS",
+	BLOCK_TYPE_BREAKING_CHANGE: "BLOCK_TYPE_BREAKING_CHANGE",
+	BLOCK_TYPE_VERSION_CONFLICT: "BLOCK_TYPE_VERSION_CONFLICT",
 	// Byline schema (Discussion #1174). Reuses RESERVED_SLUG, INVALID_SLUG,
 	// INVALID_TYPE, FIELD_EXISTS, NOT_FOUND, VALIDATION_ERROR where the
 	// semantics match; the two below are byline-domain specific:
@@ -385,6 +391,9 @@ export const ErrorCode = {
 	NO_DB: "NO_DB",
 	INVALID_REQUEST: "INVALID_REQUEST",
 	UNKNOWN_ACTION: "UNKNOWN_ACTION",
+
+	// Site transfer
+	...TransferErrorCode,
 } as const;
 
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
@@ -413,6 +422,9 @@ export type OAuthErrorCode = (typeof OAuthErrorCode)[keyof typeof OAuthErrorCode
  * defaults to 400 (client error).
  */
 export function mapErrorStatus(code: string | undefined): number {
+	const transferStatus = transferErrorStatus(code);
+	if (transferStatus !== undefined) return transferStatus;
+
 	switch (code) {
 		// 400 Bad Request
 		case ErrorCode.VALIDATION_ERROR:
@@ -477,6 +489,7 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.FILE_NOT_FOUND:
 		case ErrorCode.NO_VERSION:
 		case ErrorCode.AGGREGATOR_NOT_FOUND:
+		case ErrorCode.BLOCK_TYPE_NOT_FOUND:
 			return 404;
 
 		// 409 Conflict
@@ -496,6 +509,9 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.WORK_LEASE_ACTIVE:
 		case ErrorCode.WORK_CHANGED:
 		case ErrorCode.ENTRY_LOCKED:
+		case ErrorCode.BLOCK_TYPE_EXISTS:
+		case ErrorCode.BLOCK_TYPE_BREAKING_CHANGE:
+		case ErrorCode.BLOCK_TYPE_VERSION_CONFLICT:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT:

package/src/api/handlers/api-tokens.ts

@@ -191,6 +191,18 @@ export async function deleteApiTokensByName(
 	return Number(result.numDeletedRows ?? 0n);
 }
 
+/**
+ * A resolved bearer token. `tokenId` identifies the credential (not the
+ * user) and is safe to store and show: the token row id for a PAT, and for
+ * an OAuth token a one-way id of its grant that stays the same across
+ * access-token refreshes.
+ */
+export interface ResolvedBearerToken {
+	userId: string;
+	scopes: string[];
+	tokenId: string;
+}
+
 /**
  * Resolve a raw API token (ec_pat_...) to a user ID and scopes.
  * Updates last_used_at on successful lookup.
@@ -199,7 +211,7 @@ export async function deleteApiTokensByName(
 export async function resolveApiToken(
 	db: Kysely<Database>,
 	rawToken: string,
-): Promise<{ userId: string; scopes: string[] } | null> {
+): Promise<ResolvedBearerToken | null> {
 	const hash = hashApiToken(rawToken);
 
 	const row = await db
@@ -225,6 +237,7 @@ export async function resolveApiToken(
 	return {
 		userId: row.user_id,
 		scopes: JSON.parse(row.scopes) as string[],
+		tokenId: row.id,
 	};
 }
 
@@ -235,12 +248,12 @@ export async function resolveApiToken(
 export async function resolveOAuthToken(
 	db: Kysely<Database>,
 	rawToken: string,
-): Promise<{ userId: string; scopes: string[] } | null> {
+): Promise<ResolvedBearerToken | null> {
 	const hash = hashApiToken(rawToken);
 
 	const row = await db
 		.selectFrom("_emdash_oauth_tokens")
-		.select(["user_id", "scopes", "expires_at", "token_type"])
+		.select(["user_id", "scopes", "expires_at", "token_type", "refresh_token_hash"])
 		.where("token_hash", "=", hash)
 		.where("token_type", "=", "access")
 		.executeTakeFirst();
@@ -255,5 +268,7 @@ export async function resolveOAuthToken(
 	return {
 		userId: row.user_id,
 		scopes: JSON.parse(row.scopes) as string[],
+		// Hashing the stored hash again keeps the id from being a token lookup key.
+		tokenId: `oauth:${hashApiToken(row.refresh_token_hash ?? hash)}`,
 	};
 }

package/src/api/handlers/block-types.ts

@@ -0,0 +1,129 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import { invalidateCollectionCache } from "../../object-cache/index.js";
+import {
+	BlockTypeRegistry,
+	SchemaError,
+	invalidateSchemaCache,
+	type BlockType,
+	type CreateBlockTypeInput,
+	type UpdateBlockTypeInput,
+} from "../../schema/index.js";
+import type { ApiResult } from "../types.js";
+
+export interface BlockTypeListResponse {
+	items: BlockType[];
+}
+
+export interface BlockTypeResponse {
+	item: BlockType;
+}
+
+function schemaError(error: SchemaError) {
+	return {
+		success: false as const,
+		error: { code: error.code, message: error.message, details: error.details },
+	};
+}
+
+async function invalidateConsumers(db: Kysely<Database>, slug: string): Promise<void> {
+	const collections = await new BlockTypeRegistry(db).listAffectedCollections(slug);
+	for (const collection of collections) {
+		invalidateCollectionCache(collection);
+		invalidateSchemaCache(collection);
+	}
+}
+
+export async function handleBlockTypeList(
+	db: Kysely<Database>,
+): Promise<ApiResult<BlockTypeListResponse>> {
+	try {
+		return { success: true, data: { items: await new BlockTypeRegistry(db).listBlockTypes() } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SCHEMA_LIST_ERROR", message: "Failed to list block types" },
+		};
+	}
+}
+
+export async function handleBlockTypeGet(
+	db: Kysely<Database>,
+	slug: string,
+): Promise<ApiResult<BlockTypeResponse>> {
+	try {
+		const item = await new BlockTypeRegistry(db).getBlockType(slug);
+		if (!item) {
+			return {
+				success: false,
+				error: { code: "BLOCK_TYPE_NOT_FOUND", message: `Block type '${slug}' not found` },
+			};
+		}
+		return { success: true, data: { item } };
+	} catch (error) {
+		if (error instanceof SchemaError) return schemaError(error);
+		return {
+			success: false,
+			error: { code: "SCHEMA_GET_ERROR", message: "Failed to get block type" },
+		};
+	}
+}
+
+export async function handleBlockTypeCreate(
+	db: Kysely<Database>,
+	input: CreateBlockTypeInput,
+): Promise<ApiResult<BlockTypeResponse>> {
+	try {
+		const item = await new BlockTypeRegistry(db).createBlockType(input);
+		await invalidateConsumers(db, input.slug);
+		return { success: true, data: { item } };
+	} catch (error) {
+		if (error instanceof SchemaError) return schemaError(error);
+		return {
+			success: false,
+			error: { code: "SCHEMA_CREATE_ERROR", message: "Failed to create block type" },
+		};
+	}
+}
+
+export async function handleBlockTypeUpdate(
+	db: Kysely<Database>,
+	slug: string,
+	input: UpdateBlockTypeInput,
+): Promise<ApiResult<BlockTypeResponse>> {
+	try {
+		const item = await new BlockTypeRegistry(db).updateBlockType(slug, input);
+		await invalidateConsumers(db, slug);
+		return { success: true, data: { item } };
+	} catch (error) {
+		if (error instanceof SchemaError) return schemaError(error);
+		return {
+			success: false,
+			error: { code: "SCHEMA_UPDATE_ERROR", message: "Failed to update block type" },
+		};
+	}
+}
+
+export async function handleBlockTypeVersionActivate(
+	db: Kysely<Database>,
+	slug: string,
+	version: number,
+	expectedFingerprint: string,
+): Promise<ApiResult<BlockTypeResponse>> {
+	try {
+		const item = await new BlockTypeRegistry(db).activateVersion(
+			slug,
+			version,
+			expectedFingerprint,
+		);
+		await invalidateConsumers(db, slug);
+		return { success: true, data: { item } };
+	} catch (error) {
+		if (error instanceof SchemaError) return schemaError(error);
+		return {
+			success: false,
+			error: { code: "SCHEMA_UPDATE_ERROR", message: "Failed to activate block type version" },
+		};
+	}
+}

package/src/api/handlers/bulk-tag.ts

@@ -0,0 +1,309 @@
+import type { Kysely } from "kysely";
+import type { z } from "zod";
+
+import { taxonomyTag } from "../../cache/chrome-tags.js";
+import { ContentRepository } from "../../database/repositories/content.js";
+import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
+import type { ContentItem } from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import { getI18nConfig } from "../../i18n/config.js";
+import { localizePath, resolveLocalizedContentRoutePath } from "../../i18n/resolve.js";
+import { SchemaRegistry } from "../../schema/registry.js";
+import { compileUrlPattern } from "../../schema/url-pattern.js";
+import { invalidateTermCache } from "../../taxonomies/index.js";
+import { chunks } from "../../utils/chunks.js";
+import type { bulkTagBody } from "../schemas/taxonomies.js";
+import type { ApiResult } from "../types.js";
+
+type BulkTagInput = z.infer<typeof bulkTagBody>;
+type BulkTagSource = BulkTagInput["items"][number];
+type Collection = Awaited<ReturnType<SchemaRegistry["listCollections"]>>[number];
+type UrlCandidate = {
+	collection: Collection;
+	locale: string;
+	identifier: string;
+	by: "slug" | "id";
+};
+const TRAILING_SLASHES = /\/+$/;
+
+export interface BulkTagResult {
+	input: BulkTagSource;
+	status: "ready" | "added" | "skipped" | "unmatched" | "failed";
+	reason?: "not_found" | "ambiguous" | "save_failed";
+	entry?: { collection: string; id: string; title: string; locale: string };
+}
+
+function titleFor(item: ContentItem, collection: Collection): string {
+	const preferred = collection.titleField && item.data[collection.titleField];
+	const title = item.data.title;
+	const name = item.data.name;
+	return (
+		(typeof preferred === "string" && preferred) ||
+		(typeof title === "string" && title) ||
+		(typeof name === "string" && name) ||
+		item.slug ||
+		item.id
+	);
+}
+
+function normalizedPath(path: string): string {
+	return path.replace(TRAILING_SLASHES, "") || "/";
+}
+
+async function urlCandidates(
+	url: string,
+	origin: string,
+	collections: Collection[],
+): Promise<{ path: string; candidates: UrlCandidate[] } | null> {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	if (parsed.origin !== origin || !["https:", "http:"].includes(parsed.protocol)) return null;
+
+	const locales = getI18nConfig()?.locales ?? ["en"];
+	const candidates: UrlCandidate[] = [];
+	for (const collection of collections) {
+		const pattern = collection.urlPattern ?? `/${collection.slug}/{slug}`;
+		for (const locale of locales) {
+			const prefix = await localizePath("/", locale);
+			if (!prefix) continue;
+			const { regex, paramNames } = compileUrlPattern(`${prefix === "/" ? "" : prefix}${pattern}`);
+			const segments = regex.exec(parsed.pathname);
+			if (!segments) continue;
+			const slugIndex = paramNames.indexOf("slug");
+			const idIndex = paramNames.indexOf("id");
+			if (slugIndex < 0 && idIndex < 0) continue;
+			let identifier: string;
+			try {
+				identifier = decodeURIComponent(segments[1 + (slugIndex >= 0 ? slugIndex : idIndex)] ?? "");
+			} catch {
+				continue;
+			}
+			candidates.push({ collection, locale, identifier, by: slugIndex >= 0 ? "slug" : "id" });
+		}
+	}
+	return { path: parsed.pathname, candidates };
+}
+
+export async function handleBulkTag(
+	db: Kysely<Database>,
+	origin: string,
+	input: BulkTagInput,
+	invalidate?: (tags: string[]) => Promise<void>,
+): Promise<ApiResult<{ results: BulkTagResult[]; cacheRefreshFailed: boolean }>> {
+	try {
+		const taxonomy = new TaxonomyRepository(db);
+		const term = await taxonomy.findById(input.termId);
+		if (!term || term.name !== "tag") {
+			return { success: false, error: { code: "NOT_FOUND", message: "Tag not found" } };
+		}
+		const definitions = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.select("collections")
+			.where("name", "=", "tag")
+			.execute();
+		const allowed = new Set(
+			definitions.flatMap((def) => {
+				const parsed: unknown = def.collections ? JSON.parse(def.collections) : [];
+				return Array.isArray(parsed)
+					? parsed.filter((value): value is string => typeof value === "string")
+					: [];
+			}),
+		);
+		const collections = (await new SchemaRegistry(db).listCollections()).filter((collection) =>
+			allowed.has(collection.slug),
+		);
+		const byCollection = new Map(collections.map((collection) => [collection.slug, collection]));
+		const content = new ContentRepository(db);
+		const idNeeds = new Map<string, Set<string>>();
+		const slugNeeds = new Map<string, { collection: string; locale: string; slugs: Set<string> }>();
+		const parsedUrls = new Map<number, Awaited<ReturnType<typeof urlCandidates>>>();
+		for (const [index, source] of input.items.entries()) {
+			if ("url" in source) {
+				const parsed = await urlCandidates(source.url, origin, collections);
+				parsedUrls.set(index, parsed);
+				for (const candidate of parsed?.candidates ?? []) {
+					if (candidate.by === "id") {
+						const ids = idNeeds.get(candidate.collection.slug) ?? new Set<string>();
+						ids.add(candidate.identifier);
+						idNeeds.set(candidate.collection.slug, ids);
+					} else {
+						const key = `${candidate.collection.slug}:${candidate.locale}`;
+						const group = slugNeeds.get(key) ?? {
+							collection: candidate.collection.slug,
+							locale: candidate.locale,
+							slugs: new Set<string>(),
+						};
+						group.slugs.add(candidate.identifier);
+						slugNeeds.set(key, group);
+					}
+				}
+			} else if (byCollection.has(source.collection)) {
+				const ids = idNeeds.get(source.collection) ?? new Set<string>();
+				ids.add(source.id);
+				idNeeds.set(source.collection, ids);
+			}
+		}
+		const byId = new Map<string, Map<string, ContentItem>>();
+		for (const [collection, ids] of idNeeds) {
+			byId.set(collection, await content.findManyByIds(collection, [...ids]));
+		}
+		const bySlug = new Map<string, Map<string, ContentItem>>();
+		for (const [key, group] of slugNeeds) {
+			bySlug.set(
+				key,
+				await content.findManyBySlugsInLocale(group.collection, [...group.slugs], group.locale),
+			);
+		}
+		const prepared: Array<{
+			source: BulkTagSource;
+			resolved: { item: ContentItem; collection: Collection } | "not_found" | "ambiguous";
+		}> = [];
+		const groups = new Map<string, Set<string>>();
+		for (const [index, source] of input.items.entries()) {
+			let resolved: (typeof prepared)[number]["resolved"] = "not_found";
+			if ("url" in source) {
+				const parsed = parsedUrls.get(index);
+				const matches = new Map<string, { item: ContentItem; collection: Collection }>();
+				for (const candidate of parsed?.candidates ?? []) {
+					const item =
+						candidate.by === "id"
+							? byId.get(candidate.collection.slug)?.get(candidate.identifier)
+							: bySlug
+									.get(`${candidate.collection.slug}:${candidate.locale}`)
+									?.get(candidate.identifier);
+					if (!item || item.locale !== candidate.locale || item.status !== "published") continue;
+					const canonical = await resolveLocalizedContentRoutePath({
+						pattern: candidate.collection.urlPattern ?? `/${candidate.collection.slug}/{slug}`,
+						collection: candidate.collection.slug,
+						slug: item.slug ?? "",
+						id: item.id,
+						date: item.publishedAt,
+						locale: candidate.locale,
+					});
+					if (canonical && parsed && normalizedPath(canonical) === normalizedPath(parsed.path)) {
+						matches.set(`${candidate.collection.slug}:${item.id}`, {
+							item,
+							collection: candidate.collection,
+						});
+					}
+				}
+				resolved = matches.size > 1 ? "ambiguous" : (matches.values().next().value ?? "not_found");
+			} else {
+				const collection = byCollection.get(source.collection);
+				const item = byId.get(source.collection)?.get(source.id);
+				if (item && collection) resolved = { item, collection };
+			}
+			prepared.push({ source, resolved });
+			if (typeof resolved !== "string") {
+				const collectionGroups = groups.get(resolved.collection.slug) ?? new Set<string>();
+				collectionGroups.add(resolved.item.translationGroup ?? resolved.item.id);
+				groups.set(resolved.collection.slug, collectionGroups);
+			}
+		}
+		const termGroup = term.translationGroup ?? term.id;
+		const assigned = new Set<string>();
+		if (!input.apply) {
+			for (const [collection, entryGroups] of groups) {
+				for (const batch of chunks([...entryGroups], 50)) {
+					const rows = await db
+						.selectFrom("content_taxonomies")
+						.select("entry_id")
+						.where("collection", "=", collection)
+						.where("taxonomy_id", "=", termGroup)
+						.where("entry_id", "in", batch)
+						.execute();
+					for (const row of rows) assigned.add(`${collection}:${row.entry_id}`);
+				}
+			}
+		}
+		const siblingIds = new Map<string, Map<string, string[]>>();
+		if (input.apply && invalidate) {
+			for (const [collection, entryGroups] of groups) {
+				siblingIds.set(
+					collection,
+					await content.findTranslationIdsForGroups(collection, [...entryGroups]),
+				);
+			}
+		}
+		const seen = new Set<string>();
+		const purge = new Set<string>([taxonomyTag("tag")]);
+		const results: BulkTagResult[] = [];
+		let changed = false;
+		for (const { source, resolved } of prepared) {
+			if (typeof resolved === "string") {
+				if (
+					input.apply &&
+					input.refreshOnly &&
+					invalidate &&
+					"id" in source &&
+					byCollection.has(source.collection)
+				) {
+					purge.add(source.collection);
+					purge.add(source.id);
+				}
+				results.push({ input: source, status: "unmatched", reason: resolved });
+				continue;
+			}
+			const { item, collection } = resolved;
+			const entry = {
+				collection: collection.slug,
+				id: item.id,
+				title: titleFor(item, collection),
+				locale: item.locale ?? "en",
+			};
+			const group = item.translationGroup ?? item.id;
+			const key = `${collection.slug}:${group}`;
+			if (seen.has(key)) {
+				results.push({ input: source, status: "skipped", entry });
+				continue;
+			}
+			try {
+				const inserted =
+					input.apply && !input.refreshOnly
+						? await taxonomy.attachGroupsToEntry(collection.slug, item.id, [termGroup])
+						: 0;
+				if (inserted) changed = true;
+				seen.add(key);
+				if (input.apply && invalidate) {
+					purge.add(collection.slug);
+					for (const id of siblingIds.get(collection.slug)?.get(group) ?? [item.id]) purge.add(id);
+				}
+				results.push({
+					input: source,
+					status: input.apply
+						? inserted
+							? "added"
+							: "skipped"
+						: assigned.has(key)
+							? "skipped"
+							: "ready",
+					entry,
+				});
+			} catch (error) {
+				console.error("[bulk-tag] Failed to tag entry:", error);
+				results.push({ input: source, status: "failed", reason: "save_failed", entry });
+			}
+		}
+		if (changed) invalidateTermCache();
+		let cacheRefreshFailed = false;
+		if (input.apply && invalidate && (purge.size > 1 || input.refreshOnly)) {
+			try {
+				for (const batch of chunks([...purge], 100)) await invalidate(batch);
+			} catch (error) {
+				console.error("[bulk-tag] Failed to invalidate cache:", error);
+				cacheRefreshFailed = true;
+			}
+		}
+		return { success: true, data: { results, cacheRefreshFailed } };
+	} catch (error) {
+		console.error("[bulk-tag] Failed:", error);
+		return {
+			success: false,
+			error: { code: "BULK_TAG_ERROR", message: "Failed to bulk tag posts" },
+		};
+	}
+}

package/src/api/handlers/comments.ts

@@ -285,34 +285,6 @@ export async function handleCommentBulk(
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Anti-spam: Rate limiting
-// ---------------------------------------------------------------------------
-
-/**
- * Check if an IP has exceeded the comment rate limit.
- * Uses ip_hash in the comments table — no separate counter storage.
- */
-export async function checkRateLimit(
-	db: Kysely<Database>,
-	ipHash: string,
-	maxPerWindow: number = 5,
-	windowMinutes: number = 10,
-): Promise<boolean> {
-	const cutoff = new Date(Date.now() - windowMinutes * 60 * 1000).toISOString();
-
-	// Count recent comments from this IP
-	const result = await db
-		.selectFrom("_emdash_comments")
-		.select((eb) => eb.fn.count("id").as("count"))
-		.where("ip_hash", "=", ipHash)
-		.where("created_at", ">", cutoff)
-		.executeTakeFirst();
-
-	const count = Number(result?.count ?? 0);
-	return count >= maxPerWindow;
-}
-
 /**
  * Hash an IP address for storage (never store cleartext IPs).
  *

package/src/api/handlers/index.ts

@@ -86,6 +86,7 @@ export {
 	type MediaUsageProgress,
 	type MediaUsageProgressAdvanceResponse,
 	type MediaUsageRepairResponse,
+	type MediaUsageSiteSettingDetail,
 	type MediaUsageSourceDetail,
 	type MediaUsageSummary,
 } from "./media-usage.js";
@@ -129,6 +130,15 @@ export {
 	type OrphanedTable,
 	type OrphanedTableListResponse,
 } from "./schema.js";
+export {
+	handleBlockTypeList,
+	handleBlockTypeGet,
+	handleBlockTypeCreate,
+	handleBlockTypeUpdate,
+	handleBlockTypeVersionActivate,
+	type BlockTypeListResponse,
+	type BlockTypeResponse,
+} from "./block-types.js";
 
 // SEO handlers
 export {

package/src/api/handlers/manifest.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 
 import type { Database } from "../../database/types.js";
+import { expandCollectionBlockFields } from "../../schema/block-values.js";
 import { SchemaRegistry } from "../../schema/registry.js";
 import { MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
 import type { Field, FieldType } from "../../schema/types.js";
@@ -51,6 +52,7 @@ const FIELD_TYPE_TO_KIND: Record<FieldType, string> = {
 	reference: "reference",
 	json: "json",
 	repeater: "repeater",
+	blocks: "blocks",
 };
 
 // Collection definition shape for manifest generation
@@ -130,7 +132,10 @@ export async function buildManifestCollections(
 
 	try {
 		const registry = new SchemaRegistry(db);
-		const dbCollections = await registry.listCollectionsWithFields();
+		const storedCollections = await registry.listCollectionsWithFields();
+		const dbCollections = await Promise.all(
+			storedCollections.map((collection) => expandCollectionBlockFields(db, collection)),
+		);
 		for (const collection of dbCollections) {
 			if (manifestCollections[collection.slug]) continue;
 
@@ -277,6 +282,8 @@ function dbFieldDescriptor(field: Field): ManifestFieldDescriptor {
 		id: field.id,
 	};
 	if (field.unsupportedType) entry.unsupportedType = field.unsupportedType;
+	if (field.blockTypes) entry.blockTypes = field.blockTypes;
+	if (field.blockTypeFingerprint) entry.blockTypeFingerprint = field.blockTypeFingerprint;
 
 	if (field.widget) entry.widget = field.widget;
 	if (field.options) entry.options = field.options;