@reventlessdev/reventless-core 3.0.0-alpha.265 → 3.0.0-alpha.267

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 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.267 (2026-09-21)
+
+### Bug Fixes
+
+* **core:** an event mapping that commands its own source no longer hangs ([d30ce6b](https://github.com/ReventlessDev/reventless-core/commit/d30ce6b360707d933732fa2c90aba49c03dda006))
+* feat(spec)!: typed projection keys ([fc6a018](https://github.com/ReventlessDev/reventless-core/commit/fc6a01811ba788f3289e84a435a09f77fa627e1a))
+### Features
+
+* **core:** references derived from identities, and identity checks ([7cb1376](https://github.com/ReventlessDev/reventless-core/commit/7cb1376e56cdb4e4d5ab5954cd97fd37fd3ba258))
+
+### BREAKING CHANGES
+
+* a projection that keys a row by a payload `string`, or uses
+the envelope id as a `string`, converts explicitly with
+`Target.Id.makeFromString` / `Source.Id.toString`. `StateChangeSlice.Spec` no
+longer requires `module Id`.
+
+
+
+# 3.0.0-alpha.266 (2026-09-21)
+
+### Bug Fixes
+
+* **core:** an aggregate read model is not keyed by a foreign id ([0dfed74](https://github.com/ReventlessDev/reventless-core/commit/0dfed747c4182b1fc58675b42f5d3cb3eb6309c7))
+### Features
+
+* **spec:** one Id type per identity ([203be38](https://github.com/ReventlessDev/reventless-core/commit/203be389b9047db0a7a0294fe3c1c04ba5119965))
+* **spec:** the runtime reads identities ([417c5f6](https://github.com/ReventlessDev/reventless-core/commit/417c5f613b031a08c7849a81c75de6a8bbeb841b))
+
+
 # 3.0.0-alpha.265 (2026-09-20)
 
 **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.265",
+  "version": "3.0.0-alpha.267",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -36,14 +36,14 @@
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.21",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.12",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.166",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.138",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.37"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.168",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.37",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.140"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.80"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.81"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Projection.res

@@ -6,16 +6,6 @@ module Set = Belt.Set.String
 
 let log = Logger.fromEnv()
 
-module Mapping = {
-  module MakeGenericSource = (Mapping: Reventless.Projection.Mapping): (
-    Mapper.GenericSource with type t = Mapping.sourceEvent
-  ) => {
-    let name = Mapping.sourceName
-    type t = Mapping.sourceEvent
-    let decode' = json => json->Message.decodeEvent'(S.string, Mapping.sourceEventSchema)
-  }
-}
-
 // Lazy: the message thunk (and any `stateToString` it triggers) runs only when
 // debug logging is enabled, so projection actions don't serialize state on the
 // hot path at the default Info level.

package/src/Projection.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Sury from "sury";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -22,18 +21,6 @@ import * as LogFormat$ReventlessCore from "./util/LogFormat.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
-function MakeGenericSource(Mapping) {
-  let decode$p = json => Message$ReventlessCore.decodeEvent$p(json, Sury.string, Mapping.sourceEventSchema);
-  return {
-    name: Mapping.sourceName,
-    decode$p: decode$p
-  };
-}
-
-let Mapping = {
-  MakeGenericSource: MakeGenericSource
-};
-
 function logAction(makeStr) {
   log.debugLazy("Projection", makeStr);
 }
@@ -786,7 +773,6 @@ let $$Set;
 export {
   $$Set,
   log,
-  Mapping,
   logAction,
   overlaysFor,
   applyOverlays,

package/src/ProjectionMapper.res

@@ -34,8 +34,14 @@ module Make = (
       module GenericMapping = {
         let sourceName = M.sourceName
         let acceptedTags = Reventless.DcbTag.extractAllVariantNames(M.sourceEventSchema)
-        module Source = Projection.Mapping.MakeGenericSource(M)
-        let project = MapperNto1.makeGenericMap(Source.decode', M.project)
+        // The storage edge: the envelope and the table carry strings, the
+        // projection typed ids — the same strings, decoded and encoded here.
+        let decode = json => json->Message.decodeEvent'(M.SourceId.schema, M.sourceEventSchema)
+        let project = MapperNto1.makeGenericMap(decode, msg =>
+          msg
+          ->M.project
+          ->Reventless.Projection.mapActionId(~to_=M.targetIdToString, ~from=M.targetIdFromString)
+        )
       }
       module(GenericMapping: Mapping)
     })

package/src/ProjectionMapper.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as Message$ReventlessCore from "./Message.res.mjs";
 import * as MapperNto1$ReventlessCore from "./MapperNto1.res.mjs";
-import * as Projection$ReventlessCore from "./Projection.res.mjs";
 
 function MakeGenericTargetFromStateTarget(StateTarget) {
   let decode = json => Message$ReventlessCore.decode(json, StateTarget.stateSchema);
@@ -27,8 +27,8 @@ function Make(Target) {
     };
     let mappings = Mappings.mappings.map(M => {
       let acceptedTags = DcbTag$Reventless.extractAllVariantNames(M.sourceEventSchema);
-      let Source = Projection$ReventlessCore.Mapping.MakeGenericSource(M);
-      let project = MapperNto1$ReventlessCore.makeGenericMap(Source.decode$p, M.project);
+      let decode = json => Message$ReventlessCore.decodeEvent$p(json, M.SourceId.schema, M.sourceEventSchema);
+      let project = MapperNto1$ReventlessCore.makeGenericMap(decode, msg => Projection$Reventless.mapActionId(M.project(msg), M.targetIdToString, M.targetIdFromString));
       return {
         sourceName: M.sourceName,
         acceptedTags: acceptedTags,

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -7,7 +7,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/Plugin
 
 let pluginId = "Platform";
 
-let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(undefined, true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 

package/src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs

@@ -40,6 +40,8 @@ let name = "UiFragments";
 
 let Id;
 
+let Key;
+
 let subIdConfig;
 
 let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs";
@@ -54,6 +56,7 @@ export {
   stateSchema,
   consumedEventSchema,
   config,
+  Key,
   subIdConfig,
   moduleUrl,
   authorization,

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -316,19 +316,32 @@ type keyFieldResolution =
   | Ambiguous({candidates: array<string>, conventional: string})
   | NoCandidate
 
+/** Where a view's row key lives. A read model's row is keyed by the envelope id of
+    the events it folds, so a `*Id` field in its state is somebody else's id unless
+    it is declared or named as the view's own. A StateViewSlice keys its row by a
+    state field. */
+type rowKeying = RowKeyedByEnvelope | RowKeyedByStateField
+
 /**
 The field that identifies a row, and which rung answered:
 
 - `"annotation"` — the state declares `@id`. Nothing outranks it.
-- `"convention"` — a field named `<singular entity name>Id` exists
-  (`Products` → `productId`).
-- `"sole"` — the state has exactly one `*Id` field (`AvailableProducts`).
+- `"convention"` — a field keyed `<singular entity name>Id` exists
+  (`Products` → `productId`): named so, or typed as that identity.
+- `"sole"` — the state has exactly one `*Id` field (`AvailableProducts`). Only for
+  `RowKeyedByStateField`: a read model's lone `*Id` is a foreign id (`Orders` →
+  `customerId`), and having none of its own is its ordinary shape, so neither
+  that nor several `*Id` fields is a gap.
 
 Convention outranks sole so a view carrying one foreign key and no key of its own
 is not keyed by the foreign key. `resolveKeyField` is this, with both gaps
 flattened to `None`.
 */
-let classifyKeyField = (~entityName: string, schema: S.t<unknown>): keyFieldResolution => {
+let classifyKeyField = (
+  ~rowKeying: rowKeying,
+  ~entityName: string,
+  schema: S.t<unknown>,
+): keyFieldResolution => {
   let declared = switch Reventless.StateAnnotations.getSpec(schema) {
   | Some({ids}) => ids->Array.get(0)
   | None => None
@@ -336,29 +349,45 @@ let classifyKeyField = (~entityName: string, schema: S.t<unknown>): keyFieldReso
   switch declared {
   | Some(field) => Resolved({field, rung: "annotation"})
   | None =>
+    // A field is a candidate by its name or by its type, and its key is its
+    // identity when it has one: `orderId: CustomerId.t` never keys `Orders`, and
+    // `order: OrderId.t` does.
+    let properties = switch schema {
+    | Object({properties}) => properties
+    | _ => Dict.make()
+    }
+    let keyOf = field =>
+      properties->Dict.get(field)->Option.flatMap(Reventless.Semantic.identityKey)
     let candidates =
       SchemaType.fromSuryObject(~typeName="", schema)
       ->Option.getOr(Dict.make())
       ->Dict.keysToArray
-      ->Array.filter(isKeyFieldName)
+      ->Array.filter(field => isKeyFieldName(field) || keyOf(field)->Option.isSome)
     let singular = entityName->Api_Naming.stripViewSuffix->Api_Naming.singularize
     let conventional =
       singular->String.slice(~start=0, ~end=1)->String.toLowerCase ++
       singular->String.slice(~start=1, ~end=singular->String.length) ++ "Id"
-    if candidates->Array.includes(conventional) {
-      Resolved({field: conventional, rung: "convention"})
-    } else if candidates->Array.length == 1 {
-      Resolved({field: candidates->Array.getUnsafe(0), rung: "sole"})
-    } else if Array.length(candidates) == 0 {
-      NoCandidate
-    } else {
-      Ambiguous({candidates, conventional})
+    switch candidates->Array.find(field => keyOf(field)->Option.getOr(field) == conventional) {
+    | Some(field) => Resolved({field, rung: "convention"})
+    | None =>
+      if rowKeying == RowKeyedByEnvelope {
+        NoCandidate
+      } else if candidates->Array.length == 1 {
+        Resolved({field: candidates->Array.getUnsafe(0), rung: "sole"})
+      } else if Array.length(candidates) == 0 {
+        NoCandidate
+      } else {
+        Ambiguous({candidates, conventional})
+      }
     }
   }
 }
 
-let resolveKeyField = (~entityName: string, schema: S.t<unknown>): option<(string, string)> =>
-  switch classifyKeyField(~entityName, schema) {
+let resolveKeyField = (~rowKeying: rowKeying, ~entityName: string, schema: S.t<unknown>): option<(
+  string,
+  string,
+)> =>
+  switch classifyKeyField(~rowKeying, ~entityName, schema) {
   | Resolved({field, rung}) => Some((field, rung))
   | Ambiguous(_) | NoCandidate => None
   }
@@ -457,7 +486,9 @@ let deriveServerCapability = (~entityName: string, schema: S.t<unknown>): server
   // a client asked for happened client-side over one page. Its key is knowable
   // without the annotation in the common cases; take it. Pushed last, and both
   // pushes dedupe, so a declared `@id` keeps its position and this is a no-op.
-  switch resolveKeyField(~entityName, schema) {
+  // Read as a state-field key for every view: a read model's lone foreign id is
+  // not its key, but it stays filterable, since dropping it would break the SDL.
+  switch resolveKeyField(~rowKeying=RowKeyedByStateField, ~entityName, schema) {
   | Some((field, _rung)) =>
     pushFilter(field, ~range=false)
     pushSort(field)

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

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Api_Naming$ReventlessCore from "./Api_Naming.res.mjs";
@@ -256,7 +257,7 @@ function isKeyFieldName(name) {
   }
 }
 
-function classifyKeyField(entityName, schema) {
+function classifyKeyField(rowKeying, entityName, schema) {
   let match = StateAnnotations$Reventless.getSpec(schema);
   let declared = match !== undefined ? match.ids[0] : undefined;
   if (declared !== undefined) {
@@ -266,15 +267,27 @@ function classifyKeyField(entityName, schema) {
       rung: "annotation"
     };
   }
-  let candidates = Object.keys(Stdlib_Option.getOr(SchemaType$ReventlessCore.fromSuryObject("", schema), {})).filter(isKeyFieldName);
+  let properties;
+  properties = schema.type === "object" ? schema.properties : ({});
+  let keyOf = field => Stdlib_Option.flatMap(properties[field], Semantic$Reventless.identityKey);
+  let candidates = Object.keys(Stdlib_Option.getOr(SchemaType$ReventlessCore.fromSuryObject("", schema), {})).filter(field => {
+    if (isKeyFieldName(field)) {
+      return true;
+    } else {
+      return Stdlib_Option.isSome(keyOf(field));
+    }
+  });
   let singular = Api_Naming$ReventlessCore.singularize(Api_Naming$ReventlessCore.stripViewSuffix(entityName));
   let conventional = singular.slice(0, 1).toLowerCase() + singular.slice(1, singular.length) + "Id";
-  if (candidates.includes(conventional)) {
+  let field = candidates.find(field => Stdlib_Option.getOr(keyOf(field), field) === conventional);
+  if (field !== undefined) {
     return {
       TAG: "Resolved",
-      field: conventional,
+      field: field,
       rung: "convention"
     };
+  } else if (rowKeying === "RowKeyedByEnvelope") {
+    return "NoCandidate";
   } else if (candidates.length === 1) {
     return {
       TAG: "Resolved",
@@ -292,8 +305,8 @@ function classifyKeyField(entityName, schema) {
   }
 }
 
-function resolveKeyField(entityName, schema) {
-  let match = classifyKeyField(entityName, schema);
+function resolveKeyField(rowKeying, entityName, schema) {
+  let match = classifyKeyField(rowKeying, entityName, schema);
   if (typeof match !== "object" || match.TAG !== "Resolved") {
     return;
   } else {
@@ -373,7 +386,7 @@ function deriveServerCapability(entityName, schema) {
     spec.scan.forEach(name => pushFilter(name, false));
     spec.scanSort.forEach(pushSort);
   }
-  let match = resolveKeyField(entityName, schema);
+  let match = resolveKeyField("RowKeyedByStateField", entityName, schema);
   if (match !== undefined) {
     let field = match[0];
     pushFilter(field, false);

package/src/components/Api/SchemaType.res

@@ -45,6 +45,14 @@ let isTagged = Reventless.DcbTag.isTagged
 let isDateTime = Reventless.DateTime.isDateTime
 let isCalendarDate = Reventless.CalendarDate.isCalendarDate
 
+// On the schema itself, not through `option<…>` as `Semantic.get` reads: the
+// optional wrapper then reaches the `AnyOf` branch and stays `Nullable`.
+let isIdentity = (schema: S.t<unknown>): bool =>
+  switch schema->S.Metadata.get(~id=Reventless.Semantic.semanticId) {
+  | Some({id}) => id === Reventless.Semantic.Id.identity
+  | None => false
+  }
+
 let isIdFieldName = (name: string): bool => {
   let lower = String.toLowerCase(name)
   let len = String.length(lower)
@@ -123,12 +131,14 @@ and withoutDefault = (
 }
 
 and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
-  // Two independent facts, checked independently. A DCB-tagged field is an
+  // Three independent facts, checked independently. A DCB-tagged field is an
   // entity id because it routes; a reference field is one because it points at
-  // an entity. Neither implies the other — a `@partitionTag` field carries no
+  // an entity; an identity-typed field is one whatever it is called. Neither implies the other — a `@partitionTag` field carries no
   // reference, and `Reference.toWithoutDcbTag` carries no tag — so collapsing
   // these into one test would silently reclassify whichever case it dropped.
-  if isTagged(schema) || Reventless.Reference.getTarget(schema)->Option.isSome {
+  if (
+    isTagged(schema) || Reventless.Reference.getTarget(schema)->Option.isSome || isIdentity(schema)
+  ) {
     EntityId
   } else {
     switch schema {

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

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Sury from "sury";
 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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
@@ -11,6 +12,15 @@ import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/comp
 import * as CalendarDate$Reventless from "@reventlessdev/reventless-spec/src/semantic/CalendarDate.res.mjs";
 import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 
+function isIdentity(schema) {
+  let match = Sury.$Metadata_get(schema, Semantic$Reventless.semanticId);
+  if (match !== undefined) {
+    return match.id === Semantic$Reventless.Id.identity;
+  } else {
+    return false;
+  }
+}
+
 function isIdFieldName(name) {
   let lower = name.toLowerCase();
   let len = lower.length;
@@ -87,7 +97,7 @@ function withoutDefault(parentName, fieldName, schema) {
 }
 
 function shapeOf(parentName, fieldName, schema) {
-  if (DcbTag$Reventless.isTagged(schema) || Stdlib_Option.isSome(Reference$Reventless.getTarget(schema))) {
+  if (DcbTag$Reventless.isTagged(schema) || Stdlib_Option.isSome(Reference$Reventless.getTarget(schema)) || isIdentity(schema)) {
     return "EntityId";
   }
   switch (schema.type) {
@@ -425,6 +435,7 @@ export {
   isTagged,
   isDateTime,
   isCalendarDate,
+  isIdentity,
   isIdFieldName,
   isIdsFieldName,
   semanticCompositeNames,
@@ -439,4 +450,4 @@ export {
   trailShape,
   fromSuryObject,
 }
-/* DcbTag-Reventless Not a pure module */
+/* sury Not a pure module */

package/src/components/Api/SuryToJsonSchema.res

@@ -310,11 +310,15 @@ and withSemantic = (fieldSchema: JSON.t, sem: Reventless.Semantic.t): JSON.t =>
     obj->Dict.set("x-reventless-semantic-source", str("type"))
     switch sem.payload {
     | Plain => ()
-    | ReferenceTo({entity, plugin}) =>
-      obj->Dict.set(
-        "x-reventless-semantic-target",
-        jsonObject(withOptionalPlugin([("entity", str(entity))], plugin)),
-      )
+    | ReferenceTo({entity, plugin, ?identity}) =>
+      let pairs = withOptionalPlugin([("entity", str(entity))], plugin)
+      let pairs = switch identity {
+      | Some(key) => Array.concat(pairs, [("identity", str(key))])
+      | None => pairs
+      }
+      obj->Dict.set("x-reventless-semantic-target", jsonObject(pairs))
+    | IdentityOf({key}) =>
+      obj->Dict.set("x-reventless-semantic-target", jsonObject([("key", str(key))]))
     | StoredIn({plugin, store}) =>
       // An absent plugin means "this plugin's own store" — omit the key rather
       // than writing an empty string, so a reader never has to tell those apart.

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

@@ -355,10 +355,16 @@ function withSemantic(fieldSchema, sem) {
     switch (match.TAG) {
       case "ReferenceTo" :
         let match$1 = match._0;
-        obj["x-reventless-semantic-target"] = Object.fromEntries(withOptionalPlugin([[
+        let identity = match$1.identity;
+        let pairs = withOptionalPlugin([[
             "entity",
             match$1.entity
-          ]], match$1.plugin));
+          ]], match$1.plugin);
+        let pairs$1 = identity !== undefined ? pairs.concat([[
+              "identity",
+              identity
+            ]]) : pairs;
+        obj["x-reventless-semantic-target"] = Object.fromEntries(pairs$1);
         break;
       case "StoredIn" :
         let match$2 = match._0;
@@ -384,6 +390,12 @@ function withSemantic(fieldSchema, sem) {
             match$3.field
           ]], match$3.plugin), "view", match$3.view), "content", match$3.content));
         break;
+      case "IdentityOf" :
+        obj["x-reventless-semantic-target"] = Object.fromEntries([[
+            "key",
+            match.key
+          ]]);
+        break;
     }
   }
   return obj;

package/src/components/EventMapper/EventMapper_Builder.res

@@ -79,8 +79,26 @@ module Make = (
           ~opts,
         )
 
+        // Not awaited, for the reason AutomationSlice_Builder gives: a mapping that
+        // commands its own source (Placed → Ship) appends an event this handler's
+        // fiber must dequeue, while the fiber is still waiting on the command. The
+        // bus then waits on itself, and so does the request that started it. Only
+        // the local runtime runs this handler; a deployed one uses its entry point.
+        let publishJsonsDetached = jsons => {
+          let _ = publishJsons(jsons)->Promise.catch(exn => {
+            log.error(
+              ~comp="EventMapper",
+              `detached publish error: ${exn
+                ->JsExn.fromException
+                ->Option.flatMap(JsExn.message)
+                ->Option.getOr("unknown")}`,
+            )
+            Promise.resolve()
+          })
+          Promise.resolve()
+        }
         module EventCollectorHandler = EventMapper_Callback.MakeEventCollectorHandler({
-          let publishJsons = publishJsons
+          let publishJsons = publishJsonsDetached
           let count = count
           let addToCounterTarget = addToCounterTarget
           let commonEventsHandler = CounterHandler.commonEventsHandler

package/src/components/EventMapper/EventMapper_Builder.res.mjs

@@ -1,9 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Counter$ReventlessCore from "../Counter/Counter.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
@@ -53,8 +55,15 @@ function Make(Target) {
             kind: "EventMapper",
             name: name
           }, opts);
+          let publishJsonsDetached = jsons => {
+            Stdlib_Promise.$$catch(publishJsons(jsons), exn => {
+              log.error("EventMapper", undefined, `detached publish error: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown"));
+              return Promise.resolve();
+            });
+            return Promise.resolve();
+          };
           let EventCollectorHandler = EventMapper_Callback$ReventlessCore.MakeEventCollectorHandler({
-            publishJsons: publishJsons,
+            publishJsons: publishJsonsDetached,
             count: param.count,
             addToCounterTarget: param.addToCounterTarget,
             commonEventsHandler: CounterHandler.commonEventsHandler

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -124,7 +124,17 @@ module Make = (
                   let (eventType, dataDict) = rawEvent->Message.splitMessage
                   switch decoder.decode(~eventType, ~data=dataDict) {
                   | Some(event) =>
-                    let actions = try Projection.project({event, meta, recordedAt}) catch {
+                    let actions = try Projection.project({
+                      event,
+                      meta,
+                      recordedAt,
+                    })->Array.map(
+                      Reventless.Projection.mapActionId(
+                        _,
+                        ~to_=Spec.Key.toString,
+                        ~from=Spec.Key.makeFromString,
+                      ),
+                    ) catch {
                     | exn =>
                       let errMsg =
                         exn

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -12,6 +12,7 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -108,7 +109,7 @@ function Make(RuntimeEnvironment) {
                   event: Primitive_option.valFromOption(event),
                   meta: meta,
                   recordedAt: recordedAt
-                });
+                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
               } catch (raw_exn) {
                 let exn$1 = Primitive_exceptions.internalToException(raw_exn);
                 let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -40,7 +40,14 @@ module Make = (
       | Some(event) =>
         idx := idx.contents + 1
         let id = raw.tags->Array.get(0)->Option.map(tag => tag.value)->Option.getOr("?")
-        let actions = Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})
+        let actions =
+          Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})->Array.map(
+            Reventless.Projection.mapActionId(
+              _,
+              ~to_=Spec.Key.toString,
+              ~from=Spec.Key.makeFromString,
+            ),
+          )
         let actionsStr = LogFormat.actionNames(actions)
         EffectLogger.logInfo(
           ~comp,

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -6,6 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
 import * as Projection$ReventlessCore from "../../Projection.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
@@ -32,7 +33,7 @@ function Make(Spec) {
           event: event,
           meta: raw.meta,
           recordedAt: raw.recordedAt
-        });
+        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
         allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));