@reventlessdev/trait-notification 1.0.0-alpha.4 → 1.0.0-alpha.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/trait-notification",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.40",
   "description": "Notification domain trait: rules, host contract, conformance suite and emitter for a per-recipient contact directory, a kind x channel subscription matrix, and the decision to send, suppress or record a message as undeliverable",
   "license": "Apache-2.0",
   "files": [
@@ -11,16 +11,16 @@
     "README.md"
   ],
   "dependencies": {
-    "sury": "11.0.0-rc.2",
-    "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.202",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.128"
+    "sury": "11.0.0",
+    "sury-ppx": "11.0.0",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.238",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.160"
   },
   "devDependencies": {
-    "rescript": "12.3.0"
+    "rescript": "12.3.1"
   },
   "peerDependencies": {
-    "rescript": "12.3.0"
+    "rescript": "^12.3.1"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/Notification.res

@@ -19,7 +19,6 @@ What an occurrence *is*. It is told a recipient, a kind, and a reference; it is
 never told there was an order. That is why the two relays are the only files a
 graft has to be given, and everything else can be handed over whole.
 */
-
 /**
 This trait's own account of itself — see `AddressGeocoding.declaration` for why the
 version is read rather than written.
@@ -67,18 +66,30 @@ module type Binding = {
   module Spec: ReventlessGwt.Behavior_GWT.BehaviorSpec
   module Behavior: ReventlessGwt.Behavior_GWT.Behavior with module Spec = Spec
 
-  /** History that brings the recipient into existence with nothing on file. */
-  let created: array<Spec.consumedEvent>
-
-  /** The competency's own facts, as the slice consumes them. */
-  let announcedC: string => Spec.consumedEvent
-  let subscribedC: (category, Notification_Rules.channel) => Spec.consumedEvent
-  let unsubscribedC: (category, Notification_Rules.channel) => Spec.consumedEvent
-  /** A source taken over, as the slice reads it back. Claims are per source and
-      not per recipient, so a host produces these from wherever it keeps them —
-      what this contract requires is only that the decision can see them. */
-  let claimedC: (string, string) => Spec.consumedEvent
-  let releasedC: string => Spec.consumedEvent
+  /** The same facts as the slice **consumes** them, for building history.
+
+      A slice declares `consumedEvent` and `event` separately and they differ —
+      the consumed form carries no recipient id, because the partition already
+      says whose it is. So a suite needs both spellings of the same fact: one to
+      lay down history, one to assert what was emitted.
+
+      Grouped rather than suffixed. The pairs used to read `announcedC` against
+      `announced`, which said "consumed" only to someone who already knew — and
+      in a codebase where every binding also carries commands, a bare `C` reads
+      just as naturally as one. */
+  module Consumed: {
+    /** History that brings the recipient into existence with nothing on file. */
+    let created: array<Spec.consumedEvent>
+    let announced: string => Spec.consumedEvent
+    let subscribed: (category, Notification_Rules.channel) => Spec.consumedEvent
+    let unsubscribed: (category, Notification_Rules.channel) => Spec.consumedEvent
+    /** A source taken over, as the slice reads it back. Claims are per source
+        and not per recipient, so a host produces these from wherever it keeps
+        them — what this contract requires is only that the decision can see
+        them. */
+    let claimed: (string, string) => Spec.consumedEvent
+    let released: string => Spec.consumedEvent
+  }
 
   let announce: string => Spec.command
   let subscribe: (category, Notification_Rules.channel) => Spec.command
@@ -108,12 +119,7 @@ module type Binding = {
   /** `requested` as it comes out for a `Configured` request. A separate member
       because *which* rule asked is the host's own shape — the trait's fact
       carries no origin at all, so it cannot construct this one. */
-  let requestedConfigured: (
-    category,
-    string,
-    Notification_Rules.channel,
-    string,
-  ) => Spec.event
+  let requestedConfigured: (category, string, Notification_Rules.channel, string) => Spec.event
 
   /** The refusal for managing preferences for somebody nobody has announced. */
   let recipientUnknown: Spec.error

package/src/Notification_Conformance.res

@@ -6,7 +6,6 @@ What it asserts is the competency, not the host: the directory, the fallback to
 the host's posture, and — the part worth being strict about — that the three ways
 to send nothing stay three different facts.
 */
-
 /** The suite's title, composed once and read twice: the suite registers it,
     and `certify-trait` computes the same string to find the run's assertions in
     a test report. Exported rather than inlined so neither side parses the
@@ -17,14 +16,14 @@ module Make = (B: Notification.Binding) => {
   module G = ReventlessGwt.Behavior_GWT.Make(B.Spec, B.Behavior)
   module R = Notification_Rules
 
-  let announced = Array.concat(B.created, [B.announcedC(B.addressA)])
+  let announced = Array.concat(B.Consumed.created, [B.Consumed.announced(B.addressA)])
 
   let register = () =>
     G.describe(suiteName(B.Spec.name), () => {
       G.test("an announced contact is recorded", () =>
-        G.givenEvents(B.created)->G.whenCmd(B.announce(B.addressA))->G.thenEvent(
-          B.announced(B.addressA),
-        )
+        G.givenEvents(B.Consumed.created)
+        ->G.whenCmd(B.announce(B.addressA))
+        ->G.thenEvent(B.announced(B.addressA))
       )
 
       // The relay re-announces on every contact event a host publishes, and its
@@ -36,15 +35,15 @@ module Make = (B: Notification.Binding) => {
       )
 
       G.test("a changed address is recorded", () =>
-        G.givenEvents(announced)->G.whenCmd(B.announce(B.addressB))->G.thenEvent(
-          B.announced(B.addressB),
-        )
+        G.givenEvents(announced)
+        ->G.whenCmd(B.announce(B.addressB))
+        ->G.thenEvent(B.announced(B.addressB))
       )
 
       // A person is at the other end of this one, so they are told rather than
       // having a fact recorded about them.
       G.test("managing preferences for an unannounced recipient is refused", () =>
-        G.givenEvents(B.created)
+        G.givenEvents(B.Consumed.created)
         ->G.whenCmd(B.subscribe(B.optional, B.announcedChannel))
         ->G.thenError(B.recipientUnknown)
       )
@@ -81,13 +80,11 @@ module Make = (B: Notification.Binding) => {
       G.test("a transactional request goes out with no explicit subscription", () =>
         G.givenEvents(announced)
         ->G.whenCmd(B.request(B.transactional, "ref-1"))
-        ->G.thenEvent(
-          B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressA),
-        )
+        ->G.thenEvent(B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressA))
       )
 
       G.test("the address on the request is the one currently on file", () =>
-        G.givenEvents(Array.concat(announced, [B.announcedC(B.addressB)]))
+        G.givenEvents(Array.concat(announced, [B.Consumed.announced(B.addressB)]))
         ->G.whenCmd(B.request(B.transactional, "ref-1"))
         ->G.thenEvent(B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressB))
       )
@@ -100,7 +97,7 @@ module Make = (B: Notification.Binding) => {
 
       G.test("a recipient who opted out is suppressed", () =>
         G.givenEvents(
-          Array.concat(announced, [B.unsubscribedC(B.transactional, B.announcedChannel)]),
+          Array.concat(announced, [B.Consumed.unsubscribed(B.transactional, B.announcedChannel)]),
         )
         ->G.whenCmd(B.request(B.transactional, "ref-3"))
         ->G.thenEvent(B.suppressed(B.transactional, "ref-3"))
@@ -108,7 +105,7 @@ module Make = (B: Notification.Binding) => {
 
       // The case the directory exists for.
       G.test("a request for a recipient nobody announced is undeliverable", () =>
-        G.givenEvents(B.created)
+        G.givenEvents(B.Consumed.created)
         ->G.whenCmd(B.request(B.transactional, "ref-4"))
         ->G.thenEvent(B.undeliverable(B.transactional, "ref-4"))
       )
@@ -129,7 +126,9 @@ module Make = (B: Notification.Binding) => {
       )
 
       G.test("a default request for a claimed source is deferred", () =>
-        G.givenEvents(Array.concat(announced, [B.claimedC("other:Source", "second-producer")]))
+        G.givenEvents(
+          Array.concat(announced, [B.Consumed.claimed("other:Source", "second-producer")]),
+        )
         ->G.whenCmd(
           B.requestFrom(B.transactional, "ref-7", ~source="other:Source", ~origin=Default),
         )
@@ -140,7 +139,9 @@ module Make = (B: Notification.Binding) => {
       // keeps firing everywhere it was not taken over. Without this, a single
       // claim would silence the whole competency.
       G.test("a claim on one source leaves every other source alone", () =>
-        G.givenEvents(Array.concat(announced, [B.claimedC("other:Source", "second-producer")]))
+        G.givenEvents(
+          Array.concat(announced, [B.Consumed.claimed("other:Source", "second-producer")]),
+        )
         ->G.whenCmd(
           B.requestFrom(B.transactional, "ref-8", ~source=B.defaultSource, ~origin=Default),
         )
@@ -150,7 +151,9 @@ module Make = (B: Notification.Binding) => {
       // The producer that owns the source is the one that must get through, or
       // the handover would silence the entry rather than move it.
       G.test("a configured request for a claimed source goes through", () =>
-        G.givenEvents(Array.concat(announced, [B.claimedC("other:Source", "second-producer")]))
+        G.givenEvents(
+          Array.concat(announced, [B.Consumed.claimed("other:Source", "second-producer")]),
+        )
         ->G.whenCmd(
           B.requestFrom(B.transactional, "ref-9", ~source="other:Source", ~origin=Configured),
         )
@@ -163,7 +166,10 @@ module Make = (B: Notification.Binding) => {
         G.givenEvents(
           Array.concat(
             announced,
-            [B.claimedC("other:Source", "second-producer"), B.releasedC("other:Source")],
+            [
+              B.Consumed.claimed("other:Source", "second-producer"),
+              B.Consumed.released("other:Source"),
+            ],
           ),
         )
         ->G.whenCmd(
@@ -183,8 +189,8 @@ module Make = (B: Notification.Binding) => {
             Array.concat(
               announced,
               [
-                B.subscribedC(B.transactional, channel),
-                B.unsubscribedC(B.transactional, B.announcedChannel),
+                B.Consumed.subscribed(B.transactional, channel),
+                B.Consumed.unsubscribed(B.transactional, B.announcedChannel),
               ],
             ),
           )

package/src/Notification_Conformance.res.mjs

@@ -13,34 +13,34 @@ function Make(B) {
     evolve: $$let.evolve,
     decide: $$let.decide
   });
-  let announced = B.created.concat([B.announcedC(B.addressA)]);
+  let announced = B.Consumed.created.concat([B.Consumed.announced(B.addressA)]);
   let register = () => G.describe(suiteName(B.Spec.name), () => {
-    G.test("an announced contact is recorded", () => G.thenEvent(G.whenCmd(G.givenEvents(B.created), B.announce(B.addressA)), B.announced(B.addressA)));
+    G.test("an announced contact is recorded", () => G.thenEvent(G.whenCmd(G.givenEvents(B.Consumed.created), B.announce(B.addressA)), B.announced(B.addressA)));
     G.test("re-announcing the address already on file is a no-op", () => G.thenNoEvent(G.whenCmd(G.givenEvents(announced), B.announce(B.addressA))));
     G.test("a changed address is recorded", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.announce(B.addressB)), B.announced(B.addressB)));
-    G.test("managing preferences for an unannounced recipient is refused", () => G.thenError(G.whenCmd(G.givenEvents(B.created), B.subscribe(B.optional, B.announcedChannel)), B.recipientUnknown));
+    G.test("managing preferences for an unannounced recipient is refused", () => G.thenError(G.whenCmd(G.givenEvents(B.Consumed.created), B.subscribe(B.optional, B.announcedChannel)), B.recipientUnknown));
     G.test("opting in to a kind that is off by default is recorded", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.subscribe(B.optional, B.announcedChannel)), B.subscribed(B.optional, B.announcedChannel)));
     G.test("subscribing to a kind already on by posture is a no-op", () => G.thenNoEvent(G.whenCmd(G.givenEvents(announced), B.subscribe(B.transactional, B.announcedChannel))));
     G.test("opting out of a kind that is on is recorded", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.unsubscribe(B.transactional, B.announcedChannel)), B.unsubscribed(B.transactional, B.announcedChannel)));
     G.test("opting out of a kind already off is a no-op", () => G.thenNoEvent(G.whenCmd(G.givenEvents(announced), B.unsubscribe(B.optional, B.announcedChannel))));
     G.test("a transactional request goes out with no explicit subscription", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.request(B.transactional, "ref-1")), B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressA)));
-    G.test("the address on the request is the one currently on file", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.announcedC(B.addressB)])), B.request(B.transactional, "ref-1")), B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressB)));
+    G.test("the address on the request is the one currently on file", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.Consumed.announced(B.addressB)])), B.request(B.transactional, "ref-1")), B.requested(B.transactional, "ref-1", B.announcedChannel, B.addressB)));
     G.test("an optional request is suppressed with no explicit subscription", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.request(B.optional, "ref-2")), B.suppressed(B.optional, "ref-2")));
-    G.test("a recipient who opted out is suppressed", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.unsubscribedC(B.transactional, B.announcedChannel)])), B.request(B.transactional, "ref-3")), B.suppressed(B.transactional, "ref-3")));
-    G.test("a request for a recipient nobody announced is undeliverable", () => G.thenEvent(G.whenCmd(G.givenEvents(B.created), B.request(B.transactional, "ref-4")), B.undeliverable(B.transactional, "ref-4")));
+    G.test("a recipient who opted out is suppressed", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.Consumed.unsubscribed(B.transactional, B.announcedChannel)])), B.request(B.transactional, "ref-3")), B.suppressed(B.transactional, "ref-3")));
+    G.test("a request for a recipient nobody announced is undeliverable", () => G.thenEvent(G.whenCmd(G.givenEvents(B.Consumed.created), B.request(B.transactional, "ref-4")), B.undeliverable(B.transactional, "ref-4")));
     G.test("with nothing claimed, a default request is decided as usual", () => G.thenEvent(G.whenCmd(G.givenEvents(announced), B.requestFrom(B.transactional, "ref-6", B.defaultSource, "Default")), B.requested(B.transactional, "ref-6", B.announcedChannel, B.addressA)));
-    G.test("a default request for a claimed source is deferred", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.claimedC("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-7", "other:Source", "Default")), B.deferred("ref-7", "other:Source")));
-    G.test("a claim on one source leaves every other source alone", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.claimedC("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-8", B.defaultSource, "Default")), B.requested(B.transactional, "ref-8", B.announcedChannel, B.addressA)));
-    G.test("a configured request for a claimed source goes through", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.claimedC("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-9", "other:Source", "Configured")), B.requestedConfigured(B.transactional, "ref-9", B.announcedChannel, B.addressA)));
+    G.test("a default request for a claimed source is deferred", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.Consumed.claimed("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-7", "other:Source", "Default")), B.deferred("ref-7", "other:Source")));
+    G.test("a claim on one source leaves every other source alone", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.Consumed.claimed("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-8", B.defaultSource, "Default")), B.requested(B.transactional, "ref-8", B.announcedChannel, B.addressA)));
+    G.test("a configured request for a claimed source goes through", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([B.Consumed.claimed("other:Source", "second-producer")])), B.requestFrom(B.transactional, "ref-9", "other:Source", "Configured")), B.requestedConfigured(B.transactional, "ref-9", B.announcedChannel, B.addressA)));
     G.test("a released source stops deferring", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([
-      B.claimedC("other:Source", "second-producer"),
-      B.releasedC("other:Source")
+      B.Consumed.claimed("other:Source", "second-producer"),
+      B.Consumed.released("other:Source")
     ])), B.requestFrom(B.transactional, "ref-10", "other:Source", "Default")), B.requested(B.transactional, "ref-10", B.announcedChannel, B.addressA)));
     let channel = B.unreachableChannel;
     if (channel !== undefined) {
       return G.test("a channel with no address on file is undeliverable, not suppressed", () => G.thenEvent(G.whenCmd(G.givenEvents(announced.concat([
-        B.subscribedC(B.transactional, channel),
-        B.unsubscribedC(B.transactional, B.announcedChannel)
+        B.Consumed.subscribed(B.transactional, channel),
+        B.Consumed.unsubscribed(B.transactional, B.announcedChannel)
       ])), B.request(B.transactional, "ref-5")), B.undeliverable(B.transactional, "ref-5")));
     }
   });

package/src/Notification_Rule.res

@@ -9,7 +9,6 @@ surface. It is also why the wording is `Reventless.Template` source: readable
 text rather than ReScript interpolation, rendered against the payload's schema so
 a semantic formats itself and a `@sensitive` field is withheld.
 */
-
 /** How a field is compared. */
 @schema
 type comparison =
@@ -165,8 +164,7 @@ let recipientOf = (rule: t, ~payload: JSON.t) => stringAt(payload, rule.recipien
 
 /** What it is about. Empty is legal — a notification about nothing in particular
     is a real case, and a fabricated subject is worse than an absent one. */
-let subjectOf = (rule: t, ~payload: JSON.t) =>
-  stringAt(payload, rule.subjectPath)->Option.getOr("")
+let subjectOf = (rule: t, ~payload: JSON.t) => stringAt(payload, rule.subjectPath)->Option.getOr("")
 
 /** The wording to use, the asked-for locale if the rule has it and the first
     otherwise. Which locale to ask for is the caller's — nothing here knows who
@@ -191,10 +189,7 @@ let render = (source: string, ~payload: JSON.t, ~schema: S.t<'a>) =>
 let compose = (rule: t, ~payload: JSON.t, ~schema: S.t<'a>, ~locale: option<string>=?) =>
   switch contentFor(rule, ~locale?) {
   | None => ("", "")
-  | Some({subject, body}) => (
-      render(subject, ~payload, ~schema),
-      render(body, ~payload, ~schema),
-    )
+  | Some({subject, body}) => (render(subject, ~payload, ~schema), render(body, ~payload, ~schema))
   }
 
 /**
@@ -221,11 +216,12 @@ let validate = (rules: array<t>, ~digestRouted: bool=false, ~sample: JSON.t): ar
       note("no wording at all")
     }
     rule.content->Array.forEach(({locale, subject, body}) =>
-      [("subject", subject), ("body", body)]->Array.forEach(((which, template)) =>
-        switch Reventless.Template.parse(template) {
-        | Ok(_) => ()
-        | Error(why) => note(`${locale} ${which} does not parse — ${why}`)
-        }
+      [("subject", subject), ("body", body)]->Array.forEach(
+        ((which, template)) =>
+          switch Reventless.Template.parse(template) {
+          | Ok(_) => ()
+          | Error(why) => note(`${locale} ${which} does not parse — ${why}`)
+          },
       )
     )
     if recipientOf(rule, ~payload=sample) == None {

package/src/Notification_Rule.res.mjs

@@ -23,11 +23,11 @@ let literalSchema = Sury.union([
   })),
   Sury.$schema(s => ({
     TAG: "Number",
-    _0: s.m(Sury.float)
+    _0: s.m(Sury.number)
   })),
   Sury.$schema(s => ({
     TAG: "Flag",
-    _0: s.m(Sury.bool)
+    _0: s.m(Sury.boolean)
   }))
 ]);
 
@@ -68,7 +68,7 @@ let deliverySchema = Sury.union([
   Sury.literal("Immediate"),
   Sury.$schema(s => ({
     TAG: "Digest",
-    windowSeconds: s.m(Sury.int)
+    windowSeconds: s.m(Sury.int32)
   }))
 ]);
 

package/src/Notification_Rules.res

@@ -17,7 +17,6 @@ is the opposite. So the fallback *rule* lives here — an absent choice defers t
 the posture — and the *table* is passed in as `~posture`. A trait that hard-coded
 either answer would be wrong for half its hosts.
 */
-
 /** How a recipient is reached. Mirrors `Reventless.Messaging.channel`, which is
     the platform capability's vocabulary; this one is the domain's, so it carries
     a host's schema and travels on the wire. `Notification_Send` maps the two. */
@@ -72,22 +71,22 @@ let claimedBy = (t, source) =>
 
 /** What a host asks the competency to do. */
 type op =
-  | /** Relayed from whatever the host publishes when it learns where somebody is.
+  /** Relayed from whatever the host publishes when it learns where somebody is.
         Not a client's command: a caller who could announce another person's
         address would be redirecting their mail. */
-  Announce({channel: channel, address: string})
+  | Announce({channel: channel, address: string})
   | Subscribe({category: category, channel: channel})
   | Unsubscribe({category: category, channel: channel})
-  | /** Something worth telling them about happened. `reference` is the caller's
+  /** Something worth telling them about happened. `reference` is the caller's
         own key for it, echoed back on whichever outcome follows, so the relay
         that asked can tell its work is finished. Opaque here on purpose.
 
         `source` says which stream it came from and `origin` says who is asking;
         together they are the whole of the handover — see `decide`. */
-  Request({category: category, reference: string, source: source, origin: origin})
-  | /** A second producer takes over one source. Relayed like `Announce`: a
+  | Request({category: category, reference: string, source: source, origin: origin})
+  /** A second producer takes over one source. Relayed like `Announce`: a
         client that could claim a source would be silencing somebody else's mail. */
-  Claim({source: source, by: string})
+  | Claim({source: source, by: string})
   | Release({source: source})
 
 /** What the competency decided, for the host to name in its own events. */
@@ -95,18 +94,18 @@ type fact =
   | Announced({channel: channel, address: string})
   | Subscribed({category: category, channel: channel})
   | Unsubscribed({category: category, channel: channel})
-  | /** The addressed message. `address` is the snapshot delivery uses, which is
+  /** The addressed message. `address` is the snapshot delivery uses, which is
         why it is on the fact and not looked up again later. */
-  Requested({category: category, reference: string, channel: channel, address: string})
-  | /** They are reachable and said no. */
-  Suppressed({category: category, reference: string})
-  | /** They want it and nobody can be reached — no address on file for any
+  | Requested({category: category, reference: string, channel: channel, address: string})
+  /** They are reachable and said no. */
+  | Suppressed({category: category, reference: string})
+  /** They want it and nobody can be reached — no address on file for any
         channel they left enabled. A different fact from `Suppressed` on purpose:
         one is the system working and the other is the system falling short, and
         reporting both the same way hides every delivery gap behind a legitimate
         preference. */
-  Undeliverable({category: category, reference: string})
-  | /** Not acted on because another producer owns this source. A third way of
+  | Undeliverable({category: category, reference: string})
+  /** Not acted on because another producer owns this source. A third way of
         not sending, and its own fact for the same reason `Suppressed` and
         `Undeliverable` are two rather than one: "they declined", "nobody was
         reachable" and "somebody else has this" are three different things, and a
@@ -116,7 +115,7 @@ type fact =
         TODO row on an outcome; without a fourth one a deferred request retries
         its whole budget and lands in `onExhausted`, which is a slow silent
         failure with nothing in the log to explain it. */
-  Deferred({reference: string, source: source})
+  | Deferred({reference: string, source: source})
   | Claimed({source: source, by: string})
   | Released({source: source})
 
@@ -223,15 +222,14 @@ let decide = (t, op, ~posture: (category, channel) => bool): result<
 
   | Request({category, reference}) =>
     let wanted = channels->Array.filter(channel => enabled(t, ~posture, category, channel))
-    let addressed =
-      wanted->Array.filterMap(channel =>
-        addressFor(t, channel)->Option.map(address => Requested({
-          category,
-          reference,
-          channel,
-          address,
-        }))
-      )
+    let addressed = wanted->Array.filterMap(channel =>
+      addressFor(t, channel)->Option.map(address => Requested({
+        category,
+        reference,
+        channel,
+        address,
+      }))
+    )
     switch addressed {
     | [] =>
       // Wanted-but-unreachable and not-wanted are the two ways to send nothing,

package/src/Notification_Scaffold.res

@@ -15,7 +15,6 @@ is the one thing a trait cannot be told in names.
 says is the host's sentence, so the emitted rule table carries a `TODO(graft)`
 marker in place of one — it compiles, runs, and is obvious in a diff.
 */
-
 /**
 The names a graft needs, and nothing else.
 
@@ -137,8 +136,8 @@ let namesOf = (c: config): names => {
     delivered: "NotificationDelivered",
     failed: "NotificationFailed",
     unknownError: n ++ "Unknown",
-    recipientId: (n->String.slice(~start=0, ~end=1))->String.toLowerCase ++
-      n->String.slice(~start=1, ~end=n->String.length) ++ "Id",
+    recipientId: n->String.slice(~start=0, ~end=1)->String.toLowerCase ++
+    n->String.slice(~start=1, ~end=n->String.length) ++ "Id",
   }
 }
 
@@ -154,13 +153,14 @@ let addressB = (c: config) => c.addressB->Option.getOr("new@example.com")
     graft, so a host whose component is registered under another name edits one
     line rather than discovering the convention. */
 let subjectTypeOf = (c: config) => {
-  let stem = c.occurrenceId->String.endsWith("Id")
-    ? c.occurrenceId->String.slice(~start=0, ~end=c.occurrenceId->String.length - 2)
-    : c.occurrenceId
+  let stem =
+    c.occurrenceId->String.endsWith("Id")
+      ? c.occurrenceId->String.slice(~start=0, ~end=c.occurrenceId->String.length - 2)
+      : c.occurrenceId
   switch stem {
   | "" => "Subject"
   | s =>
-    (s->String.slice(~start=0, ~end=1))->String.toUpperCase ++
+    s->String.slice(~start=0, ~end=1)->String.toUpperCase ++
       s->String.slice(~start=1, ~end=s->String.length)
   }
 }
@@ -373,19 +373,9 @@ let sliceBehavior = (c: config): string => {
           `  switch (category, channel) {`,
         ],
         postureArms(c),
-        [
-          `  }`,
-          ``,
-          `let categoryKey = (category: category) =>`,
-          `  switch category {`,
-        ],
+        [`  }`, ``, `let categoryKey = (category: category) =>`, `  switch category {`],
         c.categories->Array.map(cat => `  | ${cat} => "${cat}"`),
-        [
-          `  }`,
-          ``,
-          `let categoryOf = (key: string) =>`,
-          `  switch key {`,
-        ],
+        [`  }`, ``, `let categoryOf = (key: string) =>`, `  switch key {`],
         c.categories
         ->Array.filter(cat => cat != first)
         ->Array.map(cat => `  | "${cat}" => ${cat}`),
@@ -773,13 +763,20 @@ let sendTranslation = (c: config): string => {
     `    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((`,
@@ -867,25 +864,27 @@ let conformanceBinding = (c: config): string => {
     `  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->String.toLowerCase} is one with no history.`,
-    `  let created: array<Spec.consumedEvent> = []`,
-    ``,
     `  let ${id} = "${c.noun->String.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)})`,
-    `  // Written by ${n.claims} and read here across partitions — this slice`,
-    `  // consumes them and produces neither.`,
-    `  let claimedC = (source, by): Spec.consumedEvent =>`,
-    `    ${n.claimed}({sourceId: source, by})`,
-    `  let releasedC = (source): Spec.consumedEvent => ${n.released}({sourceId: source})`,
+    `  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->String.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}})`,
@@ -1003,7 +1002,7 @@ let contactRelayPatch = (c: config): patch => {
   let n = namesOf(c)
   let id = n.recipientId
   {
-    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: lines(
       Array.flatMap(
@@ -1083,7 +1082,7 @@ let intakeRelayPatch = (c: config): patch => {
   let n = namesOf(c)
   let id = n.recipientId
   {
-    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: lines([
       `// Turns one of this host's occurrences into a request to notify somebody.`,
@@ -1264,16 +1263,16 @@ let emit = (~config: config, ~into: string, ~tests: string): output => {
   let n = namesOf(config)
   {
     files: [
-      {path: `${into}/StateChangeSlice/${n.slice}.res`, contents: sliceSpec(config)},
-      {path: `${into}/StateChangeSlice/${n.slice}_Behavior.res`, contents: sliceBehavior(config)},
-      {path: `${into}/StateChangeSlice/${n.claims}.res`, contents: claimsSpec(config)},
+      {path: `${into}/StateChange/${n.slice}.res`, contents: sliceSpec(config)},
+      {path: `${into}/StateChange/${n.slice}_Behavior.res`, contents: sliceBehavior(config)},
+      {path: `${into}/StateChange/${n.claims}.res`, contents: claimsSpec(config)},
       {
-        path: `${into}/StateChangeSlice/${n.claims}_Behavior.res`,
+        path: `${into}/StateChange/${n.claims}_Behavior.res`,
         contents: claimsBehavior(config),
       },
-      {path: `${into}/OutboundTranslationSlice/${n.send}.res`, contents: sendSpec(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),
       },
       {path: `${tests}/NotificationConformance_GWT.res`, contents: conformanceBinding(config)},

package/src/Notification_Scaffold.res.mjs

@@ -660,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((`,
@@ -749,25 +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)})`,
-    `  // Written by ` + n.claims + ` and read here across partitions — this slice`,
-    `  // consumes them and produces neither.`,
-    `  let claimedC = (source, by): Spec.consumedEvent =>`,
-    `    ` + n.claimed + `({sourceId: source, by})`,
-    `  let releasedC = (source): Spec.consumedEvent => ` + n.released + `({sourceId: source})`,
+    `  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 + `})`,
@@ -877,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: [
       [
@@ -950,7 +959,7 @@ 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.`,
@@ -1126,27 +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 + `/StateChangeSlice/` + n.claims + `.res`,
+        path: into + `/StateChange/` + n.claims + `.res`,
         contents: claimsSpec(config)
       },
       {
-        path: into + `/StateChangeSlice/` + n.claims + `_Behavior.res`,
+        path: into + `/StateChange/` + n.claims + `_Behavior.res`,
         contents: claimsBehavior(config)
       },
       {
-        path: into + `/OutboundTranslationSlice/` + n.send + `.res`,
+        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)
       },
       {