@reventlessdev/reventless-aws 3.0.0-alpha.339 → 3.0.0-alpha.341

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.341 (2026-09-08)
+
+### Bug Fixes
+
+* **aws:** the readiness gate waits for the collector's update, not its record ([c5a1d27](https://github.com/ReventlessDev/reventless-core/commit/c5a1d273be2c499bf1d1297a416d2cf6fce85ccf))
+
+
+# 3.0.0-alpha.340 (2026-09-08)
+
+### Bug Fixes
+
+* **aws:** a deployed state view slice composes its [@display](https://github.com/display)Name ([05ba7c5](https://github.com/ReventlessDev/reventless-core/commit/05ba7c531e605c5eb8d190a1fcb4f3d99888253d))
+### Features
+
+* a slice folder is named for its kind, without the Slice ([a400555](https://github.com/ReventlessDev/reventless-core/commit/a400555121b023823983ebe846e99cda27063c1f))
+* **core:** a reference names a row and shows its picture ([2b40d04](https://github.com/ReventlessDev/reventless-core/commit/2b40d0418bba2bf83463f446e94e372ea0c9898c))
+* **core:** a state view records when it reached each state ([5216f71](https://github.com/ReventlessDev/reventless-core/commit/5216f71b8dcafcb2f0c991923ebcf2438b27e347))
+
+
 # 3.0.0-alpha.339 (2026-09-07)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.339",
+  "version": "3.0.0-alpha.341",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -15,18 +15,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.15",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.8",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.258",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.122",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.259",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.160",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.159",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.131"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.123",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.132"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res.mjs

@@ -30,7 +30,7 @@ import * as CapabilityNeed$Reventless from "@reventlessdev/reventless-spec/src/s
 import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
 import * as Util_Bundle$ReventlessAws from "./util/Util_Bundle.res.mjs";
 import * as Plugin_Stack$ReventlessAws from "./plugin/stack/Plugin_Stack.res.mjs";
-import * as UiFragments$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs";
+import * as UiFragments$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs";
 import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
 import * as Platform_Casts$ReventlessAws from "./Platform_Casts.res.mjs";
 import * as Platform_Stack$ReventlessAws from "./Platform_Stack.res.mjs";
@@ -61,7 +61,7 @@ import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-cor
 import * as PluginsProjection$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsProjection.res.mjs";
 import * as StateTopic_AppSync$ReventlessAws from "./adapter/StateTopic/StateTopic_AppSync.res.mjs";
 import * as AppSync_SdlDecorate$ReventlessAws from "./components/Api/AppSync_SdlDecorate.res.mjs";
-import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
+import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry.res.mjs";
 import * as Util_ResourceNaming$ReventlessAws from "./util/Util_ResourceNaming.res.mjs";
 import * as Auth_ActiveRoleStore$ReventlessAws from "./adapter/Auth/Auth_ActiveRoleStore.res.mjs";
 import * as ClonerRunner_Fargate$ReventlessAws from "./plugin/cloner/ClonerRunner_Fargate.res.mjs";
@@ -77,7 +77,7 @@ import * as EventTopicPublisher_SNS$ReventlessAws from "./adapter/EventTopic/Eve
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
 import * as PgQueryResolver_Builder$ReventlessAws from "./adapter/QueryDb/PgQueryResolver_Builder.res.mjs";
 import * as Platform_BakedManifest$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_BakedManifest.res.mjs";
-import * as UiFragments_Projection$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs";
+import * as UiFragments_Projection$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateView/UiFragments_Projection.res.mjs";
 import * as Aggregate_Builder_Single$ReventlessAws from "./components/Aggregate_Builder_Single.res.mjs";
 import * as ReadModel_Builder_Single$ReventlessAws from "./components/ReadModel_Builder_Single.res.mjs";
 import * as StateChangeSlice_Builder$ReventlessAws from "./components/StateChangeSlice_Builder.res.mjs";
@@ -89,7 +89,7 @@ import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/revent
 import * as Platform_UIFragments_Lambda$ReventlessAws from "./adapter/Api/Platform_UIFragments_Lambda.res.mjs";
 import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "./adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
 import * as EventLogSubscription_AppSync$ReventlessAws from "./adapter/EventLogSubscription/EventLogSubscription_AppSync.res.mjs";
-import * as UiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
+import * as UiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry_Behavior.res.mjs";
 import * as CommandTopicChannel_SQS_Async$ReventlessAws from "./adapter/CommandTopic/CommandTopicChannel_SQS_Async.res.mjs";
 import * as Geocoder_AwsLocation_Resolver$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation_Resolver.res.mjs";
 import * as Plugin_ExtensionPoint_Builder$ReventlessAws from "./plugin/stack/Plugin_ExtensionPoint_Builder.res.mjs";

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res

@@ -103,6 +103,10 @@ type binding = {
       name — the `@namedWhenRetired` opt-in. Read only by the reference door;
       every other door narrows as it always did. */
   namedWhenRetired: bool,
+  /** The field a reference shows this row's picture from, derived from the same
+      schema as `capability` by `Reventless.RowImage`. `None` for a view that
+      declares no picture, which is most of them. */
+  imageSource: option<Reventless.RowImage.source>,
 }
 
 // -- arg helpers -------------------------------------------------------------
@@ -309,6 +313,15 @@ let dispatch = async (
                     ->Option.getOr(id),
                   ),
                 ),
+                // The picture travels with the name, so a retired row that keeps
+                // one keeps the other.
+                (
+                  "image",
+                  switch (binding.imageSource, item->JSON.Decode.object) {
+                  | (Some(source), Some(d)) => d->Reventless.RowImage.refFrom(source)
+                  | _ => None
+                  }->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+                ),
                 ("retired", JSON.Encode.bool(retired)),
                 ("retiredState", state->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
               ])->JSON.Encode.object,

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res.mjs

@@ -5,6 +5,7 @@ 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_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as RowImage$Reventless from "@reventlessdev/reventless-spec/src/semantic/RowImage.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
@@ -218,6 +219,8 @@ async function dispatch(binding, lookupBindingOpt, payload) {
           }
           let get = key => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[key]);
           let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(get("id"), Stdlib_JSON.Decode.string), "");
+          let match$1 = binding.imageSource;
+          let match$2 = Stdlib_JSON.Decode.object(item);
           return Object.fromEntries([
             [
               "id",
@@ -227,6 +230,10 @@ async function dispatch(binding, lookupBindingOpt, payload) {
               "label",
               Stdlib_Option.getOr(Stdlib_Option.flatMap(get(binding.labelField), Stdlib_JSON.Decode.string), id)
             ],
+            [
+              "image",
+              Stdlib_Option.mapOr(match$1 !== undefined && match$2 !== undefined ? RowImage$Reventless.refFrom(match$2, match$1) : undefined, null, prim => prim)
+            ],
             [
               "retired",
               retired

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -548,6 +548,13 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
               ~retiredField,
               ~retiredValues,
               ~namedWhenRetired=retiredSpec->Option.mapOr(false, r => r.namedWhenRetired),
+              // Derived at deploy time from the same schema every other backend
+              // derives it from at runtime — this is the one resolver that is
+              // generated source rather than a function, so it takes the read as
+              // an expression instead of doing it.
+              ~imageExpr=?stateSchemaOpt
+              ->Option.flatMap(Reventless.RowImage.sourceFrom)
+              ->Option.map(source => Reventless.RowImage.jsExpr(~row="row", source)),
               ~ownerField?,
               ~elevatedGroups,
             ),

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs

@@ -4,6 +4,7 @@ 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_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
+import * as RowImage$Reventless from "@reventlessdev/reventless-spec/src/semantic/RowImage.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
@@ -181,7 +182,7 @@ function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolve
     if (includeIdParam && subIdField === undefined) {
       let storage$1 = storageResource(undefined, name$1);
       let refsField = fieldNameForAll + "Refs";
-      resolverRefs = makeQueryResolver(Stdlib_String.capitalize(refsField), refsField, generateCode(storage$1, AppSync_Resolver_Functions$PulumiAws.refsByIds(labelField, retiredField, retiredValues, Stdlib_Option.mapOr(retiredSpec, false, r => r.namedWhenRetired), ownerField, elevatedGroups)));
+      resolverRefs = makeQueryResolver(Stdlib_String.capitalize(refsField), refsField, generateCode(storage$1, AppSync_Resolver_Functions$PulumiAws.refsByIds(labelField, retiredField, retiredValues, Stdlib_Option.mapOr(retiredSpec, false, r => r.namedWhenRetired), Stdlib_Option.map(Stdlib_Option.flatMap(stateSchemaOpt, RowImage$Reventless.sourceFrom), source => RowImage$Reventless.jsExpr("row", source)), ownerField, elevatedGroups)));
     } else {
       resolverRefs = undefined;
     }

package/src/adapter/Runtime/PgQueryResolverEntryPoint_Ops.res

@@ -169,6 +169,7 @@ let registerBinding = (
       ->Reventless.StateAnnotations.getSpec
       ->Option.flatMap(a => a.retired)
       ->Option.mapOr(false, r => r.namedWhenRetired),
+      imageSource: spec.stateSchema->Reventless.RowImage.sourceFrom,
     },
   )
   logDebug("registered resolver binding for " ++ entry.readModelName, {comp: "PgQueryResolver"})

package/src/adapter/Runtime/PgQueryResolverEntryPoint_Ops.res.mjs

@@ -4,6 +4,7 @@ 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 Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
+import * as RowImage$Reventless from "@reventlessdev/reventless-spec/src/semantic/RowImage.res.mjs";
 import * as PgRuntime$ReventlessAws from "../Postgres/PgRuntime.res.mjs";
 import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
@@ -78,7 +79,8 @@ function registerBinding(pushdowns, pgConnection, entry, spec) {
     ownerField: Owner$Reventless.fieldNames(spec.stateSchema)[0],
     retiredField: Stdlib_Option.map(Stdlib_Option.flatMap(StateAnnotations$Reventless.getSpec(spec.stateSchema), a => a.retired), r => r.field),
     retiredValues: Stdlib_Option.flatMap(Stdlib_Option.flatMap(StateAnnotations$Reventless.getSpec(spec.stateSchema), a => a.retired), r => r.values),
-    namedWhenRetired: Stdlib_Option.mapOr(Stdlib_Option.flatMap(StateAnnotations$Reventless.getSpec(spec.stateSchema), a => a.retired), false, r => r.namedWhenRetired)
+    namedWhenRetired: Stdlib_Option.mapOr(Stdlib_Option.flatMap(StateAnnotations$Reventless.getSpec(spec.stateSchema), a => a.retired), false, r => r.namedWhenRetired),
+    imageSource: RowImage$Reventless.sourceFrom(spec.stateSchema)
   });
   HandlerFactoryHelpersMjs.log.debug("registered resolver binding for " + entry.readModelName, {
     comp: "PgQueryResolver"

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res

@@ -86,6 +86,45 @@ let withUnionMemberTypes = (
     }
   }
 
+/**
+Composes the synthetic `displayName` column a `@displayName` state declares.
+
+`Projection.rewriteAction` does this for the typed paths — the local platform
+and the GWT harness rewrite the projection's actions before applying them — but
+a deployed state-view slice assembles its own JSON-level pipeline here, so the
+overlay never ran on AWS and every surface named the row by its id.
+
+Applied at save rather than on the action: the state reaching the table is the
+one an `Update`'s function already produced, so every action shape is covered
+without enumerating them. `None` — a spec with no annotation, or one that
+predates the metadata — leaves rows exactly as they were.
+*/
+let withDisplayName = (
+  base: ReventlessCore.QueryDb_Adapter.operations,
+  ~stateSchema: option<S.t<unknown>>,
+): ReventlessCore.QueryDb_Adapter.operations =>
+  switch stateSchema->Option.flatMap(Reventless.DisplayName.getSpec) {
+  | None => base
+  | Some(spec) =>
+    let compose = (state: JSON.t) => {
+      switch state->JSON.Decode.object {
+      | Some(stateDict) =>
+        stateDict->Dict.set(
+          "displayName",
+          JSON.Encode.string(Reventless.DisplayName.computeLabel(spec, stateDict)),
+        )
+      | None => ()
+      }
+      state
+    }
+    {
+      ...base,
+      save: (id, state, saveMode, ttl) => base.save(id, compose(state), saveMode, ttl),
+      saveBatch: items =>
+        base.saveBatch(items->Array.map(((id, state, ttl)) => (id, compose(state), ttl))),
+    }
+  }
+
 let makeQueryDbOps = (
   ~queryDbTableName: string,
   ~pgConnection: option<PgConnection.connectionConfig>,

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as StateTopicPublishMjs from "./StateTopicPublish.mjs";
 import * as QueryDbEntryPoint_Ops$ReventlessAws from "./QueryDbEntryPoint_Ops.res.mjs";
@@ -41,6 +43,33 @@ function withUnionMemberTypes(base, stateSchema) {
   }
 }
 
+function withDisplayName(base, stateSchema) {
+  let spec = Stdlib_Option.flatMap(stateSchema, DisplayName$Reventless.getSpec);
+  if (spec === undefined) {
+    return base;
+  }
+  let compose = state => {
+    let stateDict = Stdlib_JSON.Decode.object(state);
+    if (stateDict !== undefined) {
+      stateDict["displayName"] = DisplayName$Reventless.computeLabel(spec, stateDict);
+    }
+    return state;
+  };
+  return {
+    load: base.load,
+    loadStream: base.loadStream,
+    save: (id, state, saveMode, ttl) => base.save(id, compose(state), saveMode, ttl),
+    saveBatch: items => base.saveBatch(items.map(param => [
+      param[0],
+      compose(param[1]),
+      param[2]
+    ])),
+    count: base.count,
+    delete: base.delete,
+    deleteBatch: base.deleteBatch
+  };
+}
+
 function makeQueryDbOps(queryDbTableName, pgConnection, stateTopicName, indexes, subIdField) {
   if (pgConnection !== undefined) {
     return StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
@@ -59,6 +88,7 @@ export {
   subIdFieldOf,
   withLiveUpdates,
   withUnionMemberTypes,
+  withDisplayName,
   makeQueryDbOps,
 }
-/* TaggedUnion-Reventless Not a pure module */
+/* DisplayName-Reventless Not a pure module */

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -97,6 +97,10 @@ type envelope<'event> = {
   event: JSON.t,
   meta: Reventless.Message.meta,
   recordedAt: string,
+  // The producer time, read off the JSON rather than through `asMeta` — that
+  // cast admits `undefined`, so `meta.time` throws on an envelope without one.
+  // "" where the producer wrote none, which appends no trail entry.
+  producerTime: string,
 }
 
 let decodeEnvelope = (json: JSON.t): envelope<'event> => {
@@ -111,6 +115,12 @@ let decodeEnvelope = (json: JSON.t): envelope<'event> => {
     ->Option.flatMap(f => f->Dict.get("recordedAt"))
     ->Option.flatMap(JSON.Decode.string)
     ->Option.getOr(""),
+    producerTime: fields
+    ->Option.flatMap(f => f->Dict.get("meta"))
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.flatMap(m => m->Dict.get("time"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr(""),
   }
 }
 
@@ -129,14 +139,27 @@ let makeJsonEventsHandler = (
   >,
   ~queryDbOps: ReventlessCore.QueryDb_Adapter.operations,
   ~subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  ~stateSchema: option<S.t<unknown>>,
 ): ReventlessCore.EventCollector.jsonEventsHandler =>
   stream =>
     stream
     ->Stream.mapEffect(json =>
       Effect.sync(() =>
         try {
-          let {event, meta, recordedAt} = decodeEnvelope(json)
-          project({event: event->Reventless.Util_Sury.fromJson(eventSchema), meta, recordedAt})
+          let {event, meta, recordedAt, producerTime} = decodeEnvelope(json)
+          let actions = project({
+            event: event->Reventless.Util_Sury.fromJson(eventSchema),
+            meta,
+            recordedAt,
+          })
+          // The deployed slice assembles JSON-level operations rather than going
+          // through the typed rewrite, so the trail is appended here — with this
+          // envelope's own time, which the apply below no longer has.
+          producerTime === ""
+            ? actions
+            : actions->Array.map(
+                ReventlessCore.Projection.rewriteJsonAction(_, ~at=producerTime, ~stateSchema),
+              )
         } catch {
         | exn =>
           StreamRoutedEntryPoint_Ops.logError(
@@ -190,7 +213,9 @@ let makeRegisteredHandler = (
     ~stateTopicName=entry.stateTopicName,
     ~indexes=ProjectionEntryPoint_Ops.indexesOf(modules.config),
     ~subIdField=ProjectionEntryPoint_Ops.subIdFieldOf(modules.subIdConfig),
-  )->ProjectionEntryPoint_Ops.withUnionMemberTypes(~stateSchema=modules.stateSchema)
+  )
+  ->ProjectionEntryPoint_Ops.withUnionMemberTypes(~stateSchema=modules.stateSchema)
+  ->ProjectionEntryPoint_Ops.withDisplayName(~stateSchema=modules.stateSchema)
   {
     handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
       makeJsonEventsHandler(
@@ -199,6 +224,7 @@ let makeRegisteredHandler = (
         ~project=modules.project,
         ~queryDbOps,
         ~subIdConfig=modules.subIdConfig,
+        ~stateSchema=modules.stateSchema,
       ),
     ),
     // Matches the `StateViewSlice(<name>)` shape the rest of the framework

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs

@@ -59,19 +59,26 @@ function decodeEnvelope(json) {
   return {
     event: tmp,
     meta: Stdlib_Option.flatMap(fields, f => f["meta"]),
-    recordedAt: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(fields, f => f["recordedAt"]), Stdlib_JSON.Decode.string), "")
+    recordedAt: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(fields, f => f["recordedAt"]), Stdlib_JSON.Decode.string), ""),
+    producerTime: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(fields, f => f["meta"]), Stdlib_JSON.Decode.object), m => m["time"]), Stdlib_JSON.Decode.string), "")
   };
 }
 
-function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subIdConfig) {
+function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subIdConfig, stateSchema) {
   return stream => Stream.runForEach(Stream.flatMap(Stream.mapEffect(stream, json => Effect.sync(() => {
     try {
       let match = decodeEnvelope(json);
-      return project({
+      let producerTime = match.producerTime;
+      let actions = project({
         event: Util_Sury$Reventless.fromJson(match.event, eventSchema),
         meta: match.meta,
         recordedAt: match.recordedAt
       });
+      if (producerTime === "") {
+        return actions;
+      } else {
+        return actions.map(__x => Projection$ReventlessCore.rewriteJsonAction(__x, producerTime, stateSchema));
+      }
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       StreamRoutedEntryPoint_Ops$ReventlessAws.logError("failed to decode event", {
@@ -84,9 +91,9 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
 }
 
 function makeRegisteredHandler(entry, modules) {
-  let queryDbOps = ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(modules.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(modules.subIdConfig)), modules.stateSchema);
+  let queryDbOps = ProjectionEntryPoint_Ops$ReventlessAws.withDisplayName(ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(modules.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(modules.subIdConfig)), modules.stateSchema), modules.stateSchema);
   return {
-    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeJsonEventsHandler(modules.name, modules.consumedEventSchema, modules.project, queryDbOps, modules.subIdConfig)),
+    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeJsonEventsHandler(modules.name, modules.consumedEventSchema, modules.project, queryDbOps, modules.subIdConfig, modules.stateSchema)),
     comp: `StateViewSlice(` + modules.name + `)`
   };
 }

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -677,7 +677,13 @@ module Make = (
       ~opts,
     )
 
-    eventCollectorReadyRef := runtime.parts.lambda->Pulumi.Output.apply(_ => ())
+    // Through an output property, not the resource. `apply` receives the Function
+    // record as soon as the outer Output carries it — at construction, fields
+    // still unresolved — so discarding it reported ready mid-update, and the
+    // re-detect reached a Lambda still serving the previous bundle. `flatMap`
+    // returns the Output itself, which Pulumi awaits.
+    eventCollectorReadyRef :=
+      runtime.parts.lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())
 
     // Admin-only cross-plugin SNS subscription permissions. The admin EC
     // Lambda's manageSubscriptions hook (Phase 3 Step 1) creates SNS

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Aws from "@pulumi/aws";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
@@ -413,7 +414,7 @@ function Make(EventCollectorChannel) {
         eventTopics: eventTopics,
         resources: resources
       }], runtime, opts);
-    eventCollectorReadyRef.contents = runtime.parts.lambda.apply(param => {});
+    eventCollectorReadyRef.contents = Output$Pulumi.flatMap(runtime.parts.lambda, fn => fn.arn).apply(param => {});
     let isAdminEventCollector = Stdlib_Option.isNone(Plugin_Helpers$ReventlessCore.eventCollectorContextRef.contents[name]);
     if (isAdminEventCollector) {
       new (Aws.iam.RolePolicy)(name + `-snsManageSubs`, {

package/tests/AppSync_RetirementNarrowingTest.res.mjs

@@ -197,7 +197,7 @@ globalThis.describe("the unowned stub is callable where the door calls it", () =
     ]);
   });
   globalThis.test("declares a parameter on the reference door", () => {
-    let code = AppSync_Resolver_Functions$PulumiAws.refsByIds("name", undefined, undefined, false, undefined, undefined)("Products");
+    let code = AppSync_Resolver_Functions$PulumiAws.refsByIds("name", undefined, undefined, false, undefined, undefined, undefined)("Products");
     globalThis.expect([
       code.includes("const _owns = (row) => true;"),
       code.includes("_owns(row)")

package/tests/EventCollectorReadyGateTest.res

@@ -0,0 +1,89 @@
+open JestGlobals
+
+// Guards what `eventCollectorReadyRef` waits for.
+//
+// The deploy publishes a synthetic re-detect once the EventCollector Lambda is
+// ready, because that Lambda is what ANSWERS the handshake: reached while it is
+// still serving the previous bundle, it replies with the previous definition,
+// Connect sees a definition it already holds and emits nothing, and the
+// registration keeps the old structure — with no second re-detect coming.
+//
+// The gate used to be `lambda->Output.apply(_ => ())`. `apply` receives the
+// Function record as soon as the OUTER Output carries it, which is at
+// construction, with every field inside still an unresolved Output — so the gate
+// settled while the update was in flight and the whole barrier was inert. No
+// deploy-shaped test catches it: the answer is only stale when a deploy changes a
+// structure, and the race is won more often than it is lost.
+//
+// So this asserts the barrier directly — the gate must not settle until the
+// resource's own outputs do.
+
+// The engine's Output constructor, so a field can be left genuinely pending
+// rather than faked. A resolved promise would settle on the next tick either
+// way, which is the difference under test.
+@module("@pulumi/pulumi") @new
+external makeOutput: (
+  Set.t<unit>,
+  promise<'a>,
+  promise<bool>,
+  promise<bool>,
+  promise<Set.t<unit>>,
+) => Pulumi.Output.t<'a> = "Output"
+
+let pending = (value: 'a): (Pulumi.Output.t<'a>, unit => unit) => {
+  let settle = ref(() => ())
+  let p = Promise.make((resolve, _) => settle := () => resolve(value))
+  (
+    makeOutput(Set.make(), p, Promise.resolve(true), Promise.resolve(false), Promise.resolve(Set.make())),
+    settle.contents,
+  )
+}
+
+let ticks = async () => await Promise.make((resolve, _) => {
+  let _ = setTimeout(() => resolve(), 50)
+})
+
+// A Lambda mid-update: the resource record exists, its outputs do not yet.
+let deploying = (): (Pulumi.Output.t<PulumiAws.Lambda.Function.t>, unit => unit) => {
+  let (arn, complete) = pending("arn:aws:lambda:eu-west-1:123456789012:function:CatalogPluginEventColl")
+  let fn: PulumiAws.Lambda.Function.t = {
+    arn,
+    id: "CatalogPluginEventColl"->Pulumi.Output.make,
+    name: "CatalogPluginEventColl"->Pulumi.Output.make,
+    invokeArn: "arn:aws:apigateway:invoke"->Pulumi.Output.make,
+  }
+  // `apply` preserves the nested Outputs, which is how the real resource arrives.
+  (()->Pulumi.Output.make->Pulumi.Output.apply(_ => fn), complete)
+}
+
+let observe = (gate: Pulumi.Output.t<unit>): ref<bool> => {
+  let settled = ref(false)
+  let _ = gate->Pulumi.Output.apply(_ => settled := true)
+  settled
+}
+
+describe("the EventCollector readiness gate", () => {
+  testAsync("does not settle while the function's outputs are still pending", async () => {
+    let (lambda, _complete) = deploying()
+    let settled = lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())->observe
+    await ticks()
+    expect(settled.contents)->toBe(false)
+  })
+
+  testAsync("settles once they resolve", async () => {
+    let (lambda, complete) = deploying()
+    let settled = lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())->observe
+    complete()
+    await ticks()
+    expect(settled.contents)->toBe(true)
+  })
+
+  // The shape that shipped, kept as the reason the one above is written the way it
+  // is: applying to the resource settles against a Lambda still being updated.
+  testAsync("settles immediately when taken off the resource instead", async () => {
+    let (lambda, _complete) = deploying()
+    let settled = lambda->Pulumi.Output.apply(_ => ())->observe
+    await ticks()
+    expect(settled.contents)->toBe(true)
+  })
+})

package/tests/EventCollectorReadyGateTest.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+
+function pending(value) {
+  let settle = {
+    contents: () => {}
+  };
+  let p = new Promise((resolve, param) => {
+    settle.contents = () => resolve(value);
+  });
+  return [
+    new Pulumi.Output(new Set(), p, Promise.resolve(true), Promise.resolve(false), Promise.resolve(new Set())),
+    settle.contents
+  ];
+}
+
+async function ticks() {
+  return await new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 50);
+  });
+}
+
+function deploying() {
+  let match = pending("arn:aws:lambda:eu-west-1:123456789012:function:CatalogPluginEventColl");
+  let fn_arn = match[0];
+  let fn_id = Pulumi.output("CatalogPluginEventColl");
+  let fn_name = Pulumi.output("CatalogPluginEventColl");
+  let fn_invokeArn = Pulumi.output("arn:aws:apigateway:invoke");
+  let fn = {
+    arn: fn_arn,
+    id: fn_id,
+    name: fn_name,
+    invokeArn: fn_invokeArn
+  };
+  return [
+    Pulumi.output().apply(() => fn),
+    match[1]
+  ];
+}
+
+function observe(gate) {
+  let settled = {
+    contents: false
+  };
+  gate.apply(() => {
+    settled.contents = true;
+  });
+  return settled;
+}
+
+globalThis.describe("the EventCollector readiness gate", () => {
+  globalThis.test("does not settle while the function's outputs are still pending", async () => {
+    let match = deploying();
+    let settled = observe(Output$Pulumi.flatMap(match[0], fn => fn.arn).apply(param => {}));
+    await ticks();
+    globalThis.expect(settled.contents).toBe(false);
+  });
+  globalThis.test("settles once they resolve", async () => {
+    let match = deploying();
+    let settled = observe(Output$Pulumi.flatMap(match[0], fn => fn.arn).apply(param => {}));
+    match[1]();
+    await ticks();
+    globalThis.expect(settled.contents).toBe(true);
+  });
+  globalThis.test("settles immediately when taken off the resource instead", async () => {
+    let match = deploying();
+    let settled = observe(match[0].apply(param => {}));
+    await ticks();
+    globalThis.expect(settled.contents).toBe(true);
+  });
+});
+
+export {
+  pending,
+  ticks,
+  deploying,
+  observe,
+}
+/*  Not a pure module */