@reventlessdev/reventless-local 3.0.0-alpha.234 → 3.0.0-alpha.236

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 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.236 (2026-08-23)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.235 (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.234 (2026-08-21)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.234",
+  "version": "3.0.0-alpha.236",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -37,16 +37,16 @@
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.94",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.246",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.149",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.110",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.17",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.193",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.121"
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.96",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.195",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.150",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.112",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.248",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.122",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.17"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/tests/adapter/QueryDbListResolverTest.res

@@ -574,3 +574,153 @@ describe("QueryDb by-index resolver", () => {
     }
   })
 })
+
+// ─────────────────────────────────────────────────────────────
+// Sub-id view — the `{name}Items` door
+// ─────────────────────────────────────────────────────────────
+
+// The door only exists when a view declares a sub-id, and no fixture declared one
+// alongside a union field, so it was the last door in the mechanism plan's table
+// carrying a union nowhere.
+
+@schema
+type lineState = {
+  orderId: @s.matches(Reventless.DcbTag.string) string,
+  lineNo: string,
+  label: string,
+  geolocation?: geolocation,
+}
+
+let lineStateSchemaWithAnnotations =
+  lineStateSchema->S.Metadata.set(
+    ~id=Reventless.StateAnnotations.stateAnnotationsId,
+    {
+      ids: ["orderId"],
+      compositeIds: [],
+      subIds: ["lineNo"],
+      compositeSubIds: [],
+      indexes: [],
+      hidden: [],
+      summary: [],
+      drillTargets: [],
+      drillTargetKeys: [],
+      collapsed: [],
+      scan: [],
+      scanSort: [],
+      semantic: [],
+      metric: [],
+      lifecycle: None,
+      groupBy: None,
+      visibility: None,
+      live: None,
+      retired: None,
+    },
+  )
+
+let buildSubIdFixture = async (~name: string) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalQueryDbStorage.Make(Bus)
+  module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
+
+  module Spec = {
+    module Id = Reventless.Id.StringPure
+    let name = name
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = lineState
+    let config = Reventless.ReadModel.config()
+    let subIdConfig = Some({
+      Reventless.ReadModel.subIdField: "lineNo",
+      getSubId: (state: lineState) => state.lineNo,
+    })
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module QDbResolversAdapter = ReventlessCore.QueryDb_Adapter.NoResolvers(Storage)
+  module Maker = ReventlessCore.QueryDb_Builder.Make(Spec, Storage, QDbResolversAdapter)
+
+  ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.set(
+    name,
+    {
+      singleFieldName: name,
+      listFieldName: name ++ "s",
+      returnTypeName: name,
+      pluralTypeName: "[" ++ name ++ "]",
+      includeIdParam: true,
+      connectionSpec: true,
+    },
+  )
+  ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.set(
+    name,
+    lineStateSchemaWithAnnotations->S.castToUnknown,
+  )
+
+  let queryDb = Maker.make(~api=(), ~apiRole=())
+  let ops = await queryDb->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _: ReventlessCore.QueryDb_Adapter.resolvers = Resolvers.make(
+    ~name,
+    ~api=(),
+    ~apiRole=(),
+    ~dataSourceName=""->Pulumi.Output.make,
+    ~indexes=[],
+    ~subIdField=Some("lineNo"),
+    ~idResolverConfigs=[],
+    ~idsResolverConfigs=[],
+    ~authorization=Reventless.Authorization.AllowAuthenticated,
+    ~opts=({}: Pulumi.CustomResourceOptions.t),
+  )
+
+  // Two lines under one order: the first carries the union, the second leaves the
+  // optional field absent.
+  let _ = await ops.save(
+    "o-1",
+    {orderId: "o-1", lineNo: "l-1", label: "First", geolocation: Located({lat: 48.2082, lng: 16.3738})},
+    Init,
+    None,
+  )
+  let _ = await ops.save("o-1", {orderId: "o-1", lineNo: "l-2", label: "Second"}, Init, None)
+
+  switch DomainGraphQL_Server.getQueryResolver(name ++ "Items") {
+  | Some(r) => r
+  | None => JsError.throwWithMessage("items resolver not registered: " ++ name ++ "Items")
+  }
+}
+
+describe("QueryDb sub-id resolver — the Items door", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  testPromise("answers the sub-items of one id, as edges", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemA")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let edges = getEdges(response)
+    expect(edges->Array.length)->toBe(2)
+    expect(edgeNodeField(edges->Array.getUnsafe(0), "lineNo"))->toBe("l-1")
+  })
+
+  // The gap this fixture exists to close, mirroring the by-index case above: a
+  // union reaching a caller through the Items door with the member type the
+  // write-time stamp put on it. Without it the member resolves to null and takes
+  // its non-nullable parent, so the row leaves the connection rather than erroring.
+  testPromise("carries a union field's member type through", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemB")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let first = getEdges(response)->Array.getUnsafe(0)
+    let geo = edgeNodeJson(first, "geolocation")->Option.flatMap(JSON.Decode.object)
+    expect(geo->Option.flatMap(o => o->Dict.get("__typename"))->Option.flatMap(JSON.Decode.string))
+    ->toEqual(Some("GeolocationLocated"))
+    expect(geo->Option.flatMap(o => o->Dict.get("lat"))->Option.flatMap(JSON.Decode.float))
+    ->toEqual(Some(48.2082))
+  })
+
+  testPromise("leaves an absent union absent", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemC")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let second = getEdges(response)->Array.getUnsafe(1)
+    expect(edgeNodeField(second, "label"))->toBe("Second")
+    expect(edgeNodeJson(second, "geolocation")->Option.isNone)->toBe(true)
+  })
+})

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -648,6 +648,136 @@ globalThis.describe("QueryDb by-index resolver", () => {
   });
 });
 
+let lineStateSchema = Sury.$schema(s => ({
+  orderId: s.m(DcbTag$Reventless.string),
+  lineNo: s.m(Sury.string),
+  label: s.m(Sury.string),
+  geolocation: s.m(Sury.$option(geolocationSchema$1))
+}));
+
+let lineStateSchemaWithAnnotations = Sury.$Metadata_set(lineStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["orderId"],
+  compositeIds: [],
+  subIds: ["lineNo"],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  semantic: [],
+  metric: [],
+  lifecycle: undefined,
+  groupBy: undefined,
+  visibility: undefined,
+  live: undefined,
+  retired: undefined
+});
+
+async function buildSubIdFixture(name) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
+  let Resolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
+  let moduleUrl = import.meta.url;
+  let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+  let subIdConfig = {
+    subIdField: "lineNo",
+    getSubId: state => state.lineNo
+  };
+  let QDbResolversAdapter = QueryDb_Adapter$ReventlessCore.NoResolvers({
+    make: Storage.make
+  });
+  let Maker = QueryDb_Builder$ReventlessCore.Make({
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: name,
+    moduleUrl: moduleUrl,
+    stateSchema: lineStateSchema,
+    config: config,
+    subIdConfig: subIdConfig,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(QDbResolversAdapter);
+  Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name] = {
+    singleFieldName: name,
+    listFieldName: name + "s",
+    returnTypeName: name,
+    pluralTypeName: "[" + name + "]",
+    includeIdParam: true,
+    connectionSpec: true
+  };
+  Plugin_Helpers$ReventlessCore.stateSchemaRegistry[name] = lineStateSchemaWithAnnotations;
+  let queryDb = Maker.make(undefined, undefined, undefined, undefined, undefined);
+  let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(queryDb));
+  Resolvers.make(name, undefined, undefined, Pulumi.output(""), [], "lineNo", [], [], "AllowAuthenticated", {});
+  await ops.save("o-1", {
+    orderId: "o-1",
+    lineNo: "l-1",
+    label: "First",
+    geolocation: {
+      TAG: "Located",
+      lat: 48.2082,
+      lng: 16.3738
+    }
+  }, "Init", undefined);
+  await ops.save("o-1", {
+    orderId: "o-1",
+    lineNo: "l-2",
+    label: "Second"
+  }, "Init", undefined);
+  let r = DomainGraphQL_Server$ReventlessLocal.getQueryResolver(name + "Items");
+  if (r !== undefined) {
+    return r;
+  } else {
+    return Stdlib_JsError.throwWithMessage("items resolver not registered: " + name + "Items");
+  }
+}
+
+globalThis.describe("QueryDb sub-id resolver — the Items door", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+  globalThis.test("answers the sub-items of one id, as edges", async () => {
+    let resolver = await buildSubIdFixture("ItemA");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let edges = getEdges(response);
+    globalThis.expect(edges.length).toBe(2);
+    globalThis.expect(edgeNodeField(edges[0], "lineNo")).toBe("l-1");
+  });
+  globalThis.test("carries a union field's member type through", async () => {
+    let resolver = await buildSubIdFixture("ItemB");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let first = getEdges(response)[0];
+    let geo = Stdlib_Option.flatMap(edgeNodeJson(first, "geolocation"), Stdlib_JSON.Decode.object);
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["__typename"]), Stdlib_JSON.Decode.string)).toEqual("GeolocationLocated");
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["lat"]), Stdlib_JSON.Decode.float)).toEqual(48.2082);
+  });
+  globalThis.test("leaves an absent union absent", async () => {
+    let resolver = await buildSubIdFixture("ItemC");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let second = getEdges(response)[1];
+    globalThis.expect(edgeNodeField(second, "label")).toBe("Second");
+    globalThis.expect(Stdlib_Option.isNone(edgeNodeJson(second, "geolocation"))).toBe(true);
+  });
+});
+
 export {
   geolocationSchema$1 as geolocationSchema,
   rowStateSchema,
@@ -667,5 +797,8 @@ export {
   pageInfoBool,
   pageInfoString,
   buildFixture,
+  lineStateSchema,
+  lineStateSchemaWithAnnotations,
+  buildSubIdFixture,
 }
 /*  Not a pure module */

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -179,6 +179,70 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     })
   })
 
+  // A row used to leave the retry budget by falling out of phase2's filter, so
+  // `Failed` meant both "will be retried" and "never again" and only the count
+  // told them apart — against a ceiling that lives in the Spec, not in the row.
+  describe("retry exhaustion", () => {
+    let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
+      JsError.throwWithMessage("publish failed")
+
+    let collectOne = () =>
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+
+    let statusOf = id => (Callback.todoItems->Dict.get(id)->Option.getOrThrow).status
+
+    testPromise("the attempt that spends the budget writes Abandoned, not Failed", async () => {
+      collectOne()
+      // ShipOrderSpec.maxRetries is 3: attempts at retryCount 0, 1 and 2 leave the
+      // row retriable, and the third failure is the one that ends it.
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Failed)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Failed)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+    })
+
+    testPromise("an abandoned row is not picked up again", async () => {
+      collectOne()
+      await Callback.phase2(failingPublish)
+      await Callback.phase2(failingPublish)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+
+      // A pass that would have succeeded: the row must still not be attempted,
+      // which is what makes the status a decision rather than a label.
+      let published = ref([])
+      await Callback.phase2(async cmds => published := cmds)
+      expect(published.contents->Array.length)->toBe(0)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+    })
+
+    testPromise("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      collectOne()
+      // What an older build wrote, and what a Spec that lowered maxRetries leaves
+      // behind: Failed at the ceiling, which no pass would ever pick up or mark.
+      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      Callback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 3})
+
+      let published = ref([])
+      await Callback.phase2(async cmds => published := cmds)
+      expect(published.contents->Array.length)->toBe(0)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+    })
+
+    testPromise("the row carries the ceiling its count is racing", async () => {
+      collectOne()
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)
+      ->toEqual(Some(ShipOrderSpec.maxRetries))
+    })
+  })
+
   describe("full lifecycle", () => {
     testPromise("collect → process → resolve completes the TODO item", async () => {
       Callback.phase1(

package/tests/components/automationslice/AutomationSliceCallbackTest.res.mjs

@@ -192,6 +192,61 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(row2.status).toBe("Processing");
     });
   });
+  globalThis.describe("retry exhaustion", () => {
+    let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
+    let collectOne = () => Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+        TAG: "OrderPlaced",
+        orderId: "ord-1",
+        address: "123 Main St"
+      })], AutomationSliceFixtures$ReventlessLocal.testContext);
+    let statusOf = id => Stdlib_Option.getOrThrow(Callback.todoItems[id], undefined).status;
+    globalThis.test("the attempt that spends the budget writes Abandoned, not Failed", async () => {
+      collectOne();
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Failed");
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Failed");
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
+    });
+    globalThis.test("an abandoned row is not picked up again", async () => {
+      collectOne();
+      await Callback.phase2(failingPublish);
+      await Callback.phase2(failingPublish);
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
+    });
+    globalThis.test("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      collectOne();
+      let row = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 3;
+      newrecord.status = "Failed";
+      Callback.todoItems["ord-1"] = newrecord;
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+    });
+    globalThis.test("the row carries the ceiling its count is racing", async () => {
+      collectOne();
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).maxRetries).toEqual(AutomationSliceFixtures$ReventlessLocal.ShipOrderSpec.maxRetries);
+    });
+  });
   globalThis.describe("full lifecycle", () => {
     globalThis.test("collect → process → resolve completes the TODO item", async () => {
       Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({

package/tests/components/automationslice/AutomationSliceFixtures.res

@@ -108,6 +108,7 @@ module ShipOrderAutomation: Reventless.AutomationSlice.Automation
   with module Spec := ShipOrderSpec = {
   let process = (id, _item: ShipOrderSpec.todoItem) =>
     Some((id, ShipOrderSpec.CreateShipment({orderId: id})))
+  let onExhausted = (_id, _item: ShipOrderSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(ShipOrderSpec)
   module type Mapping = M.Mapping
@@ -117,6 +118,7 @@ module ShipOrderAutomation: Reventless.AutomationSlice.Automation
 module SkipProcessAutomation: Reventless.AutomationSlice.Automation
   with module Spec := SkipProcessSpec = {
   let process = (_id, _item: SkipProcessSpec.todoItem) => None
+  let onExhausted = (_id, _item: SkipProcessSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(SkipProcessSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/AutomationSliceFixtures.res.mjs

@@ -168,6 +168,10 @@ function process(id, _item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$2 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(ShipOrderSpec);
@@ -176,6 +180,7 @@ let mappings = [ShipOrderMapping];
 
 let ShipOrderAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$2,
   mappings: mappings
 };
@@ -184,6 +189,10 @@ function process$1(_id, _item) {
   
 }
 
+function onExhausted$1(_id, _item) {
+  
+}
+
 let moduleUrl$3 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(SkipProcessSpec);
@@ -192,6 +201,7 @@ let mappings$1 = [SkipProcessMapping];
 
 let SkipProcessAutomation = {
   process: process$1,
+  onExhausted: onExhausted$1,
   moduleUrl: moduleUrl$3,
   mappings: mappings$1
 };

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -158,6 +158,7 @@ module FromDcb = AutomationSlice.Mapping.Make(
 module AutoShipAutomation: AutomationSlice.Automation with module Spec := AutoShipSpec = {
   let process = (id, _item: AutoShipSpec.todoItem) =>
     Some((id, AutoShipSpec.Ship({orderId: id})))
+  let onExhausted = (_id, _item: AutoShipSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoShipSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res.mjs

@@ -264,6 +264,10 @@ function process(id, _item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$5 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(AutoShipSpec);
@@ -272,6 +276,7 @@ let mappings = [FromDcb];
 
 let AutoShipAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$5,
   mappings: mappings
 };

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -117,6 +117,7 @@ module AutoFulfillAutomation: AutomationSlice.Automation
   with module Spec := AutoFulfillSpec = {
   let process = (id, item: AutoFulfillSpec.todoItem) =>
     Some((id, AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId})))
+  let onExhausted = (_id, _item: AutoFulfillSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoFulfillSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res.mjs

@@ -149,6 +149,10 @@ function process(id, item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$1 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(AutoFulfillSpec);
@@ -160,6 +164,7 @@ let mappings = [
 
 let AutoFulfillAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$1,
   mappings: mappings
 };

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res

@@ -6,11 +6,13 @@ open OutboundTranslationSliceFixtures
 module SendTrackingEmailTranslation = {
   let collect = SendTrackingEmailSpec.collect
   let translate = SendTrackingEmailSpec.translate
+  let onExhausted = SendTrackingEmailSpec.onExhausted
   let moduleUrl = SendTrackingEmailSpec.moduleUrl
 }
 module ProcessPaymentTranslation = {
   let collect = ProcessPaymentSpec.collect
   let translate = ProcessPaymentSpec.translate
+  let onExhausted = ProcessPaymentSpec.onExhausted
   let moduleUrl = ProcessPaymentSpec.moduleUrl
 }
 module FireForgetCallback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
@@ -31,6 +33,8 @@ describe("OutboundTranslationSlice Callback", () => {
     // Reset the translate function to its default
     ProcessPaymentSpec.translateFn :=
       (async (id, _item) => Ok(Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id})))))
+    // Default is a slice with nothing to say when its budget runs out.
+    ProcessPaymentSpec.onExhaustedFn := ((_id, _item, _lastError) => None)
   })
 
   describe("Phase 1 — collect", () => {
@@ -157,11 +161,17 @@ describe("OutboundTranslationSlice Callback", () => {
       CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
       let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
 
-      // Fail twice
+      // Fail once — still retriable, and the status says so.
       await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Failed)
+
+      // The second failure spends the budget, and is marked at that moment rather
+      // than by falling out of the next pass's filter.
       await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
       let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
       expect(row.retryCount)->toBe(2)
+      expect(row.status)->toBe(Abandoned)
 
       // Third attempt should not be tried
       let publishedCommands = ref([])
@@ -173,6 +183,130 @@ describe("OutboundTranslationSlice Callback", () => {
       let row2 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
       // retryCount should still be 2 — not retried
       expect(row2.retryCount)->toBe(2)
+      expect(row2.status)->toBe(Abandoned)
+    })
+
+    // What an older build wrote, and what a Spec that lowers maxRetries leaves
+    // behind: Failed at the ceiling, a status promising a retry no pass will make.
+    testPromise("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
+
+      await CommandBackCallback.phase2(
+        async _cmds => (),
+        ~capabilities=Reventless.Capabilities.none,
+      )
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+    })
+
+    testPromise("the last error survives the transition to Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Abandoned)
+      expect(row.lastError)->toEqual(Some("gateway down"))
+    })
+
+    testPromise("the row carries the ceiling its count is racing", async () => {
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)
+      ->toEqual(Some(ProcessPaymentSpec.maxRetries))
+    })
+
+    // Abandonment is an outcome, and a slice that has one to report gets to say
+    // so — the row going quiet is otherwise the only trace.
+    testPromise("a slice that answers onExhausted has its command published", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let published = ref([])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+        published := Array.concat(published.contents, cmds)
+
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(published.contents->Array.length)->toBe(0) // still retriable
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+      expect(published.contents->Array.length)->toBe(1)
+      expect((published.contents->Array.getUnsafe(0)).id)->toBe("ord-1")
+      // The target's name, not the slice's — the same rule the success path follows.
+      expect((published.contents->Array.getUnsafe(0)).meta.service)->toBe("ConfirmPayment")
+    })
+
+    testPromise("the hook is handed the error that ended it", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      let seen = ref(None)
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((_id, _item, lastError) => {
+          seen := lastError
+          None
+        })
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(seen.contents)->toEqual(Some("gateway down"))
+    })
+
+    testPromise("a silent slice publishes nothing, and the row is still Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      // onExhaustedFn stays at its default None (reset in beforeEach).
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let published = ref([])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+        published := Array.concat(published.contents, cmds)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(published.contents->Array.length)->toBe(0)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+    })
+
+    // The budget is what ran out, so there is nothing left to retry with — a row
+    // must not fall back to Failed and re-enter the sweep on a publish error.
+    testPromise("a failed announcement leaves the row Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let failOnAbandonment: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
+        JsError.throwWithMessage("topic unavailable")
+      await CommandBackCallback.phase2(failOnAbandonment, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(failOnAbandonment, ~capabilities=Reventless.Capabilities.none)
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Abandoned)
+      expect(row.retryCount)->toBe(2)
+    })
+
+    // A row an older build stranded reaches the hook too — it is being abandoned
+    // now, as far as anything downstream is concerned.
+    testPromise("a stranded row announces when it is normalised", async () => {
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
+
+      let published = ref([])
+      await CommandBackCallback.phase2(
+        async cmds => published := cmds,
+        ~capabilities=Reventless.Capabilities.none,
+      )
+      expect(published.contents->Array.length)->toBe(1)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
     })
 
     testPromise("individual item failure does not affect other items", async () => {

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as OutboundTranslationSliceFixtures$ReventlessLocal from "./OutboundTranslationSliceFixtures.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
@@ -10,11 +11,14 @@ let collect = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmail
 
 let translate = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.translate;
 
+let onExhausted = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.onExhausted;
+
 let moduleUrl = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.moduleUrl;
 
 let SendTrackingEmailTranslation = {
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl
 };
 
@@ -22,11 +26,14 @@ let collect$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentS
 
 let translate$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translate;
 
+let onExhausted$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhausted;
+
 let moduleUrl$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.moduleUrl;
 
 let ProcessPaymentTranslation = {
   collect: collect$1,
   translate: translate$1,
+  onExhausted: onExhausted$1,
   moduleUrl: moduleUrl$1
 };
 
@@ -70,6 +77,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         }
       ]
     });
+    OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (_id, _item, _lastError) => {};
   });
   globalThis.describe("Phase 1 — collect", () => {
     globalThis.test("OrderShipped event creates a pending outbound item", async () => {
@@ -276,9 +284,11 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         ]]);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Failed");
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       globalThis.expect(row.retryCount).toBe(2);
+      globalThis.expect(row.status).toBe("Abandoned");
       let publishedCommands = {
         contents: []
       };
@@ -289,6 +299,198 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(publishedCommands.contents.length).toBe(0);
       let row2 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       globalThis.expect(row2.retryCount).toBe(2);
+      globalThis.expect(row2.status).toBe("Abandoned");
+    });
+    globalThis.test("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "timeout"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 2;
+      newrecord.status = "Failed";
+      CommandBackCallback.todoItems["ord-1"] = newrecord;
+      await CommandBackCallback.phase2(async _cmds => {}, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+    });
+    globalThis.test("the last error survives the transition to Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let publish = async _cmds => {};
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Abandoned");
+      globalThis.expect(row.lastError).toEqual("gateway down");
+    });
+    globalThis.test("the row carries the ceiling its count is racing", async () => {
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).maxRetries).toEqual(OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries);
+    });
+    globalThis.test("a slice that answers onExhausted has its command published", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let published = {
+        contents: []
+      };
+      let publish = async cmds => {
+        published.contents = published.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(0);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+      globalThis.expect(published.contents.length).toBe(1);
+      globalThis.expect(published.contents[0].id).toBe("ord-1");
+      globalThis.expect(published.contents[0].meta.service).toBe("ConfirmPayment");
+    });
+    globalThis.test("the hook is handed the error that ended it", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      let seen = {
+        contents: undefined
+      };
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (_id, _item, lastError) => {
+        seen.contents = lastError;
+      };
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let publish = async _cmds => {};
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(seen.contents).toEqual("gateway down");
+    });
+    globalThis.test("a silent slice publishes nothing, and the row is still Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let published = {
+        contents: []
+      };
+      let publish = async cmds => {
+        published.contents = published.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+    });
+    globalThis.test("a failed announcement leaves the row Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let failOnAbandonment = async _cmds => Stdlib_JsError.throwWithMessage("topic unavailable");
+      await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Abandoned");
+      globalThis.expect(row.retryCount).toBe(2);
+    });
+    globalThis.test("a stranded row announces when it is normalised", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 2;
+      newrecord.status = "Failed";
+      CommandBackCallback.todoItems["ord-1"] = newrecord;
+      let published = {
+        contents: []
+      };
+      await CommandBackCallback.phase2(async cmds => {
+        published.contents = cmds;
+      }, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(1);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
     });
     globalThis.test("individual item failure does not affect other items", async () => {
       let callCount = {

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res

@@ -36,6 +36,7 @@ module SendTrackingEmailSpec = {
     }
 
   let translate = async (_id, _item, ~capabilities as _) => Ok(None)
+  let onExhausted = (_id, _item, ~lastError as _) => None
 
   let maxRetries = 3
   let heartbeatInterval = 60
@@ -77,6 +78,13 @@ module ProcessPaymentSpec = {
   // one restate a type it does not use.
   let translate = (id, item, ~capabilities as _) => translateFn.contents(id, item)
 
+  // Overridable like `translateFn`, so a test can assert both answers a slice may
+  // give when its budget runs out: say nothing, or tell the domain.
+  let onExhaustedFn: ref<(string, outboundItem, option<string>) => option<(string, inboundCommand)>> = ref(
+    (_id, _item, _lastError) => None
+  )
+  let onExhausted = (id, item, ~lastError) => onExhaustedFn.contents(id, item, lastError)
+
   let maxRetries = 2
   let heartbeatInterval = 30
   let targetName = Some("ConfirmPayment")

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res.mjs

@@ -56,6 +56,10 @@ async function translate(_id, _item, param) {
   };
 }
 
+function onExhausted(_id, _item, param) {
+  
+}
+
 let sourceNames = [];
 
 let SendTrackingEmailSpec = {
@@ -66,6 +70,7 @@ let SendTrackingEmailSpec = {
   inboundCommandSchema: inboundCommandSchema,
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: undefined,
@@ -119,6 +124,14 @@ function translate$1(id, item, param) {
   return translateFn.contents(id, item);
 }
 
+let onExhaustedFn = {
+  contents: (_id, _item, _lastError) => {}
+};
+
+function onExhausted$1(id, item, lastError) {
+  return onExhaustedFn.contents(id, item, lastError);
+}
+
 let sourceNames$1 = [];
 
 let ProcessPaymentSpec_targetName = "ConfirmPayment";
@@ -132,6 +145,8 @@ let ProcessPaymentSpec = {
   collect: collect$1,
   translateFn: translateFn,
   translate: translate$1,
+  onExhaustedFn: onExhaustedFn,
+  onExhausted: onExhausted$1,
   maxRetries: 2,
   heartbeatInterval: 30,
   targetName: ProcessPaymentSpec_targetName,

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res

@@ -111,6 +111,8 @@ module SendConfirmTranslation: OutboundTranslationSlice.Translation
     externalCalls->Array.push(item.orderId)
     Ok(None)
   }
+
+  let onExhausted = (_id, _item: SendConfirmSpec.outboundItem, ~lastError as _) => None
 }
 
 // ─────────────────────────────────────────────────────────────

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res.mjs

@@ -141,9 +141,14 @@ async function translate(_id, item, param) {
   };
 }
 
+function onExhausted(_id, _item, param) {
+  
+}
+
 let SendConfirmTranslation = {
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$3
 };