@reventlessdev/reventless-core 3.0.0-alpha.167 → 3.0.0-alpha.168

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 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.168 (2026-07-14)
+
+### Bug Fixes
+
+* **aws:** create EC publishToAggregates SendMessage grants — cross-plugin extension→DCB publishes no longer AccessDenied ([c2126df](https://github.com/ReventlessDev/reventless-core/commit/c2126df0b9af4a79a980f2668ffc18a7760ef4c3))
+* **aws:** create heartbeat SendMessage grant at top level; document the pulumi.all side-channel gotcha ([6ffa06a](https://github.com/ReventlessDev/reventless-core/commit/6ffa06ac87070af4027ba5753ac7c2cb216a76d0))
+* show debug logs on the local platform (both launch paths) ([81837d7](https://github.com/ReventlessDev/reventless-core/commit/81837d7e02abe1065a722b43b195adef2c836794))
+### Features
+
+* **core:** thread ~comp through Projection.handleAction for attributed action logging ([fa32d93](https://github.com/ReventlessDev/reventless-core/commit/fa32d93dedabea1b1f655f01a4ea769a5908b143))
+
+
 # 3.0.0-alpha.167 (2026-07-14)
 
 **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.167",
+  "version": "3.0.0-alpha.168",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,16 +28,16 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.12",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
+    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.12",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.15",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.99",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {

package/src/Projection.res

@@ -133,10 +133,16 @@ let statesToString: array<'a> => string = states =>
   states->Array.map(stateToString)->Array.joinUnsafe(", ")
 
 let handleAction = async (
+  ~comp="Projection",
   action,
   {QueryDb.loadStream: loadStream, save, saveBatch, delete, deleteBatch} as operations,
   subIdConfig,
 ) => {
+  // Log each applied action at Debug with the full state it creates/changes,
+  // attributed to the owning component. Debug-lazy so the state is only
+  // serialized when debug logging is enabled; shadows the module-level
+  // `logAction` to carry the threaded `~comp` and the `handling action:` prefix.
+  let logAction = makeStr => log.debugLazy(~comp, () => `handling action: ${makeStr()}`)
   let loadAtMost = (n, id) =>
     loadStream(id)
     ->Stream.take(n)
@@ -210,7 +216,6 @@ let handleAction = async (
     | Error(err) => Error(err)
     }
   | UpdateWithDefault(id, default, update) =>
-    logAction(() => `UpdateWithDefault(${id}, loading ...`)
     switch await loadAtMost(2, id) {
     | Ok(states) =>
       switch states {
@@ -424,19 +429,19 @@ let optimizeActions = actions => {
   })
 }
 
-let handleActions = async (actions, operations, subIdConfig) => {
+let handleActions = async (~comp="Projection", actions, operations, subIdConfig) => {
   let handleActionsForId = async (actions, id) => {
     let actionCount = actions->Array.length
     if actionCount > 1 {
       log.debug(
-        ~comp="Projection",
+        ~comp,
         `handleActions: optimizing ${actionCount->Int.toString} actions for id=${id}`,
       )
     }
 
     let optimizedActions = optimizeActions(actions)
     let optimizedActionCount = optimizedActions->Array.length
-    log.info(~comp="Projection", `handleActions: id=${id} actions=${optimizedActionCount->Int.toString}`)
+    log.debug(~comp, `handleActions: id=${id} actions=${optimizedActionCount->Int.toString}`)
 
     // FIXME: handle errors!
     await optimizedActions->Array.reduce(Ok()->Promise.resolve, async (p, action) => {
@@ -444,11 +449,11 @@ let handleActions = async (actions, operations, subIdConfig) => {
       | Ok() => ()
       | Error(err) =>
         log.error(
-          ~comp="Projection",
+          ~comp,
           `storage error: ${err->Message.encode(ReventlessInfra.QueryDb.storageErrorSchema)->JSON.stringify}`,
         )
       }
-      await action->handleAction(operations, subIdConfig)
+      await action->handleAction(~comp, operations, subIdConfig)
     })
   }
 

package/src/Projection.res.mjs

@@ -202,10 +202,12 @@ function statesToString(states) {
   return states.map(stateToString).join(", ");
 }
 
-async function handleAction(action, operations, subIdConfig) {
+async function handleAction($staropt$star, action, operations, subIdConfig) {
   let saveBatch = operations.saveBatch;
   let save = operations.save;
   let loadStream = operations.loadStream;
+  let comp = $staropt$star !== undefined ? $staropt$star : "Projection";
+  let logAction = makeStr => log.debugLazy(comp, () => `handling action: ` + makeStr());
   let loadAtMost = (n, id) => Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Stream$1.take(loadStream(id), n)), states => ({
     TAG: "Ok",
     _0: states
@@ -221,7 +223,7 @@ async function handleAction(action, operations, subIdConfig) {
     _0: e
   })));
   if (typeof action !== "object") {
-    log.debugLazy("Projection", () => "Ignore");
+    logAction(() => "Ignore");
     return {
       TAG: "Ok",
       _0: undefined
@@ -231,7 +233,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Create" :
       let state = action._1;
       let id = action._0;
-      log.debugLazy("Projection", () => `Create(` + id + `, ` + stateToString(state) + `)`);
+      logAction(() => `Create(` + id + `, ` + stateToString(state) + `)`);
       return await save(id, state, "Init", undefined);
     case "CreateMany" :
       let batch = action._0.map(param => [
@@ -239,7 +241,7 @@ async function handleAction(action, operations, subIdConfig) {
         param[1],
         undefined
       ]);
-      log.debugLazy("Projection", () => `CreateMany(` + batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
+      logAction(() => `CreateMany(` + batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch);
     case "Update" :
       let id$1 = action._0;
@@ -254,13 +256,13 @@ async function handleAction(action, operations, subIdConfig) {
       let len = states$1.length;
       if (len !== 1) {
         if (len !== 0) {
-          log.debugLazy("Projection", () => `Update Error: Multiple oldStates for ` + id$1 + `)`);
+          logAction(() => `Update Error: Multiple oldStates for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
           };
         } else {
-          log.debugLazy("Projection", () => `Update Error: No oldState for ` + id$1 + `)`);
+          logAction(() => `Update Error: No oldState for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
@@ -269,35 +271,34 @@ async function handleAction(action, operations, subIdConfig) {
       }
       let oldState = states$1[0];
       let newState = action._1(oldState);
-      log.debugLazy("Projection", () => `Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
+      logAction(() => `Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
       return await save(id$1, newState, "Overwrite", undefined);
     case "UpdateWithDefault" :
       let $$default = action._1;
       let id$2 = action._0;
-      log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, loading ...`);
       let states$2 = await loadAtMost(2, id$2);
       if (states$2.TAG === "Ok") {
         let states$3 = states$2._0;
         let len$1 = states$3.length;
         if (len$1 !== 1) {
           if (len$1 !== 0) {
-            log.debugLazy("Projection", () => `UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
+            logAction(() => `UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
             return {
               TAG: "Error",
               _0: "StaleState"
             };
           } else {
-            log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
+            logAction(() => `UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
             return await save(id$2, $$default, "Init", undefined);
           }
         }
         let oldState$1 = states$3[0];
         let newState$1 = action._2(oldState$1);
-        log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
+        logAction(() => `UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
         return await save(id$2, newState$1, "Overwrite", undefined);
       }
       let err = states$2._0;
-      log.debugLazy("Projection", () => `UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
+      logAction(() => `UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
       return {
         TAG: "Error",
         _0: err
@@ -305,7 +306,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Set" :
       let state$1 = action._1;
       let id$3 = action._0;
-      log.debugLazy("Projection", () => `Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
+      logAction(() => `Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
       return await save(id$3, state$1, "Any", undefined);
     case "SetMany" :
       let set = action._1;
@@ -314,15 +315,15 @@ async function handleAction(action, operations, subIdConfig) {
         set(id),
         undefined
       ]);
-      log.debugLazy("Projection", () => `SetMany(` + batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
+      logAction(() => `SetMany(` + batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch$1);
     case "Delete" :
       let id$4 = action._0;
-      log.debugLazy("Projection", () => `Delete(` + id$4 + `)`);
+      logAction(() => `Delete(` + id$4 + `)`);
       return await operations.delete(id$4, undefined);
     case "DeleteMany" :
       let ids = action._0;
-      log.debugLazy("Projection", () => `DeleteMany(` + ids.join(", ") + `)`);
+      logAction(() => `DeleteMany(` + ids.join(", ") + `)`);
       return await operations.deleteBatch(ids.map(id => [
         id,
         undefined
@@ -330,7 +331,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "CreateMultiState" :
       let states$4 = action._1;
       let id$5 = action._0;
-      log.debugLazy("Projection", () => `CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
+      logAction(() => `CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
       let len$2 = states$4.length;
       if (len$2 !== 1) {
         if (len$2 === 0) {
@@ -359,19 +360,19 @@ async function handleAction(action, operations, subIdConfig) {
         }
       } else if (subIdConfig !== undefined) {
         let err$1 = match._0;
-        log.debugLazy("Projection", () => `UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
+        logAction(() => `UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
         return {
           TAG: "Error",
           _0: err$1
         };
       }
-      log.debugLazy("Projection", () => "UpdateMultiState Error: Missing SubIdConfig !");
+      logAction(() => "UpdateMultiState Error: Missing SubIdConfig !");
       return {
         TAG: "Error",
         _0: "MissingSubIdConfig"
       };
     default:
-      log.debugLazy("Projection", () => "Error: projection action not supported");
+      logAction(() => "Error: projection action not supported");
       return {
         TAG: "Error",
         _0: {
@@ -668,24 +669,25 @@ function optimizeActions(actions) {
   });
 }
 
-async function handleActions(actions, operations, subIdConfig) {
+async function handleActions(compOpt, actions, operations, subIdConfig) {
+  let comp = compOpt !== undefined ? compOpt : "Projection";
   let handleActionsForId = async (actions, id) => {
     let actionCount = actions.length;
     if (actionCount > 1) {
-      log.debug("Projection", undefined, `handleActions: optimizing ` + actionCount.toString() + ` actions for id=` + id);
+      log.debug(comp, undefined, `handleActions: optimizing ` + actionCount.toString() + ` actions for id=` + id);
     }
     let optimizedActions = optimizeActions(actions);
     let optimizedActionCount = optimizedActions.length;
-    log.info("Projection", undefined, `handleActions: id=` + id + ` actions=` + optimizedActionCount.toString());
+    log.debug(comp, undefined, `handleActions: id=` + id + ` actions=` + optimizedActionCount.toString());
     return await Stdlib_Array.reduce(optimizedActions, Promise.resolve({
       TAG: "Ok",
       _0: undefined
     }), async (p, action) => {
       let err = await p;
       if (err.TAG !== "Ok") {
-        log.error("Projection", undefined, `storage error: ` + JSON.stringify(Message$ReventlessCore.encode(err._0, QueryDb$ReventlessInfra.storageErrorSchema)));
+        log.error(comp, undefined, `storage error: ` + JSON.stringify(Message$ReventlessCore.encode(err._0, QueryDb$ReventlessInfra.storageErrorSchema)));
       }
-      return await handleAction(action, operations, subIdConfig);
+      return await handleAction(comp, action, operations, subIdConfig);
     });
   };
   let results = await Promise.all(groupActionsById(actions).map(param => handleActionsForId(param[1], param[0])));

package/src/components/Dcb/Dcb_Builder.res

@@ -35,8 +35,15 @@ type dcbResult = {
   dcbPublishJsons: option<Pulumi.Output.t<CommandTopic.publishJsons>>,
   // SQS URL of the DCB command topic — shared by all StateChangeSlices in this
   // plugin. Surfaced so the bundled Plugin EventCollector Lambda can dispatch
-  // PublishStateChangeSliceCommand actions from user extensions to the right queue.
-  dcbCommandTopicQueueUrl: option<Pulumi.Output.t<string>>,
+  // PublishStateChangeSliceCommand actions from user extensions to the right
+  // queue. Resolves to "" when the plugin has no DCB slices — deliberately NOT
+  // option<Pulumi.Output.t<string>> (that combination is a repo-wide
+  // anti-pattern; it minted the nested-option sentinel that broke the
+  // collector's SendMessage grant). The Output is gated on the topic's
+  // `Component.operations`, so it resolves only after the topic finished
+  // constructing — see the construction site and
+  // docs/analysis/ec-publish-to-aggregates-grant-broken.md.
+  dcbCommandTopicQueueUrl: Pulumi.Output.t<string>,
   mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,
   queryEntries: array<ReventlessInfra.Api.querySchemaEntry>,
   eventLogEntries: array<ReventlessInfra.Api.eventLogSchemaEntry>,
@@ -51,7 +58,7 @@ let emptyResult: dcbResult = {
   inboundTranslationSlicesOutputs: Dict.make(),
   dcbRuntimeSetup: None,
   dcbPublishJsons: None,
-  dcbCommandTopicQueueUrl: None,
+  dcbCommandTopicQueueUrl: Pulumi.Output.make(""),
   mutationEntries: [],
   queryEntries: [],
   eventLogEntries: [],
@@ -956,24 +963,34 @@ module Make = (
             Sc.Spec.eventSchema->S.castToUnknown
           )
 
-        // NB: don't use `Option.map(r => r.id)` here — Stdlib_Option.map has a
-        // generic `'a => 'b` signature, so it wraps the lambda's return value
-        // via Caml_option.some(...). The static type of r.id is
-        // Pulumi.Output.t<string>, but a Pulumi Output is a JS object whose
-        // .id getter can resolve to undefined during early CustomResource
-        // construction; Caml_option.some(undefined) returns the nested-
-        // option sentinel `{BS_PRIVATE_NESTED_SOME_NONE: 0}`, which then
-        // flows through publishToAggregates into Lambda env vars and
-        // Pulumi's type checker rejects it (expected string, got object).
-        // The explicit switch keeps r.id's static type (non-option), so the
-        // `Some(r.id)` construction is identity-compiled — no wrapping.
-        let dcbCommandTopicQueueUrl = {
-          let outputs: CommandTopic.outputs = dcbCommandTopic->Component.outputs->Obj.magic
-          switch outputs.resources->Array.get(0) {
-          | Some(r) => Some(r.id)
-          | None => None
-          }
-        }
+        // Derive the DCB command topic's queue URL *after* the component's
+        // construct has stored its real resources. This reads `Component.outputs`
+        // as a synchronous side channel inside a callback gated on a DIFFERENT
+        // output (`Component.operations`, which resolves only post-construct) —
+        // reading `resources[0].id` at build time instead captured the SQS
+        // Queue's not-yet-resolved `.id`, which degenerated to the
+        // `{BS_PRIVATE_NESTED_SOME_NONE: 0}` nested-option sentinel and silently
+        // broke the Plugin EventCollector's sqs:SendMessage grant (cross-plugin
+        // extension → DCB-slice publishes → IAM AccessDenied).
+        //
+        // CONSUMER CONSTRAINT: because the value comes from that gated
+        // side-channel read (not from the `operations` payload itself), it must
+        // be resolved with a direct `.apply`, NOT batched through
+        // `Pulumi.Output.all`/`all2` — `all` invokes the callback at a different
+        // point in the graph where the side-channel read still yields the
+        // sentinel (verified on both preview and up). The EC grant builder
+        // therefore resolves it per-target. See
+        // docs/analysis/ec-publish-to-aggregates-grant-broken.md.
+        let dcbCommandTopicQueueUrl =
+          dcbCommandTopic
+          ->Component.operations
+          ->Pulumi.Output.flatMap(_ops => {
+            let outputs: CommandTopic.outputs = dcbCommandTopic->Component.outputs->Obj.magic
+            switch outputs.resources->Array.get(0) {
+            | Some(r) => r.id
+            | None => Pulumi.Output.make("")
+            }
+          })
         {
           dcbEventLogOutputs: Some(dcbEventLog->Component.outputs),
           stateChangeSlicesOutputs: Dict.fromArray(

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

@@ -4,6 +4,7 @@ import * as S from "sury/src/S.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";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+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 Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
@@ -55,6 +56,8 @@ let emptyResult_outboundTranslationSlicesOutputs = {};
 
 let emptyResult_inboundTranslationSlicesOutputs = {};
 
+let emptyResult_dcbCommandTopicQueueUrl = Pulumi.output("");
+
 let emptyResult_mutationEntries = [];
 
 let emptyResult_queryEntries = [];
@@ -70,7 +73,7 @@ let emptyResult = {
   inboundTranslationSlicesOutputs: emptyResult_inboundTranslationSlicesOutputs,
   dcbRuntimeSetup: undefined,
   dcbPublishJsons: undefined,
-  dcbCommandTopicQueueUrl: undefined,
+  dcbCommandTopicQueueUrl: emptyResult_dcbCommandTopicQueueUrl,
   mutationEntries: emptyResult_mutationEntries,
   queryEntries: emptyResult_queryEntries,
   eventLogEntries: emptyResult_eventLogEntries
@@ -544,9 +547,15 @@ function Make(DcbEventLogStorage) {
         };
       });
       let allProducedSchemas = stateChangeSlices.map(Sc => Sc.Spec.eventSchema);
-      let outputs = Component$ReventlessCore.outputs(dcbCommandTopic);
-      let r = outputs.resources[0];
-      let dcbCommandTopicQueueUrl = r !== undefined ? r.id : undefined;
+      let dcbCommandTopicQueueUrl = Output$Pulumi.flatMap(Component$ReventlessCore.operations(dcbCommandTopic), _ops => {
+        let outputs = Component$ReventlessCore.outputs(dcbCommandTopic);
+        let r = outputs.resources[0];
+        if (r !== undefined) {
+          return r.id;
+        } else {
+          return Pulumi.output("");
+        }
+      });
       return {
         dcbEventLogOutputs: Component$ReventlessCore.outputs(dcbEventLog),
         stateChangeSlicesOutputs: Object.fromEntries(Object.entries(stateChangeSlicesOutputs).concat(Object.entries(asyncStateChangeSlicesOutputs))),

package/src/components/ReadModel/ReadModel_Callback.res

@@ -39,7 +39,7 @@ module Make = (
           _ => {
             let action = Projection.rewriteAction(action, ReadModelSpec.stateSchema)
             Effect.promise(
-              () => Projection.handleAction(action, Spec.operations, ReadModelSpec.subIdConfig),
+              () => Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
             )->Effect.map(_ => ())
           },
         )

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

@@ -31,7 +31,7 @@ function Make(ReadModelSpec) {
         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(action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
+        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
       }));
     });
     return {

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -130,7 +130,7 @@ module Make = (
               ->Array.reduce(Effect.succeed(), (acc, action) =>
                 acc->Effect.flatMap(_ =>
                   Effect.promise(() =>
-                    FrameworkProjection.handleAction(action, projectionOps, Spec.subIdConfig)
+                    FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
                   )->Effect.map(_ => ())
                 )
               )

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

@@ -94,7 +94,7 @@ function Make(RuntimeEnvironment) {
               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, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(action, projectionOps, Spec.subIdConfig)), param => {})));
+            }).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

@@ -59,6 +59,6 @@ module Make = (
         `skipped=${skipped->Int.toString} events (decode mismatch)`,
       )->Effect.runSync
     }
-    await FrameworkProjection.handleActions(allActions, queryDbOps, Spec.subIdConfig)
+    await FrameworkProjection.handleActions(~comp, allActions, queryDbOps, Spec.subIdConfig)
   }
 }

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

@@ -38,7 +38,7 @@ function Make(Spec) {
       if (skipped > 0) {
         Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `skipped=` + skipped.toString() + ` events (decode mismatch)`));
       }
-      return await Projection$ReventlessCore.handleActions(allActions, queryDbOps, Spec.subIdConfig);
+      return await Projection$ReventlessCore.handleActions(comp, allActions, queryDbOps, Spec.subIdConfig);
     };
     return {
       Spec: Spec,

package/src/plugin/component/Plugin_Builder.res

@@ -776,13 +776,11 @@ module Make = (
         // All DCB StateChangeSlices share the same dcb command topic — map
         // every slice name to that single URL so PublishStateChangeSliceCommand
         // routes correctly regardless of which slice the extension targets.
-        switch dcbResult.dcbCommandTopicQueueUrl {
-        | Some(url) =>
-          stateChangeSlices->Array.forEach((module(Sc: StateChangeSlice.T)) =>
-            aggregateQueueUrls->Dict.set(Sc.Spec.name, url)
-          )
-        | None => ()
-        }
+        // (No-op when the plugin has no DCB slices: the list is empty and the
+        // URL Output resolves to "".)
+        stateChangeSlices->Array.forEach((module(Sc: StateChangeSlice.T)) =>
+          aggregateQueueUrls->Dict.set(Sc.Spec.name, dcbResult.dcbCommandTopicQueueUrl)
+        )
 
         // Per-RM EventCollector SQS URL — populated only for plugins that
         // expose RMs the bundled handler may enqueue events into directly.

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

@@ -510,12 +510,9 @@ function Make(Spec) {
               return;
             }
           });
-          let url = dcbResult.dcbCommandTopicQueueUrl;
-          if (url !== undefined) {
-            stateChangeSlices.forEach(Sc => {
-              aggregateQueueUrls[Sc.Spec.name] = url;
-            });
-          }
+          stateChangeSlices.forEach(Sc => {
+            aggregateQueueUrls[Sc.Spec.name] = dcbResult.dcbCommandTopicQueueUrl;
+          });
           let readModelQueueUrls = {};
           Object.entries(readModelsOutputs).forEach(param => {
             let urlOutput = Output$Pulumi.flatMap(param[1].eventCollector, ecOutputs => {

package/src/util/EffectLogger.res

@@ -68,8 +68,10 @@ external _withMinimumLogLevel: (Effect.t<'a, 'e, 'r>, effectLogLevel) => Effect.
 
 // Minimum level used when LOG_LEVEL is unset. Framework default is Info; a platform
 // may lower it (e.g. the in-memory dev platform sets Debug) via setDefaultMinLevel.
-let _defaultMin = ref(Logger.Info)
-let setDefaultMinLevel = (l: Logger.level) => _defaultMin := l
+// The ref lives in Logger (single source of truth) so both the record logger
+// (Logger.fromEnv) and this Effect logger share one platform default; re-exported
+// here so existing `EffectLogger.setDefaultMinLevel` callers keep working.
+let setDefaultMinLevel = Logger.setDefaultMinLevel
 
 // Resolve the active minimum: explicit LOG_LEVEL wins, else the platform default.
 let _effectMin = (): effectLogLevel =>
@@ -80,7 +82,7 @@ let _effectMin = (): effectLogLevel =>
   | Some("warn") => _llWarning
   | Some("error") => _llError
   | _ =>
-    switch _defaultMin.contents {
+    switch Logger.defaultMinLevel.contents {
     | Logger.Debug => _llDebug
     | Logger.Info => _llInfo
     | Logger.Warn => _llWarning

package/src/util/EffectLogger.res.mjs

@@ -26,14 +26,6 @@ function _messageToString(msg) {
   }
 }
 
-let _defaultMin = {
-  contents: "Info"
-};
-
-function setDefaultMinLevel(l) {
-  _defaultMin.contents = l;
-}
-
 function _effectMin() {
   let match = process.env.LOG_LEVEL;
   if (match !== undefined) {
@@ -50,7 +42,7 @@ function _effectMin() {
         return LogLevel.Warning;
     }
   }
-  let match$1 = _defaultMin.contents;
+  let match$1 = Logger$ReventlessCore.defaultMinLevel.contents;
   switch (match$1) {
     case "Debug" :
       return LogLevel.Debug;
@@ -155,9 +147,10 @@ function logDebug(comp, detail, msg) {
   return Logger.withMinimumLogLevel(_annotate(Effect.logDebug(msg), comp, detail), _effectMin());
 }
 
+let setDefaultMinLevel = Logger$ReventlessCore.setDefaultMinLevel;
+
 export {
   _messageToString,
-  _defaultMin,
   setDefaultMinLevel,
   _effectMin,
   ordinalToLevel,

package/src/util/Logger.res

@@ -165,8 +165,18 @@ let emit = (
 
 // ─── Logger.t (record-based API) ─────────────────────────────────────────────
 
-let makeLogger = (~minLevel=Info): t => {
-  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel)
+// Platform-tunable default minimum level, used when LOG_LEVEL is unset. Lives
+// here (not in EffectLogger) so it is the single source of truth for BOTH logger
+// paths — the record logger below and EffectLogger, which re-exports
+// `setDefaultMinLevel`. A platform may lower it (e.g. reventless-local sets
+// Debug); the framework default is Info.
+let defaultMinLevel = ref(Info)
+let setDefaultMinLevel = (l: level) => defaultMinLevel := l
+
+// Build a logger from a per-call predicate. `shouldLog` is evaluated on every
+// emit, so a logger created at module-init time still reflects a platform
+// default set later (and a live LOG_LEVEL) instead of baking the level in once.
+let makeLoggerWith = (shouldLog: level => bool): t => {
   let log = (level, ~comp=?, ~data=?, msg) =>
     if shouldLog(level) {
       let dataStr = data->Option.map(d => ` ${d->JSON.stringify}`)->Option.getOr("")
@@ -184,6 +194,11 @@ let makeLogger = (~minLevel=Info): t => {
   }
 }
 
+// Fixed-level logger — the level is baked at creation. Used by tests that assert
+// a specific minimum regardless of env/platform default.
+let makeLogger = (~minLevel=Info): t =>
+  makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel))
+
 let silent: t = {
   debug: (~comp as _=?, ~data as _=?, _) => (),
   info: (~comp as _=?, ~data as _=?, _) => (),
@@ -192,15 +207,30 @@ let silent: t = {
   debugLazy: (~comp as _=?, _) => (),
 }
 
-// Reads LOG_LEVEL from process.env and returns a configured logger.
-// Call once at module top-level or startup — not inside hot loops.
+// Active minimum level: explicit LOG_LEVEL wins, else the platform default.
+// None ⇒ silent (suppress everything). Re-read per call — LOG_LEVEL via the
+// process.env external, the platform default via `defaultMinLevel`.
+let effectiveMin = (): option<level> =>
+  switch _logLevel {
+  | Some("silent") => None
+  | Some("debug") => Some(Debug)
+  | Some("info") => Some(Info)
+  | Some("warn") => Some(Warn)
+  | Some("error") => Some(Error)
+  | Some(_) => Some(Info) // unrecognized value ⇒ Info (unchanged behavior)
+  | None => Some(defaultMinLevel.contents)
+  }
+
+// Reads LOG_LEVEL from process.env on every call and honors the platform default
+// when unset. Safe to call at module top-level: the returned logger evaluates the
+// level lazily, so a platform lowering the default afterwards (e.g.
+// reventless-local → Debug) takes effect for loggers already constructed.
 // LOG_LEVEL=silent disables all output (used by the reventless-gwt CLI so
 // framework diagnostics don't interleave with NDJSON / TAP / JUnit streams).
 let fromEnv = (): t =>
-  switch _logLevel {
-  | Some("silent") => silent
-  | Some("debug") => makeLogger(~minLevel=Debug)
-  | Some("warn") => makeLogger(~minLevel=Warn)
-  | Some("error") => makeLogger(~minLevel=Error)
-  | _ => makeLogger(~minLevel=Info)
-  }
+  makeLoggerWith(l =>
+    switch effectiveMin() {
+    | None => false
+    | Some(min) => levelToInt(l) >= levelToInt(min)
+    }
+  )

package/src/util/Logger.res.mjs

@@ -142,9 +142,15 @@ function emit(level, comp, plugin, detail, annotations, msg) {
   }
 }
 
-function makeLogger(minLevelOpt) {
-  let minLevel = minLevelOpt !== undefined ? minLevelOpt : "Info";
-  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel);
+let defaultMinLevel = {
+  contents: "Info"
+};
+
+function setDefaultMinLevel(l) {
+  defaultMinLevel.contents = l;
+}
+
+function makeLoggerWith(shouldLog) {
   let log = (level, comp, data, msg) => {
     if (!shouldLog(level)) {
       return;
@@ -165,6 +171,11 @@ function makeLogger(minLevelOpt) {
   };
 }
 
+function makeLogger(minLevelOpt) {
+  let minLevel = minLevelOpt !== undefined ? minLevelOpt : "Info";
+  return makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel));
+}
+
 function silent_debug(param, param$1, param$2) {
   
 }
@@ -193,25 +204,36 @@ let silent = {
   debugLazy: silent_debugLazy
 };
 
-function fromEnv() {
+function effectiveMin() {
   let match = process.env.LOG_LEVEL;
   if (match === undefined) {
-    return makeLogger("Info");
+    return defaultMinLevel.contents;
   }
   switch (match) {
     case "debug" :
-      return makeLogger("Debug");
+      return "Debug";
     case "error" :
-      return makeLogger("Error");
+      return "Error";
     case "silent" :
-      return silent;
+      return;
     case "warn" :
-      return makeLogger("Warn");
+      return "Warn";
     default:
-      return makeLogger("Info");
+      return "Info";
   }
 }
 
+function fromEnv() {
+  return makeLoggerWith(l => {
+    let min = effectiveMin();
+    if (min !== undefined) {
+      return levelToInt(l) >= levelToInt(min);
+    } else {
+      return false;
+    }
+  });
+}
+
 let currentPluginName = LogPrefix$Reventless.currentPluginName;
 
 let registerComponentPlugin = LogPrefix$Reventless.registerComponentPlugin;
@@ -241,8 +263,12 @@ export {
   fmtPlainPrefix,
   resolvePlugin,
   emit,
+  defaultMinLevel,
+  setDefaultMinLevel,
+  makeLoggerWith,
   makeLogger,
   silent,
+  effectiveMin,
   fromEnv,
 }
 /* s Not a pure module */

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -3,169 +3,6 @@
 import * as AdminApi$ReventlessCore from "../../src/admin/AdminApi.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
 
-let fullSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`;
-
-let collapsedSchemaSdl = `type Node {
-  id: ID!
-}
-
-type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-}`;
-
-let authAnnotatedSdl = `type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-    @aws_auth(cognito_groups: ["Admin"])
-  Catalog_addProduct(input: AddInput): Product
-    @aws_auth(cognito_groups: ["User"])
-}
-
-type Query {
-  node(id: ID!): Node @aws_auth(cognito_groups: ["Admin"])
-}`;
-
-globalThis.describe("GraphQL_Stitcher.countRootTypeFields", () => {
-  globalThis.test("counts Mutation fields", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation")).toBe(4);
-  });
-  globalThis.test("counts Query fields", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Query")).toBe(4);
-  });
-  globalThis.test("ignores @aws_auth directive lines, counts each Mutation field once", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(authAnnotatedSdl, "Mutation")).toBe(2);
-  });
-  globalThis.test("ignores @aws_auth directive lines, counts each Query field once", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(authAnnotatedSdl, "Query")).toBe(1);
-  });
-  globalThis.test("missing type returns 0", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Subscription")).toBe(0);
-  });
-  globalThis.test("empty SDL returns 0", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields("", "Mutation")).toBe(0);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.isCatastrophicSchemaShrink", () => {
-  globalThis.test("rejects the all-disconnected collapse (8 → 3 root fields, < 50%)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, collapsedSchemaSdl, 0.5)).toBe(true);
-  });
-  globalThis.test("allows an intentional small removal above threshold (8 → 7)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Ordering_placeOrder(input: OrderInput): Order
-}`, 0.5)).toBe(false);
-  });
-  globalThis.test("allows the first push when there is no live schema to protect", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink("", fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("allows an unchanged re-push (same SDL)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("allows a purely additive push even below threshold cardinality", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(collapsedSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
-  });
-  globalThis.test("includes Subscription fields when judging a shrink", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(`type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}
-
-type Subscription {
-  onOrdering_Customer_Register: Customer
-  onOrdering_Customer_UpdateAddress: Customer
-  onCatalog_Product_Added: Product
-}`, `type Query {
-  node(id: ID!): Node
-}
-
-type Mutation {
-  Ordering_placeOrder(input: OrderInput): Order
-}`, 0.5)).toBe(true);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
-  globalThis.test("lists Mutation field names", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Mutation")).toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct",
-      "Catalog_updateProduct",
-      "Ordering_placeOrder"
-    ]);
-  });
-  globalThis.test("strips args and @aws_auth directive lines", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(authAnnotatedSdl, "Mutation")).toEqual([
-      "Platform_connectPlugin",
-      "Catalog_addProduct"
-    ]);
-  });
-  globalThis.test("missing type returns []", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Subscription")).toEqual([]);
-  });
-});
-
-globalThis.describe("GraphQL_Stitcher.missingRootFields", () => {
-  globalThis.test("reports plugin fields absent from an admin-base clobber", () => {
-    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, collapsedSchemaSdl);
-    globalThis.expect(missing.includes("Catalog_addProduct")).toBe(true);
-    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
-    globalThis.expect(missing.includes("Ordering_orders")).toBe(true);
-  });
-  globalThis.test("empty when live schema is a superset (intact)", () => {
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, fullSchemaSdl)).toEqual([]);
-  });
-  globalThis.test("detects an equal-cardinality field swap the count test misses", () => {
-    let swapped = `type Query {
-  node(id: ID!): Node
-  Platform_plugins: [Plugin]
-  Catalog_products: [Product]
-  Ordering_orders: [Order]
-}
-
-type Mutation {
-  Platform_connectPlugin(input: ConnectInput): ConnectResult
-  Catalog_addProduct(input: AddInput): Product
-  Catalog_updateProduct(input: UpdateInput): Product
-  Foreign_strayField(input: OrderInput): Order
-}`;
-    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(swapped, "Mutation")).toBe(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation"));
-    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, swapped);
-    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
-  });
-});
-
 globalThis.describe("GraphQL_Stitcher.subscriptionSources", () => {
   globalThis.test("encode/decode round-trips the subscription→mutation source mapping", () => {
     let fragment = GraphQL_Stitcher$ReventlessCore.encode({
@@ -272,9 +109,4 @@ globalThis.describe("GraphQL_Stitcher.stitchStandalone", () => {
   });
 });
 
-export {
-  fullSchemaSdl,
-  collapsedSchemaSdl,
-  authAnnotatedSdl,
-}
 /*  Not a pure module */