@reventlessdev/reventless-core 3.0.0-alpha.283 → 3.0.0-alpha.285

package/tests/commandgenerator/OwnerActingTest.res.mjs

@@ -0,0 +1,1018 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+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 Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as DcbFixtures$ReventlessCore from "../dcb/DcbFixtures.res.mjs";
+import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "../../src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../../src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "../../src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+let name = "OwnedOrders";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let consumedEventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Owner$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "ProductListed",
+    productId: s.m(DcbTag$Reventless.string),
+    sellerId: s.m(Owner$Reventless.string)
+  }))
+]);
+
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "PlaceOrder",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerId: s.m(Owner$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "CancelOrder",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "ReviewOrder",
+    orderId: s.m(DcbTag$Reventless.string),
+    productId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let errorSchema = Sury.union([
+  Sury.literal("OrderAlreadyPlaced"),
+  Sury.literal("OrderNotFound")
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let OrderSlice = {
+  name: name,
+  Id: undefined,
+  moduleUrl: moduleUrl,
+  eventSchema: eventSchema,
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema,
+  errorSchema: errorSchema,
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  placed: false,
+  cancelled: false
+};
+
+function evolve(state, event) {
+  switch (event.TAG) {
+    case "OrderPlaced" :
+      return {
+        placed: true,
+        cancelled: state.cancelled
+      };
+    case "OrderCancelled" :
+      return {
+        placed: state.placed,
+        cancelled: true
+      };
+    case "ProductListed" :
+      return state;
+  }
+}
+
+function decide(state, command) {
+  switch (command.TAG) {
+    case "PlaceOrder" :
+      if (state.placed) {
+        return {
+          TAG: "Error",
+          _0: "OrderAlreadyPlaced"
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "OrderPlaced",
+              orderId: command.orderId,
+              customerId: command.customerId
+            }]
+        };
+      }
+    case "CancelOrder" :
+      let match = state.placed;
+      let match$1 = state.cancelled;
+      if (match) {
+        if (match$1) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "OrderCancelled",
+                orderId: command.orderId
+              }]
+          };
+        }
+      } else {
+        return {
+          TAG: "Error",
+          _0: "OrderNotFound"
+        };
+      }
+    case "ReviewOrder" :
+      if (state.placed) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "OrderNotFound"
+        };
+      }
+  }
+}
+
+let OrderBehavior = {
+  initialState: initialState,
+  moduleUrl: moduleUrl,
+  evolve: evolve,
+  decide: decide
+};
+
+let OrderHandler = StateChangeSlice_Callback$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema,
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl
+});
+
+let dcbMock = DcbFixtures$ReventlessCore.makeMockStorage();
+
+let storage = dcbMock.operations;
+
+let publishJson = dcbMock.mockPublishJson;
+
+let DcbOps = {
+  name: "OwnedOrdersEventLog",
+  serviceName: "OwnedOrdersEventLog",
+  storage: storage,
+  publishJson: publishJson
+};
+
+let DcbLog = DcbEventLog_Operations$ReventlessCore.Make(DcbOps);
+
+let dcbEventLog_read = DcbLog.read;
+
+let dcbEventLog_append = DcbLog.append;
+
+let dcbEventLog_readStream = DcbLog.readStream;
+
+let dcbEventLog_appendStream = DcbLog.appendStream;
+
+let dcbEventLog = {
+  read: dcbEventLog_read,
+  append: dcbEventLog_append,
+  readStream: dcbEventLog_readStream,
+  appendStream: dcbEventLog_appendStream
+};
+
+let orderPartition = {
+  TAG: "Simple",
+  _0: {
+    key: "orderId"
+  }
+};
+
+let name$1 = "OwnedAccount";
+
+let commandSchema$1 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Open",
+    holderId: s.m(Owner$Reventless.string),
+    name: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Rename",
+    newName: s.m(Sury.string)
+  }))
+]);
+
+let eventSchema$1 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Opened",
+    holderId: s.m(Owner$Reventless.string),
+    name: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Renamed",
+    newName: s.m(Sury.string)
+  }))
+]);
+
+let errorSchema$1 = Sury.union([
+  Sury.literal("AlreadyOpen"),
+  Sury.literal("NotFound")
+]);
+
+let moduleUrl$1 = import.meta.url;
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition$1(param) {
+  return "Undeclared";
+}
+
+let traits$1 = [];
+
+let AccountSpec = {
+  Id: undefined,
+  name: name$1,
+  commandSchema: commandSchema$1,
+  eventSchema: eventSchema$1,
+  errorSchema: errorSchema$1,
+  moduleUrl: moduleUrl$1,
+  commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1
+};
+
+let stateSchema = Sury.union([
+  Sury.literal("NotOpen"),
+  Sury.$schema(s => ({
+    TAG: "Active",
+    name: s.m(Sury.string)
+  }))
+]);
+
+let snapshot = {
+  interval: 1,
+  stateSchema: stateSchema
+};
+
+function evolve$1(_state, event) {
+  if (event.TAG === "Opened") {
+    return {
+      TAG: "Active",
+      name: event.name
+    };
+  } else {
+    return {
+      TAG: "Active",
+      name: event.newName
+    };
+  }
+}
+
+function decide$1(state, command) {
+  if (typeof state !== "object") {
+    if (command.TAG === "Open") {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "Opened",
+            holderId: command.holderId,
+            name: command.name
+          }]
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "NotFound"
+      };
+    }
+  } else if (command.TAG === "Open") {
+    return {
+      TAG: "Error",
+      _0: "AlreadyOpen"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Renamed",
+          newName: command.newName
+        }]
+    };
+  }
+}
+
+let AccountBehavior = {
+  Spec: undefined,
+  stateSchema: stateSchema,
+  initialState: "NotOpen",
+  snapshot: snapshot,
+  moduleUrl: moduleUrl$1,
+  evolve: evolve$1,
+  decide: decide$1
+};
+
+let accountEvents = {
+  contents: []
+};
+
+let snapshotReads = {
+  contents: 0
+};
+
+let name$2 = "OwnedAccountEventLog";
+
+let Spec = {
+  Id: undefined,
+  name: name$2,
+  eventSchema: eventSchema$1
+};
+
+function make(param, param$1, param$2) {
+  return 0;
+}
+
+let EventLog = {
+  Spec: Spec,
+  make: make
+};
+
+function ofId(id) {
+  return accountEvents.contents.filter(e => e.id === id).map(e => e.event);
+}
+
+async function eventLog_append(_seqNr, _id, newEvents) {
+  accountEvents.contents = accountEvents.contents.concat(newEvents);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let eventLog_replay = ofId;
+
+function eventLog_replayStream(id, param) {
+  return Stream.fromIterable(ofId(id));
+}
+
+function eventLog_appendStream(_seqNr, _id, stream) {
+  return Stream.runDrain(stream);
+}
+
+async function eventLog_latestSnapshot(param) {
+  snapshotReads.contents = snapshotReads.contents + 1 | 0;
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let eventLog = {
+  append: eventLog_append,
+  replay: eventLog_replay,
+  replayStream: eventLog_replayStream,
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
+};
+
+let AccountOps = {
+  Spec: undefined,
+  EventLog: EventLog,
+  ofId: ofId,
+  eventLog: eventLog
+};
+
+let AccountHandler = Aggregate_Callback$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name$1,
+  eventSchema: eventSchema$1,
+  errorSchema: errorSchema$1,
+  commandSchema: commandSchema$1,
+  moduleUrl: moduleUrl$1,
+  commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1
+})({
+  initialState: "NotOpen",
+  evolve: evolve$1,
+  decide: decide$1,
+  snapshot: snapshot,
+  moduleUrl: moduleUrl$1
+})({
+  Spec: {
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: name$1,
+    eventSchema: eventSchema$1,
+    errorSchema: errorSchema$1,
+    commandSchema: commandSchema$1,
+    moduleUrl: moduleUrl$1,
+    commandAuthorization: commandAuthorization$1,
+    commandTransition: commandTransition$1,
+    traits: traits$1
+  },
+  EventLog: {
+    Spec: {
+      Id: {
+        schema: Id$Reventless.StringPure.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: Id$Reventless.StringPure.cmp
+      },
+      name: name$2,
+      eventSchema: eventSchema$1
+    },
+    make: make
+  },
+  eventLog: eventLog
+});
+
+function cognito(userId, groups) {
+  return {
+    userId: userId,
+    username: userId,
+    groups: groups,
+    provider: "Cognito"
+  };
+}
+
+let owner = cognito("cust-A", ["User"]);
+
+let stranger = cognito("cust-B", ["User"]);
+
+let operator = cognito("ops-1", ["Admin"]);
+
+let iam = {
+  userArn: "arn:aws:sts::1:assumed-role/Ingester",
+  accountId: "1",
+  username: "Ingester",
+  provider: "IAM"
+};
+
+function cross(hop, cmd) {
+  if (hop === "Inline") {
+    return CommandTopic_Helpers$ReventlessCore.encodeCommandJson(cmd);
+  } else {
+    return JSON.parse(Message$ReventlessCore.toMessageBody(cmd));
+  }
+}
+
+let observed = {
+  contents: []
+};
+
+function outcomeOf(reference) {
+  let match = observed.contents.findLast(r => r.reference === reference);
+  if (match === undefined) {
+    return "Lost";
+  }
+  let match$1 = match.outcome;
+  if (match$1.TAG === "OutcomeAccepted") {
+    return "Accepted";
+  } else {
+    return {
+      TAG: "Refused",
+      _0: match$1.errorCode,
+      _1: match$1.cause
+    };
+  }
+}
+
+let generated = {
+  contents: []
+};
+
+function generator(serviceName, commandSchema, componentKind) {
+  return CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(async cmds => {
+    generated.contents = generated.contents.concat(cmds);
+  }, undefined, serviceName, commandSchema, componentKind, componentKind === "Aggregate", undefined);
+}
+
+async function generateOne(generate, command, args, identity) {
+  generated.contents = [];
+  let p = {
+    command: command,
+    arguments: Object.fromEntries(args),
+    meta: {
+      ip: [],
+      user: "test",
+      info: ""
+    },
+    identity: identity
+  };
+  await Effect.runPromise(generate(p));
+  return generated.contents[0];
+}
+
+function withoutClaim(cmd) {
+  let newrecord = {...cmd};
+  let newrecord$1 = {...cmd.meta};
+  newrecord$1.callerClaim = undefined;
+  newrecord.meta = newrecord$1;
+  return newrecord;
+}
+
+function str(prim) {
+  return prim;
+}
+
+let dcbGenerate = generator(name, commandSchema, "StateChangeSlice");
+
+async function deliverDcb(crossPartitionTagKeysOpt, partitionTagOpt, hop, cmd) {
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let partitionTag = partitionTagOpt !== undefined ? partitionTagOpt : orderPartition;
+  let command$p = Message$ReventlessCore.decodeCommand$p(cross(hop, cmd), Id$Reventless.$$String.schema, commandSchema);
+  await Effect.runPromise(OrderHandler.handleCommands(undefined, crossPartitionTagKeys, partitionTag, dcbEventLog, Stream.fromIterable([{
+      command: command$p,
+      reference: cmd.meta.msgId
+    }])));
+  return command$p.meta.msgId;
+}
+
+function makeDcbPath(hop) {
+  let label = `DCB slice, ` + (
+    hop === "Inline" ? "inline" : "queued"
+  ) + ` envelope`;
+  let reset = () => {
+    dcbMock.reset();
+    OrderHandler.resetCache();
+  };
+  let deliver = cmd => deliverDcb(undefined, undefined, hop, cmd);
+  let seed = async () => {
+    await deliver(await generateOne(dcbGenerate, "PlaceOrder", [
+      [
+        "orderId",
+        "o-1"
+      ],
+      [
+        "customerId",
+        "cust-A"
+      ]
+    ], owner));
+  };
+  let act = identity => generateOne(dcbGenerate, "CancelOrder", [[
+      "orderId",
+      "o-1"
+    ]], identity);
+  let historyLength = () => dcbMock.getEvents().length;
+  return {
+    label: label,
+    reset: reset,
+    seed: seed,
+    act: act,
+    deliver: deliver,
+    historyLength: historyLength
+  };
+}
+
+let aggregateGenerate = generator(name$1, commandSchema$1, "Aggregate");
+
+async function deliverAggregate(hop, cmds) {
+  let items = cmds.map(cmd => ({
+    command: Message$ReventlessCore.decodeCommand$p(cross(hop, cmd), Id$Reventless.StringPure.schema, commandSchema$1),
+    reference: cmd.meta.msgId
+  }));
+  await Effect.runPromise(AccountHandler.handleCommands(Stream.fromIterable(items)));
+}
+
+function makeAggregatePath(hop) {
+  let label = `aggregate, ` + (
+    hop === "Inline" ? "inline" : "queued"
+  ) + ` envelope`;
+  let reset = () => {
+    accountEvents.contents = [];
+    snapshotReads.contents = 0;
+    AccountHandler.resetCache();
+  };
+  let deliver = async cmd => {
+    await deliverAggregate(hop, [cmd]);
+    return cmd.meta.msgId;
+  };
+  let seed = async () => {
+    await deliver(await generateOne(aggregateGenerate, "Open", [
+      [
+        "id",
+        "acc-1"
+      ],
+      [
+        "holderId",
+        "cust-A"
+      ],
+      [
+        "name",
+        "Main"
+      ]
+    ], owner));
+  };
+  let act = identity => generateOne(aggregateGenerate, "Rename", [
+    [
+      "id",
+      "acc-1"
+    ],
+    [
+      "newName",
+      "Renamed"
+    ]
+  ], identity);
+  let historyLength = () => accountEvents.contents.length;
+  return {
+    label: label,
+    reset: reset,
+    seed: seed,
+    act: act,
+    deliver: deliver,
+    historyLength: historyLength
+  };
+}
+
+let paths = [
+  makeDcbPath("Inline"),
+  makeDcbPath("Queued"),
+  makeAggregatePath("Inline"),
+  makeAggregatePath("Queued")
+];
+
+globalThis.beforeEach(() => {
+  OwnerScope$Reventless.setElevatedGroups(["Admin"]);
+  observed.contents = [];
+  CommandTopic_Helpers$ReventlessCore.registerCommandOutcome(r => {
+    observed.contents = observed.contents.concat([r]);
+  });
+});
+
+globalThis.afterEach(() => CommandTopic_Helpers$ReventlessCore.clearCommandOutcome());
+
+let forbidden = {
+  TAG: "Refused",
+  _0: "Forbidden",
+  _1: "AccessRefusal"
+};
+
+let table = [
+  [
+    "the owner",
+    owner,
+    false,
+    "Accepted"
+  ],
+  [
+    "another owner",
+    stranger,
+    false,
+    forbidden
+  ],
+  [
+    "an operator, on the owner's behalf",
+    operator,
+    false,
+    "Accepted"
+  ],
+  [
+    "the platform's own IAM traffic",
+    iam,
+    false,
+    "Accepted"
+  ],
+  [
+    "an anonymous caller",
+    Identity$Reventless.anonymous,
+    false,
+    forbidden
+  ],
+  [
+    "an internal route, with no claim",
+    stranger,
+    true,
+    "Accepted"
+  ]
+];
+
+paths.forEach(path => {
+  globalThis.describe(`acting on an owned thing — ` + path.label + `:`, () => {
+    globalThis.beforeEach(() => path.reset());
+    table.forEach(param => {
+      let expected = param[3];
+      let internal = param[2];
+      let identity = param[1];
+      globalThis.test(param[0] + `: ` + (
+        expected === "Accepted" ? "accepted" : "refused before decide"
+      ), async () => {
+        await path.seed();
+        let before = path.historyLength();
+        let cmd = await path.act(identity);
+        let cmd$1 = internal ? withoutClaim(cmd) : cmd;
+        let received = await path.deliver(cmd$1);
+        globalThis.expect([
+          outcomeOf(received),
+          path.historyLength() > before
+        ]).toEqual([
+          expected,
+          expected === "Accepted"
+        ]);
+      });
+    });
+    globalThis.test("the owner's own creating command is accepted on an empty history", async () => {
+      await path.seed();
+      globalThis.expect(path.historyLength()).toBe(1);
+    });
+  });
+});
+
+globalThis.describe("acting on an owned thing — DCB specifics:", () => {
+  globalThis.beforeEach(() => {
+    dcbMock.reset();
+    OrderHandler.resetCache();
+  });
+  let seedOrder = async () => {
+    await deliverDcb(undefined, undefined, "Inline", await generateOne(dcbGenerate, "PlaceOrder", [
+      [
+        "orderId",
+        "o-1"
+      ],
+      [
+        "customerId",
+        "cust-A"
+      ]
+    ], owner));
+  };
+  let rawEvent = (eventType, fields, tags) => ({
+    eventType: eventType,
+    data: Object.fromEntries(fields),
+    tags: tags.map(param => ({
+      key: param[0],
+      value: param[1]
+    })),
+    meta: DcbFixtures$ReventlessCore.testMeta
+  });
+  globalThis.test("an owner recorded in another partition does not count", async () => {
+    await seedOrder();
+    await dcbMock.operations.append([rawEvent("ProductListed", [
+        [
+          "productId",
+          "p-1"
+        ],
+        [
+          "sellerId",
+          "seller-Z"
+        ]
+      ], [[
+          "productId",
+          "p-1"
+        ]])], undefined);
+    let review = await generateOne(dcbGenerate, "ReviewOrder", [
+      [
+        "orderId",
+        "o-1"
+      ],
+      [
+        "productId",
+        "p-1"
+      ]
+    ], owner);
+    await deliverDcb(["productId"], undefined, "Inline", review);
+    globalThis.expect(outcomeOf(review.meta.msgId)).toEqual("Accepted");
+  });
+  globalThis.test("a warm, delta-read command is still checked against the owner", async () => {
+    await seedOrder();
+    let mine = await generateOne(dcbGenerate, "CancelOrder", [[
+        "orderId",
+        "o-1"
+      ]], owner);
+    await deliverDcb(undefined, undefined, "Inline", mine);
+    dcbMock.readAfters.contents = [];
+    let theirs = await generateOne(dcbGenerate, "CancelOrder", [[
+        "orderId",
+        "o-1"
+      ]], stranger);
+    await deliverDcb(undefined, undefined, "Inline", theirs);
+    globalThis.expect([
+      dcbMock.readAfters.contents.some(Stdlib_Option.isSome),
+      outcomeOf(theirs.meta.msgId)
+    ]).toEqual([
+      true,
+      forbidden
+    ]);
+  });
+  globalThis.test("two owners in one partition refuse even an operator", async () => {
+    await seedOrder();
+    await dcbMock.operations.append([rawEvent("OrderPlaced", [
+        [
+          "orderId",
+          "o-1"
+        ],
+        [
+          "customerId",
+          "cust-B"
+        ]
+      ], [[
+          "orderId",
+          "o-1"
+        ]])], undefined);
+    let cmd = await generateOne(dcbGenerate, "CancelOrder", [[
+        "orderId",
+        "o-1"
+      ]], operator);
+    await deliverDcb(undefined, undefined, "Inline", cmd);
+    globalThis.expect(outcomeOf(cmd.meta.msgId)).toEqual(forbidden);
+  });
+  globalThis.test("an unnameable partition refuses an owner and admits an operator", async () => {
+    await seedOrder();
+    let unnamed = {
+      TAG: "ByEventType",
+      _0: {}
+    };
+    let mine = await generateOne(dcbGenerate, "CancelOrder", [[
+        "orderId",
+        "o-1"
+      ]], owner);
+    await deliverDcb(undefined, unnamed, "Inline", mine);
+    let ops = await generateOne(dcbGenerate, "CancelOrder", [[
+        "orderId",
+        "o-1"
+      ]], operator);
+    await deliverDcb(undefined, unnamed, "Inline", ops);
+    globalThis.expect([
+      outcomeOf(mine.meta.msgId),
+      outcomeOf(ops.meta.msgId)
+    ]).toEqual([
+      forbidden,
+      "Accepted"
+    ]);
+  });
+});
+
+globalThis.describe("acting on an owned thing — aggregate specifics:", () => {
+  globalThis.beforeEach(() => {
+    accountEvents.contents = [];
+    snapshotReads.contents = 0;
+    AccountHandler.resetCache();
+  });
+  globalThis.test("a command later in the same batch is checked against an owner just recorded", async () => {
+    let opened = await generateOne(aggregateGenerate, "Open", [
+      [
+        "id",
+        "acc-1"
+      ],
+      [
+        "holderId",
+        "cust-A"
+      ],
+      [
+        "name",
+        "Main"
+      ]
+    ], owner);
+    let renamed = await generateOne(aggregateGenerate, "Rename", [
+      [
+        "id",
+        "acc-1"
+      ],
+      [
+        "newName",
+        "Mine now"
+      ]
+    ], stranger);
+    await deliverAggregate("Inline", [
+      opened,
+      renamed
+    ]);
+    globalThis.expect([
+      outcomeOf(opened.meta.msgId),
+      outcomeOf(renamed.meta.msgId)
+    ]).toEqual([
+      "Accepted",
+      forbidden
+    ]);
+  });
+  globalThis.test("an owner-marked aggregate never seeds from a snapshot", async () => {
+    let opened = await generateOne(aggregateGenerate, "Open", [
+      [
+        "id",
+        "acc-1"
+      ],
+      [
+        "holderId",
+        "cust-A"
+      ],
+      [
+        "name",
+        "Main"
+      ]
+    ], owner);
+    await deliverAggregate("Inline", [opened]);
+    globalThis.expect(snapshotReads.contents).toBe(0);
+  });
+});
+
+let OuterEventLog;
+
+export {
+  OrderSlice,
+  OrderBehavior,
+  OrderHandler,
+  dcbMock,
+  DcbOps,
+  DcbLog,
+  dcbEventLog,
+  orderPartition,
+  AccountSpec,
+  AccountBehavior,
+  accountEvents,
+  snapshotReads,
+  OuterEventLog,
+  AccountOps,
+  AccountHandler,
+  cognito,
+  owner,
+  stranger,
+  operator,
+  iam,
+  cross,
+  observed,
+  outcomeOf,
+  generated,
+  generator,
+  generateOne,
+  withoutClaim,
+  str,
+  dcbGenerate,
+  deliverDcb,
+  makeDcbPath,
+  aggregateGenerate,
+  deliverAggregate,
+  makeAggregatePath,
+  paths,
+  forbidden,
+  table,
+}
+/* moduleUrl Not a pure module */