@abinnovision/payloadcms-mcpx 1.1.0-beta.6 → 2.0.0-beta.12

package/dist/admin/capability-matrix.d.mts

@@ -0,0 +1,33 @@
+import { CapabilityMatrix } from "../api-keys/capability-matrix.mjs";
+import React from "react";
+//#region src/admin/capability-matrix.d.ts
+interface McpxCapabilityMatrixProps {
+  /**
+   * Built from the plugin options at config time.
+   */
+  matrix: CapabilityMatrix;
+  /**
+   * The group's own config, supplied by Payload. Carries the description.
+   */
+  field?: {
+    admin?: {
+      description?: unknown;
+    };
+  };
+  /**
+   * The `capabilities` group's own path, supplied by Payload.
+   */
+  path?: string;
+  readOnly?: boolean;
+  /**
+   * Whether the key form is split into tabs, from the plugin options.
+   */
+  withinTab?: boolean;
+}
+/**
+ * What an API key may do, as one table per namespace: a row per entity, a
+ * column per operation and a bulk toggle in each column header. The nested
+ * checkbox fields back every cell, so the stored document is unaffected.
+ */
+export declare const McpxCapabilityMatrix: React.FC<McpxCapabilityMatrixProps>;
+//#endregion

package/dist/admin/capability-matrix.mjs

@@ -0,0 +1,354 @@
+"use client";
+import { CAPABILITIES_FIELD } from "../capabilities.mjs";
+import { CAPABILITY_OPERATIONS, capabilityPaths, cellPath, toolPath } from "../api-keys/capability-matrix.mjs";
+import { buildToggleActions, columnState, rowState, toolsState } from "./capability-toggles.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { CheckboxInput, FieldDescription, FieldLabel, useForm, useFormFields } from "@payloadcms/ui";
+import { useCallback, useMemo } from "react";
+//#region src/admin/capability-matrix.tsx
+const NOT_EXPOSED = "The plugin config does not expose this.";
+const BASE_CLASS = "mcpx-capabilities";
+const SHEET = `
+.${BASE_CLASS} tbody tr:hover { background: var(--theme-elevation-50); }
+.${BASE_CLASS}__toggle:hover { text-decoration: underline; }
+.${BASE_CLASS} section:last-of-type { margin-bottom: 0; }
+`;
+const CELL_PADDING = "calc(var(--base) * 0.6)";
+const EDGE_PADDING = "calc(var(--base) * 0.8)";
+const styles = {
+	section: { marginBottom: "var(--base)" },
+	table: {
+		tableLayout: "fixed",
+		width: "auto",
+		borderCollapse: "separate",
+		borderSpacing: 0,
+		textAlign: "left"
+	},
+	head: { background: "var(--theme-elevation-50)" },
+	headTitle: {
+		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
+		verticalAlign: "middle",
+		fontSize: "0.8em",
+		letterSpacing: "0.08em",
+		textTransform: "uppercase",
+		color: "var(--theme-elevation-400)",
+		fontWeight: "normal"
+	},
+	headOperation: {
+		padding: CELL_PADDING,
+		verticalAlign: "middle",
+		color: "var(--theme-elevation-400)",
+		fontWeight: "normal",
+		textAlign: "center",
+		whiteSpace: "nowrap"
+	},
+	headLabel: {
+		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
+		verticalAlign: "middle",
+		color: "var(--theme-elevation-500)",
+		fontWeight: "normal"
+	},
+	rule: { borderBottom: "1px solid var(--theme-border-color)" },
+	topStart: { borderStartStartRadius: "var(--style-radius-s)" },
+	topEnd: { borderStartEndRadius: "var(--style-radius-s)" },
+	rowHeader: {
+		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
+		verticalAlign: "middle",
+		fontWeight: "normal",
+		wordBreak: "break-word"
+	},
+	rowButton: {
+		padding: 0,
+		border: 0,
+		background: "none",
+		color: "inherit",
+		font: "inherit",
+		cursor: "pointer",
+		textAlign: "start",
+		textDecoration: "none"
+	},
+	hint: {
+		display: "block",
+		color: "var(--theme-elevation-400)"
+	},
+	cell: {
+		padding: CELL_PADDING,
+		verticalAlign: "middle",
+		textAlign: "center"
+	},
+	lastCell: { paddingInlineEnd: EDGE_PADDING },
+	dash: {
+		color: "var(--theme-elevation-400)",
+		cursor: "help"
+	}
+};
+const Box = ({ label, onChange, readOnly, state }) => /*#__PURE__*/ jsx(CheckboxInput, {
+	checked: state === "on",
+	name: label,
+	onToggle: onChange,
+	partialChecked: state === "mixed",
+	readOnly
+});
+const LABEL_WIDTH = "calc(var(--base) * 9)";
+const OPERATION_WIDTH = "calc(var(--base) * 3.5)";
+const Columns = ({ count }) => /*#__PURE__*/ jsxs("colgroup", { children: [/*#__PURE__*/ jsx("col", { style: { width: LABEL_WIDTH } }), Array.from({ length: count }, (_, index) => /*#__PURE__*/ jsx("col", { style: { width: OPERATION_WIDTH } }, index))] });
+const cellStyle = (isLast) => isLast ? {
+	...styles.cell,
+	...styles.lastCell
+} : styles.cell;
+const Dash = () => /*#__PURE__*/ jsx("span", {
+	"aria-label": NOT_EXPOSED,
+	style: styles.dash,
+	title: NOT_EXPOSED,
+	children: "—"
+});
+const NamespaceTable = ({ matrix, namespace, path, readOnly, toggle, values }) => {
+	const rows = matrix[namespace.id];
+	const columns = CAPABILITY_OPERATIONS.filter((operation) => rows.some((row) => row[operation.id]));
+	return /*#__PURE__*/ jsx("section", {
+		style: styles.section,
+		children: /*#__PURE__*/ jsxs("table", {
+			style: styles.table,
+			children: [
+				/*#__PURE__*/ jsx(Columns, { count: columns.length }),
+				/*#__PURE__*/ jsxs("thead", {
+					style: styles.head,
+					children: [/*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
+						scope: "col",
+						style: {
+							...styles.headTitle,
+							...styles.topStart
+						},
+						children: namespace.title
+					}), columns.map((operation, column) => /*#__PURE__*/ jsx("th", {
+						scope: "col",
+						style: column === columns.length - 1 ? {
+							...styles.headOperation,
+							...styles.topEnd
+						} : styles.headOperation,
+						title: operation.description,
+						children: operation.label
+					}, operation.id))] }), /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
+						scope: "row",
+						style: {
+							...styles.headLabel,
+							...styles.rule
+						},
+						children: "All"
+					}), columns.map((operation, column) => {
+						const state = columnState(matrix, path, namespace.id, operation.id, values);
+						return /*#__PURE__*/ jsx("td", {
+							style: {
+								...cellStyle(column === columns.length - 1),
+								...styles.rule
+							},
+							children: /*#__PURE__*/ jsx(Box, {
+								label: `${operation.label} every ${namespace.title.toLowerCase()} entry`,
+								onChange: () => {
+									toggle({
+										kind: "column",
+										namespace: namespace.id,
+										operation: operation.id,
+										value: state !== "on"
+									});
+								},
+								readOnly,
+								state
+							})
+						}, operation.id);
+					})] })]
+				}),
+				/*#__PURE__*/ jsx("tbody", { children: rows.map((row) => {
+					const state = rowState(path, namespace.id, row, values);
+					return /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsxs("th", {
+						scope: "row",
+						style: styles.rowHeader,
+						children: [/*#__PURE__*/ jsx("button", {
+							className: `${BASE_CLASS}__toggle`,
+							disabled: readOnly,
+							onClick: () => {
+								toggle({
+									kind: "row",
+									namespace: namespace.id,
+									fieldName: row.fieldName,
+									value: state !== "on"
+								});
+							},
+							style: styles.rowButton,
+							title: `Toggle every capability for ${row.label}`,
+							type: "button",
+							children: row.label
+						}), row.hint ? /*#__PURE__*/ jsx("span", {
+							style: styles.hint,
+							children: row.hint
+						}) : null]
+					}), columns.map((operation, column) => /*#__PURE__*/ jsx("td", {
+						style: cellStyle(column === columns.length - 1),
+						children: row[operation.id] ? /*#__PURE__*/ jsx(Box, {
+							label: `${operation.label} ${row.label}`,
+							onChange: () => {
+								toggle({
+									kind: "cell",
+									namespace: namespace.id,
+									fieldName: row.fieldName,
+									operation: operation.id,
+									value: values[cellPath(path, namespace.id, row.fieldName, operation.id)] !== true
+								});
+							},
+							readOnly,
+							state: values[cellPath(path, namespace.id, row.fieldName, operation.id)] === true ? "on" : "off"
+						}) : /*#__PURE__*/ jsx(Dash, {})
+					}, operation.id))] }, row.fieldName);
+				}) })
+			]
+		})
+	});
+};
+const ToolsTable = ({ matrix, path, readOnly, toggle, values }) => {
+	const toolState = toolsState(matrix, path, values);
+	return /*#__PURE__*/ jsx("section", {
+		style: styles.section,
+		children: /*#__PURE__*/ jsxs("table", {
+			style: styles.table,
+			children: [
+				/*#__PURE__*/ jsx(Columns, { count: 1 }),
+				/*#__PURE__*/ jsxs("thead", {
+					style: styles.head,
+					children: [/*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
+						scope: "col",
+						style: {
+							...styles.headTitle,
+							...styles.topStart
+						},
+						children: "Tools"
+					}), /*#__PURE__*/ jsx("th", {
+						scope: "col",
+						style: {
+							...styles.headOperation,
+							...styles.topEnd
+						},
+						children: "Enabled"
+					})] }), /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
+						scope: "row",
+						style: {
+							...styles.headLabel,
+							...styles.rule
+						},
+						children: "All"
+					}), /*#__PURE__*/ jsx("td", {
+						style: {
+							...cellStyle(true),
+							...styles.rule
+						},
+						children: /*#__PURE__*/ jsx(Box, {
+							label: "Enable every tool",
+							onChange: () => {
+								toggle({
+									kind: "tools",
+									value: toolState !== "on"
+								});
+							},
+							readOnly,
+							state: toolState
+						})
+					})] })]
+				}),
+				/*#__PURE__*/ jsx("tbody", { children: matrix.tools.map((tool) => /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsxs("th", {
+					scope: "row",
+					style: styles.rowHeader,
+					children: [tool.name, /*#__PURE__*/ jsx("span", {
+						style: styles.hint,
+						children: tool.description
+					})]
+				}), /*#__PURE__*/ jsx("td", {
+					style: cellStyle(true),
+					children: /*#__PURE__*/ jsx(Box, {
+						label: `Enable ${tool.name}`,
+						onChange: () => {
+							toggle({
+								kind: "tool",
+								name: tool.name,
+								value: values[toolPath(path, tool.name)] !== true
+							});
+						},
+						readOnly,
+						state: values[toolPath(path, tool.name)] === true ? "on" : "off"
+					})
+				})] }, tool.name)) })
+			]
+		})
+	});
+};
+/**
+* What an API key may do, as one table per namespace: a row per entity, a
+* column per operation and a bulk toggle in each column header. The nested
+* checkbox fields back every cell, so the stored document is unaffected.
+*/ const McpxCapabilityMatrix = ({ field, matrix, path = CAPABILITIES_FIELD, readOnly = false, withinTab = false }) => {
+	const { dispatchFields, setModified } = useForm();
+	const paths = useMemo(() => capabilityPaths(matrix, path), [matrix, path]);
+	const encoded = useFormFields(([fields]) => paths.map((cell) => fields[cell]?.value === true ? "1" : "0").join(""));
+	const values = useMemo(() => Object.fromEntries(paths.map((cell, index) => [cell, encoded[index] === "1"])), [paths, encoded]);
+	const toggle = useCallback((intent) => {
+		const actions = buildToggleActions(matrix, path, values, intent);
+		if (actions.length === 0) return;
+		for (const action of actions) dispatchFields(action);
+		setModified(true);
+	}, [
+		matrix,
+		path,
+		values,
+		dispatchFields,
+		setModified
+	]);
+	const namespaces = [{
+		id: "collections",
+		title: "Collections"
+	}, {
+		id: "globals",
+		title: "Globals"
+	}].filter((namespace) => matrix[namespace.id].length > 0);
+	return /*#__PURE__*/ jsxs("div", {
+		className: [
+			"field-type",
+			"group-field",
+			"group-field--top-level",
+			withinTab && "group-field--within-tab",
+			BASE_CLASS
+		].filter(Boolean).join(" "),
+		children: [/*#__PURE__*/ jsx("style", { children: SHEET }), /*#__PURE__*/ jsxs("div", {
+			className: "group-field__wrap",
+			children: [
+				/*#__PURE__*/ jsx("div", {
+					className: "group-field__header",
+					children: /*#__PURE__*/ jsxs("header", { children: [/*#__PURE__*/ jsx("h3", {
+						className: "group-field__title",
+						children: /*#__PURE__*/ jsx(FieldLabel, {
+							as: "span",
+							label: "Capabilities"
+						})
+					}), typeof field?.admin?.description === "string" ? /*#__PURE__*/ jsx(FieldDescription, {
+						description: field.admin.description,
+						path
+					}) : null] })
+				}),
+				namespaces.map((namespace) => /*#__PURE__*/ jsx(NamespaceTable, {
+					matrix,
+					namespace,
+					path,
+					readOnly,
+					toggle,
+					values
+				}, namespace.id)),
+				matrix.tools.length > 0 ? /*#__PURE__*/ jsx(ToolsTable, {
+					matrix,
+					path,
+					readOnly,
+					toggle,
+					values
+				}) : null
+			]
+		})]
+	});
+};
+//#endregion
+export { McpxCapabilityMatrix };

package/dist/admin/capability-toggles.mjs

@@ -0,0 +1,73 @@
+import { CAPABILITY_OPERATIONS, cellPath, toolPath } from "../api-keys/capability-matrix.mjs";
+//#region src/admin/capability-toggles.ts
+const stateOf = (paths, values) => {
+	if (paths.length === 0) return "off";
+	const granted = paths.filter((path) => values[path] === true).length;
+	if (granted === 0) return "off";
+	return granted === paths.length ? "on" : "mixed";
+};
+/**
+* Whether a column's bulk toggle reads as on, off or indeterminate. Cells the
+* config does not expose are ignored: two granted cells and one dash read as on.
+*/ const columnState = (matrix, basePath, namespace, operation, values) => stateOf(matrix[namespace].filter((row) => row[operation]).map((row) => cellPath(basePath, namespace, row.fieldName, operation)), values);
+/**
+* Whether an entity's row toggle reads as on, off or indeterminate, over the
+* operations the config exposes for that row.
+*/ const rowState = (basePath, namespace, row, values) => stateOf(CAPABILITY_OPERATIONS.filter((operation) => row[operation.id]).map((operation) => cellPath(basePath, namespace, row.fieldName, operation.id)), values);
+const toolsState = (matrix, basePath, values) => stateOf(matrix.tools.map((tool) => toolPath(basePath, tool.name)), values);
+const reconcile = (next, touched) => {
+	if (touched.has("publish") && next.publish) return {
+		...next,
+		write: true
+	};
+	if (touched.has("write") && !next.write) return {
+		...next,
+		publish: false
+	};
+	return next;
+};
+const rowActions = (basePath, namespace, row, values, changes) => {
+	const current = {
+		read: values[cellPath(basePath, namespace, row.fieldName, "read")] === true,
+		write: values[cellPath(basePath, namespace, row.fieldName, "write")] === true,
+		publish: values[cellPath(basePath, namespace, row.fieldName, "publish")] === true
+	};
+	const touched = /* @__PURE__ */ new Set();
+	const next = { ...current };
+	for (const operation of CAPABILITY_OPERATIONS) {
+		const change = changes[operation.id];
+		if (change !== void 0 && row[operation.id]) {
+			next[operation.id] = change;
+			touched.add(operation.id);
+		}
+	}
+	const reconciled = reconcile(next, touched);
+	return CAPABILITY_OPERATIONS.filter((operation) => row[operation.id] && reconciled[operation.id] !== current[operation.id]).map((operation) => ({
+		type: "UPDATE",
+		path: cellPath(basePath, namespace, row.fieldName, operation.id),
+		value: reconciled[operation.id]
+	}));
+};
+/**
+* The form-state updates one click implies, as literal actions. Every toggle
+* (cell, row, column or tool) comes through here, so the publish rule applies
+* to bulk grants too.
+*
+* Only cells whose value changes get an action, so a bulk toggle that changes
+* nothing does not mark the form modified.
+*/ const buildToggleActions = (matrix, basePath, values, intent) => {
+	if (intent.kind === "tool" || intent.kind === "tools") return matrix.tools.filter((tool) => intent.kind === "tools" || tool.name === intent.name).filter((tool) => values[toolPath(basePath, tool.name)] === true !== intent.value).map((tool) => ({
+		type: "UPDATE",
+		path: toolPath(basePath, tool.name),
+		value: intent.value
+	}));
+	const rows = matrix[intent.namespace].filter((row) => intent.kind === "column" || row.fieldName === intent.fieldName);
+	const changes = intent.kind === "row" ? {
+		read: intent.value,
+		write: intent.value,
+		publish: intent.value
+	} : { [intent.operation]: intent.value };
+	return rows.flatMap((row) => rowActions(basePath, intent.namespace, row, values, changes));
+};
+//#endregion
+export { buildToggleActions, columnState, rowState, toolsState };

package/dist/{client → admin}/setup-guide.d.mts

@@ -1,7 +1,9 @@
 import React from "react";
-//#region src/client/setup-guide.d.ts
+//#region src/admin/setup-guide.d.ts
 interface McpxSetupGuideProps {
-  /** Endpoint path below the API route, from the plugin options. */
+  /**
+   * Endpoint path below the API route, from the plugin options.
+   */
   endpointPath: string;
 }
 /**

package/dist/{client → admin}/setup-guide.mjs

@@ -3,23 +3,16 @@ import { buildSetupGuide } from "../api-keys/setup-guide.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { CopyToClipboard, useConfig, useDocumentInfo, useFormFields } from "@payloadcms/ui";
 import { useEffect, useState } from "react";
-//#region src/client/setup-guide.tsx
+//#region src/admin/setup-guide.tsx
 const asString = (value) => typeof value === "string" ? value : void 0;
-/**
-* Reads `serverURL` when the config sets one and falls back to the browser's
-* origin. The fallback has to wait for mount: this component is server-rendered
-* first, where `window` does not exist.
-*/ const useOrigin = (serverUrl) => {
+const useOrigin = (serverUrl) => {
 	const [origin, setOrigin] = useState(serverUrl);
 	useEffect(() => {
 		if (serverUrl === "") setOrigin(window.location.origin);
 	}, [serverUrl]);
 	return origin;
 };
-/**
-* Payload's own theme variables, so the panel follows the admin's light and
-* dark themes without shipping a stylesheet consumers would have to transpile.
-*/ const styles = {
+const styles = {
 	lead: { marginBottom: "calc(var(--base) * 0.75)" },
 	section: { marginBottom: "calc(var(--base) * 0.75)" },
 	sectionHeader: {

package/dist/api-keys/capability-matrix.d.mts

@@ -1,28 +1,32 @@
 import "../options.mjs";
 //#region src/api-keys/capability-matrix.d.ts
 /**
- * One entity's row. The three booleans say what the plugin config exposes, not
- * what the key has been granted: a `false` renders as a dash rather than an
- * empty box, so absence reads as a refusal by config rather than a gap.
+ * One entity's row. The booleans say what the plugin config exposes, not what
+ * the key was granted. A `false` renders as a dash, so absence reads as a
+ * refusal by config rather than a gap.
  */
 export interface CapabilityRow {
   fieldName: string;
-  /** The slug, which is what MCP clients send and what refusals name. */
+  /**
+   * The slug, which is what MCP clients send and what refusals name.
+   */
   label: string;
   read: boolean;
   write: boolean;
   publish: boolean;
-  /** Said only where a row departs from what its column header promises. */
+  /**
+   * Said only where a row departs from what its column header promises.
+   */
   hint?: string;
 }
-export interface CapabilityTool {
+interface CapabilityTool {
   name: string;
   description: string;
 }
 /**
  * Everything the admin component needs to draw the matrix, derived from the
- * plugin options at config time. Crosses the server/client boundary as a client
- * prop, so every leaf has to stay JSON-serializable.
+ * plugin options at config time. Passed as a client prop, so every leaf must be
+ * JSON-serializable.
  */
 export interface CapabilityMatrix {
   collections: CapabilityRow[];

package/dist/api-keys/capability-matrix.mjs

@@ -1,14 +1,13 @@
-import { CAPABILITIES_FIELD, canCreate, canPublish, canWrite } from "../capabilities.mjs";
+import { CAPABILITIES_FIELD, canPublish, canWrite, isLiveWrite } from "../capabilities.mjs";
 //#region src/api-keys/capability-matrix.ts
 /**
-* The group's `admin.description`, which the matrix renders in Payload's own
-* description slot under the heading. It is the one place the two markings in
-* the table are explained, so both belong in it.
+* The group's `admin.description`, rendered by the matrix in Payload's
+* description slot. It explains both markings in the table: an unticked box
+* and a dash.
 */ const CAPABILITIES_DESCRIPTION = "What this key may do. An unticked box is a refusal, and a dash means the plugin config does not expose that operation at all.";
 /**
-* The three operations a collection or global can expose, described once. The
-* generated checkboxes and the matrix column headers both read these, so the
-* wording a key's owner sees cannot drift from what the field config carries.
+* The operations a collection or global can expose. The generated checkboxes
+* and the matrix column headers share this wording.
 */ const CAPABILITY_OPERATIONS = [
 	{
 		id: "read",
@@ -26,19 +25,20 @@ import { CAPABILITIES_FIELD, canCreate, canPublish, canWrite } from "../capabili
 		description: "Promote the current draft to what the public sees."
 	}
 ];
-const UPLOAD_HINT = "Files are uploaded in the admin panel.";
+const LIVE_HINT = "Writes go live immediately.";
+const hintFor = (entity) => isLiveWrite(entity) ? { hint: LIVE_HINT } : {};
 const toRow = (entity) => ({
 	fieldName: entity.fieldName,
 	label: entity.slug,
 	read: entity.read,
 	write: canWrite(entity),
 	publish: canPublish(entity),
-	...canWrite(entity) && !canCreate(entity) ? { hint: UPLOAD_HINT } : {}
+	...hintFor(entity)
 });
 /**
 * The single description of what the config exposes. `createCapabilityFields`
-* generates its checkboxes from this, and the admin component draws from it, so
-* a cell can never appear without a field behind it.
+* and the admin component both draw from it, so a cell cannot appear without a
+* field behind it.
 */ const createCapabilityMatrix = (options) => ({
 	collections: options.collections.map(toRow),
 	globals: options.globals.map(toRow),
@@ -49,80 +49,8 @@ const toRow = (entity) => ({
 });
 const cellPath = (basePath, namespace, fieldName, operation) => `${basePath}.${namespace}.${fieldName}.${operation}`;
 const toolPath = (basePath, name) => `${basePath}.tools.${name}`;
-/** Every path the matrix can address, in a stable order. */ const capabilityPaths = (matrix, basePath = CAPABILITIES_FIELD) => [...["collections", "globals"].flatMap((namespace) => matrix[namespace].flatMap((row) => CAPABILITY_OPERATIONS.filter((operation) => row[operation.id]).map((operation) => cellPath(basePath, namespace, row.fieldName, operation.id)))), ...matrix.tools.map((tool) => toolPath(basePath, tool.name))];
-const stateOf = (paths, values) => {
-	if (paths.length === 0) return "off";
-	const granted = paths.filter((path) => values[path] === true).length;
-	if (granted === 0) return "off";
-	return granted === paths.length ? "on" : "mixed";
-};
 /**
-* Whether a column's bulk toggle reads as on, off or indeterminate. Non-exposed
-* cells are ignored: a column of two granted cells and one dash is fully on.
-*/ const columnState = (matrix, basePath, namespace, operation, values) => stateOf(matrix[namespace].filter((row) => row[operation]).map((row) => cellPath(basePath, namespace, row.fieldName, operation)), values);
-/**
-* Whether an entity's row toggle reads as on, off or indeterminate, over the
-* operations the config exposes for that row.
-*/ const rowState = (basePath, namespace, row, values) => stateOf(CAPABILITY_OPERATIONS.filter((operation) => row[operation.id]).map((operation) => cellPath(basePath, namespace, row.fieldName, operation.id)), values);
-const toolsState = (matrix, basePath, values) => stateOf(matrix.tools.map((tool) => toolPath(basePath, tool.name)), values);
-/**
-* Publishing is an extension of writing, and `publishFlag` in `capabilities.ts`
-* discards a publish without a write. Ticking publish therefore ticks write,
-* and clearing write clears publish, so the form cannot save a combination the
-* server ignores.
-*/ const reconcile = (next, touched) => {
-	if (touched.has("publish") && next.publish) return {
-		...next,
-		write: true
-	};
-	if (touched.has("write") && !next.write) return {
-		...next,
-		publish: false
-	};
-	return next;
-};
-const rowActions = (basePath, namespace, row, values, changes) => {
-	const current = {
-		read: values[cellPath(basePath, namespace, row.fieldName, "read")] === true,
-		write: values[cellPath(basePath, namespace, row.fieldName, "write")] === true,
-		publish: values[cellPath(basePath, namespace, row.fieldName, "publish")] === true
-	};
-	const touched = /* @__PURE__ */ new Set();
-	const next = { ...current };
-	for (const operation of CAPABILITY_OPERATIONS) {
-		const change = changes[operation.id];
-		if (change !== void 0 && row[operation.id]) {
-			next[operation.id] = change;
-			touched.add(operation.id);
-		}
-	}
-	const reconciled = reconcile(next, touched);
-	return CAPABILITY_OPERATIONS.filter((operation) => row[operation.id] && reconciled[operation.id] !== current[operation.id]).map((operation) => ({
-		type: "UPDATE",
-		path: cellPath(basePath, namespace, row.fieldName, operation.id),
-		value: reconciled[operation.id]
-	}));
-};
-/**
-* The form-state updates one click implies, as literal actions. Every toggle in
-* the matrix — cell, row, column or tool — comes through here, so the publish
-* rule holds for bulk grants as much as for a single box.
-*
-* Only cells whose value actually changes get an action, which keeps a bulk
-* toggle from marking the form modified when it changes nothing.
-*/ const buildToggleActions = (matrix, basePath, values, intent) => {
-	if (intent.kind === "tool" || intent.kind === "tools") return matrix.tools.filter((tool) => intent.kind === "tools" || tool.name === intent.name).filter((tool) => values[toolPath(basePath, tool.name)] === true !== intent.value).map((tool) => ({
-		type: "UPDATE",
-		path: toolPath(basePath, tool.name),
-		value: intent.value
-	}));
-	const rows = matrix[intent.namespace].filter((row) => intent.kind === "column" || row.fieldName === intent.fieldName);
-	const changes = intent.kind === "row" ? {
-		read: intent.value,
-		write: intent.value,
-		publish: intent.value
-	} : { [intent.operation]: intent.value };
-	return rows.flatMap((row) => rowActions(basePath, intent.namespace, row, values, changes));
-};
+* Every path the matrix can address, in a stable order.
+*/ const capabilityPaths = (matrix, basePath = CAPABILITIES_FIELD) => [...["collections", "globals"].flatMap((namespace) => matrix[namespace].flatMap((row) => CAPABILITY_OPERATIONS.filter((operation) => row[operation.id]).map((operation) => cellPath(basePath, namespace, row.fieldName, operation.id)))), ...matrix.tools.map((tool) => toolPath(basePath, tool.name))];
 //#endregion
-export { CAPABILITIES_DESCRIPTION, CAPABILITY_OPERATIONS, buildToggleActions, capabilityPaths, cellPath, columnState, createCapabilityMatrix, rowState, toolPath, toolsState };
+export { CAPABILITIES_DESCRIPTION, CAPABILITY_OPERATIONS, capabilityPaths, cellPath, createCapabilityMatrix, toolPath };