@reventlessdev/reventless-core 3.0.0-alpha.214 → 3.0.0-alpha.216

package/tests/adapter/RuntimeExtensionTest.res

@@ -0,0 +1,127 @@
+open JestGlobals
+
+type call = {
+  runtimeKind: ComponentType.t,
+  component: string,
+  plugin: option<string>,
+  platform: option<string>,
+}
+
+let recorderNamed = (label: string, into: array<(string, call)>): module(
+  RuntimeExtension.Extension
+) => {
+  module R = {
+    let moduleUrl = `file:///pkg/${label}.res.mjs`
+    let onColdStart = (~runtimeKind, ~component, ~plugin, ~platform) =>
+      into->Array.push((label, {runtimeKind, component, plugin, platform}))
+  }
+  module(R: RuntimeExtension.Extension)
+}
+
+let fireAggregate = () =>
+  RuntimeExtension.notifyColdStart(
+    ~runtimeKind=ComponentType.Aggregate,
+    ~component="AllAggregatesCmdHandler",
+    ~plugin=Some("Catalog"),
+    ~platform=Some("Shop"),
+  )
+
+describe("RuntimeExtension", () => {
+  beforeEach(() => RuntimeExtension.reset())
+
+  testSync("empty registry is the default and notifyColdStart is silent", () => {
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(RuntimeExtension.moduleUrls())->toEqual([])
+    fireAggregate()
+    expect(true)->toBe(true)
+  })
+
+  testSync("a registered extension receives the runtime's full identity", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+
+    fireAggregate()
+
+    expect(calls)->toEqual([
+      (
+        "tracing",
+        {
+          runtimeKind: ComponentType.Aggregate,
+          component: "AllAggregatesCmdHandler",
+          plugin: Some("Catalog"),
+          platform: Some("Shop"),
+        },
+      ),
+    ])
+  })
+
+  testSync("several extensions compose, in registration order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["tracing", "accounting"])
+  })
+
+  testSync("moduleUrls reports every registration, in order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    expect(RuntimeExtension.isEmpty())->toBe(false)
+    expect(RuntimeExtension.moduleUrls())->toEqual([
+      "file:///pkg/tracing.res.mjs",
+      "file:///pkg/accounting.res.mjs",
+    ])
+  })
+
+  testSync("a throwing extension is skipped; the runtime and its siblings survive", () => {
+    let calls: array<(string, call)> = []
+    module Broken: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/broken.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+        JsError.throwWithMessage("extension blew up")
+    }
+    RuntimeExtension.use(module(Broken: RuntimeExtension.Extension))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    // Fails the test if the seam propagates: the acceptance criterion is that a
+    // broken extension does not take the runtime down.
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["accounting"])
+  })
+
+  testSync("notifyColdStartHooks fires loose hooks — the deployed runtime's path", () => {
+    // A deployed entry point holds hooks lifted off dynamically imported
+    // modules, not first-class modules, so it never populates this process's
+    // registry. Same isolation and ordering apply.
+    let seen: array<string> = []
+    let hook = (label): RuntimeExtension.coldStartHook =>
+      (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) =>
+        seen->Array.push(`${label}:${component}`)
+
+    RuntimeExtension.notifyColdStartHooks(
+      ~hooks=[hook("a"), hook("b")],
+      ~runtimeKind=ComponentType.ReadModel,
+      ~component="AllReadModels",
+      ~plugin=None,
+      ~platform=None,
+    )
+
+    expect(seen)->toEqual(["a:AllReadModels", "b:AllReadModels"])
+  })
+
+  testSync("reset clears the registry", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.reset()
+
+    fireAggregate()
+
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(calls)->toEqual([])
+  })
+})

package/tests/adapter/RuntimeExtensionTest.res.mjs

@@ -0,0 +1,111 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+
+function recorderNamed(label, into) {
+  let moduleUrl = `file:///pkg/` + label + `.res.mjs`;
+  let onColdStart = (runtimeKind, component, plugin, platform) => {
+    into.push([
+      label,
+      {
+        runtimeKind: runtimeKind,
+        component: component,
+        plugin: plugin,
+        platform: platform
+      }
+    ]);
+  };
+  return {
+    moduleUrl: moduleUrl,
+    onColdStart: onColdStart
+  };
+}
+
+function fireAggregate() {
+  RuntimeExtension$ReventlessCore.notifyColdStart("Aggregate", "AllAggregatesCmdHandler", "Catalog", "Shop");
+}
+
+globalThis.describe("RuntimeExtension", () => {
+  globalThis.beforeEach(() => RuntimeExtension$ReventlessCore.reset());
+  globalThis.test("empty registry is the default and notifyColdStart is silent", () => {
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(true);
+    globalThis.expect(RuntimeExtension$ReventlessCore.moduleUrls()).toEqual([]);
+    fireAggregate();
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("a registered extension receives the runtime's full identity", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    fireAggregate();
+    globalThis.expect(calls).toEqual([[
+        "tracing",
+        {
+          runtimeKind: "Aggregate",
+          component: "AllAggregatesCmdHandler",
+          plugin: "Catalog",
+          platform: "Shop"
+        }
+      ]]);
+  });
+  globalThis.test("several extensions compose, in registration order", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    fireAggregate();
+    globalThis.expect(calls.map(param => param[0])).toEqual([
+      "tracing",
+      "accounting"
+    ]);
+  });
+  globalThis.test("moduleUrls reports every registration, in order", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(false);
+    globalThis.expect(RuntimeExtension$ReventlessCore.moduleUrls()).toEqual([
+      "file:///pkg/tracing.res.mjs",
+      "file:///pkg/accounting.res.mjs"
+    ]);
+  });
+  globalThis.test("a throwing extension is skipped; the runtime and its siblings survive", () => {
+    let calls = [];
+    let onColdStart = (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("extension blew up");
+    let Broken = {
+      moduleUrl: "file:///pkg/broken.res.mjs",
+      onColdStart: onColdStart
+    };
+    RuntimeExtension$ReventlessCore.use(Broken);
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    fireAggregate();
+    globalThis.expect(calls.map(param => param[0])).toEqual(["accounting"]);
+  });
+  globalThis.test("notifyColdStartHooks fires loose hooks — the deployed runtime's path", () => {
+    let seen = [];
+    let hook = label => ((param, component, param$1, param$2) => {
+      seen.push(label + `:` + component);
+    });
+    RuntimeExtension$ReventlessCore.notifyColdStartHooks([
+      hook("a"),
+      hook("b")
+    ], "ReadModel", "AllReadModels", undefined, undefined);
+    globalThis.expect(seen).toEqual([
+      "a:AllReadModels",
+      "b:AllReadModels"
+    ]);
+  });
+  globalThis.test("reset clears the registry", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.reset();
+    fireAggregate();
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(true);
+    globalThis.expect(calls).toEqual([]);
+  });
+});
+
+export {
+  recorderNamed,
+  fireAggregate,
+}
+/*  Not a pure module */

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -41,6 +41,7 @@ let wbl: writableDef = {
   producedEventTypes: ["ProductAdded"],
   consumedEventTypes: [],
   events: [{name: "ProductAdded", schema: "{}", references: []}],
+  errors: [{name: "ProductAlreadyExists", schema: "{}", references: []}],
   chapter: None,
 }
 
@@ -162,6 +163,17 @@ describe("encodePluginStructureEntry", () => {
     expect(json->String.includes("\"events\":[{\"name\":\"ProductAdded\""))->toEqual(true)
   )
 
+  // The refusals a caller has to handle travel beside the facts it can observe.
+  testSync("encodes writableDef errors", () =>
+    expect(json->String.includes("\"errors\":[{\"name\":\"ProductAlreadyExists\""))->toEqual(true)
+  )
+
+  testSync("declares Platform_ErrorDef and the errors field in the shared write-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi.sdlTypes->Array.join("\n")
+    expect(sdl->String.includes("type Platform_ErrorDef"))->toEqual(true)
+    expect(sdl->String.includes("errors: [Platform_ErrorDef!]!"))->toEqual(true)
+  })
+
   // Translation-slice externalSystem: absent on the fixture above (both None), so it
   // must serialize as null — the "no external box" case. The leading field keeps the
   // two directions apart; `targetName` sits between them and is pinned here too.
@@ -292,6 +304,7 @@ describe("allowedStates + statusField populated", () => {
     producedEventTypes: [],
     consumedEventTypes: [],
     events: [],
+    errors: [],
     chapter: None,
   }
 
@@ -325,4 +338,12 @@ describe("allowedStates + statusField populated", () => {
   testSync("encodes populated statusField as the field name string", () =>
     expect(json->String.includes("\"statusField\":\"status\""))->toEqual(true)
   )
+
+  // "declares no errors" is an empty list, never null — the SDL types `errors` as
+  // non-null, and a structure is re-derived on every build, so there is no third
+  // "cannot say" state to encode.
+  testSync("encodes a component with no declared errors as an empty array, not null", () => {
+    expect(json->String.includes("\"errors\":[]"))->toEqual(true)
+    expect(json->String.includes("\"errors\":null"))->toEqual(false)
+  })
 })

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -61,6 +61,12 @@ let wbl_events = [{
     references: []
   }];
 
+let wbl_errors = [{
+    name: "ProductAlreadyExists",
+    schema: "{}",
+    references: []
+  }];
+
 let wbl = {
   name: "Product",
   commands: wbl_commands,
@@ -69,6 +75,7 @@ let wbl = {
   linkedViews: wbl_linkedViews,
   consistencyRead: undefined,
   events: wbl_events,
+  errors: wbl_errors,
   chapter: undefined
 };
 
@@ -182,6 +189,14 @@ globalThis.describe("encodePluginStructureEntry", () => {
   globalThis.test("encodes writableDef events", () => {
     globalThis.expect(json.includes("\"events\":[{\"name\":\"ProductAdded\"")).toEqual(true);
   });
+  globalThis.test("encodes writableDef errors", () => {
+    globalThis.expect(json.includes("\"errors\":[{\"name\":\"ProductAlreadyExists\"")).toEqual(true);
+  });
+  globalThis.test("declares Platform_ErrorDef and the errors field in the shared write-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes.join("\n");
+    globalThis.expect(sdl.includes("type Platform_ErrorDef")).toEqual(true);
+    globalThis.expect(sdl.includes("errors: [Platform_ErrorDef!]!")).toEqual(true);
+  });
   globalThis.test("encodes None outbound externalSystem as null", () => {
     globalThis.expect(json.includes("\"inboundCommandTypes\":[\"Ship\"],\"targetName\":null,\"externalSystem\":null")).toEqual(true);
   });
@@ -326,6 +341,7 @@ globalThis.describe("allowedStates + statusField populated", () => {
   let wblWithStates_consumedEventTypes = [];
   let wblWithStates_linkedViews = ["Plugin"];
   let wblWithStates_events = [];
+  let wblWithStates_errors = [];
   let wblWithStates = {
     name: "Plugin",
     commands: wblWithStates_commands,
@@ -334,6 +350,7 @@ globalThis.describe("allowedStates + statusField populated", () => {
     linkedViews: wblWithStates_linkedViews,
     consistencyRead: undefined,
     events: wblWithStates_events,
+    errors: wblWithStates_errors,
     chapter: undefined
   };
   let structureWithStates_readModels = [qblWithStatus];
@@ -367,6 +384,10 @@ globalThis.describe("allowedStates + statusField populated", () => {
   globalThis.test("encodes populated statusField as the field name string", () => {
     globalThis.expect(json.includes("\"statusField\":\"status\"")).toEqual(true);
   });
+  globalThis.test("encodes a component with no declared errors as an empty array, not null", () => {
+    globalThis.expect(json.includes("\"errors\":[]")).toEqual(true);
+    globalThis.expect(json.includes("\"errors\":null")).toEqual(false);
+  });
 });
 
 export {

package/tests/commandtopic/CommandOutcomeHookTest.res

@@ -0,0 +1,258 @@
+// The command-outcome hook, at the property the side-channels don't have: it fires on the
+// fire-and-forget dispatch path — no acceptedResultChannel/rejectedResultChannel is installed
+// anywhere in this file — for both write-side component kinds, carrying the owning component
+// and telling a domain rejection apart from an infrastructure failure.
+
+open JestGlobals
+
+// ── StateChangeSlice arm (the aggregate arm reuses AggregateFixtures as-is) ──
+
+let dcbMock = DcbFixtures.makeMockStorage()
+
+module TestDcbOps: DcbEventLog_Operations.Ops = {
+  let name = "TestDcbEventLog"
+  let serviceName = "TestDcbEventLog"
+  let storage = dcbMock.operations
+  let publishJson = dcbMock.mockPublishJson
+}
+
+module EventLogOps = DcbEventLog_Operations.Make(TestDcbOps)
+
+let dcbEventLog: DcbEventLog.operations = {
+  read: EventLogOps.read,
+  append: EventLogOps.append,
+  readStream: EventLogOps.readStream,
+  appendStream: EventLogOps.appendStream,
+}
+
+module SliceBehavior = {
+  type state = DcbFixtures.TestCommandSpec.state
+  let initialState = DcbFixtures.TestCommandSpec.initialState
+  let evolve = DcbFixtures.TestCommandSpec.evolve
+  let decide = DcbFixtures.TestCommandSpec.decide
+  let moduleUrl = DcbFixtures.TestCommandSpec.moduleUrl
+}
+
+module SliceHandler = StateChangeSlice_Callback.Make(DcbFixtures.TestCommandSpec, SliceBehavior)
+
+let sliceItem = (reference, command): CommandTopic.topicItem<
+  Message.command'<Reventless.Id.String.t, DcbFixtures.TestCommandSpec.command>,
+> => {
+  command: {
+    id: Reventless.Id.String.makeFromString("cmd-" ++ reference),
+    meta: DcbFixtures.testMeta,
+    command,
+  },
+  reference,
+}
+
+let runSlice = (reference, command) =>
+  SliceHandler.handleCommands(dcbEventLog, Stream.fromIterable([sliceItem(reference, command)]))
+  ->Effect.runPromise
+
+let runAgg = (~aggId="agg-1", reference, command) =>
+  Stream.fromIterable([AggregateFixtures.makeTopicItem(~aggId, reference, command)])
+  ->AggregateFixtures.TestHandler.handleCommands
+  ->Effect.runPromise
+
+// ── Capture ──
+
+let observed: ref<array<CommandTopic_Helpers.commandOutcomeReport>> = ref([])
+
+// Flattened for readable assertions: (component, reference, disposition, errorCode, eventCount).
+let seen = () =>
+  observed.contents->Array.map(r =>
+    switch r.outcome {
+    | OutcomeAccepted({eventCount}) => (r.component, r.reference, "accepted", "", eventCount)
+    | OutcomeRejected({errorCode, cause}) => (
+        r.component,
+        r.reference,
+        switch cause {
+        | DomainRejection => "rejected/domain"
+        | InfrastructureFailure => "rejected/infrastructure"
+        },
+        errorCode,
+        0,
+      )
+    }
+  )
+
+let record = () =>
+  CommandTopic_Helpers.registerCommandOutcome(r =>
+    observed := observed.contents->Array.concat([r])
+  )
+
+let _ = beforeEach(() => {
+  AggregateFixtures.mock.reset()
+  AggregateFixtures.TestHandler.resetCache()
+  dcbMock.reset()
+  SliceHandler.resetCache()
+  observed := []
+  CommandTopic_Helpers.clearCommandOutcome()
+  RuntimeExtension.reset()
+})
+
+describe("CommandTopic command-outcome hook:", () => {
+  describe("aggregate", () => {
+    testPromise("observes an accepted command with no side-channel installed", async () => {
+      record()
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+    })
+
+    testPromise("carries the entity id of an accepted command", async () => {
+      record()
+      let _ = await runAgg(~aggId="agg-7", "ref-1", AggregateFixtures.AggSpec.Create({name: "W"}))
+
+      let entityId = switch (observed.contents->Array.getUnsafe(0)).outcome {
+      | OutcomeAccepted({entityId}) => entityId
+      | OutcomeRejected(_) => None
+      }
+      expect(entityId)->toEqual(Some("agg-7"))
+    })
+
+    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
+      // Seed before registering, so only the second (rejected) Create is observed.
+      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+      record()
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "rejected/domain", "AlreadyExists", 0),
+      ])
+    })
+
+    testPromise("reports a failed append as infrastructure, not a domain rejection", async () => {
+      record()
+      AggregateFixtures.mock.failNextAppend := true
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      // `decide` said Ok here — the store is what failed, and the hook has to say so.
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "rejected/infrastructure", "AppendFailed", 0),
+      ])
+    })
+
+    testPromise("observes every command of a mixed batch", async () => {
+      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+      record()
+      let _ =
+        await Stream.fromIterable([
+          AggregateFixtures.makeTopicItem("ref-1", AggregateFixtures.AggSpec.Rename({newName: "A"})),
+          AggregateFixtures.makeTopicItem("ref-2", AggregateFixtures.AggSpec.Create({name: "B"})),
+          AggregateFixtures.makeTopicItem("ref-3", AggregateFixtures.AggSpec.Rename({newName: "C"})),
+        ])
+        ->AggregateFixtures.TestHandler.handleCommands
+        ->Effect.runPromise
+
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "accepted", "", 2),
+        ("TestAggregate", "ref-2", "rejected/domain", "AlreadyExists", 0),
+        ("TestAggregate", "ref-3", "accepted", "", 2),
+      ])
+    })
+  })
+
+  describe("state-change slice", () => {
+    testPromise("observes an accepted command with no side-channel installed", async () => {
+      record()
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+
+      expect(seen())->toEqual([
+        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "accepted", "", 1),
+      ])
+    })
+
+    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
+      let _ = await runSlice(
+        "ref-seed",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+      record()
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Again"}),
+      )
+
+      expect(seen())->toEqual([
+        (
+          "TestStateChangeSlice",
+          DcbFixtures.testMeta.msgId,
+          "rejected/domain",
+          "ItemAlreadyExists",
+          0,
+        ),
+      ])
+    })
+
+    testPromise("reports exhausted append conflicts as infrastructure", async () => {
+      record()
+      // One more failure than the retry loop can absorb.
+      dcbMock.failNextAppends := 4
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+
+      expect(seen())->toEqual([
+        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "rejected/infrastructure", "Conflict", 0),
+      ])
+    })
+  })
+
+  describe("registration", () => {
+    testPromise("with nothing registered nothing is observed and the command is unaffected", async () => {
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+      expect(observed.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("clearCommandOutcome stops observation", async () => {
+      record()
+      CommandTopic_Helpers.clearCommandOutcome()
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(observed.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("an out-of-tree extension can register it from onColdStart", async () => {
+      // The hook needs no registration path of its own: it has the shape the cold-start
+      // seam already reaches, so an extension picks it up alongside the other four.
+      module Accountant: RuntimeExtension.Extension = {
+        let moduleUrl = "file:///pkg/accountant.res.mjs"
+        let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+          record()
+      }
+      RuntimeExtension.use(module(Accountant: RuntimeExtension.Extension))
+      RuntimeExtension.notifyColdStart(
+        ~runtimeKind=ComponentType.Aggregate,
+        ~component="AllAggregates",
+        ~plugin=Some("Catalog"),
+        ~platform=Some("Shop"),
+      )
+
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+    })
+
+    testPromise("a throwing hook is swallowed and the command still succeeds", async () => {
+      CommandTopic_Helpers.registerCommandOutcome(_ =>
+        JsError.throwWithMessage("hook exploded")
+      )
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      // The outcome the hook observes has already happened — an observer must not undo it.
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+    })
+  })
+})