@reventlessdev/reventless-core 3.0.0-alpha.235 → 3.0.0-alpha.236

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 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.236 (2026-08-15)
+
+### Bug Fixes
+
+* **core:** describe a DCB event log by every event it carries ([047bc0b](https://github.com/ReventlessDev/reventless-core/commit/047bc0beb9be1468410fde37a7f787a3d68f92d2))
+### Features
+
+* **aws:** serve one baked manifest per journey ([16d6307](https://github.com/ReventlessDev/reventless-core/commit/16d63071f059cf1fc7025f9be9206dda51f71053))
+
+
 # 3.0.0-alpha.235 (2026-08-15)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.235",
+  "version": "3.0.0-alpha.236",
   "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.7",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.7",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.7",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.142",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.31",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.114",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.142"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.114"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_BakedManifest.res

@@ -204,6 +204,58 @@ let journeyKey = (~group: string): string => {
   `component-manifest-${slug}.json`
 }
 
+let toSelection = (s: ReventlessInfra.Platform.bakedManifestSelection): selection => {
+  plugin: s.plugin,
+  views: s.views,
+  commands: s.commands,
+  derived: s.derived,
+}
+
+/** One declared journey, with everything a platform needs to serve it: the group
+    it serves, the file it is written to, and the include-list that decides the
+    file's contents. */
+type journeyFile = {group: string, key: string, selections: array<selection>}
+
+/**
+ The declared journeys, in declaration order, with their keys resolved.
+
+ The default journey is deliberately not among them: it is the file
+ `manifestUrl` points at, which is what a caller matching no declared group reads
+ and what every deployment had before journeys existed.
+ */
+let journeyFiles = (~config: ReventlessInfra.Platform.bakedManifest): array<journeyFile> =>
+  config.journeys
+  ->Option.getOr([])
+  ->Array.map(j => {
+    group: j.group,
+    key: j.key->Option.getOr(journeyKey(~group=j.group)),
+    selections: j.components->Array.map(toSelection),
+  })
+
+/**
+ Every file a bake declaration produces, as (key, selections) pairs.
+
+ The default journey first and always — it is what a caller matching no declared
+ group gets, which includes the no-bearer identity a local dev session starts
+ from — then one per declared journey.
+
+ Here rather than on either platform because several separate things have to
+ agree about this set on a deploy: the objects the bake writes, the IAM grant
+ that lets it write them, and the URLs `config.json` sends a caller to. A key
+ derived twice is a shop whose file is written where nothing fetches it, and the
+ symptom is an empty menu rather than a missing file.
+ */
+let files = (
+  ~config: ReventlessInfra.Platform.bakedManifest,
+): array<(string, array<selection>)> =>
+  [
+    (config.key->Option.getOr(defaultKey), config.components->Array.map(toSelection)),
+  ]->Array.concat(journeyFiles(~config)->Array.map(j => (j.key, j.selections)))
+
+/** Each declared journey's group and the URL a shell fetches its file from. */
+let journeyUrls = (~config: ReventlessInfra.Platform.bakedManifest): array<(string, string)> =>
+  journeyFiles(~config)->Array.map(j => (j.group, urlForKey(Some(j.key))))
+
 // The whole file: one entry per selection, in the order the deployment declared
 // them, so the include-list also states the order a consumer reads plugins in.
 let curate = (

package/src/admin/Platform_BakedManifest.res.mjs

@@ -192,6 +192,40 @@ function journeyKey(group) {
   return `component-manifest-` + slug + `.json`;
 }
 
+function toSelection(s) {
+  return {
+    plugin: s.plugin,
+    views: s.views,
+    commands: s.commands,
+    derived: s.derived
+  };
+}
+
+function journeyFiles(config) {
+  return Stdlib_Option.getOr(config.journeys, []).map(j => ({
+    group: j.group,
+    key: Stdlib_Option.getOr(j.key, journeyKey(j.group)),
+    selections: j.components.map(toSelection)
+  }));
+}
+
+function files(config) {
+  return [[
+      Stdlib_Option.getOr(config.key, defaultKey),
+      config.components.map(toSelection)
+    ]].concat(journeyFiles(config).map(j => [
+    j.key,
+    j.selections
+  ]));
+}
+
+function journeyUrls(config) {
+  return journeyFiles(config).map(j => [
+    j.group,
+    urlForKey(j.key)
+  ]);
+}
+
 function curate(structures, selections) {
   return Stdlib_Result.map(Stdlib_Array.reduce(selections, {
     TAG: "Ok",
@@ -228,6 +262,10 @@ export {
   defaultKey,
   urlForKey,
   journeyKey,
+  toSelection,
+  journeyFiles,
+  files,
+  journeyUrls,
   curate,
 }
 /* No side effect */

package/src/components/Dcb/Dcb_Builder.res

@@ -21,6 +21,52 @@ let toRelativePath: string => string = %raw(`function toRelativePath(moduleUrl)
   }
 }`)
 
+// The tag of one compiled variant arm: `{TAG: "<Name>", …}` for a payload-bearing
+// constructor, a bare string const for a payload-less one.
+let variantTag = (variant: S.t<unknown>) =>
+  switch variant {
+  | S.Object({properties}) =>
+    switch properties->Dict.get("TAG") {
+    | Some(String({const: ?Some(tag)})) => Some(tag)
+    | _ => None
+    }
+  | S.String({const: ?Some(tag)}) => Some(tag)
+  | _ => None
+  }
+
+/**
+The event schema of a DCB event log: one union over every event its slices produce.
+
+Flattened, not nested. Every reader of an `eventLogSchemaEntry` walks exactly one
+level — `Union` → per-variant `Object` with a `TAG` const — so a union OF unions
+would present each slice as an arm with no tag and read as a log carrying no
+event types at all. Arms are deduped by tag because two slices producing the same
+event would otherwise hand sury two arms with one discriminant.
+*/
+let mergedEventSchema = (schemas: array<S.t<unknown>>) =>
+  switch schemas {
+  | [single] => single
+  | many =>
+    let seen = Set.make()
+    many
+    ->Array.flatMap(schema =>
+      switch schema {
+      | S.Union({anyOf}) => anyOf
+      | other => [other]
+      }
+    )
+    ->Array.filter(arm =>
+      switch arm->variantTag {
+      | Some(tag) if seen->Set.has(tag) => false
+      | Some(tag) =>
+        seen->Set.add(tag)
+        true
+      | None => true
+      }
+    )
+    ->S.union
+  }
+
 type dcbResult = {
   dcbEventLogOutputs: option<DcbEventLog.outputs>,
   stateChangeSlicesOutputs: dict<StateChangeSlice.outputs>,
@@ -1047,7 +1093,11 @@ module Make = (
           }
         })
 
-        // Collect all event schemas from produced events for eventLogEntries
+        // Every event this plugin's slices produce lands in the one DCB event log,
+        // so the log's schema entry is the union of all of them. Taking the first
+        // slice's schema as representative left the readers of that entry — the
+        // upload claimer's `CLAIM_REF_FIELDS`, MCP's event-history resource —
+        // describing one slice and silently blind to the rest.
         let allProducedSchemas =
           stateChangeSlices->Array.map((module(Sc: StateChangeSlice.T)) =>
             Sc.Spec.eventSchema->S.castToUnknown
@@ -1102,12 +1152,11 @@ module Make = (
             ->Array.concat(outboundEntries)
             ->Array.concat(inboundEntries),
           eventLogEntries: if allProducedSchemas->Array.length > 0 {
-            // Use the first produced event schema as representative for the event log
             [
               {
                 ReventlessInfra.Api.busKey: name ++ "DcbEventLog",
                 displayName: name,
-                eventSchema: allProducedSchemas->Array.getUnsafe(0),
+                eventSchema: allProducedSchemas->mergedEventSchema,
               },
             ]
           } else {

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

@@ -48,6 +48,60 @@ let toRelativePath = (function toRelativePath(moduleUrl) {
   }
 });
 
+function variantTag(variant) {
+  switch (variant.type) {
+    case "string" :
+      let tag = variant.const;
+      if (tag !== undefined) {
+        return tag;
+      } else {
+        return;
+      }
+    case "object" :
+      let match = variant.properties["TAG"];
+      if (match === undefined) {
+        return;
+      }
+      if (match.type !== "string") {
+        return;
+      }
+      let tag$1 = match.const;
+      if (tag$1 !== undefined) {
+        return tag$1;
+      } else {
+        return;
+      }
+    default:
+      return;
+  }
+}
+
+function mergedEventSchema(schemas) {
+  if (schemas.length === 1) {
+    return schemas[0];
+  }
+  let seen = new Set();
+  return S.union(schemas.flatMap(schema => {
+    if (schema.type === "union") {
+      return schema.anyOf;
+    } else {
+      return [schema];
+    }
+  }).filter(arm => {
+    let tag = variantTag(arm);
+    if (tag !== undefined) {
+      if (seen.has(tag)) {
+        return false;
+      } else {
+        seen.add(tag);
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }));
+}
+
 let emptyResult_stateChangeSlicesOutputs = {};
 
 let emptyResult_stateViewSlicesOutputs = {};
@@ -583,7 +637,7 @@ function Make(DcbEventLogStorage) {
         eventLogEntries: allProducedSchemas.length !== 0 ? [{
               busKey: name + "DcbEventLog",
               displayName: name,
-              eventSchema: allProducedSchemas[0]
+              eventSchema: mergedEventSchema(allProducedSchemas)
             }] : []
       };
     };
@@ -596,6 +650,8 @@ function Make(DcbEventLogStorage) {
 export {
   log,
   toRelativePath,
+  variantTag,
+  mergedEventSchema,
   emptyResult,
   Make,
 }

package/tests/dcb/DcbEventLogSchemaTest.res

@@ -0,0 +1,77 @@
+// What a DCB event log tells its readers it carries.
+//
+// A plugin's slices all append to ONE log, but each slice declares only its own
+// events. The log's schema entry used to be the first slice's schema, taken as
+// representative — and every reader of that entry believed it: the upload
+// claimer granted and untagged refs for one slice's events, and MCP described
+// the log's history as carrying that slice's event types and no others. Nothing
+// failed; the rest was simply invisible, which for the claimer means objects
+// that keep their pending tag and expire while an event references them.
+//
+// So the assertions here are about completeness, and about the shape that
+// completeness has to arrive in: readers walk exactly one level, `Union` →
+// per-variant `Object` with a `TAG`, so a union of unions would be as blind as
+// the single schema it replaced while looking like it covered everything.
+
+open JestGlobals
+
+let variant = (~tag: string, fields: array<(string, S.t<unknown>)>): S.t<unknown> =>
+  S.object(s => {
+    let _ = s.field("TAG", S.literal(tag)->S.castToUnknown)
+    fields->Array.forEach(((name, schema)) => {
+      let _ = s.field(name, schema)
+    })
+    ()
+  })->S.castToUnknown
+
+let ref_ = (~store: string) => Reventless.StorageRef.forStore(~store)->S.castToUnknown
+
+let addCategory = S.union([
+  variant(~tag="CategoryAdded", [("imageUrl", ref_(~store="categoryImages"))]),
+])->S.castToUnknown
+
+let addProduct = S.union([
+  variant(~tag="ProductAdded", [("imageUrl", ref_(~store="productImages"))]),
+])->S.castToUnknown
+
+let renameCategory = S.union([
+  variant(~tag="CategoryRenamed", [("name", S.string->S.castToUnknown)]),
+])->S.castToUnknown
+
+describe("Dcb_Builder.mergedEventSchema", () => {
+  testSync("carries every slice's event types, not the first slice's", () => {
+    let merged = [addCategory, addProduct, renameCategory]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual([
+      "CategoryAdded",
+      "ProductAdded",
+      "CategoryRenamed",
+    ])
+  })
+
+  // The claimer's whole input. One slice short here is a store's objects
+  // expiring under a live reference.
+  testSync("surfaces the ref fields of every slice that declares one", () => {
+    let merged = [addCategory, addProduct, renameCategory]->Dcb_Builder.mergedEventSchema
+    expect(
+      StorageRefFields.fromEventSchema(~plugin="Catalog", merged)->Array.map(e => (
+        e.eventType,
+        e.fields->Array.map(f => f.store),
+      )),
+    )->toEqual([
+      ("CategoryAdded", ["Catalog.categoryImages"]),
+      ("ProductAdded", ["Catalog.productImages"]),
+    ])
+  })
+
+  // Two slices producing the same event would otherwise hand sury two arms
+  // under one discriminant, and every reader a duplicate.
+  testSync("keeps one arm per event type", () => {
+    let merged = [addProduct, addProduct]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual(["ProductAdded"])
+  })
+
+  testSync("leaves a lone slice's schema as it is", () => {
+    let merged = [addProduct]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual(["ProductAdded"])
+  })
+})

package/tests/dcb/DcbEventLogSchemaTest.res.mjs

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as Dcb_Builder$ReventlessCore from "../../src/components/Dcb/Dcb_Builder.res.mjs";
+import * as StorageRefFields$ReventlessCore from "../../src/components/Api/StorageRefFields.res.mjs";
+
+function variant(tag, fields) {
+  return S.object(s => {
+    s.f("TAG", S.literal(tag));
+    fields.forEach(param => {
+      s.f(param[0], param[1]);
+    });
+  });
+}
+
+function ref_(store) {
+  return StorageRef$Reventless.forStore(undefined, store);
+}
+
+let addCategory = S.union([variant("CategoryAdded", [[
+      "imageUrl",
+      StorageRef$Reventless.forStore(undefined, "categoryImages")
+    ]])]);
+
+let addProduct = S.union([variant("ProductAdded", [[
+      "imageUrl",
+      StorageRef$Reventless.forStore(undefined, "productImages")
+    ]])]);
+
+let renameCategory = S.union([variant("CategoryRenamed", [[
+      "name",
+      S.string
+    ]])]);
+
+globalThis.describe("Dcb_Builder.mergedEventSchema", () => {
+  globalThis.test("carries every slice's event types, not the first slice's", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addCategory,
+      addProduct,
+      renameCategory
+    ]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual([
+      "CategoryAdded",
+      "ProductAdded",
+      "CategoryRenamed"
+    ]);
+  });
+  globalThis.test("surfaces the ref fields of every slice that declares one", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addCategory,
+      addProduct,
+      renameCategory
+    ]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", merged).map(e => [
+      e.eventType,
+      e.fields.map(f => f.store)
+    ])).toEqual([
+      [
+        "CategoryAdded",
+        ["Catalog.categoryImages"]
+      ],
+      [
+        "ProductAdded",
+        ["Catalog.productImages"]
+      ]
+    ]);
+  });
+  globalThis.test("keeps one arm per event type", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addProduct,
+      addProduct
+    ]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual(["ProductAdded"]);
+  });
+  globalThis.test("leaves a lone slice's schema as it is", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([addProduct]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual(["ProductAdded"]);
+  });
+});
+
+export {
+  variant,
+  ref_,
+  addCategory,
+  addProduct,
+  renameCategory,
+}
+/* addCategory Not a pure module */