@aglyn/aglyn 1.0.0-beta.218 → 1.0.0-beta.220

package/src/lib/app-utils/notifications.d.ts

@@ -57,11 +57,108 @@ export interface AglynNotification {
      * `tools/scripts/backfill-notification-read.mjs` stamps.
      */
     read?: boolean;
+    /**
+     * How urgently this one notification asks to be read (AGL-3437), stamped
+     * by its emitter. Absent on a notification whose emitter has no reason to
+     * say more than its type does, and on everything written before the field
+     * existed; read it through {@link notificationLevel}, never directly.
+     */
+    level?: NotificationLevel;
 }
 export declare const NOTIFICATION_TYPE_LABELS: Record<AglynNotificationType, string>;
-/** Preference buckets (AGL-267): the prefix before the dot. */
-export type NotificationCategory = 'billing' | 'team' | 'content' | 'marketplace' | 'support' | 'system' | 'staff';
-export declare const NOTIFICATION_CATEGORY_LABELS: Record<NotificationCategory, string>;
+/**
+ * HOW LOUD A NOTIFICATION IS (AGL-3437), which the console draws as its
+ * color, icon and accent.
+ *
+ * - `critical` — something stopped, money is moving with nobody looking, or
+ *   fraud: a fraud signal, a failed payment, a form that stopped accepting.
+ * - `warning` — something degraded or is close to stopping: a health check
+ *   degraded, a limit reached, low stock.
+ * - `success` — good news: an account, a workspace or a subscription
+ *   started, an order or a booking arrived, a health check recovered.
+ * - `info` — worth reading, nothing wrong: an invite, a ticket reply, a
+ *   usage step on the way to a limit.
+ * - `neutral` — routine work arriving: a form submission, an assignment, a
+ *   digest.
+ *
+ * A level is a property of the NOTIFICATION, not only of its type: one
+ * `system.operatorAlert` says a check degraded and the next says it
+ * recovered, and a usage notice at 75% is not the one at 100%. The emitter
+ * stamps `level` when it knows more than the type; the type's default in
+ * {@link NOTIFICATION_TYPE_LEVELS} answers for everything else.
+ */
+export type NotificationLevel = 'critical' | 'warning' | 'success' | 'info' | 'neutral';
+/** Every level, loudest first — the order {@link loudestNotificationLevel} ranks by. */
+export declare const NOTIFICATION_LEVELS: readonly NotificationLevel[];
+export declare const NOTIFICATION_LEVEL_LABELS: Record<NotificationLevel, string>;
+/**
+ * Each core type's level when its emitter stamps none. A plugin's types are
+ * not listed: a plugin emitter stamps `level` itself, and an unstamped one
+ * reads as `neutral`.
+ *
+ * A type the operator alert registry raises under its own notification type
+ * must agree with that alert's level, so the backlog written before `level`
+ * existed reads the same as what the registry writes today
+ * (`notification-levels.spec.ts` holds the two together).
+ */
+export declare const NOTIFICATION_TYPE_LEVELS: Record<AglynNotificationType, NotificationLevel>;
+/** Whether a stored value is a level this build knows. */
+export declare function isNotificationLevel(value: unknown): value is NotificationLevel;
+/**
+ * A notification's level: what its emitter stamped, else its type's
+ * default, else `neutral`. A stamped value this build does not know — a
+ * level added later, read by an older console — falls back the same way
+ * rather than drawing nothing.
+ */
+export declare function notificationLevel(notification: {
+    type?: string;
+    level?: unknown;
+} | null | undefined): NotificationLevel;
+/**
+ * A usage notice's level at `percent` of its allowance: `info` on a step
+ * toward it, `warning` once it is reached. Every usage, budget and allotment
+ * notice says the same thing at the same step, so they share this.
+ */
+export declare function usageNotificationLevel(percent: number): NotificationLevel;
+/** The loudest of several levels, or `neutral` for none. */
+export declare function loudestNotificationLevel(levels: Iterable<NotificationLevel>): NotificationLevel;
+/**
+ * The preference buckets the platform owns (AGL-267): the prefix before the
+ * dot. A plugin adds its own through {@link NotificationCategoryDeclaration},
+ * so this union is the core's and nothing else's.
+ */
+export type CoreNotificationCategory = 'billing' | 'team' | 'content' | 'support' | 'system' | 'staff';
+/**
+ * A preference bucket: one of the core's, or one a first-party plugin
+ * declares. The id is persisted — it keys every stored preference map — so a
+ * declared id keeps its meaning only while its declaration keeps its spelling.
+ */
+export type NotificationCategory = CoreNotificationCategory | (string & {});
+/**
+ * A notification category a plugin declares for the notifications it sends
+ * (AGL-3080), under `notificationCategories` in `plugins.config.json`.
+ *
+ * Compiled rather than registered: `notifyUsers` resolves a recipient's
+ * channels in server processes that load no plugin, and the settings page
+ * draws its rows before any plugin could register. A category that had to
+ * wait for its plugin would read as `system` until then — so a person who had
+ * muted it would be told, and a person who had asked for its email would not.
+ * The generator refuses an id the core owns or another plugin declares.
+ */
+export interface NotificationCategoryDeclaration {
+    /** The plugin whose notifications carry this prefix. */
+    pluginId: string;
+    /** The type prefix, and the key every stored preference is written under. */
+    id: string;
+    /** The row's name on the settings page. */
+    label: string;
+    /** What arrives under it, in the reader's words — see {@link NOTIFICATION_CATEGORY_DESCRIPTIONS}. */
+    description: string;
+    /** What each channel does before anybody says — see {@link NOTIFICATION_CHANNEL_DEFAULTS}. */
+    defaults: Record<NotificationChannel, boolean>;
+}
+/** Every category's row name, the core's and the declared, in page order. */
+export declare const NOTIFICATION_CATEGORY_LABELS: Readonly<Record<NotificationCategory, string>>;
 /**
  * The categories only staff can receive (AGL-3225).
  *
@@ -71,21 +168,13 @@ export declare const NOTIFICATION_CATEGORY_LABELS: Record<NotificationCategory,
  * enumerates the `staff` claim rather than reading this.
  */
 export declare const STAFF_NOTIFICATION_CATEGORIES: ReadonlySet<NotificationCategory>;
+export declare const NOTIFICATION_CATEGORY_DESCRIPTIONS: Readonly<Record<NotificationCategory, string>>;
 /**
- * What each category actually covers, in the reader's words (AGL-3251).
- *
- * The settings page listed seven bare labels and two switches, so deciding
- * whether to silence `Product & system` meant guessing what was in it. The
- * type labels beneath each row now name the contents exactly; this is the
- * one-line answer for somebody who does not want to expand anything.
- *
- * Written as what ARRIVES rather than as what the bucket is called: "someone
- * joins, a role changes" is checkable against your own feed in a way that
- * "team and access events" is not. Exhaustive `Record`, like the channel
- * defaults below — a new category cannot ship without somebody saying in
- * plain words what lands in it.
+ * The bucket a type falls in: its prefix, when a category of that id exists,
+ * and `system` otherwise — the bucket nobody mutes to reduce noise, so a type
+ * nothing claims still reaches the person rather than riding a mute they set
+ * for something else.
  */
-export declare const NOTIFICATION_CATEGORY_DESCRIPTIONS: Record<NotificationCategory, string>;
 export declare function notificationCategory(type: AglynNotificationType | string): NotificationCategory;
 /**
  * Per-user mute map stored at `users/{uid}.notificationPrefs`
@@ -94,26 +183,42 @@ export declare function notificationCategory(type: AglynNotificationType | strin
 export declare function notificationMuted(prefs: Record<string, boolean> | null | undefined, type: AglynNotificationType | string): boolean;
 /**
  * The field on `users/{uid}` that holds a person's digest switches
- * (AGL-2619): `{ crmDaily: false }` turns the daily CRM digest off, and an
- * absent key leaves it on. Its own map rather than a key in
- * `notificationPrefs`, because that map is keyed by CATEGORY and read by
- * {@link notificationMuted} — a digest is a schedule a person keeps or
- * drops, not a bucket of types, and one switch governs both the console
- * notification and the email it travels with.
+ * (AGL-2619): `{ [digestKey]: false }` turns one digest off, and an absent key
+ * leaves it on. Its own map rather than a key in `notificationPrefs`, because
+ * that map is keyed by CATEGORY and read by {@link notificationMuted} — a
+ * digest is a schedule a person keeps or drops, not a bucket of types, and one
+ * switch governs both the console notification and the email it travels with.
  */
 export declare const DIGEST_PREFS_FIELD = "digestPrefs";
 /**
- * The key the daily CRM digest keeps inside {@link DIGEST_PREFS_FIELD}.
+ * A digest a plugin sends on its own schedule (AGL-3080), declared under
+ * `notificationDigests` in `plugins.config.json` so the settings page can draw
+ * its switch without loading the plugin, and the plugin's sender and that
+ * switch read one key.
  *
- * Exported so the console writes the switch through a name rather than a
- * second copy of the string (AGL-3230). The reader below and the page that
- * flips it were spelling the same literal in two files, which is how a
- * preference comes to be written under one key and read under another — and
- * it kept the plugin's vocabulary in a console page, where
- * `check:plugin-domain-in-core` rightly refuses it.
+ * On until the person turns it off: the key is stored in
+ * {@link DIGEST_PREFS_FIELD} only once somebody has said no. The key is
+ * persisted, so it keeps its spelling for as long as anybody's switch is
+ * stored under it.
+ */
+export interface NotificationDigestDeclaration {
+    /** The plugin that composes and sends it. */
+    pluginId: string;
+    /** The key its switch is stored under in {@link DIGEST_PREFS_FIELD}. */
+    key: string;
+    /** The switch's name. */
+    label: string;
+    /** When it arrives and what it holds, in the reader's words. */
+    description: string;
+}
+/** Every declared digest, in the order the settings page lists them. */
+export declare const NOTIFICATION_DIGESTS: readonly NotificationDigestDeclaration[];
+/**
+ * Whether a person keeps one digest: on unless its key is stored `false`. It
+ * reads only its own key — a category mute lives in a different map and does
+ * not reach it.
  */
-export declare const CRM_DAILY_DIGEST_KEY = "crmDaily";
-export declare function crmDailyDigestEnabled(prefs: Record<string, boolean> | null | undefined): boolean;
+export declare function digestEnabled(prefs: Record<string, boolean> | null | undefined, key: string): boolean;
 /**
  * The field on `users/{uid}` naming the workspaces whose weekly insights a
  * person asked for (AGL-2915): `{ [orgId]: true }`. OPT-IN, unlike the CRM
@@ -217,33 +322,28 @@ export interface NotificationSettings {
     hostTypes?: Record<string, NotificationTypePrefs>;
 }
 export declare const NOTIFICATION_SETTINGS_FIELD = "notificationSettings";
-/**
- * What a category does when nobody has said otherwise.
- *
- * Console on, email OFF, everywhere. Email defaults off because the inbox is
- * not ours to fill: the product already sends transactional mail nobody opted
- * into — welcome, verification, invites, dunning, usage alerts — and every one
- * of those leaves on the same domain a customer's password reset depends on.
- * Turning a busy site's form submissions into mail by default would put that
- * domain's reputation behind traffic the recipient never asked for.
- *
- * Exhaustive `Record` deliberately: a new {@link NotificationCategory} is a
- * compile error here until somebody decides what it does by default, which is
- * the one question a new category must not be able to ship without answering.
- */
-export declare const NOTIFICATION_CHANNEL_DEFAULTS: Record<NotificationCategory, Record<NotificationChannel, boolean>>;
+export declare const NOTIFICATION_CHANNEL_DEFAULTS: Readonly<Record<NotificationCategory, {
+    email: boolean;
+    console: boolean;
+}>>;
 /**
  * The types that send their OWN email and must never be mailed again by the
  * generic channel (AGL-3224).
  *
  * Both digests compose a message the fan-out could not reproduce — a day's
  * owed tasks, a week's figures — and send it from their own route under their
- * own switch (`digestPrefs.crmDaily`, `insightDigests.{orgId}`). A recipient
+ * own switch (a key in `digestPrefs`, `insightDigests.{orgId}`). A recipient
  * who switches the `content` email channel on would otherwise receive the
  * digest twice: once as the digest, once as a one-line "Daily CRM digest"
  * notification saying that the digest happened.
  */
 export declare const NOTIFICATION_SELF_SENT_EMAIL_TYPES: ReadonlySet<string>;
+/**
+ * The tooltip on a self-sent type's disabled email switch: it names what
+ * DOES govern that mail, which differs by type (AGL-3432). Calling a task
+ * reminder a digest sent people looking for a Digests switch that is not it.
+ */
+export declare function selfSentEmailNote(type: string): string;
 /**
  * Whether a channel is on for one notification, at its own scope.
  *

package/src/lib/app-utils/notifications.js

@@ -13,7 +13,9 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ import { buildRoute, Route } from "./console-routes.js";
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { buildRoute, Route } from "./console-routes.js";
+import { PLUGIN_NOTIFICATION_CATEGORIES_DECLARED, PLUGIN_NOTIFICATION_DIGESTS_DECLARED } from "../plugin-manager/first-party-plugins.generated.js";
 export const NOTIFICATION_TYPE_LABELS = {
     'billing.invoice': 'Invoice available',
     'billing.paymentFailed': 'Payment failed',
@@ -57,15 +59,142 @@ export const NOTIFICATION_TYPE_LABELS = {
     'staff.planChanged': 'Plan changed',
     'staff.paymentFailed': 'Payment failed (workspace)'
 };
-export const NOTIFICATION_CATEGORY_LABELS = {
+/** Every level, loudest first — the order {@link loudestNotificationLevel} ranks by. */ export const NOTIFICATION_LEVELS = [
+    'critical',
+    'warning',
+    'success',
+    'info',
+    'neutral'
+];
+export const NOTIFICATION_LEVEL_LABELS = {
+    critical: 'Critical',
+    warning: 'Warning',
+    success: 'Good news',
+    info: 'Info',
+    neutral: 'Routine'
+};
+/**
+ * Each core type's level when its emitter stamps none. A plugin's types are
+ * not listed: a plugin emitter stamps `level` itself, and an unstamped one
+ * reads as `neutral`.
+ *
+ * A type the operator alert registry raises under its own notification type
+ * must agree with that alert's level, so the backlog written before `level`
+ * existed reads the same as what the registry writes today
+ * (`notification-levels.spec.ts` holds the two together).
+ */ export const NOTIFICATION_TYPE_LEVELS = {
+    'billing.invoice': 'neutral',
+    'billing.paymentFailed': 'critical',
+    'billing.subscriptionCanceled': 'critical',
+    // At a limit. A step on the way to it is stamped `info` by its emitter.
+    'billing.usage': 'warning',
+    'team.invite': 'info',
+    'team.roleChanged': 'info',
+    'team.hostAccessGranted': 'info',
+    'content.formSubmission': 'neutral',
+    'content.booking': 'success',
+    'content.order': 'success',
+    'content.lowStock': 'warning',
+    'content.taskAssigned': 'neutral',
+    'content.taskReminder': 'info',
+    'content.contactAssigned': 'neutral',
+    'content.leadAssigned': 'neutral',
+    'content.crmDailyDigest': 'neutral',
+    'content.insightsDigest': 'neutral',
+    'marketplace.review': 'info',
+    'support.ticketOpened': 'info',
+    'support.ticketReply': 'info',
+    'system.announcement': 'info',
+    'system.pluginVerifierRegression': 'warning',
+    'system.signInMethodRemoved': 'warning',
+    'system.scopeDrift': 'info',
+    'system.ssoDomainUnverified': 'warning',
+    'system.formSubmissionsPaused': 'critical',
+    'system.visitorRecordsPaused': 'critical',
+    'system.abuseReportUrgent': 'critical',
+    'system.riskNotice': 'critical',
+    'system.dmcaCounterNotice': 'critical',
+    'system.bandwidthCeilingTripped': 'warning',
+    // The site is serving the capped notice to its visitors.
+    'system.bandwidthCapEngaged': 'critical',
+    'system.billingWebhookHalfApplied': 'critical',
+    'system.disputeUnattributed': 'critical',
+    // The registry stamps each alert's own level; this answers only for one
+    // written before it did.
+    'system.operatorAlert': 'warning',
+    'staff.userSignedUp': 'success',
+    'staff.orgCreated': 'success',
+    'staff.subscriptionStarted': 'success',
+    'staff.subscriptionCanceled': 'warning',
+    'staff.planChanged': 'info',
+    'staff.paymentFailed': 'warning'
+};
+const LEVEL_SET = new Set(NOTIFICATION_LEVELS);
+/** Whether a stored value is a level this build knows. */ export function isNotificationLevel(value) {
+    return typeof value === 'string' && LEVEL_SET.has(value);
+}
+/**
+ * A notification's level: what its emitter stamped, else its type's
+ * default, else `neutral`. A stamped value this build does not know — a
+ * level added later, read by an older console — falls back the same way
+ * rather than drawing nothing.
+ */ export function notificationLevel(notification) {
+    var _ref;
+    const stamped = notification == null ? void 0 : notification.level;
+    if (isNotificationLevel(stamped)) return stamped;
+    const byType = NOTIFICATION_TYPE_LEVELS[(_ref = notification == null ? void 0 : notification.type) != null ? _ref : ''];
+    return byType != null ? byType : 'neutral';
+}
+/**
+ * A usage notice's level at `percent` of its allowance: `info` on a step
+ * toward it, `warning` once it is reached. Every usage, budget and allotment
+ * notice says the same thing at the same step, so they share this.
+ */ export function usageNotificationLevel(percent) {
+    return percent >= 100 ? 'warning' : 'info';
+}
+/** The loudest of several levels, or `neutral` for none. */ export function loudestNotificationLevel(levels) {
+    let best = NOTIFICATION_LEVELS.length - 1;
+    for (const level of levels){
+        const rank = NOTIFICATION_LEVELS.indexOf(level);
+        if (rank >= 0 && rank < best) best = rank;
+    }
+    return NOTIFICATION_LEVELS[best];
+}
+/**
+ * The declared categories, in the order the settings page lists them: after
+ * the workspace's own work and before the platform's notices, which is where
+ * a plugin's traffic sits in a reader's day.
+ */ const DECLARED_CATEGORIES = PLUGIN_NOTIFICATION_CATEGORIES_DECLARED;
+/**
+ * The core's rows listed before the declared ones. Every other core category
+ * follows them, in the order its `Record` spells it, so a new core category
+ * cannot be left off the page.
+ */ const LEADING_CATEGORIES = [
+    'billing',
+    'team',
+    'content'
+];
+function inCategoryOrder(core, declared) {
+    // Every core id is written below, so the keys the type promises are there.
+    const out = {};
+    for (const id of LEADING_CATEGORIES)out[id] = core[id];
+    for (const declaration of DECLARED_CATEGORIES){
+        out[declaration.id] = declared(declaration);
+    }
+    for (const id of Object.keys(core)){
+        if (!LEADING_CATEGORIES.includes(id)) out[id] = core[id];
+    }
+    return out;
+}
+const CORE_CATEGORY_LABELS = {
     billing: 'Billing',
     team: 'Team & access',
     content: 'Forms & bookings',
-    marketplace: 'Marketplace',
     support: 'Support',
     system: 'Product & system',
     staff: 'Platform growth'
 };
+/** Every category's row name, the core's and the declared, in page order. */ export const NOTIFICATION_CATEGORY_LABELS = inCategoryOrder(CORE_CATEGORY_LABELS, (declaration)=>declaration.label);
 /**
  * The categories only staff can receive (AGL-3225).
  *
@@ -86,29 +215,27 @@ export const NOTIFICATION_CATEGORY_LABELS = {
  *
  * Written as what ARRIVES rather than as what the bucket is called: "someone
  * joins, a role changes" is checkable against your own feed in a way that
- * "team and access events" is not. Exhaustive `Record`, like the channel
- * defaults below — a new category cannot ship without somebody saying in
- * plain words what lands in it.
- */ export const NOTIFICATION_CATEGORY_DESCRIPTIONS = {
+ * "team and access events" is not. Exhaustive over the core's categories,
+ * like the channel defaults below, and required of every declaration — a new
+ * category cannot ship without somebody saying in plain words what lands in
+ * it.
+ */ const CORE_CATEGORY_DESCRIPTIONS = {
     billing: 'Invoices, failed payments, cancellations, and usage that crosses a plan limit.',
     team: 'Somebody joins or leaves, a role changes, or a site is shared with you.',
     content: 'Work arriving on your sites: form submissions, bookings, orders, low stock, and the tasks and leads assigned to you.',
-    marketplace: 'Decisions on plugin listings you submitted for review.',
     support: 'New support tickets and replies on tickets you are following.',
     system: 'Announcements, and the faults the platform finds in your account: sign-in methods removed, traffic limits reached, billing or sharing left in a broken state.',
     staff: 'New accounts, new workspaces, and money moving — subscriptions starting, changing, failing and ending — across the whole platform. Only staff receive these.'
 };
-export function notificationCategory(type) {
+export const NOTIFICATION_CATEGORY_DESCRIPTIONS = inCategoryOrder(CORE_CATEGORY_DESCRIPTIONS, (declaration)=>declaration.description);
+/**
+ * The bucket a type falls in: its prefix, when a category of that id exists,
+ * and `system` otherwise — the bucket nobody mutes to reduce noise, so a type
+ * nothing claims still reaches the person rather than riding a mute they set
+ * for something else.
+ */ export function notificationCategory(type) {
     const prefix = String(type).split('.')[0];
-    return [
-        'billing',
-        'team',
-        'content',
-        'marketplace',
-        'support',
-        'system',
-        'staff'
-    ].includes(prefix) ? prefix : 'system';
+    return Object.prototype.hasOwnProperty.call(NOTIFICATION_CATEGORY_LABELS, prefix) ? prefix : 'system';
 }
 /**
  * Per-user mute map stored at `users/{uid}.notificationPrefs`
@@ -118,25 +245,19 @@ export function notificationCategory(type) {
 }
 /**
  * The field on `users/{uid}` that holds a person's digest switches
- * (AGL-2619): `{ crmDaily: false }` turns the daily CRM digest off, and an
- * absent key leaves it on. Its own map rather than a key in
- * `notificationPrefs`, because that map is keyed by CATEGORY and read by
- * {@link notificationMuted} — a digest is a schedule a person keeps or
- * drops, not a bucket of types, and one switch governs both the console
- * notification and the email it travels with.
+ * (AGL-2619): `{ [digestKey]: false }` turns one digest off, and an absent key
+ * leaves it on. Its own map rather than a key in `notificationPrefs`, because
+ * that map is keyed by CATEGORY and read by {@link notificationMuted} — a
+ * digest is a schedule a person keeps or drops, not a bucket of types, and one
+ * switch governs both the console notification and the email it travels with.
  */ export const DIGEST_PREFS_FIELD = 'digestPrefs';
+/** Every declared digest, in the order the settings page lists them. */ export const NOTIFICATION_DIGESTS = PLUGIN_NOTIFICATION_DIGESTS_DECLARED;
 /**
- * The key the daily CRM digest keeps inside {@link DIGEST_PREFS_FIELD}.
- *
- * Exported so the console writes the switch through a name rather than a
- * second copy of the string (AGL-3230). The reader below and the page that
- * flips it were spelling the same literal in two files, which is how a
- * preference comes to be written under one key and read under another — and
- * it kept the plugin's vocabulary in a console page, where
- * `check:plugin-domain-in-core` rightly refuses it.
- */ export const CRM_DAILY_DIGEST_KEY = 'crmDaily';
-export function crmDailyDigestEnabled(prefs) {
-    return (prefs == null ? void 0 : prefs[CRM_DAILY_DIGEST_KEY]) !== false;
+ * Whether a person keeps one digest: on unless its key is stored `false`. It
+ * reads only its own key — a category mute lives in a different map and does
+ * not reach it.
+ */ export function digestEnabled(prefs, key) {
+    return (prefs == null ? void 0 : prefs[key]) !== false;
 }
 /**
  * The field on `users/{uid}` naming the workspaces whose weekly insights a
@@ -161,10 +282,12 @@ export const NOTIFICATION_SETTINGS_FIELD = 'notificationSettings';
  * Turning a busy site's form submissions into mail by default would put that
  * domain's reputation behind traffic the recipient never asked for.
  *
- * Exhaustive `Record` deliberately: a new {@link NotificationCategory} is a
- * compile error here until somebody decides what it does by default, which is
- * the one question a new category must not be able to ship without answering.
- */ export const NOTIFICATION_CHANNEL_DEFAULTS = {
+ * Exhaustive over the core's categories deliberately: a new
+ * {@link CoreNotificationCategory} is a compile error here until somebody
+ * decides what it does by default, which is the one question a new category
+ * must not be able to ship without answering — and a declared category may not
+ * compile without its `defaults` for the same reason.
+ */ const CORE_CHANNEL_DEFAULTS = {
     billing: {
         console: true,
         email: false
@@ -177,10 +300,6 @@ export const NOTIFICATION_SETTINGS_FIELD = 'notificationSettings';
         console: true,
         email: false
     },
-    marketplace: {
-        console: true,
-        email: false
-    },
     support: {
         console: true,
         email: false
@@ -198,22 +317,41 @@ export const NOTIFICATION_SETTINGS_FIELD = 'notificationSettings';
         email: false
     }
 };
+export const NOTIFICATION_CHANNEL_DEFAULTS = inCategoryOrder(CORE_CHANNEL_DEFAULTS, (declaration)=>_extends({}, declaration.defaults));
 /**
  * The types that send their OWN email and must never be mailed again by the
  * generic channel (AGL-3224).
  *
  * Both digests compose a message the fan-out could not reproduce — a day's
  * owed tasks, a week's figures — and send it from their own route under their
- * own switch (`digestPrefs.crmDaily`, `insightDigests.{orgId}`). A recipient
+ * own switch (a key in `digestPrefs`, `insightDigests.{orgId}`). A recipient
  * who switches the `content` email channel on would otherwise receive the
  * digest twice: once as the digest, once as a one-line "Daily CRM digest"
  * notification saying that the digest happened.
  */ export const NOTIFICATION_SELF_SENT_EMAIL_TYPES = new Set([
     'content.crmDailyDigest',
     'content.insightsDigest',
+    // The task-reminders route mails one reminder per member per run, listing
+    // every task due, and writes one notification per task; mailed again
+    // here, each task would arrive a second time as its own email (AGL-3432).
+    'content.taskReminder',
     // Emailed by `notifyRiskEvent` itself, as account mail (AGL-3368).
     'system.riskNotice'
 ]);
+/**
+ * The tooltip on a self-sent type's disabled email switch: it names what
+ * DOES govern that mail, which differs by type (AGL-3432). Calling a task
+ * reminder a digest sent people looking for a Digests switch that is not it.
+ */ export function selfSentEmailNote(type) {
+    switch(type){
+        case 'content.taskReminder':
+            return 'Task reminders send their own email, one per run listing every task due. Mute this category to stop them.';
+        case 'system.riskNotice':
+            return 'Risk and account notices are always emailed, whatever this switch says.';
+        default:
+            return 'This digest sends its own email, under its switch in Digests.';
+    }
+}
 /**
  * Whether a channel is on for one notification, at its own scope.
  *