@reventlessdev/reventless-aws 3.0.0-alpha.417 → 3.0.0-alpha.419

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.419 (2026-11-01)
+
+### Features
+
+* **core:** a command's outcome, the flow through automations, and each view change are told ([dcaeed2](https://github.com/ReventlessDev/reventless-core/commit/dcaeed2fabe2047a21797b459f2931618474dec3))
+
+
+# 3.0.0-alpha.418 (2026-11-01)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
 # 3.0.0-alpha.417 (2026-10-30)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.417",
+  "version": "3.0.0-alpha.419",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -22,19 +22,19 @@
     "sury": "11.0.0",
     "uuid": "^13.0.0",
     "yaml": "^2.8.3",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.38",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.37",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.37",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.38",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
     "@reventlessdev/rescript-web": "1.0.0-alpha.8",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.220",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.326",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.325",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.189",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.191"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.190",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.221",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.192"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/adapter/Runtime/AggregateEntryPoint.mjs

@@ -137,12 +137,22 @@ async function checkPluginStatus(event) {
 // Postgres EventLog runtime; absence keeps the DynamoDB path byte-identical.
 // `eventLogTableName` doubles as the Postgres `event_log.log_name` discriminator
 // (all aggregates share one Postgres table, unlike DynamoDB's table-per-aggregate).
-function buildAggregateParts(specModule, decisionModule, eventLogTableName, queueUrl, pgConnection) {
+// Exported for tests, which pass `makeStorage` to stand an in-memory storage in for
+// DynamoDB and drive the functor wiring below exactly as a deployed handler does
+// (tests/AggregateEntryPoint_WiringTest.res).
+export function buildAggregateParts(
+  specModule,
+  decisionModule,
+  eventLogTableName,
+  queueUrl,
+  pgConnection,
+  makeStorage = makeStorageOps,
+) {
   const patchedSpec = patchSpecId(specModule);
   // Typed core: backend-specific EventLog storage ops (Postgres when pgConnection
   // is present, else DynamoDB). Returns the full 6-field EventLog_Adapter.operations
   // — the shell previously dropped latestSnapshot/writeSnapshot.
-  const rawStorageOps = makeStorageOps(eventLogTableName, pgConnection);
+  const rawStorageOps = makeStorage(eventLogTableName, pgConnection);
   const eventLogOps = eventLogOperationsMake(patchedSpec)({
     Spec: patchedSpec,
     EventTopic: { Spec: patchedSpec },

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -539,7 +539,7 @@ let makeOutboundJsonEventsHandler = (
           ->Option.getOr("")
         let (eventType, dataDict) = rawEvent->ReventlessCore.Message.splitMessage
         switch decoder.decode(~eventType, ~data=dataDict) {
-        | Some(event) => [(sourceId, event)]
+        | Some(event) => [(sourceId, event, ReventlessCore.Message.metaOfEnvelope(envelope))]
         | None => []
         }
       })
@@ -549,7 +549,11 @@ let makeOutboundJsonEventsHandler = (
     ->Effect.flatMap(events =>
       Effect.promise(async () => {
         await loadTodoItems()
-        await callback.phase1(events, ~capabilities=capabilities())
+        await callback.phase1(
+          events->Array.map(((sourceId, event, _)) => (sourceId, event)),
+          ~metas=events->Array.map(((_, _, meta)) => meta),
+          ~capabilities=capabilities(),
+        )
         await syncTodoItems()
         await callback.phase2(publishJsons, ~capabilities=capabilities())
         await syncTodoItems()

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res.mjs

@@ -323,14 +323,18 @@ function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJso
     if (event !== undefined) {
       return [[
           sourceId,
-          Primitive_option.valFromOption(event)
+          Primitive_option.valFromOption(event),
+          Message$ReventlessCore.metaOfEnvelope(envelope)
         ]];
     } else {
       return [];
     }
   })), events => Stream$1.fromIterable(events))), events => Effect.promise(async () => {
     await loadTodoItems();
-    await callback.phase1(events, capabilities());
+    await callback.phase1(events.map(param => [
+      param[0],
+      param[1]
+    ]), events.map(param => param[2]), capabilities());
     await syncTodoItems();
     await callback.phase2(publishJsons, capabilities());
     return await syncTodoItems();

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -126,6 +126,20 @@ let decodeEnvelope = (json: JSON.t): envelope<'event> => {
 
 let exnMessage = StreamRoutedEntryPoint_Ops.exnMessage
 
+// The event an envelope carries, as the source of the rows its actions change.
+// Read off the JSON, like `producerTime`: an envelope without a meta yields none.
+let sourcesOf = (json: JSON.t): array<ReventlessCore.Projection.changeSource> => {
+  let fields = json->JSON.Decode.object->Option.getOr(Dict.make())
+  let meta = fields->Dict.get("meta")->Option.flatMap(JSON.Decode.object)
+  let string = (d, k) => d->Option.flatMap(d => d->Dict.get(k))->Option.flatMap(JSON.Decode.string)
+  switch string(meta, "msgId") {
+  | Some(msgId) =>
+    let (entityId, entityType) = ReventlessCore.ViewChange.entityOfEnvelope(fields)
+    [{msgId, correlationId: ?string(meta, "correlationId"), ?entityId, ?entityType}]
+  | None => []
+  }
+}
+
 // The typed core of buildJsonEventsHandler: decode each envelope, parse the
 // event against the slice's consumed-event schema, project, and run every
 // resulting action against the view table. A decode failure logs and yields no
@@ -140,7 +154,13 @@ let makeJsonEventsHandler = (
   ~queryDbOps: ReventlessCore.QueryDb_Adapter.operations,
   ~subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
   ~stateSchema: option<S.t<unknown>>,
-): ReventlessCore.EventCollector.jsonEventsHandler =>
+): ReventlessCore.EventCollector.jsonEventsHandler => {
+  // Each row the events change is logged; the states are already JSON.
+  let onChange = ReventlessCore.ViewChange.reporter(
+    ~comp=sliceName,
+    ~view=sliceName,
+    ~stateToJson=state => state,
+  )
   stream =>
     stream
     ->Stream.mapEffect(json =>
@@ -155,11 +175,14 @@ let makeJsonEventsHandler = (
           // The deployed slice assembles JSON-level operations rather than going
           // through the typed rewrite, so the trail is appended here — with this
           // envelope's own time, which the apply below no longer has.
-          producerTime === ""
-            ? actions
-            : actions->Array.map(
-                ReventlessCore.Projection.rewriteJsonAction(_, ~at=producerTime, ~stateSchema),
-              )
+          let sources = sourcesOf(json)
+          let actions =
+            producerTime === ""
+              ? actions
+              : actions->Array.map(
+                  ReventlessCore.Projection.rewriteJsonAction(_, ~at=producerTime, ~stateSchema),
+                )
+          actions->Array.map(action => (action, sources))
         } catch {
         | exn =>
           StreamRoutedEntryPoint_Ops.logError(
@@ -171,7 +194,7 @@ let makeJsonEventsHandler = (
       )
     )
     ->Stream.flatMap(actions => Stream.fromIterable(actions))
-    ->Stream.runForEach(action =>
+    ->Stream.runForEach(((action, sources)) =>
       // Thread the slice's `subIdConfig` (generated from `@subId`) so
       // sub-id-dependent actions like `UpdateMultiState` can resolve the sort
       // key. Dropping it here made every such action hit the
@@ -181,9 +204,17 @@ let makeJsonEventsHandler = (
       // actions. `~comp` is the slice's spec name — attribution for
       // Projection.handleAction's debug-lazy action log.
       Effect.promise(() =>
-        ReventlessCore.Projection.handleAction(~comp=sliceName, action, queryDbOps, subIdConfig)
+        ReventlessCore.Projection.handleAction(
+          ~comp=sliceName,
+          ~sources,
+          ~onChange,
+          action,
+          queryDbOps,
+          subIdConfig,
+        )
       )->Effect.map(_ => ())
     )
+}
 
 // ── Handler assembly (called by the shell per HANDLER_CONFIG entry) ─────────
 // `sliceModules` types the shell's reads off the two dynamically imported

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs

@@ -8,6 +8,7 @@ import * as Stream from "effect/Stream";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Projection$ReventlessCore from "@reventlessdev/reventless-core/src/Projection.res.mjs";
+import * as ViewChange$ReventlessCore from "@reventlessdev/reventless-core/src/ViewChange.res.mjs";
 import * as ProjectionEntryPoint_Ops$ReventlessAws from "./ProjectionEntryPoint_Ops.res.mjs";
 import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
 
@@ -64,7 +65,25 @@ function decodeEnvelope(json) {
   };
 }
 
+function sourcesOf(json) {
+  let fields = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(json), {});
+  let meta = Stdlib_Option.flatMap(fields["meta"], Stdlib_JSON.Decode.object);
+  let string = (d, k) => Stdlib_Option.flatMap(Stdlib_Option.flatMap(d, d => d[k]), Stdlib_JSON.Decode.string);
+  let msgId = string(meta, "msgId");
+  if (msgId === undefined) {
+    return [];
+  }
+  let match = ViewChange$ReventlessCore.entityOfEnvelope(fields);
+  return [{
+      msgId: msgId,
+      correlationId: string(meta, "correlationId"),
+      entityId: match[0],
+      entityType: match[1]
+    }];
+}
+
 function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subIdConfig, stateSchema) {
+  let onChange = ViewChange$ReventlessCore.reporter(sliceName, sliceName, state => state);
   return stream => Stream.runForEach(Stream.flatMap(Stream.mapEffect(stream, json => Effect.sync(() => {
     try {
       let match = decodeEnvelope(json);
@@ -74,11 +93,12 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
         meta: match.meta,
         recordedAt: match.recordedAt
       });
-      if (producerTime === "") {
-        return actions;
-      } else {
-        return actions.map(__x => Projection$ReventlessCore.rewriteJsonAction(__x, producerTime, stateSchema));
-      }
+      let sources = sourcesOf(json);
+      let actions$1 = producerTime === "" ? actions : actions.map(__x => Projection$ReventlessCore.rewriteJsonAction(__x, producerTime, stateSchema));
+      return actions$1.map(action => [
+        action,
+        sources
+      ]);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       StreamRoutedEntryPoint_Ops$ReventlessAws.logError("failed to decode event", {
@@ -87,7 +107,11 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
       });
       return [];
     }
-  })), actions => Stream.fromIterable(actions)), action => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(sliceName, action, queryDbOps, subIdConfig)), param => {}));
+  })), actions => Stream.fromIterable(actions)), param => {
+    let sources = param[1];
+    let action = param[0];
+    return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(sliceName, sources, onChange, action, queryDbOps, subIdConfig)), param => {});
+  });
 }
 
 function makeRegisteredHandler(entry, modules) {
@@ -106,6 +130,7 @@ export {
   parseHandlerConfig,
   decodeEnvelope,
   exnMessage,
+  sourcesOf,
   makeJsonEventsHandler,
   makeRegisteredHandler,
 }

package/tests/AggregateEntryPoint_WiringTest.res

@@ -0,0 +1,124 @@
+// The deployed aggregate handler, wired exactly as `AggregateEntryPoint.mjs` wires it,
+// over an in-memory storage in place of DynamoDB.
+//
+// The shell is hand-written JS that passes the compiled EventLog operations MODULE
+// where the aggregate callback expects the `EventLog.operations` RECORD, so a field
+// the record has and the module does not export under the same name type-checks
+// everywhere and fails only in a Lambda. That is how a primed field
+// (`replayStream'`, exported as `replayStream$p`) took down every command of the
+// platform's Plugin aggregate on AWS while every in-process test passed. The
+// command that broke was a derived one — it carries the stable-id header, which
+// sends the handler down the cause-reading replay — so that is the command sent
+// here, its redelivery, and a plain command, which between them reach every
+// operation the aggregate callback reads.
+
+open JestGlobals
+
+module Spec = AggTestAggregate
+
+// ── An in-memory storage, typed by the contract the shell's storage satisfies ──
+
+let stored: dict<array<JSON.t>> = Dict.make()
+
+let storage: ReventlessCore.EventLog_Adapter.operations = {
+  append: async (seq, id, events) => {
+    let current = stored->Dict.get(id)->Option.getOr([])
+    if current->Array.length != seq {
+      Error(ReventlessCore.EventLog.Conflict)
+    } else {
+      stored->Dict.set(id, current->Array.concat(events))
+      Ok()
+    }
+  },
+  replay: async id => stored->Dict.get(id)->Option.getOr([]),
+  replayStream: (id, ~fromSeq=0) =>
+    Stream.fromIterable(stored->Dict.get(id)->Option.getOr([])->Array.slice(~start=fromSeq)),
+  appendStream: (_, _, _) => Effect.succeed(),
+  latestSnapshot: async _ => Ok(None),
+  writeSnapshot: async (_, _) => Ok(),
+}
+
+// ── The shell's own wiring ────────────────────────────────────────────────────
+
+type parts = {handleJsonCommands: ReventlessCore.CommandTopic_Helpers.jsonCommandsHandler}
+
+let buildParts: ReventlessCore.EventLog_Adapter.operations => promise<parts> = %raw(`
+  async (storage) => {
+    const { buildAggregateParts } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs"
+    );
+    const spec = await import("./integration/AggTestAggregate.res.mjs");
+    const decision = await import("./integration/AggTestAggregateDecision.res.mjs");
+    return buildAggregateParts(
+      spec,
+      decision,
+      "agg-wiring-test",
+      "https://sqs.eu-west-1.amazonaws.com/000000000000/agg-wiring-test",
+      undefined,
+      () => storage,
+    );
+  }
+`)
+
+/** A command a mapping derived: its id is stable across redeliveries, and the
+    header says so. */
+let derived = (~id, ~msgId, name): JSON.t => {
+  let meta: Reventless.Message.meta = {
+    service: "AggWiringTest",
+    time: "2026-11-01T00:00:00.000Z",
+    msgId,
+    correlationId: msgId,
+    headers: Dict.fromArray([(ReventlessInfra.Message.stableIdHeader, "true")]),
+  }
+  ReventlessCore.Message.encodeCommand'(
+    {
+      Reventless.Message.id: Reventless.Id.String.makeFromString(id),
+      meta,
+      command: Spec.Add({name: name}),
+    },
+    Reventless.Id.String.schema,
+    Spec.commandSchema,
+  )
+}
+
+let send = async (parts: parts, json) =>
+  await parts.handleJsonCommands(
+    Stream.fromIterable([{ReventlessInfra.CommandTopic.reference: "r", command: json}]),
+  )->Effect.runPromise
+
+describe("the deployed aggregate handler's wiring", () => {
+  beforeEach(() => stored->Dict.keysToArray->Array.forEach(k => stored->Dict.delete(k)))
+
+  testPromise("handles a derived command, which replays its stream with causes", async () => {
+    let parts = await buildParts(storage)
+    let results = await send(parts, derived(~id="a-1", ~msgId="m-1", "first"))
+    expect(results->Array.every(Result.isOk))->toBe(true)
+    expect(stored->Dict.get("a-1")->Option.map(Array.length))->toEqual(Some(1))
+  })
+
+  testPromise("appends nothing for a redelivery of a derived command", async () => {
+    let parts = await buildParts(storage)
+    let _ = await send(parts, derived(~id="a-2", ~msgId="m-2", "first"))
+    let again = await send(parts, derived(~id="a-2", ~msgId="m-2", "first"))
+    expect(again->Array.every(Result.isOk))->toBe(true)
+    expect(stored->Dict.get("a-2")->Option.map(Array.length))->toEqual(Some(1))
+  })
+
+  // An API command: no stable id, so the handler seeds from the snapshot read and
+  // replays events alone — the other operations the shell's module must carry.
+  testPromise("handles a command with a fresh id after a derived one", async () => {
+    let parts = await buildParts(storage)
+    let _ = await send(parts, derived(~id="a-3", ~msgId="m-3", "first"))
+    let fresh = derived(~id="a-3", ~msgId="m-4", "second")
+    switch fresh {
+    | Object(d) =>
+      d
+      ->Dict.get("meta")
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.forEach(meta => meta->Dict.delete("headers"))
+    | _ => ()
+    }
+    let results = await send(parts, fresh)
+    expect(results->Array.every(Result.isOk))->toBe(true)
+  })
+})

package/tests/AggregateEntryPoint_WiringTest.res.mjs

@@ -0,0 +1,152 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Message$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/Message.res.mjs";
+import * as AggTestAggregate$ReventlessAws from "./integration/AggTestAggregate.res.mjs";
+
+let stored = {};
+
+async function storage_append(seq, id, events) {
+  let current = Stdlib_Option.getOr(stored[id], []);
+  if (current.length !== seq) {
+    return {
+      TAG: "Error",
+      _0: "Conflict"
+    };
+  } else {
+    stored[id] = current.concat(events);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function storage_replay(id) {
+  return Stdlib_Option.getOr(stored[id], []);
+}
+
+function storage_replayStream(id, fromSeqOpt) {
+  let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+  return Stream.fromIterable(Stdlib_Option.getOr(stored[id], []).slice(fromSeq));
+}
+
+function storage_appendStream(param, param$1, param$2) {
+  return Effect.succeed();
+}
+
+async function storage_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function storage_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let storage = {
+  append: storage_append,
+  replay: storage_replay,
+  replayStream: storage_replayStream,
+  appendStream: storage_appendStream,
+  latestSnapshot: storage_latestSnapshot,
+  writeSnapshot: storage_writeSnapshot
+};
+
+let buildParts = (async (storage) => {
+    const { buildAggregateParts } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs"
+    );
+    const spec = await import("./integration/AggTestAggregate.res.mjs");
+    const decision = await import("./integration/AggTestAggregateDecision.res.mjs");
+    return buildAggregateParts(
+      spec,
+      decision,
+      "agg-wiring-test",
+      "https://sqs.eu-west-1.amazonaws.com/000000000000/agg-wiring-test",
+      undefined,
+      () => storage,
+    );
+  });
+
+function derived(id, msgId, name) {
+  let meta_headers = Object.fromEntries([[
+      Message$ReventlessInfra.stableIdHeader,
+      "true"
+    ]]);
+  let meta = {
+    service: "AggWiringTest",
+    time: "2026-11-01T00:00:00.000Z",
+    msgId: msgId,
+    correlationId: msgId,
+    headers: meta_headers
+  };
+  return Message$ReventlessCore.encodeCommand$p({
+    id: Id$Reventless.$$String.makeFromString(id),
+    meta: meta,
+    command: {
+      TAG: "Add",
+      name: name
+    }
+  }, Id$Reventless.$$String.schema, AggTestAggregate$ReventlessAws.commandSchema);
+}
+
+async function send(parts, json) {
+  return await Effect.runPromise(parts.handleJsonCommands(Stream.fromIterable([{
+      command: json,
+      reference: "r"
+    }])));
+}
+
+globalThis.describe("the deployed aggregate handler's wiring", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(stored).forEach(k => Stdlib_Dict.$$delete(stored, k));
+  });
+  globalThis.test("handles a derived command, which replays its stream with causes", async () => {
+    let parts = await buildParts(storage);
+    let results = await send(parts, derived("a-1", "m-1", "first"));
+    globalThis.expect(results.every(Stdlib_Result.isOk)).toBe(true);
+    globalThis.expect(Stdlib_Option.map(stored["a-1"], prim => prim.length)).toEqual(1);
+  });
+  globalThis.test("appends nothing for a redelivery of a derived command", async () => {
+    let parts = await buildParts(storage);
+    await send(parts, derived("a-2", "m-2", "first"));
+    let again = await send(parts, derived("a-2", "m-2", "first"));
+    globalThis.expect(again.every(Stdlib_Result.isOk)).toBe(true);
+    globalThis.expect(Stdlib_Option.map(stored["a-2"], prim => prim.length)).toEqual(1);
+  });
+  globalThis.test("handles a command with a fresh id after a derived one", async () => {
+    let parts = await buildParts(storage);
+    await send(parts, derived("a-3", "m-3", "first"));
+    let fresh = derived("a-3", "m-4", "second");
+    if (typeof fresh === "object" && fresh !== null && !Array.isArray(fresh)) {
+      Stdlib_Option.forEach(Stdlib_Option.flatMap(fresh["meta"], Stdlib_JSON.Decode.object), meta => Stdlib_Dict.$$delete(meta, "headers"));
+    }
+    let results = await send(parts, fresh);
+    globalThis.expect(results.every(Stdlib_Result.isOk)).toBe(true);
+  });
+});
+
+let Spec;
+
+export {
+  Spec,
+  stored,
+  storage,
+  buildParts,
+  derived,
+  send,
+}
+/* buildParts Not a pure module */

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -388,7 +388,7 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
     let received = ref([])
     let callback: AutomationSliceEntryPoint_Ops.outboundCallback<outboundEvent> = {
       todoItems: Dict.make(),
-      phase1: async (events, ~capabilities as _) => {
+      phase1: async (events, ~metas as _=?, ~capabilities as _) => {
         received := events
         steps->Array.push("phase1")
       },

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -581,7 +581,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       contents: []
     };
     let callback_todoItems = {};
-    let callback_phase1 = async (events, param) => {
+    let callback_phase1 = async (events, param, param$1) => {
       received.contents = events;
       steps.push("phase1");
     };