@12-apps/notifications 4.9.0 → 4.10.1

package/ADOPTING.md

@@ -448,13 +448,72 @@ contract `EmailPreviewMessage` states. The one mistake a preview surface must be
 incapable of — putting a sample in somebody's inbox — is not reachable from that
 code at all, rather than merely not done.
 
+## Live activities (optional)
+
+The panel's second kind of entry: ONGOING STATE, pinned above the inbox list.
+Off unless you configure it, and off means *nothing rendered* — no section, no
+heading, no reserved space. `README.md` carries the argument and the full shape;
+this is the adoption contract.
+
+**You supply two things and this package owns the rest.**
+
+```ts
+createWebNotifications({
+  …,
+  liveActivities: {
+    useActivities: ({ active }) => useMyLiveThings({ enabled: active }),
+    messages: { sectionTitle, openActivity, updated },
+  },
+});
+```
+
+1. **Where they come from.** A HOOK, not a fetcher and not a factory-time
+   subscribe — the answer almost always lives in React context (your tenant,
+   your session, your query client), which is the same reason
+   `NotificationsSignalHook` exists one seam over. `active` is `false` while the
+   panel is shut; pass it to your query's `enabled`. Ignoring it is correct and
+   merely costs money — and an unopened inbox is free either way, because the
+   panel is lazy and the drawer unmounts its content on close.
+2. **Three sentences**, in their own pack rather than on
+   `NotificationMessages` — live activities are opt-in, and requiring copy for a
+   section you never render is the tax that gets a required-config change
+   reverted instead of adopted.
+
+**Two rules that are ours, not yours:**
+
+- A live activity NEVER touches `unread`. It is not news, and a number the bell
+  cannot clear is worse than no number.
+- It leaves when your hook stops returning it. There is no dismiss, no read and
+  no delete — the subject finishing is the only exit, which is what stops the
+  section becoming a second inbox.
+
+**On a phone**, put the activity's id on the notifications you already send
+about the same subject:
+
+```ts
+import { LIVE_SUBJECT_KEY } from '@12-apps/notifications';   // the root entry
+
+data: { [LIVE_SUBJECT_KEY]: `order:${orderId}` }
+```
+
+(`LiveActivity` itself comes from either entry — the root or `./react` — so the
+hook and the type it returns are one import line.)
+
+`formatWebPush` turns it into `tag` on the push payload; your service worker
+passes `tag` to `showNotification` and the tray keeps ONE entry per subject
+instead of one per stage. The worker is still yours (rule 12) — a worker that
+ignores `tag` behaves exactly as it does today.
+
 ## What does NOT come with it
 
 - **The events.** Generators are host code (see rule 6).
 - **A queue.** `scheduleDispatch` is a seam, not an implementation.
 - **A plan model.** `channelPolicy` answers; it does not decide.
 - **An authorization engine.** `audience` answers; it does not decide.
-- **A service worker.** The file is the host's (rule 12).
+- **A service worker.** The file is the host's (rule 12) — including the four
+  lines that read `tag` off a live push.
+- **Anything to BE live about.** `useActivities` is a seam; this package has no
+  idea what is happening in your product, which is the point.
 - **The mail INVENTORY.** The preview console renders what you declare as
   sources; it cannot discover what your product sends.
 - **A brand, a palette or a sentence.** The layout requires the first, defaults

package/README.md

@@ -186,6 +186,79 @@ holds no driver, no transport and no address.
 
 See **[ADOPTING.md](./ADOPTING.md)** for the mount, the gate and the sources.
 
+## Live activities — the centre's second kind of entry
+
+An inbox notification is an EVENT: it happened, it is stamped, it is read or
+unread, and tomorrow it still says the same thing. A **live activity** is
+ONGOING STATE — pinned above the list, no read/unread, nothing to delete, it
+updates itself, and it is gone the moment the thing it tracks finishes.
+
+The distinction is not cosmetic. "Your order is on its way", read an hour later,
+is a claim about the past presented as news; the more reliable the inbox is, the
+more of those a person accumulates, and somewhere in the pile is the question
+they actually have — *where is it now*.
+
+Opt-in, and absent means absent: a host that passes nothing renders the panel it
+had, with no section, no heading and no reserved space.
+
+```ts
+createWebNotifications({
+  apiBase: '/api/account',
+  messages,
+  liveActivities: {
+    // A HOOK, so it may read context — the tenant, the session, a query client.
+    useActivities: ({ active }) => useMyLiveThings({ enabled: active }),
+    messages: { sectionTitle, openActivity, updated },
+    renderIcon: (activity) => ICONS[activity.kind],
+  },
+});
+```
+
+`active` is whether anyone is looking — `false` while the panel is shut. Pass it
+to your query's `enabled`. It is a hint about NEED, never about correctness, and
+it is not what makes an unopened inbox free: the panel is fetched lazily and the
+drawer unmounts its content on close, so a host that ignores `active` still
+issues nothing until somebody opens the bell.
+
+One activity is `{ id, kind, title, body, link, steps, activeStepId, updatedAt }`
+— `LiveActivity`, importable from either entry (`@12-apps/notifications` or
+`@12-apps/notifications/react`, so a host wiring the surface needs one import
+line, not two). It is defined in `src/live.ts`. `steps` + `activeStepId` draw a lane, because "how far along is
+this" is the shape almost every ongoing subject has; both are optional in effect
+— an activity with no lane is a heading, a sentence and a timestamp that keeps
+moving. An `activeStepId` naming no step draws NO lane rather than a lane with
+nothing lit, which would read as a process that has stopped.
+
+### On a phone: one tray entry, one buzz
+
+The other half is the OS notification, and it is one field. A generator whose
+event is about something also tracked live puts the activity's id in `data`:
+
+```ts
+import { LIVE_SUBJECT_KEY } from '@12-apps/notifications';   // the root entry
+
+data: { [LIVE_SUBJECT_KEY]: `order:${orderId}` }
+```
+
+`formatWebPush` turns that into a `tag` on the push payload, and a tag makes the
+next push about the same subject **replace** the one already in the tray —
+silently — instead of stacking under it. Four stages then cost one entry and one
+buzz, and the entry that remains is the current one. Without it a phone
+accumulates one alert per stage, each still asserting a stage the subject has
+since left.
+
+`tag` is `null` for an ordinary event rather than absent, so a service worker
+reads one payload shape. A worker that ignores it keeps today's behaviour
+exactly — which is what makes the field safe to ship ahead of the workers:
+
+```js
+self.registration.showNotification(payload.title, {
+  body: payload.body,
+  data: { link: payload.link },
+  ...(payload.tag ? { tag: payload.tag, renotify: false } : {}),
+});
+```
+
 ## The models
 
 `prisma/notifications.prisma` — `Notification`, `NotificationDelivery`,

package/dist/{chunk-BGI4BQ66.js → chunk-6W7INOYQ.js}

@@ -19,4 +19,4 @@ export {
   NOTIFICATION_CHANNELS,
   taxonomyOf
 };
-//# sourceMappingURL=chunk-BGI4BQ66.js.map
+//# sourceMappingURL=chunk-6W7INOYQ.js.map

package/dist/chunk-6W7INOYQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/**\n * Core types of the channel-agnostic notification system (12-15).\n *\n * Three decoupled layers, each open for extension without touching the others:\n *   - GENERATORS map a typed domain event to agnostic content (title/body/…).\n *   - The CHANNEL ROUTER always writes the notification-centre inbox record,\n *     then fans out one delivery per enabled channel.\n *   - TRANSPORTS format the agnostic content for one channel and send it.\n *\n * Nothing here knows about a concrete channel's wire format — that lives\n * entirely inside each transport adapter — and nothing here knows about a\n * concrete DOMAIN either: the event `type` set, the preference categories and\n * the channel list are all host config (see {@link NotificationTaxonomy}).\n */\n\n/** Transport channels a notification can fan out to (DB CHECK mirrors this). */\nexport const NOTIFICATION_CHANNELS = ['EMAIL', 'SMS', 'WHATSAPP', 'WEB_PUSH'] as const;\nexport type NotificationChannel = (typeof NOTIFICATION_CHANNELS)[number];\n\n/**\n * The preference categories are the HOST's, and required.\n *\n * There used to be a `NOTIFICATION_CATEGORIES = ['orders','payments','stock',\n * 'system']` here — one product's set — and `taxonomyOf` fell back to it\n * whenever a host passed none. The docstring argued the case itself: \"it is\n * product vocabulary, not machinery\", and then shipped the vocabulary anyway as\n * the default, which is the only part a forgetful host would ever see.\n *\n * The consequence was quiet rather than loud: the settings screen renders four\n * rows a foreign host never chose, its own categories are absent, and every\n * preference a user sets is filed against a taxonomy nothing else in that\n * system uses. Nothing throws, because `category` is deliberately a free string\n * — the packaged migration puts **no CHECK** on it, precisely because a closed\n * set would be wrong for every host but the first. That freedom is what made\n * the default undetectable.\n *\n * `channel` and `status` are different and keep their CHECKs: those ARE this\n * library's own closed sets.\n */\nexport type NotificationCategory = string;\n\n/**\n * Per-channel delivery lifecycle (DB CHECK mirrors this).\n *\n * `SENDING` is the CLAIM: exactly one dispatcher moves a row out of `QUEUED`,\n * so two dispatchers can never both send the same delivery. A row left\n * `SENDING` is a dispatcher that died mid-send, and the sweep reclaims it once\n * it is older than the cutoff.\n *\n * `DEAD` is terminal: the attempt ceiling was reached (or the recipient no\n * longer exists), and no sweep will pick the row up again. Without it a\n * permanently invalid destination is a billed provider call on every sweep,\n * forever, and the sweep's working set only grows.\n */\nexport type DeliveryStatus = 'QUEUED' | 'SENDING' | 'SENT' | 'FAILED' | 'DEAD';\n\n/**\n * Channel-agnostic content a generator produces. This is what the inbox stores\n * verbatim and what every transport's formatter receives — no channel may leak\n * its wire format into it.\n */\nexport interface NotificationContent {\n  title: string;\n  body: string;\n  /** In-app deep link (a same-origin path such as `/orders/123`). */\n  link?: string;\n  /**\n   * Structured extras for consumers that want more than text.\n   *\n   * ONE KEY IS RESERVED: `liveSubject` (`LIVE_SUBJECT_KEY` in `./live`) ties\n   * this notification to a live activity, and the WEB_PUSH transport turns it\n   * into the tray `tag` that collapses every push about one subject onto a\n   * single entry. A host already using that name for something else acquires\n   * that behaviour without asking for it — so it is named here, on the field a\n   * generator actually writes, and not only where the feature is documented.\n   */\n  data?: Record<string, unknown>;\n}\n\n/** Who receives a notification. `clientId` scopes it to a tenant when set. */\nexport interface NotificationRecipient {\n  userId: string;\n  clientId?: string;\n}\n\n/**\n * A typed domain event handed to `notify`. `type` selects the registered\n * generator; `payload` is that generator's typed input. Callers never touch\n * channels, formatting, or preferences.\n */\nexport interface NotificationEvent<TPayload = unknown> {\n  type: string;\n  recipient: NotificationRecipient;\n  payload: TPayload;\n}\n\n/**\n * Maps one domain event type to agnostic content. Registered through the\n * server config (or `registerGenerator` for a late arrival); adding a\n * generator never touches existing generators, the router, or any transport\n * (open/closed).\n */\n/**\n * Who the content is being rendered FOR — the reader, at the moment the\n * generator is asked.\n *\n * A notification is stored as rendered TEXT: title and body are columns, so\n * the language is chosen once, when the row is written, and never again. That\n * makes this the only honest place to ask. A generator is registered at BOOT —\n * a host that resolved its words there would pin every future reader to\n * whichever language the process happened to start in, invisibly, because a\n * single-locale host cannot tell the difference.\n *\n * The tag is the RECIPIENT's, never the request's. The person who triggers a\n * notification is routinely not the person who reads it: an invite is sent\n * because an administrator acted and is read by the invitee. Reading\n * `Accept-Language` here would be a bug that only ever surfaces as somebody\n * being told things in a language they do not speak.\n *\n * Absent means \"nobody said\" — a host with one audience, or one that stores no\n * per-user language, populates nothing and every generator answers with its\n * own default exactly as it did before this existed.\n */\nexport interface NotificationGenerateContext {\n  readonly locale?: string | null;\n}\n\nexport interface NotificationGenerator<TPayload = unknown> {\n  /** The event key, dot-namespaced (\"order.paid\"). One generator per type. */\n  type: string;\n  /** The preference category the router gates this type's fan-out on. */\n  category: NotificationCategory;\n  /**\n   * Render this event's content for ONE recipient.\n   *\n   * `context` is OPTIONAL, and that is what keeps every generator written\n   * before it working: a one-parameter `generate` is assignable to this\n   * signature unchanged. A host that passes nothing is stating a fact — it has\n   * no language for this reader — rather than asserting a default.\n   */\n  generate: (payload: TPayload, context?: NotificationGenerateContext) => NotificationContent;\n}\n\n/**\n * The recipient as a transport sees them: resolved destinations only. Built by\n * the router from the host's contact directory + the push subscriptions this\n * package owns; transports use it to answer\n * {@link NotificationTransport.supports}.\n */\nexport interface TransportRecipient {\n  userId: string;\n  email: string | null;\n  /**\n   * The recipient's own language, when the host's contact directory states\n   * one. Absent means \"nobody said\" — see {@link NotificationGenerateContext}.\n   */\n  locale?: string | null;\n  /** Phone as the host stores it (transports normalize per provider rules). */\n  phone: string | null;\n  /** How many active browser push subscriptions the user holds. */\n  pushSubscriptionCount: number;\n}\n\n/**\n * One pluggable channel adapter: a FORMATTER (agnostic content → channel\n * message) plus a SENDER. Adding a channel = registering one of these; the\n * router dispatches through the registry and needs no change.\n *\n * `send` resolves on success and THROWS on failure — the router records the\n * error on the delivery row and isolates it from other channels. Sends must be\n * retry-safe: the router may re-dispatch a QUEUED/FAILED delivery.\n */\nexport interface NotificationTransport<TMessage = unknown> {\n  channel: NotificationChannel;\n  /**\n   * Whether this recipient is addressable on this channel right now — the\n   * destination exists (e-mail / phone / push subscription) AND the provider\n   * is configured. `false` simply skips the channel (no delivery row).\n   */\n  supports(recipient: TransportRecipient): boolean;\n  /** Transform the agnostic content into this channel's message shape. */\n  format(content: NotificationContent): TMessage;\n  /** Deliver the formatted message to the recipient. Throws on failure. */\n  send(message: TMessage, recipient: TransportRecipient): Promise<void>;\n}\n\n/**\n * The host's product vocabulary. Everything below the surface (routing,\n * delivery rows, retries, the wire) is identical for every host; WHICH\n * categories exist and how they are labelled is not.\n */\nexport interface NotificationTaxonomy {\n  /** The preference categories, in the order the settings screen lists them. */\n  categories: readonly NotificationCategory[];\n}\n\n/**\n * The taxonomy in force. `categories` is REQUIRED — see above.\n *\n * The empty check was already here and stays: an empty list and a missing one\n * are the same mistake, and both now fail at assembly rather than rendering an\n * empty settings screen or somebody else's four rows.\n */\nexport function taxonomyOf(config: {\n  categories: readonly NotificationCategory[];\n}): NotificationTaxonomy {\n  const categories = config.categories;\n  if (!categories || categories.length === 0) {\n    throw new Error(\n      '@12-apps/notifications: `categories` is required and must not be empty — ' +\n        'the preference categories are the host\\'s product vocabulary.',\n    );\n  }\n  return { categories: [...categories] };\n}\n\n/** The host's logger. Defaults to the console (the @12-apps/jobs precedent). */\nexport interface NotificationLogger {\n  info(message: string, ...meta: unknown[]): void;\n  error(message: string, ...meta: unknown[]): void;\n}\n"],"mappings":";;;;;AAgBO,IAAM,wBAAwB,CAAC,SAAS,OAAO,YAAY,UAAU;AA2LrE,SAAS,WAAW,QAEF;AACvB,QAAM,aAAa,OAAO;AAC1B,MAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,SAAO,EAAE,YAAY,CAAC,GAAG,UAAU,EAAE;AACvC;AAXgB;","names":[]}

package/dist/{chunk-M5XTROYM.js → chunk-I5QUMTCN.js}

@@ -105,8 +105,77 @@ __name(httpNotificationsTransport, "httpNotificationsTransport");
 import { useState as useState2 } from "react";
 
 // src/react/bell-button.tsx
+import { useSyncExternalStore } from "react";
 import { Badge } from "@12-apps/ui/data-display/Badge";
 import { Box } from "@12-apps/ui/mui/Box";
+
+// src/react/live-seen.ts
+var STORAGE_KEY = "12a.notifications.live-seen";
+var EMPTY = {};
+function instant(iso) {
+  if (iso === void 0) return null;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? null : ms;
+}
+__name(instant, "instant");
+function readStored() {
+  try {
+    const raw = globalThis.localStorage?.getItem(STORAGE_KEY);
+    if (!raw) return EMPTY;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return EMPTY;
+    const clean = {};
+    for (const [id, value] of Object.entries(parsed)) {
+      if (typeof value === "string") clean[id] = value;
+    }
+    return clean;
+  } catch {
+    return EMPTY;
+  }
+}
+__name(readStored, "readStored");
+function writeStored(value) {
+  try {
+    globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(value));
+  } catch {
+  }
+}
+__name(writeStored, "writeStored");
+function createLiveSeenStore() {
+  let current = readStored();
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    read: /* @__PURE__ */ __name(() => current, "read"),
+    mark: /* @__PURE__ */ __name((activities) => {
+      const next = {};
+      for (const activity of activities) next[activity.id] = activity.updatedAt;
+      const ids = Object.keys(next);
+      const same = ids.length === Object.keys(current).length && ids.every((id) => current[id] === next[id]);
+      if (same) return;
+      current = next;
+      writeStored(next);
+      for (const listener of listeners) listener();
+    }, "mark"),
+    subscribe: /* @__PURE__ */ __name((listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }, "subscribe")
+  };
+}
+__name(createLiveSeenStore, "createLiveSeenStore");
+function hasUnseenActivity(activities, seen) {
+  return activities.some((activity) => {
+    const shown = instant(seen[activity.id]);
+    if (shown === null) return true;
+    const now = instant(activity.updatedAt);
+    return now === null || now > shown;
+  });
+}
+__name(hasUnseenActivity, "hasUnseenActivity");
+
+// src/react/bell-button.tsx
 import { jsx } from "react/jsx-runtime";
 var triggerSx = {
   display: "inline-flex",
@@ -127,19 +196,12 @@ var triggerSx = {
     borderRadius: "50%"
   }
 };
-function BellButton({
+function BellTrigger({
   onClick,
-  enabled = true,
-  store,
-  messages,
-  subscribe,
-  useSignal
+  count,
+  hasNew,
+  messages
 }) {
-  const count = useUnreadCount(store, {
-    enabled,
-    ...subscribe ? { subscribe } : {},
-    ...useSignal ? { useSignal } : {}
-  });
   return /* @__PURE__ */ jsx(
     Box,
     {
@@ -153,24 +215,70 @@ function BellButton({
         Badge,
         {
           content: count > 0 ? count : void 0,
-          color: "primary",
+          color: hasNew ? "primary" : "neutral",
           variant: "count",
           max: 99,
           "data-testid": "notifications-badge",
+          "data-tone": hasNew ? "new" : "seen",
           children: /* @__PURE__ */ jsx(BellIcon, { size: 28 })
         }
       )
     }
   );
 }
+__name(BellTrigger, "BellTrigger");
+function BellButton({
+  onClick,
+  enabled = true,
+  store,
+  messages,
+  subscribe,
+  useSignal
+}) {
+  const count = useUnreadCount(store, {
+    enabled,
+    ...subscribe ? { subscribe } : {},
+    ...useSignal ? { useSignal } : {}
+  });
+  return /* @__PURE__ */ jsx(BellTrigger, { onClick, count, hasNew: count > 0, messages });
+}
 __name(BellButton, "BellButton");
+function LiveBellButton({
+  onClick,
+  enabled = true,
+  store,
+  messages,
+  subscribe,
+  useSignal,
+  live,
+  seen
+}) {
+  const unread = useUnreadCount(store, {
+    enabled,
+    ...subscribe ? { subscribe } : {},
+    ...useSignal ? { useSignal } : {}
+  });
+  const activities = live.useActivities({ active: enabled });
+  const seenIso = useSyncExternalStore(seen.subscribe, seen.read, seen.read);
+  const liveCount = enabled ? activities.length : 0;
+  return /* @__PURE__ */ jsx(
+    BellTrigger,
+    {
+      onClick,
+      count: unread + liveCount,
+      hasNew: unread > 0 || enabled && hasUnseenActivity(activities, seenIso),
+      messages
+    }
+  );
+}
+__name(LiveBellButton, "LiveBellButton");
 
 // src/react/panel-lazy.tsx
 import { Suspense, lazy, useEffect, useState } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function lazyNotificationsPanel(parts) {
   const Bound = lazy(async () => {
-    const { NotificationsPanel } = await import("./panel-UFXNO4AF.js");
+    const { NotificationsPanel } = await import("./panel-OPB3DBLJ.js");
     return {
       default: /* @__PURE__ */ __name((props) => /* @__PURE__ */ jsx2(NotificationsPanel, { ...props, ...parts }), "default")
     };
@@ -191,7 +299,7 @@ import { Suspense as Suspense2, lazy as lazy2 } from "react";
 import { jsx as jsx3 } from "react/jsx-runtime";
 function lazyPreferencesPage(parts) {
   const Bound = lazy2(async () => {
-    const { PreferencesScreen } = await import("./preferences-screen-V3ZBWP7A.js");
+    const { PreferencesScreen } = await import("./preferences-screen-SXUIGECY.js");
     return {
       default: /* @__PURE__ */ __name((props) => /* @__PURE__ */ jsx3(PreferencesScreen, { ...props, ...parts }), "default")
     };
@@ -217,8 +325,24 @@ function createWebNotifications(config) {
     ...subscribe ? { subscribe } : {},
     ...config.useSignal ? { useSignal: config.useSignal } : {}
   };
-  const Bell = /* @__PURE__ */ __name((props) => /* @__PURE__ */ jsx4(BellButton, { ...props, store, messages, ...subscribeOption }), "Bell");
-  const Panel = lazyNotificationsPanel({ store, messages });
+  const liveSeen = createLiveSeenStore();
+  const live = config.liveActivities;
+  const Bell = live ? (props) => /* @__PURE__ */ jsx4(
+    LiveBellButton,
+    {
+      ...props,
+      store,
+      messages,
+      live,
+      seen: liveSeen,
+      ...subscribeOption
+    }
+  ) : (props) => /* @__PURE__ */ jsx4(BellButton, { ...props, store, messages, ...subscribeOption });
+  const Panel = lazyNotificationsPanel({
+    store,
+    messages,
+    ...live ? { live, liveSeen } : {}
+  });
   function useBoundUnreadCount(options = {}) {
     return useUnreadCount(store, { ...options, ...subscribeOption });
   }
@@ -260,4 +384,4 @@ export {
   httpNotificationsTransport,
   createWebNotifications
 };
-//# sourceMappingURL=chunk-M5XTROYM.js.map
+//# sourceMappingURL=chunk-I5QUMTCN.js.map

package/dist/chunk-I5QUMTCN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/api.ts","../src/react/transport.ts","../src/react/create-web-notifications.tsx","../src/react/bell-button.tsx","../src/react/live-seen.ts","../src/react/panel-lazy.tsx","../src/react/page-lazy.tsx"],"sourcesContent":["import type { ChannelRow } from '../preferences-core';\nimport type { NotificationChannel } from '../types';\nimport type { ListNotificationsResult } from '../wire';\n\nimport type { NotificationsResult, NotificationsTransport } from './transport';\n\n/**\n * The wire client, bound to one mount (12-15).\n *\n * Every path this package's screens can call, in one place — which is what\n * makes the api half's route table and the web half's URLs one contract instead\n * of two lists that drift.\n */\n\n/** `GET <mount>/notification-preferences` and the PUT's answer. */\nexport interface PreferencesPayload {\n  preferences: Record<string, ChannelRow>;\n  availability: Record<NotificationChannel, boolean>;\n  /** The host's taxonomy, so the screen renders it without being told twice. */\n  categories: string[];\n}\n\n/** `GET <mount>/push-subscriptions`. */\nexport interface PushRegistrationPayload {\n  /** null = web push is not configured on this deployment. */\n  vapidPublicKey: string | null;\n  count: number;\n  /**\n   * Whether the endpoint asked about is still registered to the caller. Present\n   * only when one was passed — see {@link NotificationsApiClient.getPushRegistration}.\n   */\n  registered?: boolean;\n}\n\nexport interface NotificationsApiClient {\n  listNotifications(input: {\n    cursor?: string | null;\n    limit?: number;\n    filter?: 'all' | 'unread';\n  }): Promise<ListNotificationsResult>;\n  unreadCount(): Promise<number>;\n  markRead(ids: readonly string[]): Promise<NotificationsResult<{ updated: number }>>;\n  markAllRead(): Promise<NotificationsResult<{ updated: number }>>;\n  remove(ids: readonly string[]): Promise<NotificationsResult<{ deleted: number }>>;\n  getPreferences(): Promise<PreferencesPayload>;\n  savePreference(\n    category: string,\n    channel: NotificationChannel,\n    enabled: boolean,\n  ): Promise<NotificationsResult<PreferencesPayload>>;\n  /**\n   * The deployment's VAPID key and the caller's device count — and, when an\n   * `endpoint` is passed, whether the SERVER still has that exact subscription\n   * under the caller's id. The browser holding a subscription object is not\n   * evidence of that: a re-own or a 404/410 prune drops the row and leaves the\n   * browser's object in place.\n   */\n  getPushRegistration(input?: { endpoint?: string }): Promise<PushRegistrationPayload>;\n  savePushSubscription(input: {\n    endpoint: string;\n    keys: { p256dh: string; auth: string };\n  }): Promise<NotificationsResult<{ count: number }>>;\n  removePushSubscription(endpoint: string): Promise<NotificationsResult<{ count: number }>>;\n}\n\nexport function createNotificationsApiClient(\n  apiBase: string,\n  transport: NotificationsTransport,\n): NotificationsApiClient {\n  const base = apiBase.replace(/\\/$/, '');\n  const url = (path: string): string => `${base}${path}`;\n\n  return {\n    listNotifications({ cursor, limit, filter }) {\n      const params = new URLSearchParams();\n      if (limit !== undefined) params.set('limit', String(limit));\n      if (cursor) params.set('cursor', cursor);\n      if (filter) params.set('filter', filter);\n      const query = params.toString();\n      return transport.get<ListNotificationsResult>(\n        url(`/notifications${query ? `?${query}` : ''}`),\n      );\n    },\n    async unreadCount() {\n      const { count } = await transport.get<{ count: number }>(\n        url('/notifications/unread-count'),\n      );\n      return count;\n    },\n    markRead: (ids) =>\n      transport.send(url('/notifications/mark-read'), 'POST', { ids: [...ids] }),\n    markAllRead: () => transport.send(url('/notifications/mark-read'), 'POST', { all: true }),\n    remove: (ids) => transport.send(url('/notifications/delete'), 'POST', { ids: [...ids] }),\n    getPreferences: () => transport.get<PreferencesPayload>(url('/notification-preferences')),\n    savePreference: (category, channel, enabled) =>\n      transport.send(url('/notification-preferences'), 'PUT', {\n        [category]: { [channel]: enabled },\n      }),\n    getPushRegistration: ({ endpoint } = {}) =>\n      transport.get<PushRegistrationPayload>(\n        url(\n          endpoint\n            ? `/push-subscriptions?endpoint=${encodeURIComponent(endpoint)}`\n            : '/push-subscriptions',\n        ),\n      ),\n    savePushSubscription: (input) => transport.send(url('/push-subscriptions'), 'POST', input),\n    removePushSubscription: (endpoint) =>\n      transport.send(url('/push-subscriptions'), 'DELETE', { endpoint }),\n  };\n}\n","/**\n * How the notification screens reach their data (12-15) — the report-builder\n * transport doctrine: this is the ONLY way the surface performs I/O, so a\n * caller supplying one has substituted the entire backend without stubbing a\n * global. The default is same-origin `fetch` riding the browser's cookies.\n */\n\n/** A write outcome the screens branch on — never a thrown mutation. */\nexport type NotificationsResult<T> = { ok: true; data: T } | { ok: false; error: string };\n\n/** A failed read, carrying the status the screens branch on (401 = signed out). */\nexport class NotificationsHttpError extends Error {\n  readonly status: number;\n  constructor(status: number, message: string) {\n    super(message);\n    this.name = 'NotificationsHttpError';\n    this.status = status;\n    Object.setPrototypeOf(this, NotificationsHttpError.prototype);\n  }\n}\n\nexport interface NotificationsTransport {\n  /** A read. Returns the payload INSIDE the `{ data }` envelope. */\n  get<T>(path: string): Promise<T>;\n  /** A write. Returns a {@link NotificationsResult} rather than rejecting. */\n  send<T>(path: string, method: string, body?: unknown): Promise<NotificationsResult<T>>;\n}\n\n/**\n * @param fallbackError What a failed write says when the server sent no\n * sentence of its own — REQUIRED, the host's words. `createWebNotifications`\n * already passes its (equally required) `messages.operationFailed`; only a\n * host constructing the transport directly writes it here. The old default\n * was one application's Portuguese, and the only string in this package the\n * required-messages port did not cover.\n */\nexport function httpNotificationsTransport(fallbackError: string): NotificationsTransport {\n  return {\n    async get<T>(path: string): Promise<T> {\n      const response = await fetch(path, {\n        credentials: 'same-origin',\n        headers: { Accept: 'application/json' },\n      });\n      const payload = (await response.json().catch(() => null)) as\n        | { data?: T; error?: string }\n        | null;\n      if (!response.ok) {\n        throw new NotificationsHttpError(\n          response.status,\n          payload?.error ?? `HTTP ${response.status} for ${path}`,\n        );\n      }\n      return (payload?.data ?? payload) as T;\n    },\n\n    async send<T>(path: string, method: string, body?: unknown): Promise<NotificationsResult<T>> {\n      try {\n        const response = await fetch(path, {\n          method,\n          credentials: 'same-origin',\n          headers: {\n            Accept: 'application/json',\n            ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),\n          },\n          ...(body === undefined ? {} : { body: JSON.stringify(body) }),\n        });\n        if (response.status === 204) return { ok: true, data: undefined as T };\n        const payload = (await response.json().catch(() => null)) as\n          | { data?: T; error?: string }\n          | null;\n        if (!response.ok) return { ok: false, error: payload?.error ?? fallbackError };\n        return { ok: true, data: (payload?.data ?? payload) as T };\n      } catch {\n        return { ok: false, error: fallbackError };\n      }\n    },\n  };\n}\n","import { useState, type ComponentType, type JSX } from 'react';\n\nimport { messagesOf, type NotificationMessages } from '../messages';\n\nimport { createNotificationsApiClient, type NotificationsApiClient } from './api';\nimport { BellButton, LiveBellButton, type BellButtonProps } from './bell-button';\nimport {\n  useUnreadCount,\n  type NotificationsSignalHook,\n  type NotificationsSubscribe,\n} from './hooks';\nimport { createInboxStore, type InboxStore } from './inbox-state';\nimport type { LiveActivitiesConfig } from './live-config';\nimport { createLiveSeenStore } from './live-seen';\nimport { lazyNotificationsPanel } from './panel-lazy';\nimport type { NotificationsPanelProps } from './panel';\nimport { lazyPreferencesPage } from './page-lazy';\nimport type { PreferencesScreenProps } from './preferences-screen';\nimport { httpNotificationsTransport, type NotificationsTransport } from './transport';\nimport type { WebPushSetupConfig } from './web-push-setup';\n\n/**\n * The one thing this package exposes to a FRONTEND host (12-15).\n *\n * Everything the notification centre IS — the bell with its live badge, the\n * slide-over inbox with its optimistic mark-read / delete / mark-all and its\n * cursor pager, the preferences matrix with its availability hints and the\n * per-browser push enable step, and every wire call between them — lives inside\n * this package. The host names where the API is mounted, and that is the whole\n * wiring.\n *\n * `page` is the standalone surface (the preferences screen), which is the one\n * thing a host routes to. The bell and the panel are a PAIR a host drops into\n * its own chrome, and they share one store, so a read in the panel moves the\n * badge in the same tick.\n */\n\nexport interface NotificationsWebConfig {\n  /** The account mount the routes live under, e.g. `/api/account`. */\n  apiBase: string;\n  /** How the surface reaches its data. Default: same-origin fetch. */\n  transport?: NotificationsTransport;\n  /** User-facing copy overrides (pt-BR product copy by default). */\n  messages: NotificationMessages;\n  /**\n   * How the surface learns an inbox changed without asking — the host's message\n   * bus. Without it the badge keeps its 60 s poll, which is the standing\n   * contract rather than a fallback: a dropped event must cost latency, never\n   * correctness.\n   */\n  subscribe?: NotificationsSubscribe;\n  /**\n   * The same wiring as a HOOK, for a host whose realtime connection lives in\n   * React context — see `NotificationsSignalHook`. `subscribe` is read at\n   * factory time, which such a host cannot reach.\n   */\n  useSignal?: NotificationsSignalHook;\n  /** The browser push enable step's host seams (SW path, platform hint). */\n  webPush?: WebPushSetupConfig;\n  /**\n   * LIVE ACTIVITIES — the ongoing-state entries pinned above the inbox list.\n   *\n   * Opt-in, and absent means absent: a host that passes nothing gets the panel\n   * it had, with no section, no heading and no reserved space. See\n   * `./live-config` for the two things a host has to supply (where they come\n   * from, and what the section says) and `../live` for what one IS.\n   */\n  liveActivities?: LiveActivitiesConfig;\n}\n\nexport interface WebNotifications {\n  /**\n   * The routed surface: the preferences screen.\n   *\n   * Loaded on demand — see `page-lazy.tsx`. A host that mounts only the bell and\n   * the panel never downloads it, and a host that routes to it fetches it while\n   * entering that route.\n   */\n  page: ComponentType<PreferencesScreenProps>;\n  /** The bell, already bound to the shared store. */\n  BellButton: ComponentType<BellButtonProps>;\n  /**\n   * The inbox slide-over, sharing that store.\n   *\n   * Loaded the first time it is opened — see `panel-lazy.tsx`. Until then a\n   * host's chrome carries the bell and nothing else.\n   */\n  Panel: ComponentType<NotificationsPanelProps>;\n  /**\n   * Bell + panel as ONE element, for a host that just wants the feature in its\n   * header and does not want to own the open/closed state.\n   */\n  BellWithPanel: ComponentType<{\n    enabled?: boolean;\n    onNavigate?: (link: string) => void;\n  }>;\n  /** The badge number, for a host with its own trigger chrome. */\n  useUnreadCount: (options?: { enabled?: boolean }) => number;\n  /** The shared client state, for host glue. */\n  store: InboxStore;\n  /** The bound wire client. */\n  api: NotificationsApiClient;\n  /** The copy in force, so a host's own chrome can reuse a sentence. */\n  messages: NotificationMessages;\n}\n\nexport function createWebNotifications(config: NotificationsWebConfig): WebNotifications {\n  const messages = messagesOf(config);\n  const api = createNotificationsApiClient(\n    config.apiBase,\n    config.transport ?? httpNotificationsTransport(messages.operationFailed),\n  );\n  const store = createInboxStore(api);\n  const webPush = config.webPush ?? {};\n  const subscribe = config.subscribe;\n  const subscribeOption = {\n    ...(subscribe ? { subscribe } : {}),\n    ...(config.useSignal ? { useSignal: config.useSignal } : {}),\n  };\n\n  // One store per factory, shared by the bell that READS it and the panel that\n  // WRITES it — the same arrangement as the inbox store above, and for the same\n  // reason: two independent copies would disagree about what the reader saw.\n  const liveSeen = createLiveSeenStore();\n\n  // Chosen ONCE, here, because `useActivities` is a hook and the choice must\n  // not be made per render: a bell that read an optional config inside itself\n  // would be calling a hook conditionally.\n  const live = config.liveActivities;\n  const Bell: ComponentType<BellButtonProps> = live\n    ? (props) => (\n        <LiveBellButton\n          {...props}\n          store={store}\n          messages={messages}\n          live={live}\n          seen={liveSeen}\n          {...subscribeOption}\n        />\n      )\n    : (props) => (\n        <BellButton {...props} store={store} messages={messages} {...subscribeOption} />\n      );\n  const Panel = lazyNotificationsPanel({\n    store,\n    messages,\n    ...(live ? { live, liveSeen } : {}),\n  });\n\n  function useBoundUnreadCount(options: { enabled?: boolean } = {}): number {\n    return useUnreadCount(store, { ...options, ...subscribeOption });\n  }\n\n  function BellWithPanel({\n    enabled = true,\n    onNavigate,\n  }: {\n    enabled?: boolean;\n    onNavigate?: (link: string) => void;\n  }): JSX.Element {\n    const [open, setOpen] = useState(false);\n    return (\n      <>\n        <Bell enabled={enabled} onClick={() => setOpen(true)} />\n        <Panel\n          open={open}\n          onClose={() => setOpen(false)}\n          {...(onNavigate ? { onNavigate } : {})}\n        />\n      </>\n    );\n  }\n\n  return {\n    page: lazyPreferencesPage({ api, messages, webPush }),\n    BellButton: Bell,\n    Panel,\n    BellWithPanel,\n    useUnreadCount: useBoundUnreadCount,\n    store,\n    api,\n    messages,\n  };\n}\n","/**\n * Bare bell trigger with the live unread badge — for hosts that do not already\n * have a styled icon-button slot. A host with its own trigger chrome uses\n * `useUnreadCount` + `Panel` directly.\n */\nimport { useSyncExternalStore, type JSX } from 'react';\n\nimport { Badge } from '@12-apps/ui/data-display/Badge';\nimport { Box } from '@12-apps/ui/mui/Box';\n\nimport type { NotificationMessages } from '../messages';\n\nimport { BellIcon } from './bell-icon';\nimport { useUnreadCount, type NotificationsSignalHook, type NotificationsSubscribe } from './hooks';\nimport type { LiveActivitiesConfig } from './live-config';\nimport { hasUnseenActivity, type LiveSeenStore } from './live-seen';\nimport type { InboxStore } from './inbox-state';\n\nconst triggerSx = {\n  display: 'inline-flex',\n  alignItems: 'center',\n  justifyContent: 'center',\n  p: 0.5,\n  border: 'none',\n  background: 'none',\n  cursor: 'pointer',\n  color: 'text.primary',\n  lineHeight: 0,\n  '& *': { cursor: 'pointer' },\n  '&:hover': { color: 'primary.main' },\n  '&:focus-visible': {\n    outline: '2px solid',\n    outlineColor: 'primary.main',\n    outlineOffset: '2px',\n    borderRadius: '50%',\n  },\n} as const;\n\nexport interface BellButtonProps {\n  onClick: () => void;\n  /** Signed-out hosts still mount the bell; `false` silences it. */\n  enabled?: boolean;\n}\n\n/**\n * The trigger itself, given a count and whether any of it is NEW.\n *\n * Presentational, and shared by both bells below, so the two can never drift on\n * what the badge looks like — only on where the number comes from.\n *\n * ## The two tones\n *\n * `primary` says *something happened*; `neutral` says *something is present*. A\n * live activity is the reason that distinction has to exist: it stays on the\n * panel for as long as the thing is happening, so a bell that painted every\n * live entry as new would be permanently red for a pedido the reader already\n * looked at, and a bell that ignored them would say nothing at all while one\n * was running. Grey keeps the count honest without spending attention twice.\n */\nfunction BellTrigger({\n  onClick,\n  count,\n  hasNew,\n  messages,\n}: {\n  onClick: () => void;\n  count: number;\n  hasNew: boolean;\n  messages: NotificationMessages;\n}): JSX.Element {\n  return (\n    <Box\n      component=\"button\"\n      type=\"button\"\n      onClick={onClick}\n      // `openBellWithUnread` rather than a new message, and not for want of\n      // precision: `NotificationMessages` is REQUIRED of every host, so adding\n      // a field is a breaking change to a package several apps already mount.\n      // The sentence a host wrote for \"you have N\" is the sentence this wants.\n      aria-label={count > 0 ? messages.openBellWithUnread(count) : messages.openBell}\n      data-testid=\"notifications-bell\"\n      sx={triggerSx}\n    >\n      <Badge\n        content={count > 0 ? count : undefined}\n        color={hasNew ? 'primary' : 'neutral'}\n        variant=\"count\"\n        max={99}\n        data-testid=\"notifications-badge\"\n        // The tone is carried by a colour, and a colour is not something a\n        // test can read — nor, on its own, a signal every reader can. This is\n        // what the tests assert on.\n        data-tone={hasNew ? 'new' : 'seen'}\n      >\n        <BellIcon size={28} />\n      </Badge>\n    </Box>\n  );\n}\n\nexport function BellButton({\n  onClick,\n  enabled = true,\n  store,\n  messages,\n  subscribe,\n  useSignal,\n}: BellButtonProps & {\n  store: InboxStore;\n  messages: NotificationMessages;\n  subscribe?: NotificationsSubscribe;\n  useSignal?: NotificationsSignalHook;\n}): JSX.Element {\n  const count = useUnreadCount(store, {\n    enabled,\n    ...(subscribe ? { subscribe } : {}),\n    ...(useSignal ? { useSignal } : {}),\n  });\n  // No live config on this host: unread IS the whole count, and an unread row\n  // is by definition something the reader has not seen.\n  return <BellTrigger onClick={onClick} count={count} hasNew={count > 0} messages={messages} />;\n}\n\n/**\n * The bell for a host that configured live activities.\n *\n * A SECOND component rather than a flag on the one above, because the host's\n * `useActivities` is a hook: reading an optional config inside one component\n * would mean calling it conditionally, which React reports as a crash in some\n * unrelated component rather than here. The factory knows statically which host\n * it is building for and picks one.\n *\n * ## What it costs the host, stated plainly\n *\n * The bell is mounted for as long as the app is, so unlike the panel's copy of\n * this hook there is no \"nobody is looking\" state to stand down in — `active`\n * is simply `enabled`. A host that answers by polling therefore polls for every\n * signed-in reader whether or not they ever open the centre. That is the price\n * of a badge that knows about live activities at all, and the reason to answer\n * this hook from a pushed cache rather than from an interval.\n */\nexport function LiveBellButton({\n  onClick,\n  enabled = true,\n  store,\n  messages,\n  subscribe,\n  useSignal,\n  live,\n  seen,\n}: BellButtonProps & {\n  store: InboxStore;\n  messages: NotificationMessages;\n  subscribe?: NotificationsSubscribe;\n  useSignal?: NotificationsSignalHook;\n  live: LiveActivitiesConfig;\n  seen: LiveSeenStore;\n}): JSX.Element {\n  const unread = useUnreadCount(store, {\n    enabled,\n    ...(subscribe ? { subscribe } : {}),\n    ...(useSignal ? { useSignal } : {}),\n  });\n  const activities = live.useActivities({ active: enabled });\n  const seenIso = useSyncExternalStore(seen.subscribe, seen.read, seen.read);\n  const liveCount = enabled ? activities.length : 0;\n  return (\n    <BellTrigger\n      onClick={onClick}\n      // A live entry counts. It is a notification — it is the one the reader\n      // most wants to know about — and the panel it opens lists it.\n      count={unread + liveCount}\n      hasNew={unread > 0 || (enabled && hasUnseenActivity(activities, seenIso))}\n      messages={messages}\n    />\n  );\n}\n","/**\n * What the reader has already been shown, so the bell can say NEW rather than\n * merely PRESENT.\n *\n * A live activity is unlike an inbox row in the one way that matters here: it\n * stays on the panel for as long as the thing is happening, so its presence\n * cannot mean \"you have not seen this\". A pedido that has been `Preparo` for\n * ten minutes is still live and still worth counting, but nothing has happened\n * — and a badge that shouts for a subject the reader has already looked at is a\n * badge people stop reading.\n *\n * So presence and novelty are answered separately: the COUNT comes from how\n * many are live, and the TONE comes from this. The panel writes it — being on\n * screen is what seen means — and the bell reads it.\n *\n * ## Per subject, not one watermark\n *\n * A single \"newest instant already seen\" is smaller and was the first cut, and\n * it is wrong in a way that shows up in normal use: a pedido placed ten minutes\n * ago but only now reaching the client arrives with an `updatedAt` BEHIND the\n * watermark, and would be silently marked as already seen. The reader has never\n * laid eyes on it. Keyed by subject, an id that has not been recorded is new\n * whatever its clock says.\n *\n * Bounded by pruning rather than by expiry: every write keeps only the subjects\n * that are live at that moment, so the record can never outgrow the number of\n * things happening at once. A subject that finishes and later comes back is\n * news again, which is correct — it is a different occurrence.\n */\nimport type { LiveActivity } from '../live';\n\nconst STORAGE_KEY = '12a.notifications.live-seen';\n\n/** id -> the `updatedAt` that was on screen. */\ntype SeenMap = Readonly<Record<string, string>>;\n\nconst EMPTY: SeenMap = {};\n\n/** ms since epoch, or `null` for an absent or unparseable stamp. */\nfunction instant(iso: string | undefined): number | null {\n  if (iso === undefined) return null;\n  const ms = Date.parse(iso);\n  return Number.isNaN(ms) ? null : ms;\n}\n\n/**\n * Read/write through `try`, every time.\n *\n * `localStorage` is not merely absent in SSR and in a worker — the ACCESSOR\n * itself throws in a browser set to block site data. A notification bell that\n * cannot render because storage is blocked is a worse failure than one that\n * forgets what was seen, and forgetting degrades in the safe direction: towards\n * saying something is happening.\n */\nfunction readStored(): SeenMap {\n  try {\n    const raw = globalThis.localStorage?.getItem(STORAGE_KEY);\n    if (!raw) return EMPTY;\n    const parsed: unknown = JSON.parse(raw);\n    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return EMPTY;\n    // Anything can be in storage — another version of this package, or a person\n    // with the devtools open. Keep only what has the shape this reads.\n    const clean: Record<string, string> = {};\n    for (const [id, value] of Object.entries(parsed)) {\n      if (typeof value === 'string') clean[id] = value;\n    }\n    return clean;\n  } catch {\n    return EMPTY;\n  }\n}\n\nfunction writeStored(value: SeenMap): void {\n  try {\n    globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(value));\n  } catch {\n    // Blocked or full. The badge stays new a while longer; nothing else breaks.\n  }\n}\n\nexport interface LiveSeenStore {\n  /** What has been shown, keyed by subject id. */\n  read: () => SeenMap;\n  /** Record that exactly these are on screen now, forgetting subjects that are not. */\n  mark: (activities: readonly LiveActivity[]) => void;\n  subscribe: (listener: () => void) => () => void;\n}\n\nexport function createLiveSeenStore(): LiveSeenStore {\n  // Mirrored in memory as well as in storage: `useSyncExternalStore` compares\n  // snapshots by IDENTITY and calls `read` on every render, so parsing storage\n  // there would hand it a fresh object each time and re-render for ever.\n  let current = readStored();\n  const listeners = new Set<() => void>();\n\n  return {\n    read: () => current,\n    mark: (activities) => {\n      const next: Record<string, string> = {};\n      for (const activity of activities) next[activity.id] = activity.updatedAt;\n      // Identity is the snapshot, so an unchanged map must not become a new\n      // object — see `read` above.\n      const ids = Object.keys(next);\n      const same =\n        ids.length === Object.keys(current).length &&\n        ids.every((id) => current[id] === next[id]);\n      if (same) return;\n      current = next;\n      writeStored(next);\n      for (const listener of listeners) listener();\n    },\n    subscribe: (listener) => {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n\n/**\n * Whether any of these has moved, or arrived, since the reader last looked.\n *\n * An id with nothing recorded is new — that is the case the per-subject record\n * exists for. An unparseable stamp is treated as new too: the alternative is\n * silently never alerting for a host whose clock format this does not read.\n */\nexport function hasUnseenActivity(\n  activities: readonly LiveActivity[],\n  seen: SeenMap,\n): boolean {\n  return activities.some((activity) => {\n    const shown = instant(seen[activity.id]);\n    if (shown === null) return true;\n    const now = instant(activity.updatedAt);\n    return now === null || now > shown;\n  });\n}\n","/**\n * The inbox slide-over, fetched the first time somebody opens it.\n *\n * The bell and the panel are a PAIR a host drops into its chrome, and that is\n * still true — but only the BELL is on screen when a page paints. The panel is\n * behind a tap, and a static import made every host pay for it up front: the\n * design-system `Drawer` and, through it, MUI's `SwipeableDrawer`, `Modal`,\n * `Slide` and the focus trap, plus the row, the empty state and the pager. On a\n * storefront that is a slide-over most visits never open, parsed before the\n * first screen can render.\n *\n * ## Why the gate is \"ever opened\" rather than `open`\n *\n * `lazy` fetches when a component first RENDERS, so a boundary that still\n * rendered the panel while closed would fetch immediately and buy nothing. This\n * renders `null` until the panel has been open once, which is what actually\n * defers the download to the tap.\n *\n * And once opened it STAYS mounted. Unmounting on close would throw away the\n * drawer's transition state, so the panel would vanish instead of sliding out,\n * and the entrance animation would re-run on every reopen — which someone\n * working through an inbox does repeatedly. The fetch happens once.\n *\n * The initial state reads `open` rather than starting at `false`, so a host that\n * mounts the panel already open renders it in the same commit instead of a frame\n * later.\n *\n * ## Why `null` for the fallback\n *\n * The only frame this can show anything is the one right after the tap, where a\n * spinner reads as a stall rather than as progress. The chunk is small and\n * same-origin.\n */\nimport { Suspense, lazy, useEffect, useState, type ComponentType, type JSX } from 'react';\n\nimport type { NotificationMessages } from '../messages';\n\nimport type { InboxStore } from './inbox-state';\nimport type { LiveActivitiesConfig } from './live-config';\nimport type { LiveSeenStore } from './live-seen';\nimport type { NotificationsPanelProps } from './panel';\n\n/** What the factory binds into the panel, and the host never passes. */\ninterface PanelParts {\n  store: InboxStore;\n  messages: NotificationMessages;\n  /** Absent unless the host turned live activities on — see `./live-config`. */\n  live?: LiveActivitiesConfig;\n  /** Travels with `live`: where the panel records what the reader has seen. */\n  liveSeen?: LiveSeenStore;\n}\n\nexport function lazyNotificationsPanel(\n  parts: PanelParts,\n): ComponentType<NotificationsPanelProps> {\n  const Bound = lazy(async () => {\n    const { NotificationsPanel } = await import('./panel');\n    return {\n      default: (props: NotificationsPanelProps): JSX.Element => (\n        <NotificationsPanel {...props} {...parts} />\n      ),\n    };\n  });\n\n  return function NotificationsPanelSlot(props: NotificationsPanelProps): JSX.Element | null {\n    const [everOpened, setEverOpened] = useState(props.open);\n\n    useEffect(() => {\n      if (props.open) setEverOpened(true);\n    }, [props.open]);\n\n    if (!everOpened) return null;\n\n    return (\n      <Suspense fallback={null}>\n        <Bound {...props} />\n      </Suspense>\n    );\n  };\n}\n","/**\n * The routed preferences screen, fetched when a host actually routes to it.\n *\n * `createWebNotifications` returns two different KINDS of thing, and its own\n * docstring says so: `page` is \"the standalone surface … the one thing a host\n * routes to\", while the bell and the panel \"are a PAIR a host drops into its own\n * chrome\". Chrome is on screen from the first paint; a routed surface is not.\n *\n * A static import made that distinction invisible to a bundler. Every host that\n * put the bell in its header also shipped the preferences matrix — its channel\n * toggles, the per-browser push enable step, and the design-system `Switch`\n * behind them — in the same chunk as the header. A storefront paid for a\n * settings screen a shopper never opens, before its first screen could render;\n * a host that renders its OWN preferences page paid for this one twice.\n *\n * So `page` now loads on demand. Nothing else moves: the bell, the panel and\n * `BellWithPanel` stay exactly as eager as the chrome they belong to, because\n * that is what they are.\n *\n * NO PREFETCH, deliberately, and this is the opposite call from a surface a\n * host opens from chrome it already has. A routed surface is reached by\n * NAVIGATION, and every host here already code-splits its routes — so the\n * fetch happens while the route is being entered, which is the moment a\n * prefetch would have been trying to anticipate. Warming it at factory time\n * would put the screen back on the boot path of every app, which is the whole\n * cost this removes.\n */\nimport { Suspense, lazy, type ComponentType, type JSX } from 'react';\n\nimport type { NotificationMessages } from '../messages';\n\nimport type { NotificationsApiClient } from './api';\nimport type { PreferencesScreenProps } from './preferences-screen';\nimport type { WebPushSetupConfig } from './web-push-setup';\n\n/** What the factory binds into the screen, and the host never passes. */\ninterface PreferencesPageParts {\n  api: NotificationsApiClient;\n  messages: NotificationMessages;\n  webPush: WebPushSetupConfig;\n}\n\n/**\n * The routed screen, bound and loaded on first render.\n *\n * `lazy` memoises its factory, so the binding below happens once however many\n * times a host mounts the page — the same guarantee the direct call gave.\n *\n * The fallback is `null` because a host routes to this: whatever it renders\n * around the route is already on screen, and a second spinner inside it would\n * be one more thing appearing and disappearing during a navigation the host is\n * already indicating.\n */\nexport function lazyPreferencesPage(\n  parts: PreferencesPageParts,\n): ComponentType<PreferencesScreenProps> {\n  const Bound = lazy(async () => {\n    const { PreferencesScreen } = await import('./preferences-screen');\n    return {\n      default: (props: PreferencesScreenProps): JSX.Element => (\n        <PreferencesScreen {...props} {...parts} />\n      ),\n    };\n  });\n\n  return function NotificationsPreferencesPage(props: PreferencesScreenProps): JSX.Element {\n    return (\n      <Suspense fallback={null}>\n        <Bound {...props} />\n      </Suspense>\n    );\n  };\n}\n"],"mappings":"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","names":["useState","jsx","Suspense","lazy","jsx","lazy","Suspense","jsx","useState"]}

package/dist/chunk-RTURLH5U.js

@@ -0,0 +1,33 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/live.ts
+function liveActivityLane(activity) {
+  const activeStepId = activity.activeStepId;
+  if (activeStepId === null || activity.steps.length === 0) return null;
+  const reached = activity.steps.findIndex((step) => step.id === activeStepId);
+  if (reached < 0) return null;
+  return {
+    steps: activity.steps,
+    activeStepId,
+    completed: new Set(activity.steps.slice(0, reached).map((step) => step.id))
+  };
+}
+__name(liveActivityLane, "liveActivityLane");
+var LIVE_SUBJECT_KEY = "liveSubject";
+var LIVE_PUSH_TAG_PREFIX = "live:";
+function livePushTag(data) {
+  const subject = data?.[LIVE_SUBJECT_KEY];
+  if (typeof subject !== "string" || subject === "") return null;
+  return `${LIVE_PUSH_TAG_PREFIX}${subject}`;
+}
+__name(livePushTag, "livePushTag");
+
+export {
+  liveActivityLane,
+  LIVE_SUBJECT_KEY,
+  LIVE_PUSH_TAG_PREFIX,
+  livePushTag
+};
+//# sourceMappingURL=chunk-RTURLH5U.js.map

package/dist/chunk-RTURLH5U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/live.ts"],"sourcesContent":["/**\n * LIVE ACTIVITIES — the notification centre's second kind of entry.\n *\n * An inbox notification is an EVENT: it happened, it is stamped, it is read or\n * unread, and it is still there tomorrow saying the same thing. A live activity\n * is ONGOING STATE: it is pinned above the list, it has no read/unread, nobody\n * deletes it, it updates itself, and it is GONE the moment the thing it tracks\n * finishes.\n *\n * The distinction is not cosmetic. A row that says \"your order is on its way\",\n * read an hour later, is a claim about the past presented as news — and the\n * more reliable the inbox is, the more of those a person accumulates. Somewhere\n * in that list is the one question they actually have, which is *where is it\n * now*. A live activity answers that question and then removes itself, which is\n * the property no amount of better event copy can buy.\n *\n * ## This file is domain-free, and that is the whole design\n *\n * Nothing here knows what is being tracked. A host publishes activities through\n * `LiveActivitiesConfig.useActivities` (see `./react/live-config`) and this\n * package owns the contract, the placement, the rendering and the OS-level\n * collapse. The package that raises an alert has never been this package's\n * business — see the `generators` seam — and the thing an alert is ABOUT is not\n * either.\n *\n * ## The lane\n *\n * `steps` + `activeStepId` describe a progress lane, because \"how far along is\n * this\" is the shape almost every ongoing subject has. Both are optional in\n * effect: an activity with no lane (`steps: []`, `activeStepId: null`) is a\n * perfectly good live entry — a heading, a sentence and a timestamp that keeps\n * moving.\n */\n\n/** One stop on a live activity's lane. */\nexport interface LiveActivityStep {\n  /** Stable across updates — the id is what `activeStepId` names. */\n  id: string;\n  /** What the reader sees under the dot. The HOST's word, in the reader's language. */\n  label: string;\n}\n\n/** One thing that is happening right now, as the notification centre shows it. */\nexport interface LiveActivity {\n  /**\n   * Stable for the whole life of the subject.\n   *\n   * The SAME id on every update, because it is the identity of the thing being\n   * tracked and not of the message: the panel keys on it so a stage change\n   * re-renders one card rather than swapping two, and it is what\n   * {@link livePushTag} collapses an OS notification onto.\n   *\n   * **Unique among the activities live at one moment**, for the same reason:\n   * it is the React key and the card's test id. Two activities sharing one\n   * gives a duplicate-key warning and a card that silently shows the wrong\n   * subject.\n   */\n  id: string;\n  /**\n   * Which host concern this belongs to, e.g. `order`, `delivery`, `import`.\n   *\n   * Free-form and never rendered — it exists so a host publishing from two\n   * sources can tell its own activities apart in a test or a log without\n   * parsing `id`.\n   */\n  kind: string;\n  /** The heading — what is happening. */\n  title: string;\n  /** The line under it: the detail that makes the heading actionable, or none. */\n  body: string | null;\n  /** Where tapping the card goes, as a same-origin path. `null` renders no link. */\n  link: string | null;\n  /** The lane, in the order it is walked. Empty when this subject has no lane. */\n  steps: readonly LiveActivityStep[];\n  /**\n   * The stop the subject is AT — one of `steps`, or `null` for a laneless entry.\n   *\n   * An id that names no step is neither, and it is handled rather than trusted:\n   * see {@link liveActivityLane}.\n   */\n  activeStepId: string | null;\n  /**\n   * ISO-8601 — when the subject last MOVED, not when it was last polled.\n   *\n   * A timestamp that advances on every read would render \"just now\" forever,\n   * which is the one thing a live entry must not say when nothing is happening.\n   */\n  updatedAt: string;\n}\n\n/** A live activity's lane, resolved for rendering. */\nexport interface LiveActivityLane {\n  steps: readonly LiveActivityStep[];\n  activeStepId: string;\n  /** Every stop BEFORE the active one — never the active one itself. */\n  completed: ReadonlySet<string>;\n}\n\n/**\n * The lane to draw, or `null` when this activity has none to draw.\n *\n * Three cases collapse to `null`, and the third is the one worth writing down:\n * no steps, no active step, and **an active step the lane does not contain**.\n * That last one is not a theoretical defect — it is what a host produces the\n * first time a subject reaches a stage the lane was filtered to exclude, and\n * the symptom is a row of dots with NONE of them lit, which reads as a process\n * that has stopped. A card with no lane still says what is happening and when\n * it last moved; a dead lane says the tracking is broken.\n *\n * `completed` deliberately stops short of the active stop: a completed step\n * draws a tick, and ticking the stop the subject is sitting in claims it has\n * already left.\n */\nexport function liveActivityLane(activity: LiveActivity): LiveActivityLane | null {\n  const activeStepId = activity.activeStepId;\n  if (activeStepId === null || activity.steps.length === 0) return null;\n  const reached = activity.steps.findIndex((step) => step.id === activeStepId);\n  if (reached < 0) return null;\n  return {\n    steps: activity.steps,\n    activeStepId,\n    completed: new Set(activity.steps.slice(0, reached).map((step) => step.id)),\n  };\n}\n\n/**\n * The reserved `data` key that ties a NOTIFICATION to a live subject.\n *\n * A notification and a live activity are different objects with different\n * lifetimes, and this is the only thing that joins them: a generator whose\n * event is about something also tracked live puts the activity's id here, and\n * every channel that can collapse gets to.\n *\n *     data: { [LIVE_SUBJECT_KEY]: `order:${orderId}` }\n *\n * A plain string on purpose. An object here would grow a second wire contract\n * inside a column this package stores verbatim.\n */\nexport const LIVE_SUBJECT_KEY = 'liveSubject';\n\n/**\n * Namespaces the tray tag, so a live tag does not collide with the ones a host\n * already uses.\n *\n * A convention rather than an enforcement — nothing stops a host emitting its\n * own `live:`-prefixed tags — but it means the two id spaces have to be made to\n * meet rather than meeting by accident.\n */\nexport const LIVE_PUSH_TAG_PREFIX = 'live:';\n\n/**\n * The OS notification tag for a push about a live subject, or `null` for an\n * ordinary event.\n *\n * ## What the tag buys, and why it is the PWA half of this feature\n *\n * A `tag` makes a new notification REPLACE the one already in the tray instead\n * of stacking under it, and — unless the sender asks otherwise — replace it\n * *silently*. So a subject that moves through four stages costs one tray entry\n * and one buzz, and the entry that remains is the CURRENT one. Without it a\n * phone accumulates one alert per stage, all of them still asserting a stage\n * the subject has since left; the freshest is at the top and the reader has to\n * work out that the three below it are history.\n *\n * That is as close as the web platform gets to an ongoing/live notification,\n * and it is the half that reaches a person who does not have the app open —\n * which is most of the time a live activity is live.\n *\n * The id is passed through unchanged: it is the host's, it is already unique\n * per subject, and a hash would make the tray impossible to reason about from a\n * log line.\n */\nexport function livePushTag(\n  data: Readonly<Record<string, unknown>> | null | undefined,\n): string | null {\n  const subject = data?.[LIVE_SUBJECT_KEY];\n  if (typeof subject !== 'string' || subject === '') return null;\n  return `${LIVE_PUSH_TAG_PREFIX}${subject}`;\n}\n"],"mappings":";;;;;AAiHO,SAAS,iBAAiB,UAAiD;AAChF,QAAM,eAAe,SAAS;AAC9B,MAAI,iBAAiB,QAAQ,SAAS,MAAM,WAAW,EAAG,QAAO;AACjE,QAAM,UAAU,SAAS,MAAM,UAAU,CAAC,SAAS,KAAK,OAAO,YAAY;AAC3E,MAAI,UAAU,EAAG,QAAO;AACxB,SAAO;AAAA,IACL,OAAO,SAAS;AAAA,IAChB;AAAA,IACA,WAAW,IAAI,IAAI,SAAS,MAAM,MAAM,GAAG,OAAO,EAAE,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC;AAAA,EAC5E;AACF;AAVgB;AAyBT,IAAM,mBAAmB;AAUzB,IAAM,uBAAuB;AAwB7B,SAAS,YACd,MACe;AACf,QAAM,UAAU,OAAO,gBAAgB;AACvC,MAAI,OAAO,YAAY,YAAY,YAAY,GAAI,QAAO;AAC1D,SAAO,GAAG,oBAAoB,GAAG,OAAO;AAC1C;AANgB;","names":[]}

package/dist/{chunk-GGAZOLNN.js → chunk-SWOWHIFE.js}

@@ -1,6 +1,6 @@
 import {
   NOTIFICATION_CHANNELS
-} from "./chunk-BGI4BQ66.js";
+} from "./chunk-6W7INOYQ.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -131,4 +131,4 @@ export {
   normalizePhoneE164,
   inboxWire
 };
-//# sourceMappingURL=chunk-GGAZOLNN.js.map
+//# sourceMappingURL=chunk-SWOWHIFE.js.map

package/dist/{chunk-KZG7QGFA.js → chunk-WVRODNXQ.js}

@@ -7,14 +7,17 @@ import {
   mergeChoices,
   mergeStoredRow,
   normalizePhoneE164
-} from "./chunk-GGAZOLNN.js";
+} from "./chunk-SWOWHIFE.js";
 import {
   messagesOf
 } from "./chunk-M2TVBVH2.js";
+import {
+  livePushTag
+} from "./chunk-RTURLH5U.js";
 import {
   NOTIFICATION_CHANNELS,
   taxonomyOf
-} from "./chunk-BGI4BQ66.js";
+} from "./chunk-6W7INOYQ.js";
 import {
   renderEmail
 } from "./chunk-EKUSNUBT.js";
@@ -419,7 +422,8 @@ function formatWebPush(content) {
     title: content.title,
     body: content.body,
     link: content.link ?? null,
-    data: content.data ?? {}
+    data: content.data ?? {},
+    tag: livePushTag(content.data)
   };
 }
 __name(formatWebPush, "formatWebPush");
@@ -1349,4 +1353,4 @@ export {
   createTransportRegistry,
   createApiNotifications
 };
-//# sourceMappingURL=chunk-KZG7QGFA.js.map
+//# sourceMappingURL=chunk-WVRODNXQ.js.map