domma-cms 0.55.1 → 0.66.0

package/server/services/contextMenus.js

@@ -0,0 +1,477 @@
+/**
+ * Context menus - right-click menus bound to a region of a page.
+ *
+ * Deliberately NOT part of the menu system. A nav menu renders into a named
+ * slot and has a server render path; a context menu has neither. It binds to a
+ * CSS selector, exists only in the browser, and is resolved at right-click time
+ * by Domma walking outward from the clicked element. So `resolveLocation` and
+ * `buildMenuNav` are not reused here - see the domma-menus skill, which says as
+ * much.
+ *
+ * What IS reused is `binding`, in exactly the shape menus already use, so
+ * per-page and per-project scoping behaves identically and editors only learn
+ * it once.
+ *
+ * Storage mirrors menus: one file per menu under config/context-menus/.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import * as cache from './cache/index.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CONFIG_DIR = path.resolve(__dirname, '..', '..', 'config');
+const CTX_DIR = path.join(CONFIG_DIR, 'context-menus');
+
+const SLUG_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+
+/** Cached index, invalidated on every write. Mirrors getAllMenus(). */
+let _index = null;
+
+export function invalidateContextMenuIndex() {
+    _index = null;
+}
+
+/**
+ * Drop every cached page so an edited menu reaches the front end.
+ *
+ * `site` is the tag to use: routes/public.js stores each page under
+ * [`page:<urlPath>`, ...page.cacheTags, 'nav', 'site'], so `site` is the only
+ * one that covers all of them, and a context menu can apply to any page.
+ *
+ * This was two bugs in one line. It called `invalidateTag` (singular), which
+ * the cache module does not export, and it passed 'pages', which nothing is
+ * ever tagged with - so even the corrected call would have matched nothing.
+ * The catch swallowed the TypeError, and because the cache is off in dev and
+ * on in production, editing a menu worked locally and did nothing live for an
+ * hour. Failures are logged now: "the cache is optional" is a reason to carry
+ * on after a cache error, not a reason to hide one.
+ */
+async function invalidatePageCache() {
+    try {
+        await cache.invalidateTags(['site']);
+    } catch (err) {
+        console.warn(`[context-menus] Page cache not invalidated: ${err.message}`);
+    }
+}
+
+export function validateSlug(slug) {
+    return typeof slug === 'string' && slug.length <= 64 && SLUG_RE.test(slug);
+}
+
+export async function ensureContextMenusDir() {
+    await fs.mkdir(CTX_DIR, {recursive: true});
+}
+
+function ctxPath(slug) {
+    return path.join(CTX_DIR, `${slug}.json`);
+}
+
+async function readCtxFile(slug) {
+    return JSON.parse(await fs.readFile(ctxPath(slug), 'utf8'));
+}
+
+async function writeCtxFile(menu) {
+    await ensureContextMenusDir();
+    await fs.writeFile(ctxPath(menu.slug), JSON.stringify(menu, null, 2) + '\n', 'utf8');
+    invalidateContextMenuIndex();
+    await invalidatePageCache();
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+const INHERIT = new Set(['append', 'prepend', false]);
+const TRANSITIONS = new Set(['scale', 'fade', 'slide', 'none']);
+const DENSITIES = new Set(['comfortable', 'compact']);
+const SCALE = new Set(['none', 'sm', 'md', 'lg', 'xl']);
+const ACCENTS = new Set(['primary', 'success', 'danger', 'warning', 'info']);
+const HEX_RE = /^#[0-9a-fA-F]{6}$/;
+
+/*
+ * Action types an authored item may carry. Arbitrary JavaScript is deliberately
+ * not one of them: admin/ is replaced wholesale by the updater, so anything an
+ * editor pasted would be lost on the next update, and a stored script running
+ * on public pages is a cross-site scripting hole with extra steps. Anything
+ * bespoke goes through `run-action`, which names an Actions artefact that has
+ * its own permissions.
+ */
+export const ACTION_TYPES = new Set([
+    'navigate',      // {url}
+    'filter',        // {field, op, value} - collection displays
+    'search',        // opens the display's search
+    'sort',          // {field, dir}
+    'export',        // {format}
+    'copy-link',
+    'print',
+    'open-modal',    // {block} - renders a block into a modal
+    'run-action',    // {slug} - an Actions artefact
+    'mark-as-spam',  // {field} - flags the clicked entry, default field `spam`
+
+    /*
+     * Specials - the things a browser's own context menu offers. They take no
+     * arguments and each decides for itself whether it applies to the click:
+     * back greys out with no history behind it, paste unless the click landed
+     * in something editable. That is `disabled` rather than hidden, so the menu
+     * keeps a stable shape and reads the way a native one does.
+     */
+    'reload',
+    'back',
+    'forward',
+    'copy',          // the current selection
+    'cut',
+    'paste',
+    'select-all',
+    'site-search'    // opens the public search overlay (public/js/search.js)
+]);
+
+const ITEM_TYPES = new Set(['item', 'divider', 'header', 'checkbox', 'radio']);
+
+/*
+ * A selector an editor types is applied with querySelector at right-click time.
+ * These are the ones that would bind the menu to the entire document and make
+ * every other menu on the page unreachable - a mistake that looks like "context
+ * menus are broken" rather than like a typo.
+ */
+const FORBIDDEN_SELECTORS = new Set(['*', 'html', 'body', ':root', 'head']);
+
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/**
+ * Validate a context menu. Returns an array of human-readable errors; empty
+ * means valid. Mirrors validateMenu()'s contract so the routes handle both the
+ * same way.
+ *
+ * @param   {object} menu
+ * @returns {string[]}
+ */
+export function validateContextMenu(menu) {
+    const errors = [];
+
+    if (!isPlainObject(menu)) return ['Context menu must be an object'];
+    if (!validateSlug(menu.slug)) errors.push(`Invalid slug: ${menu.slug}`);
+    if (!menu.name || typeof menu.name !== 'string') errors.push('Name is required');
+
+    // --- target ---
+    const t = menu.target;
+    if (!isPlainObject(t)) {
+        errors.push('target is required');
+    } else {
+        if (!t.selector || typeof t.selector !== 'string') {
+            errors.push('target.selector is required');
+        } else {
+            const sel = t.selector.trim();
+            if (FORBIDDEN_SELECTORS.has(sel.toLowerCase())) {
+                errors.push(`target.selector "${sel}" would bind the whole page`);
+            }
+            for (const key of ['selector', 'match', 'exclude']) {
+                const v = t[key];
+                if (v === undefined || v === null || v === '') continue;
+                if (typeof v !== 'string') { errors.push(`target.${key} must be a string`); continue; }
+                try {
+                    document?.querySelector?.(v);
+                } catch { /* no DOM on the server - checked below instead */ }
+                // Cheap structural check: a selector with unbalanced brackets is
+                // a typo that would otherwise throw inside the visitor's browser.
+                const balanced = (a, b) => (v.split(a).length === v.split(b).length);
+                if (!balanced('[', ']') || !balanced('(', ')')) {
+                    errors.push(`target.${key} is not a valid selector: ${v}`);
+                }
+            }
+        }
+    }
+
+    // --- cascade ---
+    if (menu.inherit !== undefined && !INHERIT.has(menu.inherit)) {
+        errors.push('inherit must be "append", "prepend" or false');
+    }
+    if (menu.priority !== undefined && !Number.isInteger(menu.priority)) {
+        errors.push('priority must be an integer');
+    }
+
+    // --- theme ---
+    const th = menu.theme;
+    if (th !== undefined) {
+        if (!isPlainObject(th)) {
+            errors.push('theme must be an object');
+        } else {
+            if (th.accent && !ACCENTS.has(th.accent) && !HEX_RE.test(th.accent)) {
+                errors.push(`theme.accent must be a preset key or #rrggbb: ${th.accent}`);
+            }
+            for (const key of ['radius', 'shadow']) {
+                if (th[key] && !SCALE.has(th[key])) {
+                    errors.push(`theme.${key} must be one of none, sm, md, lg, xl`);
+                }
+            }
+            if (th.density && !DENSITIES.has(th.density)) {
+                errors.push('theme.density must be "comfortable" or "compact"');
+            }
+            if (th.transition && !TRANSITIONS.has(th.transition)) {
+                errors.push('theme.transition must be scale, fade, slide or none');
+            }
+            if (th.opacity !== undefined && th.opacity !== null) {
+                const n = Number(th.opacity);
+                if (!Number.isFinite(n) || n < 20 || n > 100) {
+                    errors.push('theme.opacity must be between 20 and 100');
+                }
+            }
+        }
+    }
+
+    // --- items ---
+    if (!Array.isArray(menu.items)) {
+        errors.push('items must be an array');
+    } else {
+        validateItems(menu.items, errors, 'items');
+        const usable = menu.items.filter(
+            (i) => isPlainObject(i) && !['divider', 'header'].includes(i.type)
+        );
+        if (!usable.length) {
+            errors.push('A menu needs at least one item that is not a divider or header');
+        }
+    }
+
+    return errors;
+}
+
+function validateItems(items, errors, trail, depth = 0) {
+    if (depth > 4) { errors.push(`${trail}: submenus nested more than 4 deep`); return; }
+
+    items.forEach((item, i) => {
+        const at = `${trail}[${i}]`;
+        if (!isPlainObject(item)) { errors.push(`${at} must be an object`); return; }
+
+        const type = item.type || 'item';
+        if (!ITEM_TYPES.has(type)) { errors.push(`${at}.type "${type}" is not recognised`); return; }
+        if (type === 'divider') return;
+        if (!item.text || typeof item.text !== 'string') errors.push(`${at}.text is required`);
+        if (type === 'header') return;
+
+        const hasSub = Array.isArray(item.submenu) && item.submenu.length;
+        if (hasSub) {
+            validateItems(item.submenu, errors, `${at}.submenu`, depth + 1);
+            return;   // a parent carries its children, not an action
+        }
+
+        const a = item.action;
+        if (!isPlainObject(a)) {
+            errors.push(`${at}.action is required (or give it a submenu)`);
+        } else if (!ACTION_TYPES.has(a.type)) {
+            errors.push(`${at}.action.type "${a.type}" is not recognised`);
+        } else {
+            if (a.type === 'navigate' && !a.url) errors.push(`${at}.action.url is required`);
+            if (a.type === 'run-action' && !a.slug) errors.push(`${at}.action.slug is required`);
+            if (a.type === 'open-modal' && !a.block) errors.push(`${at}.action.block is required`);
+        }
+    });
+}
+
+function normaliseBinding(binding) {
+    if (!isPlainObject(binding)) return undefined;
+    const out = {};
+    if (Array.isArray(binding.projects)) out.projects = binding.projects.filter((p) => typeof p === 'string');
+    if (Array.isArray(binding.pages)) out.pages = binding.pages.filter((p) => typeof p === 'string');
+    return (out.projects?.length || out.pages?.length) ? out : undefined;
+}
+
+function shape(input) {
+    const menu = {
+        slug: input.slug,
+        name: input.name,
+        description: input.description || '',
+        enabled: input.enabled !== false,
+        target: {
+            selector: String(input.target?.selector || '').trim(),
+            ...(input.target?.match && {match: String(input.target.match).trim()}),
+            ...(input.target?.exclude && {exclude: String(input.target.exclude).trim()})
+        },
+        inherit: input.inherit === undefined ? 'append' : input.inherit,
+        ...(Number.isInteger(input.priority) && input.priority !== 0 && {priority: input.priority}),
+        ...(isPlainObject(input.theme) && Object.keys(input.theme).length && {theme: input.theme}),
+        items: Array.isArray(input.items) ? input.items : []
+    };
+    const binding = normaliseBinding(input.binding);
+    if (binding) menu.binding = binding;
+    if (isPlainObject(input.meta) && Object.keys(input.meta).length) menu.meta = input.meta;
+    return menu;
+}
+
+// ---------------------------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------------------------
+
+/** List all context menus, metadata only. Sorted by slug. */
+export async function listContextMenus() {
+    await ensureContextMenusDir();
+    const files = await fs.readdir(CTX_DIR);
+    const out = [];
+    for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        const slug = file.slice(0, -5);
+        if (!validateSlug(slug)) continue;
+        try {
+            const menu = await readCtxFile(slug);
+            out.push({
+                slug:        menu.slug || slug,
+                name:        menu.name || '',
+                description: menu.description || '',
+                enabled:     menu.enabled !== false,
+                selector:    menu.target?.selector || '',
+                match:       menu.target?.match || '',
+                itemsCount:  Array.isArray(menu.items) ? menu.items.length : 0,
+                ...(menu.binding && {binding: menu.binding}),
+                meta:        menu.meta || {}
+            });
+        } catch (err) {
+            console.warn(`[context-menus] Skipping malformed menu "${slug}": ${err.message}`);
+        }
+    }
+    return out.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+/** Every menu in full, cached in-process. Used by the page resolver. */
+export async function getAllContextMenus() {
+    if (_index) return _index;
+    await ensureContextMenusDir();
+    const files = await fs.readdir(CTX_DIR);
+    const out = [];
+    for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        const slug = file.slice(0, -5);
+        if (!validateSlug(slug)) continue;
+        try {
+            out.push(await readCtxFile(slug));
+        } catch { /* listContextMenus() already warns */ }
+    }
+    _index = out;
+    return out;
+}
+
+export async function getContextMenu(slug) {
+    if (!validateSlug(slug)) return null;
+    try {
+        return await readCtxFile(slug);
+    } catch (err) {
+        if (err.code === 'ENOENT') return null;
+        throw err;
+    }
+}
+
+export async function createContextMenu(input) {
+    if (!validateSlug(input?.slug)) throw new Error(`Invalid slug: ${input?.slug}`);
+    if (await getContextMenu(input.slug)) throw new Error(`Context menu "${input.slug}" already exists`);
+
+    const menu = shape(input);
+    const errors = validateContextMenu(menu);
+    if (errors.length) throw new Error(errors.join('; '));
+
+    await writeCtxFile(menu);
+    return menu;
+}
+
+export async function updateContextMenu(slug, input) {
+    const existing = await getContextMenu(slug);
+    if (!existing) throw new Error(`Context menu "${slug}" not found`);
+
+    // The slug is the filename and the identity; renaming is a delete plus a
+    // create, not an edit.
+    const menu = shape({...existing, ...input, slug});
+    const errors = validateContextMenu(menu);
+    if (errors.length) throw new Error(errors.join('; '));
+
+    await writeCtxFile(menu);
+    return menu;
+}
+
+export async function deleteContextMenu(slug) {
+    if (!validateSlug(slug)) throw new Error(`Invalid slug: ${slug}`);
+    try {
+        await fs.unlink(ctxPath(slug));
+    } catch (err) {
+        if (err.code === 'ENOENT') throw new Error(`Context menu "${slug}" not found`);
+        throw err;
+    }
+    invalidateContextMenuIndex();
+    await invalidatePageCache();
+    return true;
+}
+
+export async function duplicateContextMenu(slug) {
+    const source = await getContextMenu(slug);
+    if (!source) throw new Error(`Context menu "${slug}" not found`);
+
+    let candidate = `${slug}-copy`;
+    let n = 2;
+    while (await getContextMenu(candidate)) candidate = `${slug}-copy-${n++}`;
+
+    return createContextMenu({...source, slug: candidate, name: `${source.name} (copy)`});
+}
+
+// ---------------------------------------------------------------------------
+// Page resolution
+// ---------------------------------------------------------------------------
+
+/** `/shop/*` matches `/shop/thing`; an exact path matches itself. */
+function matchesPage(pattern, urlPath) {
+    if (!pattern || !urlPath) return false;
+    if (pattern === urlPath) return true;
+    if (pattern.endsWith('/*')) return urlPath.startsWith(pattern.slice(0, -1));
+    return false;
+}
+
+/**
+ * Every context menu that applies to a page.
+ *
+ * Unlike a slot, this is NOT one-menu-wins: several can apply at once and
+ * Domma decides which answers a given right-click by walking outward from the
+ * click. That is the same resolution the `overlay` slot uses, one level down -
+ * region rather than slot.
+ *
+ * A menu with no binding is site-wide. A menu with a binding applies only where
+ * it matches, so binding is a narrowing, never a widening.
+ *
+ * @param   {{urlPath?: string, project?: string}} ctx
+ * @returns {Promise<object[]>} payloads for the browser, in binding order
+ */
+export async function resolveContextMenusForPage(ctx = {}) {
+    const all = await getAllContextMenus();
+    const {urlPath, project} = ctx;
+
+    const applies = all.filter((menu) => {
+        if (menu.enabled === false) return false;
+        const b = menu.binding;
+        if (!b) return true;                       // site-wide
+        if (b.pages?.length && urlPath && b.pages.some((p) => matchesPage(p, urlPath))) return true;
+        if (b.projects?.length && project && b.projects.includes(project)) return true;
+        return false;
+    });
+
+    /*
+     * A bound menu is more specific than a site-wide one, so it is sent later:
+     * where two menus bind the same element Domma breaks the tie on `priority`
+     * and then on registration order, and the more specific one should win.
+     */
+    applies.sort((a, b) => Number(Boolean(a.binding)) - Number(Boolean(b.binding)));
+
+    return applies.map(toClientPayload);
+}
+
+/**
+ * The browser needs the binding and the items, not the editor's metadata.
+ * Keeping the payload narrow also keeps it out of the page source for menus a
+ * visitor cannot use.
+ */
+export function toClientPayload(menu) {
+    return {
+        slug: menu.slug,
+        target: menu.target,
+        inherit: menu.inherit === undefined ? 'append' : menu.inherit,
+        ...(menu.priority && {priority: menu.priority}),
+        ...(menu.theme && {theme: menu.theme}),
+        items: menu.items || []
+    };
+}

package/server/services/markdown.js

@@ -97,12 +97,44 @@ function buildShortcodeFilter(attrs) {
  * Load a block template by name from content/blocks/{name}.html.
  * Throws if the file does not exist.
  *
+ * The template's HTML comments are DROPPED here, before anything looks at it.
+ * Every block ships with a header comment documenting its parameters and
+ * showing an example call - documentation for whoever opens the file, which
+ * has no business on a public page and, worse, is still live markup by the
+ * time the shortcode processor sees it.
+ *
+ * `plugin-card` is what that costs: its example reads
+ * `[collection slug="plugins" display="block" block="plugin-card" …]` with no
+ * `/]`, so the processor took it for an unclosed tag and swallowed the rest of
+ * the render. Four plugin cards came out as one empty `<div>`, and the block's
+ * stylesheet came out as prose. The card that renders documentation for itself
+ * is not a rare shape - every bundled block has that comment - so this is
+ * fixed at the load point rather than in one template.
+ *
  * @param {string} blockName
  * @returns {Promise<string>}
  */
 async function loadBlockTemplate(blockName) {
     const safe = path.basename(blockName).replace(/[^a-z0-9-]/g, '');
-    return readFile(path.join(BLOCKS_DIR, `${safe}.html`), 'utf8');
+    const raw = await readFile(path.join(BLOCKS_DIR, `${safe}.html`), 'utf8');
+    return stripTemplateComments(raw);
+}
+
+/**
+ * Remove HTML comments from a block template.
+ *
+ * Unterminated (`<!--` with no `-->`) is treated as comment-to-end: a truncated
+ * comment leaking its remainder onto the page is the failure this exists to
+ * prevent, so the safe reading is that everything after it was meant to be one.
+ *
+ * @param {string} tpl
+ * @returns {string}
+ */
+export function stripTemplateComments(tpl) {
+    return String(tpl || '')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<!--[\s\S]*$/, '')
+        .trim();
 }
 
 /**
@@ -258,9 +290,23 @@ function blockTemplateFields(tpl) {
     return [...names].map(n => ({name: n, label: n}));
 }
 
-function buildBlockStyleTag(blockName, css) {
+/**
+ * Wrap a block's CSS in a `<style>` scoped to that block.
+ *
+ * BLANK LINES ARE REMOVED, and that is the whole of the second bug here. A
+ * block rendered inside another shortcode's wrapper - `[reveal]`, a `[col]`,
+ * anything - arrives mid-HTML-block as far as Markdown is concerned, and a
+ * blank line ENDS an HTML block: everything after the first one in the
+ * stylesheet came back wrapped in `<p>` and was printed on the page as text.
+ * Readable CSS is not worth a stylesheet in the body copy, so the blank lines
+ * go and the line breaks stay.
+ */
+export function buildBlockStyleTag(blockName, css) {
     if (!css || !css.trim()) return '';
-    const body = String(css).replace(/<\/style/gi, '<\\/style');
+    const body = String(css)
+        .replace(/<\/style/gi, '<\\/style')
+        .replace(/\n\s*\n+/g, '\n')
+        .trim();
     return `<style>[data-block="${escapeAttr(blockName)}"] {\n${body}\n}</style>\n`;
 }
 
@@ -1940,8 +1986,14 @@ export async function refreshComponentTagAllowlist() {
 export function collectAndRewriteComponents(source) {
     const used = new Set();
 
+    // Scrub first: a `[component …/]` or a `<dm-x>` tag written inside a fenced
+    // block is documentation showing the syntax, not a component to mount.
+    // Rewriting it turns the example into the thing it was explaining, and
+    // counting it pulls that component's script onto a page that never uses it.
+    const {scrubbed, restore} = scrubCodeRegions(source);
+
     // Rewrite shortcode form → raw tag form.
-    const rewritten = source.replace(
+    const rewritten = scrubbed.replace(
         /\[component\s+([^\]]+?)\s*\/?\]/g,
         (_, attrs) => {
             const nameMatch = attrs.match(/name\s*=\s*["']([a-z][a-z0-9-]*)["']/);
@@ -1957,7 +2009,7 @@ export function collectAndRewriteComponents(source) {
         used.add(m[1]);
     }
 
-    return {output: rewritten, used};
+    return {output: restore(rewritten), used};
 }
 
 export function escapeAttr(str) {
@@ -3652,7 +3704,12 @@ async function processFormBlocks(markdown, tagSet) {
       const raw = await readFile(filePath, 'utf8');
       const form = JSON.parse(raw);
       await expandReferenceFields(form);
-      const encoded = Buffer.from(JSON.stringify(form)).toString('base64');
+      // `actions` holds the notification email recipients and the webhook URL.
+      // The embed is base64 in the page source, which is not a secret keeping
+      // measure, so strip them exactly as GET /forms/:slug/public does - the
+      // browser never reads them, the submit route resolves them server-side.
+      const {actions: _actions, ...publicForm} = form;
+      const encoded = Buffer.from(JSON.stringify(publicForm)).toString('base64');
         const extraClass = attrs.class ? ` ${escapeAttr(attrs.class)}` : '';
         const idAttr = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : '';
         replacement = `<div class="cms-form-embed${extraClass}" data-form-inline="${escapeAttr(encoded)}"${idAttr}></div>`;
@@ -3868,11 +3925,15 @@ function processSlideoverBlocks(markdown) {
  * @returns {Promise<string>}
  */
 async function processMenuBlocks(markdown, user, ctx = {}) {
+    // Scrub first, or a `[menu …/]` written inside a fenced block as an example
+    // of the syntax is rendered into a real nav and then escaped into the code
+    // block - the docs page shows the output instead of the shortcode.
+    const {scrubbed, restore} = scrubCodeRegions(markdown);
     const re = /\[menu(\s+[^\]]*?)?\s*\/\]/gi;
-    const matches = [...markdown.matchAll(re)];
+    const matches = [...scrubbed.matchAll(re)];
     if (!matches.length) return markdown;
 
-    let out = markdown;
+    let out = scrubbed;
     for (const m of matches) {
         const attrs = parseShortcodeAttrs(m[1] || '');
         // A bare `slug` / `location` with no value parses as the boolean `true`
@@ -3925,7 +3986,7 @@ async function processMenuBlocks(markdown, user, ctx = {}) {
         });
         out = out.replace(m[0], html);
     }
-    return out;
+    return restore(out);
 }
 
 /** Visible diagnostic for an unusable [menu] shortcode - mirrors [form]'s. */

package/server/services/permissionRegistry.js

@@ -87,6 +87,19 @@ export const REGISTRY = [
             {key: 'delete', label: 'Delete', description: 'Delete menus'}
         ]
     },
+    {
+        key: 'context-menus',
+        label: 'Context Menus',
+        description: 'Author right-click menus and the regions they bind to.',
+        icon: 'menu',
+        group: 'Structure',
+        actions: [
+            {key: 'read',   label: 'View',   description: 'View context menus'},
+            {key: 'create', label: 'Create', description: 'Create new context menus'},
+            {key: 'update', label: 'Edit',   description: 'Edit context menus'},
+            {key: 'delete', label: 'Delete', description: 'Delete context menus'}
+        ]
+    },
     {
         key: 'projects',
         label: 'Projects',
@@ -165,6 +178,17 @@ export const REGISTRY = [
             {key: 'delete', label: 'Delete', description: 'Delete users'}
         ]
     },
+    {
+        key: 'theme',
+        label: 'Theme',
+        description: 'Choose the site and admin themes, fonts, and per-element theme overrides.',
+        icon: 'droplet',
+        group: 'Configuration',
+        actions: [
+            {key: 'read', label: 'View', description: 'View theme settings and overrides'},
+            {key: 'update', label: 'Edit', description: 'Change themes, fonts and overrides'}
+        ]
+    },
     {
         key: 'settings',
         label: 'Settings',