@reventlessdev/reventless-core 3.0.0-alpha.300 → 3.0.0-alpha.302

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs

@@ -16,8 +16,8 @@ import * as StateChangeSlice_Callback$ReventlessCore from "./StateChangeSlice_Ca
 let log = Logger$ReventlessCore.fromEnv();
 
 function Make(Spec) {
-  return Behavior => {
-    let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Behavior);
+  return Decision => {
+    let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Decision);
     let makeJsonHandler = (tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLogOps) => (stream => {
       let decodedStream = Stream.flatMap(Stream.mapEffect(stream, param => {
         let reference = param.reference;
@@ -67,7 +67,7 @@ function Make(Spec) {
     };
     return {
       Spec: Spec,
-      Behavior: Behavior,
+      Decision: Decision,
       isAsync: false,
       make: make
     };

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -1,6 +1,6 @@
 module type T = {
   module Spec: Reventless.StateChangeSlice.Spec
-  module Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec
+  module Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec
   let handleCommands: (
     ~tagKeysByEventType: Dict.t<array<string>>=?,
     ~crossPartitionTagKeys: array<string>=?,
@@ -21,10 +21,10 @@ module type T = {
 
 module Make = (
   Spec: Reventless.StateChangeSlice.Spec,
-  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
-): (T with module Spec = Spec and module Behavior := Behavior) => {
+  Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec,
+): (T with module Spec = Spec and module Decision := Decision) => {
   module Spec = Spec
-  module Behavior = Behavior
+  module Decision = Decision
 
   let comp = `StateChangeSlice(${Spec.name})`
 
@@ -164,7 +164,7 @@ module Make = (
   // sees the event that recorded them.
   let projectionCache: Lru.t<
     string,
-    (Behavior.state, option<Reventless.DcbTag.sequencePosition>, array<string>),
+    (Decision.state, option<Reventless.DcbTag.sequencePosition>, array<string>),
   > = Lru.make(~capacity=projectionCacheCapacity)
 
   let resetCache = () => projectionCache->Lru.clear
@@ -174,7 +174,7 @@ module Make = (
   //      model — seeded from the projection cache when warm, so only events after
   //      the cached head are read (delta), else the full history (cold)
   //   2. Decodes raw events using consumedEventSchema
-  //   3. Calls Behavior.decide to produce new events
+  //   3. Calls Decision.decide to produce new events
   //   4. Encodes produced events to raw and appends with a condition
   //   5. On conflict, retries from step 1 (up to maxRetries)
   let handleSingleCommand = (
@@ -303,7 +303,7 @@ module Make = (
     let rec attempt = (~retries) => {
       let (baseState, afterPos, baseOwners) = switch seed.contents {
       | Some((state, head, owners)) => (state, head, owners)
-      | None => (Behavior.initialState, None, [])
+      | None => (Decision.initialState, None, [])
       }
       let cacheHit = seed.contents->Option.isSome
 
@@ -347,7 +347,7 @@ module Make = (
         (dm, _pos, reads, owners),
         (event, position, eventType, eventId, (ownerFields, data)),
       ) => (
-        Behavior.evolve(dm, event),
+        Decision.evolve(dm, event),
         Some(position),
         reads->Array.concat([
           switch eventId {
@@ -406,7 +406,7 @@ module Make = (
               isDefect ? EffectLogger.logError(~comp, line) : EffectLogger.logWarn(~comp, line)
             )->Effect.map(_ => Ok("rejected"))
           | None =>
-            switch Behavior.decide(state, command'.command) {
+            switch Decision.decide(state, command'.command) {
             | Ok(newEvents) if newEvents->Array.length == 0 =>
               // No append, but the read snapshot is valid — cache it for the next command.
               cachePut((state, headPosition, owners))

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -21,7 +21,7 @@ import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
 
 function Make(Spec) {
-  return Behavior => {
+  return Decision => {
     let comp = `StateChangeSlice(` + Spec.name + `)`;
     let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
     let queryEventTypes = decoder.eventTypes;
@@ -155,7 +155,7 @@ function Make(Spec) {
             match[1],
             match[2]
           ] : [
-            Behavior.initialState,
+            Decision.initialState,
             undefined,
             []
           ];
@@ -202,7 +202,7 @@ function Make(Spec) {
           let eventId = param$1[3];
           let eventType = param$1[2];
           return [
-            Behavior.evolve(param[0], param$1[0]),
+            Decision.evolve(param[0], param$1[0]),
             param$1[1],
             param[2].concat([eventId !== undefined ? LogFormat$ReventlessCore.bold(eventType) + `(` + eventId + `)` : LogFormat$ReventlessCore.bold(eventType)]),
             OwnerScope$Reventless.recordOwners(param[3], match[0], match[1])
@@ -237,7 +237,7 @@ function Make(Spec) {
                 _0: "rejected"
               }));
             }
-            let newEvents = Behavior.decide(state, command$p.command);
+            let newEvents = Decision.decide(state, command$p.command);
             if (newEvents.TAG === "Ok") {
               let newEvents$1 = newEvents._0;
               if (newEvents$1.length === 0) {

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -132,8 +132,8 @@ module Make = (
                     })->Array.map(
                       Reventless.Projection.mapActionId(
                         _,
-                        ~to_=Spec.Key.toString,
-                        ~from=Spec.Key.makeFromString,
+                        ~to_=Spec.Id.toString,
+                        ~from=Spec.Id.makeFromString,
                       ),
                     ) catch {
                     | exn =>

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

@@ -109,7 +109,7 @@ function Make(RuntimeEnvironment) {
                   event: Primitive_option.valFromOption(event),
                   meta: meta,
                   recordedAt: recordedAt
-                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
+                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Id.toString, Spec.Id.makeFromString));
               } catch (raw_exn) {
                 let exn$1 = Primitive_exceptions.internalToException(raw_exn);
                 let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -44,8 +44,8 @@ module Make = (
           Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})->Array.map(
             Reventless.Projection.mapActionId(
               _,
-              ~to_=Spec.Key.toString,
-              ~from=Spec.Key.makeFromString,
+              ~to_=Spec.Id.toString,
+              ~from=Spec.Id.makeFromString,
             ),
           )
         let actionsStr = LogFormat.actionNames(actions)

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

@@ -33,7 +33,7 @@ function Make(Spec) {
           event: event,
           meta: raw.meta,
           recordedAt: raw.recordedAt
-        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
+        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Id.toString, Spec.Id.makeFromString));
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
         allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));

package/src/components/Task/Task_Adapter.res

@@ -24,7 +24,7 @@ module type Bucket = {
   type bucketParts
 
   let connect: connect<bucketParts, runtimeParts>
-  let makeHandler: Task.bucketCallback => Runtime.eventHandler<
+  let makeHandler: Task.bucketCallback => Runtime.invocationHandler<
     callbackEvent,
     context,
     array<Task.taskAction>,

package/src/components/Task/Task_Builder.res

@@ -97,7 +97,7 @@ module Make = (
 ): Task.T => {
   module Spec = Spec
   type component = Task.component
-  // type handler = Runtime.eventHandler<
+  // type handler = Runtime.invocationHandler<
   //   TaskRuntimeBuilder.callbackEvent,
   //   TaskRuntimeBuilder.context,
   //   array<Task.taskAction>,

package/src/plugin/component/Plugin_Builder.res

@@ -1050,31 +1050,31 @@ module Make = (
     ~aggregatePositions: array<string>=[],
   ): Reventless.Plugin.uiFragmentManifest => {
     // Internal queryable components are hidden from the AutoUI manifest. They
-    // remain fully wired (resolvers, GraphQL schema, queryable defs,
+    // remain fully wired (resolvers, GraphQL schema, read-side defs,
     // authorization) — visibility is a UX hint, not a security boundary. See
     // docs/plans/done/component-visibility-annotations.md
-    let isVisibleQueryable = (q: Reventless.Plugin.queryableDef) =>
+    let isVisibleReadSide = (q: Reventless.Plugin.readSideDef) =>
       switch q.visibility {
       | Some("Internal") => false
       | _ => true
       }
-    let visibleReadModels = pluginStructure.readModels->Array.filter(isVisibleQueryable)
-    let visibleStateViewSlices = pluginStructure.stateViewSlices->Array.filter(isVisibleQueryable)
-    let listPanel = (q: Reventless.Plugin.queryableDef): Reventless.Plugin.panelManifestEntry => {
+    let visibleReadModels = pluginStructure.readModels->Array.filter(isVisibleReadSide)
+    let visibleStateViewSlices = pluginStructure.stateViewSlices->Array.filter(isVisibleReadSide)
+    let listPanel = (q: Reventless.Plugin.readSideDef): Reventless.Plugin.panelManifestEntry => {
       fragmentId: name ++ "." ++ q.name ++ ".list",
       title: q.name,
       description: "",
       positions: readModelPositions,
       requiredAccess: None,
     }
-    let detailPanel = (w: Reventless.Plugin.writableDef): Reventless.Plugin.panelManifestEntry => {
+    let detailPanel = (w: Reventless.Plugin.writeSideDef): Reventless.Plugin.panelManifestEntry => {
       fragmentId: name ++ "." ++ w.name ++ ".detail",
       title: w.name,
       description: "",
       positions: aggregatePositions,
       requiredAccess: None,
     }
-    let listPage = (q: Reventless.Plugin.queryableDef): Reventless.Plugin.pageManifestEntry => {
+    let listPage = (q: Reventless.Plugin.readSideDef): Reventless.Plugin.pageManifestEntry => {
       fragmentId: name ++ "." ++ q.name ++ ".list",
       title: q.name,
       menuEntry: {label: q.name, icon: None, group: None, sortOrder: 0},

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

@@ -47,7 +47,7 @@ function Make(Spec) {
     let makeAutoUIManifest = (remoteEntryUrl, name, pluginStructure, readModelPositionsOpt, aggregatePositionsOpt) => {
       let readModelPositions = readModelPositionsOpt !== undefined ? readModelPositionsOpt : [];
       let aggregatePositions = aggregatePositionsOpt !== undefined ? aggregatePositionsOpt : [];
-      let isVisibleQueryable = q => {
+      let isVisibleReadSide = q => {
         let match = q.visibility;
         if (match !== undefined) {
           return match !== "Internal";
@@ -55,8 +55,8 @@ function Make(Spec) {
           return true;
         }
       };
-      let visibleReadModels = pluginStructure.readModels.filter(isVisibleQueryable);
-      let visibleStateViewSlices = pluginStructure.stateViewSlices.filter(isVisibleQueryable);
+      let visibleReadModels = pluginStructure.readModels.filter(isVisibleReadSide);
+      let visibleStateViewSlices = pluginStructure.stateViewSlices.filter(isVisibleReadSide);
       let listPanel = q => ({
         fragmentId: name + "." + q.name + ".list",
         title: q.name,

package/src/plugin/component/Plugin_BuiltHook.res

@@ -97,7 +97,7 @@ type pluginDeployedSchema = {
   /** 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`. */
+   `Reventless.Plugin.readSideDef.chapter`. */
   chapter?: string,
 }
 

package/src/plugin/component/Plugin_Structure.res

@@ -74,7 +74,7 @@ type retiredCheck =
 // says whether that name is a case of the field's enum). A name the enum does not
 // declare is a failure — the predicate then matches no row and every row stays
 // visible. A `value` on a field that is not the lifecycle is only a warning: a
-// modelling judgement rather than a wrong name.
+// modeling judgement rather than a wrong name.
 let checkRetiredValue = (~entityName: string, stateSchema: S.t<unknown>): retiredCheck =>
   switch retiredFromStateSchema(stateSchema) {
   // The boolean form names no state, so there is nothing to compare. Not a skip.
@@ -392,13 +392,13 @@ let extensionPartitionFailure = (
 // forces a spec to pick its linked view's enum.
 let checkDeclaredTransitions = (
   ~pluginName: string,
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): unit => {
   let unvalidated = ref(0)
   let failures = []
 
-  writables->Array.forEach(w =>
+  writeSides->Array.forEach(w =>
     w.commands->Array.forEach(cmd => {
       let declared = Array.concat(
         cmd.allowedStates->Option.getOr([]),
@@ -469,7 +469,7 @@ let checkDeclaredTransitions = (
 // and one that stops a deploy gets silenced rather than fixed. Pure, so the rule
 // tests without a log; `checkLifecycleTopology` reports.
 let lifecycleTopologyFindings = (
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): array<(string, string)> => {
   let findings = []
@@ -479,7 +479,7 @@ let lifecycleTopologyFindings = (
     // Arrival only, so a creating command (a target and no from-set) counts
     // towards reachability like any other edge.
     let reachable =
-      writables->Array.reduce([], (acc, w) =>
+      writeSides->Array.reduce([], (acc, w) =>
         w.linkedViews->Array.includes(view)
           ? Array.concat(acc, w.commands->Array.filterMap(cmd => cmd.targetState))
           : acc
@@ -508,10 +508,10 @@ let lifecycleTopologyFindings = (
 
 let checkLifecycleTopology = (
   ~pluginName: string,
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): unit =>
-  lifecycleTopologyFindings(~writables, ~lifecycleStatesByView)->Array.forEach(((view, message)) =>
+  lifecycleTopologyFindings(~writeSides, ~lifecycleStatesByView)->Array.forEach(((view, message)) =>
     log.warn(~comp="Plugin_Structure", `${pluginName}/${view}: ${message}`)
   )
 
@@ -1074,12 +1074,12 @@ let visibilityTag = (v: Reventless.Visibility.t): option<string> =>
   }
 
 /**
- A read model's `queryableDef` assembled from its spec, for the platform's own
+ A read model's `readSideDef` assembled from its spec, for the platform's own
  components: `make` takes `module(ReadModel.T)` values, and at structure-assembly
  time the platform has no built module to hand itself. Every extractor here is the
  one `make` calls, so the two cannot drift — a hand-written record did, four times.
  */
-let queryableDefFromSpec = (
+let readSideDefFromSpec = (
   ~plugin: string,
   ~name: string,
   ~stateSchema: S.t<unknown>,
@@ -1088,7 +1088,7 @@ let queryableDefFromSpec = (
   ~consumedEventTypes: array<string>=[],
   ~linkedWriteSide: array<string>=[],
   ~chapter: option<string>=?,
-): Reventless.Plugin.queryableDef => {
+): Reventless.Plugin.readSideDef => {
   let qf = Api_Naming.queryFieldNamesForReadModel(~plugin, ~name)
   let label = labelFieldsFromStateSchema(~entityName=name, stateSchema)
   // The published key is always filterable; not every filterable field is the key.
@@ -1498,9 +1498,9 @@ let make = (
     )
   )
 
-  // ── Build queryable defs ───────────────────────────────────────────────────
+  // ── Build read-side defs ───────────────────────────────────────────────────
   //
-  // Internal views are carried here, tagged via `queryableDef.visibility`, so
+  // Internal views are carried here, tagged via `readSideDef.visibility`, so
   // developer tools see them; AutoUI's consumers re-filter on the tag.
   // View name -> the states its lifecycle field can hold, collected as the view
   // defs are built so the transition check below has both sides in one place.
@@ -1576,7 +1576,7 @@ let make = (
         idFieldSource: keyField->Option.map(((_, rung)) => rung),
         requiredAccess: accessKeysFor(R.Spec.authorization->Reventless.Authorization.named),
         requiredRoles: ?rolesFor(R.Spec.authorization->Reventless.Authorization.named),
-      }: Reventless.Plugin.queryableDef
+      }: Reventless.Plugin.readSideDef
     )
   })
 
@@ -1617,11 +1617,11 @@ let make = (
           idFieldSource: keyField->Option.map(((_, rung)) => rung),
           requiredAccess: accessKeysFor(SVS.Spec.authorization->Reventless.Authorization.named),
           requiredRoles: ?rolesFor(SVS.Spec.authorization->Reventless.Authorization.named),
-        }: Reventless.Plugin.queryableDef
+        }: Reventless.Plugin.readSideDef
       )
     })
 
-  // ── Build writable defs ────────────────────────────────────────────────────
+  // ── Build write-side defs ──────────────────────────────────────────────────
 
   // Non-throwing: this is a description of the plugin, and the builder is what
   // refuses a boundary whose partitions do not resolve.
@@ -1728,7 +1728,7 @@ let make = (
           events: extractEventDefs(~identityViews, SCS.Spec.eventSchema->S.castToUnknown),
           errors: extractErrorDefs(SCS.Spec.errorSchema->S.castToUnknown),
           chapter: chapterOf(SCS.Spec.name),
-        }: Reventless.Plugin.writableDef
+        }: Reventless.Plugin.writeSideDef
       )
     })
 
@@ -1762,7 +1762,7 @@ let make = (
         events: extractEventDefs(~identityViews, A.Spec.eventSchema->S.castToUnknown),
         errors: extractErrorDefs(A.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(A.Spec.name),
-      }: Reventless.Plugin.writableDef
+      }: Reventless.Plugin.writeSideDef
     )
   })
 
@@ -2258,12 +2258,12 @@ let make = (
   // assembled, so the check cannot run inline where the defs are made.
   checkDeclaredTransitions(
     ~pluginName=name,
-    ~writables=Array.concat(stateChangeDefs, aggregateDefs),
+    ~writeSides=Array.concat(stateChangeDefs, aggregateDefs),
     ~lifecycleStatesByView,
   )
   checkLifecycleTopology(
     ~pluginName=name,
-    ~writables=Array.concat(stateChangeDefs, aggregateDefs),
+    ~writeSides=Array.concat(stateChangeDefs, aggregateDefs),
     ~lifecycleStatesByView,
   )
   // Also a second pass, for a different reason: the failures are gathered per

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

@@ -318,12 +318,12 @@ function extensionPartitionFailure(label, delegate, expected, actual) {
   return label + `: the extension ` + seen + `, but the plugin partitions ` + delegate + ` by ` + describePartition(expected) + `. An extension sees only the slice's command and events, not what it reads or its chapter — ` + (`add @partitionTag ` + describePartition(expected) + ` to ` + delegate + `'s event.`);
 }
 
-function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView) {
+function checkDeclaredTransitions(pluginName, writeSides, lifecycleStatesByView) {
   let unvalidated = {
     contents: 0
   };
   let failures = [];
-  writables.forEach(w => {
+  writeSides.forEach(w => {
     w.commands.forEach(cmd => {
       let t = cmd.targetState;
       let declared = Stdlib_Option.getOr(cmd.allowedStates, []).concat(t !== undefined ? [t] : []);
@@ -357,12 +357,12 @@ function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView)
   }
 }
 
-function lifecycleTopologyFindings(writables, lifecycleStatesByView) {
+function lifecycleTopologyFindings(writeSides, lifecycleStatesByView) {
   let findings = [];
   Object.entries(lifecycleStatesByView).forEach(param => {
     let states = param[1];
     let view = param[0];
-    let reachable = Stdlib_Array.reduce(writables, [], (acc, w) => {
+    let reachable = Stdlib_Array.reduce(writeSides, [], (acc, w) => {
       if (w.linkedViews.includes(view)) {
         return acc.concat(Stdlib_Array.filterMap(w.commands, cmd => cmd.targetState));
       } else {
@@ -386,8 +386,8 @@ function lifecycleTopologyFindings(writables, lifecycleStatesByView) {
   return findings;
 }
 
-function checkLifecycleTopology(pluginName, writables, lifecycleStatesByView) {
-  lifecycleTopologyFindings(writables, lifecycleStatesByView).forEach(param => log.warn("Plugin_Structure", undefined, pluginName + `/` + param[0] + `: ` + param[1]));
+function checkLifecycleTopology(pluginName, writeSides, lifecycleStatesByView) {
+  lifecycleTopologyFindings(writeSides, lifecycleStatesByView).forEach(param => log.warn("Plugin_Structure", undefined, pluginName + `/` + param[0] + `: ` + param[1]));
 }
 
 function labelFieldSourceToString(s) {
@@ -772,7 +772,7 @@ function visibilityTag(v) {
   }
 }
 
-function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibilityOpt, consumedEventTypesOpt, linkedWriteSideOpt, chapter) {
+function readSideDefFromSpec(plugin, name, stateSchema, authorization, visibilityOpt, consumedEventTypesOpt, linkedWriteSideOpt, chapter) {
   let visibility = visibilityOpt !== undefined ? visibilityOpt : "Public";
   let consumedEventTypes = consumedEventTypesOpt !== undefined ? consumedEventTypesOpt : [];
   let linkedWriteSide = linkedWriteSideOpt !== undefined ? linkedWriteSideOpt : [];
@@ -1591,7 +1591,7 @@ export {
   toCommandDef,
   extractCommandDefs,
   visibilityTag,
-  queryableDefFromSpec,
+  readSideDefFromSpec,
   make,
 }
 /* log Not a pure module */

package/src/plugin/lifecycle/{PluginBehavior.res → PluginDecision.res}

@@ -1,4 +1,4 @@
-@@reventless.behavior(PluginSpec)
+@@reventless.decision(PluginSpec)
 
 open Reventless.Plugin
 
@@ -30,9 +30,9 @@ type state = {
 
 let initialState = {current: None, known: Dict.make()}
 
-// The @@reventless.behavior snapshot injection is gated to Aggregate/ folders;
-// this framework-internal behavior lives under plugin/lifecycle, so the
-// Behavior.T field is satisfied manually. The admin Plugin aggregate's history
+// The @@reventless.decision snapshot injection is gated to Aggregate/ folders;
+// this framework-internal decision lives under plugin/lifecycle, so the
+// Decision.T field is satisfied manually. The admin Plugin aggregate's history
 // is short (lifecycle transitions), so persisted snapshots would buy nothing.
 let snapshot = None
 

package/src/plugin/lifecycle/{PluginBehavior.res.mjs → PluginDecision.res.mjs}

@@ -382,7 +382,7 @@ let snapshot;
 
 let atomicCounter;
 
-let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginDecision.res.mjs";
 
 export {
   Spec,

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -80,7 +80,7 @@ let cmd: commandDef = {
 let evt: eventDef = {name: "ProductAdded", schema: "{}", references: [fieldRef]}
 let err: errorDef = {name: "ProductAlreadyExists", schema: "{}", references: []}
 
-let writable: writableDef = {
+let writeSide: writeSideDef = {
   name: "Product",
   commands: [cmd],
   producedEventTypes: ["ProductAdded"],
@@ -92,7 +92,7 @@ let writable: writableDef = {
   chapter: Some("Catalogue"),
 }
 
-let queryable: queryableDef = {
+let readSide: readSideDef = {
   name: "Products",
   queryField: "Catalog_Products",
   schema: "{}",
@@ -174,10 +174,10 @@ let capabilityDecl: requiredCapabilityDeclaration = {
 }
 
 let structure: pluginStructure = {
-  readModels: [queryable],
+  readModels: [readSide],
   stateViewSlices: [],
   stateChangeSlices: [],
-  aggregates: [writable],
+  aggregates: [writeSide],
   automationSlices: [automation],
   outboundTranslationSlices: [outbound],
   inboundTranslationSlices: [inbound],
@@ -278,16 +278,16 @@ let guards: array<guard> = [
   {
     gqlType: "Platform_WriteSideDef",
     sdlTypes: componentSdl,
-    recordFields: schemaKeys(writableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeWritableDef(writable)),
+    recordFields: schemaKeys(writeSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeWriteSideDef(writeSide)),
     wireOnly: [],
     recordOnly: [],
   },
   {
     gqlType: "Platform_ReadSideDef",
     sdlTypes: componentSdl,
-    recordFields: schemaKeys(queryableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeQueryableDef(queryable)),
+    recordFields: schemaKeys(readSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeReadSideDef(readSide)),
     wireOnly: [],
     // The roles behind `requiredAccess`, read by the deploy check in-process.
     // A client gates on the mapped groups and has no use for role names.