@reventlessdev/reventless-core 3.0.0-alpha.152 → 3.0.0-alpha.154

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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.154 (2026-07-11)
+
+### Bug Fixes
+
+* **plugin-lifecycle:** heal message decode of definitions persisted before a schema field existed ([6bb3e72](https://github.com/ReventlessDev/reventless-core/commit/6bb3e7259ad606a0f77fb670bcfc680256592003))
+### Features
+
+* **monitoring:** deploy-time Monitoring hook seam for provisioned execution units ([30f1c23](https://github.com/ReventlessDev/reventless-core/commit/30f1c23ba118805dae83af9115341f4aff6db92b))
+
+
+# 3.0.0-alpha.153 (2026-07-10)
+
+### Features
+
+* **plugin-structure:** capture per-component chapter grouping for the deployed graph ([f9c88a9](https://github.com/ReventlessDev/reventless-core/commit/f9c88a9a48d8c032ffe23f9e5277caf12c29e85c))
+* **plugin-structure:** carry translation-slice externalSystem into the deployed structure ([80c0cda](https://github.com/ReventlessDev/reventless-core/commit/80c0cda3b6d5fc6625d4b285f41505028f1dd06f))
+
+
 # 3.0.0-alpha.152 (2026-07-10)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.152",
+  "version": "3.0.0-alpha.154",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.93",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.71",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.24"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.95",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.73"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/Message.res

@@ -64,10 +64,16 @@ let toCommandSchema' = (idSchema, commandSchema) =>
     })
   )
 
+// Schema-migration-on-read: reuse the tolerant parse from `Reventless.Message`
+// (`parseJsonTolerant` / `fillMissingDefaults`, included above) so a message persisted
+// before a nested `@schema` field existed still decodes instead of bricking the
+// aggregate's log replay. These two entry points thread the memoized envelope schema;
+// `Reventless.Message.decode` (the other central decoder) is tolerant at the source.
+// See docs/plans/platform-infrastructure-in-plugin-list.md (durable fix option 2).
 let decodeEvent' = (json, idSchema, eventSchema) =>
-  json->S.parseJsonOrThrow(toEventSchema'(idSchema, eventSchema))
+  json->parseJsonTolerant(toEventSchema'(idSchema, eventSchema))
 let decodeCommand' = (json, idSchema, commandSchema) =>
-  json->S.parseJsonOrThrow(toCommandSchema'(idSchema, commandSchema))
+  json->parseJsonTolerant(toCommandSchema'(idSchema, commandSchema))
 
 let encodeEvent' = (event', idSchema, eventSchema) =>
   event'->S.reverseConvertToJsonOrThrow(toEventSchema'(idSchema, eventSchema))

package/src/Message.res.mjs

@@ -44,11 +44,11 @@ function toCommandSchema$p(idSchema, commandSchema) {
 }
 
 function decodeEvent$p(json, idSchema, eventSchema) {
-  return S.parseJsonOrThrow(json, toEventSchema$p(idSchema, eventSchema));
+  return Message$Reventless.parseJsonTolerant(json, toEventSchema$p(idSchema, eventSchema));
 }
 
 function decodeCommand$p(json, idSchema, commandSchema) {
-  return S.parseJsonOrThrow(json, toCommandSchema$p(idSchema, commandSchema));
+  return Message$Reventless.parseJsonTolerant(json, toCommandSchema$p(idSchema, commandSchema));
 }
 
 function encodeEvent$p(event$p, idSchema, eventSchema) {
@@ -384,6 +384,10 @@ let statusChangeSchema = Message$Reventless.statusChangeSchema;
 
 let commandJsonSchema = Message$Reventless.commandJsonSchema;
 
+let fillMissingDefaults = Message$Reventless.fillMissingDefaults;
+
+let parseJsonTolerant = Message$Reventless.parseJsonTolerant;
+
 let decode = Message$Reventless.decode;
 
 let encode = Message$Reventless.encode;
@@ -397,6 +401,8 @@ export {
   contextSchema,
   statusChangeSchema,
   commandJsonSchema,
+  fillMissingDefaults,
+  parseJsonTolerant,
   decode,
   encode,
   InvalidEvent,

package/src/adapter/Monitoring/Monitoring.res

@@ -0,0 +1,96 @@
+/**
+Deploy-time inventory hook: every runtime backend announces the execution units
+it provisions so an extension can attach provider-native monitoring to each.
+
+No-op by default. Zero behavioral change unless an extension registers a backend
+via `use` before the platform/plugin build. The seam fires once per unit at
+provisioning time (inside the deploy program) — never at invocation, and it runs
+no code in production. Monitoring/alerting itself is deliberately NOT a framework
+concern; this only exposes the choke point through which the framework says
+"I just provisioned an execution unit" and leaves what to do about it to the
+listener.
+
+See `docs/plans/monitoring-hook-seam.md`.
+*/
+
+/**
+The ROLE of a provisioned execution unit, not its mechanism. What "failure"
+means for a unit is provider-specific (a Lambda `Errors` metric vs. container
+restarts vs. NATS redeliveries) and belongs in the extension's per-provider
+`Backend`; core only says *that* a unit exists and *what role* it plays, which is
+what keeps the contract stable across runtimes. `Other(string)` is the escape
+hatch for support units and future roles (same pattern as the protocol's
+`OtherKind`).
+*/
+type unitKind =
+  | /** aggregates, state-change slices, extension points — failure = writes
+       rejected/dropped (the silent-freeze class) */
+  CommandHandler
+  | /** state-view slices, read models — failure = silently stale reads */
+  Projection
+  | /** automation slices, side-effect handlers, translations — failure = missed
+       side effects at boundaries */
+  Reactor
+  | /** cross-plugin/admin event ingestion — failure = event flow between plugins
+       stops */
+  EventCollector
+  | /** scheduled task runners */
+  Task
+  | /** heartbeat/keep-alive — failure = lifecycle detection AND any staleness
+       watchdog go blind (monitoring's own pulse) */
+  Scheduler
+  | /** receives messages that exhausted processing */
+  DeadLetterSink
+  | /** support units (counters, change-feed relays, migration runners, query
+       resolvers, …) — providers pass their name */
+  Other(string)
+
+/**
+A monitoring backend, registered by an extension (a deploy program) before the
+platform builds. `onProvisioned` is called once per execution unit.
+
+`~name` is the unit's STATIC logical name — the string the builder passed to its
+provisioning call. A Pulumi-based backend derives logical resource names from it
+(alarm/rule resource names must be stable and known at graph-construction time).
+`~component` is the deploy-time `Adapter.resource`; its fields are `Output`s
+(physical, suffix-bearing — right for a metric dimension like a CloudWatch
+FunctionName or a PrometheusRule deployment selector, but unusable as a logical
+resource name). Because `onProvisioned` fires during resource creation inside the
+deploy program, a Pulumi-based backend can create monitoring resources in the
+same stack, parented naturally.
+*/
+module type Backend = {
+  let onProvisioned: (
+    ~kind: unitKind,
+    ~name: string,
+    ~component: ReventlessInfra.Adapter.resource,
+  ) => unit
+}
+
+/** Default backend: does nothing. Active unless an extension calls `use`. */
+module Noop: Backend = {
+  let onProvisioned = (~kind as _, ~name as _, ~component as _) => ()
+}
+
+let backend: ref<module(Backend)> = ref(module(Noop: Backend))
+
+/**
+Register the monitoring backend. Must run before the platform/plugin build in the
+deploy program (plain statement order — the registry is consulted lazily at each
+provisioning site). Called once, by the extension, first.
+*/
+let use = (b: module(Backend)) => backend := b
+
+/**
+Announce a provisioned execution unit to the registered backend. Called by
+runtime backends at their provisioning sites (once per unit). No-op until an
+extension registers a backend.
+*/
+let notify = (
+  ~kind: unitKind,
+  ~name: string,
+  ~component: ReventlessInfra.Adapter.resource,
+) => {
+  module B = unpack(backend.contents)
+  B.onProvisioned(~kind, ~name, ~component)
+}

package/src/adapter/Monitoring/Monitoring.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function onProvisioned(param, param$1, param$2) {
+  
+}
+
+let Noop = {
+  onProvisioned: onProvisioned
+};
+
+let backend = {
+  contents: Noop
+};
+
+function use(b) {
+  backend.contents = b;
+}
+
+function notify(kind, name, component) {
+  let B = backend.contents;
+  B.onProvisioned(kind, name, component);
+}
+
+export {
+  Noop,
+  backend,
+  use,
+  notify,
+}
+/* No side effect */

package/src/admin/Platform_Admin_Structure.res

@@ -96,6 +96,7 @@ let pluginAggregate: writableDef = {
   linkedViews: ["Plugins"],
   consistencyRead: None,
   events: [],
+  chapter: None,
 }
 
 let pluginReadModel: queryableDef = {
@@ -110,6 +111,7 @@ let pluginReadModel: queryableDef = {
   searchableFields: ["name"],
   statusField: Some("status"),
   visibility: None,
+  chapter: None,
 }
 
 let structure: pluginStructure = {

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -110,7 +110,8 @@ let pluginAggregate = {
   consumedEventTypes: pluginAggregate_consumedEventTypes,
   linkedViews: pluginAggregate_linkedViews,
   consistencyRead: undefined,
-  events: pluginAggregate_events
+  events: pluginAggregate_events,
+  chapter: undefined
 };
 
 let pluginReadModel_queryField = Api_Naming$ReventlessCore.adminField("Plugins");
@@ -134,7 +135,8 @@ let pluginReadModel = {
   labelField: "name",
   searchableFields: pluginReadModel_searchableFields,
   statusField: pluginReadModel_statusField,
-  visibility: undefined
+  visibility: undefined,
+  chapter: undefined
 };
 
 let structure_readModels = [pluginReadModel];

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -72,6 +72,7 @@ let encodeQueryableDef = (r: queryableDef): JSON.t =>
     ("labelField", JSON.Encode.string(r.labelField)),
     ("searchableFields", encodeStrings(r.searchableFields)),
     ("statusField", r.statusField->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("chapter", r.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeEventDef = (e: eventDef): JSON.t =>
@@ -94,6 +95,7 @@ let encodeWritableDef = (w: writableDef): JSON.t =>
     ("consumedEventTypes", encodeStrings(w.consumedEventTypes)),
     // Phase 6.3: emitted-event field schemas (None → [] on the wire).
     ("events", w.events->Array.map(encodeEventDef)->JSON.Encode.array),
+    ("chapter", w.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeAutomationSliceDef = (a: automationSliceDef): JSON.t =>
@@ -101,6 +103,7 @@ let encodeAutomationSliceDef = (a: automationSliceDef): JSON.t =>
     ("name", JSON.Encode.string(a.name)),
     ("consumedEventTypes", encodeStrings(a.consumedEventTypes)),
     ("producedCommandTypes", encodeStrings(a.producedCommandTypes)),
+    ("chapter", a.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeOutboundTranslationSliceDef = (o: outboundTranslationSliceDef): JSON.t =>
@@ -108,12 +111,20 @@ let encodeOutboundTranslationSliceDef = (o: outboundTranslationSliceDef): JSON.t
     ("name", JSON.Encode.string(o.name)),
     ("consumedEventTypes", encodeStrings(o.consumedEventTypes)),
     ("inboundCommandTypes", encodeStrings(o.inboundCommandTypes)),
+    // Foreign system this slice publishes to — lets a deployed-graph consumer draw
+    // the external-system boundary box without workspace access. None → null.
+    ("externalSystem", o.externalSystem->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("chapter", o.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeInboundTranslationSliceDef = (i: inboundTranslationSliceDef): JSON.t =>
   Dict.fromArray([
     ("name", JSON.Encode.string(i.name)),
     ("commandTypes", encodeStrings(i.commandTypes)),
+    // Foreign system this slice receives from — lets a deployed-graph consumer draw
+    // the external-system boundary box without workspace access. None → null.
+    ("externalSystem", i.externalSystem->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("chapter", i.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeExtensionDef = (e: extensionDef): JSON.t =>

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -115,6 +115,10 @@ function encodeQueryableDef(r) {
     [
       "statusField",
       Stdlib_Option.mapOr(r.statusField, null, prim => prim)
+    ],
+    [
+      "chapter",
+      Stdlib_Option.mapOr(r.chapter, null, prim => prim)
     ]
   ]);
 }
@@ -165,6 +169,10 @@ function encodeWritableDef(w) {
     [
       "events",
       w.events.map(encodeEventDef)
+    ],
+    [
+      "chapter",
+      Stdlib_Option.mapOr(w.chapter, null, prim => prim)
     ]
   ]);
 }
@@ -182,6 +190,10 @@ function encodeAutomationSliceDef(a) {
     [
       "producedCommandTypes",
       a.producedCommandTypes.map(prim => prim)
+    ],
+    [
+      "chapter",
+      Stdlib_Option.mapOr(a.chapter, null, prim => prim)
     ]
   ]);
 }
@@ -199,6 +211,14 @@ function encodeOutboundTranslationSliceDef(o) {
     [
       "inboundCommandTypes",
       o.inboundCommandTypes.map(prim => prim)
+    ],
+    [
+      "externalSystem",
+      Stdlib_Option.mapOr(o.externalSystem, null, prim => prim)
+    ],
+    [
+      "chapter",
+      Stdlib_Option.mapOr(o.chapter, null, prim => prim)
     ]
   ]);
 }
@@ -212,6 +232,14 @@ function encodeInboundTranslationSliceDef(i) {
     [
       "commandTypes",
       i.commandTypes.map(prim => prim)
+    ],
+    [
+      "externalSystem",
+      Stdlib_Option.mapOr(i.externalSystem, null, prim => prim)
+    ],
+    [
+      "chapter",
+      Stdlib_Option.mapOr(i.chapter, null, prim => prim)
     ]
   ]);
 }

package/src/plugin/component/Plugin.res

@@ -46,6 +46,7 @@ module type T = {
     ~inboundTranslationSlices: array<module(ReventlessInfra.InboundTranslationSlice.T)>=?,
     ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=?,
     ~extensionPoints: array<module(ReventlessInfra.ExtensionPointMapping.Mapping)>=?,
+    ~componentChapters: dict<string>=?,
   ) => Reventless.Plugin.pluginStructure
 }
 

package/src/plugin/component/Plugin_Builder.res

@@ -368,6 +368,30 @@ module Make = (
       // so only aggregates, read models, and DCB slice names are included.
 
       let extractTypes = schema => Reventless.DcbTag.extractAllVariantNames(schema)
+
+      // Chapter (intra-plugin grouping band) per component name, mirrored from the
+      // static pluginStructure so the hook surface reaches parity with it. The
+      // structure is the single source — it was populated by the generator's
+      // componentChapters map at makePluginDefinition time.
+      let chapterByName: Dict.t<string> = Dict.make()
+      switch pluginStructure {
+      | Some(ps) =>
+        let put = (n, c) =>
+          switch c {
+          | Some(ch) => chapterByName->Dict.set(n, ch)
+          | None => ()
+          }
+        ps.aggregates->Array.forEach(d => put(d.name, d.chapter))
+        ps.readModels->Array.forEach(d => put(d.name, d.chapter))
+        ps.stateChangeSlices->Array.forEach(d => put(d.name, d.chapter))
+        ps.stateViewSlices->Array.forEach(d => put(d.name, d.chapter))
+        ps.automationSlices->Array.forEach(d => put(d.name, d.chapter))
+        ps.outboundTranslationSlices->Array.forEach(d => put(d.name, d.chapter))
+        ps.inboundTranslationSlices->Array.forEach(d => put(d.name, d.chapter))
+      | None => ()
+      }
+      let chapterFor = (n: string): option<string> => chapterByName->Dict.get(n)
+
       // Build per-component schema data and register it for the deployed hook.
       let aggregateComponents = aggregates->Array.map((
         module(M: ReventlessInfra.Aggregate.T with type api = api),
@@ -382,6 +406,7 @@ module Make = (
           eventSchemas: [
             SchemaWalker.walk(M.Spec.name ++ ".event", M.Spec.eventSchema),
           ],
+          chapter: ?chapterFor(M.Spec.name),
         }
         Plugin_Helpers.componentSchemaRegistry->Dict.set(M.Spec.name, schema)
         ({name: M.Spec.name, kind: "Aggregate", schema}: Plugin_Helpers.pluginBuiltComponent)
@@ -393,6 +418,7 @@ module Make = (
         let qn = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
         let schema: Plugin_Helpers.pluginDeployedSchema = {
           queryFields: [qn.singleFieldName, qn.listFieldName],
+          chapter: ?chapterFor(R.Spec.name),
         }
         Plugin_Helpers.componentSchemaRegistry->Dict.set(R.Spec.name, schema)
         ({name: R.Spec.name, kind: "ReadModel", schema}: Plugin_Helpers.pluginBuiltComponent)
@@ -421,6 +447,7 @@ module Make = (
             consumedEventTypes,
             producedCommandTypes: extractTypes(As.Spec.commandSchema),
             targetName: As.Spec.targetName,
+            chapter: ?chapterFor(As.Spec.name),
           },
         )
       })
@@ -434,6 +461,9 @@ module Make = (
             commandTypes: extractTypes(Ots.Spec.inboundCommandSchema),
             // Outbound slices may have no target (option); pass it through.
             targetName: ?Ots.Spec.targetName,
+            // Foreign system this slice publishes to (option); drives the external box.
+            externalSystem: ?Ots.Spec.externalSystem,
+            chapter: ?chapterFor(Ots.Spec.name),
           },
         )
       )
@@ -445,6 +475,9 @@ module Make = (
           {
             commandTypes: extractTypes(Its.Spec.commandSchema),
             targetName: Its.Spec.targetName,
+            // Foreign system this slice receives from (option); drives the external box.
+            externalSystem: ?Its.Spec.externalSystem,
+            chapter: ?chapterFor(Its.Spec.name),
           },
         )
       )
@@ -464,13 +497,17 @@ module Make = (
             commandTypes: extractTypes(Scs.Spec.commandSchema),
             eventTypes: extractEventTypes(Scs.Spec.eventSchema->S.castToUnknown),
             consumedEventTypes: extractEventTypes(Scs.Spec.consumedEventSchema->S.castToUnknown),
+            chapter: ?chapterFor(Scs.Spec.name),
           },
         )
       )
       stateViewSlices->Array.forEach((module(Svs: ReventlessInfra.StateViewSlice.T)) =>
         stateSchemas->Dict.set(
           Svs.Spec.name,
-          {consumedEventTypes: extractEventTypes(Svs.Spec.consumedEventSchema->S.castToUnknown)},
+          {
+            consumedEventTypes: extractEventTypes(Svs.Spec.consumedEventSchema->S.castToUnknown),
+            chapter: ?chapterFor(Svs.Spec.name),
+          },
         )
       )
 
@@ -993,6 +1030,7 @@ module Make = (
     ~inboundTranslationSlices: array<module(ReventlessInfra.InboundTranslationSlice.T)>=[],
     ~extensions: array<module(ReventlessInfra.Extension.Blueprint)>=[],
     ~extensionPoints: array<module(ReventlessInfra.ExtensionPointMapping.Mapping)>=[],
+    ~componentChapters: dict<string>=Dict.make(),
   ): Reventless.Plugin.pluginStructure =>
     Plugin_Structure.make(
       ~name,
@@ -1005,6 +1043,7 @@ module Make = (
       ~inboundTranslationSlices,
       ~extensions,
       ~extensionPoints,
+      ~componentChapters,
     )
 
   let make = (

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

@@ -89,7 +89,7 @@ function Make(Spec) {
         pages: pages
       };
     };
-    let makePluginDefinition = (name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt) => {
+    let makePluginDefinition = (name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) => {
       let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
       let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
       let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
@@ -99,7 +99,8 @@ function Make(Spec) {
       let inboundTranslationSlices = inboundTranslationSlicesOpt !== undefined ? inboundTranslationSlicesOpt : [];
       let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
       let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
-      return Plugin_Structure$ReventlessCore.make(name, aggregates, readModels, stateViewSlices, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints);
+      let componentChapters = componentChaptersOpt !== undefined ? componentChaptersOpt : ({});
+      return Plugin_Structure$ReventlessCore.make(name, aggregates, readModels, stateViewSlices, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints, componentChapters);
     };
     let make = (name, heartbeatInterval, extensionPointsOpt, extensionsOpt, aggregatesOpt, readModelsOpt, tasksOpt, stateChangeSlicesOpt, stateViewSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, systemCallableComponentsOpt, uiFragments, pluginStructure, opts) => {
       let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
@@ -264,18 +265,36 @@ function Make(Spec) {
           allQueryDbs[param[0] + "Todo"] = param[1].queryDb;
         });
         let queryEngine = QueryEngineAdapter.make(allQueryDbs);
+        let chapterByName = {};
+        if (pluginStructure !== undefined) {
+          let put = (n, c) => {
+            if (c !== undefined) {
+              chapterByName[n] = c;
+              return;
+            }
+          };
+          pluginStructure.aggregates.forEach(d => put(d.name, d.chapter));
+          pluginStructure.readModels.forEach(d => put(d.name, d.chapter));
+          pluginStructure.stateChangeSlices.forEach(d => put(d.name, d.chapter));
+          pluginStructure.stateViewSlices.forEach(d => put(d.name, d.chapter));
+          pluginStructure.automationSlices.forEach(d => put(d.name, d.chapter));
+          pluginStructure.outboundTranslationSlices.forEach(d => put(d.name, d.chapter));
+          pluginStructure.inboundTranslationSlices.forEach(d => put(d.name, d.chapter));
+        }
         let aggregateComponents = aggregates.map(M => {
           let schema_commandTypes = DcbTag$Reventless.extractAllVariantNames(M.Spec.commandSchema);
           let schema_eventTypes = DcbTag$Reventless.extractAllVariantNames(M.Spec.eventSchema);
           let schema_errorTypes = DcbTag$Reventless.extractAllVariantNames(M.Spec.errorSchema);
           let schema_commandSchemas = [SchemaWalker$ReventlessCore.walk(M.Spec.name + ".command", M.Spec.commandSchema)];
           let schema_eventSchemas = [SchemaWalker$ReventlessCore.walk(M.Spec.name + ".event", M.Spec.eventSchema)];
+          let schema_chapter = chapterByName[M.Spec.name];
           let schema = {
             commandTypes: schema_commandTypes,
             eventTypes: schema_eventTypes,
             errorTypes: schema_errorTypes,
             commandSchemas: schema_commandSchemas,
-            eventSchemas: schema_eventSchemas
+            eventSchemas: schema_eventSchemas,
+            chapter: schema_chapter
           };
           Plugin_Helpers$ReventlessCore.componentSchemaRegistry[M.Spec.name] = schema;
           return {
@@ -290,8 +309,10 @@ function Make(Spec) {
             qn.singleFieldName,
             qn.listFieldName
           ];
+          let schema_chapter = chapterByName[R.Spec.name];
           let schema = {
-            queryFields: schema_queryFields
+            queryFields: schema_queryFields,
+            chapter: schema_chapter
           };
           Plugin_Helpers$ReventlessCore.componentSchemaRegistry[R.Spec.name] = schema;
           return {
@@ -306,20 +327,25 @@ function Make(Spec) {
           routingSchemas[As.Spec.name] = {
             consumedEventTypes: consumedEventTypes,
             producedCommandTypes: DcbTag$Reventless.extractAllVariantNames(As.Spec.commandSchema),
-            targetName: As.Spec.targetName
+            targetName: As.Spec.targetName,
+            chapter: chapterByName[As.Spec.name]
           };
         });
         outboundTranslationSlices.forEach(Ots => {
           routingSchemas[Ots.Spec.name] = {
             commandTypes: DcbTag$Reventless.extractAllVariantNames(Ots.Spec.inboundCommandSchema),
             consumedEventTypes: DcbTag$Reventless.extractVariantNames(Ots.Spec.consumedEventSchema),
-            targetName: Ots.Spec.targetName
+            targetName: Ots.Spec.targetName,
+            externalSystem: Ots.Spec.externalSystem,
+            chapter: chapterByName[Ots.Spec.name]
           };
         });
         inboundTranslationSlices.forEach(Its => {
           routingSchemas[Its.Spec.name] = {
             commandTypes: DcbTag$Reventless.extractAllVariantNames(Its.Spec.commandSchema),
-            targetName: Its.Spec.targetName
+            targetName: Its.Spec.targetName,
+            externalSystem: Its.Spec.externalSystem,
+            chapter: chapterByName[Its.Spec.name]
           };
         });
         let stateSchemas = {};
@@ -327,12 +353,14 @@ function Make(Spec) {
           stateSchemas[Scs.Spec.name] = {
             commandTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.commandSchema),
             eventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.eventSchema),
-            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.consumedEventSchema)
+            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.consumedEventSchema),
+            chapter: chapterByName[Scs.Spec.name]
           };
         });
         stateViewSlices.forEach(Svs => {
           stateSchemas[Svs.Spec.name] = {
-            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Svs.Spec.consumedEventSchema)
+            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Svs.Spec.consumedEventSchema),
+            chapter: chapterByName[Svs.Spec.name]
           };
         });
         let enrichedComponents = (d, kind, schemas) => Object.keys(d).map(name => {

package/src/plugin/component/Plugin_BuiltHook.res

@@ -78,6 +78,12 @@ type pluginDeployedSchema = {
   /** For routing slices (automation / inbound + outbound translation): the name
    of the writable component this slice routes its commands to. */
   targetName?: string,
+  /** For inbound / outbound translation slices: the foreign system this slice
+   integrates with, mirrored from the static `pluginStructure` for hook parity.
+   Drives the deployed graph's external-system boundary box. Absent when the slice
+   names no external system. See the translation-slice defs on
+   `Reventless.Plugin.pluginStructure`. */
+  externalSystem?: string,
   sharedBy?: array<string>,
   extensionPointName?: string,
   providerPlugin?: string,
@@ -88,6 +94,11 @@ type pluginDeployedSchema = {
   eventSchemas?: array<typeSchema>,
   /** Field-level schema for the state type. */
   stateSchema?: typeSchema,
+  /** Intra-plugin grouping band (the "chapter") this component belongs to, mirrored
+   from the static `pluginStructure` for parity on the hook surface. Absent when the
+   component carries no chapter (lives directly under a kind-folder). See
+   `Reventless.Plugin.queryableDef.chapter`. */
+  chapter?: string,
 }
 
 // ---------------------------------------------------------------------------