@reventlessdev/reventless-core 3.0.0-alpha.142 → 3.0.0-alpha.144

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.144 (2026-07-07)
+
+### Bug Fixes
+
+* **reventless-aws:** thread inferred DCB scope into the deployed command handler ([4d8327f](https://github.com/ReventlessDev/reventless-core/commit/4d8327fad8659a1cde8c36098c72392737437af1))
+
+
+# 3.0.0-alpha.143 (2026-07-06)
+
+### Features
+
+* **reventless-aws:** classic EventLog Postgres deploy-time wiring + relay (B1 vertical) ([8235ba4](https://github.com/ReventlessDev/reventless-core/commit/8235ba44e506f7094d17251405c6a05c39789805))
+
+
 # 3.0.0-alpha.142 (2026-07-05)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.142",
+  "version": "3.0.0-alpha.144",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.90",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.13",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.88",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.23",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.66"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.68"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
@@ -61,7 +61,7 @@
     "build": "rescript build",
     "start": "rescript watch",
     "clean": "rescript clean",
-    "rebuild": "pnpm run clean && pnpm run build -- -with-deps",
+    "rebuild": "pnpm run clean && pnpm run build",
     "deploy": "./scripts/deploy.sh",
     "test": "NODE_OPTIONS='--experimental-vm-modules' jest",
     "test:watch": "jest --watchAll",

package/src/components/Api/QueryDbListQuery.res

@@ -0,0 +1,264 @@
+// The connection-list filter / sort / keyset-paginate logic, extracted verbatim
+// from QueryDbResolvers_GraphQL so there is ONE source of truth for the
+// semantics. The in-memory / GraphQL resolver calls `run` over the materialised
+// items; the SQLite backend's list push-down (reventless-local) and the Postgres
+// resolver Lambda (reventless-aws) must reproduce these exact semantics, and the
+// parity harness asserts they do. Kept pure (no server / storage dependencies —
+// the one server helper it needs, global-id decoding for the `ids` filter, is
+// passed in) so it can be the shared spec every backend is tested against.
+//
+// Lives in reventless-core (not reventless-local) so both the local SQLite path
+// and the AWS Postgres resolver path can share it without a layering violation —
+// `GraphQL_FragmentGenerator.serverCapability`, its only dependency, is a sibling
+// here.
+
+// base64 cursor of the active sort field's value. Shared with the resolver's
+// items (sub-id) connection so cursor encoding stays in lockstep.
+@val external btoa: string => string = "btoa"
+@val external atob: string => string = "atob"
+let encodeCursor = (value: string): string => btoa(value)
+let decodeCursor = (cursor: string): string => atob(cursor)
+
+// Default page size when neither `first` nor `last` is supplied — a bound is
+// required for keyset `pageInfo` to be reported correctly.
+let defaultListPageSize = 50
+
+// The effective id of an item (its "id" field). Shared with the SQLite
+// push-down so both compute the tiebreak / default-cursor value identically.
+let getId = (item: JSON.t): string =>
+  item
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("id"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("")
+
+// String form of a field for comparison / cursor purposes: the string itself,
+// or a number rendered via Float.toString, else None. The push-down must render
+// the same string in SQL (CAST … AS TEXT) for cursor/order parity.
+let getFieldString = (item: JSON.t, field: string): option<string> =>
+  item
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(field))
+  ->Option.flatMap(v =>
+    switch v->JSON.Decode.string {
+    | Some(s) => Some(s)
+    | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))
+    }
+  )
+
+// Build the Relay connection object from an already-ordered page. Shared by
+// `run` and the SQLite push-down so edges / cursors / pageInfo have one shape.
+let buildConnection = (
+  ~pageItems: array<JSON.t>,
+  ~hasNextPage: bool,
+  ~hasPreviousPage: bool,
+  ~cursorValueOf: JSON.t => string,
+): JSON.t => {
+  let edges =
+    pageItems->Array.map(item => Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))}))
+  let startCursor = pageItems->Array.get(0)->Option.map(item => encodeCursor(cursorValueOf(item)))
+  let endCursor =
+    pageItems->Array.get(pageItems->Array.length - 1)->Option.map(item => encodeCursor(cursorValueOf(item)))
+  Obj.magic({
+    "edges": edges,
+    "pageInfo": {
+      "hasNextPage": hasNextPage,
+      "hasPreviousPage": hasPreviousPage,
+      "startCursor": startCursor->Nullable.fromOption,
+      "endCursor": endCursor->Nullable.fromOption,
+    },
+  })
+}
+
+// Compute the Relay connection response (edges + pageInfo) for `items` under the
+// GraphQL args. `decodeLocalId` maps a possibly-Relay-encoded id to its local id
+// (the resolver passes DomainGraphQL_Server.decodeGlobalId); everything else is
+// pure over the item array.
+let run = (
+  ~items: array<JSON.t>,
+  ~argsDict: Dict.t<JSON.t>,
+  ~capability: GraphQL_FragmentGenerator.serverCapability,
+  ~labelField: string,
+  ~decodeLocalId: string => option<string>,
+): JSON.t => {
+  let filterDict =
+    argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let search = filterDict->Dict.get("search")->Option.flatMap(JSON.Decode.string)
+  let searchPrefix = filterDict->Dict.get("searchPrefix")->Option.flatMap(JSON.Decode.string)
+  let ids =
+    filterDict
+    ->Dict.get("ids")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.map(arr => arr->Array.filterMap(JSON.Decode.string))
+  let getLabel = item =>
+    item
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get(labelField))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("")
+  // Per-field eq / from / to filters derived from capability — applied alongside
+  // the legacy search/searchPrefix/ids block.
+  let perFieldChecks: array<JSON.t => bool> = capability.filterFields->Array.flatMap(f => {
+    let checks: array<JSON.t => bool> = []
+    switch filterDict->Dict.get(f.name ++ "Eq") {
+    | Some(v) when v != JSON.Encode.null =>
+      let expected = switch v->JSON.Decode.string {
+      | Some(s) => s
+      | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr("")
+      }
+      checks->Array.push(item =>
+        getFieldString(item, f.name)->Option.mapOr(false, v => v == expected)
+      )
+    | _ => ()
+    }
+    if f.range {
+      switch filterDict->Dict.get(f.name ++ "From") {
+      | Some(v) when v != JSON.Encode.null =>
+        let from =
+          v
+          ->JSON.Decode.string
+          ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
+        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v >= from))
+      | _ => ()
+      }
+      switch filterDict->Dict.get(f.name ++ "To") {
+      | Some(v) when v != JSON.Encode.null =>
+        let to_ =
+          v
+          ->JSON.Decode.string
+          ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
+        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v <= to_))
+      | _ => ()
+      }
+    }
+    checks
+  })
+
+  let filtered = items->Array.filter(item => {
+    let passSearch = switch search {
+    | Some(s) if s->String.length > 0 =>
+      getLabel(item)->String.toLowerCase->String.includes(s->String.toLowerCase)
+    | _ => true
+    }
+    let passPrefix = switch searchPrefix {
+    | Some(p) if p->String.length > 0 =>
+      getLabel(item)->String.toLowerCase->String.startsWith(p->String.toLowerCase)
+    | _ => true
+    }
+    let passIds = switch ids {
+    | Some(idList) if idList->Array.length > 0 =>
+      let itemId = getId(item)
+      let itemLocalId = decodeLocalId(itemId)
+      idList->Array.some(i => i == itemId || itemLocalId == Some(i))
+    | _ => true
+    }
+    let passPerField = perFieldChecks->Array.every(check => check(item))
+    passSearch && passPrefix && passIds && passPerField
+  })
+
+  let orderByDict = argsDict->Dict.get("orderBy")->Option.flatMap(JSON.Decode.object)
+  let orderByField =
+    orderByDict->Option.flatMap(ob => ob->Dict.get("field"))->Option.flatMap(JSON.Decode.string)
+  let direction =
+    orderByDict
+    ->Option.flatMap(ob => ob->Dict.get("direction"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("ASC")
+  let isDesc = direction == "DESC"
+  let sorted = switch orderByField {
+  | Some(f) =>
+    let cmp = (a, b) => {
+      let av = getFieldString(a, f)->Option.getOr("")
+      let bv = getFieldString(b, f)->Option.getOr("")
+      let primary = if av < bv {
+        -1
+      } else if av > bv {
+        1
+      } else {
+        0
+      }
+      let primary = isDesc ? -primary : primary
+      if primary != 0 {
+        primary
+      } else {
+        let aid = getId(a)
+        let bid = getId(b)
+        if aid < bid {
+          -1
+        } else if aid > bid {
+          1
+        } else {
+          0
+        }
+      }
+    }
+    filtered->Array.toSorted((a, b) => cmp(a, b)->Int.toFloat)
+  | None =>
+    filtered->Array.toSorted((a, b) => {
+      let aid = getId(a)
+      let bid = getId(b)
+      if aid < bid {
+        -1.
+      } else if aid > bid {
+        1.
+      } else {
+        0.
+      }
+    })
+  }
+
+  let first =
+    argsDict->Dict.get("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+  let after = argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string)
+  let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+  let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
+  let isBackward = last->Option.isSome
+  let cursorField = orderByField->Option.getOr("id")
+  let getCursorValue = item => getFieldString(item, cursorField)->Option.getOr(getId(item))
+
+  let cursorBounded = switch (isBackward, after, before) {
+  | (false, Some(c), _) =>
+    let cv = decodeCursor(c)
+    sorted->Array.filter(item => {
+      let v = getCursorValue(item)
+      isDesc ? v < cv : v > cv
+    })
+  | (true, _, Some(c)) =>
+    let cv = decodeCursor(c)
+    sorted->Array.filter(item => {
+      let v = getCursorValue(item)
+      isDesc ? v > cv : v < cv
+    })
+  | _ => sorted
+  }
+
+  let pageSize = if isBackward {
+    last->Option.getOr(defaultListPageSize)
+  } else {
+    first->Option.getOr(defaultListPageSize)
+  }
+  let take = pageSize + 1
+  let (pageItems, hasMore) = if isBackward {
+    let len = cursorBounded->Array.length
+    let startIdx = len > take ? len - take : 0
+    let arr = cursorBounded->Array.slice(~start=startIdx, ~end=len)
+    let hasMore = arr->Array.length > pageSize
+    let result = if hasMore {
+      arr->Array.slice(~start=1, ~end=arr->Array.length)
+    } else {
+      arr
+    }
+    (result, hasMore)
+  } else {
+    let arr = cursorBounded->Array.slice(~start=0, ~end=take)
+    let hasMore = arr->Array.length > pageSize
+    (arr->Array.slice(~start=0, ~end=pageSize), hasMore)
+  }
+
+  buildConnection(
+    ~pageItems,
+    ~hasNextPage=!isBackward && hasMore,
+    ~hasPreviousPage=isBackward && hasMore,
+    ~cursorValueOf=getCursorValue,
+  )
+}

package/src/components/Api/QueryDbListQuery.res.mjs

@@ -0,0 +1,212 @@
+// 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 Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function encodeCursor(value) {
+  return btoa(value);
+}
+
+function decodeCursor(cursor) {
+  return atob(cursor);
+}
+
+function getId(item) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d["id"]), Stdlib_JSON.Decode.string), "");
+}
+
+function getFieldString(item, field) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]), v => {
+    let s = Stdlib_JSON.Decode.string(v);
+    if (s !== undefined) {
+      return s;
+    } else {
+      return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+    }
+  });
+}
+
+function buildConnection(pageItems, hasNextPage, hasPreviousPage, cursorValueOf) {
+  let edges = pageItems.map(item => ({
+    node: item,
+    cursor: btoa(cursorValueOf(item))
+  }));
+  let startCursor = Stdlib_Option.map(pageItems[0], item => btoa(cursorValueOf(item)));
+  let endCursor = Stdlib_Option.map(pageItems[pageItems.length - 1 | 0], item => btoa(cursorValueOf(item)));
+  return {
+    edges: edges,
+    pageInfo: {
+      hasNextPage: hasNextPage,
+      hasPreviousPage: hasPreviousPage,
+      startCursor: Stdlib_Nullable.fromOption(startCursor),
+      endCursor: Stdlib_Nullable.fromOption(endCursor)
+    }
+  };
+}
+
+function run(items, argsDict, capability, labelField, decodeLocalId) {
+  let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+  let search = Stdlib_Option.flatMap(filterDict["search"], Stdlib_JSON.Decode.string);
+  let searchPrefix = Stdlib_Option.flatMap(filterDict["searchPrefix"], Stdlib_JSON.Decode.string);
+  let ids = Stdlib_Option.map(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), arr => Stdlib_Array.filterMap(arr, Stdlib_JSON.Decode.string));
+  let getLabel = item => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[labelField]), Stdlib_JSON.Decode.string), "");
+  let perFieldChecks = capability.filterFields.flatMap(f => {
+    let checks = [];
+    let v = filterDict[f.name + "Eq"];
+    if (v !== undefined && v !== null) {
+      let s = Stdlib_JSON.Decode.string(v);
+      let expected = s !== undefined ? s : Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString()), "");
+      checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v === expected));
+    }
+    if (f.range) {
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        let from = Stdlib_Option.getOr(Stdlib_JSON.Decode.string(v$1), Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v$1), f => f.toString()), ""));
+        checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v >= from));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        let to_ = Stdlib_Option.getOr(Stdlib_JSON.Decode.string(v$2), Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v$2), f => f.toString()), ""));
+        checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v <= to_));
+      }
+    }
+    return checks;
+  });
+  let filtered = items.filter(item => {
+    let passSearch = search !== undefined && search.length > 0 ? getLabel(item).toLowerCase().includes(search.toLowerCase()) : true;
+    let passPrefix = searchPrefix !== undefined && searchPrefix.length > 0 ? getLabel(item).toLowerCase().startsWith(searchPrefix.toLowerCase()) : true;
+    let passIds;
+    if (ids !== undefined && ids.length !== 0) {
+      let itemId = getId(item);
+      let itemLocalId = decodeLocalId(itemId);
+      passIds = ids.some(i => {
+        if (i === itemId) {
+          return true;
+        } else {
+          return Primitive_object.equal(itemLocalId, i);
+        }
+      });
+    } else {
+      passIds = true;
+    }
+    let passPerField = perFieldChecks.every(check => check(item));
+    if (passSearch && passPrefix && passIds) {
+      return passPerField;
+    } else {
+      return false;
+    }
+  });
+  let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+  let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
+  let direction = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC");
+  let isDesc = direction === "DESC";
+  let sorted;
+  if (orderByField !== undefined) {
+    sorted = filtered.toSorted((a, b) => {
+      let av = Stdlib_Option.getOr(getFieldString(a, orderByField), "");
+      let bv = Stdlib_Option.getOr(getFieldString(b, orderByField), "");
+      let primary = av < bv ? -1 : (
+          av > bv ? 1 : 0
+        );
+      let primary$1 = isDesc ? -primary | 0 : primary;
+      if (primary$1 !== 0) {
+        return primary$1;
+      }
+      let aid = getId(a);
+      let bid = getId(b);
+      if (aid < bid) {
+        return -1;
+      } else if (aid > bid) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+  } else {
+    sorted = filtered.toSorted((a, b) => {
+      let aid = getId(a);
+      let bid = getId(b);
+      if (aid < bid) {
+        return -1;
+      } else if (aid > bid) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+  }
+  let first = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0);
+  let after = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+  let last = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float), prim => prim | 0);
+  let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+  let isBackward = Stdlib_Option.isSome(last);
+  let cursorField = Stdlib_Option.getOr(orderByField, "id");
+  let getCursorValue = item => Stdlib_Option.getOr(getFieldString(item, cursorField), getId(item));
+  let cursorBounded;
+  if (isBackward) {
+    if (before !== undefined) {
+      let cv = atob(before);
+      cursorBounded = sorted.filter(item => {
+        let v = getCursorValue(item);
+        if (isDesc) {
+          return v > cv;
+        } else {
+          return v < cv;
+        }
+      });
+    } else {
+      cursorBounded = sorted;
+    }
+  } else if (after !== undefined) {
+    let cv$1 = atob(after);
+    cursorBounded = sorted.filter(item => {
+      let v = getCursorValue(item);
+      if (isDesc) {
+        return v < cv$1;
+      } else {
+        return v > cv$1;
+      }
+    });
+  } else {
+    cursorBounded = sorted;
+  }
+  let pageSize = isBackward ? Stdlib_Option.getOr(last, 50) : Stdlib_Option.getOr(first, 50);
+  let take = pageSize + 1 | 0;
+  let match;
+  if (isBackward) {
+    let len = cursorBounded.length;
+    let startIdx = len > take ? len - take | 0 : 0;
+    let arr = cursorBounded.slice(startIdx, len);
+    let hasMore = arr.length > pageSize;
+    let result = hasMore ? arr.slice(1, arr.length) : arr;
+    match = [
+      result,
+      hasMore
+    ];
+  } else {
+    let arr$1 = cursorBounded.slice(0, take);
+    let hasMore$1 = arr$1.length > pageSize;
+    match = [
+      arr$1.slice(0, pageSize),
+      hasMore$1
+    ];
+  }
+  let hasMore$2 = match[1];
+  return buildConnection(match[0], !isBackward && hasMore$2, isBackward && hasMore$2, getCursorValue);
+}
+
+let defaultListPageSize = 50;
+
+export {
+  encodeCursor,
+  decodeCursor,
+  defaultListPageSize,
+  getId,
+  getFieldString,
+  buildConnection,
+  run,
+}
+/* No side effect */

package/src/components/Dcb/Dcb_Builder.res

@@ -289,11 +289,21 @@ module Make = (
 
         // All-or-nothing: thread the derived scope only when every slice resolved.
         // An ambiguous boundary keeps the annotated values (no partial inference).
-        let useInferred = inferred.ambiguities->Array.length == 0
-        let effectiveCrossPartitionTagKeys =
-          useInferred ? inferred.crossPartitionTagKeys : crossPartitionTagKeys
-        let effectiveTagKeysByEventType =
-          useInferred ? inferred.tagKeysByEventType : tagKeysByEventType
+        // Both this builder and the deployed command-handler entry point
+        // (DcbCommandTopicEntryPoint.mjs) route through `DcbTag.deriveEffectiveScope`
+        // so the runtime decision query cannot drift from this scope — see
+        // docs/analysis/dcb-runtime-scope-annotation-drift.md.
+        let {
+          crossPartitionTagKeys: effectiveCrossPartitionTagKeys,
+          tagKeysByEventType: effectiveTagKeysByEventType,
+        } = Reventless.DcbTag.deriveEffectiveScope(
+          stateChangeSlices->Array.map((module(Sc: StateChangeSlice.T)) => {
+            Reventless.DcbTag.name: Sc.Spec.name,
+            commandSchema: Sc.Spec.commandSchema->S.castToUnknown,
+            consumedEventSchema: Sc.Spec.consumedEventSchema->S.castToUnknown,
+            eventSchema: Sc.Spec.eventSchema->S.castToUnknown,
+          }),
+        )
 
         module DcbEventLog = DcbEventLog_Builder.Make(
           DcbEventLogStorage,

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -167,9 +167,14 @@ function Make(DcbEventLogStorage) {
       let scopeIssues = DcbValidation$Reventless.validateScopeVsInference(scopeAnnotations, inferred);
       scopeIssues.contradictions.forEach(e => log.warn("Dcb_Builder", undefined, `DCB scope contradiction (` + e.sliceName + `): ` + e.message));
       scopeIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB scope (` + e.sliceName + `): ` + e.message));
-      let useInferred = inferred.ambiguities.length === 0;
-      let effectiveCrossPartitionTagKeys = useInferred ? inferred.crossPartitionTagKeys : crossPartitionTagKeys;
-      let effectiveTagKeysByEventType = useInferred ? inferred.tagKeysByEventType : tagKeysByEventType;
+      let match = DcbTag$Reventless.deriveEffectiveScope(stateChangeSlices.map(Sc => ({
+        name: Sc.Spec.name,
+        commandSchema: Sc.Spec.commandSchema,
+        consumedEventSchema: Sc.Spec.consumedEventSchema,
+        eventSchema: Sc.Spec.eventSchema
+      })));
+      let effectiveTagKeysByEventType = match.tagKeysByEventType;
+      let effectiveCrossPartitionTagKeys = match.crossPartitionTagKeys;
       let DcbEventLog = DcbEventLog_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher);
       let dcbEventLog = DcbEventLog.make(name, indexes$1, partitionTag, effectiveCrossPartitionTagKeys, opts);
       Stdlib_Option.forEach(HooksConfig.hooks.onDcbEventLogCreated, hook => hook(dcbEventLog));