@reventlessdev/trait-notification 1.0.0-alpha.1 → 1.0.0-alpha.10

package/src/Notification_Scaffold.res.mjs

@@ -24,6 +24,7 @@ function namesOf(c) {
   let n = c.noun;
   return {
     slice: n + "Preferences",
+    claims: "NotificationSourceClaims",
     send: "Send" + n + "Notification",
     relay: "Announce" + n + "Contact",
     intake: n + "NotificationIntake",
@@ -41,6 +42,12 @@ function namesOf(c) {
     requested: "NotificationRequested",
     suppressed: "NotificationSuppressed",
     undeliverable: "NotificationUndeliverable",
+    deferred: "NotificationDeferred",
+    claimed: "NotificationSourceClaimed",
+    released: "NotificationSourceReleased",
+    claimCmd: "ClaimNotificationSource",
+    releaseCmd: "ReleaseNotificationSource",
+    claimError: "ClaimRefused",
     delivered: "NotificationDelivered",
     failed: "NotificationFailed",
     unknownError: n + "Unknown",
@@ -60,6 +67,15 @@ function addressB(c) {
   return Stdlib_Option.getOr(c.addressB, "new@example.com");
 }
 
+function subjectTypeOf(c) {
+  let stem = c.occurrenceId.endsWith("Id") ? c.occurrenceId.slice(0, c.occurrenceId.length - 2 | 0) : c.occurrenceId;
+  if (stem === "") {
+    return "Subject";
+  } else {
+    return stem.slice(0, 1).toUpperCase() + stem.slice(1, stem.length);
+  }
+}
+
 function authorizeOn(c) {
   let a = c.authorize;
   if (a !== undefined) {
@@ -108,13 +124,24 @@ function sliceSpec(c) {
       `  | Sms`,
       `  | Push`,
       ``,
-      `// Its own past facts, and nothing else — which is what lets one component hold`,
-      `// the directory and make the dispatch decision.`,
+      `// Why a request exists: the compiled table in the relay, 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 ` + n.claims + `. Claims are per`,
+      `// source and this slice is per recipient, so they come from another partition —`,
+      `// see \`` + n.requestCmd + `\` for what makes that read happen.`,
       `@schema`,
       `type consumedEvent =`,
       `  | ` + n.announced + `({` + id + `: string, ` + c.contactField + `: string})`,
       `  | ` + n.subscribed + `({` + id + `: string, category: category, channel: channel})`,
       `  | ` + n.unsubscribed + `({` + id + `: string, category: category, channel: channel})`,
+      `  | ` + n.claimed + `({sourceId: string, by: string})`,
+      `  | ` + n.released + `({sourceId: string})`,
       ``,
       `@schema`,
       `type command =`,
@@ -127,13 +154,32 @@ function sliceSpec(c) {
       auth + n.unsubscribeCmd + `({@owner ` + id + `: string, category: category, channel: channel})`,
       `  // Also relayed. \`reference\` is the requester's own key, echoed back on`,
       `  // whichever outcome follows, so the relay can tell its work is finished.`,
+      `  // \`subjectType\`/\`subjectRef\` say what the notification is ABOUT, which the`,
+      `  // reference deliberately does not: its format is the requester's own`,
+      `  // business, so a row keyed by it alone cannot be read back. Empty is legal.`,
+      `  // Named \`*Ref\` and not \`*Id\` on purpose: two inferences read id fields by`,
+      `  // NAME — the DCB partition and the queryable's key field — and a second`,
+      `  // \`*Id\` on the row makes both ambiguous, which costs the view its filter`,
+      `  // and its orderBy with no error anywhere.`,
       `  | @noApi`,
       `  ` + n.requestCmd + `({`,
       `      ` + id + `: string,`,
       `      category: category,`,
       `      reference: string,`,
+      `      subjectType: string,`,
+      `      subjectRef: string,`,
       `      subject: string,`,
       `      body: string,`,
+      `      // Which stream this came from, \`"<log>:<eventType>"\`, and who is asking.`,
+      `      // A \`Default\` request for a source another producer has claimed yields;`,
+      `      // a \`Configured\` one always goes through.`,
+      `      //`,
+      `      // \`sourceId\` is a DCB tag and has to be: the decision reads claim facts`,
+      `      // that live in another partition. Because this slice consumes \`sourceId\``,
+      `      // without producing it, the framework infers the cross-partition read from`,
+      `      // the slice graph. Renaming it off \`*Id\` would silently drop that.`,
+      `      sourceId: string,`,
+      `      origin: origin,`,
       `    })`,
       `  // Reported by the send slice once the provider has settled.`,
       `  | @noApi ` + n.recordCmd + `({` + id + `: string, reference: string, providerRef: string})`,
@@ -151,21 +197,51 @@ function sliceSpec(c) {
       `  | ` + n.subscribed + `({` + id + `: string, category: category, channel: channel})`,
       `  | ` + n.unsubscribed + `({` + id + `: string, category: category, channel: channel})`,
       `  // The addressed message. \`address\` is the snapshot delivery uses, which is`,
-      `  // why it is on the fact rather than looked up again later.`,
+      `  // why it is on the fact rather than looked up again later — and why it stays`,
+      `  // here and off the delivery view: the record of where a message actually went`,
+      `  // belongs in the log an investigation reads, not in a general read model.`,
       `  | ` + n.requested + `({`,
       `      ` + id + `: string,`,
       `      category: category,`,
       `      reference: string,`,
       `      channel: channel,`,
       `      address: string,`,
+      `      subjectType: string,`,
+      `      subjectRef: string,`,
       `      subject: string,`,
       `      body: string,`,
+      `      // What was in force when this went out — a message should record why.`,
+      `      origin: origin,`,
       `    })`,
       `  // Two different ways to send nothing. A ` + c.noun.toLowerCase() + ` who declined is the`,
       `  // system working; one with no address for a channel they enabled is the system`,
       `  // falling short, and one fact for both hides every gap behind a preference.`,
-      `  | ` + n.suppressed + `({` + id + `: string, category: category, reference: string})`,
-      `  | ` + n.undeliverable + `({` + id + `: string, category: category, reference: string})`,
+      `  | ` + n.suppressed + `({`,
+      `      ` + id + `: string,`,
+      `      category: category,`,
+      `      reference: string,`,
+      `      subjectType: string,`,
+      `      subjectRef: string,`,
+      `      origin: origin,`,
+      `    })`,
+      `  | ` + n.undeliverable + `({`,
+      `      ` + id + `: 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 silently.`,
+      `  //`,
+      `  // \`sourceKey\` and not \`sourceId\`, and this is the one place the two names`,
+      `  // differ: a produced \`sourceId\` here would give this slice two candidate`,
+      `  // partitions and stop \`sourceId\` counting as consumed-but-not-produced, which`,
+      `  // is what makes the claim read cross partitions at all.`,
+      `  | ` + n.deferred + `({` + id + `: string, reference: string, sourceKey: string})`,
       `  | ` + n.delivered + `({` + id + `: string, reference: string, providerRef: string})`,
       `  | ` + n.failed + `({` + id + `: string, reference: string, reason: string})`,
       ``
@@ -252,44 +328,86 @@ function sliceBehavior(c) {
       `    state->Rules.evolve(`,
       `      Unsubscribed({category: categoryKey(category), channel: channelKey(channel)}),`,
       `    )`,
+      `  // Read across partitions from ` + n.claims + ` — see the source field on`,
+      `  // \`` + n.requestCmd + `\`.`,
+      `  | ` + n.claimed + `({sourceId, by}) => state->Rules.evolve(Claimed({source: sourceId, by}))`,
+      `  | ` + n.released + `({sourceId}) => state->Rules.evolve(Released({source: sourceId}))`,
       `  }`,
       ``,
       `// The trait decides; this names what it decided in the host's vocabulary.`,
+      `//`,
+      `// \`option\` because two of the trait's facts belong to ` + n.claims + `: this`,
+      `// component reads them and never writes them, so it has no event to name them`,
+      `// with.`,
       `let named = (` + id + `, fact: Rules.fact) =>`,
       `  switch fact {`,
-      `  | Announced({address}) => ` + n.announced + `({` + id + `: ` + id + `, ` + c.contactField + `: address})`,
+      `  | Claimed(_)`,
+      `  | Released(_) => None`,
+      `  | Deferred({reference, source}) =>`,
+      `    Some(` + n.deferred + `({` + id + `: ` + id + `, reference, sourceKey: source}))`,
+      `  | Announced({address}) =>`,
+      `    Some(` + n.announced + `({` + id + `: ` + id + `, ` + c.contactField + `: address}))`,
       `  | Subscribed({category, channel}) =>`,
-      `    ` + n.subscribed + `({`,
-      `      ` + id + `: ` + id + `,`,
-      `      category: categoryOf(category),`,
-      `      channel: channelOf(channel),`,
-      `    })`,
+      `    Some(`,
+      `      ` + n.subscribed + `({`,
+      `        ` + id + `: ` + id + `,`,
+      `        category: categoryOf(category),`,
+      `        channel: channelOf(channel),`,
+      `      }),`,
+      `    )`,
       `  | Unsubscribed({category, channel}) =>`,
-      `    ` + n.unsubscribed + `({`,
-      `      ` + id + `: ` + id + `,`,
-      `      category: categoryOf(category),`,
-      `      channel: channelOf(channel),`,
-      `    })`,
+      `    Some(`,
+      `      ` + n.unsubscribed + `({`,
+      `        ` + id + `: ` + id + `,`,
+      `        category: categoryOf(category),`,
+      `        channel: channelOf(channel),`,
+      `      }),`,
+      `    )`,
       `  | Requested({category, reference, channel, address}) =>`,
-      `    ` + n.requested + `({`,
-      `      ` + id + `: ` + id + `,`,
-      `      category: categoryOf(category),`,
-      `      reference,`,
-      `      channel: channelOf(channel),`,
-      `      address,`,
-      `      // Carried on the command and put back below: the trait holds no sentence.`,
-      `      subject: "",`,
-      `      body: "",`,
-      `    })`,
+      `    Some(`,
+      `      ` + n.requested + `({`,
+      `        ` + id + `: ` + id + `,`,
+      `        category: categoryOf(category),`,
+      `        reference,`,
+      `        channel: channelOf(channel),`,
+      `        address,`,
+      `        // Carried on the command and put back below: the trait holds no`,
+      `        // sentence, refuses to know what an occurrence is, and has no opinion`,
+      `        // about which rule asked.`,
+      `        subjectType: "",`,
+      `        subjectRef: "",`,
+      `        subject: "",`,
+      `        body: "",`,
+      `        origin: Default,`,
+      `      }),`,
+      `    )`,
       `  | Suppressed({category, reference}) =>`,
-      `    ` + n.suppressed + `({` + id + `: ` + id + `, category: categoryOf(category), reference})`,
+      `    Some(`,
+      `      ` + n.suppressed + `({`,
+      `        ` + id + `: ` + id + `,`,
+      `        category: categoryOf(category),`,
+      `        reference,`,
+      `        subjectType: "",`,
+      `        subjectRef: "",`,
+      `        origin: Default,`,
+      `      }),`,
+      `    )`,
       `  | Undeliverable({category, reference}) =>`,
-      `    ` + n.undeliverable + `({` + id + `: ` + id + `, category: categoryOf(category), reference})`,
+      `    Some(`,
+      `      ` + n.undeliverable + `({`,
+      `        ` + id + `: ` + id + `,`,
+      `        category: categoryOf(category),`,
+      `        reference,`,
+      `        subjectType: "",`,
+      `        subjectRef: "",`,
+      `        origin: Default,`,
+      `      }),`,
+      `    )`,
       `  }`,
       ``,
       `let through = (state, ` + id + `, op) =>`,
       `  switch state->Rules.decide(op, ~posture) {`,
-      `  | Ok(facts) => Ok(facts->Array.map(named(` + id + `, _)))`,
+      `  | Ok(facts) => Ok(facts->Array.filterMap(named(` + id + `, _)))`,
       `  | Error(#RecipientUnknown) => Error(` + n.unknownError + `)`,
       `  }`,
       ``,
@@ -310,14 +428,44 @@ function sliceBehavior(c) {
       `      Unsubscribe({category: categoryKey(category), channel: channelKey(channel)}),`,
       `    )`,
       ``,
-      `  // The one arm that is not a rename: the words belong to the requester, and the`,
-      `  // trait's fact does not carry them, so they are put back on the way out.`,
-      `  | ` + n.requestCmd + `({` + id + `, category, reference, subject, body}) =>`,
-      `    through(state, ` + id + `, Request({category: categoryKey(category), reference}))`,
-      `    ->Result.map(events =>`,
+      `  // The one arm that is not a rename: the words and the subject belong to the`,
+      `  // requester and the trait's facts carry neither, so both are put back on the`,
+      `  // way out. All three outcomes get the subject — what a suppressed or`,
+      `  // undeliverable notification was about is what makes those rows worth reading.`,
+      `  | ` + n.requestCmd + `({`,
+      `      ` + id + `,`,
+      `      category,`,
+      `      reference,`,
+      `      subjectType,`,
+      `      subjectRef,`,
+      `      subject,`,
+      `      body,`,
+      `      sourceId,`,
+      `      origin,`,
+      `    }) =>`,
+      `    through(`,
+      `      state,`,
+      `      ` + id + `,`,
+      `      Request({`,
+      `        category: categoryKey(category),`,
+      `        reference,`,
+      `        source: sourceId,`,
+      `        // The trait needs only which of the two yields to a claim; which rule`,
+      `        // it was is this host's fact, put back below.`,
+      `        origin: switch origin {`,
+      `        | Default => Default`,
+      `        | Configured(_) => Configured`,
+      `        },`,
+      `      }),`,
+      `    )->Result.map(events =>`,
       `      events->Array.map(event =>`,
       `        switch event {`,
-      `        | ` + n.requested + `(fields) => ` + n.requested + `({...fields, subject, body})`,
+      `        | ` + n.requested + `(fields) =>`,
+      `          ` + n.requested + `({...fields, subjectType, subjectRef, subject, body, origin})`,
+      `        | ` + n.suppressed + `(fields) =>`,
+      `          ` + n.suppressed + `({...fields, subjectType, subjectRef, origin})`,
+      `        | ` + n.undeliverable + `(fields) =>`,
+      `          ` + n.undeliverable + `({...fields, subjectType, subjectRef, origin})`,
       `        | other => other`,
       `        }`,
       `      )`,
@@ -334,6 +482,93 @@ function sliceBehavior(c) {
   ].flatMap(x => x).join("\n");
 }
 
+function claimsSpec(c) {
+  let n = namesOf(c);
+  return [
+    `// ` + n.claims + ` StateChangeSlice: which streams of occurrences a second`,
+    `// producer has taken over. One row per source, keyed by the source itself —`,
+    `// \`"<log>:<eventType>"\`, opaque to everyone but the producers that agree on it.`,
+    `//`,
+    `// Emitted by the trait; ordinary source from here on.`,
+    ``,
+    `@@reventless.spec`,
+    ``,
+    `@schema`,
+    `type consumedEvent =`,
+    `  | ` + n.claimed + `({sourceId: string, by: string})`,
+    `  | ` + n.released + `({sourceId: string})`,
+    ``,
+    `@schema`,
+    `type command =`,
+    `  // Relayed, never a client door — a caller who could claim a source would be`,
+    `  // silencing everybody else's notifications from it.`,
+    `  | @noApi ` + n.claimCmd + `({sourceId: string, by: string})`,
+    `  | @noApi ` + n.releaseCmd + `({sourceId: string})`,
+    ``,
+    `@schema`,
+    `type error =`,
+    `  // Both commands are idempotent, so there is no refusal to make. Declared`,
+    `  // because the shape requires one.`,
+    `  | ` + n.claimError,
+    ``,
+    `@schema`,
+    `type event =`,
+    `  | ` + n.claimed + `({sourceId: string, by: string})`,
+    `  | ` + n.released + `({sourceId: string})`,
+    ``,
+    `let traits = [TraitNotification.Notification.declaration]`,
+    ``
+  ].join("\n");
+}
+
+function claimsBehavior(c) {
+  let n = namesOf(c);
+  return [
+    `@@reventless.behavior`,
+    ``,
+    `// The claim set is the trait's, folded through the same value the preferences`,
+    `// slice folds. Only the claim half is ever populated here.`,
+    `module Rules = TraitNotification.Notification_Rules`,
+    ``,
+    `type state = Rules.t`,
+    ``,
+    `let initialState = Rules.empty`,
+    ``,
+    `let evolve = (state, event: consumedEvent) =>`,
+    `  switch event {`,
+    `  | ` + n.claimed + `({sourceId, by}) => state->Rules.evolve(Claimed({source: sourceId, by}))`,
+    `  | ` + n.released + `({sourceId}) => state->Rules.evolve(Released({source: sourceId}))`,
+    `  }`,
+    ``,
+    `// No posture is consulted on either arm, so this table is never read. Passing`,
+    `// the trait's own decision function anyway keeps the idempotence rule in one`,
+    `// place rather than restating it here.`,
+    `let posture = (_category: string, _channel: Rules.channel) => false`,
+    ``,
+    `let named = (fact: Rules.fact) =>`,
+    `  switch fact {`,
+    `  | Claimed({source, by}) => Some(` + n.claimed + `({sourceId: source, by}))`,
+    `  | Released({source}) => Some(` + n.released + `({sourceId: source}))`,
+    `  // The other facts belong to the preferences slice; the two commands below`,
+    `  // cannot reach them.`,
+    `  | _ => None`,
+    `  }`,
+    ``,
+    `let through = (state, op) =>`,
+    `  switch state->Rules.decide(op, ~posture) {`,
+    `  | Ok(facts) => Ok(facts->Array.filterMap(named))`,
+    `  | Error(#RecipientUnknown) => Error(` + n.claimError + `)`,
+    `  }`,
+    ``,
+    `let decide = (state, command) =>`,
+    `  switch command {`,
+    `  | ` + n.claimCmd + `({sourceId, by}) => through(state, Claim({source: sourceId, by}))`,
+    `  | ` + n.releaseCmd + `({sourceId}) => through(state, Release({source: sourceId}))`,
+    `  }`,
+    ``
+  ].join("\n");
+}
+
 function sendSpec(c) {
   let n = namesOf(c);
   let id = n.recipientId;
@@ -425,13 +660,20 @@ function sendTranslation(c) {
     `    item.address`,
     `    ->Reventless.Phone.fromString`,
     `    ->Result.map(phone => Reventless.Messaging.ToSms(phone))`,
-    `  | Push => Ok(Reventless.Messaging.ToPush({deviceToken: item.address}))`,
+    `  // The directory stores a channel beside one flat address, and no push address is`,
+    `  // one string: two services issue a token, Web Push issues an endpoint with its`,
+    `  // encryption keys, and which service issued this one is not recorded either. So`,
+    `  // the pair cannot be re-fused, and refusing says so once rather than guessing a`,
+    `  // service and failing at whichever provider. A push transport arrives with the`,
+    `  // stored shape it needs, in the commit that justifies the columns.`,
+    `  | Push =>`,
+    `    Error("a push address names its issuing service, and the directory stores one flat address")`,
     `  }`,
     ``,
     `let translate = async (_id, item: outboundItem, ~capabilities: Reventless.Capabilities.t) =>`,
     `  switch recipientFor(item) {`,
-    `  // An address the directory holds that its own channel's grammar refuses. Not`,
-    `  // retryable and not the provider's fault — the row that holds it needs fixing.`,
+    `  // An address the directory holds that its own channel cannot use. Not retryable`,
+    `  // and not the provider's fault — the row that holds it needs fixing.`,
     `  | Error(why) =>`,
     `    Ok(`,
     `      Some((`,
@@ -514,20 +756,27 @@ function conformanceBinding(c) {
     `  module Spec = ` + n.slice,
     `  module Behavior = ` + n.slice + `_Behavior`,
     ``,
-    `  // A DCB slice's entity comes into existence with its first fact, so there is`,
-    `  // no creation event to seed: an unannounced ` + c.noun.toLowerCase() + ` is one with no history.`,
-    `  let created: array<Spec.consumedEvent> = []`,
-    ``,
     `  let ` + id + ` = "` + c.noun.toLowerCase() + `-1"`,
     ``,
     `  // Annotated: this slice reads back exactly what it writes, so each of these`,
     `  // names a constructor of both unions and the later declaration would win.`,
-    `  let announcedC = (` + c.contactField + `): Spec.consumedEvent =>`,
-    `    ` + n.announced + `({` + id + `: ` + id + `, ` + c.contactField + `: ` + c.contactField + `})`,
-    `  let subscribedC = (category, channel): Spec.consumedEvent =>`,
-    `    ` + n.subscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
-    `  let unsubscribedC = (category, channel): Spec.consumedEvent =>`,
-    `    ` + n.unsubscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
+    `  module Consumed = {`,
+    `    // A DCB slice's entity comes into existence with its first fact, so there`,
+    `    // is no creation event to seed: an unannounced ` + c.noun.toLowerCase() + ` is one with no`,
+    `    // history.`,
+    `    let created: array<Spec.consumedEvent> = []`,
+    `    let announced = (` + c.contactField + `): Spec.consumedEvent =>`,
+    `      ` + n.announced + `({` + id + `: ` + id + `, ` + c.contactField + `: ` + c.contactField + `})`,
+    `    let subscribed = (category, channel): Spec.consumedEvent =>`,
+    `      ` + n.subscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
+    `    let unsubscribed = (category, channel): Spec.consumedEvent =>`,
+    `      ` + n.unsubscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
+    `    // Written by ` + n.claims + ` and read here across partitions — this slice`,
+    `    // consumes them and produces neither.`,
+    `    let claimed = (source, by): Spec.consumedEvent =>`,
+    `      ` + n.claimed + `({sourceId: source, by})`,
+    `    let released = (source): Spec.consumedEvent => ` + n.released + `({sourceId: source})`,
+    `  }`,
     ``,
     `  let announce = ` + c.contactField + ` =>`,
     `    Spec.` + n.announceCmd + `({` + id + `: ` + id + `, ` + c.contactField + `: ` + c.contactField + `})`,
@@ -535,37 +784,86 @@ function conformanceBinding(c) {
     `    Spec.` + n.subscribeCmd + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
     `  let unsubscribe = (category, channel) =>`,
     `    Spec.` + n.unsubscribeCmd + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
-    `  // The wording is this host's and the trait carries none, so the suite supplies`,
-    `  // whatever it likes and asserts nothing about it.`,
-    `  let request = (category, reference) =>`,
+    `  // The wording and the subject are this host's and the trait carries neither, so`,
+    `  // the suite supplies whatever it likes and asserts nothing about them.`,
+    `  //`,
+    `  // One source nothing ever claims, so every assertion that predates the handover`,
+    `  // keeps deciding exactly as it did.`,
+    `  let defaultSource = "TODO(graft)DcbEventLog:` + c.occurrence + `"`,
+    ``,
+    `  let requestFrom = (category, reference, ~source, ~origin) =>`,
     `    Spec.` + n.requestCmd + `({`,
     `      ` + id + `: ` + id + `,`,
     `      category,`,
     `      reference,`,
+    `      subjectType: "` + subjectTypeOf(c) + `",`,
+    `      subjectRef: "subject-1",`,
     `      subject: "subject",`,
     `      body: "body",`,
+    `      sourceId: source,`,
+    `      origin: switch (origin: TraitNotification.Notification_Rules.origin) {`,
+    `      | Default => Default`,
+    `      | Configured => Configured({ruleId: "rule-1", ruleVersion: "1"})`,
+    `      },`,
     `    })`,
     ``,
+    `  let request = (category, reference) =>`,
+    `    requestFrom(category, reference, ~source=defaultSource, ~origin=Default)`,
+    ``,
     `  let announced = ` + c.contactField + ` =>`,
     `    Spec.` + n.announced + `({` + id + `: ` + id + `, ` + c.contactField + `: ` + c.contactField + `})`,
     `  let subscribed = (category, channel) =>`,
     `    Spec.` + n.subscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
     `  let unsubscribed = (category, channel) =>`,
     `    Spec.` + n.unsubscribed + `({` + id + `: ` + id + `, category, channel: Behavior.channelOf(channel)})`,
-    `  let requested = (category, reference, channel, address) =>`,
+    `  let requestedWith = (category, reference, channel, address, origin) =>`,
     `    Spec.` + n.requested + `({`,
     `      ` + id + `: ` + id + `,`,
     `      category,`,
     `      reference,`,
     `      channel: Behavior.channelOf(channel),`,
     `      address,`,
+    `      subjectType: "` + subjectTypeOf(c) + `",`,
+    `      subjectRef: "subject-1",`,
     `      subject: "subject",`,
     `      body: "body",`,
+    `      origin,`,
     `    })`,
+    ``,
+    `  let requested = (category, reference, channel, address) =>`,
+    `    requestedWith(category, reference, channel, address, Spec.Default)`,
+    `  // Which rule asked is this host's own shape, so the trait cannot build this.`,
+    `  let requestedConfigured = (category, reference, channel, address) =>`,
+    `    requestedWith(`,
+    `      category,`,
+    `      reference,`,
+    `      channel,`,
+    `      address,`,
+    `      Spec.Configured({ruleId: "rule-1", ruleVersion: "1"}),`,
+    `    )`,
+    `  let deferred = (reference, source) =>`,
+    `    Spec.` + n.deferred + `({` + id + `: ` + id + `, reference, sourceKey: source})`,
+    `  // The subject rides through the two decisions not to send as well: what a`,
+    `  // suppressed or undeliverable notification was about is the whole reason those`,
+    `  // rows are worth reading.`,
     `  let suppressed = (category, reference) =>`,
-    `    Spec.` + n.suppressed + `({` + id + `: ` + id + `, category, reference})`,
+    `    Spec.` + n.suppressed + `({`,
+    `      ` + id + `: ` + id + `,`,
+    `      category,`,
+    `      reference,`,
+    `      subjectType: "` + subjectTypeOf(c) + `",`,
+    `      subjectRef: "subject-1",`,
+    `      origin: Spec.Default,`,
+    `    })`,
     `  let undeliverable = (category, reference) =>`,
-    `    Spec.` + n.undeliverable + `({` + id + `: ` + id + `, category, reference})`,
+    `    Spec.` + n.undeliverable + `({`,
+    `      ` + id + `: ` + id + `,`,
+    `      category,`,
+    `      reference,`,
+    `      subjectType: "` + subjectTypeOf(c) + `",`,
+    `      subjectRef: "subject-1",`,
+    `      origin: Spec.Default,`,
+    `    })`,
     ``,
     `  let recipientUnknown = Spec.` + n.unknownError,
     ``,
@@ -588,7 +886,7 @@ function contactRelayPatch(c) {
   let n = namesOf(c);
   let id = n.recipientId;
   return {
-    into: c.chapter + `/OutboundTranslationSlice/` + n.relay + `.res (new, plus its _Translation)`,
+    into: c.chapter + `/OutboundTranslation/` + n.relay + `.res (new, plus its _Translation)`,
     at: `a new file — the trait cannot write what this host's events mean`,
     contents: [
       [
@@ -661,15 +959,21 @@ function intakeRelayPatch(c) {
   let n = namesOf(c);
   let id = n.recipientId;
   return {
-    into: c.chapter + `/AutomationSlice/` + n.intake + `.res (new, plus its _Automation)`,
+    into: c.chapter + `/Automation/` + n.intake + `.res (new, plus its _Automation)`,
     at: `a new file — the wording is this host's sentence, not the trait's`,
     contents: [
       `// Turns one of this host's occurrences into a request to notify somebody.`,
       ``,
       `@@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 — \`{{ ` + c.occurrenceId + ` }}\`.`,
       `@schema`,
-      `type todoItem = {` + id + `: string, ` + c.occurrenceId + `: string}`,
+      `type todoItem = {ruleId: string, ` + id + `: string, ` + c.occurrenceId + `: string}`,
       ``,
       `@schema`,
       `type command =`,
@@ -677,8 +981,12 @@ function intakeRelayPatch(c) {
       `    ` + id + `: string,`,
       `    category: ` + n.slice + `.category,`,
       `    reference: string,`,
+      `    subjectType: string,`,
+      `    subjectRef: string,`,
       `    subject: string,`,
       `    body: string,`,
+      `    sourceId: string,`,
+      `    origin: ` + n.slice + `.origin,`,
       `  })`,
       ``,
       `let maxRetries = 3`,
@@ -689,9 +997,7 @@ function intakeRelayPatch(c) {
       ``,
       `@@reventless.automation`,
       ``,
-      `// A TODO id is also the reference the request carries, so the outcome event`,
-      `// echoes back exactly what resolves the row.`,
-      `let key = ` + c.occurrenceId + ` => \`notify:\${` + c.occurrenceId + `}\``,
+      `module Rule = TraitNotification.Notification_Rule`,
       ``,
       `module DcbSource = {`,
       `  // MUST equal "<pluginName>DcbEventLog".`,
@@ -705,32 +1011,73 @@ function intakeRelayPatch(c) {
       `    | ` + n.requested + `({reference: string})`,
       `    | ` + n.suppressed + `({reference: string})`,
       `    | ` + n.undeliverable + `({reference: string})`,
+      `    // The fourth is not a 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.`,
+      `    | ` + n.deferred + `({reference: string})`,
       `}`,
       ``,
+      `// TODO(graft): the wording. A trait declares the kind; what the sentence says`,
+      `// is this host's — and it is text rather than ReScript, rendered against the`,
+      `// todo item next door, so \`{{ ` + c.occurrenceId + ` }}\` is a field of it.`,
+      `//`,
+      `// A rule's id is also the namespace of the references it writes, so two rules`,
+      `// on one subject are two notifications and two delivery rows.`,
+      `let defaultRules: array<Rule.t> = [`,
+      `  {`,
+      `    id: "` + c.occurrence + `",`,
+      `    version: "1",`,
+      `    source: {log: DcbSource.name, eventType: "` + c.occurrence + `"},`,
+      `    filter: Always,`,
+      `    category: "` + c.occurrenceCategory + `",`,
+      `    delivery: Immediate,`,
+      `    recipientPath: "` + id + `",`,
+      `    subjectType: "` + subjectTypeOf(c) + `",`,
+      `    subjectPath: "` + c.occurrenceId + `",`,
+      `    content: [{locale: "en", subject: "TODO(graft)", body: "TODO(graft)"}],`,
+      `  },`,
+      `]`,
+      ``,
+      `// 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 here.`,
+      `let todosFor = (~eventType, ~` + id + `, ~` + c.occurrenceId + `) =>`,
+      `  defaultRules`,
+      `  ->Rule.forEvent(~log=DcbSource.name, ~eventType)`,
+      `  ->Array.filter(Rule.isImmediate)`,
+      `  ->Array.map(rule => (`,
+      `    Rule.reference(rule, ~subject=` + c.occurrenceId + `),`,
+      `    ({ruleId: rule.id, ` + id + `: ` + id + `, ` + c.occurrenceId + `: ` + c.occurrenceId + `}: ` + n.intake + `.todoItem),`,
+      `  ))`,
+      ``,
       `module FromDcb = Mapping.Make(`,
       `  DcbSource,`,
       `  ` + n.intake + `,`,
       `  {`,
       `    open DcbSource`,
       ``,
-      `    let collect = (event, _ctx) =>`,
+      `    let collect = (event, ~sourceId as _, _ctx) =>`,
       `      switch event {`,
-      `      | ` + c.occurrence + `({` + c.occurrenceId + `, ` + c.occurrenceRecipient + `}) => [`,
-      `          (`,
-      `            key(` + c.occurrenceId + `),`,
-      `            ({` + id + `: ` + c.occurrenceRecipient + `, ` + c.occurrenceId + `: ` + c.occurrenceId + `}: ` + n.intake + `.todoItem),`,
-      `          ),`,
-      `        ]`,
+      `      | ` + c.occurrence + `({` + c.occurrenceId + `, ` + c.occurrenceRecipient + `}) =>`,
+      `        todosFor(`,
+      `          ~eventType="` + c.occurrence + `",`,
+      `          ~` + id + `=` + c.occurrenceRecipient + `,`,
+      `          ~` + c.occurrenceId + `,`,
+      `        )`,
       `      | ` + n.requested + `(_)`,
       `      | ` + n.suppressed + `(_)`,
-      `      | ` + n.undeliverable + `(_) => []`,
+      `      | ` + n.undeliverable + `(_)`,
+      `      | ` + n.deferred + `(_) => []`,
       `      }`,
       ``,
       `    let resolve = event =>`,
       `      switch event {`,
       `      | ` + n.requested + `({reference})`,
       `      | ` + n.suppressed + `({reference})`,
-      `      | ` + n.undeliverable + `({reference}) =>`,
+      `      | ` + n.undeliverable + `({reference})`,
+      `      | ` + n.deferred + `({reference}) =>`,
       `        Some(reference)`,
       `      | ` + c.occurrence + `(_) => None`,
       `      }`,
@@ -739,19 +1086,41 @@ function intakeRelayPatch(c) {
       ``,
       `let mappings: array<module(Mapping)> = [module(FromDcb)]`,
       ``,
-      `// TODO(graft): the wording. A trait declares the kind; what the sentence says`,
-      `// is this host's, and a config field for it would be a template language.`,
       `let process = (id, item: ` + n.intake + `.todoItem) =>`,
-      `  Some((`,
-      `    item.` + id + `,`,
-      `    ` + n.intake + `.` + n.requestCmd + `({`,
-      `      ` + id + `: item.` + id + `,`,
-      `      category: ` + c.occurrenceCategory + `,`,
-      `      reference: id,`,
-      `      subject: "TODO(graft)",`,
-      `      body: "TODO(graft)",`,
-      `    }),`,
-      `  ))`,
+      `  // 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. Neither publishes anything, and`,
+      `  // either leaves the row Pending — a \`None\` here spends no retry budget, so it`,
+      `  // is re-swept on every batch and never reaches \`onExhausted\`.`,
+      `  switch defaultRules->Rule.byId(item.ruleId)->Option.filter(Rule.isImmediate) {`,
+      `  | None => None`,
+      `  | Some(rule) =>`,
+      `    let payload = item->Reventless.Util_Sury.toJson(` + n.intake + `.todoItemSchema)`,
+      `    switch (Rule.matches(rule.filter, ~payload), Rule.recipientOf(rule, ~payload)) {`,
+      `    | (false, _) | (_, None) => None`,
+      `    | (true, Some(` + id + `)) =>`,
+      `      let (subject, body) =`,
+      `        Rule.compose(rule, ~payload, ~schema=` + n.intake + `.todoItemSchema)`,
+      `      Some((`,
+      `        ` + id + `,`,
+      `        ` + n.intake + `.` + n.requestCmd + `({`,
+      `          ` + id + `: ` + id + `,`,
+      `          category: ` + n.slice + `_Behavior.categoryOf(rule.category),`,
+      `          reference: id,`,
+      `          subjectType: rule.subjectType,`,
+      `          subjectRef: Rule.subjectOf(rule, ~payload),`,
+      `          subject,`,
+      `          body,`,
+      `          // Which stream this came from. A second producer claims exactly this`,
+      `          // string to take the entry over, so both sides must derive it the same`,
+      `          // way — the format is the whole agreement.`,
+      `          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 claims the source.`,
+      `          origin: Default,`,
+      `        }),`,
+      `      ))`,
+      `    }`,
+      `  }`,
       ``,
       `// A relay that gave up published no command, so the competency never heard of`,
       `// the occurrence — a delivery-failed fact for a message nobody requested would`,
@@ -766,19 +1135,27 @@ function emit(config, into, tests) {
   return {
     files: [
       {
-        path: into + `/StateChangeSlice/` + n.slice + `.res`,
+        path: into + `/StateChange/` + n.slice + `.res`,
         contents: sliceSpec(config)
       },
       {
-        path: into + `/StateChangeSlice/` + n.slice + `_Behavior.res`,
+        path: into + `/StateChange/` + n.slice + `_Behavior.res`,
         contents: sliceBehavior(config)
       },
       {
-        path: into + `/OutboundTranslationSlice/` + n.send + `.res`,
+        path: into + `/StateChange/` + n.claims + `.res`,
+        contents: claimsSpec(config)
+      },
+      {
+        path: into + `/StateChange/` + n.claims + `_Behavior.res`,
+        contents: claimsBehavior(config)
+      },
+      {
+        path: into + `/OutboundTranslation/` + n.send + `.res`,
         contents: sendSpec(config)
       },
       {
-        path: into + `/OutboundTranslationSlice/` + n.send + `_Translation.res`,
+        path: into + `/OutboundTranslation/` + n.send + `_Translation.res`,
         contents: sendTranslation(config)
       },
       {
@@ -799,11 +1176,14 @@ export {
   lines,
   addressA,
   addressB,
+  subjectTypeOf,
   authorizeOn,
   categoryArms,
   sliceSpec,
   postureArms,
   sliceBehavior,
+  claimsSpec,
+  claimsBehavior,
   sendSpec,
   sendTranslation,
   conformanceBinding,