@reventlessdev/reventless-local 3.0.0-alpha.172 → 3.0.0-alpha.174

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.174 (2026-07-27)
+
+### Features
+
+* **api:** event-history query — the Source A read counterpart ([9268b33](https://github.com/ReventlessDev/reventless-core/commit/9268b33a4835d4cd4bc79b38f19bc2b974853fa4))
+
+
+# 3.0.0-alpha.173 (2026-07-27)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
 # 3.0.0-alpha.172 (2026-07-27)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.172",
+  "version": "3.0.0-alpha.174",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -34,13 +34,13 @@
     "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.25",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.184",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.32",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.131",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.48",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.186",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.34",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.133",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.106",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.50",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
   },
   "devDependencies": {

package/src/Platform.res

@@ -221,6 +221,10 @@ module MakeWithConfig = (
       }
     }
 
+  // Event-history query resolvers. Reads the same event logs the Source A
+  // subscription bridge below streams, but historically and per entity.
+  module EventHistoryResolvers = EventHistoryResolvers_GraphQL.Make(Bus)
+
   // Platform hook record — callbacks known at MakeWithConfig time plus a
   // mutable ref for admin extension points (set by makePlatform/deployPlugin
   // after Admin.construct returns, before plugins are built).
@@ -269,6 +273,11 @@ module MakeWithConfig = (
     inboundMutationBindReceiveHook: InboundTranslationResolvers_GraphQL.bindReceive,
     // Register GraphQL type definitions from the generated schema fragment.
     schemaTypeRegistrationHook: sdlTypes => resolveTargetGraphQL().registerTypes(~sdlTypes),
+    // Event-history queries — the historical read counterpart of the Source A
+    // subscription bridged further down. Same `eventLogEntries`, so the two
+    // always describe the same set of streams.
+    eventQueryResolverHook: params =>
+      EventHistoryResolvers.register(~server=resolveTargetGraphQL(), params),
     // MCP tools and resources — registered during plugin construction.
     // See the large lambda below; it references Bus for QueryDb lookups.
     mcpSchemaRegistrationHook: ({pluginName, mutationEntries, queryEntries, eventLogEntries, subscriptionFields}) => {

package/src/Platform.res.mjs

@@ -76,6 +76,7 @@ import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "./adapter/DcbEventLo
 import * as LocalEventCollectorChannel$ReventlessLocal from "./adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
 import * as PluginRuntime_Builder_Micro$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/PluginRuntime_Builder_Micro.res.mjs";
 import * as UiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
+import * as EventHistoryResolvers_GraphQL$ReventlessLocal from "./adapter/EventHistory/EventHistoryResolvers_GraphQL.res.mjs";
 import * as InboundTranslationSlice_Builder$ReventlessLocal from "./components/InboundTranslationSlice_Builder.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_ComponentDefinitionsApi.res.mjs";
 import * as OutboundTranslationSlice_Builder$ReventlessLocal from "./components/OutboundTranslationSlice_Builder.res.mjs";
@@ -192,6 +193,7 @@ function MakeWithConfig(Config) {
       return PlatformMCP_Server$ReventlessLocal.asInterface;
     }
   };
+  let EventHistoryResolvers = EventHistoryResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let hooks_mutationResolverHook = (kind, fields, commandSchema, commandAuthorization) => {
     let server = resolveTargetGraphQL();
     if (kind === "Aggregate") {
@@ -407,6 +409,7 @@ function MakeWithConfig(Config) {
     });
     LocalGraphQL_SubscriptionResolvers$ReventlessLocal.registerAll(server, subscriptionFields, sourceAEntries, []);
   };
+  let hooks_eventQueryResolverHook = params => EventHistoryResolvers.register(resolveTargetGraphQL(), params);
   let hooks_adminExtensionPoints = {
     contents: Pulumi.output({})
   };
@@ -435,6 +438,7 @@ function MakeWithConfig(Config) {
     inboundMutationBindReceiveHook: hooks_inboundMutationBindReceiveHook,
     schemaTypeRegistrationHook: hooks_schemaTypeRegistrationHook,
     mcpSchemaRegistrationHook: hooks_mcpSchemaRegistrationHook,
+    eventQueryResolverHook: hooks_eventQueryResolverHook,
     adminExtensionPoints: hooks_adminExtensionPoints,
     scheduler: hooks_scheduler,
     schedulerRoleUrn: hooks_schedulerRoleUrn,
@@ -1862,6 +1866,7 @@ function Make($star) {
       return PlatformMCP_Server$ReventlessLocal.asInterface;
     }
   };
+  let EventHistoryResolvers = EventHistoryResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let hooks_mutationResolverHook = (kind, fields, commandSchema, commandAuthorization) => {
     let server = resolveTargetGraphQL();
     if (kind === "Aggregate") {
@@ -2077,6 +2082,7 @@ function Make($star) {
     });
     LocalGraphQL_SubscriptionResolvers$ReventlessLocal.registerAll(server, subscriptionFields, sourceAEntries, []);
   };
+  let hooks_eventQueryResolverHook = params => EventHistoryResolvers.register(resolveTargetGraphQL(), params);
   let hooks_adminExtensionPoints = {
     contents: Pulumi.output({})
   };
@@ -2105,6 +2111,7 @@ function Make($star) {
     inboundMutationBindReceiveHook: hooks_inboundMutationBindReceiveHook,
     schemaTypeRegistrationHook: hooks_schemaTypeRegistrationHook,
     mcpSchemaRegistrationHook: hooks_mcpSchemaRegistrationHook,
+    eventQueryResolverHook: hooks_eventQueryResolverHook,
     adminExtensionPoints: hooks_adminExtensionPoints,
     scheduler: hooks_scheduler,
     schedulerRoleUrn: hooks_schedulerRoleUrn,

package/src/adapter/EventHistory/EventHistoryResolvers_GraphQL.res

@@ -0,0 +1,352 @@
+// Local (yoga) resolvers for the event-history queries whose SDL is emitted by
+// `Plugin_EventQuerySchema` — the historical read counterpart of the Source A
+// raw-event subscription.
+//
+// Two flavours of event log land in the same `eventLogEntries` array and are
+// read differently, exactly as the MCP event-history handler in Platform.res
+// forks them:
+//
+//   aggregate log → Bus.getEventLogReplay(busKey)   — replay by entity id
+//   DCB log       → Bus.getDcbEventLogRead(busKey)  — read(~query) by tag
+//
+// The difference that matters to a caller: an aggregate log is only readable
+// *per entity* (replay takes an id), so a filter-less plugin-wide query over
+// one returns nothing and says so. A DCB log answers both.
+//
+// Unlike the MCP handler, this keeps `meta` and `recordedAt` — who caused each
+// change and when is the point of reading a history at all.
+
+open ReventlessCore
+
+// Positions are numeric strings. Comparing them lexically silently breaks the
+// moment a log crosses a digit boundary ("10" > "9" is false as strings), which
+// makes cursor pages skip or duplicate events. One implementation, used for
+// both the sort and the cursor bound.
+let comparePosition = (a: string, b: string): float =>
+  switch (Int.fromString(a), Int.fromString(b)) {
+  | (Some(ai), Some(bi)) => (ai - bi)->Int.toFloat
+  | _ =>
+    if a < b {
+      -1.
+    } else if a > b {
+      1.
+    } else {
+      0.
+    }
+  }
+
+let positionGt = (a, b) => comparePosition(a, b) > 0.
+let positionLt = (a, b) => comparePosition(a, b) < 0.
+
+// ── The normalised record every branch produces ──────────────────────────────
+// Mirrors the `{N}EventRecord` SDL type field for field.
+
+type record = {
+  position: string,
+  eventType: string,
+  payload: JSON.t,
+  tags: array<Reventless.DcbTag.tag>,
+  meta: JSON.t,
+  recordedAt: string,
+}
+
+let str = JSON.Encode.string
+let optStr = o => o->Option.mapOr(JSON.Encode.null, str)
+
+// Only the audit-relevant subset of `Message.meta` crosses to the client —
+// `ip`, `traceparent`, `schemaVersion` and the `headers` context bag are
+// deliberately dropped here as well as in the SDL, so a future SDL widening
+// can't quietly start leaking them.
+let metaJson = (m: Reventless.Message.meta): JSON.t =>
+  Dict.fromArray([
+    ("service", str(m.service)),
+    ("time", str(m.time)),
+    ("user", optStr(m.user)),
+    ("msgId", str(m.msgId)),
+    ("correlationId", str(m.correlationId)),
+    ("causationId", optStr(m.causationId)),
+  ])->JSON.Encode.object
+
+// Same subset, read out of a stored aggregate envelope (which is raw JSON, not
+// a decoded `Message.meta`).
+let metaJsonFromEnvelope = (envelope: Dict.t<JSON.t>): JSON.t => {
+  let m = envelope->Dict.get("meta")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let get = k => m->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  Dict.fromArray([
+    ("service", get("service")->Option.getOr("")->str),
+    ("time", get("time")->Option.getOr("")->str),
+    ("user", get("user")->optStr),
+    ("msgId", get("msgId")->Option.getOr("")->str),
+    ("correlationId", get("correlationId")->Option.getOr("")->str),
+    ("causationId", get("causationId")->optStr),
+  ])->JSON.Encode.object
+}
+
+let recordJson = (r: record): JSON.t =>
+  Dict.fromArray([
+    ("position", str(r.position)),
+    ("eventType", str(r.eventType)),
+    ("payload", r.payload),
+    (
+      "tags",
+      r.tags
+      ->Array.map(t =>
+        Dict.fromArray([("key", str(t.key)), ("value", str(t.value))])->JSON.Encode.object
+      )
+      ->JSON.Encode.array,
+    ),
+    ("meta", r.meta),
+    ("recordedAt", str(r.recordedAt)),
+  ])->JSON.Encode.object
+
+// ── Filter arguments ─────────────────────────────────────────────────────────
+
+type filter = {
+  entityId?: string,
+  tagKey?: string,
+  tagValue?: string,
+  eventTypes?: array<string>,
+  user?: string,
+  timeFrom?: string,
+  timeTo?: string,
+}
+
+let readFilter = (args: JSON.t): filter => {
+  let f =
+    args
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("filter"))
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.getOr(Dict.make())
+  let s = k => f->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  {
+    entityId: ?s("entityId"),
+    tagKey: ?s("tagKey"),
+    tagValue: ?s("tagValue"),
+    eventTypes: ?f
+    ->Dict.get("eventTypes")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.map(a => a->Array.filterMap(JSON.Decode.string)),
+    user: ?s("user"),
+    timeFrom: ?s("timeFrom"),
+    timeTo: ?s("timeTo"),
+  }
+}
+
+// The tag a caller means: the precise (tagKey, tagValue) pair when given,
+// otherwise the `entityId` shortcut matched against ANY tag value.
+let matchesTag = (r: record, f: filter): bool =>
+  switch (f.tagKey, f.tagValue) {
+  | (Some(k), Some(v)) => r.tags->Array.some(t => t.key == k && t.value == v)
+  | (None, Some(v)) => r.tags->Array.some(t => t.value == v)
+  | (Some(k), None) => r.tags->Array.some(t => t.key == k)
+  | (None, None) =>
+    switch f.entityId {
+    | Some(id) => r.tags->Array.some(t => t.value == id)
+    | None => true
+    }
+  }
+
+let matchesFilter = (r: record, f: filter): bool => {
+  let userOf = () =>
+    r.meta->JSON.Decode.object->Option.flatMap(d => d->Dict.get("user"))->Option.flatMap(JSON.Decode.string)
+  let timeOf = () =>
+    r.meta
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("time"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr(r.recordedAt)
+  matchesTag(r, f) &&
+  f.eventTypes->Option.mapOr(true, types => types->Array.includes(r.eventType)) &&
+  f.user->Option.mapOr(true, u => userOf() == Some(u)) &&
+  f.timeFrom->Option.mapOr(true, from => timeOf() >= from) &&
+  f.timeTo->Option.mapOr(true, to_ => timeOf() <= to_)
+}
+
+// ── Pagination ───────────────────────────────────────────────────────────────
+// Keyset over `position`, ascending (oldest first) — the natural reading order
+// for a history. Reuses QueryDbListQuery's connection builder so edges,
+// cursors and pageInfo are byte-identical in shape to every other connection
+// in the API, so existing client pagination applies unchanged.
+
+let paginate = (~records: array<record>, ~args: JSON.t): JSON.t => {
+  let argsDict = args->JSON.Decode.object->Option.getOr(Dict.make())
+  let getInt = k =>
+    argsDict->Dict.get(k)->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+  let getStr = k => argsDict->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+
+  let sorted = records->Array.toSorted((a, b) => comparePosition(a.position, b.position))
+
+  let first = getInt("first")
+  let last = getInt("last")
+  let after = getStr("after")
+  let before = getStr("before")
+  let isBackward = last->Option.isSome
+
+  let bounded = switch (after, before) {
+  | (Some(c), _) if !isBackward =>
+    let cv = QueryDbListQuery.decodeCursor(c)
+    sorted->Array.filter(r => positionGt(r.position, cv))
+  | (_, Some(c)) if isBackward =>
+    let cv = QueryDbListQuery.decodeCursor(c)
+    sorted->Array.filter(r => positionLt(r.position, cv))
+  | _ => sorted
+  }
+
+  let pageSize = (isBackward ? last : first)->Option.getOr(QueryDbListQuery.defaultListPageSize)
+  let take = pageSize + 1
+  let (pageItems, hasMore) = if isBackward {
+    let len = bounded->Array.length
+    let startIdx = len > take ? len - take : 0
+    let arr = bounded->Array.slice(~start=startIdx, ~end=len)
+    let hasMore = arr->Array.length > pageSize
+    (hasMore ? arr->Array.slice(~start=1, ~end=arr->Array.length) : arr, hasMore)
+  } else {
+    let arr = bounded->Array.slice(~start=0, ~end=take)
+    let hasMore = arr->Array.length > pageSize
+    (arr->Array.slice(~start=0, ~end=pageSize), hasMore)
+  }
+
+  QueryDbListQuery.buildConnection(
+    ~pageItems=pageItems->Array.map(recordJson),
+    ~hasNextPage=!isBackward && hasMore,
+    ~hasPreviousPage=isBackward && hasMore,
+    ~cursorValueOf=item =>
+      item
+      ->JSON.Decode.object
+      ->Option.flatMap(d => d->Dict.get("position"))
+      ->Option.flatMap(JSON.Decode.string)
+      ->Option.getOr(""),
+  )
+}
+
+let emptyConnection = () =>
+  QueryDbListQuery.buildConnection(
+    ~pageItems=[],
+    ~hasNextPage=false,
+    ~hasPreviousPage=false,
+    ~cursorValueOf=_ => "",
+  )
+
+module Make = (Bus: LocalBus.T) => {
+  let log = Logger.fromEnv()
+
+  // A DCB read narrowed to the caller's tag whenever one was supplied. Pushing
+  // the tag into the query means only the unfiltered plugin-wide sweep — the
+  // rare case — ever reads broadly; the audit-trail case reads just its entity.
+  let dcbQueryFor = (f: filter): Reventless.DcbTag.query =>
+    switch (f.tagKey, f.tagValue, f.entityId) {
+    | (Some(k), Some(v), _) => [{tags: [{key: k, value: v}]}]
+    | _ => []
+    }
+
+  let readDcb = async (
+    read: (
+      ~query: Reventless.DcbTag.query,
+      ~after: Reventless.DcbTag.sequencePosition=?,
+    ) => promise<ReventlessCore.DcbEventLog_Adapter.rawReadResult>,
+    f: filter,
+  ) => {
+    let result = await read(~query=dcbQueryFor(f), ~after=?None)
+    result.ReventlessCore.DcbEventLog_Adapter.events->Array.map(e => {
+      position: e.position,
+      eventType: e.eventType,
+      payload: e.data,
+      tags: e.tags,
+      meta: metaJson(e.meta),
+      recordedAt: e.recordedAt,
+    })
+  }
+
+  // Aggregate logs replay per entity and return the stored `{id, meta, event}`
+  // envelopes in seq order, so the array index IS the sequence position.
+  let readAggregate = async (~replay, ~entityId) => {
+    let envelopes = await replay(entityId)
+    envelopes->Array.mapWithIndex((json, i) => {
+      let obj = json->JSON.Decode.object->Option.getOr(Dict.make())
+      let event = obj->Dict.get("event")->Option.getOr(JSON.Encode.null)
+      let id =
+        obj->Dict.get("id")->Option.flatMap(JSON.Decode.string)->Option.getOr(entityId)
+      let meta = metaJsonFromEnvelope(obj)
+      let time =
+        meta
+        ->JSON.Decode.object
+        ->Option.flatMap(d => d->Dict.get("time"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.getOr("")
+      {
+        position: i->Int.toString,
+        eventType: Reventless.Message.variantNameOfJson(event),
+        payload: event,
+        tags: [{Reventless.DcbTag.key: "id", value: id}],
+        meta,
+        // An aggregate log stores no separate storage timestamp — producer
+        // time is the only one there is.
+        recordedAt: time,
+      }
+    })
+  }
+
+  let register = (
+    ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t,
+    params: Plugin_Helpers.eventQueryRegistrationParams,
+  ) => {
+    let seen: Set.t<string> = Set.make()
+
+    params.eventLogEntries->Array.forEach(entry => {
+      let displayName = entry.displayName
+      if !(seen->Set.has(displayName)) {
+        seen->Set.add(displayName)
+        let fieldName = Plugin_EventQuerySchema.historyFieldName(
+          ~plugin=params.pluginName,
+          ~displayName,
+        )
+
+        let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+          _root,
+          args,
+          _ctx,
+        ) => {
+          let f = readFilter(args)
+          let records = switch Bus.getEventLogReplay(entry.busKey) {
+          | Some(replay) =>
+            switch f.entityId {
+            | Some(entityId) => await readAggregate(~replay, ~entityId)
+            | None =>
+              // Not a silent empty page: an aggregate log genuinely cannot be
+              // read without an id, and a caller who omitted one asked a
+              // question this log cannot answer.
+              log.warn(
+                ~comp="EventHistoryResolvers_GraphQL",
+                `${fieldName}: ${displayName} is an aggregate event log — it can only be read per entity. Supply filter.entityId.`,
+              )
+              []
+            }
+          | None =>
+            switch Bus.getDcbEventLogRead(entry.busKey) {
+            | Some(read) => await readDcb(read, f)
+            | None => []
+            }
+          }
+          switch records {
+          | [] => emptyConnection()
+          | _ => paginate(~records=records->Array.filter(r => matchesFilter(r, f)), ~args)
+          }
+        }
+
+        // The SDL comes from the same generator that produced the plugin
+        // fragment's field, so the local server's schema and the fragment can
+        // not disagree about arguments or return type. (The supporting types
+        // reach the server separately, via `schemaTypeRegistrationHook` over
+        // the fragment's `types`.)
+        let sdlFields =
+          Plugin_EventQuerySchema.generate(
+            ~plugin=params.pluginName,
+            ~eventLogEntries=[entry],
+          ).queryFields
+
+        server.registerQueries(~sdlFields, ~resolvers=Dict.fromArray([(fieldName, resolver)]))
+      }
+    })
+  }
+}

package/src/adapter/EventHistory/EventHistoryResolvers_GraphQL.res.mjs

@@ -0,0 +1,362 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
+import * as Plugin_EventQuerySchema$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_EventQuerySchema.res.mjs";
+
+function comparePosition(a, b) {
+  let match = Stdlib_Int.fromString(a, undefined);
+  let match$1 = Stdlib_Int.fromString(b, undefined);
+  if (match !== undefined && match$1 !== undefined) {
+    return match - match$1 | 0;
+  }
+  if (a < b) {
+    return -1;
+  } else if (a > b) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+function positionGt(a, b) {
+  return comparePosition(a, b) > 0;
+}
+
+function positionLt(a, b) {
+  return comparePosition(a, b) < 0;
+}
+
+function str(prim) {
+  return prim;
+}
+
+function optStr(o) {
+  return Stdlib_Option.mapOr(o, null, str);
+}
+
+function metaJson(m) {
+  return Object.fromEntries([
+    [
+      "service",
+      m.service
+    ],
+    [
+      "time",
+      m.time
+    ],
+    [
+      "user",
+      Stdlib_Option.mapOr(m.user, null, str)
+    ],
+    [
+      "msgId",
+      m.msgId
+    ],
+    [
+      "correlationId",
+      m.correlationId
+    ],
+    [
+      "causationId",
+      Stdlib_Option.mapOr(m.causationId, null, str)
+    ]
+  ]);
+}
+
+function metaJsonFromEnvelope(envelope) {
+  let m = Stdlib_Option.getOr(Stdlib_Option.flatMap(envelope["meta"], Stdlib_JSON.Decode.object), {});
+  let get = k => Stdlib_Option.flatMap(m[k], Stdlib_JSON.Decode.string);
+  return Object.fromEntries([
+    [
+      "service",
+      Stdlib_Option.getOr(get("service"), "")
+    ],
+    [
+      "time",
+      Stdlib_Option.getOr(get("time"), "")
+    ],
+    [
+      "user",
+      Stdlib_Option.mapOr(get("user"), null, str)
+    ],
+    [
+      "msgId",
+      Stdlib_Option.getOr(get("msgId"), "")
+    ],
+    [
+      "correlationId",
+      Stdlib_Option.getOr(get("correlationId"), "")
+    ],
+    [
+      "causationId",
+      Stdlib_Option.mapOr(get("causationId"), null, str)
+    ]
+  ]);
+}
+
+function recordJson(r) {
+  return Object.fromEntries([
+    [
+      "position",
+      r.position
+    ],
+    [
+      "eventType",
+      r.eventType
+    ],
+    [
+      "payload",
+      r.payload
+    ],
+    [
+      "tags",
+      r.tags.map(t => Object.fromEntries([
+        [
+          "key",
+          t.key
+        ],
+        [
+          "value",
+          t.value
+        ]
+      ]))
+    ],
+    [
+      "meta",
+      r.meta
+    ],
+    [
+      "recordedAt",
+      r.recordedAt
+    ]
+  ]);
+}
+
+function readFilter(args) {
+  let f = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["filter"]), Stdlib_JSON.Decode.object), {});
+  let s = k => Stdlib_Option.flatMap(f[k], Stdlib_JSON.Decode.string);
+  return {
+    entityId: s("entityId"),
+    tagKey: s("tagKey"),
+    tagValue: s("tagValue"),
+    eventTypes: Stdlib_Option.map(Stdlib_Option.flatMap(f["eventTypes"], Stdlib_JSON.Decode.array), a => Stdlib_Array.filterMap(a, Stdlib_JSON.Decode.string)),
+    user: s("user"),
+    timeFrom: s("timeFrom"),
+    timeTo: s("timeTo")
+  };
+}
+
+function matchesTag(r, f) {
+  let match = f.tagKey;
+  let match$1 = f.tagValue;
+  if (match !== undefined) {
+    if (match$1 !== undefined) {
+      return r.tags.some(t => {
+        if (t.key === match) {
+          return t.value === match$1;
+        } else {
+          return false;
+        }
+      });
+    } else {
+      return r.tags.some(t => t.key === match);
+    }
+  }
+  if (match$1 !== undefined) {
+    return r.tags.some(t => t.value === match$1);
+  }
+  let id = f.entityId;
+  if (id !== undefined) {
+    return r.tags.some(t => t.value === id);
+  } else {
+    return true;
+  }
+}
+
+function matchesFilter(r, f) {
+  let userOf = () => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(r.meta), d => d["user"]), Stdlib_JSON.Decode.string);
+  let timeOf = () => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(r.meta), d => d["time"]), Stdlib_JSON.Decode.string), r.recordedAt);
+  if (matchesTag(r, f) && Stdlib_Option.mapOr(f.eventTypes, true, types => types.includes(r.eventType)) && Stdlib_Option.mapOr(f.user, true, u => Primitive_object.equal(userOf(), u)) && Stdlib_Option.mapOr(f.timeFrom, true, from => timeOf() >= from)) {
+    return Stdlib_Option.mapOr(f.timeTo, true, to_ => timeOf() <= to_);
+  } else {
+    return false;
+  }
+}
+
+function paginate(records, args) {
+  let argsDict = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(args), {});
+  let getInt = k => Stdlib_Option.map(Stdlib_Option.flatMap(argsDict[k], Stdlib_JSON.Decode.float), prim => prim | 0);
+  let getStr = k => Stdlib_Option.flatMap(argsDict[k], Stdlib_JSON.Decode.string);
+  let sorted = records.toSorted((a, b) => comparePosition(a.position, b.position));
+  let first = getInt("first");
+  let last = getInt("last");
+  let after = getStr("after");
+  let before = getStr("before");
+  let isBackward = Stdlib_Option.isSome(last);
+  let bounded;
+  let exit = 0;
+  if (after !== undefined && !isBackward) {
+    let cv = QueryDbListQuery$ReventlessCore.decodeCursor(after);
+    bounded = sorted.filter(r => positionGt(r.position, cv));
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    if (before !== undefined && isBackward) {
+      let cv$1 = QueryDbListQuery$ReventlessCore.decodeCursor(before);
+      bounded = sorted.filter(r => positionLt(r.position, cv$1));
+    } else {
+      bounded = sorted;
+    }
+  }
+  let pageSize = Stdlib_Option.getOr(isBackward ? last : first, QueryDbListQuery$ReventlessCore.defaultListPageSize);
+  let take = pageSize + 1 | 0;
+  let match;
+  if (isBackward) {
+    let len = bounded.length;
+    let startIdx = len > take ? len - take | 0 : 0;
+    let arr = bounded.slice(startIdx, len);
+    let hasMore = arr.length > pageSize;
+    match = [
+      hasMore ? arr.slice(1, arr.length) : arr,
+      hasMore
+    ];
+  } else {
+    let arr$1 = bounded.slice(0, take);
+    let hasMore$1 = arr$1.length > pageSize;
+    match = [
+      arr$1.slice(0, pageSize),
+      hasMore$1
+    ];
+  }
+  let hasMore$2 = match[1];
+  return QueryDbListQuery$ReventlessCore.buildConnection(match[0].map(recordJson), !isBackward && hasMore$2, isBackward && hasMore$2, item => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d["position"]), Stdlib_JSON.Decode.string), ""));
+}
+
+function emptyConnection() {
+  return QueryDbListQuery$ReventlessCore.buildConnection([], false, false, param => "");
+}
+
+function Make(Bus) {
+  let log = Logger$ReventlessCore.fromEnv();
+  let dcbQueryFor = f => {
+    let match = f.tagKey;
+    let match$1 = f.tagValue;
+    if (match !== undefined) {
+      if (match$1 !== undefined) {
+        return [{
+            tags: [{
+                key: match,
+                value: match$1
+              }]
+          }];
+      } else {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  };
+  let readDcb = async (read, f) => {
+    let result = await read(dcbQueryFor(f), undefined);
+    return result.events.map(e => ({
+      position: e.position,
+      eventType: e.eventType,
+      payload: e.data,
+      tags: e.tags,
+      meta: metaJson(e.meta),
+      recordedAt: e.recordedAt
+    }));
+  };
+  let readAggregate = async (replay, entityId) => {
+    let envelopes = await replay(entityId);
+    return envelopes.map((json, i) => {
+      let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(json), {});
+      let event = Stdlib_Option.getOr(obj["event"], null);
+      let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["id"], Stdlib_JSON.Decode.string), entityId);
+      let meta = metaJsonFromEnvelope(obj);
+      let time = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(meta), d => d["time"]), Stdlib_JSON.Decode.string), "");
+      return {
+        position: i.toString(),
+        eventType: Message$Reventless.variantNameOfJson(event),
+        payload: event,
+        tags: [{
+            key: "id",
+            value: id
+          }],
+        meta: meta,
+        recordedAt: time
+      };
+    });
+  };
+  let register = (server, params) => {
+    let seen = new Set();
+    params.eventLogEntries.forEach(entry => {
+      let displayName = entry.displayName;
+      if (seen.has(displayName)) {
+        return;
+      }
+      seen.add(displayName);
+      let fieldName = Plugin_EventQuerySchema$ReventlessCore.historyFieldName(params.pluginName, displayName);
+      let resolver = async (_root, args, _ctx) => {
+        let f = readFilter(args);
+        let replay = Bus.getEventLogReplay(entry.busKey);
+        let records;
+        if (replay !== undefined) {
+          let entityId = f.entityId;
+          if (entityId !== undefined) {
+            records = await readAggregate(replay, entityId);
+          } else {
+            log.warn("EventHistoryResolvers_GraphQL", undefined, fieldName + `: ` + displayName + ` is an aggregate event log — it can only be read per entity. Supply filter.entityId.`);
+            records = [];
+          }
+        } else {
+          let read = Bus.getDcbEventLogRead(entry.busKey);
+          records = read !== undefined ? await readDcb(read, f) : [];
+        }
+        if (records.length !== 0) {
+          return paginate(records.filter(r => matchesFilter(r, f)), args);
+        } else {
+          return emptyConnection();
+        }
+      };
+      let sdlFields = Plugin_EventQuerySchema$ReventlessCore.generate(params.pluginName, [entry]).queryFields;
+      server.registerQueries(sdlFields, Object.fromEntries([[
+          fieldName,
+          resolver
+        ]]));
+    });
+  };
+  return {
+    log: log,
+    dcbQueryFor: dcbQueryFor,
+    readDcb: readDcb,
+    readAggregate: readAggregate,
+    register: register
+  };
+}
+
+export {
+  comparePosition,
+  positionGt,
+  positionLt,
+  str,
+  optStr,
+  metaJson,
+  metaJsonFromEnvelope,
+  recordJson,
+  readFilter,
+  matchesTag,
+  matchesFilter,
+  paginate,
+  emptyConnection,
+  Make,
+}
+/* Message-Reventless Not a pure module */

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 */