@riducms/plugin 0.2.3 → 0.4.0

package/src/admin-extensions/views.ts

@@ -0,0 +1,145 @@
+import type { SchemaCollection, SchemaGlobal } from "@riducms/protocol";
+import type { Component, Snippet } from "svelte";
+
+import type { FieldDocument } from "../authoring";
+import type { AdminI18n, ExtensionTranslationKey } from "../i18n";
+import type {
+	AdminExtensionNotificationTone,
+	AdminExtensionProps,
+	AdminViewComponent,
+} from "./shared";
+
+/** Sign-in operations provided to a custom login screen. */
+export interface AdminLoginExtensionHost {
+	/** Sign in, check admin access and enter the admin. Rejects if authentication/access fails. */
+	login: (credentials: { email: string; password: string }) => Promise<void>;
+	/** Show a temporary success or error message. Does not perform an operation itself. */
+	notify: (tone: AdminExtensionNotificationTone, title: string, message?: string) => void;
+}
+
+export interface AdminLoginComponentProps extends AdminExtensionProps {
+	/** Render with `{@render defaultView()}` to keep Ridu's sign-in screen inside your wrapper. */
+	defaultView: Snippet;
+	host: AdminLoginExtensionHost;
+}
+
+/** Add content before/after sign-in, or replace it with a custom screen. */
+export interface AdminLoginComponent {
+	key: string;
+	component: Component<AdminLoginComponentProps>;
+	/** Defaults to after. Only one replace entry is allowed across plugins and the application. */
+	position?: "before" | "after" | "replace";
+}
+
+export type AdminAccountSurface = "profile" | "security";
+
+/** Operations for keeping a custom account screen in sync with the signed-in session. */
+export interface AdminAccountExtensionHost {
+	/** Reloads the signed-in document and updates the shell identity. */
+	refreshUser: () => Promise<FieldDocument | undefined>;
+	/** Ends the current session and returns to sign-in. */
+	logout: () => Promise<void>;
+	/** Show a temporary success or error message. */
+	notify: (tone: AdminExtensionNotificationTone, title: string, message?: string) => void;
+}
+
+export interface AdminAccountComponentProps extends AdminExtensionProps {
+	surface: AdminAccountSurface;
+	/** Render with `{@render defaultView()}` to keep Ridu's account screen inside your wrapper. */
+	defaultView: Snippet;
+	host: AdminAccountExtensionHost;
+}
+
+/** Add to or replace the profile/security screen identified by `surface`. */
+export interface AdminAccountComponent {
+	key: string;
+	surface: AdminAccountSurface;
+	component: Component<AdminAccountComponentProps>;
+	/** Defaults to after. Each account surface permits at most one replacement. */
+	position?: "before" | "after" | "replace";
+}
+
+export type AdminCoreViewSurface =
+	"collectionList" | "collectionCreate" | "collectionEdit" | "global" | "notFound";
+
+/** Refresh tools for a custom collection/global screen. They do not save documents. */
+export interface AdminCoreViewHost {
+	/** Fetch the current Go schema again and update the admin's schema-dependent UI. */
+	refreshManifest: () => Promise<void>;
+	/** Notify Ridu that your code changed documents so dependent lists/lookups can refresh. */
+	documentsChanged: () => void;
+	/** Show a temporary success or error message. */
+	notify: (tone: AdminExtensionNotificationTone, title: string, message?: string) => void;
+}
+
+export interface AdminCoreViewProps extends AdminExtensionProps {
+	surface: AdminCoreViewSurface;
+	collection?: SchemaCollection;
+	global?: SchemaGlobal;
+	documentID?: string;
+	/** Render with `{@render defaultView()}` to wrap the normal screen rather than rebuilding it. */
+	defaultView: Snippet;
+	host: AdminCoreViewHost;
+}
+
+interface AdminCollectionCoreView {
+	key: string;
+	surface: "collectionList" | "collectionCreate" | "collectionEdit";
+	/** Omit to replace this surface for every collection. */
+	collection?: string;
+}
+
+interface AdminGlobalCoreView {
+	key: string;
+	surface: "global";
+	/** Omit to replace this surface for every global. */
+	global?: string;
+}
+
+interface AdminNotFoundCoreView {
+	key: string;
+	surface: "notFound";
+}
+
+/**
+ * Replace a collection/global/not-found screen. A resource-specific registration
+ * wins over an all-resources fallback for that surface; duplicate targets fail.
+ * The supplied `defaultView` lets your component wrap the existing screen.
+ */
+export type AdminCoreView = (
+	AdminCollectionCoreView | AdminGlobalCoreView | AdminNotFoundCoreView
+) &
+	AdminViewComponent<AdminCoreViewProps>;
+
+export interface AdminDashboardPanelProps {
+	manifest: AdminExtensionProps["manifest"];
+	user?: FieldDocument;
+	i18n: AdminI18n;
+}
+
+/** Add dashboard content before/after Ridu's overview, or replace that overview. */
+interface AdminDashboardPanelRegistration {
+	/** Unique name among dashboard entries; duplicates throw. Array order controls display order. */
+	key: string;
+	/** Defaults to after. Replace hides Ridu's overview and may only be registered once. */
+	position?: "before" | "after" | "replace";
+}
+
+export type AdminDashboardPanel = AdminDashboardPanelRegistration &
+	AdminViewComponent<AdminDashboardPanelProps>;
+
+export interface AdminRouteNavigation {
+	/** Human-readable navigation label inside the authenticated admin shell. */
+	label: string;
+	labelKey?: ExtensionTranslationKey;
+	/** Optional grouping hint reserved for shells that render grouped plugin navigation. */
+	group?: string;
+}
+
+/** One statically bundled route mounted beneath the authenticated admin layout. */
+export type AdminRoute = {
+	/** Relative admin path, without a leading slash. Paired plugins must match their Go descriptor. */
+	path: string;
+	/** Optional navigation entry; omit it for a route reachable only by links or redirects. */
+	navigation?: AdminRouteNavigation;
+} & AdminViewComponent<AdminExtensionProps>;

package/src/admin.ts

@@ -27,7 +27,7 @@ import {
 /**
  * Settings for your application's admin, exported from `admin/src/admin.config.ts`.
  * Register your custom components here. Keep `generatedAdminPlugins` in `plugins`
- * to load installed plugins such as rich text. Use `fields` to replace inputs for
+ * to load installed plugins such as rich text. Use `fieldEditors` to replace inputs for
  * text, textarea, email, date, code, number and checkbox fields.
  */
 export interface AdminConfig extends AdminContributions, FieldEditorConfig {
@@ -46,8 +46,8 @@ export interface AdminConfig extends AdminContributions, FieldEditorConfig {
  *
  * Export the result as the default export of `admin/src/admin.config.ts`. Keep
  * `plugins: generatedAdminPlugins` to load installed packages such as rich text.
- * Add `fields` for inputs made with `defineFieldEditor`, `rowLabels` for headings
- * made with `defineRowLabel`, or options such as `dashboard`, `routes`, and
+ * Add `fieldEditors` for inputs made with `defineFieldEditor`, `rowLabels` for headings
+ * made with `defineRowLabel`, or options such as `dashboardPanels`, `routes`, and
  * `documentActions` for other parts of the admin. All options are optional.
  *
  * Application field and row-label keys use `app:name`; select the same key in Go
@@ -70,7 +70,7 @@ export interface AdminConfig extends AdminContributions, FieldEditorConfig {
  *
  * export default defineAdmin({
  *   plugins: generatedAdminPlugins,
- *   dashboard: [{ key: 'welcome', component: WelcomePanel, position: 'before' }]
+ *   dashboardPanels: [{ key: 'welcome', component: WelcomePanel, position: 'before' }]
  * });
  * ```
  */
@@ -81,8 +81,8 @@ export function defineAdmin(config: AdminConfig): AdminConfig {
 /** Static configuration owned by one mounted admin. Changes require remount/HMR. */
 export interface ResolvedAdminConfig {
 	readonly plugins: readonly AdminPlugin[];
-	readonly fields: readonly ResolvedPluginField[];
-	readonly editors: NonNullable<AdminConfig["fields"]>;
+	readonly pluginFields: readonly ResolvedPluginField[];
+	readonly fieldEditors: NonNullable<AdminConfig["fieldEditors"]>;
 	readonly rowLabels: NonNullable<AdminConfig["rowLabels"]>;
 	readonly languages: readonly TranslationLanguage[];
 	readonly extensions: Readonly<ResolvedAdminExtensions>;
@@ -102,8 +102,8 @@ export function resolveAdminConfig(config: AdminConfig = {}): ResolvedAdminConfi
 	const plugins = Object.freeze([...(config.plugins ?? [])]);
 	return Object.freeze({
 		plugins,
-		fields: resolvePluginFields(plugins),
-		editors: Object.freeze({ ...config.fields }),
+		pluginFields: resolvePluginFields(plugins),
+		fieldEditors: Object.freeze({ ...config.fieldEditors }),
 		rowLabels: Object.freeze({ ...config.rowLabels }),
 		languages: Object.freeze(config.languages?.length ? [...config.languages] : [en]),
 		extensions: Object.freeze(resolveAdminExtensions(plugins, config)),
@@ -120,22 +120,22 @@ export function resolveAdminConfig(config: AdminConfig = {}): ResolvedAdminConfi
 export function validateAdminManifest(
 	config: ResolvedAdminConfig,
 	manifest: Pick<SchemaManifest, "collections" | "globals" | "blocks"> &
-		Partial<Pick<SchemaManifest, "plugins">>,
+		Partial<Pick<SchemaManifest, "plugins" | "application">>,
 	options: { completeManifest?: boolean } = {}
 ): void {
 	validateManifestPluginPairs(
 		config.plugins,
-		config.fields,
+		config.pluginFields,
 		manifest,
 		options.completeManifest === true
 	);
-	const validatePluginField = createPluginFieldValidator(config.fields);
+	const validatePluginField = createPluginFieldValidator(config.pluginFields);
 	const failures: string[] = [];
 	bindSchemaManifest(manifest);
 	const inspect = (fields: readonly SchemaField[], owner: string) => {
 		for (const field of fields) {
 			try {
-				validateFieldEditorSelection(config.editors, field);
+				validateFieldEditorSelection(config.fieldEditors, field);
 				validatePluginField(field);
 				const selection = field.nested?.rowLabelComponent;
 				if (selection?.reference !== undefined) {
@@ -174,14 +174,46 @@ export function validateAdminManifest(
 	const collections = new Map(manifest.collections.map((item) => [item.slug, item]));
 	const globals = new Set((manifest.globals ?? []).map((item) => item.slug));
 	const extensions = config.extensions;
-	for (const cell of extensions.listCells) {
+
+	// Loader keys may be reused by several views, but every reference must carry the
+	// exact generated contract for the compiled Go loader. This rejects stale or
+	// hand-authored TypeScript contracts before the view can request data.
+	for (const view of [
+		...extensions.dashboardPanels,
+		...extensions.routes,
+		...extensions.coreViews,
+	]) {
+		if (view.loader === undefined) continue;
+		const contract = manifest.application?.adminLoaders?.find(
+			(loader) => loader.key === view.loader.key
+		);
+		if (contract === undefined || JSON.stringify(contract) !== JSON.stringify(view.loader.contract))
+			throw new Error(
+				`Admin view ${"key" in view ? view.key : view.path} requires a matching generated Go loader; run ridu generate.`
+			);
+	}
+	for (const results of extensions.listResultsRenderers) {
+		if (!collections.has(results.collection))
+			throw new Error(
+				`Admin list results ${results.key} selects unknown collection ${results.collection}.`
+			);
+		if (
+			extensions.coreViews.some(
+				(view) =>
+					view.surface === "collectionList" &&
+					(view.collection === undefined || view.collection === results.collection)
+			)
+		)
+			throw new Error(`Admin list results ${results.key} targets a replaced collection view.`);
+	}
+	for (const cell of extensions.listCellRenderers) {
 		const collection = collections.get(cell.collection);
 		if (!collection?.fields.some((field) => field.name === cell.field || field.path === cell.field))
 			throw new Error(
 				`Admin list cell ${cell.key} selects unknown field ${cell.collection}.${cell.field}.`
 			);
 	}
-	for (const view of extensions.views) {
+	for (const view of extensions.coreViews) {
 		if ("collection" in view && view.collection !== undefined && !collections.has(view.collection))
 			throw new Error(`Admin core view ${view.key} selects unknown collection ${view.collection}.`);
 		if ("global" in view && view.global !== undefined && !globals.has(view.global))

package/src/authoring/v1.ts

@@ -26,7 +26,7 @@ const authoringAPIVersion = 1;
  *
  * Use `fields` for the default editors of new Go field types. Each map key matches
  * a Go `PluginFieldType.Key`, and each value is returned by `definePluginField`.
- * Use `components` for alternative editors made with `defineFieldComponent`,
+ * Use `fieldEditors` for alternative editors made with `defineFieldComponent`,
  * selected explicitly in Go with `field.PluginComponent`. The other options add
  * pages, dashboard panels, navigation, and the UI described by `AdminContributions`.
  *
@@ -60,9 +60,9 @@ export function defineAdminPlugin<const Plugin extends Omit<AdminPlugin, "apiVer
 	const result = Object.freeze({
 		...plugin,
 		...(plugin.fields === undefined ? {} : { fields: Object.freeze({ ...plugin.fields }) }),
-		...(plugin.components === undefined
+		...(plugin.fieldEditors === undefined
 			? {}
-			: { components: Object.freeze({ ...plugin.components }) }),
+			: { fieldEditors: Object.freeze({ ...plugin.fieldEditors }) }),
 		apiVersion: authoringAPIVersion,
 	});
 	const definition: Omit<AdminPlugin, "apiVersion"> = plugin;

package/src/authoring.ts

@@ -41,6 +41,11 @@ export interface FieldReferenceBrowserProps {
 	field: SchemaField;
 	/** The target collection's resolved schema, available from `authoring.collections`. */
 	collection: SchemaCollection;
+	/**
+	 * Optional collection choices. Only readable collections are offered; switching clears the
+	 * current list query and uncommitted selection.
+	 */
+	collections?: readonly SchemaCollection[];
 	/** Allow multiple selections when true; otherwise select at most one document. */
 	hasMany: boolean;
 	/** IDs currently selected by your editor. */
@@ -51,8 +56,20 @@ export interface FieldReferenceBrowserProps {
 	initialDocument?: FieldDocument;
 	/** Fetch and open this document when `initialDocument` is not supplied. */
 	initialDocumentID?: string;
-	/** Limit selectable documents; the server still applies its own access rules. */
-	optionFilter?: FieldReferenceFilter | readonly FieldReferenceFilter[];
+	/** Open a new document form immediately when creation is permitted. */
+	initialCreate?: boolean;
+	/** File dropped into an upload field; opens a new metadata form before any upload is saved. */
+	initialFile?: File;
+	/**
+	 * Limit selectable documents; the server still applies its own access rules. A static filter
+	 * applies to every collection. Use a resolver when collection schemas need different fields.
+	 */
+	optionFilter?:
+		| FieldReferenceFilter
+		| readonly FieldReferenceFilter[]
+		| ((
+				collection: SchemaCollection
+		  ) => FieldReferenceFilter | readonly FieldReferenceFilter[] | undefined);
 	/** Initial values for a new related document, not changes to an existing document. */
 	defaultValues?: Readonly<Record<string, unknown>>;
 	/** Allow creation when access permits it. Set false to hide creation. */
@@ -60,12 +77,12 @@ export interface FieldReferenceBrowserProps {
 	/** Content locale for loading and editing related documents. */
 	locale?: string;
 	/**
-	 * Called when the user confirms the selection. Update your field here.
+	 * Called with selected IDs and their collection slug. Update your field here.
 	 * Return false (or resolve to false) to keep the browser open. Returning void or
 	 * true accepts the selection and closes it while editing remains allowed. A thrown
 	 * error/rejected promise keeps it open and Ridu displays an error notification.
 	 */
-	onCommit: (ids: string[]) => void | boolean | Promise<void | boolean>;
+	onCommit: (ids: string[], collectionSlug: string) => void | boolean | Promise<void | boolean>;
 	/** Called when the browser closes; update your open/closed UI state here. */
 	onClose: () => void;
 }
@@ -206,6 +223,12 @@ export interface FieldAuthoringHost {
 	readonly documentRevision: number;
 	/** The content locale being edited, separate from the admin interface language. */
 	readonly locale?: string;
+	/**
+	 * Whether the current admin session may create documents in this collection.
+	 * This is a presentation hint for create controls, not authorization. Access is
+	 * checked again by the reference browser and operation engine when work is saved.
+	 */
+	canCreateDocument(collection: string): boolean;
 	/** Related-document picker/editor component. Its `onCommit` handler updates your field. */
 	referenceBrowser: Component<FieldReferenceBrowserProps>;
 	/**

package/src/editor/registry.ts

@@ -37,7 +37,7 @@ export type FieldEditorDefinition<Type extends FieldEditorType, Config = undefin
 
 const registration = Symbol("ridu-field-editor");
 const registeredEditors = new WeakSet<RegisteredFieldEditor>();
-/** Registration returned by `defineFieldEditor`; store it in `defineAdmin({ fields: ... })`. */
+/** Registration returned by `defineFieldEditor`; store it in `defineAdmin({ fieldEditors: ... })`. */
 export interface RegisteredFieldEditor {
 	readonly [registration]: true;
 	readonly type: FieldEditorType;
@@ -51,7 +51,7 @@ export interface RegisteredFieldEditor {
  * Register a Svelte component to replace a field input in your application.
  * Supports text, textarea, email, date, code, number, checkbox, text-list and number-list fields.
  *
- * Put the result under an `app:name` key in `defineAdmin({ fields: ... })` and
+ * Put the result under an `app:name` key in `defineAdmin({ fieldEditors: ... })` and
  * select that same key in Go with `field.Admin{Editor: field.Component("app:name")}`. The Go field keeps
  * its original storage, validation and filtering behaviour.
  *
@@ -67,7 +67,7 @@ export interface RegisteredFieldEditor {
  * TypeScript infers the `Config` type from the decoder's return value.
  *
  * @param definition The existing field type, Svelte component, and optional settings decoder.
- * @returns A frozen registration for `defineAdmin`'s `fields` map. This does not
+ * @returns A frozen registration for `defineAdmin`'s `fieldEditors` map. This does not
  * render the component, select it on a Go field, or change the stored value type.
  * @throws If the type is unsupported or the component is invalid. `ridu check`
  * also checks the selected Go field type and its settings before deployment.
@@ -80,7 +80,7 @@ export interface RegisteredFieldEditor {
  *
  * export default defineAdmin({
  *   plugins: generatedAdminPlugins,
- *   fields: {
+ *   fieldEditors: {
  *     'app:titleCounter': defineFieldEditor({ type: 'text', component: TitleField })
  *   }
  * });
@@ -117,12 +117,12 @@ export function defineFieldEditor<const Type extends FieldEditorType, Config = u
 
 export interface FieldEditorConfig {
 	/** Custom field inputs selected by Go `field.Admin{Editor: field.Component("app:name")}`. Use `defineFieldEditor` for each entry. */
-	fields?: Readonly<Record<`app:${string}`, RegisteredFieldEditor>>;
+	fieldEditors?: Readonly<Record<`app:${string}`, RegisteredFieldEditor>>;
 }
 
 /** The application owns one static configuration; packaged plugins retain their pairing contracts. */
 export function validateFieldEditorRegistrations(config: FieldEditorConfig): void {
-	for (const [reference, editor] of Object.entries(config.fields ?? {})) {
+	for (const [reference, editor] of Object.entries(config.fieldEditors ?? {})) {
 		if (!localEditorReference.test(reference))
 			throw new Error(
 				`Invalid editor reference ${reference}; expected app:name in admin/src/admin.config.ts.`
@@ -134,14 +134,14 @@ export function validateFieldEditorRegistrations(config: FieldEditorConfig): voi
 
 /** Check one local selection using the same decoder as the mounted editor. */
 export function validateFieldEditorSelection(
-	editors: NonNullable<FieldEditorConfig["fields"]>,
+	fieldEditors: NonNullable<FieldEditorConfig["fieldEditors"]>,
 	field: SchemaField
 ): void {
 	const reference = field.admin.editor?.reference;
 	if (reference === undefined) return;
 	if (!localEditorReference.test(reference))
 		throw new Error(`Malformed editor reference ${reference}; expected app:name.`);
-	const editor = editors[reference as `app:${string}`];
+	const editor = fieldEditors[reference as `app:${string}`];
 	if (editor === undefined)
 		throw new Error(
 			`Editor ${reference} is not registered. Register it in admin/src/admin.config.ts or change the field component in Go.`

package/src/editor/types.ts

@@ -95,7 +95,7 @@ export type FieldEditorProps<Type extends FieldEditorType = FieldEditorType, Con
 	 */
 	authoring: Pick<
 		FieldAuthoringHost,
-		"collections" | "documentRevision" | "referenceBrowser" | "findDocument"
+		"collections" | "documentRevision" | "canCreateDocument" | "referenceBrowser" | "findDocument"
 	> & { readonly locale: string | undefined };
 } & ([Config] extends [undefined]
 	? { config?: never }

package/src/field.ts

@@ -299,7 +299,7 @@ type NamedFieldTarget<Type extends FieldType, Key extends string> = Type extends
 /**
  * Register a plugin component that can replace an existing field's editor.
  *
- * Put the result in `defineAdminPlugin({ components: { colorSwatch: ... } })`.
+ * Put the result in `defineAdminPlugin({ fieldEditors: { colorSwatch: ... } })`.
  * Go selects that name through `field.PluginComponent(pluginKey, "colorSwatch")`
  * in the field's `Admin.Editor` setting. This changes the input while keeping
  * the original Go field's storage, validation, permissions, and generated types.
@@ -319,7 +319,7 @@ type NamedFieldTarget<Type extends FieldType, Key extends string> = Type extends
  * errors for invalid input. Go still validates the document when it is saved.
  *
  * @param definition The existing field type, component, and value/settings decoders.
- * @returns A frozen registration for the plugin's `components` map. It preserves
+ * @returns A frozen registration for the plugin's `fieldEditors` map. It preserves
  * the selected field type and inferred value/input types; it does not create a new field type.
  * @throws If the field type, component, decoders, or plugin field-type selection are invalid.
  * @example
@@ -330,7 +330,7 @@ type NamedFieldTarget<Type extends FieldType, Key extends string> = Type extends
  * export const editorialAdminPlugin = defineAdminPlugin({
  *   key: 'editorial-tools',
  *   pairingVersion: 1,
- *   components: {
+ *   fieldEditors: {
  *     colorSwatch: defineFieldComponent({
  *       type: 'text',
  *       component: ColorSwatch,
@@ -359,7 +359,7 @@ export function defineFieldComponent<
 		}
 ): PluginFieldRegistration<Value, Input, Type> & NamedFieldTarget<Type, Key>;
 /**
- * Name an alternative editor in your paired plugin's `components` map. Go selects
+ * Name an alternative editor in your paired plugin's `fieldEditors` map. Go selects
  * it with `.Admin(field.Admin{Editor: field.PluginComponent(pluginKey, componentName, config)})`. Set `type` to
  * the actual field type; also supply `fieldType` for plugin values. `decodeValue`
  * checks reads/writes and `decodeConfig` checks settings, synchronously. Changing
@@ -379,7 +379,7 @@ export function defineFieldComponent<
 		}
 ): PluginFieldRegistration<Value, Value, Type> & NamedFieldTarget<Type, Key>;
 /**
- * Name an alternative editor without settings in your plugin's `components` map.
+ * Name an alternative editor without settings in your plugin's `fieldEditors` map.
  * Go selects it with `field.Admin.Editor`. Set the actual schema `type`, plus
  * `fieldType` for plugin values. Supply synchronous `decodeValue` and `decodeInput`
  * for different saved/write shapes. Omit the Go settings argument; no config prop is
@@ -400,7 +400,7 @@ export function defineFieldComponent<
 		}
 ): PluginFieldRegistration<Value, Input, Type> & NamedFieldTarget<Type, Key>;
 /**
- * Name an alternative editor without settings in your plugin's `components` map.
+ * Name an alternative editor without settings in your plugin's `fieldEditors` map.
  * Go selects it with `field.Admin.Editor`. Set the actual schema `type`, plus
  * `fieldType` for plugin values. `decodeValue` synchronously checks reads/writes.
  * Omit the Go settings argument; no config prop is passed. Any supplied component
@@ -463,10 +463,10 @@ function createRegistration(
 		blocks: true,
 		plugin: true,
 	};
-	if (!Object.hasOwn(supported, type)) throw new Error(`Unsupported field renderer type ${type}.`);
+	if (!Object.hasOwn(supported, type)) throw new Error(`Unsupported field editor type ${type}.`);
 	if ("canRender" in definition || "key" in definition || "componentKey" in definition)
 		throw new Error(
-			"Renderer matching comes from its keyed registration; key/canRender/componentKey are not supported."
+			"Field editor matching comes from its keyed registration; key/canRender/componentKey are not supported."
 		);
 	if (
 		typeof definition.component !== "function" ||

package/src/index.ts

@@ -42,6 +42,9 @@ export {
 	type AdminContributions,
 	type AdminDashboardPanel,
 	type AdminDashboardPanelProps,
+	type AdminLoaderProps,
+	type AdminViewComponent,
+	withAdminLoader,
 	type AdminExtensionProps,
 	type AdminLoginComponent,
 	type AdminLoginComponentProps,
@@ -63,9 +66,9 @@ export {
 	type AdminBrandComponent,
 	type AdminBrandComponentProps,
 	type AdminBrandSurface,
-	type AdminShellComponent,
-	type AdminShellComponentProps,
-	type AdminShellPosition,
+	type AdminShellSlot,
+	type AdminShellSlotProps,
+	type AdminShellSlotPosition,
 	type AdminProvider,
 	type AdminProviderProps,
 	type AdminDocumentAction,
@@ -73,8 +76,11 @@ export {
 	type AdminDocumentExtensionProps,
 	type AdminDocumentView,
 	type AdminExtensionNotificationTone,
-	type AdminListCell,
-	type AdminListCellProps,
+	type AdminListCellRenderer,
+	type AdminListCellRendererProps,
+	type AdminCollectionList,
+	type AdminListResultsRenderer,
+	type AdminListResultsRendererProps,
 	type AdminRouteNavigation,
 	type AdminPluginPair,
 	type AdminRoute,

package/src/plugin-registry.ts

@@ -8,14 +8,14 @@ export interface ResolvedPluginField {
 	readonly owner: string;
 	/** Field-type key for a default editor, or component name for an explicitly selected editor. */
 	readonly key: string;
-	/** Present only for editors registered in `components` and selected by Go `AdminComponent`. */
+	/** Present only for editors registered in `fieldEditors` and selected by Go `AdminComponent`. */
 	readonly componentKey?: string;
 	readonly registration: RegisteredPluginField;
 }
 
 /**
  * Collect field registrations, checking plugin IDs, field-type ownership, named
- * components and API versions. Throws on malformed/duplicate registrations.
+ * field editors and API versions. Throws on malformed/duplicate registrations.
  * Used by Ridu's runtime/check tooling; authors normally call the registration
  * helpers and retain their generated plugin list instead of invoking this directly.
  */
@@ -37,7 +37,7 @@ export function resolvePluginFields(
 		owners.add(plugin.key);
 		for (const [kind, entries] of [
 			["fields", plugin.fields],
-			["components", plugin.components],
+			["fieldEditors", plugin.fieldEditors],
 		] as const) {
 			if (entries === undefined) continue;
 			if (
@@ -63,15 +63,14 @@ export function resolvePluginFields(
 				)
 					throw new Error(`Plugin ${plugin.key} ${kind}.${key} uses the wrong registration kind.`);
 				const identity = kind === "fields" ? `field:${key}` : `component:${plugin.key}:${key}`;
-				if (identities.has(identity))
-					throw new Error(`Duplicate admin field renderer ${identity}.`);
+				if (identities.has(identity)) throw new Error(`Duplicate admin field editor ${identity}.`);
 				identities.add(identity);
 				resolved.push(
 					Object.freeze({
 						owner: plugin.key,
 						key,
 						registration,
-						...(kind === "components" ? { componentKey: key } : {}),
+						...(kind === "fieldEditors" ? { componentKey: key } : {}),
 					})
 				);
 			}
@@ -89,7 +88,7 @@ export function validateManifestPluginPairs(
 	complete: boolean
 ): void {
 	// Startup may receive only public or access-filtered schemas. Build/check own
-	// completeness; selected fields below still validate their exact renderer.
+	// completeness; selected fields below still validate their exact editor.
 	if (complete && manifest.plugins !== undefined)
 		for (const item of registrations) {
 			if (
@@ -99,7 +98,7 @@ export function validateManifestPluginPairs(
 				)
 			)
 				throw new Error(
-					`Named renderer ${item.owner}:${item.key} selects undeclared field type ${item.registration.fieldType}.`
+					`Named field editor ${item.owner}:${item.key} selects undeclared field type ${item.registration.fieldType}.`
 				);
 		}
 	if (manifest.plugins !== undefined) {
@@ -136,7 +135,7 @@ export function createPluginFieldValidator(registrations: readonly ResolvedPlugi
 	const fields = new Map(
 		registrations.filter((item) => item.componentKey === undefined).map((item) => [item.key, item])
 	);
-	const components = new Map(
+	const fieldEditors = new Map(
 		registrations
 			.filter((item) => item.componentKey !== undefined)
 			.map((item) => [`${item.owner}:${item.key}`, item])
@@ -145,14 +144,14 @@ export function createPluginFieldValidator(registrations: readonly ResolvedPlugi
 		const selection = field.admin.component;
 		const selected =
 			selection !== undefined
-				? components.get(`${selection.plugin}:${selection.component}`)
+				? fieldEditors.get(`${selection.plugin}:${selection.component}`)
 				: field.type === "plugin"
 					? fields.get(field.plugin?.key ?? "")
 					: undefined;
 		if (selection !== undefined || field.type === "plugin") {
 			if (selected === undefined)
 				throw new Error(
-					`Missing renderer for ${selection !== undefined ? `${selection.plugin}:${selection.component}` : field.plugin?.key}.`
+					`Missing field editor for ${selection !== undefined ? `${selection.plugin}:${selection.component}` : field.plugin?.key}.`
 				);
 			selected.registration.decodeConfig(field);
 		}