domma-cms 0.79.1 → 0.81.0

package/server/routes/api/effects.js

@@ -2,6 +2,7 @@
  * Effects API Routes
  * GET  /api/effects/settings  - public (read by public site IIFE)
  * PUT  /api/effects/settings  - admin-only (save user overrides)
+ * GET  /api/effects/_count     - the sidebar badge: how many effects the editor offers (an inventory)
  *
  * The PUT whitelists and checks what it stores (normaliseEffectsSettings): it
  * used to write the request body to config/effects.json verbatim, and GET
@@ -60,12 +61,47 @@ function loadSettings() {
  * @param {import('fastify').FastifyInstance} fastify
  * @param {{authenticate?: Function, requireAdmin?: Function}} [opts] - injectable for tests
  */
+/**
+ * The sidebar badge on Effects: how many effects the page editor offers, by
+ * category, and whether the scroll-reveal defaults have been changed. An
+ * inventory, so a closed System folder does not add it up.
+ *
+ * @param {{category: string, effects: object[]}[]} byCategory - effectsByCategory()
+ * @param {object} settings - config/effects.json
+ * @param {object} defaults - the shipped defaults
+ */
+export function effectsBadge(byCategory = [], settings = {}, defaults = {}) {
+    const n = byCategory.reduce((t, c) => t + c.effects.length, 0);
+    const changed = Object.keys(defaults).filter(k => settings[k] !== undefined && settings[k] !== defaults[k]);
+    return {
+        count: n,
+        inventory: true,
+        label: `${n} effect${n === 1 ? '' : 's'} for the page editor`,
+        tone: 'info',
+        details: {
+            title: 'Effects',
+            rows: [
+                ...byCategory.map(c => ({label: c.category, value: String(c.effects.length)})),
+                {label: 'Reveal defaults', value: changed.length ? `${changed.length} changed` : 'as shipped'}
+            ]
+        }
+    };
+}
+
 export async function effectsRoutes(fastify, opts = {}) {
     const authenticate = opts.authenticate || defaultAuthenticate;
     const requireAdmin = opts.requireAdmin || defaultRequireAdmin;
 
     fastify.get('/effects/settings', async () => loadSettings());
 
+    fastify.get('/effects/_count', {preHandler: [authenticate]}, async () => {
+        const {effectsByCategory} = await import('../../../admin/js/lib/effect-defs.js');
+        const {DEFAULT_SETTINGS} = await import('../../../admin/js/lib/effects-arrange.js');
+        let settings = {};
+        try { settings = getConfig('effects') || {}; } catch { /* no file yet: the defaults */ }
+        return effectsBadge(effectsByCategory(), settings, DEFAULT_SETTINGS);
+    });
+
     fastify.put('/effects/settings', {preHandler: [authenticate, requireAdmin]}, async (request, reply) => {
         const {errors, settings} = normaliseEffectsSettings(request.body);
         if (errors.length) return reply.status(400).send({error: errors.join('; ')});

package/server/routes/api/forms.js

@@ -25,6 +25,7 @@ import path from 'path';
 import {deleteForm, ensureCollectionForForm, ensureFormsDir, listForms, readForm, slugify, writeForm} from '../../services/forms.js';
 import {executeAction} from '../../services/actions.js';
 import {createTransport, sendFormEmail} from '../../services/email.js';
+import {formActionFailed, formTriggerNotice} from '../../services/notification-sources.js';
 import {
     clearEntries,
     createCollection,
@@ -797,9 +798,15 @@ export async function formsRoutes(fastify) {
         // Hidden and disabled are the same thing to a submission: the visitor
         // was given no way to answer, so the answer is not theirs and is not
         // required. A value posted for one anyway is dropped below.
-        const triggerOff = new Set([...triggerState.hidden, ...triggerState.disabled]);
+        const triggerOff = new Set([...triggerState.hidden, ...triggerState.disabled, ...triggerState.masked]);
         const triggerRequired = new Set(triggerState.required);
 
+        // An end-form in force: the answers so far ARE the submission, and the
+        // masked rest is neither asked for nor kept. `record: false` keeps
+        // nothing at all - the trigger's notification is the only trace.
+        const ended = triggerState.ends[0] || null;
+        const record = !ended || ended.record;
+
         // Evaluate conditional logic
         const missingFields    = [];
         const validationErrors = [];
@@ -841,9 +848,13 @@ export async function formsRoutes(fastify) {
 
         // Build submission data - only include visible fields
         const data = {};
+        const excused = [];
         for (const field of form.fields || []) {
             if (field.type === 'page-break' || field.type === 'spacer') continue;
-            if (!visibleFieldNames.has(field.name)) continue;
+            // The collection mirrors the form's static `required`, so a field
+            // the form excused (hidden, disabled, masked) would still be
+            // refused there - the form's own pass above is the one that knows.
+            if (!visibleFieldNames.has(field.name)) { excused.push(field.name); continue; }
             const val = body[field.name];
             if (val !== undefined) {
                 data[field.name] = typeof val === 'string' ? val.trim() : val;
@@ -862,7 +873,8 @@ export async function formsRoutes(fastify) {
         const collectionAction = form.actions?.collection;
         const targetSlug = (collectionAction?.enabled && collectionAction.slug) ? collectionAction.slug : slug;
         let entry = null;
-        try {
+        // An end-form set not to record stores nothing (see `record` above).
+        if (record) try {
             let col = await getCollection(targetSlug);
             if (!col) {
                 // The backing collection was never created (a form pointing at a
@@ -875,7 +887,9 @@ export async function formsRoutes(fastify) {
             if (col) {
                 entry = await createEntry(targetSlug, data, {
                     source:    `form:${slug}`,
-                    createdBy: submittingUser?.id || null
+                    createdBy: submittingUser?.id || null,
+                    excused,
+                    outcome:   ended ? {type: 'ended', trigger: ended.key, field: ended.field} : null
                 });
             } else {
                 // Could not resolve or provision a target - e.g. collection
@@ -897,9 +911,10 @@ export async function formsRoutes(fastify) {
             return reply.status(400).send({ error: msg });
         }
 
-        // Email action
+        // Email action - like the webhook and the form's action, it reports a
+        // stored submission, so an unrecorded end has nothing for it to say.
         const emailAction = form.actions?.email;
-        if (emailAction?.enabled && emailAction.recipients) {
+        if (record && emailAction?.enabled && emailAction.recipients) {
             try {
                 const smtp      = getConfig('site').smtp || {};
                 const transport = await createTransport(smtp);
@@ -914,12 +929,13 @@ export async function formsRoutes(fastify) {
                 });
             } catch (err) {
                 fastify.log.warn(`[forms] Email send failed for "${slug}": ${err.message}`);
+                formActionFailed(slug, form.title, 'notification email', err.message);
             }
         }
 
         // Webhook action
         const webhookAction = form.actions?.webhook;
-        if (webhookAction?.enabled && webhookAction.url) {
+        if (record && webhookAction?.enabled && webhookAction.url) {
             try {
                 await fetch(webhookAction.url, {
                     method:  webhookAction.method || 'POST',
@@ -928,6 +944,7 @@ export async function formsRoutes(fastify) {
                 });
             } catch (err) {
                 fastify.log.warn(`[forms] Webhook failed for "${slug}": ${err.message}`);
+                formActionFailed(slug, form.title, 'webhook', err.message);
             }
         }
 
@@ -940,6 +957,7 @@ export async function formsRoutes(fastify) {
                 await executeAction(actionSlug, entry.id, { user: submittingUser });
             } catch (err) {
                 fastify.log.warn(`[forms] Action "${actionSlug}" failed for form "${slug}": ${err.message}`);
+                formActionFailed(slug, form.title, `action "${actionSlug}"`, err.message);
             }
         }
 
@@ -953,7 +971,17 @@ export async function formsRoutes(fastify) {
                     await executeAction(event.action.slug, entry.id, {user: submittingUser});
                 } catch (err) {
                     fastify.log.warn(`[forms] Trigger action "${event.action.slug}" failed for form "${slug}": ${err.message}`);
+                    formActionFailed(slug, form.title, `action "${event.action.slug}"`, err.message);
                 }
+            } else if (event.type === 'notify') {
+                // Never throws; a switched-off source or the hourly cap just
+                // means nothing is raised.
+                const owner = (form.fields || []).find(f => f.name === event.field);
+                await formTriggerNotice({
+                    slug, formTitle: form.title, action: event.action,
+                    field: owner?.label || event.field, answer: formValues[event.field],
+                    ended: !!ended, recorded: !!entry
+                });
             } else if (event.type === 'redirect' && event.action.url && !triggerRedirect) {
                 // First one wins - two triggers redirecting at once is an
                 // authoring mistake, not a case to resolve cleverly.
@@ -961,7 +989,9 @@ export async function formsRoutes(fastify) {
             }
         }
 
-        hooks.emit('form:submitted', {slug, entryId: entry?.id || null, data, formTitle: form.title});
+        // An unrecorded end is not a submission anyone keeps, so nothing that
+        // listens for submissions (plugins, the "Form submitted" notice) hears it.
+        if (record) hooks.emit('form:submitted', {slug, entryId: entry?.id || null, data, formTitle: form.title, ended: !!ended});
 
         // Template interpolation for successRedirect. A trigger's redirect is
         // the more specific instruction, so it wins over the form's default.
@@ -973,7 +1003,8 @@ export async function formsRoutes(fastify) {
         return {
             ok:       true,
             entryId:  entry?.id || null,
-            message:  settings.successMessage  || 'Thank you for your submission.',
+            ended:    !!ended,
+            message:  ended?.doneMessage || settings.successMessage || 'Thank you for your submission.',
             redirect: redirect
         };
     });

package/server/routes/api/layouts.js

@@ -122,12 +122,16 @@ export function layoutsBadge(presets = {}, usage = {byKey: {}, missing: []}) {
     const missing = usage.missing || [];
     const inUse = Object.values(usage.byKey || {}).filter(list => list.length).length;
     const n = missing.length;
+    // A number either way (0.80): how many layouts while all is well - an
+    // inventory, left out of the System folder's total - and the pages on a
+    // missing layout, in red, when not.
     return {
-        count: n,
+        count: n || all.length,
+        ...(!n && {inventory: true}),
         label: n
             ? `${n} page${n === 1 ? '' : 's'} use${n === 1 ? 's' : ''} a layout that no longer exists`
             : `${all.length} layout${all.length === 1 ? '' : 's'}, every page's layout exists`,
-        tone: 'attention',
+        tone: n ? 'attention' : 'info',
         details: {
             title: 'Layouts',
             rows: [

package/server/routes/api/notifications.js

@@ -9,7 +9,14 @@
  * POST   /api/system/notifications/dismiss-all  - Dismiss every active one, for this user
  * POST   /api/system/notifications/read-all     - Mark every active one read, for this user
  * POST   /api/system/notifications/:id/dismiss  - Mark dismissed
+ * POST   /api/system/notifications/samples      - Add one sample of each severity (admin only)
  * DELETE /api/system/notifications/:id          - Hard delete (admin only)
+ * GET    /api/system/notifications/sources      - What can raise one, with settings (Super Admin)
+ * PUT    /api/system/notifications/sources/:id  - {enabled, audience} (Super Admin)
+ * POST   /api/system/notifications/sources/:id/run - Run a scheduled source now (Super Admin)
+ *
+ * Who sees a notification: its `audience` (services/notify.js). None - manager
+ * pushes and everything before 0.80 - is everyone who can read notifications.
  */
 import {
     authenticate as defaultAuthenticate,
@@ -18,6 +25,8 @@ import {
 import { requireManager } from '../../middleware/managerAuth.js';
 import { randomUUID } from 'crypto';
 import { getAdapter } from '../../services/adapterRegistry.js';
+import {AUDIENCES, isActiveFor, listNotificationSources, runSource, saveSourceSetting} from '../../services/notify.js';
+import {getEffectiveRoles} from '../../services/userRoles.js';
 
 const SLUG = 'notifications';
 
@@ -62,19 +71,6 @@ async function saveData(adapter, entry, data) {
     return adapter.update(SLUG, entry.id, {...entry, data, meta: {...(entry.meta || {}), updatedAt: new Date().toISOString()}});
 }
 
-/**
- * Is this notification live for this user right now: not expired, not dismissed.
- *
- * @param {object} data - A notification payload.
- * @param {string} userId
- * @param {string} now - ISO timestamp.
- * @returns {boolean}
- */
-function isActiveFor(data, userId, now) {
-    if (data.expiresAt && data.expiresAt < now) return false;
-    return !(Array.isArray(data.dismissedBy) && data.dismissedBy.includes(userId));
-}
-
 /**
  * The sidebar badge on Notifications (its countUrl): the unread ones - the same
  * number the sidebar always showed there - red while any of them is critical.
@@ -112,6 +108,42 @@ export function notificationsBadge(active = []) {
     };
 }
 
+/**
+ * One sample of each severity, shaped like what the site's own sources will
+ * send (see the Notifications plan): something to look at on a fresh site, and
+ * a way to try the bell, the badge and desktop notifications. Each ends itself
+ * after a week.
+ *
+ * @param {Date} now
+ * @param {string} origin - the site's own address, for the one sample with a link
+ * @returns {object[]} entries, `{id, data, meta}`
+ */
+export function sampleNotifications(now = new Date(), origin = '') {
+    const expiresAt = new Date(now.getTime() + 7 * 86_400_000).toISOString();
+    const note = `\n\n(A sample - it goes by itself on ${expiresAt.slice(0, 10)}.)`;
+    const samples = [
+        {severity: 'critical', title: 'Plugin failed to load: Calendar',
+            body: 'The Calendar plugin stopped with an error while the site started, so its screens and pages are missing. Check Plugins for the error, then restart the site.',
+            link: origin ? `${origin}/admin/#/plugins` : null},
+        {severity: 'warning', title: 'Invoice INV-0042 is overdue',
+            body: 'INV-0042 for Acme Ltd (£1,250.00) was due 3 days ago and has not been paid.'},
+        {severity: 'info', title: 'New comment awaiting moderation',
+            body: 'Sam left a comment on "Spring opening hours". It will not show on the site until it is approved.'},
+        {severity: 'success', title: 'Payment recorded: INV-0039',
+            body: 'A payment of £480.00 was recorded against INV-0039. It is now paid in full.'}
+    ];
+    // A minute apart, newest first, so the list shows its order.
+    return samples.map((x, i) => {
+        const at = new Date(now.getTime() - i * 60_000).toISOString();
+        return {
+            id: randomUUID(),
+            data: {title: x.title, body: x.body + note, severity: x.severity, source: 'sample', link: x.link || null,
+                createdAt: at, expiresAt, readBy: [], dismissedBy: []},
+            meta: {createdAt: at, updatedAt: at, source: 'sample'}
+        };
+    });
+}
+
 export async function notificationsRoutes(fastify, opts = {}) {
     // Injectable so tests can supply no-ops rather than a seeded roles cache -
     // the same DI pattern as menus.js, projects.js and context-menus.js.
@@ -182,7 +214,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
         return all
             .filter(entry => {
                 const d = notificationData(entry, fastify.log);
-                return !!d && isActiveFor(d, userId, now);
+                return !!d && isActiveFor(d, request.user, now);
             })
             // A record with no createdAt sorts last rather than taking the
             // whole list down with it.
@@ -202,7 +234,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
 
         const count = all.filter(entry => {
             const d = notificationData(entry, fastify.log);
-            if (!d || !isActiveFor(d, userId, now)) return false;
+            if (!d || !isActiveFor(d, request.user, now)) return false;
             return !Array.isArray(d.readBy) || !d.readBy.includes(userId);
         }).length;
 
@@ -210,26 +242,27 @@ export async function notificationsRoutes(fastify, opts = {}) {
     });
 
     /** This user's active notifications, newest first, each flagged `unread`. */
-    async function activeFor(userId) {
+    async function activeFor(user) {
+        const userId = user.id;
         const now = new Date().toISOString();
         const adapter = await getAdapter(SLUG);
         return (await adapter.all(SLUG))
             .filter(entry => {
                 const d = notificationData(entry, fastify.log);
-                return !!d && isActiveFor(d, userId, now);
+                return !!d && isActiveFor(d, user, now);
             })
             .map(entry => ({...entry, unread: !Array.isArray(entry.data.readBy) || !entry.data.readBy.includes(userId)}));
     }
 
     // --- Sidebar badge (static path: GET has no /:id route to shadow) ---
-    fastify.get('/system/notifications/_count', canRead, async (request) => notificationsBadge(await activeFor(request.user.id)));
+    fastify.get('/system/notifications/_count', canRead, async (request) => notificationsBadge(await activeFor(request.user)));
 
     // --- Dismiss everything active, for this user ---
     fastify.post('/system/notifications/dismiss-all', canRead, async (request) => {
         const userId = request.user.id;
         const adapter = await getAdapter(SLUG);
         let dismissed = 0;
-        for (const entry of await activeFor(userId)) {
+        for (const entry of await activeFor(request.user)) {
             const {unread: _u, ...stored} = entry;
             const data = stored.data;
             const dismissedBy = Array.isArray(data.dismissedBy) ? data.dismissedBy : [];
@@ -252,7 +285,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
         const userId = request.user.id;
         const adapter = await getAdapter(SLUG);
         let marked = 0;
-        for (const entry of await activeFor(userId)) {
+        for (const entry of await activeFor(request.user)) {
             if (!entry.unread) continue;
             const {unread: _u, ...stored} = entry;
             const readBy = Array.isArray(stored.data.readBy) ? stored.data.readBy : [];
@@ -317,6 +350,50 @@ export async function notificationsRoutes(fastify, opts = {}) {
         return { ok: true, entry: updated };
     });
 
+    // --- Samples (the settings cog's "Add samples"; same permission as deleting) ---
+    fastify.post('/system/notifications/samples', canDelete, async (request, reply) => {
+        const adapter = await getAdapter(SLUG);
+        const origin = `${request.protocol}://${request.host || request.hostname}`;
+        const made = sampleNotifications(new Date(), origin);
+        // A second click replaces the samples rather than stacking another set.
+        for (const e of await adapter.all(SLUG)) if (e?.data?.source === 'sample') await adapter.remove(SLUG, e.id);
+        for (const entry of made) await adapter.insert(SLUG, entry);
+        return reply.code(201).send({ok: true, added: made.length});
+    });
+
+    // --- Sources: what the site itself raises, and where it goes (Super Admins) ---
+    const superAdminOnly = async (request, reply) => {
+        if (!getEffectiveRoles(request.user || {}).includes('super-admin')) {
+            return reply.code(403).send({error: 'Only a Super Admin can change notification sources.'});
+        }
+    };
+    const canManageSources = {preHandler: [authenticate, requirePermission('notifications', 'read'), superAdminOnly]};
+
+    fastify.get('/system/notifications/sources', canManageSources, async () => ({
+        sources: listNotificationSources(),
+        audiences: Object.keys(AUDIENCES)
+    }));
+
+    fastify.put('/system/notifications/sources/:id', canManageSources, async (request, reply) => {
+        const {id} = request.params;
+        const known = listNotificationSources().find(s => s.id === id);
+        if (!known) return reply.code(404).send({error: 'No such source.'});
+        const {enabled, audience} = request.body || {};
+        if (enabled !== undefined && typeof enabled !== 'boolean') return reply.code(400).send({error: 'enabled must be true or false.'});
+        if (audience !== undefined && AUDIENCES[audience] === undefined) {
+            return reply.code(400).send({error: `audience must be one of: ${Object.keys(AUDIENCES).join(', ')}.`});
+        }
+        return {ok: true, setting: saveSourceSetting(id, {enabled, audience})};
+    });
+
+    fastify.post('/system/notifications/sources/:id/run', canManageSources, async (request, reply) => {
+        const known = listNotificationSources().find(s => s.id === request.params.id);
+        if (!known) return reply.code(404).send({error: 'No such source.'});
+        if (!known.every) return reply.code(400).send({error: 'That source is not a scheduled check - it raises notifications as things happen.'});
+        const result = await runSource(known.id);
+        return {...result, source: listNotificationSources().find(s => s.id === known.id)};
+    });
+
     // --- Hard delete (admin only) ---
     fastify.delete('/system/notifications/:id', canDelete, async (request, reply) => {
         const { id } = request.params;

package/server/routes/api/users.js

@@ -12,6 +12,7 @@ import {getPermissionsFor} from '../../services/roles.js';
 import {createUser, deleteUser, getUserById, listUsers, updateUser} from '../../services/users.js';
 import {getProfile, listProfiles, updateProfile} from '../../services/userProfiles.js';
 import {ago, clip, plural} from '../../services/sidebarBadges.js';
+import * as notices from '../../services/notification-sources.js';
 
 /**
  * The sidebar badge on Users (its countUrl, GET /api/users/_count). The number
@@ -133,6 +134,9 @@ export async function usersRoutes(fastify) {
         } catch (err) {
             return reply.status(409).send({ error: err.message });
         }
+        notices.userCreated(user, request.user?.name || request.user?.email);
+        const newAdmin = [user.role, ...(user.additionalRoles || [])].filter(r => r === 'admin' || r === 'super-admin');
+        if (newAdmin.length) notices.adminRightsGiven(user, newAdmin, request.user?.name || request.user?.email);
         if (profile && typeof profile === 'object' && !Array.isArray(profile)) await updateProfile(user.id, profile);
         return reply.status(201).send(user);
     });
@@ -187,6 +191,12 @@ export async function usersRoutes(fastify) {
             await updateProfile(id, profile);
         }
 
+        // Admin rights given (not kept): the Super Admins hear about it.
+        const adminRoles = (u) => [u?.role, ...(Array.isArray(u?.additionalRoles) ? u.additionalRoles : [])]
+            .filter(r => r === 'admin' || r === 'super-admin');
+        const gained = adminRoles(user).filter(r => !adminRoles(target).includes(r));
+        if (gained.length) notices.adminRightsGiven(user, gained, actor.name || actor.email);
+
         const profileEntry = await getProfile(id);
         return {...user, profile: profileEntry?.data || {}};
     });
@@ -208,6 +218,7 @@ export async function usersRoutes(fastify) {
         }
 
         await deleteUser(id);
+        notices.userDeleted(target, actor.name || actor.email);
         return { success: true };
     });
 }

package/server/server.js

@@ -19,7 +19,8 @@ import fs from 'fs/promises';
 import {fileURLToPath} from 'url';
 import {createRequire} from 'module';
 import {config, getConfig} from './config.js';
-import {getLoadedPlugins, getPluginSettings, registerPlugins} from './services/plugins.js';
+import {getLoadedPlugins, getPluginSettings, recordPluginLoadFailure, registerPlugins} from './services/plugins.js';
+import {notifierFor} from './services/notify.js';
 import {load as loadRoles, seed as seedRoles} from './services/roles.js';
 import {ensureAllProfiles, seed as seedUserProfiles} from './services/userProfiles.js';
 import {seedAll as seedPresetCollections} from './services/presetCollections.js';
@@ -89,13 +90,17 @@ const app = Fastify({
 });
 
 // Register process error handlers immediately so startup errors are captured
+// Each leaves a marker, so the next start can tell the Super Admin (core:crash).
+const {recordCrash} = await import('./services/notification-sources.js');
 process.on('uncaughtException', (err) => {
     app.log.error({ err }, 'Uncaught exception');
+    recordCrash(err);
     process.exit(1);
 });
 
 process.on('unhandledRejection', (reason) => {
     app.log.error({ reason }, 'Unhandled rejection');
+    recordCrash(reason);
     process.exit(1);
 });
 
@@ -321,7 +326,11 @@ try {
     const {ran, converted, pending} = await migrateNumberFields();
     const done = Object.entries(converted).map(([slug, n]) => `${slug} (${n})`);
     if (ran && done.length) app.log.info(`[collections] Number fields stored as text converted: ${done.join(', ')}`);
-    if (pending.length) app.log.warn(`[collections] Number-field repair will retry next start for: ${pending.join(', ')}`);
+    if (pending.length) {
+        app.log.warn(`[collections] Number-field repair will retry next start for: ${pending.join(', ')}`);
+        const {startupPending} = await import('./services/notification-sources.js');
+        startupPending(`Number fields stored as text could not be converted in: ${pending.join(', ')} (a database was unreachable).`);
+    }
 } catch (err) {
     app.log.warn(`[collections] Number-field repair skipped: ${err.message}`);
 }
@@ -561,17 +570,25 @@ registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Actions',
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'API Builder', url: '#/api-endpoints', icon: 'code', permission: 'api-endpoints', countUrl: '/api/api-endpoints/_count', inventory: true}});
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Blocks', url: '#/blocks', icon: 'box', permission: 'pages', countUrl: '/api/blocks/_count', inventory: true}});
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Components', url: '#/components', icon: 'component', permission: 'components', countUrl: '/api/components/_count', inventory: true}});
-// System. Notifications, Site Settings, Layouts and API Tokens are signals (unread, something quietly
-// wrong, pages on a missing layout, tokens expiring), so not `inventory`.
+// System. Notifications, Site Settings and My Profile are signals (unread, something quietly wrong,
+// details not filled in); Layouts and API Tokens are a count while all is well and a signal when not
+// (pages on a missing layout, tokens expiring - the answer says `inventory` in the calm case); Effects
+// is an inventory.
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Notifications', url: '#/system/notifications', icon: 'bell', permission: 'notifications', countUrl: '/api/system/notifications/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Roles', url: '#/roles', icon: 'shield', permission: 'plugins', countUrl: '/api/roles/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Users', url: '#/users', icon: 'users', permission: 'users', countUrl: '/api/users/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Site Settings', url: '#/settings', icon: 'settings', permission: 'settings', countUrl: '/api/settings/_count'}});
+registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Effects', url: '#/effects', icon: 'sparkles', permission: 'settings', countUrl: '/api/effects/_count', inventory: true}});
+registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'My Profile', url: '#/my-profile', icon: 'user', countUrl: '/api/auth/me/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Layouts', url: '#/layouts', icon: 'layout', permission: 'layouts', countUrl: '/api/layouts/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Plugins', url: '#/plugins', icon: 'package', permission: 'plugins', countUrl: '/api/plugins/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'API Tokens', url: '#/api-tokens', icon: 'key', permission: 'api-tokens', countUrl: '/api/api-tokens/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Search', url: '#/search', icon: 'search', permission: 'settings', countUrl: '/api/search/_count', inventory: true}});
 
+// Core's notification sources, before plugins add theirs (0.80).
+const {registerCoreSources} = await import('./services/notification-sources.js');
+await registerCoreSources();
+
 await registerPlugins(app);
 
 // ---------------------------------------------------------------------------
@@ -589,10 +606,13 @@ for (const [name, plugin] of Object.entries(getLoadedPlugins())) {
             auth: { authenticate: _authenticate, requireAdmin: _requireAdmin, requireVisibility: _requireVisibility },
             // getConfig() requires a name; pass the startup config singleton instead.
             // (Without this every enabled plugin.public.js fails to register.)
-            config
+            config,
+            // notify / resolveNotification / registerNotificationSource, as plugin.js gets them (0.80).
+            hooks: notifierFor(name)
         });
     } catch (err) {
         app.log.error(`[plugins] Failed to register public plugin ${name}: ${err.message}`);
+        recordPluginLoadFailure(name, `public side failed to load: ${err.message}`);
     }
 }
 
@@ -623,6 +643,10 @@ process.on('SIGINT',  () => shutdown('SIGINT'));
 
 try {
     await app.listen({ port: serverConfig.port, host: serverConfig.host });
+    // Notifications: flush what start-up raised, run the boot checks, start the ticker.
+    const {startNotifications} = await import('./services/notify.js');
+    // Its timers are unref'd, so they never hold a shutdown open.
+    startNotifications({log: app.log});
     console.log(`Domma CMS running at http://localhost:${serverConfig.port}`);
     console.log(`  Admin:  http://localhost:${serverConfig.port}/admin/`);
     console.log(`  Public: http://localhost:${serverConfig.port}/`);

package/server/services/actions.js

@@ -225,6 +225,34 @@ async function executeStep(step, collection, entry, context) {
             return { to };
         }
 
+        /*
+         * notify - raise a notification in the admin (the bell, and desktop
+         * notifications for those who switched them on). Goes to whoever the
+         * "Actions" source is set to reach in Notifications' settings.
+         *
+         * Config (all template-interpolated):
+         *   title    {string} required
+         *   body     {string} optional
+         *   severity {string} optional - info | success | warning | critical
+         *   link     {string} optional - an admin route (#/…) or http(s) URL
+         *
+         * Returns: { raised: boolean } - false when the source is switched off
+         * or over its hourly cap, which is not a failure of the action.
+         */
+        case 'notify': {
+            const title = interpolate(cfg.title || '', context).trim();
+            if (!title) throw new Error('notify: title is required');
+            const { notify } = await import('./notify.js');
+            const raised = await notify({
+                source:   'core:actions',
+                title,
+                body:     interpolate(cfg.body || '', context),
+                severity: interpolate(cfg.severity || 'info', context).trim(),
+                link:     interpolate(cfg.link || '', context).trim() || null
+            });
+            return { raised: !!raised };
+        }
+
         default:
             throw new Error(`Unknown step type: "${step.type}"`);
     }

package/server/services/adapterRegistry.js

@@ -93,6 +93,7 @@ async function resolveMongoAdapter(schema) {
         return new MongoAdapter(db);
     } catch (err) {
         console.warn(`[adapterRegistry] Failed to load MongoAdapter for "${schema.slug}": ${err.message}. Falling back to FileAdapter.`);
+        import('./notification-sources.js').then(m => m.storageDown(schema.storage?.connection || 'default', err.message)).catch(() => {});
         return fileAdapter;
     }
 }

package/server/services/collections.js

@@ -260,11 +260,15 @@ export async function deleteCollection(slug) {
  *
  * @param {object} schema
  * @param {object} data
+ * @param {Iterable<string>} [excused] - fields whose `required` does not apply to this
+ *        write: a form submission the form itself excused from answering them
  * @returns {{ valid: boolean, errors: string[] }}
  */
-export function validateEntryData(schema, data) {
+export function validateEntryData(schema, data, excused = []) {
     const errors = [];
+    const skip = new Set(excused);
     for (const field of (schema.fields || [])) {
+        if (skip.has(field.name)) continue;
         const val = data[field.name];
         const isEmpty = val === undefined || val === null || val === '';
         if (field.required && isEmpty) {
@@ -383,15 +387,17 @@ export async function getEntry(slug, entryId) {
  * @param {object} [meta]
  * @param {string} [meta.createdBy]
  * @param {string} [meta.source]  - 'admin' | 'api' | 'import' | 'form:{slug}'
+ * @param {string[]} [meta.excused] - required fields this write may leave empty (see validateEntryData)
+ * @param {object} [meta.outcome]   - how a form submission ended, stored as meta.outcome
  * @returns {Promise<object>} Created entry
  * @throws {Error} If validation fails or collection not found
  */
-export async function createEntry(slug, data, { createdBy = null, source = 'admin' } = {}) {
+export async function createEntry(slug, data, { createdBy = null, source = 'admin', excused = [], outcome = null } = {}) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
     data = typedEntryData(schema, data);
 
-    const { valid, errors } = validateEntryData(schema, data);
+    const { valid, errors } = validateEntryData(schema, data, excused);
     if (!valid) throw new Error(`Validation failed: ${errors.join('; ')}`);
 
     const refErrors = await validateReferences(schema, data);
@@ -401,7 +407,7 @@ export async function createEntry(slug, data, { createdBy = null, source = 'admi
     const entry = {
         id:   uuidv4(),
         data,
-        meta: { createdAt: now, updatedAt: now, createdBy, source }
+        meta: { createdAt: now, updatedAt: now, createdBy, source, ...(outcome && {outcome}) }
     };
 
     const adapter = await getAdapter(slug);

package/server/services/connectionManager.js

@@ -43,6 +43,7 @@ export async function initialise(connectionsConfig) {
             console.log(`[connectionManager] Connected: ${name} → ${cfg.database}`);
         } catch (err) {
             console.error(`[connectionManager] Failed to connect "${name}": ${err.message}`);
+            import('./notification-sources.js').then(m => m.storageDown(name, err.message)).catch(() => {});
             // Don't throw - allow server to start with degraded MongoDB support.
         }
     }