@reventlessdev/reventless-core 3.0.0-alpha.258 → 3.0.0-alpha.260

package/src/components/Api/SchemaType.res

@@ -10,6 +10,13 @@ type rec schemaType =
   | ScalarBigInt
   | EntityId
   | DateTime
+  | /** A calendar day, with no instant in it. A shape of its own rather than a
+        plain string so `format: "date"` reaches the JSON Schema — but, unlike
+        `DateTime`, it is not excluded from the generic semantic wrapper below,
+        so it carries `x-reventless-semantic` as well. `DateTime`'s exclusion
+        exists because its bare-`format` output predates the marker and is a
+        published contract; a new semantic has no such history. */
+  CalendarDate
   | Nullable(schemaType)
   | ArrayOf(schemaType)
   | ObjectRef(string, dict<schemaType>)
@@ -20,6 +27,10 @@ type rec schemaType =
         are *not* expressed this way: they long predate the generic marker and
         their JSON Schema `format` output is a published contract. */
   Semantic(Reventless.Semantic.t, schemaType)
+  | /** A field whose type declares the value it opens with. Wraps the shape the
+        value has, as `Semantic` does, so a consumer that cares only about shape
+        unwraps: a default changes where a form starts, never what the field is. */
+  Defaulted(JSON.t, schemaType)
   | /** A variant used as a field: the union's name, and one arm per constructor
         keyed by the `TAG` sury discriminates on. Each arm is the `ObjectRef` its
         member type is emitted from, so the arm's own name travels with it and
@@ -32,6 +43,7 @@ type rec schemaType =
 
 let isTagged = Reventless.DcbTag.isTagged
 let isDateTime = Reventless.DateTime.isDateTime
+let isCalendarDate = Reventless.CalendarDate.isCalendarDate
 
 let isIdFieldName = (name: string): bool => {
   let lower = String.toLowerCase(name)
@@ -74,6 +86,17 @@ let canonicalName = (id: string): option<string> =>
   ->Option.map(((_, name)) => name)
 
 let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
+  // Outermost, so it wraps whatever the field turns out to be, a semantic
+  // composite included — the other order buries the marker under a shape whose
+  // consumers unwrap it.
+  let shape = withoutDefault(~parentName, ~fieldName, schema)
+  switch Reventless.FieldDefault.getFrom(schema) {
+  | Some(value) => Defaulted(value, shape)
+  | None => shape
+  }
+}
+
+and withoutDefault = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
   // Semantics the IR already has a dedicated shape for keep it: `dateTime` and
   // `reference` are read below via `isDateTime` / `getTarget`, both of which now
   // consult the generic marker, and their `format` output is a published
@@ -107,6 +130,7 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
     switch schema {
     | String({const: ?Some(_)}) => ScalarString
     | String(_) if isDateTime(schema) => DateTime
+    | String(_) if isCalendarDate(schema) => CalendarDate
     | String(_) => isIdFieldName(fieldName) ? EntityId : ScalarString
     // `Int32` and `Port` are both whole-number formats; anything else (or no
     // format at all) is a `float` as far as the schema is concerned.
@@ -348,15 +372,71 @@ let optionalFieldNames = (schema: S.t<unknown>): array<string> =>
   | _ => []
   }
 
+// A lifecycle trail's entries are `{state, at}`, and `state` holds the record's
+// own lifecycle. Walked under the lifecycle field's name so it resolves to the
+// enum that field already emits, rather than a second copy under the trail's
+// path — the trail and the current state must read as one vocabulary.
+let trailShape = (
+  ~parentName: string,
+  ~trailField: string,
+  ~lifecycleField: string,
+  schema: S.t<unknown>,
+): schemaType => {
+  let entryName =
+    parentName ++
+    trailField->String.charAt(0)->String.toUpperCase ++
+    trailField->String.slice(~start=1, ~end=trailField->String.length)
+  let entrySchema = switch schema {
+  | Array({additionalItems: Schema(item)}) => Some(item)
+  | _ => None
+  }
+  switch entrySchema {
+  | Some(Object({properties})) =>
+    let fields = Dict.make()
+    properties
+    ->Dict.toArray
+    ->Array.forEach(((propName, propSchema)) =>
+      fields->Dict.set(
+        propName,
+        propName === "state"
+          ? fromSury(~parentName, ~fieldName=lifecycleField, propSchema)
+          : fromSury(~parentName=entryName, ~fieldName=propName, propSchema),
+      )
+    )
+    let shape = ArrayOf(ObjectRef(entryName, fields))
+    // Walking the entries by shape skips the semantic dispatch `fromSury` does,
+    // so the marker is re-applied here. Without it the trail reaches a consumer
+    // as an unremarkable array of objects, and recognising it would come down to
+    // the field's name.
+    switch Reventless.Semantic.get(schema) {
+    | Some(sem) => Semantic(sem, shape)
+    | None => shape
+    }
+  | _ => fromSury(~parentName, ~fieldName=trailField, schema)
+  }
+}
+
 let fromSuryObject = (~typeName: string, schema: S.t<unknown>): option<dict<schemaType>> =>
   switch schema {
   | Object({properties}) =>
+    let trail = switch (
+      Reventless.Lifecycle.Trail.fieldName(schema),
+      Reventless.Lifecycle.fieldName(schema),
+    ) {
+    | (Some(trailField), Some(lifecycleField)) => Some((trailField, lifecycleField))
+    | _ => None
+    }
     let fields = Dict.make()
     properties
     ->Dict.toArray
     ->Array.forEach(((propName, propSchema)) => {
       if propName !== "TAG" {
-        fields->Dict.set(propName, fromSury(~parentName=typeName, ~fieldName=propName, propSchema))
+        let shape = switch trail {
+        | Some((trailField, lifecycleField)) if trailField === propName =>
+          trailShape(~parentName=typeName, ~trailField, ~lifecycleField, propSchema)
+        | _ => fromSury(~parentName=typeName, ~fieldName=propName, propSchema)
+        }
+        fields->Dict.set(propName, shape)
       }
     })
     Some(fields)

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

@@ -3,10 +3,13 @@
 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";
-import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
+import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/semantic/DateTime.res.mjs";
 import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
+import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
+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 isIdFieldName(name) {
   let lower = name.toLowerCase();
@@ -52,6 +55,20 @@ function canonicalName(id) {
 }
 
 function fromSury(parentName, fieldName, schema) {
+  let shape = withoutDefault(parentName, fieldName, schema);
+  let value = FieldDefault$Reventless.getFrom(schema);
+  if (value !== undefined) {
+    return {
+      TAG: "Defaulted",
+      _0: value,
+      _1: shape
+    };
+  } else {
+    return shape;
+  }
+}
+
+function withoutDefault(parentName, fieldName, schema) {
   let sem = Semantic$Reventless.get(schema);
   if (sem === undefined) {
     return shapeOf(parentName, fieldName, schema);
@@ -79,6 +96,8 @@ function shapeOf(parentName, fieldName, schema) {
         return "ScalarString";
       } else if (DateTime$Reventless.isDateTime(schema)) {
         return "DateTime";
+      } else if (CalendarDate$Reventless.isCalendarDate(schema)) {
+        return "CalendarDate";
       } else if (isIdFieldName(fieldName)) {
         return "EntityId";
       } else {
@@ -324,17 +343,72 @@ function optionalFieldNames(schema) {
   }
 }
 
+function trailShape(parentName, trailField, lifecycleField, schema) {
+  let entryName = parentName + trailField.charAt(0).toUpperCase() + trailField.slice(1, trailField.length);
+  let entrySchema;
+  if (schema.type === "array") {
+    let item = schema.additionalItems;
+    entrySchema = item === "strip" || item === "strict" ? undefined : item;
+  } else {
+    entrySchema = undefined;
+  }
+  if (entrySchema === undefined) {
+    return fromSury(parentName, trailField, schema);
+  }
+  if (entrySchema.type !== "object") {
+    return fromSury(parentName, trailField, schema);
+  }
+  let fields = {};
+  Object.entries(entrySchema.properties).forEach(param => {
+    let propSchema = param[1];
+    let propName = param[0];
+    fields[propName] = propName === "state" ? fromSury(parentName, lifecycleField, propSchema) : fromSury(entryName, propName, propSchema);
+  });
+  let shape = {
+    TAG: "ArrayOf",
+    _0: {
+      TAG: "ObjectRef",
+      _0: entryName,
+      _1: fields
+    }
+  };
+  let sem = Semantic$Reventless.get(schema);
+  if (sem !== undefined) {
+    return {
+      TAG: "Semantic",
+      _0: sem,
+      _1: shape
+    };
+  } else {
+    return shape;
+  }
+}
+
 function fromSuryObject(typeName, schema) {
   if (schema.type !== "object") {
     return;
   }
+  let match = Lifecycle$Reventless.Trail.fieldName(schema);
+  let match$1 = Lifecycle$Reventless.fieldName(schema);
+  let trail = match !== undefined && match$1 !== undefined ? [
+      match,
+      match$1
+    ] : undefined;
   let fields = {};
   Object.entries(schema.properties).forEach(param => {
     let propName = param[0];
-    if (propName !== "TAG") {
-      fields[propName] = fromSury(typeName, propName, param[1]);
+    if (propName === "TAG") {
       return;
     }
+    let propSchema = param[1];
+    let shape;
+    if (trail !== undefined) {
+      let trailField = trail[0];
+      shape = trailField === propName ? trailShape(typeName, trailField, trail[1], propSchema) : fromSury(typeName, propName, propSchema);
+    } else {
+      shape = fromSury(typeName, propName, propSchema);
+    }
+    fields[propName] = shape;
   });
   return fields;
 }
@@ -343,21 +417,26 @@ let isTagged = DcbTag$Reventless.isTagged;
 
 let isDateTime = DateTime$Reventless.isDateTime;
 
+let isCalendarDate = CalendarDate$Reventless.isCalendarDate;
+
 let maxReportDepth = 12;
 
 export {
   isTagged,
   isDateTime,
+  isCalendarDate,
   isIdFieldName,
   isIdsFieldName,
   semanticCompositeNames,
   canonicalName,
   fromSury,
+  withoutDefault,
   shapeOf,
   maxReportDepth,
   collectUnclassifiedUnions,
   unclassifiedUnions,
   optionalFieldNames,
+  trailShape,
   fromSuryObject,
 }
 /* DcbTag-Reventless Not a pure module */

package/src/components/Api/SuryToJsonSchema.res

@@ -207,6 +207,7 @@ let rec fromSchemaType = (~inputNames: bool=false, st: SchemaType.schemaType): J
   | ScalarBigInt => jsonObject([("type", str("integer"))])
   | EntityId => jsonObject([("type", str("string")), ("format", str("uuid"))])
   | DateTime => jsonObject([("type", str("string")), ("format", str("date-time"))])
+  | CalendarDate => jsonObject([("type", str("string")), ("format", str("date"))])
   | Nullable(inner) =>
     let innerSchema = fromSchemaType(~inputNames, inner)
     jsonObject([("oneOf", JSON.Encode.array([innerSchema, jsonObject([("type", str("null"))])]))])
@@ -233,6 +234,15 @@ let rec fromSchemaType = (~inputNames: bool=false, st: SchemaType.schemaType): J
     | _ => base
     }
     base->withSemantic(sem)
+  // JSON Schema's own keyword, not an `x-reventless-` extension: the vocabulary
+  // already has a word for this one, so any client reads it.
+  | Defaulted(value, inner) =>
+    switch fromSchemaType(~inputNames, inner)->JSON.Decode.object {
+    | Some(obj) =>
+      obj->Dict.set("default", value)
+      JSON.Encode.object(obj)
+    | None => fromSchemaType(~inputNames, inner)
+    }
   // A union has no input form — see the fragment generator, which emits `String`
   // and says so — hence no name to publish on either arm.
   // A union is `oneOf` its arms, each an object carrying the `TAG` const it is

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

@@ -170,119 +170,144 @@ function withGraphqlInput(schema, name) {
   }
 }
 
-function fromSchemaType(inputNamesOpt, st) {
-  let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
-  if (typeof st !== "object") {
-    switch (st) {
-      case "ScalarNumber" :
-        return Object.fromEntries([[
-            "type",
-            "number"
-          ]]);
-      case "ScalarBoolean" :
-        return Object.fromEntries([[
-            "type",
-            "boolean"
-          ]]);
-      case "ScalarInt" :
-      case "ScalarBigInt" :
-        return Object.fromEntries([[
-            "type",
-            "integer"
-          ]]);
-      case "EntityId" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "format",
-            "uuid"
-          ]
-        ]);
-      case "DateTime" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "format",
-            "date-time"
-          ]
-        ]);
-      case "ScalarString" :
-      case "Unknown" :
-        return Object.fromEntries([[
-            "type",
-            "string"
-          ]]);
-    }
-  } else {
-    switch (st.TAG) {
-      case "Nullable" :
-        let innerSchema = fromSchemaType(inputNames, st._0);
-        return Object.fromEntries([[
-            "oneOf",
+function fromSchemaType(_inputNamesOpt, _st) {
+  while (true) {
+    let inputNamesOpt = _inputNamesOpt;
+    let st = _st;
+    let inputNames = inputNamesOpt !== undefined ? inputNamesOpt : false;
+    if (typeof st !== "object") {
+      switch (st) {
+        case "ScalarNumber" :
+          return Object.fromEntries([[
+              "type",
+              "number"
+            ]]);
+        case "ScalarBoolean" :
+          return Object.fromEntries([[
+              "type",
+              "boolean"
+            ]]);
+        case "ScalarInt" :
+        case "ScalarBigInt" :
+          return Object.fromEntries([[
+              "type",
+              "integer"
+            ]]);
+        case "EntityId" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
             [
-              innerSchema,
-              Object.fromEntries([[
-                  "type",
-                  "null"
-                ]])
+              "format",
+              "uuid"
             ]
-          ]]);
-      case "ArrayOf" :
-        return Object.fromEntries([
-          [
-            "type",
-            "array"
-          ],
-          [
-            "items",
-            fromSchemaType(inputNames, st._0)
-          ]
-        ]);
-      case "ObjectRef" :
-        let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, st._1);
-        if (inputNames) {
-          return withGraphqlInput(base, st._0);
-        } else {
-          return base;
-        }
-      case "Enum" :
-        return Object.fromEntries([
-          [
-            "type",
-            "string"
-          ],
-          [
-            "enum",
-            st._1.map(prim => prim)
-          ]
-        ]);
-      case "Semantic" :
-        let inner = st._1;
-        let sem = st._0;
-        let base$1 = fromSchemaType(inputNames, inner);
-        let match = SchemaType$ReventlessCore.canonicalName(sem.id);
-        let base$2 = inputNames && match !== undefined && typeof inner === "object" && inner.TAG === "ObjectRef" ? withGraphqlInput(base$1, match + "Input") : base$1;
-        return withSemantic(base$2, sem);
-      case "TaggedUnion" :
-        let members = st._1.map(param => armToJsonSchema(inputNames, param[0], param[1]));
-        return Object.fromEntries([
-          [
-            "oneOf",
-            members
-          ],
-          [
-            "x-reventless-union",
-            st._0
-          ]
-        ]);
+          ]);
+        case "DateTime" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "format",
+              "date-time"
+            ]
+          ]);
+        case "CalendarDate" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "format",
+              "date"
+            ]
+          ]);
+        case "ScalarString" :
+        case "Unknown" :
+          return Object.fromEntries([[
+              "type",
+              "string"
+            ]]);
+      }
+    } else {
+      switch (st.TAG) {
+        case "Nullable" :
+          let innerSchema = fromSchemaType(inputNames, st._0);
+          return Object.fromEntries([[
+              "oneOf",
+              [
+                innerSchema,
+                Object.fromEntries([[
+                    "type",
+                    "null"
+                  ]])
+              ]
+            ]]);
+        case "ArrayOf" :
+          return Object.fromEntries([
+            [
+              "type",
+              "array"
+            ],
+            [
+              "items",
+              fromSchemaType(inputNames, st._0)
+            ]
+          ]);
+        case "ObjectRef" :
+          let base = objectRefToJsonSchema(undefined, undefined, undefined, undefined, inputNames, st._1);
+          if (inputNames) {
+            return withGraphqlInput(base, st._0);
+          } else {
+            return base;
+          }
+        case "Enum" :
+          return Object.fromEntries([
+            [
+              "type",
+              "string"
+            ],
+            [
+              "enum",
+              st._1.map(prim => prim)
+            ]
+          ]);
+        case "Semantic" :
+          let inner = st._1;
+          let sem = st._0;
+          let base$1 = fromSchemaType(inputNames, inner);
+          let match = SchemaType$ReventlessCore.canonicalName(sem.id);
+          let base$2 = inputNames && match !== undefined && typeof inner === "object" && inner.TAG === "ObjectRef" ? withGraphqlInput(base$1, match + "Input") : base$1;
+          return withSemantic(base$2, sem);
+        case "Defaulted" :
+          let inner$1 = st._1;
+          let obj = Stdlib_JSON.Decode.object(fromSchemaType(inputNames, inner$1));
+          if (obj !== undefined) {
+            obj["default"] = st._0;
+            return obj;
+          }
+          _st = inner$1;
+          _inputNamesOpt = inputNames;
+          continue;
+        case "TaggedUnion" :
+          let members = st._1.map(param => armToJsonSchema(inputNames, param[0], param[1]));
+          return Object.fromEntries([
+            [
+              "oneOf",
+              members
+            ],
+            [
+              "x-reventless-union",
+              st._0
+            ]
+          ]);
+      }
     }
-  }
+  };
 }
 
 function armToJsonSchema(inputNamesOpt, tag, armType) {

package/src/components/ReadModel/ReadModel_Callback.res

@@ -31,13 +31,16 @@ module Make = (
               json,
             )} actions:${actionsStr}`,
         )->Effect.runSync
-        actions
+        // Rewritten here rather than at the apply below: a trail entry is
+        // stamped with this envelope's own time.
+        actions->Array.map(
+          Projection.rewriteAction(_, ~at=context.meta.time, ReadModelSpec.stateSchema),
+        )
       })
       ->Array.flat
       ->Array.reduce(Effect.succeed(), (acc, action) =>
         acc->Effect.flatMap(
           _ => {
-            let action = Projection.rewriteAction(action, ReadModelSpec.stateSchema)
             Effect.promise(
               () => Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
             )->Effect.map(_ => ())

package/src/components/ReadModel/ReadModel_Callback.res.mjs

@@ -28,11 +28,8 @@ function Make(ReadModelSpec) {
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         let idxStr = (idx + 1 | 0).toString();
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, json, `handling event ` + idxStr + `/` + total + ` from ` + sourceName + `: ` + LogFormat$ReventlessCore.eventDetail(json) + ` actions:` + actionsStr));
-        return actions;
-      }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
-        let action$1 = Projection$ReventlessCore.rewriteAction(action, ReadModelSpec.stateSchema);
-        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
-      }));
+        return actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, context.meta.time, ReadModelSpec.stateSchema));
+      }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, Spec.operations, ReadModelSpec.subIdConfig)), param => {})));
     });
     return {
       EventProjector: EventProjector,

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -148,18 +148,19 @@ module Make = (
                     ~detail=eventData,
                     `handling event ${idxStr}/${total}: ${LogFormat.bold(eventType)}${fieldsStr} ${actionsStr}`,
                   )->Effect.runSync
-                  actions
+                  // A slice's state carries the same synthetic `displayName` the
+                  // ppx injects for a read model's, and the same lifecycle trail.
+                  // Rewritten here rather than at the apply below because the
+                  // trail entry is stamped with this envelope's own time.
+                  actions->Array.map(
+                    FrameworkProjection.rewriteAction(_, ~at=meta.time, Spec.stateSchema),
+                  )
                 | None => []
                 }
               })
               ->Array.flat
               ->Array.reduce(Effect.succeed(), (acc, action) =>
                 acc->Effect.flatMap(_ => {
-                  // A slice's state carries the same synthetic `displayName` the
-                  // ppx injects for a read model's, so it is composed on the same
-                  // terms — without this the column stays null and every surface
-                  // names the row by its id.
-                  let action = FrameworkProjection.rewriteAction(action, Spec.stateSchema)
                   Effect.promise(() =>
                     FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
                   )->Effect.map(_ => ())

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

@@ -120,11 +120,8 @@ function Make(RuntimeEnvironment) {
               let f = Object.entries(dataDict).map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
               let fieldsStr = f === "" ? "" : `({` + f + `})`;
               Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, dataDict, `handling event ` + idxStr + `/` + total + `: ` + LogFormat$ReventlessCore.bold(eventType) + fieldsStr + ` ` + actionsStr));
-              return actions;
-            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
-              let action$1 = Projection$ReventlessCore.rewriteAction(action, Spec.stateSchema);
-              return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, projectionOps, Spec.subIdConfig)), param => {});
-            }));
+              return actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, meta.time, Spec.stateSchema));
+            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, projectionOps, Spec.subIdConfig)), param => {})));
           });
           let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
           let resources = Component$ReventlessCore.outputs(queryDb).resources;

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -48,7 +48,9 @@ module Make = (
           `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(raw.eventType)}(${id}) ${actionsStr}`,
         )->Effect.runSync
         allActions->Array.pushMany(
-          actions->Array.map(FrameworkProjection.rewriteAction(_, Spec.stateSchema)),
+          actions->Array.map(
+            FrameworkProjection.rewriteAction(_, ~at=raw.meta.time, Spec.stateSchema),
+          ),
         )
         Some(event)
       | None => None

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

@@ -35,7 +35,7 @@ function Make(Spec) {
         });
         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, Spec.stateSchema)));
+        allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));
         return Primitive_option.some(event);
       });
       let skipped = rawEvents.length - events.length | 0;