@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.229 → 1.0.0-alpha.231

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.231 (2026-09-04)
+
+### Features
+
+* **notifications:** a delivery row names what it was about, not where it was sent ([65c01c6](https://github.com/ReventlessDev/reventless-core/commit/65c01c6b1b982880364c952266eab4294a824108))
+* **notifications:** a rule says how it goes out, and the relay sends only its half ([cbcb992](https://github.com/ReventlessDev/reventless-core/commit/cbcb99207597830aa955154a0833aac2205a8e2f))
+* **notifications:** a second producer can take over one stream of occurrences ([3050637](https://github.com/ReventlessDev/reventless-core/commit/3050637c8af69083c528030f2c59b04065ab8c2f))
+* **notifications:** the wording is a table of values, not a switch ([bfcc939](https://github.com/ReventlessDev/reventless-core/commit/bfcc93940b81060d201fd231447fb14dcf48d80e))
+
+
+# 1.0.0-alpha.230 (2026-09-02)
+
+### Features
+
+* **notifications:** a shipped order notifies the customer who placed it ([4280274](https://github.com/ReventlessDev/reventless-core/commit/428027471fc98cc60c1ab12dbcd5c70b9f33e545))
+
+
 # 1.0.0-alpha.229 (2026-09-02)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/online-shop-hybrid-ordering",
-  "version": "1.0.0-alpha.229",
+  "version": "1.0.0-alpha.231",
   "description": "Online Shop Hybrid example — Ordering plugin (Customer aggregate + Order/CatalogProduct DCB)",
   "license": "Apache-2.0",
   "jest": {
@@ -21,20 +21,20 @@
   },
   "dependencies": {
     "sury": "11.0.0-rc.2",
-    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.123",
-    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.123",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.201",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.155",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.124",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.124",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.127",
-    "@reventlessdev/trait-notification": "1.0.0-alpha.3",
-    "@reventlessdev/reventless-local": "3.0.0-alpha.243",
-    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.3"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.202",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.156",
+    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.4",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.128",
+    "@reventlessdev/trait-notification": "1.0.0-alpha.4",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.244"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.76"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.77"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Notification/AutomationSlice/NotificationIntake.res

@@ -1,19 +1,25 @@
 // NotificationIntake AutomationSlice.
 //
-// Half of the graft point: it turns one of this host's occurrences into a
-// request to notify somebody about it. The other half is
-// `AnnounceRecipientContact`, which relays who that somebody is reachable at.
+// Half of the graft point: it turns this host's occurrences into requests to
+// notify somebody about them. The other half is `AnnounceRecipientContact`,
+// which relays who that somebody is reachable at.
 //
 // Everything downstream is host-free — `NotificationPreferences` decides and
 // `SendNotification` delivers, neither knowing what an order is. This file is
-// where "a placed order is an OrderConfirmation, and here is what it says" is
-// written down, which is why it is a file a graft has to be given rather than
-// handed whole.
+// where "a placed order is an OrderConfirmation, a shipped one is a
+// ShippingUpdate, and here is what each says" is written down, which is why it
+// is a file a graft has to be given rather than handed whole.
 
 @@reventless.spec
 
+// The row a rule composes from. It carries the rule's id rather than a kind of
+// occurrence: the rule holds the category, the subject and the wording, so a
+// second notifiable event is a second entry in the table next door.
+//
+// It is also the payload the wording is rendered against, so every field here is
+// a path a template may name — `{{ orderId }}`.
 @schema
-type todoItem = {recipientId: string, orderId: string}
+type todoItem = {ruleId: string, recipientId: string, orderId: string}
 
 @schema
 type command =
@@ -21,8 +27,12 @@ type command =
     recipientId: string,
     category: NotificationPreferences.category,
     reference: string,
+    subjectType: string,
+    subjectRef: string,
     subject: string,
     body: string,
+    sourceId: string,
+    origin: NotificationPreferences.origin,
   })
 
 let maxRetries = 3

package/src/Notification/AutomationSlice/NotificationIntake.res.mjs

@@ -5,6 +5,7 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as NotificationPreferences$OrderingPlugin from "../StateChangeSlice/NotificationPreferences.res.mjs";
 
 let todoItemSchema = Sury.$schema(s => ({
+  ruleId: s.m(Sury.string),
   recipientId: s.m(Sury.string),
   orderId: s.m(Sury.string)
 }));
@@ -14,8 +15,12 @@ let commandSchema = Sury.$schema(s => ({
   recipientId: s.m(DcbTag$Reventless.string),
   category: s.m(NotificationPreferences$OrderingPlugin.categorySchema),
   reference: s.m(Sury.string),
+  subjectType: s.m(Sury.string),
+  subjectRef: s.m(Sury.string),
   subject: s.m(Sury.string),
-  body: s.m(Sury.string)
+  body: s.m(Sury.string),
+  sourceId: s.m(DcbTag$Reventless.string),
+  origin: s.m(NotificationPreferences$OrderingPlugin.originSchema)
 }));
 
 function commandAuthorization(param) {

package/src/Notification/AutomationSlice/NotificationIntake_Automation.res

@@ -1,27 +1,91 @@
 @@reventless.automation
 
-// A TODO id is also the `reference` the request carries, so the outcome event
-// echoes back exactly what resolves the row.
-let confirmationKey = orderId => `confirm:${orderId}`
+module Rule = TraitNotification.Notification_Rule
 
 // One source: this plugin's DCB log, which is where the occurrence is and where
-// every outcome lands. `OrderPlaced` names its own customer, which is what lets
-// an automation read it at all — see the sibling contact relay for the events
-// that do not.
+// every outcome lands. Both order events name their own customer, which is what
+// lets an automation read them at all — see the sibling contact relay for the
+// events that do not.
 module OrderingDcbSource = {
   let name = "OrderingDcbEventLog"
 
   @schema
   type event =
     | OrderPlaced({orderId: string, customerId: string})
-    // Every way a request can end. All three resolve the row, because all three
+    | OrderShipped({orderId: string, customerId: string})
+    // Every way a request can end. All four resolve the row, because all four
     // mean the decision was made — a suppressed notification is a finished piece
-    // of work, not a failed one.
+    // of work, not a failed one, and a deferred one is somebody else's work.
+    //
+    // Missing the fourth is not a missing nicety: an unresolved row retries its
+    // whole budget and lands in `onExhausted`, so a handover would look like a
+    // slow failure with nothing in the log to explain it.
     | NotificationRequested({reference: string})
     | NotificationSuppressed({reference: string})
     | NotificationUndeliverable({reference: string})
+    | NotificationDeferred({reference: string})
 }
 
+// The one place this host's occurrences are given a kind and a wording, and it
+// is a table of values rather than a switch. A trait cannot write this: the
+// categories are ones the trait declares, but which of the host's events earns
+// which — and what the sentence says — is the host's.
+//
+// A rule's id is also the namespace of the references it writes, so an order
+// that is placed and then ships is two notifications and two delivery rows.
+let defaultRules: array<Rule.t> = [
+  {
+    id: "confirm",
+    version: "1",
+    source: {log: OrderingDcbSource.name, eventType: "OrderPlaced"},
+    filter: Always,
+    category: "OrderConfirmation",
+    delivery: Immediate,
+    recipientPath: "recipientId",
+    subjectType: "Order",
+    subjectPath: "orderId",
+    content: [
+      {
+        locale: "en",
+        subject: "Your order {{ orderId }} is confirmed",
+        body: "Thanks — we have your order {{ orderId }} and will let you know when it ships.",
+      },
+    ],
+  },
+  {
+    id: "ship",
+    version: "1",
+    source: {log: OrderingDcbSource.name, eventType: "OrderShipped"},
+    filter: Always,
+    category: "ShippingUpdate",
+    delivery: Immediate,
+    recipientPath: "recipientId",
+    subjectType: "Order",
+    subjectPath: "orderId",
+    content: [
+      {
+        locale: "en",
+        subject: "Your order {{ orderId }} is on its way",
+        body: "Good news — order {{ orderId }} has shipped.",
+      },
+    ],
+  },
+]
+
+// The dispatch is the table's, so the switch below only takes an event apart.
+// Two rules on one event type are two notifications, with no arm to add.
+//
+// Only the immediate half of the table: a digest rule's occurrences are gathered
+// by the component that sends the digest, so no row is opened for one here.
+let todosFor = (~eventType, ~recipientId, ~orderId) =>
+  defaultRules
+  ->Rule.forEvent(~log=OrderingDcbSource.name, ~eventType)
+  ->Array.filter(Rule.isImmediate)
+  ->Array.map(rule => (
+    Rule.reference(rule, ~subject=orderId),
+    ({ruleId: rule.id, recipientId, orderId}: NotificationIntake.todoItem),
+  ))
+
 module FromOrderingDcb = Mapping.Make(
   OrderingDcbSource,
   NotificationIntake,
@@ -30,44 +94,63 @@ module FromOrderingDcb = Mapping.Make(
 
     let collect = (event, ~sourceId as _, _ctx) =>
       switch event {
-      | OrderPlaced({orderId, customerId}) => [
-          (
-            confirmationKey(orderId),
-            ({recipientId: customerId, orderId}: NotificationIntake.todoItem),
-          ),
-        ]
+      | OrderPlaced({orderId, customerId}) =>
+        todosFor(~eventType="OrderPlaced", ~recipientId=customerId, ~orderId)
+      | OrderShipped({orderId, customerId}) =>
+        todosFor(~eventType="OrderShipped", ~recipientId=customerId, ~orderId)
       | NotificationRequested(_)
       | NotificationSuppressed(_)
-      | NotificationUndeliverable(_) => []
+      | NotificationUndeliverable(_)
+      | NotificationDeferred(_) => []
       }
 
     let resolve = event =>
       switch event {
       | NotificationRequested({reference})
       | NotificationSuppressed({reference})
-      | NotificationUndeliverable({reference}) =>
+      | NotificationUndeliverable({reference})
+      | NotificationDeferred({reference}) =>
         Some(reference)
-      | OrderPlaced(_) => None
+      | OrderPlaced(_)
+      | OrderShipped(_) => None
       }
   },
 )
 
 let mappings: array<module(Mapping)> = [module(FromOrderingDcb)]
 
-// The one place this host's occurrences are given a kind and a wording. A trait
-// cannot write this: `OrderConfirmation` is a category the trait declares, but
-// which of the host's events earns it, and what the sentence says, is the host's.
 let process = (id, item: NotificationIntake.todoItem) =>
-  Some((
-    item.recipientId,
-    NotificationIntake.RequestNotification({
-      recipientId: item.recipientId,
-      category: OrderConfirmation,
-      reference: id,
-      subject: `Your order ${item.orderId} is confirmed`,
-      body: `Thanks — we have your order ${item.orderId} and will let you know when it ships.`,
-    }),
-  ))
+  // Two ways the table can have moved under a row that was already open: the rule
+  // is gone, or it has become a digest's and is no longer this relay's to send.
+  // Neither publishes anything, and either leaves the row Pending — a `None` from
+  // `process` spends no retry budget, so it is re-swept on every batch and never
+  // reaches `onExhausted`. Inert, but not self-clearing.
+  switch defaultRules->Rule.byId(item.ruleId)->Option.filter(Rule.isImmediate) {
+  | None => None
+  | Some(rule) =>
+    let payload = item->Reventless.Util_Sury.toJson(NotificationIntake.todoItemSchema)
+    switch (Rule.matches(rule.filter, ~payload), Rule.recipientOf(rule, ~payload)) {
+    | (false, _) | (_, None) => None
+    | (true, Some(recipientId)) =>
+      let (subject, body) = Rule.compose(rule, ~payload, ~schema=NotificationIntake.todoItemSchema)
+      Some((
+        recipientId,
+        NotificationIntake.RequestNotification({
+          recipientId,
+          category: NotificationPreferences_Behavior.categoryOf(rule.category),
+          reference: id,
+          subjectType: rule.subjectType,
+          subjectRef: Rule.subjectOf(rule, ~payload),
+          subject,
+          body,
+          sourceId: Rule.sourceId(rule),
+          // This relay IS the compiled table, so every request it makes is the
+          // default one — the arm that yields when somebody else claims the source.
+          origin: Default,
+        }),
+      ))
+    }
+  }
 
 // Nothing to say. A relay that gave up published no command, so the notification
 // competency never heard of the occurrence — and a delivery-failed fact for a

package/src/Notification/AutomationSlice/NotificationIntake_Automation.res.mjs

@@ -2,9 +2,13 @@
 
 import * as Sury from "sury";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
 import * as NotificationIntake$OrderingPlugin from "./NotificationIntake.res.mjs";
+import * as Notification_Rule$TraitNotification from "@reventlessdev/trait-notification/src/Notification_Rule.res.mjs";
+import * as NotificationPreferences_Behavior$OrderingPlugin from "../StateChangeSlice/NotificationPreferences_Behavior.res.mjs";
 
 let M = AutomationSlice$Reventless.Mappings.Make({
   name: NotificationIntake$OrderingPlugin.name,
@@ -16,10 +20,6 @@ let M = AutomationSlice$Reventless.Mappings.Make({
   targetName: NotificationIntake$OrderingPlugin.targetName
 });
 
-function confirmationKey(orderId) {
-  return `confirm:` + orderId;
-}
-
 let name = "OrderingDcbEventLog";
 
 let eventSchema = Sury.union([
@@ -28,6 +28,11 @@ let eventSchema = Sury.union([
     orderId: s.m(DcbTag$Reventless.string),
     customerId: s.m(DcbTag$Reventless.string)
   })),
+  Sury.$schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(DcbTag$Reventless.string)
+  })),
   Sury.$schema(s => ({
     TAG: "NotificationRequested",
     reference: s.m(Sury.string)
@@ -39,6 +44,10 @@ let eventSchema = Sury.union([
   Sury.$schema(s => ({
     TAG: "NotificationUndeliverable",
     reference: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "NotificationDeferred",
+    reference: s.m(Sury.string)
   }))
 ]);
 
@@ -48,25 +57,76 @@ let OrderingDcbSource = {
   eventSchema: eventSchema
 };
 
+let defaultRules = [
+  {
+    id: "confirm",
+    version: "1",
+    source: {
+      log: name,
+      eventType: "OrderPlaced"
+    },
+    filter: "Always",
+    category: "OrderConfirmation",
+    delivery: "Immediate",
+    recipientPath: "recipientId",
+    subjectType: "Order",
+    subjectPath: "orderId",
+    content: [{
+        locale: "en",
+        subject: "Your order {{ orderId }} is confirmed",
+        body: "Thanks — we have your order {{ orderId }} and will let you know when it ships."
+      }]
+  },
+  {
+    id: "ship",
+    version: "1",
+    source: {
+      log: name,
+      eventType: "OrderShipped"
+    },
+    filter: "Always",
+    category: "ShippingUpdate",
+    delivery: "Immediate",
+    recipientPath: "recipientId",
+    subjectType: "Order",
+    subjectPath: "orderId",
+    content: [{
+        locale: "en",
+        subject: "Your order {{ orderId }} is on its way",
+        body: "Good news — order {{ orderId }} has shipped."
+      }]
+  }
+];
+
+function todosFor(eventType, recipientId, orderId) {
+  return Notification_Rule$TraitNotification.forEvent(defaultRules, name, eventType).filter(Notification_Rule$TraitNotification.isImmediate).map(rule => [
+    Notification_Rule$TraitNotification.reference(rule, orderId),
+    {
+      ruleId: rule.id,
+      recipientId: recipientId,
+      orderId: orderId
+    }
+  ]);
+}
+
 function collect(event, param, _ctx) {
-  if (event.TAG !== "OrderPlaced") {
-    return [];
+  switch (event.TAG) {
+    case "OrderPlaced" :
+      return todosFor("OrderPlaced", event.customerId, event.orderId);
+    case "OrderShipped" :
+      return todosFor("OrderShipped", event.customerId, event.orderId);
+    default:
+      return [];
   }
-  let orderId = event.orderId;
-  return [[
-      confirmationKey(orderId),
-      {
-        recipientId: event.customerId,
-        orderId: orderId
-      }
-    ]];
 }
 
 function resolve(event) {
-  if (event.TAG === "OrderPlaced") {
-    return;
-  } else {
-    return event.reference;
+  switch (event.TAG) {
+    case "OrderPlaced" :
+    case "OrderShipped" :
+      return;
+    default:
+      return event.reference;
   }
 }
 
@@ -90,15 +150,33 @@ let FromOrderingDcb = AutomationSlice$Reventless.Mapping.Make({
 let mappings = [FromOrderingDcb];
 
 function process(id, item) {
+  let rule = Stdlib_Option.filter(Notification_Rule$TraitNotification.byId(defaultRules, item.ruleId), Notification_Rule$TraitNotification.isImmediate);
+  if (rule === undefined) {
+    return;
+  }
+  let payload = Util_Sury$Reventless.toJson(item, NotificationIntake$OrderingPlugin.todoItemSchema);
+  let match = Notification_Rule$TraitNotification.matches(rule.filter, payload);
+  let match$1 = Notification_Rule$TraitNotification.recipientOf(rule, payload);
+  if (!match) {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  let match$2 = Notification_Rule$TraitNotification.compose(rule, payload, NotificationIntake$OrderingPlugin.todoItemSchema, undefined);
   return [
-    item.recipientId,
+    match$1,
     {
       TAG: "RequestNotification",
-      recipientId: item.recipientId,
-      category: "OrderConfirmation",
+      recipientId: match$1,
+      category: NotificationPreferences_Behavior$OrderingPlugin.categoryOf(rule.category),
       reference: id,
-      subject: `Your order ` + item.orderId + ` is confirmed`,
-      body: `Thanks — we have your order ` + item.orderId + ` and will let you know when it ships.`
+      subjectType: rule.subjectType,
+      subjectRef: Notification_Rule$TraitNotification.subjectOf(rule, payload),
+      subject: match$2[0],
+      body: match$2[1],
+      sourceId: Notification_Rule$TraitNotification.sourceId(rule),
+      origin: "Default"
     }
   ];
 }
@@ -109,13 +187,17 @@ function onExhausted(_id, _item) {
 
 let Spec;
 
+let Rule;
+
 let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Notification/AutomationSlice/NotificationIntake_Automation.res.mjs";
 
 export {
   Spec,
   M,
-  confirmationKey,
+  Rule,
   OrderingDcbSource,
+  defaultRules,
+  todosFor,
   FromOrderingDcb,
   mappings,
   process,

package/src/Notification/StateChangeSlice/NotificationPreferences.res

@@ -37,14 +37,24 @@ type channel =
   | Sms
   | Push
 
-// Its own past facts, and nothing else. What lets one component hold the
-// directory and make the dispatch decision without either half reaching for the
-// other's state.
+// Why a request exists: the compiled table in `NotificationIntake`, or a rule
+// somebody configured on top of it. Recorded on the request that goes out, so
+// "which wording was in force when this was sent" has an answer.
+@schema
+type origin =
+  | Default
+  | Configured({ruleId: string, ruleVersion: string})
+
+// Its own past facts, plus the claim set from `NotificationSourceClaims`. The
+// claims are per source and this slice is per recipient, so they come from
+// another partition — see `RequestNotification` for what makes that read happen.
 @schema
 type consumedEvent =
   | RecipientAnnounced({recipientId: string, email: string})
   | NotificationSubscribed({recipientId: string, category: category, channel: channel})
   | NotificationUnsubscribed({recipientId: string, category: category, channel: channel})
+  | NotificationSourceClaimed({sourceId: string, by: string})
+  | NotificationSourceReleased({sourceId: string})
 
 @schema
 type command =
@@ -67,8 +77,29 @@ type command =
       recipientId: string,
       category: category,
       reference: string,
+      // What the notification is about. `reference` is a correlation key whose
+      // format is the requester's own business; these two name the thing plainly,
+      // so a row can be read back without decoding somebody else's string.
+      // `subjectType` is the referenced component's name as the deployment
+      // registers it, `subjectRef` that row's own id. Empty is legal — a
+      // notification about nothing in particular is a real case, and a fabricated
+      // subject is worse than an absent one.
+      subjectType: string,
+      subjectRef: string,
       subject: string,
       body: string,
+      // Which stream this came from, `"<log>:<eventType>"`, and who is asking.
+      // Together they are the handover: a `Default` request for a source another
+      // producer has claimed yields, a `Configured` one always goes through.
+      //
+      // `sourceId` is a DCB tag, and it has to be — the decision must read the
+      // claim facts, which live in another partition (they are per source, this
+      // slice is per recipient). Because the slice consumes `sourceId` without
+      // producing it, the framework infers the cross-partition read from the
+      // slice graph, and the claim write fences in-flight requests for that
+      // source. Renaming it off the `*Id` convention would silently drop both.
+      sourceId: string,
+      origin: origin,
     })
   // Reported by the send slice once the provider has settled. Trait-owned state,
   // so this is not a host side effect — the host is never written to at all.
@@ -94,16 +125,54 @@ type event =
       category: category,
       reference: string,
       channel: channel,
+      // Kept on the event and deliberately not on the delivery view: the send
+      // slice cannot deliver without it, and this is the record of the address a
+      // message actually went to, as opposed to the address of record the
+      // directory holds. Answering "where was this confirmation sent" therefore
+      // means reading the log, which is the right reach for personal data —
+      // available to an investigation, not to every reader of a view.
       address: string,
+      subjectType: string,
+      subjectRef: string,
       subject: string,
       body: string,
+      // What was in force when this went out. A message should record why it was
+      // sent, and until this field existed nothing did.
+      origin: origin,
     })
   // Both of the ways not to send, kept apart because they mean opposite things.
   // A recipient who declined is the system working; a recipient with no address
   // is the system missing something, and one fact for both would hide every
   // delivery gap behind a legitimate preference.
-  | NotificationSuppressed({recipientId: string, category: category, reference: string})
-  | NotificationUndeliverable({recipientId: string, category: category, reference: string})
+  | NotificationSuppressed({
+      recipientId: string,
+      category: category,
+      reference: string,
+      subjectType: string,
+      subjectRef: string,
+      origin: origin,
+    })
+  | NotificationUndeliverable({
+      recipientId: string,
+      category: category,
+      reference: string,
+      subjectType: string,
+      subjectRef: string,
+      origin: origin,
+    })
+  // The third way of not sending: another producer owns this source. Its own
+  // fact for the same reason the two above are two — and load-bearing besides,
+  // because the relay resolves its TODO row on an outcome, and without this one a
+  // deferred request retries its whole budget and is abandoned with nothing in
+  // the log to say why.
+  //
+  // `sourceKey` and not `sourceId`, deliberately, and this is the one place the
+  // two names differ: the slice's partition is derived from the `*Id` fields its
+  // own events declare, so a produced `sourceId` here would give it two candidate
+  // partitions, resolve to neither, and — worse — stop `sourceId` counting as a
+  // consumed-but-not-produced key, which is what makes the claim read cross
+  // partitions at all. The value is the same; only the fact is descriptive.
+  | NotificationDeferred({recipientId: string, reference: string, sourceKey: string})
   | NotificationDelivered({recipientId: string, reference: string, providerRef: string})
   | NotificationFailed({recipientId: string, reference: string, reason: string})