npm - @reventlessdev/reventless-aws - Versions diffs - 3.0.0-alpha.167 - Mend

@reventlessdev/reventless-aws 3.0.0-alpha.167

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (394) hide show

package/tests/Util_StaticBundleTest.res.mjs ADDED Viewed

@@ -0,0 +1,149 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+import * as Fs from "fs";
+import * as Os from "os";
+import * as Path from "path";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Util_StaticBundle$ReventlessAws from "../src/util/Util_StaticBundle.res.mjs";
+function makeFixture() {
+  let base = Fs.mkdtempSync(Path.join(Os.tmpdir(), "static-bundle-"));
+  Fs.writeFileSync(Path.join(base, "index.html"), "<html></html>");
+  Fs.writeFileSync(Path.join(base, "app.js"), "console.log('x')");
+  Fs.writeFileSync(Path.join(base, "app.css"), "body{color:red}");
+  Fs.writeFileSync(Path.join(base, ".DS_Store"), "ignored");
+  let assets = Path.join(base, "assets");
+  Fs.mkdirSync(assets, {
+    recursive: true
+  });
+  Fs.writeFileSync(Path.join(assets, "logo.svg"), "<svg/>");
+  Fs.writeFileSync(Path.join(assets, "favicon.ico"), "ico");
+  return base;
+}
+globalThis.describe("Util_StaticBundle.contentTypeFor", () => {
+  globalThis.test("html", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("index.html")).toBe("text/html; charset=utf-8");
+  });
+  globalThis.test("css", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("foo/bar.css")).toBe("text/css; charset=utf-8");
+  });
+  globalThis.test("js", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("app.js")).toBe("application/javascript; charset=utf-8");
+  });
+  globalThis.test("mjs", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("module.mjs")).toBe("application/javascript; charset=utf-8");
+  });
+  globalThis.test("json", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("data.json")).toBe("application/json; charset=utf-8");
+  });
+  globalThis.test("svg", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("logo.svg")).toBe("image/svg+xml");
+  });
+  globalThis.test("woff2", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("font.woff2")).toBe("font/woff2");
+  });
+  globalThis.test("wasm", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("blob.wasm")).toBe("application/wasm");
+  });
+  globalThis.test("uppercase extension is normalised", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("LOGO.PNG")).toBe("image/png");
+  });
+  globalThis.test("unknown extension defaults to octet-stream", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.contentTypeFor("blob.xyz")).toBe("application/octet-stream");
+  });
+});
+globalThis.describe("Util_StaticBundle.sanitizeName", () => {
+  globalThis.test("replaces slashes with dashes", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.sanitizeName("foo/bar/baz")).toBe("foo-bar-baz");
+  });
+  globalThis.test("replaces dots with dashes", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.sanitizeName("index.html")).toBe("index-html");
+  });
+  globalThis.test("replaces both", () => {
+    globalThis.expect(Util_StaticBundle$ReventlessAws.sanitizeName("assets/logo.svg")).toBe("assets-logo-svg");
+  });
+});
+globalThis.describe("Util_StaticBundle.walk", () => {
+  globalThis.test("returns one entry per file, skips dotfiles, uses forward slashes", () => {
+    let dir = makeFixture();
+    let entries = Util_StaticBundle$ReventlessAws.walk(dir);
+    let keys = entries.map(e => e.relativePath).toSorted(Primitive_string.compare);
+    globalThis.expect(keys).toEqual([
+      "app.css",
+      "app.js",
+      "assets/favicon.ico",
+      "assets/logo.svg",
+      "index.html"
+    ]);
+    Fs.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("computes a non-empty content hash for each entry", () => {
+    let dir = makeFixture();
+    let entries = Util_StaticBundle$ReventlessAws.walk(dir);
+    entries.forEach(e => {
+      globalThis.expect(e.contentHash.length > 0).toBe(true);
+    });
+    Fs.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("identical contents produce identical hashes", () => {
+    let dir = makeFixture();
+    let entries = Util_StaticBundle$ReventlessAws.walk(dir);
+    let indexEntry = entries.find(e => e.relativePath === "index.html");
+    let indexHash = indexEntry.contentHash;
+    let dir2 = Fs.mkdtempSync(Path.join(Os.tmpdir(), "static-bundle-"));
+    Fs.writeFileSync(Path.join(dir2, "index.html"), "<html></html>");
+    let entries2 = Util_StaticBundle$ReventlessAws.walk(dir2);
+    let indexHash2 = entries2[0].contentHash;
+    globalThis.expect(indexHash).toBe(indexHash2);
+    Fs.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+    Fs.rmSync(dir2, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("different contents produce different hashes", () => {
+    let dirA = Fs.mkdtempSync(Path.join(Os.tmpdir(), "static-bundle-"));
+    Fs.writeFileSync(Path.join(dirA, "f.txt"), "AAA");
+    let dirB = Fs.mkdtempSync(Path.join(Os.tmpdir(), "static-bundle-"));
+    Fs.writeFileSync(Path.join(dirB, "f.txt"), "BBB");
+    let hashA = Util_StaticBundle$ReventlessAws.walk(dirA)[0].contentHash;
+    let hashB = Util_StaticBundle$ReventlessAws.walk(dirB)[0].contentHash;
+    globalThis.expect(hashA === hashB).toBe(false);
+    Fs.rmSync(dirA, {
+      recursive: true,
+      force: true
+    });
+    Fs.rmSync(dirB, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("throws when assetsDir does not exist", () => {
+    let missing = Path.join(Os.tmpdir(), "static-bundle-does-not-exist-xyz123");
+    let threw;
+    try {
+      Util_StaticBundle$ReventlessAws.walk(missing);
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+  });
+});
+export {
+  makeFixture,
+}
+/*  Not a pure module */

package/tests/integration/DcbCommandTopicEntryPoint_IntegrationTest.res ADDED Viewed

@@ -0,0 +1,101 @@
+// Integration regression guard for the DCB CommandTopic Lambda entry point.
+//
+// Drives the real `DcbCommandTopicEntryPoint.mjs` against a DynamoDB Local
+// table, with a test loader supplying a tiny `EpTestSlice` spec/behavior pair
+// in place of the production Lambda's `/var/task/node_modules` dynamic import.
+// Covers the regression class behind the 2026-06-21 incident: the entry point
+// was passing the wrong number of positional args to ReScript-compiled
+// `StateChangeSlice_Callback.handleCommands`, so `stream` landed as undefined
+// and the Lambda crashed inside Effect's `Stream.mapEffect` with
+// `'channel' in undefined`. Any future arity drift between the JS caller and
+// the ReScript signature (e.g. a new optional labelled arg added before the
+// positional ones) re-breaks the same path; this test fails it as
+// CommandAccepted → Lambda:Unhandled.
+//
+// Boots via the same `pnpm run test:integration` Docker-gated suite as the
+// storage-runtime integration tests; harnessed by `DcbIntegrationHarness`.
+open JestGlobals
+module H = DcbIntegrationHarness
+// `cmdGenHandler(event)` returns an Effect that must be runPromise'd through
+// the request context the production handler supplies. This raw helper drives
+// the full real pipeline: build handlers via the entry point's exported
+// factory, dispatch one AppSync event, run the Effect, return the AppSync-
+// shape outcome JSON.
+let runOneAppSyncEvent: (string, JSON.t) => promise<JSON.t> = %raw(`
+  async (tableName, event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const Effect = await import("effect/Effect");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+    const { commandOutcomeToJson } = await import(
+      "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs"
+    );
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-test://spec") return await import("./EpTestSlice.res.mjs");
+      if (specifier === "ep-test://behavior") return await import("./EpTestSliceBehavior.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+    const config = {
+      pluginName: "EpTestPlugin",
+      dcbEventLogTableName: tableName,
+      stateChangeSliceModules: [{ spec: "ep-test://spec", behavior: "ep-test://behavior" }],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-test-queue",
+    };
+    const [, cmdGenHandler] = await buildHandlersForConfig(config, { loadModule });
+    const effect = cmdGenHandler(event)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "ep-test" }));
+    const outcome = await Effect.runPromise(effect);
+    return commandOutcomeToJson(outcome);
+  }
+`)
+let buildAppSyncEvent = (widgetId): JSON.t => {
+  // CommandGenerator payload: `{command, arguments, meta, identity?}` — the
+  // exact shape AppSync's direct-invoke resolver sends (matches the resolver
+  // template in `DcbCmdHandlerResolver_GraphQL.res`).
+  let command = Dict.fromArray([("AddWidget", Dict.make()->JSON.Encode.object)])
+  let arguments = Dict.fromArray([("widgetId", widgetId->JSON.Encode.string)])
+  let meta = Dict.fromArray([
+    ("user", "ep-test"->JSON.Encode.string),
+    ("ip", JSON.Encode.null),
+  ])
+  Dict.fromArray([
+    ("command", command->JSON.Encode.object),
+    ("arguments", arguments->JSON.Encode.object),
+    ("meta", meta->JSON.Encode.object),
+  ])->JSON.Encode.object
+}
+describe("DcbCommandTopicEntryPoint integration", () => {
+  testAsync(
+    "AppSync direct-invoke routes through the runtime handler to CommandAccepted",
+    async () => {
+      // Own table-name prefix avoids `ResourceInUseException` when the test
+      // shares a DDB Local instance with sibling suites that also use the
+      // harness's `DcbItTest_N` counter.
+      let table = await H.createDcbTable("EpTest_" ++ Date.now()->Float.toString)
+      let event = buildAppSyncEvent("widget-1")
+      let outcomeJson = await runOneAppSyncEvent(table.name, event)
+      // `commandOutcomeToJson` produces an AppSync-shape envelope:
+      //   { __typename: "CommandAccepted" | "CommandRejected" | "CommandPending", ... }
+      // The arity bug surfaces as `Lambda:Unhandled` at the AppSync layer —
+      // here it would manifest as a thrown error from `runPromise` before
+      // `commandOutcomeToJson` ever runs, so reaching this assertion at all
+      // already proves the regression hasn't returned. We still assert on
+      // `CommandAccepted` so a future drift to silent-rejection also fails.
+      let s = outcomeJson->JSON.stringifyAny->Option.getOr("<unserializable>")
+      expect(s->String.includes("CommandAccepted"))->toBe(true)
+    },
+  )
+})

package/tests/integration/DcbCommandTopicEntryPoint_IntegrationTest.res.mjs ADDED Viewed

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbIntegrationHarness$ReventlessAws from "./DcbIntegrationHarness.res.mjs";
+let runOneAppSyncEvent = (async (tableName, event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const Effect = await import("effect/Effect");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+    const { commandOutcomeToJson } = await import(
+      "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs"
+    );
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-test://spec") return await import("./EpTestSlice.res.mjs");
+      if (specifier === "ep-test://behavior") return await import("./EpTestSliceBehavior.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+    const config = {
+      pluginName: "EpTestPlugin",
+      dcbEventLogTableName: tableName,
+      stateChangeSliceModules: [{ spec: "ep-test://spec", behavior: "ep-test://behavior" }],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-test-queue",
+    };
+    const [, cmdGenHandler] = await buildHandlersForConfig(config, { loadModule });
+    const effect = cmdGenHandler(event)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "ep-test" }));
+    const outcome = await Effect.runPromise(effect);
+    return commandOutcomeToJson(outcome);
+  });
+function buildAppSyncEvent(widgetId) {
+  let command = Object.fromEntries([[
+      "AddWidget",
+      {}
+    ]]);
+  let $$arguments = Object.fromEntries([[
+      "widgetId",
+      widgetId
+    ]]);
+  let meta = Object.fromEntries([
+    [
+      "user",
+      "ep-test"
+    ],
+    [
+      "ip",
+      null
+    ]
+  ]);
+  return Object.fromEntries([
+    [
+      "command",
+      command
+    ],
+    [
+      "arguments",
+      $$arguments
+    ],
+    [
+      "meta",
+      meta
+    ]
+  ]);
+}
+globalThis.describe("DcbCommandTopicEntryPoint integration", () => {
+  globalThis.test("AppSync direct-invoke routes through the runtime handler to CommandAccepted", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.createDcbTable("EpTest_" + Date.now().toString());
+    let event = buildAppSyncEvent("widget-1");
+    let outcomeJson = await runOneAppSyncEvent(table.name, event);
+    let s = Stdlib_Option.getOr(JSON.stringify(outcomeJson), "<unserializable>");
+    globalThis.expect(s.includes("CommandAccepted")).toBe(true);
+  });
+});
+let H;
+export {
+  H,
+  runOneAppSyncEvent,
+  buildAppSyncEvent,
+}
+/* runOneAppSyncEvent Not a pure module */

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res ADDED Viewed

@@ -0,0 +1,315 @@
+// ⚠️ PENDING REWRITE (dcb-fence-event-type-granularity): this suite still encodes
+// the OLD scalar-`lastPosition` fence + `create#…` create-guard model. The adapter
+// now uses PER-TYPE `pos#<eventType>` fence attributes with the create guard folded
+// in, so `H.setFence(~lastPosition=…)` seeding, the `create#…`-row assertions, and
+// the tag-only (no `eventTypes`) queries below must be reworked and re-run against
+// DynamoDB Local before they pass. Tracked as Test plan #2 in
+// docs/plans/dcb-fence-event-type-granularity.md. Not run by the default unit suite
+// (CI `pnpm test`), so it does not gate the build.
+//
+// DCB DynamoDB integration suite — exercises the real fence path against a
+// DynamoDB Local engine (NOT run by the default unit suite; see
+// `jest.integration.config.js` + `scripts/run-integration-tests.sh`).
+//
+// The unit suite (`DcbEventLogStorage_DynamoDb_RuntimeTest.res`) asserts the
+// *shape* of the built `TransactWriteItems`. This suite asserts DynamoDB's
+// *behaviour* — that the `ConditionExpression`s interpret as we expect — which
+// is the only thing that proves the fence-scope model (Issue 1 fix) and the
+// optimistic-concurrency guarantees end-to-end. See
+// `docs/analysis/dcb-consistency-check-issues.md` and
+// `docs/plans/dcb-consistency-hardening.md` (Phase 1).
+open JestGlobals
+module H = DcbIntegrationHarness
+module Runtime = DcbEventLogStorage_DynamoDb_Runtime
+let tag = (key, value): Reventless.DcbTag.tag => {key, value}
+let meta = () => ReventlessCore.Message.generateMeta(~service="dcb-it")
+let event = (eventType, tags): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data: JSON.Object(Dict.make()),
+  tags,
+  meta: meta(),
+}
+let simple = (key): Reventless.DcbTag.derivedPartitionTag => Simple({key: key})
+let isOk = r =>
+  switch r {
+  | Ok(_) => true
+  | Error(_) => false
+  }
+let isConflict = r =>
+  switch r {
+  | Error(msg) => msg->String.includes("Conflict")
+  | Ok(_) => false
+  }
+// Read a slice's decision-model head position for a query — the `after` an
+// append rides with.
+let readAfter = async (table, query: Reventless.DcbTag.query) => {
+  let result = await Runtime.read(table)(~query)
+  result.headPosition
+}
+// Seed a single event with no consistency check (import/replay path). Bumps the
+// event's partition fence so later conditional readers observe it.
+let seed = (table, ev, ~partitionTag) => Runtime.appendUnconditional(table, [ev], ~partitionTag)
+describe("DCB DynamoDb integration — fence-scope = read-scope (Issue 1 regression)", () => {
+  let productTag = tag("productId", "P5")
+  // Place an order: read (orderId ∪ productId), then append OrderPlaced.
+  let placeOrder = async (table, ~orderId, ~customerId) => {
+    let query: Reventless.DcbTag.query = [
+      {tags: [tag("orderId", orderId)]},
+      {tags: [productTag]},
+    ]
+    let after = await readAfter(table, query)
+    await Runtime.appendConditional(
+      table,
+      [event("OrderPlaced", [tag("orderId", orderId), tag("customerId", customerId), productTag])],
+      {query, after: ?after},
+      ~partitionTag=simple("orderId"),
+    )
+  }
+  testAsync("a second order of the same product (different order + customer) succeeds", async () => {
+    let table = await H.freshTable()
+    let _ = await seed(table, event("CatalogProductSynced", [productTag]), ~partitionTag=simple("productId"))
+    let r1 = await placeOrder(table, ~orderId="O1", ~customerId="C1")
+    let r2 = await placeOrder(table, ~orderId="O2", ~customerId="C2")
+    expect(isOk(r1))->toBe(true)
+    expect(isOk(r2))->toBe(true)
+  })
+  testAsync("two concurrent orders of the same product both succeed (no productId contention)", async () => {
+    let table = await H.freshTable()
+    let _ = await seed(table, event("CatalogProductSynced", [productTag]), ~partitionTag=simple("productId"))
+    let results = await Promise.all([
+      placeOrder(table, ~orderId="OA", ~customerId="CA"),
+      placeOrder(table, ~orderId="OB", ~customerId="CB"),
+    ])
+    expect(results->Array.every(isOk))->toBe(true)
+  })
+  testAsync("a concurrent product re-sync after the order's read still conflicts (OCC preserved)", async () => {
+    let table = await H.freshTable()
+    let _ = await seed(table, event("CatalogProductSynced", [productTag]), ~partitionTag=simple("productId"))
+    // Order reads its decision model (after = the sync's position)…
+    let query: Reventless.DcbTag.query = [{tags: [tag("orderId", "O1")]}, {tags: [productTag]}]
+    let after = (await readAfter(table, query))->Option.getOr("")
+    expect(after == "")->toBe(false)
+    // …a concurrent re-sync advances fence#productId:P5 past `after`. We set the
+    // fence directly (rather than racing a second appendUnconditional) so the
+    // advance is deterministically > after — same-millisecond writers can
+    // otherwise tie on UUID order (analysis Issue 7). Appending "z" stays
+    // lexically greater than any real position.
+    let _ = await H.setFence(table, productTag, ~lastPosition=after ++ "z")
+    // …so the now-stale order append must conflict on the productId fence.
+    let r = await Runtime.appendConditional(
+      table,
+      [event("OrderPlaced", [tag("orderId", "O1"), tag("customerId", "C1"), productTag])],
+      {query, after: ?Some(after)},
+      ~partitionTag=simple("orderId"),
+    )
+    expect(isConflict(r))->toBe(true)
+  })
+  testAsync("placing an order does not poison the customer slice (secondary customerId not fenced)", async () => {
+    let table = await H.freshTable()
+    let customerTag = tag("customerId", "C1")
+    // Customer exists (partitioned by customerId) → fence#customerId:C1 seeded.
+    let _ = await seed(table, event("CustomerRegistered", [customerTag]), ~partitionTag=simple("customerId"))
+    // Order for C1 carries customerId as a SECONDARY tag (partitioned by orderId).
+    let orderQuery: Reventless.DcbTag.query = [{tags: [tag("orderId", "O1")]}]
+    let orderAfter = await readAfter(table, orderQuery)
+    let _ = await Runtime.appendConditional(
+      table,
+      [event("OrderPlaced", [tag("orderId", "O1"), customerTag, productTag])],
+      {query: orderQuery, after: ?orderAfter},
+      ~partitionTag=simple("orderId"),
+    )
+    // The customer slice reads its own partition (sees only CustomerRegistered)
+    // and changes the email. Pre-fix the order would have bumped
+    // fence#customerId:C1, falsely conflicting this append.
+    let customerQuery: Reventless.DcbTag.query = [{tags: [customerTag]}]
+    let customerAfter = await readAfter(table, customerQuery)
+    let r = await Runtime.appendConditional(
+      table,
+      [event("EmailChanged", [customerTag])],
+      {query: customerQuery, after: ?customerAfter},
+      ~partitionTag=simple("customerId"),
+    )
+    expect(isOk(r))->toBe(true)
+  })
+})
+describe("DCB DynamoDb integration — optimistic concurrency primitives", () => {
+  testAsync("fresh first-writer (after=None) succeeds and seeds the fence", async () => {
+    let table = await H.freshTable()
+    let query: Reventless.DcbTag.query = [{tags: [tag("counterId", "K0")]}]
+    let r = await Runtime.appendConditional(
+      table,
+      [event("CounterStarted", [tag("counterId", "K0")])],
+      {query, after: ?None},
+      ~partitionTag=simple("counterId"),
+    )
+    expect(isOk(r))->toBe(true)
+    // The seeded event is now readable.
+    let after = await readAfter(table, query)
+    expect(after->Option.isSome)->toBe(true)
+  })
+  testAsync("two concurrent commits at the same after never both win (no duplicate)", async () => {
+    let table = await H.freshTable()
+    let counterTag = tag("counterId", "K1")
+    let _ = await seed(table, event("CounterStarted", [counterTag]), ~partitionTag=simple("counterId"))
+    let query: Reventless.DcbTag.query = [{tags: [counterTag]}]
+    let after = await readAfter(table, query)
+    let increment = () =>
+      Runtime.appendConditional(
+        table,
+        [event("CounterIncremented", [counterTag])],
+        {query, after: ?after},
+        ~partitionTag=simple("counterId"),
+      )
+    let results = await Promise.all([increment(), increment()])
+    let oks = results->Array.filter(isOk)->Array.length
+    let conflicts = results->Array.filter(isConflict)->Array.length
+    // Safety invariant at the raw-append layer: at most one writer commits, and
+    // every non-winner surfaces a Conflict. (DynamoDB may cancel BOTH with a
+    // mutual TransactionConflict — there is no retry here; the slice callback's
+    // 3-retry loop is what turns this into a guaranteed single winner in prod.)
+    expect(oks <= 1)->toBe(true)
+    expect(oks + conflicts)->toBe(2)
+    expect(conflicts >= 1)->toBe(true)
+  })
+  testAsync("two concurrent first-writers to the same entity — exactly one creates it (Issue 2)", async () => {
+    let table = await H.freshTable()
+    // Both writers read an empty decision model (after=None) and try to create
+    // the same order. The per-(eventType, partition) create guard must let only
+    // one through.
+    let create = () =>
+      Runtime.appendConditional(
+        table,
+        [event("OrderCreated", [tag("orderId", "O1")])],
+        {query: [{tags: [tag("orderId", "O1")]}], after: ?None},
+        ~partitionTag=simple("orderId"),
+      )
+    let results = await Promise.all([create(), create()])
+    let oks = results->Array.filter(isOk)->Array.length
+    // Safety: the two first-writers must NOT both create the entity. At most one
+    // commits; every non-winner surfaces a Conflict. (DynamoDB may cancel both
+    // with a mutual TransactionConflict — the slice callback's retry loop then
+    // makes exactly one win. Pre-fix this asserted-2: both committed = duplicate.)
+    expect(oks <= 1)->toBe(true)
+    expect(oks + results->Array.filter(isConflict)->Array.length)->toBe(2)
+    // No duplicate landed — persisted OrderCreated count matches the winners.
+    let readResult = await Runtime.read(table)(~query=[{tags: [tag("orderId", "O1")]}])
+    expect(readResult.events->Array.length)->toBe(oks)
+  })
+  testAsync("the create guard does not false-conflict a subset-event-type writer (Issue 4)", async () => {
+    let table = await H.freshTable()
+    // A productId partition already holds a ProductAdded (its own create guard +
+    // fence). A different slice reads only NameChanged on that partition, sees
+    // nothing (after=None), and appends the first NameChanged. Its guard is
+    // create#NameChanged#productId:P — distinct from ProductAdded's — so it must
+    // NOT conflict with the pre-existing partition state.
+    let productTag = tag("productId", "P")
+    let r1 = await Runtime.appendConditional(
+      table,
+      [event("ProductAdded", [productTag])],
+      {query: [{tags: [productTag]}], after: ?None},
+      ~partitionTag=simple("productId"),
+    )
+    expect(isOk(r1))->toBe(true)
+    let r2 = await Runtime.appendConditional(
+      table,
+      [event("NameChanged", [productTag])],
+      {query: [{tags: [productTag]}], after: ?None},
+      ~partitionTag=simple("productId"),
+    )
+    expect(isOk(r2))->toBe(true)
+  })
+  testAsync("a chain of compatible commits all succeed", async () => {
+    let table = await H.freshTable()
+    let counterTag = tag("counterId", "K2")
+    let _ = await seed(table, event("CounterStarted", [counterTag]), ~partitionTag=simple("counterId"))
+    let query: Reventless.DcbTag.query = [{tags: [counterTag]}]
+    let step = async () => {
+      let after = await readAfter(table, query)
+      await Runtime.appendConditional(
+        table,
+        [event("CounterIncremented", [counterTag])],
+        {query, after: ?after},
+        ~partitionTag=simple("counterId"),
+      )
+    }
+    let r1 = await step()
+    let r2 = await step()
+    let r3 = await step()
+    expect([r1, r2, r3]->Array.every(isOk))->toBe(true)
+  })
+  testAsync("a failed fence condition aborts the whole transaction (multi-tag atomicity)", async () => {
+    let table = await H.freshTable()
+    // Composite slice: one multi-tag clause → both tags get check+bump.
+    let tags = [tag("productId", "p1"), tag("orderId", "o1")]
+    let query: Reventless.DcbTag.query = [{tags: tags}]
+    // Seed one event so the next append rides after=Some.
+    let seedRes = await Runtime.appendConditional(
+      table,
+      [event("ProductDemandRecorded", tags)],
+      {query, after: ?None},
+      ~partitionTag=simple("productId"),
+    )
+    expect(isOk(seedRes))->toBe(true)
+    let after = (await readAfter(table, query))->Option.getOr("")
+    expect(after == "")->toBe(false)
+    // A concurrent writer advances ONLY the productId fence past `after`.
+    // Appending "z" keeps the position lexically greater than any real position.
+    let _ = await H.setFence(table, tag("productId", "p1"), ~lastPosition=after ++ "z")
+    let r = await Runtime.appendConditional(
+      table,
+      [event("ProductDemandRecorded", tags)],
+      {query, after: ?Some(after)},
+      ~partitionTag=simple("productId"),
+    )
+    expect(isConflict(r))->toBe(true)
+    // Atomic rollback: the second event was NOT written — the composite read
+    // still returns exactly the one seeded event.
+    let readResult = await Runtime.read(table)(~query)
+    expect(readResult.events->Array.length)->toBe(1)
+  })
+})