@reventlessdev/reventless-local 3.0.0-alpha.173 → 3.0.0-alpha.175

package/tests/adapter/EventHistoryResolverTest.res

@@ -0,0 +1,208 @@
+// Behavioural tests for the event-history query resolver's pure core —
+// position ordering, filtering, and keyset pagination. That is where the
+// behaviour lives; the Bus fork around them is two registry lookups.
+
+@@warning("-44")
+
+open JestGlobals
+
+module EH = EventHistoryResolvers_GraphQL
+
+let metaOf = (~user=?, ~time="2026-01-01T00:00:00Z", ()) =>
+  Dict.fromArray([
+    ("service", JSON.Encode.string("OrderingService")),
+    ("time", JSON.Encode.string(time)),
+    ("user", user->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("msgId", JSON.Encode.string("msg-1")),
+    ("correlationId", JSON.Encode.string("corr-1")),
+    ("causationId", JSON.Encode.null),
+  ])->JSON.Encode.object
+
+let rec_ = (~position, ~eventType="OrderPlaced", ~tags=[], ~user=?, ~time="2026-01-01T00:00:00Z", ()): EH.record => {
+  position,
+  eventType,
+  payload: JSON.Encode.object(Dict.make()),
+  tags,
+  meta: metaOf(~user?, ~time, ()),
+  recordedAt: time,
+}
+
+let tag = (key, value): Reventless.DcbTag.tag => {key, value}
+
+let args = (~first=?, ~after=?, ~last=?, ~before=?, ()) => {
+  let d = Dict.make()
+  first->Option.forEach(v => d->Dict.set("first", JSON.Encode.float(v->Int.toFloat)))
+  last->Option.forEach(v => d->Dict.set("last", JSON.Encode.float(v->Int.toFloat)))
+  after->Option.forEach(v => d->Dict.set("after", JSON.Encode.string(v)))
+  before->Option.forEach(v => d->Dict.set("before", JSON.Encode.string(v)))
+  JSON.Encode.object(d)
+}
+
+let positionsOf = (connection: JSON.t): array<string> =>
+  connection
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("edges"))
+  ->Option.flatMap(JSON.Decode.array)
+  ->Option.getOr([])
+  ->Array.filterMap(edge =>
+    edge
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("node"))
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.flatMap(d => d->Dict.get("position"))
+    ->Option.flatMap(JSON.Decode.string)
+  )
+
+let endCursorOf = (connection: JSON.t): option<string> =>
+  connection
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("pageInfo"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(d => d->Dict.get("endCursor"))
+  ->Option.flatMap(JSON.Decode.string)
+
+let hasNextPageOf = (connection: JSON.t): bool =>
+  connection
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("pageInfo"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(d => d->Dict.get("hasNextPage"))
+  ->Option.flatMap(JSON.Decode.bool)
+  ->Option.getOr(false)
+
+describe("EventHistoryResolvers_GraphQL — position ordering", () => {
+  testSync("orders positions numerically, not lexically", () => {
+    // The regression this test exists for: as strings, "10" < "9", so a
+    // lexical sort silently reorders every log that passes nine events and
+    // cursor pages then skip or duplicate.
+    let records = [
+      rec_(~position="10", ()),
+      rec_(~position="9", ()),
+      rec_(~position="2", ()),
+      rec_(~position="11", ()),
+    ]
+    let page = EH.paginate(~records, ~args=args())
+    expect(page->positionsOf)->toEqual(["2", "9", "10", "11"])
+  })
+
+  testSync("a cursor bound crossing a digit boundary skips nothing", () => {
+    let records = Array.make(~length=12, 0)->Array.mapWithIndex((_, i) =>
+      rec_(~position=i->Int.toString, ())
+    )
+    // Page 1 ends at position 9; page 2 must start at 10, not at 1.
+    let page1 = EH.paginate(~records, ~args=args(~first=10, ()))
+    expect(page1->positionsOf->Array.length)->toBe(10)
+    expect(page1->hasNextPageOf)->toBe(true)
+    let cursor = page1->endCursorOf->Option.getOr("")
+    let page2 = EH.paginate(~records, ~args=args(~first=10, ~after=cursor, ()))
+    expect(page2->positionsOf)->toEqual(["10", "11"])
+  })
+})
+
+describe("EventHistoryResolvers_GraphQL — filtering", () => {
+  let records = [
+    rec_(~position="1", ~eventType="OrderPlaced", ~tags=[tag("orderId", "o-1")], ~user="alice", ~time="2026-01-01T00:00:00Z", ()),
+    rec_(~position="2", ~eventType="OrderShipped", ~tags=[tag("orderId", "o-1")], ~user="bob", ~time="2026-01-05T00:00:00Z", ()),
+    rec_(~position="3", ~eventType="OrderPlaced", ~tags=[tag("orderId", "o-2")], ~user="alice", ~time="2026-01-09T00:00:00Z", ()),
+  ]
+  let filtered = f => records->Array.filter(r => EH.matchesFilter(r, f))->Array.map(r => r.position)
+
+  testSync("entityId matches any tag value", () => {
+    expect(filtered({entityId: "o-1"}))->toEqual(["1", "2"])
+  })
+
+  testSync("tagKey + tagValue is the precise form", () => {
+    expect(filtered({tagKey: "orderId", tagValue: "o-2"}))->toEqual(["3"])
+    // A tag key that no event carries matches nothing, rather than falling
+    // back to "everything".
+    expect(filtered({tagKey: "customerId", tagValue: "o-1"}))->toEqual([])
+  })
+
+  testSync("eventTypes narrows to the listed constructors", () => {
+    expect(filtered({eventTypes: ["OrderShipped"]}))->toEqual(["2"])
+  })
+
+  testSync("user filters on the envelope actor", () => {
+    expect(filtered({user: "alice"}))->toEqual(["1", "3"])
+  })
+
+  testSync("time range is inclusive on both bounds", () => {
+    expect(filtered({timeFrom: "2026-01-05T00:00:00Z"}))->toEqual(["2", "3"])
+    expect(filtered({timeTo: "2026-01-05T00:00:00Z"}))->toEqual(["1", "2"])
+    expect(
+      filtered({timeFrom: "2026-01-05T00:00:00Z", timeTo: "2026-01-05T00:00:00Z"}),
+    )->toEqual(["2"])
+  })
+
+  testSync("an empty filter keeps everything", () => {
+    expect(filtered({}))->toEqual(["1", "2", "3"])
+  })
+
+  testSync("filters compose (AND, not OR)", () => {
+    expect(filtered({entityId: "o-1", user: "alice"}))->toEqual(["1"])
+  })
+})
+
+describe("EventHistoryResolvers_GraphQL — argument decoding", () => {
+  testSync("reads every filter field off the GraphQL args", () => {
+    let raw = JSON.Encode.object(
+      Dict.fromArray([
+        (
+          "filter",
+          JSON.Encode.object(
+            Dict.fromArray([
+              ("entityId", JSON.Encode.string("o-1")),
+              ("tagKey", JSON.Encode.string("orderId")),
+              ("tagValue", JSON.Encode.string("o-1")),
+              (
+                "eventTypes",
+                [JSON.Encode.string("OrderPlaced")]->JSON.Encode.array,
+              ),
+              ("user", JSON.Encode.string("alice")),
+              ("timeFrom", JSON.Encode.string("2026-01-01")),
+              ("timeTo", JSON.Encode.string("2026-02-01")),
+            ]),
+          ),
+        ),
+      ]),
+    )
+    let f = EH.readFilter(raw)
+    expect(f.entityId)->toEqual(Some("o-1"))
+    expect(f.tagKey)->toEqual(Some("orderId"))
+    expect(f.eventTypes)->toEqual(Some(["OrderPlaced"]))
+    expect(f.user)->toEqual(Some("alice"))
+    expect(f.timeFrom)->toEqual(Some("2026-01-01"))
+    expect(f.timeTo)->toEqual(Some("2026-02-01"))
+  })
+
+  testSync("absent filter decodes to the everything filter", () => {
+    let f = EH.readFilter(JSON.Encode.object(Dict.make()))
+    expect(f.entityId)->toEqual(None)
+    expect(f.eventTypes)->toEqual(None)
+  })
+})
+
+describe("EventHistoryResolvers_GraphQL — pagination", () => {
+  let records = Array.make(~length=5, 0)->Array.mapWithIndex((_, i) =>
+    rec_(~position=(i + 1)->Int.toString, ())
+  )
+
+  testSync("forward paging reports hasNextPage until exhausted", () => {
+    let page = EH.paginate(~records, ~args=args(~first=2, ()))
+    expect(page->positionsOf)->toEqual(["1", "2"])
+    expect(page->hasNextPageOf)->toBe(true)
+    let last = EH.paginate(~records, ~args=args(~first=10, ()))
+    expect(last->hasNextPageOf)->toBe(false)
+  })
+
+  testSync("backward paging takes the tail", () => {
+    let page = EH.paginate(~records, ~args=args(~last=2, ()))
+    expect(page->positionsOf)->toEqual(["4", "5"])
+  })
+
+  testSync("no records yields an empty connection, not a crash", () => {
+    let page = EH.paginate(~records=[], ~args=args())
+    expect(page->positionsOf)->toEqual([])
+    expect(page->hasNextPageOf)->toBe(false)
+  })
+})

package/tests/adapter/EventHistoryResolverTest.res.mjs

@@ -0,0 +1,286 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EventHistoryResolvers_GraphQL$ReventlessLocal from "../../src/adapter/EventHistory/EventHistoryResolvers_GraphQL.res.mjs";
+
+function metaOf(user, timeOpt, param) {
+  let time = timeOpt !== undefined ? timeOpt : "2026-01-01T00:00:00Z";
+  return Object.fromEntries([
+    [
+      "service",
+      "OrderingService"
+    ],
+    [
+      "time",
+      time
+    ],
+    [
+      "user",
+      Stdlib_Option.mapOr(user, null, prim => prim)
+    ],
+    [
+      "msgId",
+      "msg-1"
+    ],
+    [
+      "correlationId",
+      "corr-1"
+    ],
+    [
+      "causationId",
+      null
+    ]
+  ]);
+}
+
+function rec_(position, eventTypeOpt, tagsOpt, user, timeOpt, param) {
+  let eventType = eventTypeOpt !== undefined ? eventTypeOpt : "OrderPlaced";
+  let tags = tagsOpt !== undefined ? tagsOpt : [];
+  let time = timeOpt !== undefined ? timeOpt : "2026-01-01T00:00:00Z";
+  return {
+    position: position,
+    eventType: eventType,
+    payload: {},
+    tags: tags,
+    meta: metaOf(user, time, undefined),
+    recordedAt: time
+  };
+}
+
+function tag(key, value) {
+  return {
+    key: key,
+    value: value
+  };
+}
+
+function args(first, after, last, before, param) {
+  let d = {};
+  Stdlib_Option.forEach(first, v => {
+    d["first"] = v;
+  });
+  Stdlib_Option.forEach(last, v => {
+    d["last"] = v;
+  });
+  Stdlib_Option.forEach(after, v => {
+    d["after"] = v;
+  });
+  Stdlib_Option.forEach(before, v => {
+    d["before"] = v;
+  });
+  return d;
+}
+
+function positionsOf(connection) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(connection), d => d["edges"]), Stdlib_JSON.Decode.array), []), edge => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(edge), d => d["node"]), Stdlib_JSON.Decode.object), d => d["position"]), Stdlib_JSON.Decode.string));
+}
+
+function endCursorOf(connection) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(connection), d => d["pageInfo"]), Stdlib_JSON.Decode.object), d => d["endCursor"]), Stdlib_JSON.Decode.string);
+}
+
+function hasNextPageOf(connection) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(connection), d => d["pageInfo"]), Stdlib_JSON.Decode.object), d => d["hasNextPage"]), Stdlib_JSON.Decode.bool), false);
+}
+
+globalThis.describe("EventHistoryResolvers_GraphQL — position ordering", () => {
+  globalThis.test("orders positions numerically, not lexically", () => {
+    let records = [
+      rec_("10", undefined, undefined, undefined, undefined, undefined),
+      rec_("9", undefined, undefined, undefined, undefined, undefined),
+      rec_("2", undefined, undefined, undefined, undefined, undefined),
+      rec_("11", undefined, undefined, undefined, undefined, undefined)
+    ];
+    let page = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(undefined, undefined, undefined, undefined, undefined));
+    globalThis.expect(positionsOf(page)).toEqual([
+      "2",
+      "9",
+      "10",
+      "11"
+    ]);
+  });
+  globalThis.test("a cursor bound crossing a digit boundary skips nothing", () => {
+    let records = Stdlib_Array.make(12, 0).map((param, i) => rec_(i.toString(), undefined, undefined, undefined, undefined, undefined));
+    let page1 = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(10, undefined, undefined, undefined, undefined));
+    globalThis.expect(positionsOf(page1).length).toBe(10);
+    globalThis.expect(hasNextPageOf(page1)).toBe(true);
+    let cursor = Stdlib_Option.getOr(endCursorOf(page1), "");
+    let page2 = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(10, cursor, undefined, undefined, undefined));
+    globalThis.expect(positionsOf(page2)).toEqual([
+      "10",
+      "11"
+    ]);
+  });
+});
+
+globalThis.describe("EventHistoryResolvers_GraphQL — filtering", () => {
+  let records = [
+    rec_("1", "OrderPlaced", [{
+        key: "orderId",
+        value: "o-1"
+      }], "alice", "2026-01-01T00:00:00Z", undefined),
+    rec_("2", "OrderShipped", [{
+        key: "orderId",
+        value: "o-1"
+      }], "bob", "2026-01-05T00:00:00Z", undefined),
+    rec_("3", "OrderPlaced", [{
+        key: "orderId",
+        value: "o-2"
+      }], "alice", "2026-01-09T00:00:00Z", undefined)
+  ];
+  let filtered = f => records.filter(r => EventHistoryResolvers_GraphQL$ReventlessLocal.matchesFilter(r, f)).map(r => r.position);
+  globalThis.test("entityId matches any tag value", () => {
+    globalThis.expect(filtered({
+      entityId: "o-1"
+    })).toEqual([
+      "1",
+      "2"
+    ]);
+  });
+  globalThis.test("tagKey + tagValue is the precise form", () => {
+    globalThis.expect(filtered({
+      tagKey: "orderId",
+      tagValue: "o-2"
+    })).toEqual(["3"]);
+    globalThis.expect(filtered({
+      tagKey: "customerId",
+      tagValue: "o-1"
+    })).toEqual([]);
+  });
+  globalThis.test("eventTypes narrows to the listed constructors", () => {
+    globalThis.expect(filtered({
+      eventTypes: ["OrderShipped"]
+    })).toEqual(["2"]);
+  });
+  globalThis.test("user filters on the envelope actor", () => {
+    globalThis.expect(filtered({
+      user: "alice"
+    })).toEqual([
+      "1",
+      "3"
+    ]);
+  });
+  globalThis.test("time range is inclusive on both bounds", () => {
+    globalThis.expect(filtered({
+      timeFrom: "2026-01-05T00:00:00Z"
+    })).toEqual([
+      "2",
+      "3"
+    ]);
+    globalThis.expect(filtered({
+      timeTo: "2026-01-05T00:00:00Z"
+    })).toEqual([
+      "1",
+      "2"
+    ]);
+    globalThis.expect(filtered({
+      timeFrom: "2026-01-05T00:00:00Z",
+      timeTo: "2026-01-05T00:00:00Z"
+    })).toEqual(["2"]);
+  });
+  globalThis.test("an empty filter keeps everything", () => {
+    globalThis.expect(filtered({})).toEqual([
+      "1",
+      "2",
+      "3"
+    ]);
+  });
+  globalThis.test("filters compose (AND, not OR)", () => {
+    globalThis.expect(filtered({
+      entityId: "o-1",
+      user: "alice"
+    })).toEqual(["1"]);
+  });
+});
+
+globalThis.describe("EventHistoryResolvers_GraphQL — argument decoding", () => {
+  globalThis.test("reads every filter field off the GraphQL args", () => {
+    let raw = Object.fromEntries([[
+        "filter",
+        Object.fromEntries([
+          [
+            "entityId",
+            "o-1"
+          ],
+          [
+            "tagKey",
+            "orderId"
+          ],
+          [
+            "tagValue",
+            "o-1"
+          ],
+          [
+            "eventTypes",
+            ["OrderPlaced"]
+          ],
+          [
+            "user",
+            "alice"
+          ],
+          [
+            "timeFrom",
+            "2026-01-01"
+          ],
+          [
+            "timeTo",
+            "2026-02-01"
+          ]
+        ])
+      ]]);
+    let f = EventHistoryResolvers_GraphQL$ReventlessLocal.readFilter(raw);
+    globalThis.expect(f.entityId).toEqual("o-1");
+    globalThis.expect(f.tagKey).toEqual("orderId");
+    globalThis.expect(f.eventTypes).toEqual(["OrderPlaced"]);
+    globalThis.expect(f.user).toEqual("alice");
+    globalThis.expect(f.timeFrom).toEqual("2026-01-01");
+    globalThis.expect(f.timeTo).toEqual("2026-02-01");
+  });
+  globalThis.test("absent filter decodes to the everything filter", () => {
+    let f = EventHistoryResolvers_GraphQL$ReventlessLocal.readFilter({});
+    globalThis.expect(f.entityId).toEqual(undefined);
+    globalThis.expect(f.eventTypes).toEqual(undefined);
+  });
+});
+
+globalThis.describe("EventHistoryResolvers_GraphQL — pagination", () => {
+  let records = Stdlib_Array.make(5, 0).map((param, i) => rec_((i + 1 | 0).toString(), undefined, undefined, undefined, undefined, undefined));
+  globalThis.test("forward paging reports hasNextPage until exhausted", () => {
+    let page = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(2, undefined, undefined, undefined, undefined));
+    globalThis.expect(positionsOf(page)).toEqual([
+      "1",
+      "2"
+    ]);
+    globalThis.expect(hasNextPageOf(page)).toBe(true);
+    let last = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(10, undefined, undefined, undefined, undefined));
+    globalThis.expect(hasNextPageOf(last)).toBe(false);
+  });
+  globalThis.test("backward paging takes the tail", () => {
+    let page = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate(records, args(undefined, undefined, 2, undefined, undefined));
+    globalThis.expect(positionsOf(page)).toEqual([
+      "4",
+      "5"
+    ]);
+  });
+  globalThis.test("no records yields an empty connection, not a crash", () => {
+    let page = EventHistoryResolvers_GraphQL$ReventlessLocal.paginate([], args(undefined, undefined, undefined, undefined, undefined));
+    globalThis.expect(positionsOf(page)).toEqual([]);
+    globalThis.expect(hasNextPageOf(page)).toBe(false);
+  });
+});
+
+let EH;
+
+export {
+  EH,
+  metaOf,
+  rec_,
+  tag,
+  args,
+  positionsOf,
+  endCursorOf,
+  hasNextPageOf,
+}
+/*  Not a pure module */

package/tests/adapter/LocalEvents_ServerTest.res

@@ -0,0 +1,200 @@
+// LocalEvents_Server protocol tests — socket-free.
+//
+// A `connection` is just a capturing `send` callback + subscription dict, so
+// the AppSync Events frame handling, wildcard matching, LocalBus bridge and
+// the publish route are all driven without a WebSocket. The ws attach glue is
+// the only part not covered here (framework territory + a real socket).
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let sentFrames: ref<array<string>> = ref([])
+
+let makeConn = () => {
+  sentFrames := []
+  LocalEvents_Server.addConnection(~send=f => sentFrames.contents->Array.push(f))
+}
+
+let parseFrame = (s: string): dict<JSON.t> =>
+  s->JSON.parseOrThrow->JSON.Decode.object->Option.getOr(Dict.make())
+
+let frameField = (s: string, field: string): option<string> =>
+  parseFrame(s)->Dict.get(field)->Option.flatMap(JSON.Decode.string)
+
+let descriptor = (~id: string): JSON.t =>
+  Dict.fromArray([
+    ("changeKind", JSON.Encode.string("Updated")),
+    ("id", JSON.Encode.string(id)),
+    ("sortKeyValue", JSON.Encode.string("2026-07-28T00:00:00Z")),
+  ])->JSON.Encode.object
+
+describe("LocalEvents_Server", () => {
+  beforeEach(() => LocalEvents_Server.resetConnections())
+
+  describe("channelMatches", () => {
+    testSync("exact match", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/p-1",
+          ~channel="/default/Product/p-1",
+        ),
+      )->toBe(true)
+    })
+    testSync("wildcard prefix matches any depth", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/*",
+          ~channel="/default/Product/p-1",
+        ),
+      )->toBe(true)
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/*",
+          ~channel="/default/Product/p-1/deep",
+        ),
+      )->toBe(true)
+    })
+    testSync("wildcard does not match a sibling with the same stem", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/*",
+          ~channel="/default/ProductArchive/p-1",
+        ),
+      )->toBe(false)
+    })
+    testSync("non-wildcard mismatch", () => {
+      expect(
+        LocalEvents_Server.channelMatches(
+          ~subscription="/default/Product/p-1",
+          ~channel="/default/Product/p-2",
+        ),
+      )->toBe(false)
+    })
+  })
+
+  describe("subscribe protocol", () => {
+    testSync("connection_init is answered with connection_ack", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(conn, `{"type":"connection_init"}`)
+      expect(sentFrames.contents->Array.length)->toBe(1)
+      expect(sentFrames.contents->Array.getUnsafe(0)->frameField("type"))->toEqual(
+        Some("connection_ack"),
+      )
+    })
+
+    testSync("subscribe → state change → data frame on the subscription id", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`,
+      )
+      expect(sentFrames.contents->Array.getUnsafe(0)->frameField("type"))->toEqual(
+        Some("subscribe_success"),
+      )
+      LocalEvents_Server.broadcastStateChange(~name="Product", ~descriptor=descriptor(~id="p-1"))
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      let data = sentFrames.contents->Array.getUnsafe(1)
+      expect(data->frameField("type"))->toEqual(Some("data"))
+      expect(data->frameField("id"))->toEqual(Some("sub-1"))
+      // `event` is a stringified JSON payload — parse the string to verify.
+      let event =
+        data->frameField("event")->Option.getOr("")->JSON.parseOrThrow->JSON.Decode.object
+      expect(
+        event->Option.flatMap(o => o->Dict.get("id"))->Option.flatMap(JSON.Decode.string),
+      )->toEqual(Some("p-1"))
+    })
+
+    testSync("channel segments are normalized like the AWS publisher", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"s","channel":"/default/My-Model/order-1-2026"}`,
+      )
+      // Read-model name `My.Model` and entity key `order#1@2026` normalize to
+      // the subscribed channel (`[^A-Za-z0-9-]` → `-`).
+      LocalEvents_Server.broadcastStateChange(
+        ~name="My.Model",
+        ~descriptor=descriptor(~id="order#1@2026"),
+      )
+      expect(sentFrames.contents->Array.length)->toBe(2)
+    })
+
+    testSync("unsubscribe stops delivery", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`,
+      )
+      LocalEvents_Server.handleFrame(conn, `{"type":"unsubscribe","id":"sub-1"}`)
+      LocalEvents_Server.broadcastStateChange(~name="Product", ~descriptor=descriptor(~id="p-1"))
+      // subscribe_success + unsubscribe_success, but no data frame
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      expect(sentFrames.contents->Array.getUnsafe(1)->frameField("type"))->toEqual(
+        Some("unsubscribe_success"),
+      )
+    })
+
+    testSync("malformed and unknown frames are ignored", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(conn, `not json`)
+      LocalEvents_Server.handleFrame(conn, `{"type":"mystery"}`)
+      LocalEvents_Server.handleFrame(conn, `{"type":"subscribe","id":"only-id"}`)
+      expect(sentFrames.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("handlePublish", () => {
+    testSync("rejects non-client channels with 403", () => {
+      let (status, _) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/default/Product/p-1","events":["{}"]}`,
+      )
+      expect(status)->toBe(403)
+    })
+
+    testSync("rejects an unverifiable token with 401", () => {
+      let (status, _) = LocalEvents_Server.handlePublish(
+        ~authorization=Some("garbage-token"),
+        ~body=`{"channel":"/client/x","events":["{}"]}`,
+      )
+      expect(status)->toBe(401)
+    })
+
+    testSync("rejects malformed bodies with 400", () => {
+      let (s1, _) = LocalEvents_Server.handlePublish(~authorization=None, ~body=`nope`)
+      let (s2, _) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/client/x","events":[]}`,
+      )
+      expect(s1)->toBe(400)
+      expect(s2)->toBe(400)
+    })
+
+    testSync("fans out to a wildcard subscriber and accounts per event", () => {
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"sub-p","channel":"/client/shop/presence/*"}`,
+      )
+      let (status, response) = LocalEvents_Server.handlePublish(
+        ~authorization=None,
+        ~body=`{"channel":"/client/shop/presence/room-1","events":["{\\"userId\\":\\"u1\\"}","not json",42]}`,
+      )
+      expect(status)->toBe(200)
+      let counts =
+        response
+        ->JSON.Decode.object
+        ->Option.map(o => (
+          o->Dict.get("successful")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length,
+          o->Dict.get("failed")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length,
+        ))
+      expect(counts)->toEqual(Some((1, 2)))
+      // subscribe_success + one data frame for the one valid event
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      let data = sentFrames.contents->Array.getUnsafe(1)
+      expect(data->frameField("id"))->toEqual(Some("sub-p"))
+      expect(data->frameField("event"))->toEqual(Some(`{"userId":"u1"}`))
+    })
+  })
+})