emdash 0.40.1 → 0.42.0

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/types.ts

@@ -45,6 +45,9 @@ export interface SeedFile {
 	/** Database-owned block types, applied before collections that reference them. */
 	blockTypes?: SeedBlockType[];
 
+	/** Relations joining two collections, which reference fields bind to */
+	relations?: SeedRelation[];
+
 	/** Taxonomy definitions */
 	taxonomies?: SeedTaxonomy[];
 
@@ -118,6 +121,34 @@ export interface SeedCollection {
 	fields: SeedField[];
 }
 
+/**
+ * Relation definition in seed.
+ *
+ * A relation joins two collections and owns the link set a reference field
+ * views. Declaring it here names it — the slug is how a field addresses it — and
+ * lets a field on either collection bind to it. A reference field that names
+ * only a `targetCollection` gets a relation created for it instead, which stays
+ * the shorter path for a one-sided link.
+ *
+ * Labels are single-valued: a relation is schema, like a collection or a field,
+ * and carries no locale.
+ */
+export interface SeedRelation {
+	slug: string;
+	parentCollection: string;
+	childCollection: string;
+	/** Names the parent's role, as seen from the child. */
+	parentLabel: string;
+	parentLabelSingular?: string;
+	/** Names the child's role, as seen from the parent. */
+	childLabel: string;
+	childLabelSingular?: string;
+	/** How many children one parent may link. Omitted or `null` is unlimited. */
+	maxChildrenPerParent?: number | null;
+	/** How many parents one child may link. Omitted or `null` is unlimited. */
+	maxParentsPerChild?: number | null;
+}
+
 /**
  * Field definition in seed
  */
@@ -129,6 +160,8 @@ export interface SeedField {
 	unique?: boolean;
 	searchable?: boolean;
 	indexed?: boolean;
+	/** Whether the value is stored per locale (default true). `false` shares one value across translations. */
+	translatable?: boolean;
 	defaultValue?: unknown;
 	validation?: Record<string, unknown>;
 	widget?: string;
@@ -250,8 +283,8 @@ export interface SeedSection {
 	keywords?: string[];
 	/** Portable Text content */
 	content: Array<{ _type: string; _key?: string; [key: string]: unknown }>;
-	/** Source: "theme" for seed-provided, "import" for WP imports */
-	source?: "theme" | "import";
+	/** Source: "theme" for seed-provided (the default), "user" for editor-created, "import" for WP imports */
+	source?: "theme" | "user" | "import";
 }
 
 /**
@@ -375,6 +408,7 @@ export interface SeedApplyResult {
 	blockTypes: { created: number; skipped: number; updated: number };
 	collections: { created: number; skipped: number; updated: number };
 	fields: { created: number; skipped: number; updated: number };
+	relations: { created: number; skipped: number; updated: number };
 	taxonomies: { created: number; skipped: number; terms: number };
 	bylines: { created: number; skipped: number; updated: number };
 	menus: { created: number; items: number };

package/src/seed/validate.ts

@@ -5,16 +5,22 @@
  */
 
 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_]*$/;
+/** Matches `SchemaRegistry.validateSlug`, which collection and field slugs go through. */
+const MAX_SLUG_LENGTH = 63;
 const SLUG_PATTERN = /^[a-z0-9-]+$/;
 const REDIRECT_TYPES = new Set([301, 302, 307, 308]);
 const CRLF_PATTERN = /[\r\n]/;
@@ -197,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`);
@@ -206,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)
@@ -239,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
@@ -278,12 +311,27 @@ export function validateSeed(data: unknown): ValidationResult {
 							errors.push(`${fieldPrefix}.indexed: must be a boolean`);
 						}
 
+						if (field.translatable !== undefined && typeof field.translatable !== "boolean") {
+							errors.push(`${fieldPrefix}.translatable: must be a boolean`);
+						}
+
 						if (!field.type) {
 							errors.push(`${fieldPrefix}: type is required`);
 						} else if (!(FIELD_TYPES as readonly string[]).includes(field.type)) {
 							errors.push(`${fieldPrefix}.type: unsupported field type "${field.type}"`);
 						} else if (field.indexed === true && !isIndexableFieldType(field.type)) {
 							errors.push(`${fieldPrefix}.indexed: type "${field.type}" cannot be indexed`);
+						} else if (
+							field.indexed === true &&
+							field.type === "reference" &&
+							typeof field.validation?.targetCollection === "string"
+						) {
+							// A targetCollection makes this field storage-less on apply: its
+							// selection becomes relation edges, leaving no column to index.
+							// Without one it stays a plain entry-id column, which can be.
+							errors.push(
+								`${fieldPrefix}.indexed: a reference field with a targetCollection stores no column to index`,
+							);
 						}
 					}
 				}
@@ -291,6 +339,65 @@ export function validateSeed(data: unknown): ValidationResult {
 		}
 	}
 
+	// Validate relations
+	if (seed.relations) {
+		if (!Array.isArray(seed.relations)) {
+			errors.push("relations must be an array");
+		} else {
+			const relationSlugs = new Set<string>();
+
+			for (let i = 0; i < seed.relations.length; i++) {
+				const relation = seed.relations[i];
+				const prefix = `relations[${i}]`;
+				if (!relation) continue;
+
+				if (!relation.slug) {
+					errors.push(`${prefix}: slug is required`);
+				} else {
+					if (!COLLECTION_FIELD_SLUG_PATTERN.test(relation.slug)) {
+						errors.push(
+							`${prefix}.slug: must start with a letter and contain only lowercase letters, numbers, and underscores`,
+						);
+					}
+					if (relation.slug.length > MAX_SLUG_LENGTH) {
+						errors.push(`${prefix}.slug: must be ${MAX_SLUG_LENGTH} characters or fewer`);
+					}
+					if (relationSlugs.has(relation.slug)) {
+						errors.push(`${prefix}.slug: duplicate relation slug "${relation.slug}"`);
+					}
+					relationSlugs.add(relation.slug);
+				}
+
+				for (const end of ["parentCollection", "childCollection"] as const) {
+					const value = relation[end];
+					if (!value) {
+						errors.push(`${prefix}: ${end} is required`);
+					} else if (!COLLECTION_FIELD_SLUG_PATTERN.test(value)) {
+						errors.push(`${prefix}.${end}: "${value}" is not a valid collection slug`);
+					}
+				}
+
+				for (const label of ["parentLabel", "childLabel"] as const) {
+					if (!relation[label]) errors.push(`${prefix}: ${label} is required`);
+				}
+				for (const label of ["parentLabelSingular", "childLabelSingular"] as const) {
+					const value = relation[label];
+					if (value !== undefined && typeof value !== "string") {
+						errors.push(`${prefix}.${label}: must be a string`);
+					}
+				}
+
+				for (const limit of ["maxChildrenPerParent", "maxParentsPerChild"] as const) {
+					const value = relation[limit];
+					if (value === undefined || value === null) continue;
+					if (!Number.isInteger(value) || value < 1) {
+						errors.push(`${prefix}.${limit}: must be a positive integer, or null for unlimited`);
+					}
+				}
+			}
+		}
+	}
+
 	// Validate taxonomies
 	if (seed.taxonomies) {
 		if (!Array.isArray(seed.taxonomies)) {
@@ -524,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`);
@@ -637,8 +756,8 @@ export function validateSeed(data: unknown): ValidationResult {
 				}
 
 				// Validate source
-				if (section.source && !["theme", "import"].includes(section.source)) {
-					errors.push(`${prefix}.source: must be "theme" or "import"`);
+				if (section.source && !["theme", "user", "import"].includes(section.source)) {
+					errors.push(`${prefix}.source: must be "theme", "user", or "import"`);
 				}
 			}
 		}

package/src/transfer/analyze/unique-keys.ts

@@ -32,8 +32,7 @@ export const UNIQUE_CONSTRAINTS = [
 	"byline_principal_locale",
 	"byline_field_slug",
 	"menu_name_locale",
-	"relation_name_locale",
-	"relation_group_locale",
+	"relation_slug",
 	"widget_area_name",
 	"section_slug",
 	"content_reference_groups",
@@ -111,22 +110,14 @@ export function uniqueKeysOf(record: SitePackageRecord): UniqueKey[] {
 		case "menu":
 			return [key("menu_name_locale", record.name, record.locale)];
 		case "relation":
-			return [
-				key("relation_name_locale", record.name, record.locale),
-				key("relation_group_locale", record.translationGroup, record.locale),
-			];
+			return [key("relation_slug", record.slug)];
 		case "widget_area":
 			return [key("widget_area_name", record.name)];
 		case "section":
 			return [key("section_slug", record.slug)];
 		case "content_reference":
 			return [
-				key(
-					"content_reference_groups",
-					record.relationGroup,
-					record.parentGroup,
-					record.childGroup,
-				),
+				key("content_reference_groups", record.relationId, record.parentGroup, record.childGroup),
 			];
 		case "content_byline":
 			return [

package/src/transfer/analyze/validate.ts

@@ -37,6 +37,7 @@ import { SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isTransferError, TransferError } from "../errors.js";
 import {
 	blocksFieldTypeSlugs,
+	referenceFieldRelationSlugs,
 	blockTypeVersionKey,
 	compareIds,
 	compareStreamOrder,
@@ -70,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,
@@ -77,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";
@@ -85,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];
@@ -122,11 +131,23 @@ export const validationStateSchema = z.strictObject({
 					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() }),
 	),
@@ -204,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>>;
@@ -238,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(),
@@ -279,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]) => [
@@ -315,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(
@@ -722,7 +751,9 @@ function groupIdOf(record: SitePackageRecord): string {
 }
 
 function nameKeyOf(record: SitePackageRecord): string | null {
-	if (record.kind === "collection" || record.kind === "block_type") return record.slug;
+	if (record.kind === "collection" || record.kind === "block_type" || record.kind === "relation") {
+		return record.slug;
+	}
 	if (record.kind === "menu") return record.name;
 	if (record.kind === "block_type_version") {
 		return blockTypeVersionKey(record.blockTypeId, record.version);
@@ -888,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.
@@ -900,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;
@@ -926,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, {
@@ -1015,6 +1101,11 @@ function collectRecordFacts(
 			fields.set(record.slug, {
 				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;
@@ -1172,27 +1263,44 @@ interface NestedReference {
 	targets: readonly RecordKind[];
 	by: ReferenceKey;
 	values: (record: SitePackageRecord) => string[];
+	/** A dangling value is a warning, not a blocker (see `KindReference.soft`). */
+	soft?: boolean;
 }
 
 /**
  * References that live inside a property rather than being one: the block
- * types a `blocks` field names in `validation`, and the version a block type
- * names as current.
+ * types a `blocks` field names in `validation`, the relation a bound
+ * `reference` field names there, and the version a block type names as
+ * current.
+ *
+ * A bound field's relation is soft because the origin does not keep it
+ * resolvable: deleting a relation leaves the fields bound to it in place.
  */
-const NESTED_REFERENCES: Partial<Record<RecordKind, NestedReference>> = {
-	field: {
-		property: "validation",
-		targets: ["block_type"],
-		by: "slug",
-		values: (record) => (record.kind === "field" ? blocksFieldTypeSlugs(record) : []),
-	},
-	block_type: {
-		property: "currentVersion",
-		targets: ["block_type_version"],
-		by: "name",
-		values: (record) =>
-			record.kind === "block_type" ? [blockTypeVersionKey(record.id, record.currentVersion)] : [],
-	},
+const NESTED_REFERENCES: Partial<Record<RecordKind, readonly NestedReference[]>> = {
+	field: [
+		{
+			property: "validation",
+			targets: ["block_type"],
+			by: "slug",
+			values: (record) => (record.kind === "field" ? blocksFieldTypeSlugs(record) : []),
+		},
+		{
+			property: "validation",
+			targets: ["relation"],
+			by: "slug",
+			values: (record) => (record.kind === "field" ? referenceFieldRelationSlugs(record) : []),
+			soft: true,
+		},
+	],
+	block_type: [
+		{
+			property: "currentVersion",
+			targets: ["block_type_version"],
+			by: "name",
+			values: (record) =>
+				record.kind === "block_type" ? [blockTypeVersionKey(record.id, record.currentVersion)] : [],
+		},
+	],
 };
 
 async function checkNestedReferences(
@@ -1201,29 +1309,33 @@ async function checkNestedReferences(
 	records: readonly ChunkRecord[],
 	path: string,
 ): Promise<void> {
-	const reference = NESTED_REFERENCES[kind];
-	if (!reference) return;
-	const owners = new Map<string, ChunkRecord[]>();
-	for (const item of records) {
-		for (const value of reference.values(item.record)) {
-			const list = owners.get(value) ?? [];
-			list.push(item);
-			owners.set(value, list);
+	for (const reference of NESTED_REFERENCES[kind] ?? []) {
+		const owners = new Map<string, ChunkRecord[]>();
+		for (const item of records) {
+			for (const value of reference.values(item.record)) {
+				const list = owners.get(value) ?? [];
+				list.push(item);
+				owners.set(value, list);
+			}
 		}
-	}
-	if (owners.size === 0) return;
-	const missing = await context.index.findMissing(reference.targets, reference.by, [
-		...owners.keys(),
-	]);
-	for (const value of missing) {
-		for (const item of owners.get(value) ?? []) {
-			addBlocker(context.state.issues, {
-				code: "dangling_reference",
-				message: "Reference does not resolve to a record in the package",
-				kind,
-				id: item.record.id,
-				detail: { property: reference.property, path, line: item.line },
-			});
+		if (owners.size === 0) continue;
+		const missing = await context.index.findMissing(reference.targets, reference.by, [
+			...owners.keys(),
+		]);
+		for (const value of missing) {
+			for (const item of owners.get(value) ?? []) {
+				const issue = {
+					message: "Reference does not resolve to a record in the package",
+					kind,
+					id: item.record.id,
+					detail: { property: reference.property, path, line: item.line },
+				};
+				if (reference.soft) {
+					addWarning(context.state.issues, { code: "soft_reference_dangling", ...issue });
+				} else {
+					addBlocker(context.state.issues, { code: "dangling_reference", ...issue });
+				}
+			}
 		}
 	}
 }
@@ -1368,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,
+		);
 	}
 }