@riducms/admin 0.1.5 → 0.2.1

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

@@ -0,0 +1,160 @@
+import type {
+	EmbeddedSchemaDraft,
+	FieldAuthoringHost,
+	FieldReferenceBrowserProps,
+} from "@riducms/plugin";
+import type { PluginFieldBinding } from "@admin/core/forms/plugin-field-binding";
+import { cloneFormValue } from "@admin/core/forms/form-schema";
+
+/** Every retained callable checks its lease, including after asynchronous host operations. */
+export function guardPluginAuthoring(
+	host: FieldAuthoringHost,
+	binding: PluginFieldBinding,
+	registerDraft?: (draft: EmbeddedSchemaDraft, raw: EmbeddedSchemaDraft) => void
+): FieldAuthoringHost {
+	return {
+		get collections() {
+			binding.assertActive();
+			return cloneFormValue(host.collections) as typeof host.collections;
+		},
+		get documentRevision() {
+			binding.assertActive();
+			return host.documentRevision;
+		},
+		get locale() {
+			binding.assertActive();
+			return host.locale;
+		},
+		referenceBrowser: (anchor, props) => {
+			binding.assertActive();
+			const overrides = {
+				get readOnly() {
+					return binding.readOnly || props.readOnly;
+				},
+				onCommit: async (ids: string[]) => {
+					binding.assertEditable();
+					const result = await props.onCommit([...ids]);
+					binding.assertEditable();
+					return result;
+				},
+				onClose: () => {
+					binding.assertActive();
+					props.onClose();
+				},
+			};
+			// Delegate every read, including spread-props proxies whose backing object is replaced.
+			const guarded = new Proxy({} as FieldReferenceBrowserProps, {
+				get: (_target, key) =>
+					Reflect.has(overrides, key) ? Reflect.get(overrides, key) : Reflect.get(props, key),
+				set: (_target, key, value) => Reflect.set(props, key, value),
+				has: (_target, key) => Reflect.has(overrides, key) || Reflect.has(props, key),
+				ownKeys: () => [...new Set([...Reflect.ownKeys(props), ...Reflect.ownKeys(overrides)])],
+				getOwnPropertyDescriptor: (_target, key) => {
+					if (!Reflect.has(overrides, key) && !Reflect.has(props, key)) return undefined;
+					const setter = Reflect.has(overrides, key)
+						? undefined
+						: Reflect.getOwnPropertyDescriptor(props, key)?.set;
+					return {
+						configurable: true,
+						enumerable: true,
+						get: () => Reflect.get(guarded, key),
+						...(setter === undefined
+							? {}
+							: {
+									set: (value: unknown) => {
+										Reflect.set(props, key, value);
+									},
+								}),
+					};
+				},
+			});
+			return host.referenceBrowser(anchor, guarded);
+		},
+		async findDocument(...args) {
+			binding.assertActive();
+			const result = await host.findDocument(...args);
+			binding.assertActive();
+			return cloneFormValue(result) as typeof result;
+		},
+		...(host.requestPlugin === undefined
+			? {}
+			: {
+					async requestPlugin<Result>(
+						path: string,
+						body: unknown,
+						signal?: AbortSignal
+					): Promise<Result> {
+						binding.assertEditable();
+						const detached = cloneFormValue(body);
+						binding.assertEditable();
+						const result = await host.requestPlugin!<Result>(path, detached, signal);
+						binding.assertEditable();
+						return cloneFormValue(result) as Result;
+					},
+				}),
+		...(host.schemaForm === undefined ? {} : { schemaForm: host.schemaForm }),
+		...(host.schemaIssues === undefined
+			? {}
+			: {
+					schemaIssues: (scope) => {
+						binding.assertActive();
+						return host.schemaIssues!(scope).map((issue) => ({ ...issue }));
+					},
+				}),
+		...(host.copySchemaPayload === undefined
+			? {}
+			: {
+					copySchemaPayload: (scope, payload) => {
+						binding.assertActive();
+						const result = host.copySchemaPayload!(scope, payload);
+						binding.assertActive();
+						return result;
+					},
+				}),
+		...(host.beginSchemaDraft === undefined
+			? {}
+			: {
+					beginSchemaDraft: (scope) => {
+						binding.assertEditable();
+						const raw = host.beginSchemaDraft!({ ...scope });
+						const discard = raw.discard;
+						const stop = binding.onDestroy(() => raw.discard());
+						// Drawers dispose the raw session; every disposal must release owner cleanup.
+						raw.discard = () => {
+							stop();
+							discard();
+						};
+						const assertDraft = () => {
+							binding.assertEditable();
+							if (raw.stale) throw new Error("This embedded schema draft is stale.");
+						};
+						const draft: EmbeddedSchemaDraft = {
+							id: raw.id,
+							identity: raw.identity,
+							get stale() {
+								return binding.stale || raw.stale;
+							},
+							get dirty() {
+								return !binding.stale && raw.dirty;
+							},
+							get issues() {
+								binding.assertActive();
+								return raw.issues.map((issue) => ({ ...issue }));
+							},
+							payload: () => {
+								assertDraft();
+								return cloneFormValue(raw.payload()) as Record<string, unknown>;
+							},
+							validate: () => {
+								assertDraft();
+								return raw.validate();
+							},
+							discard: raw.discard,
+						};
+						registerDraft?.(draft, raw);
+						return draft;
+					},
+				}),
+		...(host.schemaDraftEditor === undefined ? {} : { schemaDraftEditor: host.schemaDraftEditor }),
+	};
+}

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

@@ -0,0 +1,258 @@
+import { cloneSchemaField } from "@riducms/protocol";
+import type {
+	PluginFieldBinding as Binding,
+	PluginForm,
+	RegisteredPluginField,
+} from "@riducms/plugin";
+import type { SchemaField } from "@riducms/protocol";
+import type { FormController } from "@admin/core/forms/form-controller.svelte";
+import { captureFieldOccurrence } from "@admin/core/forms/field-occurrence";
+import { writePluginField } from "@admin/core/forms/plugin-field-write";
+import { cloneFormValue } from "@admin/core/forms/form-schema";
+import { fieldAccessPath } from "@admin/fields/nested/scoped-field";
+import { evaluateFieldCondition } from "@admin/core/forms/field-condition";
+
+/** The form owns values. This lease owns registration, occurrence tracking and child capabilities. */
+export class PluginFieldBinding implements Binding<unknown> {
+	#stale = false;
+	#path: string;
+	#resolvePath: () => string | undefined;
+	#ancestors: ReturnType<typeof captureFieldOccurrence>["ancestors"];
+	#epoch: number;
+	#version: unknown;
+	#schemaID: string;
+	#resource: string;
+	#locale: string | undefined;
+	#stopPath: () => void;
+	#stopObserve: () => void;
+	#stopLifetime: () => void;
+	#cleanup = new Set<() => void>();
+	readonly form: PluginForm;
+	constructor(
+		private controller: FormController,
+		private getSchema: () => SchemaField,
+		private registration: Pick<RegisteredPluginField, "decodeValue"> &
+			Partial<Pick<RegisteredPluginField, "decodeInput" | "decodeFormValue">>,
+		private schemaVersion: () => unknown = () => controller.editorEpoch,
+		private owner?: PluginFieldBinding
+	) {
+		const schema = getSchema();
+		this.#path = schema.path;
+		const occurrence = captureFieldOccurrence(controller, schema.path);
+		this.#resolvePath = occurrence.resolve;
+		this.#ancestors = occurrence.ancestors;
+		this.#epoch = controller.editorEpoch;
+		this.#schemaID = schema.id;
+		this.#version = schemaVersion();
+		this.#resource = JSON.stringify(controller.resource);
+		this.#locale = controller.contentLocale;
+		this.#stopPath = controller.register(this.#path);
+		this.#stopObserve = controller.observe(this.#path.split(".")[0]!, () => this.#resolve());
+		this.#stopLifetime = controller.registerEditorLifetime(this.destroy);
+		const binding = this;
+		this.form = {
+			get contentLocale() {
+				binding.assertActive();
+				return controller.contentLocale;
+			},
+			get resource() {
+				binding.assertActive();
+				return cloneFormValue(controller.resource) as typeof controller.resource;
+			},
+			get: (path) => {
+				this.assertActive();
+				return cloneFormValue(controller.get(path));
+			},
+			issuesFor: (path) => {
+				this.assertActive();
+				return controller.issuesFor(path).map((issue) => ({ ...issue }));
+			},
+			snapshot: () => {
+				this.assertActive();
+				return controller.snapshot();
+			},
+			bind: (path) => {
+				this.assertActive();
+				const captured = captureFieldOccurrence(controller, path);
+				const child = new PluginFieldBinding(
+					controller,
+					() => captured.schema,
+					{ decodeValue: (value) => value },
+					schemaVersion,
+					this
+				);
+				this.onDestroy(child.destroy);
+				return child;
+			},
+		};
+	}
+	get stale() {
+		this.#resolve();
+		return this.#stale;
+	}
+	get schema() {
+		this.assertActive();
+		const schema = cloneSchemaField(this.getSchema());
+		return {
+			...schema,
+			path: this.#path,
+			admin: { ...schema.admin, readOnly: this.#isReadOnly() },
+		};
+	}
+	get rawValue() {
+		this.assertActive();
+		return cloneFormValue(this.controller.get(this.#path));
+	}
+	get value() {
+		const raw = this.rawValue;
+		const value =
+			raw === null || raw === undefined
+				? raw
+				: (this.registration.decodeFormValue ?? this.registration.decodeValue)(raw);
+		this.assertActive();
+		return copyValue(value);
+	}
+	get issues() {
+		this.assertActive();
+		return this.controller.issuesFor(this.#path).map((issue) => ({ ...issue }));
+	}
+	get liveValidation() {
+		if (this.stale) return { status: "idle" as const, retry: () => {} };
+		const feedback = this.controller.liveValidation.forField(this.#path);
+		return {
+			status: feedback.status,
+			retry: () => {
+				this.assertActive();
+				if (!this.readOnly) this.controller.liveValidation.flush(this.#path);
+			},
+		};
+	}
+
+	get readOnly() {
+		return this.controller.editingBlocked || this.#isReadOnly();
+	}
+	#isReadOnly() {
+		if (this.stale || (this.owner !== undefined && this.owner.#isReadOnly())) return true;
+		if (
+			this.#ancestors.some(({ schema, resolve }) => {
+				const path = resolve();
+				return (
+					path === undefined ||
+					schema.admin.readOnly === true ||
+					schema.admin.hidden === true ||
+					!this.controller.canRead(path, fieldAccessPath(schema)) ||
+					!this.controller.canWrite(path, fieldAccessPath(schema)) ||
+					(schema.admin.condition !== undefined &&
+						!evaluateFieldCondition(schema.admin.condition, path, (other) =>
+							this.controller.get(other)
+						))
+				);
+			})
+		)
+			return true;
+		const field = this.getSchema();
+		return (
+			field.admin.readOnly === true ||
+			field.admin.hidden === true ||
+			!this.controller.canRead(this.#path, fieldAccessPath(field)) ||
+			!this.controller.canWrite(this.#path, fieldAccessPath(field)) ||
+			(field.admin.condition !== undefined &&
+				!evaluateFieldCondition(field.admin.condition, this.#path, (path) =>
+					this.controller.get(path)
+				))
+		);
+	}
+	set = (value: unknown) => {
+		this.assertEditable();
+		if (value === undefined) throw new Error("Use null to clear a field value.");
+		const supplied = copyValue(value);
+		const decoded =
+			supplied === null
+				? null
+				: (this.registration.decodeInput ?? this.registration.decodeValue)(supplied);
+		// Decoders and getters are application code and may revoke the binding synchronously.
+		const detached = copyValue(decoded);
+		this.assertEditable();
+		const schema = { ...this.getSchema(), path: this.#path };
+		writePluginField(this.controller, schema, detached);
+	};
+	assertActive = () => {
+		if (this.stale)
+			throw new Error(
+				"This plugin field binding is stale. Use the current mounted field occurrence."
+			);
+	};
+	assertEditable = () => {
+		this.assertActive();
+		if (this.readOnly) throw new Error("This plugin field is read-only.");
+	};
+	onDestroy = (cleanup: () => void) => {
+		this.assertActive();
+		this.#cleanup.add(cleanup);
+		return () => {
+			this.#cleanup.delete(cleanup);
+		};
+	};
+	destroy = () => {
+		if (this.#stale) return;
+		this.#stale = true;
+		this.#stopPath();
+		this.#stopObserve();
+		this.#stopLifetime();
+		for (const cleanup of [...this.#cleanup]) cleanup();
+		this.#cleanup.clear();
+	};
+	#resolve() {
+		if (this.#stale) return;
+		if (
+			!this.controller.editorScopeActive ||
+			this.controller.editorEpoch !== this.#epoch ||
+			this.schemaVersion() !== this.#version ||
+			this.getSchema().id !== this.#schemaID ||
+			this.controller.contentLocale !== this.#locale ||
+			JSON.stringify(this.controller.resource) !== this.#resource
+		) {
+			this.destroy();
+			return;
+		}
+		const path = this.#resolvePath();
+		if (path === undefined) {
+			this.destroy();
+			return;
+		}
+		if (path !== this.#path) {
+			this.#stopPath();
+			this.#path = path;
+			this.#stopPath = this.controller.register(path);
+		}
+	}
+}
+
+/** Reject non-JSON mutable objects before they can enter the form (including decoder outputs). */
+function copyValue(value: unknown, seen = new Set<object>(), depth = 0): unknown {
+	if (depth > 100) throw new Error("Plugin value is too deeply nested.");
+	if (
+		value === null ||
+		value === undefined ||
+		typeof value === "string" ||
+		typeof value === "boolean"
+	)
+		return value;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (
+		typeof value !== "object" ||
+		seen.has(value) ||
+		(!Array.isArray(value) &&
+			Object.getPrototypeOf(value) !== Object.prototype &&
+			Object.getPrototypeOf(value) !== null)
+	)
+		throw new Error("Plugin values must be finite, acyclic JSON data.");
+	seen.add(value);
+	const result = Array.isArray(value)
+		? value.map((item) => copyValue(item, seen, depth + 1))
+		: Object.fromEntries(
+				Object.entries(value).map(([key, item]) => [key, copyValue(item, seen, depth + 1)])
+			);
+	seen.delete(value);
+	return result;
+}

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

@@ -0,0 +1,57 @@
+import type { SchemaField } from "@riducms/protocol";
+import type { FormController } from "@admin/core/forms/form-controller.svelte";
+import { indexFieldValues } from "@admin/core/forms/form-issue-correlation";
+import { fieldAccessPath } from "@admin/fields/nested/scoped-field";
+import { evaluateFieldCondition } from "@admin/core/forms/field-condition";
+
+/** Structural plugin writes use the same schema identity index as server issue correlation. */
+export function writePluginField(form: FormController, field: SchemaField, value: unknown) {
+	const before = indexFieldValues([field], { [field.name]: form.get(field.path) });
+	const after = indexFieldValues([field], { [field.name]: value });
+	const current = new Map(after.map((location) => [location.token, location]));
+	for (const source of before) {
+		const schema = source.schema,
+			target = current.get(source.token);
+		if (!schema || !target || JSON.stringify(source.value) === JSON.stringify(target.value))
+			continue;
+		if (
+			schema.admin.readOnly ||
+			schema.admin.hidden ||
+			!form.canRead(source.path, fieldAccessPath(schema)) ||
+			!form.canWrite(source.path, fieldAccessPath(schema)) ||
+			(schema.admin.condition !== undefined &&
+				!evaluateFieldCondition(schema.admin.condition, source.path, (path) => form.get(path)))
+		)
+			throw new Error(`Field ${source.path} is read-only.`);
+	}
+	if (form.access !== undefined) {
+		const previous = new Map(before.map((location) => [location.path, location]));
+		const fields: typeof form.access.fields = {};
+		for (const [path, access] of Object.entries(form.access.fields)) {
+			if (path !== field.path && !path.startsWith(`${field.path}.`)) {
+				fields[path] = access;
+				continue;
+			}
+			let prefix = path;
+			while (!previous.has(prefix) && prefix.includes("."))
+				prefix = prefix.slice(0, prefix.lastIndexOf("."));
+			const source = previous.get(prefix);
+			if (!source) {
+				fields[path] = access;
+				continue;
+			}
+			const target = current.get(source.token);
+			if (!target) continue;
+			const suffix = path.slice(source.path.length);
+			if (
+				/\.\d+(?:\.|$)/.test(suffix) &&
+				JSON.stringify(source.value) !== JSON.stringify(target.value)
+			)
+				continue;
+			fields[target.path + suffix] = access;
+		}
+		form.access = { ...form.access, fields };
+	}
+	if (field.plugin?.embeddedTrees !== undefined) form.setEmbedded(field, value, false);
+	else form.set(field.path, value);
+}

package/src/core/i18n/admin-i18n.svelte.ts

@@ -45,7 +45,8 @@ export class AdminI18nController implements AdminI18n {
 		private readonly client: AdminClient,
 		private readonly session: () => AuthSession<AdminDocument> | undefined,
 		catalogs: readonly TranslationLanguage[] = [en],
-		messages: Readonly<Record<string, PluginMessageCatalog>> = {}
+		messages: Readonly<Record<string, PluginMessageCatalog>> = {},
+		private readonly applicationMessages?: PluginMessageCatalog
 	) {
 		this.#catalogs = catalogs.length === 0 ? [en] : [...catalogs];
 		this.#catalogByCode = new Map(this.#catalogs.map((catalog) => [catalog.code, catalog]));
@@ -100,6 +101,9 @@ export class AdminI18nController implements AdminI18n {
 			fallbackLanguage: this.#fallbackLanguage,
 			...(this.#timeZone === undefined ? {} : { timeZone: this.#timeZone }),
 			pluginMessages: this.#messages,
+			...(this.applicationMessages === undefined
+				? {}
+				: { applicationMessages: this.applicationMessages }),
 		}));
 	}
 
@@ -167,6 +171,9 @@ export class AdminI18nController implements AdminI18n {
 			fallbackLanguage,
 			...(timeZone === undefined ? {} : { timeZone }),
 			pluginMessages: this.#messages,
+			...(this.applicationMessages === undefined
+				? {}
+				: { applicationMessages: this.applicationMessages }),
 		});
 
 		// Commit only after every catalog, direction, locale, and timezone validates.

package/src/core/i18n/localized-schema.ts

@@ -1,3 +1,4 @@
+import { mapBlockTypes } from "@riducms/protocol";
 import type { AdminI18n } from "@riducms/plugin";
 import type { SchemaCollection, SchemaField } from "@riducms/protocol";
 
@@ -35,9 +36,9 @@ export function localizeSchemaField(field: SchemaField, i18n: AdminI18n): Schema
 			: {
 					select: {
 						...field.select,
-						choices: field.select.choices.map((choice) => ({
-							...choice,
-							label: i18n.text(choice.label, choice.labelTranslations),
+						options: field.select.options.map((option) => ({
+							...option,
+							label: i18n.text(option.label, option.labelTranslations),
 						})),
 					},
 				}),
@@ -64,18 +65,40 @@ export function localizeSchemaField(field: SchemaField, i18n: AdminI18n): Schema
 								}),
 					},
 				}),
-		...(field.blocks === undefined
+		...(field.plugin?.embeddedTrees === undefined
 			? {}
 			: {
-					blocks: {
-						...field.blocks,
-						types: field.blocks.types.map((block) => ({
-							...block,
-							label: i18n.text(block.label, block.labelTranslations),
-							fields: block.fields.map((child) => localizeSchemaField(child, i18n)),
+					plugin: {
+						...field.plugin,
+						embeddedTrees: field.plugin.embeddedTrees.map((tree) => ({
+							...tree,
+							cases: tree.cases.map((branch) =>
+								mapBlockTypes(branch, (block) => ({
+									...block,
+									labels: {
+										...block.labels,
+										singular: i18n.text(block.labels.singular, block.labels.singularTranslations),
+										plural: i18n.text(block.labels.plural, block.labels.pluralTranslations),
+									},
+									fields: block.fields.map((child) => localizeSchemaField(child, i18n)),
+								}))
+							),
 						})),
 					},
 				}),
+		...(field.blocks === undefined
+			? {}
+			: {
+					blocks: mapBlockTypes(field.blocks, (block) => ({
+						...block,
+						labels: {
+							...block.labels,
+							singular: i18n.text(block.labels.singular, block.labels.singularTranslations),
+							plural: i18n.text(block.labels.plural, block.labels.pluralTranslations),
+						},
+						fields: block.fields.map((child) => localizeSchemaField(child, i18n)),
+					})),
+				}),
 	};
 }
 

package/src/core/plugins/field-registry.ts

@@ -1,60 +1,40 @@
-import type { FieldPlugin } from "@riducms/plugin";
-import type { SchemaField } from "@riducms/protocol";
+import { resolvePluginFields, type AdminPlugin, type ResolvedPluginField } from "@riducms/plugin";
+import type { FieldType, SchemaField } from "@riducms/protocol";
 
+interface FieldRenderer {
+	type: FieldType;
+	extension?: ResolvedPluginField;
+}
 export class FieldRegistry {
-	#plugins = new Map<string, FieldPlugin>();
-
-	register(plugin: FieldPlugin) {
-		const identity = pluginIdentity(plugin);
+	#plugins = new Map<string, FieldRenderer>();
+	register(plugin: ResolvedPluginField) {
+		const identity =
+			plugin.componentKey === undefined
+				? `plugin:${plugin.key}`
+				: `${plugin.registration.type}:${plugin.owner}:${plugin.key}`;
 		if (this.#plugins.has(identity))
-			throw new Error(`Field plugin ${identity} is already registered`);
-		this.#plugins.set(identity, plugin);
+			throw new Error(`Field renderer ${identity} is already registered.`);
+		this.#plugins.set(identity, { type: plugin.registration.type, extension: plugin });
 	}
-
-	resolve(field: SchemaField) {
+	resolve(field: SchemaField): FieldRenderer {
+		if (field.admin.editor !== undefined)
+			throw new Error(
+				`No local editor ${field.admin.editor.reference} is registered for ${field.path}.`
+			);
 		const component = field.admin.component;
+		if (component === undefined && field.type !== "plugin") return { type: field.type };
 		const identity =
-			component !== undefined
-				? `${field.type}:${component.plugin}:${component.component}`
-				: field.plugin === undefined
-					? field.type
-					: `${field.type}:${field.plugin.key}`;
-		const plugin = this.#plugins.get(identity);
-		if (plugin === undefined || !plugin.canRender(field)) {
-			throw new Error(`No admin field plugin can render ${field.path} (${identity})`);
-		}
-		return plugin;
+			component === undefined
+				? `plugin:${field.plugin?.key}`
+				: `${field.type}:${component.plugin}:${component.component}`;
+		const renderer = this.#plugins.get(identity);
+		if (!renderer)
+			throw new Error(`No admin field renderer can render ${field.path} (${identity}).`);
+		return renderer;
 	}
 }
-
-function pluginIdentity(plugin: FieldPlugin) {
-	if (plugin.componentKey !== undefined)
-		return `${plugin.type}:${plugin.key ?? "<missing>"}:${plugin.componentKey}`;
-	return plugin.key === undefined ? plugin.type : `${plugin.type}:${plugin.key}`;
-}
-
-export function createCoreFieldRegistry(plugins: readonly FieldPlugin[] = []): FieldRegistry {
+export function createCoreFieldRegistry(plugins: readonly AdminPlugin[] = []): FieldRegistry {
 	const registry = new FieldRegistry();
-	registry.register({ type: "text", canRender: (field) => field.text !== undefined });
-	registry.register({ type: "code", canRender: (field) => field.code !== undefined });
-	registry.register({ type: "select", canRender: (field) => field.select !== undefined });
-	registry.register({ type: "radio", canRender: (field) => field.select !== undefined });
-	registry.register({ type: "point", canRender: (field) => field.point !== undefined });
-	registry.register({ type: "ui", canRender: (field) => field.ui !== undefined });
-	registry.register({ type: "join", canRender: (field) => field.join !== undefined });
-	registry.register({ type: "virtual", canRender: (field) => field.virtual !== undefined });
-	for (const type of ["textarea", "email", "date", "number", "checkbox", "json"] as const) {
-		registry.register({ type, canRender: () => true });
-	}
-	for (const type of ["group", "array"] as const) {
-		registry.register({ type, canRender: (field) => field.nested !== undefined });
-	}
-	registry.register({ type: "blocks", canRender: (field) => field.blocks !== undefined });
-	registry.register({
-		type: "relationship",
-		canRender: (field) => field.relationship !== undefined,
-	});
-	registry.register({ type: "upload", canRender: (field) => field.upload !== undefined });
-	for (const plugin of plugins) registry.register(plugin);
+	for (const field of resolvePluginFields(plugins)) registry.register(field);
 	return registry;
 }