@conduction/nextcloud-vue 2.97.0 → 2.98.0

package/src/components/CnChecklistRunWidget/index.js

@@ -0,0 +1,27 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * CnChecklistRunWidget — self-registers the `checklist-run` widget type (a
+ * checklist answered a page of questions at a time, with a note and photos)
+ * into the shared dashboardWidgetRegistry at module load. Renderer only: the
+ * questions and where the answers go are declared in the manifest.
+ */
+
+import CnChecklistRunWidget from './CnChecklistRunWidget.vue'
+import { registerDashboardWidget } from '../CnWidgetGrid/dashboardWidgetRegistry.js'
+
+registerDashboardWidget('checklist-run', {
+	renderer: CnChecklistRunWidget,
+	form: null,
+	defaultContent: {
+		questions: { register: '', schema: '', filter: {} },
+		pageSize: 1,
+	},
+	displayName: 'Checklist run',
+	icon: 'ClipboardCheckOutline',
+	surfaces: ['detail-page', 'app-dashboard'],
+})
+
+export { CnChecklistRunWidget }
+export default CnChecklistRunWidget

package/src/components/CnDashboardPage/CnDashboardPage.vue

@@ -1079,6 +1079,7 @@ const CHART_PROP_KEYS = [
 	'barMax',
 	'footnote',
 	'highlight',
+	'cellSource',
 ]
 
 /**

package/src/components/CnDataTable/CnDataTable.vue

@@ -408,6 +408,7 @@ import { fillTemplate, joinTemplateParts } from '../../utils/fillTemplate.js'
 import { lensUnavailableText, readLensReports } from '../../utils/lensAvailability.js'
 import { followLinkClick, openRowTarget, resolveHref } from '../../utils/linkNavigation.js'
 import { nextSortState } from '../../utils/multiColumnSort.js'
+import { readPath } from '../../utils/readPath.js'
 import { isNewTabClick, isNewTabHandled, isRowMiddleClick, markNewTabHandled, preventMiddleClickAutoscroll } from '../../utils/rowAuxClick.js'
 import { DEFAULT_ROW_INDICATOR_CAP, resolveRowIndicators } from '../../utils/rowIndicators.js'
 import { columnsFromSchema } from '../../utils/schema.js'
@@ -1841,8 +1842,11 @@ export default {
 				if (v === undefined) {
 					return this.aggregateLoading ? '…' : '—'
 				}
+				if (v === null && !(typeof col.aggregate.zeroLabel === 'string' && col.aggregate.zeroLabel !== '')) {
+					return '—'
+				}
 				const zeroLabel = col.aggregate.zeroLabel
-				if ((v === 0 || v === '0') && typeof zeroLabel === 'string' && zeroLabel !== '') {
+				if ((v === 0 || v === '0' || v === null) && typeof zeroLabel === 'string' && zeroLabel !== '') {
 					return typeof this.cnTranslate === 'function' ? this.cnTranslate(zeroLabel) : zeroLabel
 				}
 				return v
@@ -1872,17 +1876,21 @@ export default {
 		},
 
 		/**
-		 * For every column that declares `aggregate` (currently `op: "count"`),
-		 * issue one `_limit=0` count request per visible row against the related
-		 * OpenRegister collection and cache the totals in `aggregateValues`.
+		 * For every column that declares `aggregate`, issue one request per
+		 * visible row against the related OpenRegister collection and cache the
+		 * answer in `aggregateValues`: `op: "count"` asks `_limit=0` for the
+		 * total, `op: "max"` asks for the one object with the highest `field`
+		 * (`_limit=1`, sorted descending) and keeps that value, null when there
+		 * is none (shown as `zeroLabel`, else a dash).
 		 * Batched with `Promise.all`; a per-request failure degrades that one
 		 * cell to `'—'` (logged), never the page. A monotonic request id
 		 * discards a stale batch when `rows` / columns change mid-flight.
 		 *
 		 * @return {Promise<void>}
+		 * @spec openspec/changes/masked-formatter-max-aggregate/specs/index-page/spec.md#requirement-a-column-aggregate-can-take-the-highest-value
 		 */
 		async loadAggregates() {
-			const aggCols = this.effectiveColumns.filter((c) => c && c.aggregate && c.aggregate.op === 'count')
+			const aggCols = this.effectiveColumns.filter((c) => c && c.aggregate && (c.aggregate.op === 'count' || (c.aggregate.op === 'max' && c.aggregate.field)))
 			if (aggCols.length === 0) {
 				if (Object.keys(this.aggregateValues).length > 0) {
 					this.aggregateValues = {}
@@ -1903,11 +1911,21 @@ export default {
 						continue
 					}
 					const where = this.resolveAggregateWhere(agg.where, row)
-					jobs.push(axios.get(generateUrl(`/apps/openregister/api/objects/${agg.register}/${agg.schema}`), {
-						params: { ...where, _limit: 0 },
-					})
+					// `max`: the highest `field` among the related objects, as the
+					// first of them sorted on it descending ("Laatste contact").
+					const isMax = agg.op === 'max'
+					const params = isMax
+						? { ...where, _limit: 1, [`_order[${agg.field}]`]: 'desc' }
+						: { ...where, _limit: 0 }
+					jobs.push(axios.get(generateUrl(`/apps/openregister/api/objects/${agg.register}/${agg.schema}`), { params })
 						.then((res) => {
 							const d = res && res.data
+							if (isMax) {
+								const first = d && Array.isArray(d.results) ? d.results[0] : undefined
+								const top = first === undefined ? undefined : readPath(first, agg.field)
+								next[rowKey][col.key] = top === undefined || top === '' ? null : top
+								return
+							}
 							next[rowKey][col.key] = (d && (d.total ?? (Array.isArray(d.results) ? d.results.length : undefined))) ?? 0
 						})
 						.catch((e) => {

package/src/components/CnDetailPage/CnDetailPage.md

@@ -434,6 +434,54 @@ Four levels of action and the case surfaces around them. All opt in. See [the re
 
 `previousTo` and `nextTo` (default `null`) take `useListNavigation`'s `previousRoute` / `nextRoute` and turn the previous and next controls into real links, so they can be opened in a new tab. The link navigates by itself; `previous-record` / `next-record` are still emitted, with `{ event, to }`, and `goPrevious` / `goNext` do not push again when they receive that payload.
 
+## Records that are not objects (`config.entitySource`)
+
+A detail page reads its record from the object store through `register` +
+`schema`. A record that is not a register/schema object names a registered
+entity source instead, the same registry and the same name `CnIndexPage`
+lists it with. `organisations` reads the OpenRegister organisation whose uuid
+is the route's id (`GET /apps/openregister/api/organisations/{uuid}`):
+
+```json
+{
+  "id": "organisation-detail",
+  "route": "/organisations/:id",
+  "type": "detail",
+  "config": {
+    "entitySource": "organisations",
+    "statusPill": { "field": "status" },
+    "typePill": { "field": "type" },
+    "headerFields": [{ "key": "slug" }],
+    "layout": [{ "id": "1", "widgetId": "facts", "gridX": 0, "gridY": 0, "gridWidth": 6 }],
+    "widgets": [{
+      "id": "facts",
+      "type": "facts",
+      "title": "Details",
+      "content": { "fields": [
+        { "path": "slug", "label": "Slug" },
+        { "path": "created", "label": "Created", "format": "date" },
+        { "path": "contactEmail", "label": "Contact", "format": "email" },
+        { "path": "kvk", "label": "KvK" }
+      ] }
+    }]
+  }
+}
+```
+
+The record feeds everything a fetched object feeds: the title, the pills, the
+header fields, the widgets, and the `@objectId` / `@object.*` tokens. A tab
+that lists register objects belonging to the organisation filters on
+`@objectId`, e.g. `{ "type": "object-list", "content": { "register": "...",
+"schema": "...", "filter": { "tenantRef": "@objectId" } } }`. The record's
+`id` is its uuid, as an object's is.
+
+`entitySource` wins over `register` + `schema`. A name that is unknown, or a
+source that cannot read one record, shows no record and warns in the console.
+A refusal (403) or a missing record (404) shows the not-found state; which
+records the viewer may read is OpenRegister's decision. Refresh and
+`cn:page:refresh` re-read the record. There is no Edit: a record source has
+no schema form.
+
 ## Not found
 
 When the schema-driven fetch answers 404 the page shows a not-found state whose back button is a router link to `notFoundRoute` (default `null`, which means the app root `/`). `notFoundRouteLabel` names that page in the button's "Back to …" label.

package/src/components/CnDetailPage/CnDetailPage.vue

@@ -1232,11 +1232,13 @@ import CnSegmentedControl from '../CnSegmentedControl/CnSegmentedControl.vue'
 import CnSummaryAggregates from '../CnSummaryAggregates/CnSummaryAggregates.vue'
 import CnTranslatedBadge from '../CnTranslatedBadge/CnTranslatedBadge.vue'
 import CnDetailHeaderChips from './CnDetailHeaderChips.vue'
+import { resolveRecordSource } from '../../composables/indexSources.js'
 import { useIntegrationRegistry } from '../../composables/useIntegrationRegistry.js'
 import { normalizeLook } from '../../composables/useLook.js'
 import { useObjectLock } from '../../composables/useObjectLock.js'
 import { useObjectPresence } from '../../composables/useObjectPresence.js'
 import { useObjectSubscription } from '../../composables/useObjectSubscription.js'
+import { createRefLabelResolver } from '../../composables/useRefLabels.js'
 import { gridLayout } from '../../mixins/gridLayout.js'
 import { pageViews } from '../../mixins/pageViews.js'
 import { useObjectStore } from '../../store/index.js'
@@ -1909,6 +1911,23 @@ export default {
 			default: null,
 		},
 
+		/**
+		 * Name of a registered entity source that reads ONE record (manifest
+		 * `config.entitySource`), for a record that is not a register/schema
+		 * object. The same registry and the same name as `CnIndexPage`'s
+		 * `entitySource`: `organisations` shows the OpenRegister organisation
+		 * whose uuid is `objectId`. The record feeds the header, pills, facts,
+		 * widgets and the `@objectId` / `@object.*` tokens exactly as a fetched
+		 * object does. Wins over `register` + `schema`. Empty (the default)
+		 * leaves the page on its object store.
+		 *
+		 * @type {string}
+		 */
+		entitySource: {
+			type: String,
+			default: '',
+		},
+
 		/**
 		 * OpenRegister register slug. Pair with `schema` to opt into the
 		 * schema-driven mode: the page fuses the two into an internal
@@ -2863,6 +2882,10 @@ export default {
 			pillCounts: {},
 			/** Sequence of the last pill count round, so a late answer does not overwrite a newer one. */
 			pillCountSeq: 0,
+			/** The labels of the records pills with `resolve` point at, by pill key. */
+			pillRefLabels: {},
+			/** Sequence of the last pill label lookup, so a late answer for another record is dropped. */
+			pillRefSeq: 0,
 			/** `register/schema/id` the read-state call was last made for, so it is sent once per load. */
 			readStateSentFor: '',
 			/** Whether the user is arranging the chosen view (`userLayout`). */
@@ -3384,7 +3407,16 @@ export default {
 					const pill = pillCountSource(config)
 						? resolveCountPill(config, this.pillCounts[key], (text) => this.effectiveTranslate(text))
 						: resolvePill(config, this.resolvedObject)
-					return pill ? { ...pill, key, label: this.effectiveTranslate(pill.label) } : null
+					if (!pill) {
+						return null
+					}
+					// `resolve`: the referenced record's label replaces the id, and
+					// keys the colour too ("Woo-verzoek", not a uuid).
+					const resolved = this.pillRefLabels[key]
+					if (typeof resolved === 'string' && resolved !== '') {
+						return { ...pill, key, label: this.effectiveTranslate(resolved), colorKey: resolved }
+					}
+					return { ...pill, key, label: this.effectiveTranslate(pill.label) }
 				})
 				.filter(Boolean)
 		},
@@ -3396,6 +3428,34 @@ export default {
 		 * @return {string} The key.
 		 * @spec openspec/changes/screens-relation-pages/specs/relation-pages/spec.md#requirement-a-header-pill-can-be-a-constant-or-a-count
 		 */
+		/**
+		 * What the resolved pills depend on, as one key: a change looks again.
+		 *
+		 * @return {string}
+		 * @spec openspec/changes/detail-pill-resolve/specs/detail-page/spec.md#requirement-a-header-pill-can-show-a-referenced-record-s-label
+		 */
+		pillResolveKey() {
+			return JSON.stringify(this.pillResolveTargets)
+		},
+
+		/**
+		 * The pills with `resolve: { register, schema, labelField? }` and the
+		 * id each one shows: `[key, register, schema, labelField, id]`. Empty
+		 * while the field is empty.
+		 *
+		 * @return {Array<Array<string>>}
+		 * @spec openspec/changes/detail-pill-resolve/specs/detail-page/spec.md#requirement-a-header-pill-can-show-a-referenced-record-s-label
+		 */
+		pillResolveTargets() {
+			return [['type', this.typePill], ['status', this.statusPill]]
+				.filter(([, config]) => config && config.resolve && config.resolve.register && config.resolve.schema && typeof config.field === 'string')
+				.map(([key, config]) => {
+					const pill = resolvePill({ field: config.field }, this.resolvedObject)
+					return pill ? [key, config.resolve.register, config.resolve.schema, config.resolve.labelField || '', pill.colorKey] : null
+				})
+				.filter(Boolean)
+		},
+
 		pillCountKey() {
 			return JSON.stringify([this.objectId, pillCountSource(this.typePill), pillCountSource(this.statusPill)])
 		},
@@ -3598,6 +3658,9 @@ export default {
 		 * @return {boolean}
 		 */
 		awaitingObject() {
+			if (this.hasRecordSourceFetch) {
+				return this.objectFetchPending && !this.currentObject
+			}
 			return this.hasSchemaDrivenFetch
 				&& this.objectFetchPending
 				&& typeof this.effectiveObjectStore?.fetchObject === 'function'
@@ -3671,7 +3734,45 @@ export default {
 		 * the fetch path entirely.
 		 */
 		hasSchemaDrivenFetch() {
-			return Boolean(this.register && this.schema && this.objectId)
+			return !this.entitySource && Boolean(this.register && this.schema && this.objectId)
+		},
+
+		/**
+		 * The record source named by `entitySource`, or null. An unknown name,
+		 * or a source that cannot read one record, is null with a warning.
+		 *
+		 * @return {object|null}
+		 */
+		recordSource() {
+			if (!this.entitySource) {
+				return null
+			}
+			try {
+				return resolveRecordSource(this.entitySource)
+			} catch (err) {
+				// eslint-disable-next-line no-console -- the console is the only channel a host app can read the detail on
+				console.warn('[CnDetailPage] the record source could not start; no record is shown.', err)
+				return null
+			}
+		},
+
+		/**
+		 * Whether the page reads its record through a record source.
+		 *
+		 * @return {boolean}
+		 */
+		hasRecordSourceFetch() {
+			return Boolean(this.recordSource && this.objectId)
+		},
+
+		/**
+		 * Whether the page reads its own record, from the object store or a
+		 * record source, so Refresh and `cn:page:refresh` have something to do.
+		 *
+		 * @return {boolean}
+		 */
+		selfFetchesRecord() {
+			return this.hasSchemaDrivenFetch || this.hasRecordSourceFetch
 		},
 
 		/**
@@ -3886,7 +3987,7 @@ export default {
 			}
 			// `$.vnode.props`, not `$attrs`: `refresh` is a declared emit, and
 			// Vue keeps declared emits out of `$attrs`.
-			return Boolean(this.$.vnode.props?.onRefresh) || this.hasSchemaDrivenFetch
+			return Boolean(this.$.vnode.props?.onRefresh) || this.selfFetchesRecord
 		},
 
 		/**
@@ -3930,6 +4031,9 @@ export default {
 		 * @return {object|null}
 		 */
 		currentObject() {
+			if (this.recordSource) {
+				return this.objectId ? (this.recordSource.record(this.objectId) ?? null) : null
+			}
 			const store = this.effectiveObjectStore
 			if (!store) {
 				return null
@@ -4605,6 +4709,14 @@ export default {
 			},
 		},
 
+		// A pill with `resolve` looks its record up again for another value.
+		pillResolveKey: {
+			immediate: true,
+			handler() {
+				this.refreshPillRefLabels()
+			},
+		},
+
 		// The header's count pills count again for another record or other lists.
 		pillCountKey: {
 			immediate: true,
@@ -5028,7 +5140,7 @@ export default {
 			// Schema-driven (manifest) detail pages self-fetch — without this
 			// the Refresh action has no host listener to act on and does
 			// nothing. Re-fetch the object + schema and spin the action.
-			if (!this.hasSchemaDrivenFetch) {
+			if (!this.selfFetchesRecord) {
 				return
 			}
 			this.internalRefreshing = true
@@ -5041,6 +5153,42 @@ export default {
 			}
 		},
 
+		/**
+		 * Look up the records the `resolve` pills point at, through the same
+		 * reference-label resolver the index tables use. A failed lookup keeps
+		 * the raw value.
+		 *
+		 * @return {Promise<void>}
+		 * @spec openspec/changes/detail-pill-resolve/specs/detail-page/spec.md#requirement-a-header-pill-can-show-a-referenced-record-s-label
+		 */
+		async refreshPillRefLabels() {
+			const targets = this.pillResolveTargets
+			const seq = ++this.pillRefSeq
+			if (targets.length === 0) {
+				this.pillRefLabels = {}
+				return
+			}
+			if (!this._pillRefResolver) {
+				this._pillRefResolver = createRefLabelResolver(() => {
+					try {
+						return this.objectStore || useObjectStore()
+					} catch {
+						return null
+					}
+				})
+			}
+			const labels = {}
+			await Promise.all(targets.map(async ([key, register, schema, labelField, id]) => {
+				const found = await this._pillRefResolver.resolve(register, schema, [id], labelField).catch(() => ({}))
+				if (found && typeof found[id] === 'string') {
+					labels[key] = found[id]
+				}
+			}))
+			if (seq === this.pillRefSeq) {
+				this.pillRefLabels = labels
+			}
+		},
+
 		/**
 		 * Count the lists behind the header's count pills (`countFrom`): one
 		 * list request each (`_limit=1`, the `total`). A failed count, or a
@@ -5083,7 +5231,7 @@ export default {
 		 */
 		onPageRefreshBus(payload) {
 			this.refreshPillCounts()
-			if (!this.hasSchemaDrivenFetch) {
+			if (!this.selfFetchesRecord) {
 				return
 			}
 			if (this.internalRefreshing) {
@@ -5308,6 +5456,10 @@ export default {
 		},
 
 		async fetchObjectIfNeeded() {
+			if (this.recordSource) {
+				await this.fetchSourceRecord()
+				return
+			}
 			// Create archetype: no object to fetch, but the create form needs
 			// the schema — register the type and fetch its schema, then stop.
 			if (!this.hasSchemaDrivenFetch) {
@@ -5371,6 +5523,37 @@ export default {
 			}
 		},
 
+		/**
+		 * Read the record through the record source. A refusal (403) or a
+		 * missing record (404) shows the not-found state; which records the
+		 * viewer may read is the server's decision.
+		 *
+		 * @return {Promise<void>}
+		 */
+		async fetchSourceRecord() {
+			const source = this.recordSource
+			const objectId = this.objectId
+			if (!objectId) {
+				this.objectFetchPending = false
+				return
+			}
+			this.objectFetchPending = true
+			this.objectNotFound = false
+			try {
+				await source.loadRecord(String(objectId))
+			} catch (err) {
+				// eslint-disable-next-line no-console -- the failure is already handled; the console is the only channel a host app can read the detail on
+				console.error('[CnDetailPage] record source fetch failed:', err)
+			} finally {
+				// A newer fetch for another id owns the flags now.
+				if (objectId === this.objectId) {
+					const status = typeof source.recordError === 'function' ? source.recordError(String(objectId)) : null
+					this.objectNotFound = !this.currentObject && (status === 403 || status === 404)
+					this.objectFetchPending = false
+				}
+			}
+		},
+
 		/**
 		 * Whether a grid-layout item resolves to an integration-typed
 		 * widget — `def.type === 'integration'` with a string

package/src/components/CnFeaturesAndRoadmapView/CnFeaturesAndRoadmapView.vue

@@ -223,8 +223,8 @@ export default {
 		/**
 		 * Board look options, passed to CnFeaturesBoard: `layout` (`cards` or
 		 * `rows`), `tabs`, `filter` (`chips` or `segmented`), `statusLabels`,
-		 * `next`, `issueLabels`, `subtitle`, `notice`, `documentationButton`
-		 * and `suggestButton`. Ignored in the default look.
+		 * `next`, `issueLabels`, `subtitle`, `notice`, `noticeLink`,
+		 * `summaries`, `documentationButton` and `suggestButton`. Ignored in the default look.
 		 *
 		 * @type {object}
 		 */
@@ -460,7 +460,7 @@ export default {
 		 * @return {object}
 		 */
 		boardOptions() {
-			const keys = ['layout', 'tabs', 'filter', 'statusLabels', 'next', 'issueLabels', 'subtitle', 'notice', 'documentationButton', 'suggestButton']
+			const keys = ['layout', 'tabs', 'filter', 'statusLabels', 'next', 'issueLabels', 'subtitle', 'notice', 'noticeLink', 'summaries', 'documentationButton', 'suggestButton']
 			const options = {}
 			for (const key of keys) {
 				if (this.board && this.board[key] !== undefined && this.board[key] !== null) {

package/src/components/CnFeaturesBoard/CnFeaturesBoard.vue

@@ -195,7 +195,7 @@
 									data-testid="cn-features-board-feature">
 									<span class="cn-features-board__row-text">
 										<span class="cn-features-board__row-title">{{ feature.title }}</span>
-										<span v-if="feature.summary" class="cn-features-board__row-summary">{{ feature.summary }}</span>
+										<span v-if="summaries && feature.summary" class="cn-features-board__row-summary">{{ feature.summary }}</span>
 									</span>
 									<CnStatusBadge
 										:label="statusText(feature)"
@@ -271,7 +271,16 @@
 					type="info"
 					class="cn-features-board__notice"
 					data-testid="cn-features-board-notice">
-					{{ tr(notice) }}
+					<template v-if="noticeParts.link">
+						{{ noticeParts.before }}<a
+							:href="noticeParts.link.href"
+							target="_blank"
+							rel="noopener noreferrer"
+							data-testid="cn-features-board-notice-link">{{ noticeParts.link.text }}</a>{{ noticeParts.after }}
+					</template>
+					<template v-else>
+						{{ noticeParts.before }}
+					</template>
 				</NcNoteCard>
 			</template>
 		</div>
@@ -397,6 +406,10 @@ export default {
 		suggestUrl: { type: String, default: '' },
 		/** Show the feature-request form as the header's primary button; without it, it is an entry in the Actions menu. */
 		suggestButton: { type: Boolean, default: true },
+		/** In the `rows` layout, draw each feature's summary under its title; false shows the title and status only. */
+		summaries: { type: Boolean, default: true },
+		/** A link inside the notice: `{ text, href }`; the first occurrence of `text` in the translated notice opens `href` in a new tab. Only http(s) and site-relative hrefs link. */
+		noticeLink: { type: Object, default: null },
 		/** Target of the OpenBuilt entry in the Actions menu. */
 		openbuiltUrl: { type: String, default: '' },
 		/** Target of the AI skills entry in the Actions menu. */
@@ -421,8 +434,10 @@ export default {
 			return readerLanguage()
 		},
 
+		/** The groups, their captions through the app's translate function. */
 		groups() {
 			return groupFeatures(this.features, this.categories, this.language)
+				.map((group) => ({ ...group, label: group.label ? this.tr(group.label) : '' }))
 		},
 
 		allFeatures() {
@@ -466,6 +481,27 @@ export default {
 			return this.title ? this.tr(this.title) : t('nextcloud-vue', 'Features and roadmap')
 		},
 
+		/**
+		 * The notice split around its link: the text before, the link and the
+		 * text after. Without a usable `noticeLink` (no match in the
+		 * translated notice, or an href that is not http(s) or site-relative)
+		 * `before` is the whole notice.
+		 *
+		 * @return {{before: string, link: ({text: string, href: string}|null), after: string}} The parts.
+		 */
+		noticeParts() {
+			const text = this.notice ? this.tr(this.notice) : ''
+			const link = this.noticeLink
+			const label = link && typeof link.text === 'string' ? this.tr(link.text) : ''
+			const href = link && typeof link.href === 'string' ? link.href.trim() : ''
+			const index = label ? text.indexOf(label) : -1
+			const allowed = (/^https?:\/\//i.test(href) || href.startsWith('/')) && safeHref(href) === href
+			if (index === -1 || !allowed) {
+				return { before: text, link: null, after: '' }
+			}
+			return { before: text.slice(0, index), link: { text: label, href }, after: text.slice(index + label.length) }
+		},
+
 		resolvedSubtitle() {
 			if (!this.subtitle) {
 				return ''

package/src/components/CnIndexPage/CnIndexPage.md

@@ -535,6 +535,34 @@ What the source brings, all overridable by the manifest:
 - Scope stays the endpoint's session decision. The loader drops any
   user-naming key, so a manifest cannot ask for someone else's inbox.
 
+### The `organisations` source: OpenRegister organisations
+
+`entitySource: "organisations"` lists the OpenRegister organisations the
+viewer belongs to, from `GET /apps/openregister/api/organisations`. An
+organisation is not a register/schema object, so self-fetch cannot reach it.
+
+```json
+{
+  "id": "organisations",
+  "route": "/organisations",
+  "type": "index",
+  "config": { "entitySource": "organisations", "rowRoute": "organisation-detail" }
+}
+```
+
+- Columns: name, status (a pill with the lifecycle state in words), type and
+  created. A manifest `columns` list still wins; every field of the
+  organisation can be a column (`slug`, `contactEmail`, `kvk`, ...).
+- A row's `id` is the organisation's uuid, so `rowRoute` pushes
+  `{ name: rowRoute, params: { id: <uuid> } }`.
+- No Add, Copy or Delete: creating an organisation is not this page's object
+  form, and OpenRegister has no delete for one.
+- Which organisations are listed is OpenRegister's decision from the
+  session. The endpoint takes no parameters, so no config key reaches it.
+
+The same name works on a `type: "detail"` page, which then shows ONE
+organisation (see CnDetailPage, "Records that are not objects").
+
 ### Search fields on a named source
 
 Available from the release that follows 3.2.0. An app on 3.2.0 or older ignores `sidebar.fields`, so bump the dependency before declaring them.