@reventlessdev/reventless-core 3.0.0-alpha.206 → 3.0.0-alpha.208

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.208 (2026-08-03)
+
+### Bug Fixes
+
+* **aws:** make the slice callback protocol one declaration, not three ([d49e543](https://github.com/ReventlessDev/reventless-core/commit/d49e543f4715c955c75cec8bd691ee0927b7e2f4))
+
+
+# 3.0.0-alpha.207 (2026-08-03)
+
+### Bug Fixes
+
+* **dcb:** let the produced/consumed check see aggregate producers ([0075360](https://github.com/ReventlessDev/reventless-core/commit/0075360fc5915b166ab25b6acca2c8580e5b4ecb))
+* **geocoding:** calibrate the confidence rule against a real index ([cd72b27](https://github.com/ReventlessDev/reventless-core/commit/cd72b2741460c871db2915a8603f7837b8191187))
+
+
 # 3.0.0-alpha.206 (2026-08-03)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.206",
+  "version": "3.0.0-alpha.208",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -30,15 +30,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-node": "2.0.0-alpha.1",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.1",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.123",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.98",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.99"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res

@@ -140,6 +140,15 @@ module Make = (
       aggregates->createAggregatesWithoutEventMappers(~api, ~componentRuntime=Dict.make(), opts)
     let aggregateEventTopics = Aggregate.allEventTopics(aggregatesWithoutEventMappers)
 
+    // As in Plugin_Builder: what the admin aggregates emit, so a slice naming one
+    // as its source is checked against real producers rather than reported as
+    // consuming events nothing produces.
+    let aggregateProducedEvents =
+      aggregates->Array.map((module(A: ReventlessInfra.Aggregate.T with type api = api)) => (
+        A.Spec.name,
+        A.Spec.eventSchema->S.castToUnknown,
+      ))
+
     // Wire CommandGenerator → AppSync / in-memory GraphQL resolvers via
     // `mutationResolverHook` and populate `aggregateMutationFieldsRegistry`.
     // The matching SDL entries are owned by
@@ -159,6 +168,7 @@ module Make = (
       // Domain API — routes the provider hook to `hooks.adminApi`.
       ~onAdminApi=true,
       ~aggregateEventTopics,
+      ~aggregateProducedEvents,
       ~stateChangeSlices,
       ~stateViewSlices,
       ~automationSlices,

package/src/admin/Platform_Admin.res.mjs

@@ -73,8 +73,12 @@ function Make(RuntimeEnvironment) {
       });
       let aggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, {}, opts);
       let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
+      let aggregateProducedEvents = aggregates.map(A => [
+        A.Spec.name,
+        A.Spec.eventSchema
+      ]);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
+      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
       let slicePublishJsons = dcbResult.dcbPublishJsons;
       if (slicePublishJsons !== undefined) {
         stateChangeSlices.forEach(Sc => {

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -31,6 +31,30 @@ type todoRow = {
   retryCount: int,
 }
 
+/**
+The runtime protocol between a built callback and whoever drives it — the same
+arrangement as `OutboundTranslationSlice_Callback`, and for the same reason. The
+AWS entry point builds callbacks dynamically and has to ascribe a structural type
+at the JS boundary; pointing that ascription at these aliases is what keeps it
+from becoming an unreconcilable second declaration of the shape.
+
+Unlike outbound, phase 1 here takes *raw* envelope JSONs: the callback routes by
+`meta.service` and unwraps `{id, meta, event}` itself, per-source, through the
+registered Mappings.
+*/
+type phase1 = (array<JSON.t>, Reventless.AutomationSlice.context) => unit
+
+/** Phase 2: process all pending items, publishing commands. */
+type phase2 = ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+
+/** The whole protocol as a value, for a driver that holds a built callback and
+    knows nothing of the Spec behind it. */
+type runtime = {
+  todoItems: Dict.t<todoRow>,
+  phase1: phase1,
+  phase2: phase2,
+}
+
 module type T = {
   module Spec: Reventless.AutomationSlice.Spec
   module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
@@ -40,10 +64,10 @@ module type T = {
 
   /** Phase 1: update TODO list from a batch of raw event JSONs. Internally
       decodes per-source via the registered Mappings. */
-  let phase1: (array<JSON.t>, Reventless.AutomationSlice.context) => unit
+  let phase1: phase1
 
   /** Phase 2: process all pending items, publishing commands via publishJsons. */
-  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+  let phase2: phase2
 }
 
 module Make = (

package/src/components/Dcb/Dcb_Builder.res

@@ -87,6 +87,13 @@ module Make = (
     ~environment: string="",
     ~platformName: string="",
     ~aggregateEventTopics: EventTopic.allOutputs=Dict.make(),
+    // `(Aggregate name, its event schema)` for every aggregate in this plugin.
+    // Feeds the produced/consumed check only — an outbound or automation slice
+    // may name an Aggregate as a source, and without these its events look like
+    // events nothing produces. Deliberately *not* folded into `produced`, which
+    // also drives DCB GSI creation: an aggregate's events live on its own
+    // EventLog and must not mint indexes on the DCB table.
+    ~aggregateProducedEvents: array<(string, S.t<unknown>)>=[],
     ~stateChangeSlices: array<module(StateChangeSlice.T)>,
     ~stateViewSlices: array<module(StateViewSlice.T)>,
     ~automationSlices: array<module(AutomationSlice.T)>,
@@ -145,7 +152,10 @@ module Make = (
             ),
           )
 
-        switch Reventless.DcbValidation.validateProducedAndConsumed(~produced, ~consumed) {
+        switch Reventless.DcbValidation.validateProducedAndConsumed(
+          ~produced=produced->Array.concat(aggregateProducedEvents),
+          ~consumed,
+        ) {
         | Error(errors) =>
           errors->Array.forEach(err =>
             log.error(~comp="Dcb_Builder", `DCB validation error (${err.sliceName}): ${err.message}`)

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

@@ -83,12 +83,13 @@ let emptyResult = {
 
 function Make(DcbEventLogStorage) {
   return DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (RuntimeBuilder => (HooksConfig => {
-    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
+    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
       let apiNamePrefix = apiNamePrefixOpt !== undefined ? apiNamePrefixOpt : name;
       let onAdminApi = onAdminApiOpt !== undefined ? onAdminApiOpt : false;
       let environment = environmentOpt !== undefined ? environmentOpt : "";
       let platformName = platformNameOpt !== undefined ? platformNameOpt : "";
       let aggregateEventTopics = aggregateEventTopicsOpt !== undefined ? aggregateEventTopicsOpt : ({});
+      let aggregateProducedEvents = aggregateProducedEventsOpt !== undefined ? aggregateProducedEventsOpt : [];
       let systemCallableComponents = systemCallableComponentsOpt !== undefined ? systemCallableComponentsOpt : [];
       let componentRuntime = componentRuntimeOpt !== undefined ? componentRuntimeOpt : ({});
       let hasDcb = stateChangeSlices.length !== 0;
@@ -119,7 +120,7 @@ function Make(DcbEventLogStorage) {
         O.Spec.name,
         O.Spec.consumedEventSchema
       ]));
-      let errors = DcbValidation$Reventless.validateProducedAndConsumed(produced, consumed);
+      let errors = DcbValidation$Reventless.validateProducedAndConsumed(produced.concat(aggregateProducedEvents), consumed);
       if (errors.TAG !== "Ok") {
         errors._0.forEach(err => log.error("Dcb_Builder", undefined, `DCB validation error (` + err.sliceName + `): ` + err.message));
       }

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -22,6 +22,34 @@ type todoRow = {
   lastError?: string,
 }
 
+/**
+The runtime protocol between a built callback and whoever drives it.
+
+Defined here, once, and referenced by every party — `module type T` below, the
+in-process builder, and the AWS entry point, which cannot name `T` because it
+builds callbacks dynamically per `HANDLER_CONFIG` entry and must ascribe a
+structural type at the JS boundary.
+
+That ascription is the reason these aliases exist. A driver that restates the
+shape instead of referencing it becomes a second source of truth that the
+compiler cannot reconcile with this one: when `phase1` gained its `sourceId`,
+the AWS entry point kept passing bare events and nothing complained, because its
+hand-written copy was internally consistent. The mismatch surfaced only at
+runtime, as `undefined` destructured from a tuple that was never a tuple.
+*/
+type phase1<'event> = array<(string, 'event)> => unit
+
+/** Phase 2: translate all pending items, optionally publishing commands. */
+type phase2 = ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+
+/** The whole protocol as a value — what a driver holding a built callback needs,
+    with no knowledge of the Spec it was built from. */
+type runtime<'event> = {
+  todoItems: Dict.t<todoRow>,
+  phase1: phase1<'event>,
+  phase2: phase2,
+}
+
 module type T = {
   module Spec: Reventless.OutboundTranslationSlice.Spec
   module Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec
@@ -32,10 +60,10 @@ module type T = {
   /** Phase 1: update TODO list from a batch of `(sourceId, event)` pairs
       (collect only, no resolve). `sourceId` is the envelope id of the entity the
       event was published for. */
-  let phase1: array<(string, Spec.consumedEvent)> => unit
+  let phase1: phase1<Spec.consumedEvent>
 
   /** Phase 2: translate all pending items, optionally publishing commands via publishJsons. */
-  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+  let phase2: phase2
 }
 
 module Make = (

package/src/plugin/component/Plugin_Builder.res

@@ -143,6 +143,15 @@ module Make = (
       aggregates->createAggregatesWithoutEventMappers(~api, ~componentRuntime, opts)
     let aggregateEventTopics = Aggregate.allEventTopics(aggregatesWithoutEventMappers)
 
+    // What each aggregate emits, for the DCB produced/consumed check. A slice
+    // naming an Aggregate as its source consumes those events, and the check
+    // otherwise sees no producer for them and reports correct code as broken.
+    let aggregateProducedEvents =
+      aggregates->Array.map((module(A: ReventlessInfra.Aggregate.T with type api = api)) => (
+        A.Spec.name,
+        A.Spec.eventSchema->S.castToUnknown,
+      ))
+
     // Construct DCB components and derive DCB-specific API schema entries
     module DcbBuilder = Dcb_Builder.Make(
       DcbEventLogStorage,
@@ -158,6 +167,7 @@ module Make = (
       ~environment=Spec.environment,
       ~platformName=Spec.platformName,
       ~aggregateEventTopics,
+      ~aggregateProducedEvents,
       ~stateChangeSlices,
       ~stateViewSlices,
       ~automationSlices,

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -149,10 +149,14 @@ function Make(Spec) {
         let childName = ComponentType$ReventlessCore.name(extra$1, Plugin$ReventlessCore.componentType);
         let aggregatesWithoutEventMappers = Plugin_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, componentRuntime, opts);
         let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
+        let aggregateProducedEvents = aggregates.map(A => [
+          A.Spec.name,
+          A.Spec.eventSchema
+        ]);
         let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(PluginRuntimeBuilder)({
           hooks: Spec.hooks
         });
-        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
+        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
         let mutationEntriesFromAggregates = aggregates.flatMap(M => {
           let commandSchema = M.Spec.commandSchema;
           if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {

package/tests/api/GeocodingTest.res

@@ -24,7 +24,7 @@ let candidate = (~label, ~relevance=?): Geocoding.candidate => {
 
 describe("Geocoder_AwsLocation_Geocoding.confidentMatch", () => {
   testSync("a clear winner is the answer", () => {
-    let top = candidate(~label="Stephansplatz 1, Vienna", ~relevance=0.97)
+    let top = candidate(~label="Stephansplatz 1, Vienna", ~relevance=1.0)
     let result = Geocoding.confidentMatch([top, candidate(~label="Elsewhere", ~relevance=0.4)])
     expect(result->Option.map(c => c.Geocoding.label))->toEqual(Some("Stephansplatz 1, Vienna"))
   })
@@ -35,11 +35,42 @@ describe("Geocoder_AwsLocation_Geocoding.confidentMatch", () => {
   })
 
   testSync("two near-equal candidates are ambiguous, not a winner", () => {
-    // The bare-town-name case: the service matched several places about equally
-    // well, and picking the first would pin a confident marker in the wrong one.
+    // The bare-town-name case, with the scores the live Esri index actually
+    // returns for it: five states at exactly 1.0. Genuine ambiguity there is a
+    // tie, not a near miss — which is why the margin is small and this case is
+    // still caught.
     let result = Geocoding.confidentMatch([
-      candidate(~label="Springfield, IL", ~relevance=0.91),
-      candidate(~label="Springfield, MA", ~relevance=0.89),
+      candidate(~label="Springfield, IL", ~relevance=1.0),
+      candidate(~label="Springfield, MA", ~relevance=1.0),
+    ])
+    expect(result->Option.isNone)->toBe(true)
+  })
+
+  testSync("a correct match with a plausible runner-up is still a winner", () => {
+    // Measured against the live index: "Baker Street 221B, London NW1 6XE"
+    // returns the right building — matching postcode — at 0.991, with an
+    // unrelated Baker Street at 0.962. The previous calibration (floor 0.8,
+    // margin 0.1) read that 0.029 gap as ambiguity and declined, so a perfectly
+    // good address was written off as unresolvable and, per the retry policy,
+    // never tried again. Three of twelve realistic addresses failed this way.
+    let result = Geocoding.confidentMatch([
+      candidate(~label="221 Baker Street, Marylebone, London NW1 6XE", ~relevance=0.991),
+      candidate(~label="Baker Street, elsewhere", ~relevance=0.962),
+    ])
+    expect(result->Option.map(c => c.Geocoding.label))->toEqual(
+      Some("221 Baker Street, Marylebone, London NW1 6XE"),
+    )
+  })
+
+  testSync("a wrong street in the right city is declined", () => {
+    // The other half of the same measurement, and the reason the floor moved up
+    // rather than the margin merely moving down: "Kaiserstrasse 12, 4020 Linz"
+    // resolves to *Rainerstrasse* 12 in Linz at 0.958. Its gap to the runner-up
+    // is 0.031 — wider than the correct match above — so no margin can separate
+    // the two. Only the absolute score can.
+    let result = Geocoding.confidentMatch([
+      candidate(~label="Rainerstraße 12, 4020 Linz", ~relevance=0.958),
+      candidate(~label="Somewhere else, Linz", ~relevance=0.927),
     ])
     expect(result->Option.isNone)->toBe(true)
   })

package/tests/api/GeocodingTest.res.mjs

@@ -24,7 +24,7 @@ function candidate(label, relevance) {
 
 globalThis.describe("Geocoder_AwsLocation_Geocoding.confidentMatch", () => {
   globalThis.test("a clear winner is the answer", () => {
-    let top = candidate("Stephansplatz 1, Vienna", 0.97);
+    let top = candidate("Stephansplatz 1, Vienna", 1.0);
     let result = Geocoding$Reventless.confidentMatch([
       top,
       candidate("Elsewhere", 0.4)
@@ -37,8 +37,22 @@ globalThis.describe("Geocoder_AwsLocation_Geocoding.confidentMatch", () => {
   });
   globalThis.test("two near-equal candidates are ambiguous, not a winner", () => {
     let result = Geocoding$Reventless.confidentMatch([
-      candidate("Springfield, IL", 0.91),
-      candidate("Springfield, MA", 0.89)
+      candidate("Springfield, IL", 1.0),
+      candidate("Springfield, MA", 1.0)
+    ], undefined, undefined);
+    globalThis.expect(Stdlib_Option.isNone(result)).toBe(true);
+  });
+  globalThis.test("a correct match with a plausible runner-up is still a winner", () => {
+    let result = Geocoding$Reventless.confidentMatch([
+      candidate("221 Baker Street, Marylebone, London NW1 6XE", 0.991),
+      candidate("Baker Street, elsewhere", 0.962)
+    ], undefined, undefined);
+    globalThis.expect(Stdlib_Option.map(result, c => c.label)).toEqual("221 Baker Street, Marylebone, London NW1 6XE");
+  });
+  globalThis.test("a wrong street in the right city is declined", () => {
+    let result = Geocoding$Reventless.confidentMatch([
+      candidate("Rainerstraße 12, 4020 Linz", 0.958),
+      candidate("Somewhere else, Linz", 0.927)
     ], undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(result)).toBe(true);
   });