@reventlessdev/reventless-core 3.0.0-alpha.246 → 3.0.0-alpha.248

package/CHANGELOG.md

@@ -3,6 +3,35 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.248 (2026-08-23)
+
+* feat(aws)!: scope the active-role store to the identity provider ([08e287d](https://github.com/ReventlessDev/reventless-core/commit/08e287db9721977b818bad76671ec4c62be6f9af))
+
+### BREAKING CHANGES
+
+* platform:cognitoUserPoolId is now
+platform:identityProviderId (REVENTLESS_IDENTITY_PROVIDER_ID). The old
+spelling is still read and warns — do not drop it until the new secret
+is in place, because an unset provider id is auto mode, and auto mode
+creates a new user pool.
+
+
+
+# 3.0.0-alpha.247 (2026-08-22)
+
+* feat(core)!: a slice that has given up says so ([f5559ab](https://github.com/ReventlessDev/reventless-core/commit/f5559abede3a9cf2c9a48aadc69a666c46cc75bf))
+
+### BREAKING CHANGES
+
+* `onExhausted` is required on the Translation and Automation
+module types. ReScript has no optional module-type fields, so the alternative
+was a PPX-injected default — and defaulting this one to silence is the bug.
+A slice now states what abandonment means for its domain, `None` included.
+GeocodeCustomerAddress answers with MarkAddressUnresolvable; the others say
+nothing, on purpose.
+
+
+
 # 3.0.0-alpha.246 (2026-08-21)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.246",
+  "version": "3.0.0-alpha.248",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.149",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.150",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.33",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.121"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.122"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Auth/Auth_ActiveRole.res

@@ -43,6 +43,21 @@ they picked stopped taking effect.
 */
 let staleRoleClaim = "activeRoleStale"
 
+// 🚨 **State that narrows an identity is scoped to the identity provider, not to
+// the platform.**
+//
+// A provider has one minting point, and narrowing works by driving it. Keep the
+// state a platform-scoped resource and two deployments sharing one provider each
+// drive their own copy — whichever holds the minting point reads state the other
+// never writes, so a role switch reports success and changes nothing. Each half
+// is individually correct, so nothing short of two deployments can observe it.
+//
+// On AWS that is a pool's single `PreTokenGeneration` slot and the
+// `platform:activeRoleStore` that follows it; elsewhere the shape differs and the
+// rule does not. It cannot be a `conformanceCases` entry — those are
+// `(membership, requested) → expected`, and this is about *where two deployments
+// keep state*. See [docs/plans/active-role-store-scoped-to-the-pool.md].
+
 /**
 The conformance table §6 of the plan requires: the same (membership, requested,
 expected) cases run against both minting paths, so the two implementations cannot

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -18,7 +18,12 @@ type todoStatus =
   | Pending
   | Processing
   | Completed
+  /** Failed and will be tried again. */
   | Failed
+  /** Failed for the last time — the retry budget is spent and no pass will pick
+      this row up again. Distinct from `Failed` because the two are opposite
+      instructions to whoever is reading: wait, or intervene. */
+  | Abandoned
 
 @schema
 type todoRow = {
@@ -28,6 +33,11 @@ type todoRow = {
   processedAt?: string,
   completedAt?: string,
   retryCount: int,
+  /** The ceiling `retryCount` is racing, copied from the Spec when the row is
+      created. Optional because rows written before this field existed are
+      rehydrated through `S.parseOrThrow`, and a required field would fail that
+      decode — silently, since the restore swallows it per row. */
+  maxRetries?: int,
 }
 
 /** The item schema seen through the `JSON.t` the row actually stores.
@@ -58,6 +68,7 @@ let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
     processedAt: ?s.matches(S.option(S.string)),
     completedAt: ?s.matches(S.option(S.string)),
     retryCount: s.matches(S.int),
+    maxRetries: ?s.matches(S.option(S.int)),
   })
 
 /**
@@ -122,6 +133,39 @@ module Make = (
   // the slice here makes the target's own events unmatchable, silently.
   let makeMeta = (): Reventless.Message.meta => Message.generateMeta(~service=Spec.targetName)
 
+  /** Record a failed attempt. The row is marked `Abandoned` at the moment the
+      budget runs out rather than being left to fall out of the next pass's
+      filter, so a reader never has to compare `retryCount` against a constant
+      that lives only in this Spec. */
+  let afterFailedAttempt = (row: todoRow): todoRow => {
+    let retryCount = row.retryCount + 1
+    {...row, status: retryCount >= Spec.maxRetries ? Abandoned : Failed, retryCount}
+  }
+
+  /** The command a slice wants published now that this item will never be
+      processed again, if it wants one. The row is `Abandoned` either way. */
+  let abandonmentCommand = (~id: string, ~row: todoRow): option<Reventless.Message.commandJson> =>
+    switch row.item->Reventless.Util_Sury.fromJson(Spec.todoItemSchema) {
+    | item =>
+      Automation.onExhausted(id, item)->Option.flatMap(((targetId, command)) =>
+        switch command->Reventless.Util_Sury.toJson(Spec.commandSchema) {
+        | commandJson => Some({Reventless.Message.id: targetId, meta: makeMeta(), commandJson})
+        | exception _ =>
+          EffectLogger.logError(
+            ~comp=`AutomationSlice(${Spec.name})`,
+            `retries exhausted for ${id}, and the abandonment command could not be encoded`,
+          )->Effect.runSync
+          None
+        }
+      )
+    | exception _ =>
+      EffectLogger.logError(
+        ~comp=`AutomationSlice(${Spec.name})`,
+        `retries exhausted for ${id}, and its item could not be decoded to announce it`,
+      )->Effect.runSync
+      None
+    }
+
   // Per-source erased dispatch — pre-compile decoders once at module init.
   type dispatch = {
     sourceName: string,
@@ -146,6 +190,7 @@ module Make = (
               status: Pending,
               createdAt: now(),
               retryCount: 0,
+              maxRetries: Spec.maxRetries,
             }
             todoItems->Dict.set(id, row)
           }
@@ -187,6 +232,20 @@ module Make = (
   }
 
   let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
+    // A `Failed` row at or past the ceiling is one an older build left stranded,
+    // or one whose Spec lowered `maxRetries` under it. Either way it is abandoned
+    // in fact, so say so rather than letting it sit in a status that promises a
+    // retry no pass will make.
+    let newlyAbandoned: array<string> = []
+    todoItems
+    ->Dict.toArray
+    ->Array.forEach(((id, row)) =>
+      if row.status == Failed && row.retryCount >= Spec.maxRetries {
+        todoItems->Dict.set(id, {...row, status: Abandoned})
+        newlyAbandoned->Array.push(id)
+      }
+    )
+
     let pending =
       todoItems
       ->Dict.toArray
@@ -222,10 +281,11 @@ module Make = (
               ~comp=`AutomationSlice(${Spec.name})`,
               `failed to encode command: ${errMsg}`,
             )->Effect.runSync
-            todoItems->Dict.set(
-              id,
-              {...row, status: Failed, retryCount: row.retryCount + 1},
-            )
+            let updated = row->afterFailedAttempt
+            todoItems->Dict.set(id, updated)
+            if updated.status == Abandoned {
+              newlyAbandoned->Array.push(id)
+            }
             None
           }
           commandJson->Option.forEach(
@@ -256,14 +316,34 @@ module Make = (
         pending->Array.forEach(((id, row)) => {
           switch todoItems->Dict.get(id) {
           | Some(current) if current.status == Processing =>
-            todoItems->Dict.set(
-              id,
-              {...row, status: Failed, retryCount: row.retryCount + 1},
-            )
+            let updated = row->afterFailedAttempt
+            todoItems->Dict.set(id, updated)
+            if updated.status == Abandoned {
+              newlyAbandoned->Array.push(id)
+            }
           | _ => ()
           }
         })
       }
     }
+
+    // Announced after the batch, so a publish failure above has already had its
+    // say on which rows ran out of budget. A failure here cannot mark anything for
+    // retry — the budget is what ran out — so the rows stay `Abandoned` regardless.
+    let abandonmentCommands =
+      newlyAbandoned->Array.filterMap(id =>
+        todoItems->Dict.get(id)->Option.flatMap(row => abandonmentCommand(~id, ~row))
+      )
+    if abandonmentCommands->Array.length > 0 {
+      try await publishJsons(abandonmentCommands) catch {
+      | exn =>
+        let errMsg =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`AutomationSlice(${Spec.name})`,
+          `failed to publish abandonment commands: ${errMsg}`,
+        )->Effect.runSync
+      }
+    }
   }
 }

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Sury from "sury";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -17,7 +18,8 @@ let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
   Sury.literal("Processing"),
   Sury.literal("Completed"),
-  Sury.literal("Failed")
+  Sury.literal("Failed"),
+  Sury.literal("Abandoned")
 ]);
 
 let todoRowSchema = Sury.$schema(s => ({
@@ -26,7 +28,8 @@ let todoRowSchema = Sury.$schema(s => ({
   createdAt: s.m(Sury.string),
   processedAt: s.m(Sury.$option(Sury.string)),
   completedAt: s.m(Sury.$option(Sury.string)),
-  retryCount: s.m(Sury.int)
+  retryCount: s.m(Sury.int),
+  maxRetries: s.m(Sury.$option(Sury.int))
 }));
 
 function todoRowSchemaFor(itemSchema) {
@@ -36,7 +39,8 @@ function todoRowSchemaFor(itemSchema) {
     createdAt: s.m(Sury.string),
     processedAt: s.m(Sury.$option(Sury.string)),
     completedAt: s.m(Sury.$option(Sury.string)),
-    retryCount: s.m(Sury.int)
+    retryCount: s.m(Sury.int),
+    maxRetries: s.m(Sury.$option(Sury.int))
   }));
 }
 
@@ -44,6 +48,13 @@ function Make(Spec) {
   return Automation => {
     let todoItems = {};
     let makeMeta = () => Message$ReventlessCore.generateMeta(Spec.targetName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let afterFailedAttempt = row => {
+      let retryCount = row.retryCount + 1 | 0;
+      let newrecord = {...row};
+      newrecord.retryCount = retryCount;
+      newrecord.status = retryCount >= Spec.maxRetries ? "Abandoned" : "Failed";
+      return newrecord;
+    };
     let dispatches = Automation.mappings.map(M => {
       let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
       let handle = (json, ctx) => {
@@ -61,11 +72,13 @@ function Make(Spec) {
           }
           let row_item = Util_Sury$Reventless.toJson(param[1], Spec.todoItemSchema);
           let row_createdAt = new Date().toISOString();
+          let row_maxRetries = Spec.maxRetries;
           let row = {
             item: row_item,
             status: "Pending",
             createdAt: row_createdAt,
-            retryCount: 0
+            retryCount: 0,
+            maxRetries: row_maxRetries
           };
           todoItems[id] = row;
         });
@@ -98,6 +111,18 @@ function Make(Spec) {
       });
     };
     let phase2 = async publishJsons => {
+      let newlyAbandoned = [];
+      Object.entries(todoItems).forEach(param => {
+        let row = param[1];
+        if (!(row.status === "Failed" && row.retryCount >= Spec.maxRetries)) {
+          return;
+        }
+        let id = param[0];
+        let newrecord = {...row};
+        newrecord.status = "Abandoned";
+        todoItems[id] = newrecord;
+        newlyAbandoned.push(id);
+      });
       let pending = Object.entries(todoItems).filter(param => {
         let row = param[1];
         if (row.status === "Pending") {
@@ -138,10 +163,11 @@ function Make(Spec) {
             let exn = Primitive_exceptions.internalToException(raw_exn);
             let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
             Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to encode command: ` + errMsg));
-            let newrecord$1 = {...row};
-            newrecord$1.retryCount = row.retryCount + 1 | 0;
-            newrecord$1.status = "Failed";
-            todoItems[id] = newrecord$1;
+            let updated = afterFailedAttempt(row);
+            todoItems[id] = updated;
+            if (updated.status === "Abandoned") {
+              newlyAbandoned.push(id);
+            }
             commandJson = undefined;
           }
           Stdlib_Option.forEach(commandJson, commandJson => {
@@ -155,32 +181,64 @@ function Make(Spec) {
           });
         });
       });
-      if (commands.length === 0) {
-        return;
+      if (commands.length !== 0) {
+        try {
+          await publishJsons(commands);
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish commands: ` + errMsg));
+          pending.forEach(param => {
+            let id = param[0];
+            let current = todoItems[id];
+            if (current === undefined) {
+              return;
+            }
+            if (current.status !== "Processing") {
+              return;
+            }
+            let updated = afterFailedAttempt(param[1]);
+            todoItems[id] = updated;
+            if (updated.status === "Abandoned") {
+              newlyAbandoned.push(id);
+              return;
+            }
+          });
+        }
       }
-      try {
-        return await publishJsons(commands);
-      } catch (raw_exn) {
-        let exn = Primitive_exceptions.internalToException(raw_exn);
-        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish commands: ` + errMsg));
-        pending.forEach(param => {
-          let row = param[1];
-          let id = param[0];
-          let current = todoItems[id];
-          if (current === undefined) {
-            return;
-          }
-          if (current.status !== "Processing") {
+      let abandonmentCommands = Stdlib_Array.filterMap(newlyAbandoned, id => Stdlib_Option.flatMap(todoItems[id], row => {
+        let item;
+        try {
+          item = Util_Sury$Reventless.fromJson(row.item, Spec.todoItemSchema);
+        } catch (exn) {
+          Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and its item could not be decoded to announce it`));
+          return;
+        }
+        return Stdlib_Option.flatMap(Automation.onExhausted(id, item), param => {
+          let commandJson;
+          try {
+            commandJson = Util_Sury$Reventless.toJson(param[1], Spec.commandSchema);
+          } catch (exn) {
+            Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and the abandonment command could not be encoded`));
             return;
           }
-          let newrecord = {...row};
-          newrecord.retryCount = row.retryCount + 1 | 0;
-          newrecord.status = "Failed";
-          todoItems[id] = newrecord;
+          return {
+            id: param[0],
+            meta: makeMeta(),
+            commandJson: commandJson
+          };
         });
+      }));
+      if (abandonmentCommands.length === 0) {
         return;
       }
+      try {
+        return await publishJsons(abandonmentCommands);
+      } catch (raw_exn$1) {
+        let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+        let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `failed to publish abandonment commands: ` + errMsg$1));
+      }
     };
     return {
       Spec: Spec,

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -8,7 +8,12 @@ type todoStatus =
   | Pending
   | Processing
   | Completed
+  /** Failed and will be tried again. */
   | Failed
+  /** Failed for the last time — the retry budget is spent and no pass will pick
+      this row up again. Distinct from `Failed` because the two are opposite
+      instructions to whoever is reading: wait, or intervene. */
+  | Abandoned
 
 @schema
 type todoRow = {
@@ -18,6 +23,11 @@ type todoRow = {
   processedAt?: string,
   completedAt?: string,
   retryCount: int,
+  /** The ceiling `retryCount` is racing, copied from the Spec when the row is
+      created. Optional because rows written before this field existed are
+      rehydrated through `S.parseOrThrow`, and a required field would fail that
+      decode — silently, since the restore swallows it per row. */
+  maxRetries?: int,
   lastError?: string,
 }
 
@@ -50,6 +60,7 @@ let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
     processedAt: ?s.matches(S.option(S.string)),
     completedAt: ?s.matches(S.option(S.string)),
     retryCount: s.matches(S.int),
+    maxRetries: ?s.matches(S.option(S.int)),
     lastError: ?s.matches(S.option(S.string)),
   })
 
@@ -135,6 +146,61 @@ module Make = (
       ~service=Spec.targetName->Option.getOr(`OutboundTranslationSlice:${Spec.name}`),
     )
 
+  /** Record a failed attempt. The row is marked `Abandoned` at the moment the
+      budget runs out rather than being left to fall out of the next pass's
+      filter, so a reader never has to compare `retryCount` against a constant
+      that lives only in this Spec. */
+  let afterFailedAttempt = (row: todoRow, ~lastError: option<string>=?): todoRow => {
+    let retryCount = row.retryCount + 1
+    {
+      ...row,
+      status: retryCount >= Spec.maxRetries ? Abandoned : Failed,
+      retryCount,
+      lastError: ?switch lastError {
+      | Some(_) as given => given
+      | None => row.lastError
+      },
+    }
+  }
+
+  /** Ask the slice whether abandonment is worth telling the domain about, and
+      publish what it says. Failing to publish here cannot mark the row for retry
+      — the budget is what ran out — so the loss is logged and the row stays
+      `Abandoned`. */
+  let announceAbandonment = async (
+    ~id: string,
+    ~row: todoRow,
+    ~publishJsons: ReventlessInfra.CommandTopic.publishJsons,
+  ) =>
+    switch row.item->Reventless.Util_Sury.fromJson(Spec.outboundItemSchema) {
+    | item =>
+      switch Translation.onExhausted(id, item, ~lastError=row.lastError) {
+      | None => ()
+      | Some((targetId, cmd)) =>
+        try {
+          let msg: Reventless.Message.commandJson = {
+            id: targetId,
+            meta: makeMeta(),
+            commandJson: cmd->Reventless.Util_Sury.toJson(Spec.inboundCommandSchema),
+          }
+          await publishJsons([msg])
+        } catch {
+        | exn =>
+          let errMsg =
+            exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+          EffectLogger.logError(
+            ~comp=`OutboundTranslationSlice(${Spec.name})`,
+            `retries exhausted for ${id}, and the abandonment command could not be published: ${errMsg}`,
+          )->Effect.runSync
+        }
+      }
+    | exception _ =>
+      EffectLogger.logError(
+        ~comp=`OutboundTranslationSlice(${Spec.name})`,
+        `retries exhausted for ${id}, and its item could not be decoded to announce it`,
+      )->Effect.runSync
+    }
+
   let phase1 = (events: array<(string, Spec.consumedEvent)>) => {
     events->Array.forEach(((sourceId, event)) => {
       // Collect new outbound items
@@ -147,6 +213,7 @@ module Make = (
             status: Pending,
             createdAt: now(),
             retryCount: 0,
+            maxRetries: Spec.maxRetries,
           }
           todoItems->Dict.set(id, row)
         }
@@ -158,6 +225,23 @@ module Make = (
     publishJsons: ReventlessInfra.CommandTopic.publishJsons,
     ~capabilities: Reventless.Capabilities.t,
   ) => {
+    // Ids that ran out of budget during this pass, announced once at the end so
+    // one item's abandonment cannot interleave with another's attempt.
+    let newlyAbandoned: array<string> = []
+
+    // A `Failed` row at or past the ceiling is one an older build left stranded,
+    // or one whose Spec lowered `maxRetries` under it. Either way it is abandoned
+    // in fact, so say so rather than letting it sit in a status that promises a
+    // retry no pass will make.
+    todoItems
+    ->Dict.toArray
+    ->Array.forEach(((id, row)) =>
+      if row.status == Failed && row.retryCount >= Spec.maxRetries {
+        todoItems->Dict.set(id, {...row, status: Abandoned})
+        newlyAbandoned->Array.push(id)
+      }
+    )
+
     let pending =
       todoItems
       ->Dict.toArray
@@ -229,16 +313,18 @@ module Make = (
                 ~comp=`OutboundTranslationSlice(${Spec.name})`,
                 `failed to publish command: ${errMsg}`,
               )->Effect.runSync
-              todoItems->Dict.set(
-                id,
-                {...row, status: Failed, retryCount: row.retryCount + 1},
-              )
+              let updated = row->afterFailedAttempt(~lastError=errMsg)
+              todoItems->Dict.set(id, updated)
+              if updated.status == Abandoned {
+                newlyAbandoned->Array.push(id)
+              }
             }
           | None =>
-            todoItems->Dict.set(
-              id,
-              {...row, status: Failed, retryCount: row.retryCount + 1},
-            )
+            let updated = row->afterFailedAttempt
+            todoItems->Dict.set(id, updated)
+            if updated.status == Abandoned {
+              newlyAbandoned->Array.push(id)
+            }
           }
 
         | Ok(None) =>
@@ -246,12 +332,22 @@ module Make = (
           todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
 
         | Error(msg) =>
-          todoItems->Dict.set(
-            id,
-            {...row, status: Failed, retryCount: row.retryCount + 1, lastError: msg},
-          )
+          let updated = row->afterFailedAttempt(~lastError=msg)
+          todoItems->Dict.set(id, updated)
+          if updated.status == Abandoned {
+            newlyAbandoned->Array.push(id)
+          }
         }
       }
     })
+
+    // The row is already `Abandoned`; this only asks whether the domain hears.
+    let _ = await newlyAbandoned->Array.reduce(Promise.resolve(), async (prev, id) => {
+      let _ = await prev
+      switch todoItems->Dict.get(id) {
+      | Some(row) => await announceAbandonment(~id, ~row, ~publishJsons)
+      | None => ()
+      }
+    })
   }
 }

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -15,7 +15,8 @@ let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
   Sury.literal("Processing"),
   Sury.literal("Completed"),
-  Sury.literal("Failed")
+  Sury.literal("Failed"),
+  Sury.literal("Abandoned")
 ]);
 
 let todoRowSchema = Sury.$schema(s => ({
@@ -25,6 +26,7 @@ let todoRowSchema = Sury.$schema(s => ({
   processedAt: s.m(Sury.$option(Sury.string)),
   completedAt: s.m(Sury.$option(Sury.string)),
   retryCount: s.m(Sury.int),
+  maxRetries: s.m(Sury.$option(Sury.int)),
   lastError: s.m(Sury.$option(Sury.string))
 }));
 
@@ -36,6 +38,7 @@ function todoRowSchemaFor(itemSchema) {
     processedAt: s.m(Sury.$option(Sury.string)),
     completedAt: s.m(Sury.$option(Sury.string)),
     retryCount: s.m(Sury.int),
+    maxRetries: s.m(Sury.$option(Sury.int)),
     lastError: s.m(Sury.$option(Sury.string))
   }));
 }
@@ -44,6 +47,41 @@ function Make(Spec) {
   return Translation => {
     let todoItems = {};
     let makeMeta = () => Message$ReventlessCore.generateMeta(Stdlib_Option.getOr(Spec.targetName, `OutboundTranslationSlice:` + Spec.name), undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let afterFailedAttempt = (row, lastError) => {
+      let retryCount = row.retryCount + 1 | 0;
+      let newrecord = {...row};
+      newrecord.lastError = lastError !== undefined ? lastError : row.lastError;
+      newrecord.retryCount = retryCount;
+      newrecord.status = retryCount >= Spec.maxRetries ? "Abandoned" : "Failed";
+      return newrecord;
+    };
+    let announceAbandonment = async (id, row, publishJsons) => {
+      let item;
+      try {
+        item = Util_Sury$Reventless.fromJson(row.item, Spec.outboundItemSchema);
+      } catch (exn) {
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and its item could not be decoded to announce it`));
+      }
+      let match = Translation.onExhausted(id, item, row.lastError);
+      if (match === undefined) {
+        return;
+      }
+      try {
+        let msg_id = match[0];
+        let msg_meta = makeMeta();
+        let msg_commandJson = Util_Sury$Reventless.toJson(match[1], Spec.inboundCommandSchema);
+        let msg = {
+          id: msg_id,
+          meta: msg_meta,
+          commandJson: msg_commandJson
+        };
+        return await publishJsons([msg]);
+      } catch (raw_exn) {
+        let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `retries exhausted for ` + id + `, and the abandonment command could not be published: ` + errMsg));
+      }
+    };
     let phase1 = events => {
       events.forEach(param => {
         Translation.collect(param[1], param[0]).forEach(param => {
@@ -54,17 +92,31 @@ function Make(Spec) {
           }
           let row_item = Util_Sury$Reventless.toJson(param[1], Spec.outboundItemSchema);
           let row_createdAt = new Date().toISOString();
+          let row_maxRetries = Spec.maxRetries;
           let row = {
             item: row_item,
             status: "Pending",
             createdAt: row_createdAt,
-            retryCount: 0
+            retryCount: 0,
+            maxRetries: row_maxRetries
           };
           todoItems[id] = row;
         });
       });
     };
     let phase2 = async (publishJsons, capabilities) => {
+      let newlyAbandoned = [];
+      Object.entries(todoItems).forEach(param => {
+        let row = param[1];
+        if (!(row.status === "Failed" && row.retryCount >= Spec.maxRetries)) {
+          return;
+        }
+        let id = param[0];
+        let newrecord = {...row};
+        newrecord.status = "Abandoned";
+        todoItems[id] = newrecord;
+        newlyAbandoned.push(id);
+      });
       let pending = Object.entries(todoItems).filter(param => {
         let row = param[1];
         if (row.status === "Pending") {
@@ -137,33 +189,48 @@ function Make(Spec) {
                 let exn$3 = Primitive_exceptions.internalToException(raw_exn$3);
                 let errMsg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$3), Stdlib_JsExn.message), "unknown");
                 Effect.runSync(EffectLogger$ReventlessCore.logError(`OutboundTranslationSlice(` + Spec.name + `)`, undefined, `failed to publish command: ` + errMsg$2));
-                let newrecord$2 = {...row};
-                newrecord$2.retryCount = row.retryCount + 1 | 0;
-                newrecord$2.status = "Failed";
-                todoItems[id] = newrecord$2;
-                return;
+                let updated = afterFailedAttempt(row, errMsg$2);
+                todoItems[id] = updated;
+                if (updated.status === "Abandoned") {
+                  newlyAbandoned.push(id);
+                  return;
+                } else {
+                  return;
+                }
               }
             } else {
-              let newrecord$3 = {...row};
-              newrecord$3.retryCount = row.retryCount + 1 | 0;
-              newrecord$3.status = "Failed";
-              todoItems[id] = newrecord$3;
-              return;
+              let updated$1 = afterFailedAttempt(row, undefined);
+              todoItems[id] = updated$1;
+              if (updated$1.status === "Abandoned") {
+                newlyAbandoned.push(id);
+                return;
+              } else {
+                return;
+              }
             }
           } else {
-            let newrecord$4 = {...row};
-            newrecord$4.completedAt = new Date().toISOString();
-            newrecord$4.status = "Completed";
-            todoItems[id] = newrecord$4;
+            let newrecord$2 = {...row};
+            newrecord$2.completedAt = new Date().toISOString();
+            newrecord$2.status = "Completed";
+            todoItems[id] = newrecord$2;
             return;
           }
         } else {
-          let newrecord$5 = {...row};
-          newrecord$5.lastError = result._0;
-          newrecord$5.retryCount = row.retryCount + 1 | 0;
-          newrecord$5.status = "Failed";
-          todoItems[id] = newrecord$5;
-          return;
+          let updated$2 = afterFailedAttempt(row, result._0);
+          todoItems[id] = updated$2;
+          if (updated$2.status === "Abandoned") {
+            newlyAbandoned.push(id);
+            return;
+          } else {
+            return;
+          }
+        }
+      });
+      await Stdlib_Array.reduce(newlyAbandoned, Promise.resolve(), async (prev, id) => {
+        await prev;
+        let row = todoItems[id];
+        if (row !== undefined) {
+          return await announceAbandonment(id, row, publishJsons);
         }
       });
     };