@riducms/admin 0.2.1 → 0.2.2

package/package.json

@@ -9,11 +9,11 @@
 		"@hvniel/svelte-router": "^0.0.6",
 		"@iconify/json": "^2.2.509",
 		"@internationalized/date": "^3.12.3",
-		"@riducms/plugin": "0.2.1",
-		"@riducms/protocol": "0.2.1",
-		"@riducms/sdk": "0.2.1",
-		"@riducms/translations": "0.2.1",
-		"@riducms/ui": "0.2.1",
+		"@riducms/plugin": "0.2.2",
+		"@riducms/protocol": "0.2.2",
+		"@riducms/sdk": "0.2.2",
+		"@riducms/translations": "0.2.2",
+		"@riducms/ui": "0.2.2",
 		"@types/prismjs": "^1.26.5",
 		"bits-ui": "^2.18.1",
 		"prismjs": "^1.30.0",
@@ -22,7 +22,7 @@
 	"description": "Framework-owned Svelte 5 authoring application embedded by Ridu servers.",
 	"devDependencies": {
 		"@hvniel/lexical-svelte": "^0.1.1",
-		"@riducms/build": "0.2.1",
+		"@riducms/build": "0.2.2",
 		"svelte": "^5.56.8"
 	},
 	"exports": {
@@ -60,5 +60,5 @@
 		"test:unit": "bun test tests"
 	},
 	"type": "module",
-	"version": "0.2.1"
+	"version": "0.2.2"
 }

package/src/app.svelte

@@ -25,16 +25,7 @@
 	let { clientFactory, adminBasePath = "/admin", adminConfig = {} }: Props = $props();
 	// The runtime owns the client and plugin registry selected when this admin instance is mounted.
 	// svelte-ignore state_referenced_locally
-	const runtime = setAdminRuntime(
-		new AdminRuntime(
-			clientFactory(),
-			adminConfig.plugins,
-			adminConfig.languages,
-			undefined,
-			adminConfig.fields,
-			adminConfig
-		)
-	);
+	const runtime = setAdminRuntime(new AdminRuntime(clientFactory(), adminConfig));
 	setAdminI18n(runtime.i18n);
 	const notifications = setNotificationCenter(new NotificationCenter());
 	const development = import.meta.hot !== undefined;

package/src/core/api/admin-client.ts

@@ -13,6 +13,7 @@ type AdminCollection = CollectionContract & {
 	auth: true;
 	upload: true;
 	versions: true;
+	drafts: true;
 	output: AdminDocument;
 	create: Record<string, unknown>;
 	update: Record<string, unknown>;
@@ -24,6 +25,7 @@ type AdminCollection = CollectionContract & {
 
 type AdminGlobal = {
 	versions: true;
+	drafts: true;
 	output: AdminDocument;
 	update: Record<string, unknown>;
 	select: Record<string, boolean>;

package/src/core/forms/embedded-schema-draft.svelte.ts

@@ -5,7 +5,7 @@ import type {
 	EmbeddedSchemaFormScope,
 	EmbeddedSchemaVariantScope,
 } from "@riducms/plugin";
-import type { SchemaField } from "@riducms/protocol";
+import type { SchemaBlockType, SchemaField } from "@riducms/protocol";
 import { FormController } from "@admin/core/forms/form-controller.svelte";
 import { embeddedOccurrences } from "@admin/core/forms/embedded-fields";
 import { cloneFormValue, initialFormValues } from "@admin/core/forms/form-schema";
@@ -19,6 +19,8 @@ export interface HostedSchemaDraft {
 	draft: EmbeddedSchemaDraft;
 	form: FormController;
 	fields: SchemaField[];
+	block: SchemaBlockType;
+	treeKey: string;
 }
 
 export function embeddedVariant(field: SchemaField, scope: EmbeddedSchemaVariantScope) {
@@ -331,5 +333,5 @@ export function createEmbeddedSchemaDraft(
 			form.disposeBindings();
 		},
 	};
-	return { draft, form, fields };
+	return { draft, form, fields, block, treeKey: scope.treeKey };
 }

package/src/core/forms/field-binding-lifetime.ts

@@ -0,0 +1,155 @@
+import { cloneSchemaField, type SchemaField } from "@riducms/protocol";
+import type { FormController } from "@admin/core/forms/form-controller.svelte";
+import { captureFieldOccurrence, type FieldOccurrence } from "@admin/core/forms/field-occurrence";
+import { evaluateFieldCondition } from "@admin/core/forms/field-condition";
+import { fieldAccessPath } from "@admin/fields/nested/scoped-field";
+
+/** Private owner shared by local and paired adapters. Revocation is synchronous and permanent. */
+export class FieldBindingLifetime {
+	#revoked = false;
+	#source: SchemaField;
+	#snapshot: SchemaField;
+	#path: string;
+	#occurrence: FieldOccurrence;
+	#epoch: number;
+	#version: unknown;
+	#resource: string;
+	#locale: string | undefined;
+	#stopPath: () => void;
+	#stopObserve: () => void;
+	#stopLifetime: () => void;
+	#cleanup = new Set<() => void>();
+
+	constructor(
+		private form: FormController,
+		private getSchema: () => SchemaField,
+		private schemaVersion: () => unknown = () => form.editorEpoch
+	) {
+		this.#source = getSchema();
+		this.#snapshot = cloneSchemaField(this.#source);
+		this.#path = this.#source.path;
+		this.#occurrence = captureFieldOccurrence(form, this.#path);
+		this.#epoch = form.editorEpoch;
+		this.#version = schemaVersion();
+		this.#resource = JSON.stringify(form.resource);
+		this.#locale = form.contentLocale;
+		this.#stopPath = form.register(this.#path);
+		this.#stopObserve = form.observe(this.#path.split(".")[0]!, () => this.#resolve());
+		this.#stopLifetime = form.registerEditorLifetime(this.destroy);
+	}
+
+	get stale() {
+		this.#resolve();
+		return this.#revoked;
+	}
+	get path() {
+		this.#resolve();
+		return this.#path;
+	}
+	/** A revoked local host can render cached metadata once before its subtree unmounts. */
+	get schema(): SchemaField {
+		this.#resolve();
+		return { ...cloneSchemaField(this.#revoked ? this.#snapshot : this.#source), path: this.#path };
+	}
+	get visible() {
+		if (this.stale) return false;
+		return this.#selections().every(({ schema, resolve }) => {
+			const path = resolve();
+			return path !== undefined && this.#visible(schema, path);
+		});
+	}
+	/** Permission/schema restrictions exclude the temporary pending-save lock. */
+	get schemaReadOnly() {
+		if (this.stale) return true;
+		return this.#selections().some(({ schema, resolve }) => {
+			const path = resolve();
+			return (
+				path === undefined ||
+				schema.admin.readOnly === true ||
+				!this.#visible(schema, path) ||
+				!this.form.canWrite(path, fieldAccessPath(schema))
+			);
+		});
+	}
+	get readOnly() {
+		return this.schemaReadOnly || this.form.editingBlocked;
+	}
+	#selections() {
+		return [...this.#occurrence.ancestors, { schema: this.#source, resolve: () => this.#path }];
+	}
+	#visible(schema: SchemaField, path: string) {
+		return (
+			schema.admin.hidden !== true &&
+			this.form.canRead(path, fieldAccessPath(schema)) &&
+			(schema.admin.condition === undefined ||
+				evaluateFieldCondition(schema.admin.condition, path, (other) => this.form.get(other)))
+		);
+	}
+	onDestroy(cleanup: () => void) {
+		if (this.stale) {
+			cleanup();
+			return () => {};
+		}
+		this.#cleanup.add(cleanup);
+		return () => {
+			this.#cleanup.delete(cleanup);
+		};
+	}
+	destroy = () => {
+		if (this.#revoked) return;
+		this.#revoked = true;
+		// Never call component-owned getters during or after revocation.
+		this.#snapshot = cloneSchemaField(this.#source);
+		this.#stopPath();
+		this.#stopObserve();
+		this.#stopLifetime();
+		const callbacks = [...this.#cleanup];
+		this.#cleanup.clear();
+		// Dispose every child even if one cleanup fails.
+		const failures: unknown[] = [];
+		for (const cleanup of callbacks) {
+			try {
+				cleanup();
+			} catch (error) {
+				failures.push(error);
+			}
+		}
+		if (failures.length) throw new AggregateError(failures, "Field binding cleanup failed.");
+	};
+	#resolve() {
+		if (this.#revoked) return;
+		if (
+			this.form.editorEpoch !== this.#epoch ||
+			this.form.contentLocale !== this.#locale ||
+			JSON.stringify(this.form.resource) !== this.#resource ||
+			!this.form.editorScopeActive
+		) {
+			this.destroy();
+			return;
+		}
+		if (this.#revoked) return;
+		const version = this.schemaVersion();
+		if (this.#revoked) return;
+		if (version !== this.#version) {
+			this.destroy();
+			return;
+		}
+		const schema = this.getSchema();
+		if (this.#revoked) return;
+		if (schema.id !== this.#source.id) {
+			this.destroy();
+			return;
+		}
+		this.#source = schema;
+		const path = this.#occurrence.resolve();
+		if (path === undefined) {
+			this.destroy();
+			return;
+		}
+		if (path !== this.#path) {
+			this.#stopPath();
+			this.#path = path;
+			this.#stopPath = this.form.register(path);
+		}
+	}
+}

package/src/core/forms/field-condition.ts

@@ -1,7 +1,8 @@
+import { scalarLiteralValue } from "@admin/core/forms/scalar-literal";
 import type {
 	SchemaFieldCondition,
 	SchemaFieldConditionPredicate,
-	SchemaFieldConditionValue,
+	SchemaScalarLiteral,
 } from "@riducms/protocol";
 
 export type FieldConditionValueReader = (path: string) => unknown;
@@ -40,7 +41,7 @@ function evaluatePredicate(
 	read: FieldConditionValueReader
 ) {
 	const actual = read(fieldConditionValuePath(predicate.scope, predicate.path, fieldPath));
-	const matches = (expected: SchemaFieldConditionValue) => scalarMatches(actual, expected);
+	const matches = (expected: SchemaScalarLiteral) => scalarMatches(actual, expected);
 	switch (predicate.operator) {
 		case "equals":
 			return predicate.values[0] !== undefined && matches(predicate.values[0]);
@@ -51,13 +52,7 @@ function evaluatePredicate(
 	}
 }
 
-function scalarMatches(actual: unknown, expected: SchemaFieldConditionValue) {
-	switch (expected.type) {
-		case "string":
-			return typeof actual === "string" && actual === expected.value;
-		case "number":
-			return typeof actual === "number" && actual === Number(expected.value);
-		case "boolean":
-			return typeof actual === "boolean" && actual === (expected.value === "true");
-	}
+function scalarMatches(actual: unknown, expected: SchemaScalarLiteral) {
+	const value = scalarLiteralValue(expected);
+	return value !== undefined && actual === value;
 }

package/src/core/forms/field-editor-binding.ts

@@ -1,4 +1,4 @@
-import { cloneSchemaField } from "@riducms/protocol";
+import { FieldBindingLifetime } from "@admin/core/forms/field-binding-lifetime";
 import type {
 	FieldBinding,
 	FieldEditorProps,
@@ -8,55 +8,32 @@ import type {
 import type { SchemaField } from "@riducms/protocol";
 import { fieldControlARIA } from "@riducms/ui";
 import type { FormController } from "@admin/core/forms/form-controller.svelte";
-import { fieldAccessPath } from "@admin/fields/nested/scoped-field";
 import { cloneFormValue } from "@admin/core/forms/form-schema";
-import { evaluateFieldCondition } from "@admin/core/forms/field-condition";
-import { captureFieldOccurrence, type FieldOccurrence } from "@admin/core/forms/field-occurrence";
 
 /** The host owns this capability until unmount or an invalidating form transition. */
 export class FieldEditorBinding<Type extends FieldEditorType> implements FieldBinding<Type> {
 	#form: FormController;
-	#schema: () => SchemaField;
-	#occurrence: FieldOccurrence;
-	#path: string;
-	#stale = false;
-	#stopPath: () => void;
-	#stopObserve: () => void;
-	#stopLifetime: () => void;
-	#epoch: number;
-	#resource: string;
-	#locale: string | undefined;
+	#lifetime: FieldBindingLifetime;
 	#type: Type;
-	#schemaID: string;
-	#schemaVersion: () => unknown;
-	#initialSchemaVersion: unknown;
+	#apply: ((value: FieldEditorValue<Type> | null) => void) | undefined;
 	readonly form: FieldEditorProps["form"];
 
 	constructor(
 		form: FormController,
 		schema: () => SchemaField,
 		type: Type,
-		schemaVersion: () => unknown = () => form.editorEpoch
+		schemaVersion: () => unknown = () => form.editorEpoch,
+		apply?: (value: FieldEditorValue<Type> | null) => void
 	) {
 		this.#form = form;
-		this.#schemaID = schema().id;
-		this.#schemaVersion = schemaVersion;
-		this.#initialSchemaVersion = schemaVersion();
-		this.#schema = schema;
+		this.#apply = apply;
 		this.#type = type;
-		this.#epoch = form.editorEpoch;
-		this.#resource = JSON.stringify(form.resource);
-		this.#locale = form.contentLocale;
-		this.#path = schema().path;
-		this.#occurrence = captureFieldOccurrence(form, this.#path);
-		this.#stopPath = form.register(this.#path);
-		this.#stopObserve = form.observe(this.#path.split(".")[0]!, () => this.#resolve());
-		this.#stopLifetime = form.registerEditorLifetime(this.destroy);
+		this.#lifetime = new FieldBindingLifetime(form, schema, schemaVersion);
 		const binding = this;
 		this.form = {
 			get contentLocale() {
 				binding.assertActive();
-				return binding.#locale;
+				return form.contentLocale;
 			},
 			get resource() {
 				binding.assertActive();
@@ -78,68 +55,39 @@ export class FieldEditorBinding<Type extends FieldEditorType> implements FieldBi
 	}
 
 	get schema(): SchemaField & { type: Type } {
-		// A revoked host can render once before its keyed subtree unmounts. Metadata
-		// remains a detached snapshot; values and writes stay revoked immediately.
-		this.#resolve();
-		return {
-			...cloneSchemaField(this.#schema()),
-			type: this.#type,
-			path: this.#path,
-		};
+		return { ...this.#lifetime.schema, type: this.#type };
 	}
 	get stale() {
-		this.#resolve();
-		return this.#stale;
+		return this.#lifetime.stale;
 	}
 	get value(): FieldEditorValue<Type> | null | undefined {
 		if (this.stale) return undefined;
-		const value = this.#form.get(this.#path);
+		const value = this.#form.get(this.#lifetime.path);
 		assertEditorValue(this.#type, value);
 		return cloneFormValue(value) as FieldEditorValue<Type> | null | undefined;
 	}
 	get issues() {
-		return this.stale ? [] : this.#form.issuesFor(this.#path).map((issue) => ({ ...issue }));
+		return this.stale
+			? []
+			: this.#form.issuesFor(this.#lifetime.path).map((issue) => ({ ...issue }));
 	}
 	get liveValidation() {
 		if (this.stale) return { status: "idle" as const, retry: () => {} };
-		const feedback = this.#form.liveValidation.forField(this.#path);
+		const feedback = this.#form.liveValidation.forField(this.#lifetime.path);
 		return {
 			status: feedback.status,
 			retry: () => {
 				this.assertActive();
-				if (!this.readOnly) this.#form.liveValidation.flush(this.#path);
+				if (!this.readOnly) this.#form.liveValidation.flush(this.#lifetime.path);
 			},
 		};
 	}
 
+	get visible() {
+		return this.#lifetime.visible;
+	}
 	get readOnly() {
-		if (this.stale) return true;
-		if (
-			this.#occurrence.ancestors.some(({ schema, resolve }) => {
-				const path = resolve();
-				return (
-					path === undefined ||
-					schema.admin.readOnly === true ||
-					schema.admin.hidden === true ||
-					!this.#form.canRead(path, fieldAccessPath(schema)) ||
-					!this.#form.canWrite(path, fieldAccessPath(schema)) ||
-					(schema.admin.condition !== undefined &&
-						!evaluateFieldCondition(schema.admin.condition, path, (other) => this.#form.get(other)))
-				);
-			})
-		)
-			return true;
-		const schema = this.#schema();
-		const accessPath = fieldAccessPath(schema);
-		return (
-			this.#form.editingBlocked ||
-			schema.admin.readOnly === true ||
-			schema.admin.hidden === true ||
-			!this.#form.canRead(this.#path, accessPath) ||
-			!this.#form.canWrite(this.#path, accessPath) ||
-			(schema.admin.condition !== undefined &&
-				!evaluateFieldCondition(schema.admin.condition, this.#path, (path) => this.#form.get(path)))
-		);
+		return this.#lifetime.readOnly;
 	}
 	get inputProps() {
 		const schema = this.schema;
@@ -167,43 +115,17 @@ export class FieldEditorBinding<Type extends FieldEditorType> implements FieldBi
 				"This field editor is stale. Use the editor mounted for the current document, locale and field occurrence."
 			);
 	};
-	destroy = () => {
-		if (this.#stale) return;
-		this.#stale = true;
-		this.#stopPath();
-		this.#stopObserve();
-		this.#stopLifetime();
-	};
+	destroy = () => this.#lifetime.destroy();
 	#write(value: unknown) {
 		this.assertActive();
-		if (this.readOnly) throw new Error(`Field ${this.#path} is read-only.`);
+		if (this.readOnly) throw new Error(`Field ${this.#lifetime.path} is read-only.`);
 		assertEditorValue(this.#type, value);
 		if (value === undefined) throw new Error("Use null to clear an editor value.");
-		this.#form.set(this.#path, cloneFormValue(value));
-	}
-	#resolve() {
-		if (this.#stale) return;
-		if (
-			this.#schema().id !== this.#schemaID ||
-			this.#schemaVersion() !== this.#initialSchemaVersion ||
-			!this.#form.editorScopeActive ||
-			this.#form.editorEpoch !== this.#epoch ||
-			this.#form.contentLocale !== this.#locale ||
-			JSON.stringify(this.#form.resource) !== this.#resource
-		) {
-			this.destroy();
-			return;
-		}
-		const path = this.#occurrence.resolve();
-		if (path === undefined) {
-			this.destroy();
-			return;
-		}
-		if (path !== this.#path) {
-			this.#stopPath();
-			this.#path = path;
-			this.#stopPath = this.#form.register(path);
-		}
+		const detached = cloneFormValue(value) as FieldEditorValue<Type> | null;
+		this.assertActive();
+		if (this.readOnly) throw new Error(`Field ${this.#lifetime.path} is read-only.`);
+		if (this.#apply !== undefined) this.#apply(detached);
+		else this.#form.set(this.#lifetime.path, detached);
 	}
 }
 

package/src/core/forms/field-occurrence.ts

@@ -1,7 +1,6 @@
 import { resolveBlockTypes } from "@riducms/protocol";
 import type { SchemaField } from "@riducms/protocol";
 import type { FormController } from "@admin/core/forms/form-controller.svelte";
-import { embeddedOccurrences } from "@admin/core/forms/embedded-fields";
 import { scopeRepeatedRowField } from "@admin/fields/nested/scoped-field";
 
 type ResolvePath = () => string | undefined;
@@ -58,20 +57,7 @@ export function captureFieldOccurrence(form: FormController, target: string): Fi
 				const rowPath = () => {
 					const base = path();
 					if (base === undefined) return;
-					const values = form.get(base);
-					if (!Array.isArray(values)) return;
-					const matches = values
-						.map((value: unknown, index) => ({ value, index }))
-						.filter(({ value }) => record(value) && value._key === key);
-					const match = matches[0];
-					if (
-						matches.length !== 1 ||
-						!match ||
-						!record(match.value) ||
-						match.value.blockType !== variant
-					)
-						return;
-					return `${base}.${match.index}`;
+					return form.rowPath(base, key, variant);
 				};
 				const children =
 					field.type === "array"
@@ -81,21 +67,18 @@ export function captureFieldOccurrence(form: FormController, target: string): Fi
 				if (result) return result;
 			}
 			if (field.plugin?.embeddedTrees !== undefined) {
-				const initial = embeddedOccurrences(field, form.get(current), current).occurrences.find(
-					(item) => target.startsWith(`${item.path}.`)
-				);
+				const initial = form
+					.embeddedFields({ ...field, path: current })
+					.occurrences.find((item) => target.startsWith(`${item.path}.`));
 				if (!initial || initial.identity === undefined)
 					throw new Error(`Cannot bind ${target}: embedded payloads require stable identities.`);
 				const { identity, tree, block, case: branch } = initial;
 				const payloadPath = () => {
 					const base = path();
 					if (base === undefined) return;
-					const matches = embeddedOccurrences(field, form.get(base), base).occurrences.filter(
-						(item) => item.tree.key === tree.key && item.identity === identity
-					);
-					const match = matches[0];
+					const match = form.embeddedOccurrence({ ...field, path: base }, tree.key, identity);
 					if (
-						matches.length !== 1 ||
+						match === undefined ||
 						match?.block.slug !== block.slug ||
 						match.case.tagValue !== branch.tagValue
 					)

package/src/core/forms/form-controller.svelte.ts

@@ -136,6 +136,7 @@ export class FormController {
 		};
 	}
 	#invalidateEditors() {
+		this.#invalidateValueIndexes();
 		this.liveValidation.reset();
 		this.#listEdits.clear();
 		this.editorEpoch += 1;
@@ -164,6 +165,15 @@ export class FormController {
 	localizationSources = $state.raw<Readonly<Record<string, string>>>({});
 	#registered = new Map<string, Set<symbol>>();
 	#rowMountKeys = new WeakMap<object, symbol>();
+	#valueEpoch = $state(0);
+	#rowIndexes = new Map<string, Map<string, { index: number; variant: unknown }>>();
+	#embeddedIndexes = new Map<
+		string,
+		{
+			result: ReturnType<typeof embeddedOccurrences>;
+			identities: Map<string, EmbeddedOccurrence | undefined>;
+		}
+	>();
 	#pathObservers = new Map<string, Set<(value: unknown) => void>>();
 	#derivedTextBindings = new Map<string, DerivedTextBindingState>();
 	#revision = 0;
@@ -295,6 +305,60 @@ export class FormController {
 		return readPath(this.values, path);
 	}
 
+	/** Shared identity lookups: a mounted header never scans every sibling on its own. */
+	rowPath(path: string, identity: string, variant: unknown) {
+		this.#valueEpoch;
+		let index = this.#rowIndexes.get(path);
+		if (index === undefined) {
+			index = new Map();
+			const rows = this.get(path);
+			if (Array.isArray(rows))
+				for (const [position, row] of rows.entries()) {
+					if (!isRecord(row) || typeof row._key !== "string") continue;
+					index.set(row._key, {
+						index: index.has(row._key) ? -1 : position,
+						variant: row.blockType,
+					});
+				}
+			this.#rowIndexes.set(path, index);
+		}
+		const match = index.get(identity);
+		return match !== undefined && match.index >= 0 && match.variant === variant
+			? `${path}.${match.index}`
+			: undefined;
+	}
+
+	/** Cache only structural traversal, never access decisions or detached field values. */
+	embeddedFields(field: SchemaField) {
+		this.#valueEpoch;
+		const key = field.path;
+		let entry = this.#embeddedIndexes.get(key);
+		if (entry === undefined) {
+			const result = embeddedOccurrences(field, this.get(field.path), field.path);
+			const identities = new Map<string, EmbeddedOccurrence | undefined>();
+			for (const occurrence of result.occurrences) {
+				const identity = JSON.stringify([occurrence.tree.key, occurrence.identity]);
+				identities.set(identity, identities.has(identity) ? undefined : occurrence);
+			}
+			entry = { result, identities };
+			this.#embeddedIndexes.set(key, entry);
+		}
+		return entry.result;
+	}
+
+	embeddedOccurrence(field: SchemaField, treeKey: string, identity: string) {
+		this.embeddedFields(field);
+		return this.#embeddedIndexes
+			.get(field.path)
+			?.identities.get(JSON.stringify([treeKey, identity]));
+	}
+
+	#invalidateValueIndexes() {
+		this.#rowIndexes.clear();
+		this.#embeddedIndexes.clear();
+		this.#valueEpoch++;
+	}
+
 	/** DOM identity survives retained-row replacements, but not removal and key reuse. */
 	rowMountKey(row: Record<string, unknown>) {
 		const key = this.#rowMountKeys.get(row) ?? Symbol();
@@ -333,6 +397,7 @@ export class FormController {
 				if (key) mounts.set(token, { row, key });
 			}
 		writePath(this.values, path, value);
+		this.#invalidateValueIndexes();
 		if (root) {
 			const retained = new Set<string>();
 			for (const { token, schema, path: fieldPath, value: current } of indexFieldValues(
@@ -540,6 +605,7 @@ export class FormController {
 		this.#invalidateEditors();
 		this.#clearDerivedTextBindings();
 		this.values = cloneFormValues(values);
+		this.#invalidateValueIndexes();
 		this.original = cloneFormValues(values);
 		this.localizationSources = {};
 		this.issues = [];
@@ -558,6 +624,7 @@ export class FormController {
 		this.#fields = nextFields;
 		const result = reconcileFormSchema(this, previousFields, nextFields, { initializeDefaults });
 		this.values = result.values;
+		this.#invalidateValueIndexes();
 		this.original = result.original;
 		this.issues = [];
 		this.#submittingIssues = [];
@@ -575,6 +642,7 @@ export class FormController {
 		this.#fields = nextFields;
 		const result = recoverFormDraft(this, draft, previousFields, nextFields);
 		this.values = result.values;
+		this.#invalidateValueIndexes();
 		this.original = result.original;
 		this.issues = [];
 		this.#submittingIssues = [];

package/src/core/forms/plugin-field-authoring.ts

@@ -93,6 +93,7 @@ export function guardPluginAuthoring(
 					},
 				}),
 		...(host.schemaForm === undefined ? {} : { schemaForm: host.schemaForm }),
+		...(host.schemaHeader === undefined ? {} : { schemaHeader: host.schemaHeader }),
 		...(host.schemaIssues === undefined
 			? {}
 			: {