emdash 0.41.0 → 0.42.0

package/src/schema/project-env-types.ts

@@ -0,0 +1,41 @@
+/**
+ * Offline `emdash-env.d.ts` generation for a project directory.
+ *
+ * Reproduces what a fresh `astro dev` run writes: migrate an empty database,
+ * apply the project's seed, and generate types from the resulting schema.
+ * Used by `scripts/env-types.mjs` to keep committed files in the repo current.
+ */
+
+import { generateSeedModule } from "../astro/integration/virtual-modules.js";
+import { createDatabase } from "../database/connection.js";
+import { runMigrations } from "../database/migrations/runner.js";
+import { applySeed } from "../seed/apply.js";
+import type { SeedFile } from "../seed/types.js";
+import { validateSeed } from "../seed/validate.js";
+import { generateEnvTypes } from "./env-types.js";
+
+async function loadProjectSeed(projectRoot: string): Promise<SeedFile> {
+	const source = generateSeedModule(projectRoot);
+	const mod: { seed: SeedFile } = await import(
+		/* @vite-ignore */ `data:text/javascript,${encodeURIComponent(source)}`
+	);
+	return mod.seed;
+}
+
+export async function generateProjectEnvTypes(projectRoot: string): Promise<string> {
+	const seed = await loadProjectSeed(projectRoot);
+	const { errors } = validateSeed(seed);
+	if (errors.length > 0) {
+		throw new Error(`Invalid seed in ${projectRoot}:\n  ${errors.join("\n  ")}`);
+	}
+
+	const db = createDatabase({ url: ":memory:" });
+	try {
+		await runMigrations(db);
+		await applySeed(db, seed, { includeContent: false, onConflict: "skip" });
+		const { types } = await generateEnvTypes(db);
+		return types;
+	} finally {
+		await db.destroy();
+	}
+}

package/src/schema/registry.ts

@@ -22,6 +22,7 @@ import type { CollectionTable, Database, FieldTable } from "../database/types.js
 import { validateIdentifier } from "../database/validate.js";
 import {
 	canResumeMediaUsageCollectionCapture,
+	findResumableMediaUsageCollectionCaptureId,
 	finalizeMediaUsageCollectionCapture,
 	installPreparedMediaUsageCollectionCapture,
 	markMediaUsageCollectionCaptureReady,
@@ -71,6 +72,7 @@ import {
 	RESERVED_COLLECTION_SLUGS,
 	MAX_BLOCKS_ITEMS,
 } from "./types.js";
+import { compileUrlPattern } from "./url-pattern.js";
 
 // Regex patterns for schema registry
 const SLUG_VALIDATION_PATTERN = /^[a-z][a-z0-9_]*$/;
@@ -212,6 +214,7 @@ function parseCollectionAdmin(raw: string | null | undefined): CollectionAdminCo
 		listColumns: Array.isArray(listColumns)
 			? listColumns.filter((value): value is string => typeof value === "string")
 			: undefined,
+		quickCreate: typeof parsed.quickCreate === "boolean" ? parsed.quickCreate : undefined,
 	};
 }
 
@@ -329,7 +332,7 @@ export class SchemaRegistry {
 	 * Notify the dev typegen hook that the schema has changed.
 	 */
 	private notifyTypegen(): void {
-		refreshDevTypes(this.db);
+		refreshDevTypes();
 	}
 
 	// ============================================
@@ -492,6 +495,7 @@ export class SchemaRegistry {
 	async createCollection(input: CreateCollectionInput): Promise<Collection> {
 		// Validate slug
 		this.validateSlug(input.slug, "collection");
+		this.validateUrlPattern(input.urlPattern);
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
 			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		}
@@ -515,6 +519,19 @@ export class SchemaRegistry {
 		}
 
 		const proposedId = existing?.id ?? ulid();
+		const tableName = this.getTableName(input.slug);
+		if (
+			!existing &&
+			(await tableExists(this.db, tableName)) &&
+			!(await findResumableMediaUsageCollectionCaptureId(this.db, {
+				collectionSlug: input.slug,
+			}))
+		) {
+			throw new SchemaError(
+				`Collection table "${tableName}" exists but is not registered`,
+				"COLLECTION_TABLE_ORPHANED",
+			);
+		}
 
 		// Default `supports` to drafts + revisions when the caller didn't
 		// specify it. Explicit empty array (`[]`) is preserved as an opt-out
@@ -606,6 +623,7 @@ export class SchemaRegistry {
 		fields: readonly CreateFieldInput[],
 	): Promise<void> {
 		this.validateSlug(input.slug, "collection");
+		this.validateUrlPattern(input.urlPattern);
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
 			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		}
@@ -1049,6 +1067,7 @@ export class SchemaRegistry {
 			if (!existingRow) {
 				throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
 			}
+			if (input.urlPattern !== existingRow.url_pattern) this.validateUrlPattern(input.urlPattern);
 			const existing = this.mapCollectionRow(existingRow);
 			await this.validateTitleDateFields(
 				existing.id,
@@ -1064,7 +1083,7 @@ export class SchemaRegistry {
 			if (input.label !== undefined) updates.label = input.label;
 			if (input.labelSingular !== undefined) updates.label_singular = input.labelSingular;
 			if (input.description !== undefined) updates.description = input.description;
-			if (input.icon !== undefined) updates.icon = input.icon;
+			if (input.icon !== undefined) updates.icon = input.icon || null;
 			if (input.admin !== undefined) updates.admin_config = JSON.stringify(input.admin);
 			if (input.supports !== undefined) updates.supports = JSON.stringify(input.supports);
 			if (input.urlPattern !== undefined) updates.url_pattern = input.urlPattern;
@@ -2307,6 +2326,18 @@ export class SchemaRegistry {
 		}
 	}
 
+	private validateUrlPattern(urlPattern: string | null | undefined): void {
+		if (!urlPattern) return;
+		try {
+			compileUrlPattern(urlPattern);
+		} catch (error) {
+			throw new SchemaError(
+				error instanceof Error ? error.message : "Invalid URL pattern",
+				"INVALID_URL_PATTERN",
+			);
+		}
+	}
+
 	/**
 	 * Format a default value for SQL.
 	 *

package/src/schema/types.ts

@@ -247,10 +247,15 @@ export const MAX_COLLECTION_LIST_COLUMNS = 4;
 /** Longest admin sidebar folder label a collection may declare. */
 export const MAX_COLLECTION_GROUP_LENGTH = 100;
 
+/** Longest Phosphor icon name a collection may declare. */
+export const MAX_COLLECTION_ICON_LENGTH = 64;
+
 /** Collection-level admin presentation options. */
 export interface CollectionAdminConfig {
 	/** Custom field slugs to show in the content list. */
 	listColumns?: string[];
+	/** Show a "new entry" quick action on the dashboard. Defaults to true. */
+	quickCreate?: boolean;
 }
 
 /**

package/src/schema/url-pattern.ts

@@ -6,6 +6,13 @@ function escapeRegex(literal: string): string {
 	return literal.replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
 }
 
+/**
+ * Compile a collection URL pattern to an anchored regex.
+ *
+ * Each placeholder must sit in its own path segment. Two `[^/]+` groups in one
+ * segment can split the segment many ways, so a crafted request path makes the
+ * regex backtrack polynomially (exponentially in the placeholder count).
+ */
 export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames: string[] } {
 	const paramNames: string[] = [];
 	let regexSource = "";
@@ -15,6 +22,9 @@ export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames:
 		const matchIndex = match.index;
 		const literal = pattern.slice(previousIndex, matchIndex);
 		if (INVALID_LITERAL_PATTERN.test(literal)) throw new Error("Invalid URL pattern placeholder");
+		if (paramNames.length > 0 && !literal.includes("/")) {
+			throw new Error("URL patterns allow only one placeholder per path segment");
+		}
 		regexSource += escapeRegex(literal);
 
 		const name = match[1];

package/src/schema/zod-generator.ts

@@ -1,6 +1,7 @@
 import { z, type ZodType } from "zod";
 
 import { hashString } from "../utils/hash.js";
+import { isSafeUrlFieldValue } from "../utils/url.js";
 import type { BlockFieldDefinition } from "./block-types.js";
 import {
 	isStoragelessField,
@@ -80,7 +81,16 @@ export function generateBlockFieldSchema(field: BlockFieldDefinition): ZodType {
 function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodType {
 	switch (type) {
 		case "url":
-			return z.string().check(z.url());
+			// The admin localizes `invalid_format` issues with `format: "url"`.
+			return z.string().check((ctx) => {
+				if (isSafeUrlFieldValue(ctx.value)) return;
+				ctx.issues.push({
+					code: "invalid_format",
+					format: "url",
+					input: ctx.value,
+					message: "URL must use http, https, mailto, or tel, or be a site-relative path",
+				});
+			});
 
 		case "string":
 		case "text":

package/src/seed/apply.ts

@@ -813,11 +813,39 @@ async function applySeedWrites(
 					entries,
 					defaultLocale,
 				);
+				const entriesWithoutLiveMatch = entries.filter((entry) => {
+					const { slug, locale } = seedEntryIdentity(entry, defaultLocale);
+					return !existingEntries.has(seedEntryKey(entry, slug, locale));
+				});
+				const trashedEntries = await findExistingSeedEntries(
+					contentRepo,
+					collectionSlug,
+					entriesWithoutLiveMatch,
+					defaultLocale,
+					true,
+				);
 				for (const entry of entries) {
 					const { slug: entrySlug, locale: entryLocale } = seedEntryIdentity(entry, defaultLocale);
 					const entryKey = seedEntryKey(entry, entrySlug, entryLocale);
 					const existing = existingEntries.get(entryKey);
 
+					if (!existing) {
+						const trashed = trashedEntries.get(entryKey);
+						if (trashed) {
+							if (onConflict === "error") {
+								throw new Error(
+									`Conflict: content "${entrySlug ?? entry.id}" in "${collectionSlug}" already exists (in trash)`,
+								);
+							}
+							console.warn(
+								`content.${collectionSlug}: "${entrySlug ?? entry.id}" (${entryLocale}) exists in the trash — skipping`,
+							);
+							result.content.skipped++;
+							progress.done++;
+							continue;
+						}
+					}
+
 					if (existing) {
 						if (onConflict === "error") {
 							throw new Error(
@@ -1563,6 +1591,7 @@ async function findExistingSeedEntries(
 	collectionSlug: string,
 	entries: SeedContentEntry[],
 	defaultLocale: string,
+	includeTrashed = false,
 ): Promise<Map<string, ContentItem>> {
 	const identities = entries.map((entry) => ({
 		entry,
@@ -1578,11 +1607,15 @@ async function findExistingSeedEntries(
 
 	const bySlug = new Map<string, Map<string, ContentItem>>();
 	for (const [locale, slugs] of slugsByLocale) {
-		bySlug.set(locale, await repo.findManyBySlugsInLocale(collectionSlug, slugs, locale));
+		bySlug.set(
+			locale,
+			await repo.findManyBySlugsInLocale(collectionSlug, slugs, locale, { includeTrashed }),
+		);
 	}
 	const byId = await repo.findManyByIds(
 		collectionSlug,
 		identities.filter(({ slug }) => slug === null).map(({ entry }) => entry.id),
+		{ includeTrashed },
 	);
 
 	const existing = new Map<string, ContentItem>();

package/src/seed/ownership.ts

@@ -0,0 +1,15 @@
+import type { Kysely } from "kysely";
+
+import { OptionsRepository } from "../database/repositories/options.js";
+import type { Database } from "../database/types.js";
+import type { SeedFile } from "./types.js";
+
+export const AUTO_SEED_COMPLETE_OPTION = "emdash:seed_complete";
+
+export async function claimExplicitSeedOwnership(
+	db: Kysely<Database>,
+	seed: SeedFile,
+): Promise<void> {
+	if (!seed.collections?.length) return;
+	await new OptionsRepository(db).set(AUTO_SEED_COMPLETE_OPTION, true);
+}

package/src/seed/validate.ts

@@ -5,13 +5,17 @@
  */
 
 import { getI18nConfig, resolveConfiguredLocale } from "../i18n/config.js";
+import { isSiteRelativeDestination } from "../redirects/destination.js";
+import { isPattern, validateDestinationParams, validatePattern } from "../redirects/patterns.js";
 import { validateBlockFields } from "../schema/block-type-contract.js";
 import {
 	FIELD_TYPES,
 	isIndexableFieldType,
 	MAX_COLLECTION_GROUP_LENGTH,
+	MAX_COLLECTION_ICON_LENGTH,
 	MAX_COLLECTION_LIST_COLUMNS,
 } from "../schema/types.js";
+import { compileUrlPattern } from "../schema/url-pattern.js";
 import type { SeedFile, SeedMenuItem, SeedTaxonomy, ValidationResult } from "./types.js";
 
 const COLLECTION_FIELD_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
@@ -199,6 +203,19 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (collection.routable !== undefined && typeof collection.routable !== "boolean") {
 					errors.push(`${prefix}.routable: must be a boolean`);
 				}
+				if (collection.urlPattern !== undefined) {
+					if (typeof collection.urlPattern !== "string") {
+						errors.push(`${prefix}.urlPattern: must be a string`);
+					} else if (collection.urlPattern) {
+						try {
+							compileUrlPattern(collection.urlPattern);
+						} catch (error) {
+							errors.push(
+								`${prefix}.urlPattern: ${error instanceof Error ? error.message : "invalid URL pattern"}`,
+							);
+						}
+					}
+				}
 				if (collection.group !== undefined) {
 					if (typeof collection.group !== "string") {
 						errors.push(`${prefix}.group: must be a string`);
@@ -208,6 +225,13 @@ export function validateSeed(data: unknown): ValidationResult {
 						);
 					}
 				}
+				if (collection.icon !== undefined) {
+					if (typeof collection.icon !== "string") {
+						errors.push(`${prefix}.icon: must be a string`);
+					} else if (collection.icon.trim().length > MAX_COLLECTION_ICON_LENGTH) {
+						errors.push(`${prefix}.icon: must be at most ${MAX_COLLECTION_ICON_LENGTH} characters`);
+					}
+				}
 
 				const declaredFieldSlugs = new Set(
 					Array.isArray(collection.fields)
@@ -241,6 +265,13 @@ export function validateSeed(data: unknown): ValidationResult {
 							}
 						}
 					}
+					if (
+						isRecord(collection.admin) &&
+						collection.admin.quickCreate !== undefined &&
+						typeof collection.admin.quickCreate !== "boolean"
+					) {
+						errors.push(`${prefix}.admin.quickCreate: must be a boolean`);
+					}
 				}
 
 				// Validate fields
@@ -600,12 +631,24 @@ export function validateSeed(data: unknown): ValidationResult {
 
 				if (!destination) {
 					errors.push(`${prefix}: destination is required`);
-				} else if (!isValidRedirectPath(destination)) {
+				} else if (!isValidRedirectPath(destination) || !isSiteRelativeDestination(destination)) {
 					errors.push(
-						`${prefix}.destination: must be a path starting with / (no protocol-relative URLs, path traversal, or newlines)`,
+						`${prefix}.destination: must be a path starting with / (no protocol-relative URLs, backslash prefixes, path traversal, or control characters)`,
 					);
 				}
 
+				if (source && isPattern(source)) {
+					const patternError = validatePattern(source);
+					if (patternError) {
+						errors.push(`${prefix}.source: invalid pattern: ${patternError}`);
+					} else if (destination) {
+						const destinationError = validateDestinationParams(source, destination);
+						if (destinationError) {
+							errors.push(`${prefix}.destination: ${destinationError}`);
+						}
+					}
+				}
+
 				if (redirect.type !== undefined) {
 					if (typeof redirect.type !== "number" || !REDIRECT_TYPES.has(redirect.type)) {
 						errors.push(`${prefix}.type: must be 301, 302, 307, or 308`);

package/src/transfer/analyze/validate.ts

@@ -71,6 +71,7 @@ import {
 import { blockerForError, decodeRecordLine, readVerifiedChunk } from "./read.js";
 import { findUniqueCollisions, UNIQUE_CHECK_QUERIES, uniqueKeysOf } from "./unique-keys.js";
 import {
+	checkContentUrlFields,
 	checkEntryFields,
 	checkRecordNumbers,
 	recordLocale,
@@ -78,7 +79,9 @@ import {
 	scanRecordValues,
 	OTHER_PROVIDER,
 	type FieldInfo,
+	type BlockTypeInfo,
 	type TargetDialect,
+	type UrlValueField,
 	type ValueIssue,
 } from "./values.js";
 import { writeRuleIssues, type BylineFieldFacts } from "./write-rules.js";
@@ -86,6 +89,11 @@ import { writeRuleIssues, type BylineFieldFacts } from "./write-rules.js";
 const count = z.number().int().nonnegative();
 const kindSchema = z.enum(RECORD_KINDS);
 const kindCounts = z.array(z.tuple([kindSchema, count]));
+const urlValueFieldSchema = z.strictObject({
+	slug: z.string(),
+	type: z.enum(["url", "repeater"]),
+	urlSubFields: z.array(z.string()).optional(),
+});
 
 export const VALIDATION_PHASES = ["structure", "records", "references", "done"] as const;
 export type ValidationPhase = (typeof VALIDATION_PHASES)[number];
@@ -124,11 +132,22 @@ export const validationStateSchema = z.strictObject({
 						columnType: z.enum(["TEXT", "REAL", "INTEGER", "JSON"]),
 						required: z.boolean(),
 						storageless: z.boolean().optional(),
+						type: z.enum(["url", "repeater", "blocks"]).optional(),
+						urlSubFields: z.array(z.string()).optional(),
 					}),
 				]),
 			),
 		]),
 	),
+	blockTypes: z
+		.array(
+			z.tuple([
+				z.string(),
+				z.strictObject({ id: z.string(), currentVersion: z.number().int().positive() }),
+			]),
+		)
+		.default([]),
+	blockVersions: z.array(z.tuple([z.string(), z.array(urlValueFieldSchema)])).default([]),
 	principals: z.array(
 		z.strictObject({ id: z.string(), displayName: z.string(), email: z.string().optional() }),
 	),
@@ -206,6 +225,8 @@ interface WorkingState {
 	unreadableKinds: Set<RecordKind>;
 	collections: Map<string, { id: string; searchEnabled: boolean }>;
 	fields: Map<string, Map<string, FieldInfo>>;
+	blockTypes: Map<string, BlockTypeInfo>;
+	blockVersions: Map<string, UrlValueField[]>;
 	principals: PrincipalSummary[];
 	principalReferences: Map<string, number>;
 	principalBylineLocales: Map<string, Set<string>>;
@@ -240,6 +261,8 @@ function initialWorkingState(): WorkingState {
 		unreadableKinds: new Set(),
 		collections: new Map(),
 		fields: new Map(),
+		blockTypes: new Map(),
+		blockVersions: new Map(),
 		principals: [],
 		principalReferences: new Map(),
 		principalBylineLocales: new Map(),
@@ -281,6 +304,8 @@ function serialize(state: WorkingState): ValidationState {
 		unreadableKinds: [...state.unreadableKinds],
 		collections: sortedEntries(state.collections),
 		fields: sortedEntries(state.fields).map(([slug, fields]) => [slug, sortedEntries(fields)]),
+		blockTypes: sortedEntries(state.blockTypes),
+		blockVersions: sortedEntries(state.blockVersions),
 		principals: state.principals,
 		principalReferences: sortedEntries(state.principalReferences),
 		principalBylineLocales: sortedEntries(state.principalBylineLocales).map(([id, locales]) => [
@@ -317,6 +342,8 @@ function deserialize(state: ValidationState): WorkingState {
 		unreadableKinds: new Set(state.unreadableKinds),
 		collections: new Map(state.collections),
 		fields: new Map(state.fields.map(([slug, fields]) => [slug, new Map(fields)])),
+		blockTypes: new Map(state.blockTypes),
+		blockVersions: new Map(state.blockVersions),
 		principals: state.principals,
 		principalReferences: new Map(state.principalReferences),
 		principalBylineLocales: new Map(
@@ -892,10 +919,43 @@ function selectOptions(validation: unknown): string[] {
 		: [];
 }
 
+function repeaterUrlSubFields(validation: unknown): string[] {
+	if (typeof validation !== "object" || validation === null || Array.isArray(validation)) return [];
+	const subFields: unknown = Reflect.get(validation, "subFields");
+	if (!Array.isArray(subFields)) return [];
+	return subFields.flatMap((field) => {
+		if (typeof field !== "object" || field === null || Array.isArray(field)) return [];
+		const slug: unknown = Reflect.get(field, "slug");
+		return Reflect.get(field, "type") === "url" && typeof slug === "string" ? [slug] : [];
+	});
+}
+
+function urlValueFields(fields: readonly unknown[]): UrlValueField[] {
+	const result: UrlValueField[] = [];
+	for (const field of fields) {
+		if (typeof field !== "object" || field === null || Array.isArray(field)) continue;
+		const slug: unknown = Reflect.get(field, "slug");
+		const type: unknown = Reflect.get(field, "type");
+		if (typeof slug !== "string") continue;
+		if (type === "url") {
+			result.push({ slug, type });
+			continue;
+		}
+		if (type !== "repeater") continue;
+		const urlSubFields = repeaterUrlSubFields(Reflect.get(field, "validation"));
+		if (urlSubFields.length > 0) result.push({ slug, type, urlSubFields });
+	}
+	return result;
+}
+
 function isKnownFieldType(type: string): type is keyof typeof FIELD_TYPE_TO_COLUMN {
 	return FIELD_TYPE_SET.has(type);
 }
 
+function isUrlRelevantFieldType(type: string): type is "url" | "repeater" | "blocks" {
+	return type === "url" || type === "repeater" || type === "blocks";
+}
+
 /**
  * Records whose facts analysis keeps in its state. A package beyond these is
  * rejected rather than letting per-step state grow with the package.
@@ -904,6 +964,8 @@ const MAX_TRACKED = {
 	principals: 10_000,
 	collections: 1_000,
 	fields: 20_000,
+	blockTypes: 1_000,
+	blockVersions: 20_000,
 	bylineFields: 1_000,
 	providers: 100,
 } as const;
@@ -930,6 +992,26 @@ function collectRecordFacts(
 ): void {
 	const { state } = context;
 	switch (record.kind) {
+		case "block_type":
+			if (state.blockTypes.size >= MAX_TRACKED.blockTypes) {
+				reportTrackingLimit(state, record.kind);
+				return;
+			}
+			state.blockTypes.set(record.slug, {
+				id: record.id,
+				currentVersion: record.currentVersion,
+			});
+			return;
+		case "block_type_version":
+			if (state.blockVersions.size >= MAX_TRACKED.blockVersions) {
+				reportTrackingLimit(state, record.kind);
+				return;
+			}
+			state.blockVersions.set(
+				blockTypeVersionKey(record.blockTypeId, record.version),
+				urlValueFields(record.fields),
+			);
+			return;
 		case "principal":
 			if (record.id === "__proto__") {
 				addBlocker(state.issues, {
@@ -1020,6 +1102,10 @@ function collectRecordFacts(
 				columnType: record.columnType,
 				required: record.required === true,
 				storageless: referenceFieldRelationSlugs(record).length > 0,
+				...(isUrlRelevantFieldType(record.type) ? { type: record.type } : {}),
+				...(record.type === "repeater"
+					? { urlSubFields: repeaterUrlSubFields(record.validation) }
+					: {}),
 			});
 			state.fields.set(collectionSlug, fields);
 			return;
@@ -1394,9 +1480,35 @@ function checkTargetValues(
 	if (record.kind === "entry") {
 		const fields = context.state.fields.get(record.collection);
 		if (!fields) return;
-		const values = checkEntryFields(record, fields, target.dialect);
+		const values = checkEntryFields(
+			record,
+			fields,
+			target.dialect,
+			context.state.blockTypes,
+			context.state.blockVersions,
+		);
 		context.state.float4Rounded += values.float4Rounded;
 		reportValueIssues(context, record, values.issues, location);
+	} else if (
+		record.kind === "revision" &&
+		typeof record.data === "object" &&
+		record.data !== null &&
+		!Array.isArray(record.data)
+	) {
+		const fields = context.state.fields.get(record.collection);
+		if (!fields) return;
+		reportValueIssues(
+			context,
+			record,
+			checkContentUrlFields(
+				record.data,
+				fields,
+				context.state.blockTypes,
+				context.state.blockVersions,
+				"data",
+			),
+			location,
+		);
 	}
 }