@reventlessdev/reventless-core 3.0.0-alpha.134 → 3.0.0-alpha.136

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.136 (2026-07-02)
+
+### Bug Fixes
+
+* **core,local:** projection/publisher/bus correctness (plan A5,A7) ([86e27a5](https://github.com/ReventlessDev/reventless-core/commit/86e27a5d68873d7dd9e746f9b4126f4d5bad63c9))
+
+
+# 3.0.0-alpha.135 (2026-06-29)
+
+### Features
+
+* external-system boxes for translation slices (Event Graph data) ([3f8ad39](https://github.com/ReventlessDev/reventless-core/commit/3f8ad39b78a3cb1182d59a0e1fb203b7dcb7379b))
+
+
 # 3.0.0-alpha.134 (2026-06-27)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.134",
+  "version": "3.0.0-alpha.136",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.23",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.3",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.81",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.21",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.61",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.13"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.83",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.13",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.22",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.63"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.47"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Projection.res

@@ -103,8 +103,16 @@ let applyChanges = async (
     `${action}(${id}): beforeStates:${beforeCount->Int.toString} afterStates:${afterCount->Int.toString} added:${addedCount->Int.toString} changed:${changedCount->Int.toString} deleted:${deletedCount->Int.toString}`,
   )
   let result = await [deleteBatch(batchToDelete), saveBatch(batchToSave)]->Promise.all
-  switch result {
-  | _ => Ok() // TODO: Error handling
+  // Propagate the first storage failure instead of swallowing it — a failed
+  // delete/save was previously reported as a successful projection.
+  switch result->Array.find(r =>
+    switch r {
+    | Error(_) => true
+    | Ok(_) => false
+    }
+  ) {
+  | Some(err) => err
+  | None => Ok()
   }
 }
 
@@ -236,10 +244,12 @@ let handleAction = async (
     logAction(`DeleteMany(${ids->Array.joinUnsafe(", ")})`)
     await deleteBatch(ids->Array.map(id => (id, None)))
 
-  // TODO: add missing actions
+  // An action reaching here is one this projection engine doesn't implement.
+  // Returning Ok() reported the read-model write as done while silently losing
+  // it; surface a storage error instead.
   | _ =>
-    logAction("Error: Action not yet supported !")
-    Ok()
+    logAction("Error: projection action not supported")
+    Error(ReventlessInfra.QueryDb.NotSavedToStorage("unsupported projection action"))
   }
 }
 
@@ -285,11 +295,10 @@ let optimizeActions = actions => {
       [action]
     } else {
       let lastAction = optimizedActions->Array.getUnsafe(optimizedActionsCount - 1)
-      let previousActions = if optimizedActionsCount == 1 {
-        []
-      } else {
-        optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount)
-      }
+      // Everything BEFORE the last action. `~end` is exclusive, so this must be
+      // `count - 1`; using `count` kept `lastAction` in the slice while the merged
+      // action was also appended, applying the last action twice.
+      let previousActions = optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount - 1)
 
       switch (lastAction, action) {
       // SINGLE STATES

package/src/Projection.res.mjs

@@ -174,14 +174,19 @@ async function applyChanges(action, id, beforeStates, afterStates, param, param$
   ]);
   let deletedCount = batchToDelete.length;
   logAction(action + `(` + id + `): beforeStates:` + beforeCount.toString() + ` afterStates:` + afterCount.toString() + ` added:` + addedCount.toString() + ` changed:` + changedCount.toString() + ` deleted:` + deletedCount.toString());
-  await Promise.all([
+  let result = await Promise.all([
     param.deleteBatch(batchToDelete),
     param.saveBatch(batchToSave)
   ]);
-  return {
-    TAG: "Ok",
-    _0: undefined
-  };
+  let err = result.find(r => r.TAG !== "Ok");
+  if (err !== undefined) {
+    return err;
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
 }
 
 function stateToString(state) {
@@ -369,10 +374,13 @@ async function handleAction(action, operations, subIdConfig) {
         _0: "MissingSubIdConfig"
       };
     default:
-      logAction("Error: Action not yet supported !");
+      logAction("Error: projection action not supported");
       return {
-        TAG: "Ok",
-        _0: undefined
+        TAG: "Error",
+        _0: {
+          TAG: "NotSavedToStorage",
+          _0: "unsupported projection action"
+        }
       };
   }
 }
@@ -456,7 +464,7 @@ function optimizeActions(actions) {
       return [action];
     }
     let lastAction = optimizedActions[optimizedActionsCount - 1 | 0];
-    let previousActions = optimizedActionsCount === 1 ? [] : optimizedActions.slice(0, optimizedActionsCount);
+    let previousActions = optimizedActions.slice(0, optimizedActionsCount - 1 | 0);
     if (typeof lastAction === "object") {
       switch (lastAction.TAG) {
         case "Create" :

package/src/components/Aggregate/Aggregate_Callback.res

@@ -185,11 +185,14 @@ module Make = (
                 ~appendedEventCount=generatedEvents'->Array.length,
               )
               EffectLogger.logInfo(~comp, `append: id=${idStr}`)->Effect.map(_ => Ok(perRef))
-            | Error(msg) if msg->String.includes("conflict") =>
+            | Error(EventLog.Conflict) =>
+              // Signal the outer replay+re-decide retry loop (which matches
+              // Error(_)); the string is an internal marker, no longer a
+              // cross-component substring sentinel.
               EffectLogger.logWarn(~comp, `conflict: id=${idStr}, will retry`)->Effect.map(
-                _ => Error(msg),
+                _ => Error("conflict"),
               )
-            | Error(msg) =>
+            | Error(EventLog.StorageFailure(msg)) =>
               let perRef = reportFinalOutcomes(
                 outcomes,
                 ~entityId=idStr,

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -146,14 +146,15 @@ function Make(Spec) {
               }));
             }
             let msg = appendResult._0;
-            if (msg.includes("conflict")) {
+            if (typeof msg !== "object") {
               return Effect.map(EffectLogger$ReventlessCore.logWarn(comp, undefined, `conflict: id=` + idStr + `, will retry`), () => ({
                 TAG: "Error",
-                _0: msg
+                _0: "conflict"
               }));
             }
-            let perRef$1 = reportFinalOutcomes(outcomes, idStr, false, 0, msg);
-            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed: id=` + idStr + `: ` + msg), () => ({
+            let msg$1 = msg._0;
+            let perRef$1 = reportFinalOutcomes(outcomes, idStr, false, 0, msg$1);
+            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed: id=` + idStr + `: ` + msg$1), () => ({
               TAG: "Ok",
               _0: perRef$1
             }));

package/src/components/EventLog/EventLog.res

@@ -7,7 +7,19 @@ type component<'operations> = Component.t<t, outputs, 'operations>
 
 exception ReplayError(string)
 
-type append<'id, 'event> = (int, 'id, array<'event>) => promise<result<unit, string>>
+// Typed append outcome. `Conflict` is the optimistic-concurrency sentinel — the
+// deliberate append-condition failure (seq_nr/position already taken) that the
+// caller retries by re-reading and re-deciding. Every other failure is a
+// `StorageFailure` carrying its message. This replaces the former string sentinel
+// that was detected by substring-matching a pretty-printed Cause across three
+// layers — a real error whose text happened to contain "conflict" would have
+// been retried as an OCC conflict, and a misclassified conflict would surface as
+// a permanent error.
+type appendError =
+  | Conflict
+  | StorageFailure(string)
+
+type append<'id, 'event> = (int, 'id, array<'event>) => promise<result<unit, appendError>>
 type replay<'id, 'event> = 'id => promise<array<'event>>
 type replayStream<'id, 'event> = 'id => Stream.t<'event, string, unit>
 type appendStream<'id, 'event> = (int, 'id, Stream.t<'event, string, unit>) => Effect.t<unit, string, unit>

package/src/components/EventLog/EventLog_Operations.res

@@ -16,14 +16,21 @@ module type T = {
 // Retry schedule for transient storage errors.
 // Exponential backoff: 100ms, ~200ms, ~400ms, ~800ms, ~1600ms — max 5 retries.
 // Only retries on recognised transient error messages; permanent errors propagate immediately.
-let isTransient = (msg: string) =>
-  msg->String.includes("ThrottlingException") ||
-  msg->String.includes("ProvisionedThroughputExceededException") ||
-  msg->String.includes("ServiceUnavailable") ||
-  msg->String.includes("RequestLimitExceeded") ||
-  msg->String.includes("InternalServerError")
-
-let storageRetrySchedule: Schedule.t<(Duration.t, int), string, unit> =
+// Retry only recognised transient storage failures — never a Conflict (a retry
+// of the same append would just conflict again; the OCC retry happens a layer up
+// via replay+re-decide).
+let isTransient = (e: EventLog.appendError) =>
+  switch e {
+  | EventLog.Conflict => false
+  | StorageFailure(msg) =>
+    msg->String.includes("ThrottlingException") ||
+    msg->String.includes("ProvisionedThroughputExceededException") ||
+    msg->String.includes("ServiceUnavailable") ||
+    msg->String.includes("RequestLimitExceeded") ||
+    msg->String.includes("InternalServerError")
+  }
+
+let storageRetrySchedule: Schedule.t<(Duration.t, int), EventLog.appendError, unit> =
   Schedule.exponential(Duration.millis(100))
   ->Schedule.jittered
   ->Schedule.intersect(Schedule.recurs(5))
@@ -112,44 +119,40 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
     }
   }
 
-  // append returns result<unit, string> — never throws.
-  // Storage errors are retried with exponential backoff (up to 5 times for transient errors).
-  // After exhausting retries, or on permanent errors, returns Error.
-  let isConflict = (msg: string) => msg->String.includes("conflict")
-
+  // append returns result<unit, EventLog.appendError> — never throws.
+  // Transient storage failures are retried with exponential backoff (up to 5
+  // times); a Conflict is returned immediately (retried a layer up), and other
+  // failures propagate after retries are exhausted.
   let append = async (sequenceNr, id, events') => {
     let eventsJson = events'->encodeEvents'(id, sequenceNr)
     let idStr = id->Spec.Id.toString
-    // Build an Effect that fails with a string on storage error (enabling retry)
+    // A thrown storage error becomes a StorageFailure; a returned Error keeps its
+    // typed variant. The Effect fails with the typed appendError so the schedule
+    // can retry only transient failures, then we collapse the outcome back into a
+    // result (no Cause stringification / substring matching).
     let storageEffect =
       Effect.tryPromise(
-        ~catch=(err: unknown) => Util.Error.messageFromUnknown(err, "storage error"),
+        ~catch=(err: unknown) =>
+          EventLog.StorageFailure(Util.Error.messageFromUnknown(err, "storage error")),
         () => Ops.storage.append(sequenceNr, idStr, eventsJson),
       )
       ->Effect.flatMap(result =>
         switch result {
-        | Ok(_) => Effect.succeed(())
-        | Error(msg) => Effect.fail(msg)
+        | Ok(_) => Effect.succeed()
+        | Error(e) => Effect.fail(e)
         }
       )
       ->Effect.retry(storageRetrySchedule)
-    let exit = await storageEffect->Effect.runPromiseExit
-    if exit->Exit.isSuccess {
-      await publishToEventTopic(id, events', eventsJson)
-    } else {
-      // Retry exhausted — extract the final error message from the Cause.
-      // Use Cause.pretty so defects (uncaught throws) are surfaced too, not
-      // just typed failures from Cause.failures.
-      let failMsg = exit->Exit.match(
-        ~onFailure=cause => cause->Cause.pretty,
-        ~onSuccess=_ => "storage error", // unreachable: we are in the isFailure branch
-      )
-      // Propagate conflict errors without wrapping so callers can detect them
-      if isConflict(failMsg) {
-        Error("conflict")
-      } else {
-        Error(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${failMsg}`)
-      }
+      ->Effect.map(_ => Ok())
+      ->Effect.catchAll(e => Effect.succeed(Error(e)))
+    switch await storageEffect->Effect.runPromise {
+    | Ok() =>
+      (await publishToEventTopic(id, events', eventsJson))->Result.mapError(msg => EventLog.StorageFailure(
+        msg,
+      ))
+    | Error(EventLog.Conflict) => Error(EventLog.Conflict)
+    | Error(StorageFailure(msg)) =>
+      Error(EventLog.StorageFailure(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${msg}`))
     }
   }
 

package/src/components/EventLog/EventLog_Operations.res.mjs

@@ -1,12 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Exit from "@reventlessdev/rescript-effect/src/Exit.res.mjs";
 import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Exit$1 from "effect/Exit";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
-import * as Cause from "effect/Cause";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Effect$1 from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -18,7 +16,11 @@ import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as EventPublish_Callback$ReventlessCore from "./EventPublish_Callback.res.mjs";
 
-function isTransient(msg) {
+function isTransient(e) {
+  if (typeof e !== "object") {
+    return false;
+  }
+  let msg = e._0;
   if (msg.includes("ThrottlingException") || msg.includes("ProvisionedThroughputExceededException") || msg.includes("ServiceUnavailable") || msg.includes("RequestLimitExceeded")) {
     return true;
   } else {
@@ -111,27 +113,42 @@ function Make(Spec) {
     let append = async (sequenceNr, id, events$p) => {
       let eventsJson = encodeEvents$p(events$p, id, sequenceNr);
       let idStr = Spec.Id.toString(id);
-      let storageEffect = Effect$1.retry(Effect$1.flatMap(Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "storage error"), () => Ops.storage.append(sequenceNr, idStr, eventsJson)), result => {
+      let storageEffect = Effect$1.catchAll(Effect$1.map(Effect$1.retry(Effect$1.flatMap(Effect.tryPromise(err => ({
+        TAG: "StorageFailure",
+        _0: Util_Error$ReventlessCore.messageFromUnknown(err, "storage error")
+      }), () => Ops.storage.append(sequenceNr, idStr, eventsJson)), result => {
         if (result.TAG === "Ok") {
           return Effect$1.succeed();
         } else {
           return Effect$1.fail(result._0);
         }
-      }), storageRetrySchedule);
-      let exit = await Effect$1.runPromiseExit(storageEffect);
-      if (Exit$1.isSuccess(exit)) {
-        return await publishToEventTopic(id, events$p, eventsJson);
+      }), storageRetrySchedule), () => ({
+        TAG: "Ok",
+        _0: undefined
+      })), e => Effect$1.succeed({
+        TAG: "Error",
+        _0: e
+      }));
+      let match = await Effect$1.runPromise(storageEffect);
+      if (match.TAG === "Ok") {
+        return Stdlib_Result.mapError(await publishToEventTopic(id, events$p, eventsJson), msg => ({
+          TAG: "StorageFailure",
+          _0: msg
+        }));
       }
-      let failMsg = Exit.match(exit, cause => Cause.pretty(cause), () => "storage error");
-      if (failMsg.includes("conflict")) {
+      let msg = match._0;
+      if (typeof msg !== "object") {
         return {
           TAG: "Error",
-          _0: "conflict"
+          _0: "Conflict"
         };
       } else {
         return {
           TAG: "Error",
-          _0: `EventLog: Error: Couldn't append for ` + Spec.name + `(` + idStr + `): ` + failMsg
+          _0: {
+            TAG: "StorageFailure",
+            _0: `EventLog: Error: Couldn't append for ` + Spec.name + `(` + idStr + `): ` + msg._0
+          }
         };
       }
     };

package/src/components/ReadModel/ReadModel.res

@@ -19,6 +19,11 @@ module type T = {
     ~opts: Pulumi.ComponentResource.options=?,
   ) => component
   let sourceNames: array<string>
+  /** Bare event-variant names consumed across every projection mapping's source event
+      schema — names the actual events (so a DCB-log-sourced mapping is captured), unlike
+      `sourceNames` which only lists source aggregate / DCB-log names. Surfaced by
+      Plugin_Structure as `queryableDef.consumedEventTypes`. */
+  let consumedEventNames: array<string>
   let outputs: component => outputs
   let operations: component => Pulumi.Output.t<operations>
   let finish: unit => unit

package/src/components/ReadModel/ReadModel_Builder.res

@@ -25,6 +25,18 @@ module Make = (
     ->Belt.Set.String.fromArray
     ->Belt.Set.String.toArray
 
+  // Bare event-variant names consumed across every mapping's source event schema — the
+  // union the reflected graph turns into Event→ReadModel "projects" edges (see
+  // Plugin_Structure / DomainGraph). A DCB-log-sourced mapping declares a narrow event type
+  // (e.g. just `OrderPlaced`), so this captures cross-source events `sourceNames` can't name.
+  let consumedEventNames =
+    Mappings.mappings
+    ->Array.flatMap((module(Mapping: Mappings.Mapping)) =>
+      Reventless.DcbTag.extractVariantNames(Mapping.sourceEventSchema->S.castToUnknown)
+    )
+    ->Belt.Set.String.fromArray
+    ->Belt.Set.String.toArray
+
   type api = QueryDbStorage.api
   type role = QueryDbStorage.role
   type component = ReadModel.component

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

@@ -4,6 +4,7 @@ import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as ReadModel$ReventlessCore from "./ReadModel.res.mjs";
 import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
@@ -15,6 +16,7 @@ import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventC
 function Make(Spec) {
   return Mappings => (RuntimeEnvironment => (QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => {
     let sourceNames = Belt_SetString.toArray(Belt_SetString.fromArray(Mappings.mappings.map(Mapping => Mapping.sourceName)));
+    let consumedEventNames = Belt_SetString.toArray(Belt_SetString.fromArray(Mappings.mappings.flatMap(Mapping => DcbTag$Reventless.extractVariantNames(Mapping.sourceEventSchema))));
     let make = (api, apiRole, allEventTopics, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(ReadModel$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
       let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
       let opts = {
@@ -88,6 +90,7 @@ function Make(Spec) {
       EventCollectorRuntimeBuilder: EventCollectorRuntimeBuilder,
       make: make,
       sourceNames: sourceNames,
+      consumedEventNames: consumedEventNames,
       outputs: Component$ReventlessCore.outputs,
       operations: Component$ReventlessCore.operations,
       finish: finish

package/src/plugin/component/Plugin_Structure.res

@@ -390,12 +390,17 @@ let make = (
         ~entityName=R.Spec.name,
         stateSchema,
       )
+      // The events this read model projects from, qualified to the plugin's event ids so
+      // they match the producers' nodes in the graph. Was empty — which dropped projection
+      // edges for any event reaching the read model via a DCB-log-sourced mapping (a classic
+      // aggregate→view link is also drawn from the producer's linkedViews, deduped downstream).
+      let consumed = qualify(~prefix=name, R.consumedEventNames)
       ({
         Reventless.Plugin.name: R.Spec.name,
         queryField: qf.listFieldName,
         schema: stateSchema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
-        consumedEventTypes: [],
-        linkedWriteSide: [],
+        consumedEventTypes: consumed,
+        linkedWriteSide: linkedWriteSideFor(consumed),
         labelField,
         searchableFields,
         statusField: statusFieldFromStateSchema(stateSchema),
@@ -497,6 +502,7 @@ let make = (
       consumedEventTypes: qualify(~prefix=name, eventVariantNames(OTS.Spec.consumedEventSchema)),
       inboundCommandTypes: qualify(~prefix=name, commandVariantNames(OTS.Spec.inboundCommandSchema)),
       targetName: OTS.Spec.targetName,
+      externalSystem: OTS.Spec.externalSystem,
     }: Reventless.Plugin.outboundTranslationSliceDef))
 
   // ── Inbound translation slices ────────────────────────────────────────────
@@ -506,6 +512,7 @@ let make = (
       Reventless.Plugin.name: ITS.Spec.name,
       commandTypes: qualify(~prefix=name, commandVariantNames(ITS.Spec.commandSchema)),
       targetName: ITS.Spec.targetName,
+      externalSystem: ITS.Spec.externalSystem,
     }: Reventless.Plugin.inboundTranslationSliceDef))
 
   // ── Extensions ───────────────────────────────────────────────────────────

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

@@ -323,12 +323,13 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let qf = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(name, R.Spec.name, undefined);
     let stateSchema = R.Spec.stateSchema;
     let match = labelFieldsFromStateSchema(R.Spec.name, stateSchema);
+    let consumed = qualify(name, R.consumedEventNames);
     return {
       name: R.Spec.name,
       queryField: qf.listFieldName,
       schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
-      consumedEventTypes: [],
-      linkedWriteSide: [],
+      consumedEventTypes: consumed,
+      linkedWriteSide: linkedWriteSideFor(consumed),
       labelField: match[0],
       searchableFields: match[1],
       statusField: statusFieldFromStateSchema(stateSchema),
@@ -394,12 +395,14 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     name: OTS.Spec.name,
     consumedEventTypes: qualify(name, DcbTag$Reventless.extractVariantNames(OTS.Spec.consumedEventSchema)),
     inboundCommandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(OTS.Spec.inboundCommandSchema)),
-    targetName: OTS.Spec.targetName
+    targetName: OTS.Spec.targetName,
+    externalSystem: OTS.Spec.externalSystem
   }));
   let inboundTranslationSliceDefs = inboundTranslationSlices.map(ITS => ({
     name: ITS.Spec.name,
     commandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(ITS.Spec.commandSchema)),
-    targetName: ITS.Spec.targetName
+    targetName: ITS.Spec.targetName,
+    externalSystem: ITS.Spec.externalSystem
   }));
   let extensionDefs = extensions.map(E => {
     let delegateNames = E.mappings.map(M => M.delegateName);

package/src/plugin/component/SchemaWalker.res

@@ -38,7 +38,19 @@ let rec describeSchema = (schema: S.t<unknown>): string =>
     | _ => "unknown"
     }
     "array<" ++ itemDesc ++ ">"
-  | Object(_) => "object"
+  | Object({properties}) =>
+    // Recurse into nested records. Rendering every object as the literal
+    // "object" made the structural hash blind to nested field changes — a
+    // nested schema edit produced an identical SHA256, so drift detection
+    // silently missed it. Emit a sorted `{name:type,…}` description instead.
+    let inner =
+      properties
+      ->Dict.toArray
+      ->Array.filter(((name, _)) => name != "TAG")
+      ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+      ->Array.map(((name, s)) => name ++ ":" ++ describeSchema(s))
+      ->Array.join(",")
+    "{" ++ inner ++ "}"
   | _ => "unknown"
   }
 

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

@@ -23,7 +23,8 @@ function describeSchema(schema) {
       itemDesc = additionalItems === "strip" || additionalItems === "strict" ? "unknown" : describeSchema(additionalItems);
       return "array<" + itemDesc + ">";
     case "object" :
-      return "object";
+      let inner = Object.entries(schema.properties).filter(param => param[0] !== "TAG").toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => param[0] + ":" + describeSchema(param[1])).join(",");
+      return "{" + inner + "}";
     case "union" :
       let nonNull = schema.anyOf.filter(v => {
         switch (v.type) {
@@ -34,9 +35,9 @@ function describeSchema(schema) {
             return true;
         }
       });
-      let inner = nonNull[0];
-      if (inner !== undefined) {
-        return "option<" + describeSchema(inner) + ">";
+      let inner$1 = nonNull[0];
+      if (inner$1 !== undefined) {
+        return "option<" + describeSchema(inner$1) + ">";
       } else {
         return "unknown";
       }

package/src/util/CommandPublisher.res

@@ -63,7 +63,12 @@ module Make = (Spec: Spec, Config: Config) => {
           ~comp="CommandPublisher",
           `send: bufferSize: ${bufferSizeStr}, chunk: ${chunkCountStr}, size: ${sizeStr}`,
         )->Effect.runSync
-        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        // Take the first `size` commands and remove them from the buffer.
+        // (`toSpliced` is non-mutating and returns the *remainder*, so the buffer
+        // never drained: send() recursed on the same buffer and published the
+        // wrong slice. `slice` captures the chunk; `splice` drains it in place.)
+        let commandsToSend = buffer->Array.slice(~start=0, ~end=size)
+        buffer->Array.splice(~start=0, ~remove=size, ~insert=[])
         let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
         running := Some(promise)
         switch await promise {
@@ -82,7 +87,12 @@ module Make = (Spec: Spec, Config: Config) => {
     | SendAllInOneChunk =>
       let size = buffer->Array.length
       if size > 0 {
-        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        // Take the first `size` commands and remove them from the buffer.
+        // (`toSpliced` is non-mutating and returns the *remainder*, so the buffer
+        // never drained: send() recursed on the same buffer and published the
+        // wrong slice. `slice` captures the chunk; `splice` drains it in place.)
+        let commandsToSend = buffer->Array.slice(~start=0, ~end=size)
+        buffer->Array.splice(~start=0, ~remove=size, ~insert=[])
         let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
         running := Some(promise)
         switch await promise {
@@ -115,19 +125,19 @@ module Make = (Spec: Spec, Config: Config) => {
 
   let clear = () => {
     EffectLogger.logDebug(~comp="CommandPublisher", "clear")->Effect.runSync
-    let _ = buffer->Array.removeInPlace(0)
+    // Truncate the whole buffer. `removeInPlace(0)` is `splice(0, 1)` — it drops
+    // only the first element, so the rest leaked out on a later publish.
+    buffer->Array.splice(~start=0, ~remove=buffer->Array.length, ~insert=[])
     flush := false
   }
 
   let flush = async () => {
     EffectLogger.logDebug(~comp="CommandPublisher", "flush")->Effect.runSync
     flush := true
-    switch running.contents {
-    | None => await send()
-    | _ =>
-      while running.contents->Option.isNone {
-        await finishRunning()
-      }
-    }
+    // `send` already awaits any in-flight publish (finishRunning) before draining
+    // the buffer, and flush:=true forces a partial final chunk. The previous
+    // in-flight arm looped on `running.contents->Option.isNone` — dead, since this
+    // path only ran when running was Some — so buffered commands were never sent.
+    await send()
   }
 }