@conduction/nextcloud-vue 1.0.0-beta.17 → 1.0.0-beta.19

package/src/components/CnIndexPage/CnIndexPage.vue

@@ -215,7 +215,7 @@
 							<CnRowActions
 								:actions="mergedActions"
 								:row="row"
-								@action="$emit('action', $event)" />
+								@action="onRowAction" />
 						</slot>
 					</template>
 				</CnDataTable>
@@ -257,7 +257,7 @@
 							<CnRowActions
 								:actions="mergedActions"
 								:row="object"
-								@action="$emit('action', $event)" />
+								@action="onRowAction" />
 						</slot>
 					</template>
 				</CnCardGrid>
@@ -267,7 +267,7 @@
 					:open.sync="contextMenuOpen"
 					:actions="mergedActions"
 					:target-item="contextMenuRow"
-					@action="$emit('action', $event)"
+					@action="onRowAction"
 					@close="closeContextMenu" />
 
 				<!-- Pagination -->
@@ -433,14 +433,20 @@ export default {
 		CnIndexSidebar,
 	},
 
+	/**
+	 * Inject the customComponents registry from a CnAppRoot ancestor.
+	 * Used by:
+	 * - REQ-MAD-3 / REQ-MAD-8 (manifest-actions-dispatch): resolves
+	 *   `actions[].handler` registry names to functions called on
+	 *   row-action click.
+	 * - The cardComponent + form-dialog override paths: when set, the
+	 *   prop-level `customComponents` wins, but the inject is the
+	 *   default. See `effectiveCustomComponents`.
+	 *
+	 * Falls back to an empty object so `CnIndexPage` works standalone
+	 * (unit tests, isolated mount) without `CnAppRoot`.
+	 */
 	inject: {
-		/**
-		 * Custom-component registry provided by `CnAppRoot`. Falls back
-		 * to an empty object so `CnIndexPage` works when mounted
-		 * without `CnAppRoot` (e.g. in unit tests). The explicit
-		 * `customComponents` prop wins when set — see
-		 * `effectiveCustomComponents`.
-		 */
 		cnCustomComponents: { default: () => ({}) },
 	},
 
@@ -783,6 +789,11 @@ export default {
 		 * `cnCustomComponents`. Provided primarily so unit tests can
 		 * pass a registry without mounting `CnAppRoot`.
 		 *
+		 * Used by:
+		 * - `cardComponent` resolution (REQ-MCI from manifest-card-index)
+		 * - `actions[].handler` registry name resolution (REQ-MAD-3 from
+		 *   manifest-actions-dispatch — handler funcs called on row-action click)
+		 *
 		 * @type {object|null}
 		 */
 		customComponents: {
@@ -887,9 +898,56 @@ export default {
 			return builtIn
 		},
 
-		/** Merged actions: app-provided first, then built-in defaults */
+		/**
+		 * Effective customComponents registry — explicit prop wins over
+		 * the injected ancestor registry. Used to:
+		 * - Resolve `actions[].handler` registry names (REQ-MAD-3,
+		 *   manifest-actions-dispatch).
+		 * - Resolve the `cardComponent` name for card-grid view (REQ-MCI,
+		 *   manifest-card-index).
+		 *
+		 * @return {object}
+		 */
+		effectiveCustomComponents() {
+			return this.customComponents ?? this.cnCustomComponents ?? {}
+		},
+
+		/**
+		 * Merged actions: app-provided first, then built-in defaults.
+		 *
+		 * REQ-MAD-3 / REQ-MAD-4 / REQ-MAD-5 / REQ-MAD-6 / REQ-MAD-7
+		 * (manifest-actions-dispatch) — for any action whose `handler`
+		 * is a string, resolve it through `resolveHandler()` so
+		 * `CnRowActions` sees the same `{ handler: fn }` shape it does
+		 * for built-in defaults. Function-typed handlers (the existing
+		 * runtime path) pass through untouched.
+		 */
 		mergedActions() {
-			return [...this.actions, ...this.defaultActions]
+			const dispatched = this.actions.map((action) => {
+				if (typeof action.handler === 'function') {
+					// Back-compat: programmatic function handler — keep as-is.
+					return action
+				}
+				if (typeof action.handler !== 'string' || action.handler.length === 0) {
+					// No handler → emit-only path (existing default).
+					return action
+				}
+				const isNone = action.handler === 'none'
+				const resolved = this.resolveHandler(action)
+				if (resolved) {
+					// `none` returns a sentinel no-op handler AND must
+					// suppress the `@action` emit; flag it so onRowAction
+					// can drop the bubbled event.
+					return isNone
+						? { ...action, handler: resolved, _dispatchSuppress: true }
+						: { ...action, handler: resolved }
+				}
+				// Either reserved keyword "emit" / unknown name / non-function
+				// registry entry → page emits @action only; no handler call.
+				const { handler, ...rest } = action
+				return rest
+			})
+			return [...dispatched, ...this.defaultActions]
 		},
 
 		hasRowActions() {
@@ -937,17 +995,6 @@ export default {
 			return (this.sidebar && this.sidebar.search) || {}
 		},
 
-		/**
-		 * Effective customComponents registry used to resolve the
-		 * `cardComponent` name. Explicit prop wins, inject falls back,
-		 * empty object is the last resort.
-		 *
-		 * @return {object}
-		 */
-		effectiveCustomComponents() {
-			return this.customComponents ?? this.cnCustomComponents ?? {}
-		},
-
 		/**
 		 * Resolved card component for card-grid view mode. Returns
 		 * `null` when `cardComponent` is empty OR when the name is not
@@ -984,6 +1031,89 @@ export default {
 	},
 
 	methods: {
+		/**
+		 * REQ-MAD-3 / REQ-MAD-4 / REQ-MAD-5 / REQ-MAD-6 / REQ-MAD-7
+		 * (manifest-actions-dispatch) — Resolve a manifest-declared
+		 * action's `handler` string into a `(row) => void` invocation
+		 * function. Returns null when the action should fall back to
+		 * the page's `@action`-event-only path.
+		 *
+		 *   - Reserved keyword `"navigate"` → push the configured route
+		 *     with `params: { id: row[rowKey] }`.
+		 *   - Reserved keyword `"emit"` → null (page still bubbles
+		 *     `@action`; explicit no-op).
+		 *   - Reserved keyword `"none"` → returns a no-op function that
+		 *     suppresses both the handler and the `@action` emit. The
+		 *     suppression happens via the special `_dispatchSuppress`
+		 *     flag on the cloned action; see mergedActions for the
+		 *     detail.
+		 *   - Registry name → look up in `effectiveCustomComponents`;
+		 *     when it's a function, wrap as
+		 *     `(row) => fn({ actionId: action.id, item: row })`. When
+		 *     it's a non-function, console.warn and return null.
+		 *   - Unknown registry name → silent fall-through (null).
+		 *
+		 * @param {object} action The manifest-shaped action object.
+		 * @return {Function|null}
+		 */
+		resolveHandler(action) {
+			const name = action.handler
+			if (typeof name !== 'string' || name.length === 0) return null
+			if (name === 'navigate') {
+				const route = action.route
+				if (typeof route !== 'string' || route.length === 0) {
+					// eslint-disable-next-line no-console
+					console.warn(
+						`[CnIndexPage] action "${action.id}" declares handler:"navigate" `
+						+ 'but route is missing; falling back to @action-only.',
+					)
+					return null
+				}
+				return (row) => {
+					this.$router.push({
+						name: route,
+						params: { id: row[this.rowKey] },
+					})
+				}
+			}
+			if (name === 'emit') return null
+			if (name === 'none') {
+				// Returns a sentinel that CnRowActions will treat as a
+				// no-op; we additionally short-circuit @action emit in
+				// `onRowAction` via the action's id.
+				return () => {}
+			}
+			const fn = this.effectiveCustomComponents[name]
+			if (typeof fn === 'function') {
+				return (row) => fn({ actionId: action.id, item: row })
+			}
+			if (fn !== undefined) {
+				// eslint-disable-next-line no-console
+				console.warn(
+					`[CnIndexPage] action.handler "${name}" resolved to a non-function in `
+					+ 'customComponents — components belong to slot overrides; falling '
+					+ 'back to @action-only.',
+				)
+			}
+			return null
+		},
+
+		/**
+		 * REQ-MAD-6 (manifest-actions-dispatch) — `handler: "none"`
+		 * blocks the `@action` emit entirely. CnRowActions emits
+		 * `@action` with `{ action: action.label, row }` and the page
+		 * forwards via `@action="$emit('action', $event)"`. This handler
+		 * intercepts so the `none`-flagged action is dropped before
+		 * re-emit.
+		 *
+		 * @param {{action: string, row: object}} payload The CnRowActions emit.
+		 */
+		onRowAction(payload) {
+			const matched = this.mergedActions.find((a) => a.label === payload.action)
+			if (matched && matched._dispatchSuppress) return
+			this.$emit('action', payload)
+		},
+
 		/**
 		 * Handle row click — emits row-click event for the parent to handle navigation.
 		 * @param {object} row The clicked row object

package/src/components/CnPageRenderer/pageTypes.js

@@ -53,4 +53,5 @@ export const defaultPageTypes = {
 	settings: defineAsyncComponent(() => import('../CnSettingsPage/CnSettingsPage.vue').then(m => m.default)),
 	chat: defineAsyncComponent(() => import('../CnChatPage/CnChatPage.vue').then(m => m.default)),
 	files: defineAsyncComponent(() => import('../CnFilesPage/CnFilesPage.vue').then(m => m.default)),
+	form: defineAsyncComponent(() => import('../CnFormPage/CnFormPage.vue').then(m => m.default)),
 }

package/src/components/index.js

@@ -60,6 +60,7 @@ export { CnLogsPage } from './CnLogsPage/index.js'
 export { CnSettingsPage } from './CnSettingsPage/index.js'
 export { CnChatPage } from './CnChatPage/index.js'
 export { CnFilesPage } from './CnFilesPage/index.js'
+export { CnFormPage } from './CnFormPage/index.js'
 export { CnPageRenderer, defaultPageTypes } from './CnPageRenderer/index.js'
 export { CnAppNav } from './CnAppNav/index.js'
 export { CnAppLoading } from './CnAppLoading/index.js'

package/src/composables/cnFormFieldRenderer.js

@@ -0,0 +1,256 @@
+/**
+ * cnFormFieldRenderer — shared field-renderer helper used by
+ * `CnFormPage` (and, in a follow-up, `CnSettingsPage`'s bare-fields
+ * branch).
+ *
+ * Maps a `formField` shape (the `$def` shared by
+ * `pages[].config.sections[].fields[]` for `type: "settings"` and
+ * `pages[].config.fields[]` for `type: "form"`) to one of the
+ * library's input components. Emitted to keep the input-rendering
+ * logic in one place — the settings page used to inline this switch
+ * (and still does, until a follow-up DRY pass migrates it); the form
+ * page consumes the shared helper from day one.
+ *
+ * Field shapes:
+ *
+ *  | `field.type`  | Component / behaviour                              |
+ *  |---------------|----------------------------------------------------|
+ *  | `boolean`     | NcCheckboxRadioSwitch                              |
+ *  | `number`      | NcTextField type=number, value coerced to Number   |
+ *  | `password`    | NcTextField type=password                          |
+ *  | `string`      | NcTextField (default), or NcTextArea when         |
+ *  |               | `field.widget === "textarea"`                      |
+ *  | `enum`        | NcSelect, options shaped from `field.enum`/`field.options` |
+ *  | `json`        | CnJsonViewer (read-only display in this rev)       |
+ *
+ * Unknown `field.type` values fall back to NcTextField and emit a
+ * single `console.warn` so the consumer notices the typo.
+ *
+ * The helper exports a render-function — components consume it via
+ * `<component :is="cnRenderFormField(...).renderer" v-bind="cnRenderFormField(...).bindings" />`
+ * — but for Vue 2 + the test toolchain we use a small functional
+ * resolver pattern: the helper returns `{ tag, props, listeners }`
+ * the parent template binds via `<component :is>`. This keeps the
+ * template trivially mountable in jest with the same component stubs
+ * tests already use for CnSettingsPage.
+ *
+ * @param {object} args
+ * @param {object} args.field   The formField shape.
+ * @param {*}      args.value   Current value for `field.key`.
+ * @param {Function} args.onInput Callback invoked with the new value.
+ * @param {Function} [args.t]   Optional translator for `field.label`.
+ * @param {object}  [args.componentMap] Optional override map from
+ *   widget id → Vue component. Defaults to the library's standard
+ *   set (`NcCheckboxRadioSwitch`, `NcTextField`, `NcTextArea`,
+ *   `NcSelect`, `CnJsonViewer`).
+ *
+ * @return {{ tag: object, props: object, listeners: object }}
+ */
+import {
+	NcCheckboxRadioSwitch,
+	NcSelect,
+	NcTextField,
+} from '@nextcloud/vue'
+import CnJsonViewer from '../components/CnJsonViewer/CnJsonViewer.vue'
+
+// NcTextArea is not always exported under the same path across
+// @nextcloud/vue versions; falling back to NcTextField with a
+// `multiline` prop hint keeps this resilient. The actual textarea
+// rendering is delegated to the textarea fallback below.
+let NcTextArea = null
+try {
+	// eslint-disable-next-line global-require
+	NcTextArea = require('@nextcloud/vue').NcTextArea ?? null
+} catch (_e) {
+	NcTextArea = null
+}
+
+const DEFAULT_COMPONENT_MAP = Object.freeze({
+	boolean: NcCheckboxRadioSwitch,
+	number: NcTextField,
+	password: NcTextField,
+	string: NcTextField,
+	'string-textarea': NcTextArea,
+	enum: NcSelect,
+	json: CnJsonViewer,
+})
+
+const KNOWN_TYPES = ['boolean', 'number', 'password', 'string', 'enum', 'json']
+
+const warned = new Set()
+
+/**
+ * Coerce an enum field's options into the `{ label, value }` shape
+ * NcSelect expects. Accepts:
+ *  - `field.enum: ['a', 'b']` (preferred per the formField $def)
+ *  - `field.options: [{ label, value }]` (legacy CnSettingsPage shape)
+ *  - mixed `[{ label, value }, 'literal']`
+ *
+ * @param {object} field
+ * @return {Array<{label: string, value: *}>}
+ */
+function resolveEnumOptions(field) {
+	const raw = Array.isArray(field.enum)
+		? field.enum
+		: (Array.isArray(field.options) ? field.options : [])
+	return raw.map((entry) => {
+		if (entry && typeof entry === 'object' && 'value' in entry) {
+			return { label: String(entry.label ?? entry.value), value: entry.value }
+		}
+		return { label: String(entry), value: entry }
+	})
+}
+
+/**
+ * Resolve render bindings for a single form field.
+ *
+ * @param {object} args See module docblock.
+ * @return {{ tag: object|string, props: object, listeners: object, kind: string }}
+ */
+export function cnRenderFormField({ field, value, onInput, t, componentMap } = {}) {
+	if (!field || typeof field !== 'object' || typeof field.key !== 'string') {
+		return null
+	}
+	const map = { ...DEFAULT_COMPONENT_MAP, ...(componentMap || {}) }
+	const translate = typeof t === 'function' ? t : (k) => k
+	const label = translate(field.label || field.key)
+
+	if (field.type === 'boolean') {
+		return {
+			kind: 'boolean',
+			tag: map.boolean,
+			props: {
+				checked: !!value,
+				label,
+			},
+			listeners: {
+				'update:checked': (next) => onInput(next),
+			},
+			labelText: label,
+		}
+	}
+
+	if (field.type === 'number') {
+		return {
+			kind: 'number',
+			tag: map.number,
+			props: {
+				label,
+				type: 'number',
+				value: value === null || value === undefined ? '' : String(value),
+			},
+			listeners: {
+				'update:value': (next) => onInput(next === '' ? null : Number(next)),
+			},
+		}
+	}
+
+	if (field.type === 'password') {
+		return {
+			kind: 'password',
+			tag: map.password,
+			props: {
+				label,
+				type: 'password',
+				value: value === null || value === undefined ? '' : String(value),
+			},
+			listeners: {
+				'update:value': (next) => onInput(next),
+			},
+		}
+	}
+
+	if (field.type === 'enum') {
+		const options = resolveEnumOptions(field)
+		const selected = options.find((o) => o.value === value) ?? null
+		return {
+			kind: 'enum',
+			tag: map.enum,
+			props: {
+				inputLabel: label,
+				options,
+				value: selected,
+			},
+			listeners: {
+				input: (next) => onInput(next?.value),
+			},
+		}
+	}
+
+	if (field.type === 'json') {
+		return {
+			kind: 'json',
+			tag: map.json,
+			props: {
+				value: value ?? null,
+				label,
+			},
+			listeners: {},
+		}
+	}
+
+	if (field.type === 'string') {
+		const isTextarea = field.widget === 'textarea'
+		if (isTextarea) {
+			// NcTextArea is preferred; otherwise fall back to a plain
+			// <textarea> rendered via the host template. The renderer
+			// returns `tag: 'textarea'` so the consumer's `<component :is>`
+			// resolves to the native element.
+			return {
+				kind: 'string-textarea',
+				tag: map['string-textarea'] || 'textarea',
+				props: {
+					label,
+					value: value === null || value === undefined ? '' : String(value),
+					rows: 4,
+				},
+				listeners: {
+					'update:value': (next) => onInput(next),
+					input: (event) => {
+						// Native textarea path — `event` is the InputEvent.
+						const next = event && event.target ? event.target.value : event
+						onInput(next)
+					},
+				},
+			}
+		}
+		return {
+			kind: 'string',
+			tag: map.string,
+			props: {
+				label,
+				value: value === null || value === undefined ? '' : String(value),
+			},
+			listeners: {
+				'update:value': (next) => onInput(next),
+			},
+		}
+	}
+
+	// Unknown type — warn ONCE per type and fall back to NcTextField.
+	if (!KNOWN_TYPES.includes(field.type)) {
+		if (!warned.has(field.type)) {
+			warned.add(field.type)
+			// eslint-disable-next-line no-console
+			console.warn(
+				`[cnRenderFormField] Unknown field.type "${field.type}" for field "${field.key}". Falling back to NcTextField. Known types: ${KNOWN_TYPES.join(', ')}.`,
+			)
+		}
+		return {
+			kind: 'fallback',
+			tag: map.string,
+			props: {
+				label,
+				value: value === null || value === undefined ? '' : String(value),
+			},
+			listeners: {
+				'update:value': (next) => onInput(next),
+			},
+		}
+	}
+
+	// Should be unreachable given KNOWN_TYPES check above.
+	return null
+}
+
+export default cnRenderFormField

package/src/composables/index.js

@@ -5,3 +5,4 @@ export { useDashboardView } from './useDashboardView.js'
 export { useContextMenu } from './useContextMenu.js'
 export { useAppManifest } from './useAppManifest.js'
 export { useAppStatus } from './useAppStatus.js'
+export { cnRenderFormField } from './cnFormFieldRenderer.js'

package/src/schemas/app-manifest.schema.json

@@ -119,7 +119,7 @@
 				},
 				"type": {
 					"type": "string",
-					"description": "Page type. Must match a key in the renderer's `pageTypes` registry (library defaults: \"index\", \"detail\", \"dashboard\", \"logs\", \"settings\", \"chat\", \"files\") OR be \"custom\" — in which case `component` resolves against the customComponents registry. Library extensions add their built-in types to `defaultPageTypes`; consumer apps pass a merged map via the `pageTypes` prop on CnAppRoot / CnPageRenderer."
+					"description": "Page type. Must match a key in the renderer's `pageTypes` registry (library defaults: \"index\", \"detail\", \"dashboard\", \"logs\", \"settings\", \"chat\", \"files\", \"form\") OR be \"custom\" — in which case `component` resolves against the customComponents registry. Library extensions add their built-in types to `defaultPageTypes`; consumer apps pass a merged map via the `pageTypes` prop on CnAppRoot / CnPageRenderer. The \"form\" type was added by `manifest-form-page-type` and renders a manifest-declared field set with submit/save handlers — see the type='form' note in `pages[].config` for the dispatch contract."
 				},
 				"title": {
 					"type": "string",
@@ -127,7 +127,7 @@
 				},
 				"config": {
 					"type": "object",
-					"description": "Type-specific configuration. For type='index': { register, schema, columns, actions, sidebar?, cardComponent? }. The optional `cardComponent` is a string referencing a key in the consuming app's `customComponents` registry (the same registry that powers `type:'custom'` pages). When set AND the page is in card-grid view mode AND the parent has not provided a `#card` scoped slot, CnIndexPage mounts the registry-resolved component for each row instead of the schema-driven CnObjectCard, passing `{ item, object, schema, register, selected }` props and forwarding `click` + `select` events. An unknown name logs a console warning and falls back to CnObjectCard so a misconfigured manifest never blanks the grid. The optional `sidebar` is an object `{ enabled: boolean, show?: boolean, columnGroups?: array, facets?: object, showMetadata?: boolean, search?: object }` that, when `enabled`, makes CnIndexPage auto-mount its embedded CnIndexSidebar. `show` (default true) suppresses the embedded sidebar without removing config when set false. For type='detail': { register, schema, sidebar?, sidebarProps? }. The `sidebar` field accepts EITHER a Boolean (legacy: true/false toggles the external CnObjectSidebar) OR an Object mirroring the index shape plus detail-specific fields `{ show?: boolean, enabled?: boolean, register?, schema?, hiddenTabs?, title?, subtitle?, tabs? }`. `config.sidebar.show: false` suppresses the embedded sidebar on either index or detail pages. The optional `sidebarProps.tabs` is an open-enum array of tab definitions `{ id, label, icon?, widgets?, component?, order? }` that overrides CnObjectSidebar's hard-coded built-in tab set; each tab declares either a list of widgets (`type: 'data' | 'metadata' | <registry-name>`) or a registry component name. For type='dashboard': { widgets, layout }. For type='logs': { register?, schema?, source?, columns? } — one of register+schema OR source MUST be set. For type='settings': { sections: array<Section>, saveEndpoint? } where each Section declares EXACTLY ONE of `fields[]` (back-compat flat-field body), `component: <registry-name>` + optional `props` (mounts a customComponents-resolved component as the section body), OR `widgets: array<{ type, props? }>` (mounts one or more widgets in sequence; built-in widget types `version-info` → CnVersionInfoCard and `register-mapping` → CnRegisterMapping resolve first, falling back to the customComponents registry). Widget events bubble through CnSettingsPage's `@widget-event` so consumers wire one page-level handler (see manifest-settings-rich-sections spec). For type='chat': { conversationSource?, postUrl?, schema? } — one of conversationSource OR postUrl MUST be set. For type='files': { folder, allowedTypes? }. For type='custom': any shape the custom component expects. As of schema version 1.2.0, the recurring sub-shapes (`columns[]`, `actions[]`, `widgets[]`, `layout[]`, `sections[].fields[]`, `sidebar.columnGroups[]`, `sidebar.tabs[]`, `sidebarProps.tabs[]`) `$ref` the seven `$defs` (`column`, `action`, `widgetDef`, `layoutItem`, `formField`, `sidebarSection`, `sidebarTab`). The OUTER `config` block keeps `additionalProperties: true` so per-type scalars (`register`, `schema`, `source`, `folder`, `saveEndpoint`, …) and consumer-app extension keys remain free-form.",
+					"description": "Type-specific configuration. For type='index': { register, schema, columns, actions, sidebar?, cardComponent? }. The optional `cardComponent` is a string referencing a key in the consuming app's `customComponents` registry (the same registry that powers `type:'custom'` pages). When set AND the page is in card-grid view mode AND the parent has not provided a `#card` scoped slot, CnIndexPage mounts the registry-resolved component for each row instead of the schema-driven CnObjectCard, passing `{ item, object, schema, register, selected }` props and forwarding `click` + `select` events. An unknown name logs a console warning and falls back to CnObjectCard so a misconfigured manifest never blanks the grid. The optional `sidebar` is an object `{ enabled: boolean, show?: boolean, columnGroups?: array, facets?: object, showMetadata?: boolean, search?: object }` that, when `enabled`, makes CnIndexPage auto-mount its embedded CnIndexSidebar. `show` (default true) suppresses the embedded sidebar without removing config when set false. For type='detail': { register, schema, sidebar?, sidebarProps? }. The `sidebar` field accepts EITHER a Boolean (legacy: true/false toggles the external CnObjectSidebar) OR an Object mirroring the index shape plus detail-specific fields `{ show?: boolean, enabled?: boolean, register?, schema?, hiddenTabs?, title?, subtitle?, tabs? }`. `config.sidebar.show: false` suppresses the embedded sidebar on either index or detail pages. The optional `sidebarProps.tabs` is an open-enum array of tab definitions `{ id, label, icon?, widgets?, component?, order? }` that overrides CnObjectSidebar's hard-coded built-in tab set; each tab declares either a list of widgets (`type: 'data' | 'metadata' | <registry-name>`) or a registry component name. For type='dashboard': { widgets, layout }. For type='logs': { register?, schema?, source?, columns? } — one of register+schema OR source MUST be set. For type='settings': { sections: array<Section>, saveEndpoint? } where each Section declares EXACTLY ONE of `fields[]` (back-compat flat-field body), `component: <registry-name>` + optional `props` (mounts a customComponents-resolved component as the section body), OR `widgets: array<{ type, props? }>` (mounts one or more widgets in sequence; built-in widget types `version-info` → CnVersionInfoCard and `register-mapping` → CnRegisterMapping resolve first, falling back to the customComponents registry). Widget events bubble through CnSettingsPage's `@widget-event` so consumers wire one page-level handler (see manifest-settings-rich-sections spec). For type='chat': { conversationSource?, postUrl?, schema? } — one of conversationSource OR postUrl MUST be set. For type='files': { folder, allowedTypes? }. For type='form': { fields: array<formField>, submitHandler? OR submitEndpoint?, submitMethod?, mode?, submitLabel?, successMessage?, initialValue? }. Exactly one of `submitHandler` (registry name resolved against customComponents) OR `submitEndpoint` (URL string; `:paramName` segments resolve against `$route.params`) MUST be set. `submitMethod` (default POST) MUST be one of POST | PUT | PATCH when set. `mode` (default public) MUST be one of edit | create | public when set. The `fields[]` array `$ref`s the same `formField` $def `pages[].config.sections[].fields[]` consumes for type='settings'. See manifest-form-page-type spec. For type='custom': any shape the custom component expects. As of schema version 1.2.0, the recurring sub-shapes (`columns[]`, `actions[]`, `widgets[]`, `layout[]`, `sections[].fields[]`, `sidebar.columnGroups[]`, `sidebar.tabs[]`, `sidebarProps.tabs[]`) `$ref` the seven `$defs` (`column`, `action`, `widgetDef`, `layoutItem`, `formField`, `sidebarSection`, `sidebarTab`). The OUTER `config` block keeps `additionalProperties: true` so per-type scalars (`register`, `schema`, `source`, `folder`, `saveEndpoint`, …) and consumer-app extension keys remain free-form.",
 					"additionalProperties": true,
 					"properties": {
 						"columns": {
@@ -155,6 +155,11 @@
 							"description": "Dashboard layout entries consumed by CnDashboardGrid / CnDashboardPage (for type='dashboard'). Each item references the `layoutItem` $def.",
 							"items": { "$ref": "#/$defs/layoutItem" }
 						},
+						"fields": {
+							"type": "array",
+							"description": "Form fields consumed by CnFormPage (for type='form'). Each item references the `formField` $def — the same shape `pages[].config.sections[].fields[]` uses for type='settings'.",
+							"items": { "$ref": "#/$defs/formField" }
+						},
 						"sections": {
 							"type": "array",
 							"description": "Settings sections consumed by CnSettingsPage (for type='settings'). Each section declares EXACTLY ONE of `fields[]` / `component` / `widgets[]` (FE-validated mutual exclusion). The outer section object keeps `additionalProperties: true`; only `fields[]` is typed via $ref formField. Settings widgets use a thinner shape `{ type, props? }` (NOT the same as dashboard widgetDef) and are NOT typed by this schema.",
@@ -310,6 +315,15 @@
 					"type": "boolean",
 					"default": false,
 					"description": "When true the consumer SHOULD show a confirmation dialog before invoking the action. Useful for destructive actions; defaults to false."
+				},
+				"handler": {
+					"type": "string",
+					"description": "Optional dispatch target for the action. Either (a) one of the reserved keywords \"navigate\" / \"emit\" / \"none\", or (b) a registry name resolving to a function in the customComponents map passed to CnAppRoot. When the registry name resolves to a function, CnIndexPage / CnDetailPage call it with `{ actionId, item }` on row-action click. The reserved keywords short-circuit the registry lookup: \"navigate\" calls `$router.push({ name: action.route, params: { id: row[rowKey] } })`; \"emit\" emits `@action` only (semantic-explicit no-op); \"none\" disables the click entirely. When unset (the default), the action only emits `@action` and the page-level listener decides the side-effect — preserves v1.2 behaviour. Added in schema 1.3.0.",
+					"pattern": "^(navigate|emit|none|[A-Za-z][A-Za-z0-9_]*)$"
+				},
+				"route": {
+					"type": "string",
+					"description": "Vue-router route name dispatched when `handler === \"navigate\"`. Required for the navigate keyword; ignored for other handler values. CnIndexPage uses it as `$router.push({ name: action.route, params: { id: row[rowKey] } })`. Added in schema 1.3.0."
 				}
 			}
 		},

package/src/utils/validateManifest.js

@@ -254,6 +254,42 @@ function validateTypeConfig(page, index, errors) {
 		}
 		break
 	}
+	case 'form': {
+		// `manifest-form-page-type` REQ-MFPT-* — runtime form pages
+		// MUST declare a non-empty fields[] array and exactly one of
+		// submitHandler | submitEndpoint as the dispatch destination.
+		// Optional submitMethod and mode are constrained to closed
+		// enums so manifest typos surface at validate time.
+		const hasFields = cfg && Array.isArray(cfg.fields) && cfg.fields.length > 0
+		if (!hasFields) {
+			errors.push(`${pathSlash}/fields: ${pathBracket}: form pages must declare a non-empty fields[] array`)
+		} else {
+			validateFieldsArray(cfg.fields, `${pathSlash}/fields`, errors)
+		}
+
+		const hasHandler = cfg && typeof cfg.submitHandler === 'string' && cfg.submitHandler.length > 0
+		const hasEndpoint = cfg && typeof cfg.submitEndpoint === 'string' && cfg.submitEndpoint.length > 0
+		const dispatchCount = (hasHandler ? 1 : 0) + (hasEndpoint ? 1 : 0)
+		if (dispatchCount !== 1) {
+			errors.push(`${pathSlash}: ${pathBracket}: form pages must declare exactly one of submitHandler | submitEndpoint`)
+		}
+
+		if (cfg && cfg.submitMethod !== undefined) {
+			const allowed = ['POST', 'PUT', 'PATCH']
+			const upper = typeof cfg.submitMethod === 'string' ? cfg.submitMethod.toUpperCase() : null
+			if (!upper || !allowed.includes(upper)) {
+				errors.push(`${pathSlash}/submitMethod: ${pathBracket}.submitMethod: must be one of POST | PUT | PATCH`)
+			}
+		}
+
+		if (cfg && cfg.mode !== undefined) {
+			const allowedModes = ['edit', 'create', 'public']
+			if (typeof cfg.mode !== 'string' || !allowedModes.includes(cfg.mode)) {
+				errors.push(`${pathSlash}/mode: ${pathBracket}.mode: must be one of edit | create | public`)
+			}
+		}
+		break
+	}
 	default:
 		// No per-type rules for index/detail/dashboard/custom or
 		// consumer-defined types; their `config` shape is enforced
@@ -527,9 +563,34 @@ function validateActionsArray(cfg, pathSlash, pathBracket, errors) {
 		if (typeof action.label !== 'string' || action.label.length === 0) {
 			errors.push(`${actionPath}/label: must be a non-empty string`)
 		}
+		// REQ-MAD-1 / REQ-MAD-2 — `handler` (string, registry name OR
+		// reserved keyword `navigate`/`emit`/`none`) and the matching
+		// `navigate` requirement on `route`. Schema 1.3.0+.
+		if (action.handler !== undefined) {
+			if (typeof action.handler !== 'string') {
+				errors.push(`${actionPath}/handler: must be a string when set`)
+			} else if (!HANDLER_PATTERN.test(action.handler)) {
+				errors.push(
+					`${actionPath}/handler: "${action.handler}" must match `
+					+ '"navigate" | "emit" | "none" | [A-Za-z][A-Za-z0-9_]*',
+				)
+			}
+			if (action.handler === 'navigate'
+				&& (typeof action.route !== 'string' || action.route.length === 0)) {
+				errors.push(`${actionPath}/route: required when handler is "navigate"`)
+			}
+		}
 	})
 }
 
+/**
+ * REQ-MAD-1 — Allowed shapes for `actions[].handler`. Either a
+ * reserved keyword (`navigate` | `emit` | `none`) or a JS-identifier
+ * registry name (alphanumeric + underscore, leading letter). Mirrors
+ * the schema's `pattern` on the `handler` property.
+ */
+const HANDLER_PATTERN = /^(navigate|emit|none|[A-Za-z][A-Za-z0-9_]*)$/
+
 /**
  * Validate `config.widgets[]` for dashboard page type
  * (`manifest-config-refs` REQ-MCR). Each entry MUST be an object with