@reventlessdev/reventless-core 3.0.0-alpha.189 → 3.0.0-alpha.191

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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.191 (2026-07-29)
+
+### Bug Fixes
+
+* **plugin:** the field a read model is named by ([c679bb9](https://github.com/ReventlessDev/reventless-core/commit/c679bb9f610be9947417174bc3dfceea38207ba0))
+### Features
+
+* **plugin:** why a read model is named by that field ([699ef8e](https://github.com/ReventlessDev/reventless-core/commit/699ef8e72f1b1d82fb04672739e5e4a8db61ae9a))
+
+
+# 3.0.0-alpha.190 (2026-07-28)
+
+### Features
+
+* **platform:** provision object stores from the fields that declare them ([b5e2a1e](https://github.com/ReventlessDev/reventless-core/commit/b5e2a1ec88099941c113e4963f9c4b346b96b0d6))
+
+
 # 3.0.0-alpha.189 (2026-07-28)
 
 **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.189",
+  "version": "3.0.0-alpha.191",
   "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.31",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.107",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.109",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.82"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.84"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res

@@ -252,7 +252,7 @@ module Make = (
       // pushed SDL — CreateResolver then loops on
       // `NotFoundException: No field named ...`.
       let registryKey = entry.specName->Option.getOr(entityName)
-      let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+      let label: Plugin_Structure.labelResolution = Plugin_Structure.labelFieldsFromStateSchema(
         ~entityName,
         entry.stateSchema,
       )
@@ -263,7 +263,7 @@ module Make = (
         pluralTypeName: entry.listFieldName,
         includeIdParam: entry.includeIdParam->Option.getOr(true),
         connectionSpec: entry.connectionSpec->Option.getOr(true),
-        labelField,
+        labelField: label.field,
         connectionFilterTypeName: entry.returnTypeName ++ "Filter",
       }
       Plugin_Helpers.queryFieldNamesRegistry->Dict.set(registryKey, qn)

package/src/admin/Platform_Admin.res.mjs

@@ -110,13 +110,13 @@ function Make(RuntimeEnvironment) {
         let prefix = "Platform_";
         let entityName = entry.returnTypeName.startsWith(prefix) ? entry.returnTypeName.slice(prefix.length, entry.returnTypeName.length) : entry.returnTypeName;
         let registryKey = Stdlib_Option.getOr(entry.specName, entityName);
-        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, entry.stateSchema);
+        let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(entityName, entry.stateSchema);
         let qn_singleFieldName = entry.singleFieldName;
         let qn_listFieldName = entry.listFieldName;
         let qn_returnTypeName = entry.returnTypeName;
         let qn_pluralTypeName = entry.listFieldName;
         let qn_connectionFilterTypeName = entry.returnTypeName + "Filter";
-        let qn_labelField = match[0];
+        let qn_labelField = label.field;
         let qn_includeIdParam = Stdlib_Option.getOr(entry.includeIdParam, true);
         let qn_connectionSpec = Stdlib_Option.getOr(entry.connectionSpec, true);
         let qn = {

package/src/admin/Platform_Admin_Structure.res

@@ -111,6 +111,9 @@ let pluginReadModel: queryableDef = {
   linkedWriteSide: ["Plugin"],
   labelField: "name",
   searchableFields: ["name"],
+  // Hand-rolled rather than resolved, but the rung is the same one
+  // `labelFieldsFromStateSchema` would report for a field literally named `name`.
+  labelFieldSource: Some("convention"),
   statusField: Some("status"),
   visibility: None,
   chapter: None,
@@ -126,4 +129,5 @@ let structure: pluginStructure = {
   inboundTranslationSlices: [],
   extensions: [],
   extensionPoints: None,
+  requiredStores: None,
 }

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -126,6 +126,8 @@ let pluginReadModel_linkedWriteSide = ["Plugin"];
 
 let pluginReadModel_searchableFields = ["name"];
 
+let pluginReadModel_labelFieldSource = "convention";
+
 let pluginReadModel_statusField = "status";
 
 let pluginReadModel = {
@@ -136,6 +138,7 @@ let pluginReadModel = {
   linkedWriteSide: pluginReadModel_linkedWriteSide,
   labelField: "name",
   searchableFields: pluginReadModel_searchableFields,
+  labelFieldSource: pluginReadModel_labelFieldSource,
   statusField: pluginReadModel_statusField,
   visibility: undefined,
   chapter: undefined
@@ -166,7 +169,8 @@ let structure = {
   outboundTranslationSlices: structure_outboundTranslationSlices,
   inboundTranslationSlices: structure_inboundTranslationSlices,
   extensions: structure_extensions,
-  extensionPoints: undefined
+  extensionPoints: undefined,
+  requiredStores: undefined
 };
 
 let pluginName = pluginId;

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -11,7 +11,7 @@ let sdlTypes: array<string> = [
   `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  statusField: String\n}`,
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n}`,
@@ -72,6 +72,10 @@ let encodeQueryableDef = (r: queryableDef): JSON.t =>
     ("linkedWriteSide", encodeStrings(r.linkedWriteSide)),
     ("labelField", JSON.Encode.string(r.labelField)),
     ("searchableFields", encodeStrings(r.searchableFields)),
+    (
+      "labelFieldSource",
+      r.labelFieldSource->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+    ),
     ("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

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -9,7 +9,7 @@ let sdlTypes = [
   `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  statusField: String\n}`,
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n}`,
@@ -116,6 +116,10 @@ function encodeQueryableDef(r) {
       "searchableFields",
       r.searchableFields.map(prim => prim)
     ],
+    [
+      "labelFieldSource",
+      Stdlib_Option.mapOr(r.labelFieldSource, null, prim => prim)
+    ],
     [
       "statusField",
       Stdlib_Option.mapOr(r.statusField, null, prim => prim)

package/src/components/Dcb/Dcb_Builder.res

@@ -526,13 +526,13 @@ module Make = (
           module(V: StateViewSlice.T),
         ) => {
           let qn = Api_Naming.queryFieldNamesForStateView(~plugin=name, ~viewName=V.Spec.name)
-          let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+          let label = Plugin_Structure.labelFieldsFromStateSchema(
             ~entityName=V.Spec.name,
             V.Spec.stateSchema->S.castToUnknown,
           )
           let qn = {
             ...qn,
-            labelField,
+            labelField: label.field,
             connectionFilterTypeName: qn.returnTypeName ++ "Filter",
           }
           let qn = switch V.Spec.subIdConfig {

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

@@ -276,13 +276,13 @@ function Make(DcbEventLogStorage) {
       }
       stateViewSlices.forEach(V => {
         let qn = Api_Naming$ReventlessCore.queryFieldNamesForStateView(name, V.Spec.name, undefined);
-        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(V.Spec.name, V.Spec.stateSchema);
+        let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(V.Spec.name, V.Spec.stateSchema);
         let newrecord = {...qn};
-        newrecord.labelField = match[0];
+        newrecord.labelField = label.field;
         newrecord.connectionFilterTypeName = qn.returnTypeName + "Filter";
-        let match$1 = V.Spec.subIdConfig;
+        let match = V.Spec.subIdConfig;
         let qn$1;
-        if (match$1 !== undefined) {
+        if (match !== undefined) {
           let newrecord$1 = {...newrecord};
           newrecord$1.itemsFilterTypeName = newrecord.returnTypeName + "ItemsFilter";
           newrecord$1.itemsFieldName = newrecord.singleFieldName + "Items";

package/src/plugin/component/Plugin_Builder.res

@@ -267,13 +267,13 @@ module Make = (
       module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
     ) => {
       let qn = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
-      let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+      let label = Plugin_Structure.labelFieldsFromStateSchema(
         ~entityName=R.Spec.name,
         R.Spec.stateSchema->S.castToUnknown,
       )
       let qn = {
         ...qn,
-        labelField,
+        labelField: label.field,
         connectionFilterTypeName: qn.returnTypeName ++ "Filter",
       }
       let qn = switch R.Spec.subIdConfig {

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

@@ -208,13 +208,13 @@ function Make(Spec) {
         let eventLogEntries = eventLogEntriesFromAggregates.concat(dcbResult.eventLogEntries);
         readModels.forEach(R => {
           let qn = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(extra$1, R.Spec.name, undefined);
-          let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(R.Spec.name, R.Spec.stateSchema);
+          let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(R.Spec.name, R.Spec.stateSchema);
           let newrecord = {...qn};
-          newrecord.labelField = match[0];
+          newrecord.labelField = label.field;
           newrecord.connectionFilterTypeName = qn.returnTypeName + "Filter";
-          let match$1 = R.Spec.subIdConfig;
+          let match = R.Spec.subIdConfig;
           let qn$1;
-          if (match$1 !== undefined) {
+          if (match !== undefined) {
             let newrecord$1 = {...newrecord};
             newrecord$1.itemsFilterTypeName = newrecord.returnTypeName + "ItemsFilter";
             newrecord$1.itemsFieldName = newrecord.singleFieldName + "Items";

package/src/plugin/component/Plugin_Structure.res

@@ -5,26 +5,53 @@
 
 let log = Logger.fromEnv()
 
-// Returns (labelField, searchableFields) from a state schema.
-// Source ladder:
-//   1. @displayName spec present → "displayName" + spec.fields (raw underlying fields)
-//   2. First non-id, non-`*Id`/`*Ids`, non-TAG, string-typed field in declaration order
-//   3. "id" fallback with a logged warning (no searchable fields)
-//
-// `*Id` / `*Ids` fields (e.g. `productId`, `customerId`, `orderIds`) are entity
-// references, not human-readable labels — skipping them lets a sibling like
-// `name` win even when it appears later in declaration order.
-let isIdLikeFieldName = (name: string): bool =>
-  name == "id" || name->String.endsWith("Id") || name->String.endsWith("Ids")
-
-// Resolve the field that holds the entity's lifecycle status, used by
-// AutoUI to filter the per-row command menu against each command's
-// `allowedStates`. Resolution order:
+// What a field *is* is `SchemaType`'s question, and it is the IR every other
+// schema consumer here reads. The two predicates below are the only two answers
+// this module needs; both are stated over the IR rather than over sury shapes,
+// so a field that is a date, a reference or an enum is one for the label picker
+// too.
+
+// Whether a field can name a record. `Nullable` unwraps — an optional name is
+// still the entity's name, absent on some rows, which is a rendering question
+// rather than a declaration one. A `Semantic` wrapper is refused: it is the
+// schema saying the string means something other than prose (a storage ref, a
+// URL), and a bucket key is not a name. `DateTime`, `EntityId`, `Enum` and every
+// composite shape fall out of the catch-all without being named — which is the
+// point of reading an IR rather than restating it: the next shape it grows is
+// excluded before it exists.
+let rec isLabelShape = (t: SchemaType.schemaType): bool =>
+  switch t {
+  | ScalarString => true
+  | Nullable(inner) => isLabelShape(inner)
+  | _ => false
+  }
+
+// Whether a field can hold a lifecycle status: a closed set of values, or an
+// optional one. A free-text `status: string` is not a lifecycle — filtering a
+// command menu against `allowedStates` needs states to compare with.
+let rec isStatusShape = (t: SchemaType.schemaType): bool =>
+  switch t {
+  | Enum(_, _) => true
+  | Nullable(inner) => isStatusShape(inner)
+  | _ => false
+  }
+
+// Field names that say "this one is the record's name" in the only way
+// available short of the `@displayName` annotation. Matched case-insensitively
+// and *exactly*: `customerName` holds a customer's name, not this record's.
+let conventionalLabelNames = ["name", "title", "label", "displayname"]
+
+let shapeOfItem = (~entityName: string, item: S.item): SchemaType.schemaType =>
+  SchemaType.fromSury(~parentName=entityName, ~fieldName=item.location, item.schema)
+
+// Resolve the field that holds the entity's lifecycle status, used to filter a
+// per-row command menu against each command's `allowedStates`. Resolution order:
 //   1. Field annotated `@status` (PPX-emitted; see StateAnnotations).
-//   2. Field literally named `"status"` (convention; mirrors how
-//      labelField falls back to a conventionally-named string field).
+//   2. Field literally named `"status"` whose IR shape is an enum (convention;
+//      mirrors how labelField falls back to a conventionally-named field).
 //   3. None — filter is inert for this read model.
 let statusFieldFromStateSchema = (
+  ~entityName: string,
   stateSchema: S.t<unknown>,
 ): option<string> => {
   let annotated = switch Reventless.StateAnnotations.getSpec(stateSchema) {
@@ -37,40 +64,96 @@ let statusFieldFromStateSchema = (
     switch stateSchema {
     | Object({items}) =>
       items
-      ->Array.find(item => item.location == "status")
+      ->Array.find(item =>
+        item.location == "status" && isStatusShape(shapeOfItem(~entityName, item))
+      )
       ->Option.map(item => item.location)
     | _ => None
     }
   }
 }
 
+// Which rung of the ladder below produced the label. Published on `queryableDef`
+// as `labelFieldSource`, because the four rungs are not equally believable and a
+// consumer with a name rule of its own has to rank the declaration against it:
+// rung 1 is the author saying which field names the record, rungs 2 and 3 are
+// guesses this repo makes on their behalf, and rung 4 is the admission that
+// there was nothing to guess from. Convention and position are both guesses and
+// nothing here branches on the difference — but a conventional name is the one a
+// client can independently arrive at, while a positional pick is a fact only
+// this side knows.
+type labelFieldSource =
+  | Annotation
+  | Convention
+  | Position
+  | Fallback
+
+let labelFieldSourceToString = (s: labelFieldSource): string =>
+  switch s {
+  | Annotation => "annotation"
+  | Convention => "convention"
+  | Position => "position"
+  | Fallback => "fallback"
+  }
+
+type labelResolution = {
+  field: string,
+  searchableFields: array<string>,
+  source: labelFieldSource,
+}
+
+// Resolves the field a state is named by, from a state schema.
+// Source ladder:
+//   1. @displayName spec present → "displayName" + spec.fields (raw underlying fields)
+//   2. A candidate field named `name`/`title`/`label`/`displayName`
+//   3. The first candidate in declaration order
+//   4. "id" fallback with a logged warning (no searchable fields)
+//
+// A *candidate* is a non-TAG field, not literally named `id`, whose IR shape can
+// name a record (`isLabelShape`). Rungs 2 and 3 are both guesses, and the order
+// between them matters: declaration order alone means a state gains a new name
+// whenever a field is inserted above the old one — a `placedAt` added so date
+// views have something to key off renames every order to a timestamp.
+//
+// `id` is excluded here rather than by the IR because `SchemaType` treats a name
+// that short as an ordinary string; every other reference — `*Id`/`*Ids`, a DCB
+// tag, a `Reference.to` — is already an `EntityId` there.
 let labelFieldsFromStateSchema = (
   ~entityName: string,
   stateSchema: S.t<unknown>,
-): (string, array<string>) =>
+): labelResolution =>
   switch Reventless.DisplayName.getSpec(stateSchema) {
-  | Some(spec) => ("displayName", spec.fields)
+  | Some(spec) => {field: "displayName", searchableFields: spec.fields, source: Annotation}
   | None =>
-    let firstStringItem = switch stateSchema {
+    let candidates = switch stateSchema {
     | Object({items}) =>
-      items->Array.find(item =>
+      items->Array.filter(item =>
         item.location != "TAG" &&
-        !isIdLikeFieldName(item.location) &&
-        switch item.schema {
-        | String(_) => true
-        | _ => false
-        }
+        item.location != "id" &&
+        isLabelShape(shapeOfItem(~entityName, item))
       )
-    | _ => None
+    | _ => []
+    }
+    let conventional = candidates->Array.find(item => {
+      let lower = item.location->String.toLowerCase
+      conventionalLabelNames->Array.some(n => n == lower)
+    })
+    let picked = switch conventional {
+    | Some(item) => Some((item, Convention))
+    | None => candidates->Array.get(0)->Option.map(item => (item, Position))
     }
-    switch firstStringItem {
-    | Some(item) => (item.location, [item.location])
+    switch picked {
+    | Some((item, source)) => {
+        field: item.location,
+        searchableFields: [item.location],
+        source,
+      }
     | None =>
       log.warn(
         ~comp="Plugin_Structure",
         `${entityName}: no @displayName annotation and no suitable string field — labelField falls back to "id"`,
       )
-      ("id", [])
+      {field: "id", searchableFields: [], source: Fallback}
     }
   }
 
@@ -387,6 +470,73 @@ let make = (
     }
   }
 
+  // ── Declared object stores ─────────────────────────────────────────────────
+  //
+  // A field typed as a storage ref states that the deployment needs the named
+  // store to exist. Read that declaration the same way `Reference.getTarget` is
+  // read for entity references, so the requirement travels with the plugin's
+  // structure instead of living only inside a field's schema, where the deploy
+  // would have to re-walk every component to find it.
+  //
+  // An unqualified store belongs to the declaring plugin, so every collected
+  // entry is qualified to `{plugin}.{store}` — one shape, and the string is
+  // directly the store's identity. Many fields legitimately name one store, so
+  // the result is deduplicated.
+
+  let storesFromProperties = (properties: dict<S.t<unknown>>): array<string> =>
+    properties
+    ->Dict.toArray
+    ->Array.filterMap(((_, fieldSchema)) =>
+      Reventless.StorageRef.getStore(fieldSchema)->Option.map(target =>
+        target.plugin->Option.getOr(name) ++ "." ++ target.store
+      )
+    )
+
+  // Commands and events are unions of per-variant objects; state is a single
+  // object. Both reduce to "the properties of every object in this schema".
+  let storesFromSchema = (schema: S.t<unknown>): array<string> => {
+    let fromVariant = v =>
+      switch v {
+      | S.Object({properties}) => storesFromProperties(properties)
+      | _ => []
+      }
+    switch schema {
+    | Union({anyOf}) => anyOf->Array.flatMap(fromVariant)
+    | other => fromVariant(other)
+    }
+  }
+
+  let requiredStores =
+    [
+      aggregates->Array.flatMap((module(A: ReventlessInfra.Aggregate.T with type api = api)) =>
+        Array.concat(
+          storesFromSchema(A.Spec.commandSchema->S.castToUnknown),
+          storesFromSchema(A.Spec.eventSchema->S.castToUnknown),
+        )
+      ),
+      stateChangeSlices->Array.flatMap((module(SCS: ReventlessInfra.StateChangeSlice.T)) =>
+        Array.concat(
+          storesFromSchema(SCS.Spec.commandSchema->S.castToUnknown),
+          storesFromSchema(SCS.Spec.eventSchema->S.castToUnknown),
+        )
+      ),
+      stateViewSlices->Array.flatMap((module(SVS: ReventlessInfra.StateViewSlice.T)) =>
+        storesFromSchema(SVS.Spec.stateSchema->S.castToUnknown)
+      ),
+      readModels->Array.flatMap((
+        module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
+      ) => storesFromSchema(R.Spec.stateSchema->S.castToUnknown)),
+      automationSlices->Array.flatMap((module(AS: ReventlessInfra.AutomationSlice.T)) =>
+        storesFromSchema(AS.Spec.commandSchema->S.castToUnknown)
+      ),
+      inboundTranslationSlices->Array.flatMap((
+        module(ITS: ReventlessInfra.InboundTranslationSlice.T),
+      ) => storesFromSchema(ITS.Spec.commandSchema->S.castToUnknown)),
+    ]
+    ->Array.flat
+    ->Belt.Set.String.fromArray
+    ->Belt.Set.String.toArray
+
   // ── Build queryable defs ───────────────────────────────────────────────────
   //
   // Internal ReadModels and StateViewSlices (marked `@@reventless.visibility(Internal)`)
@@ -408,10 +558,7 @@ let make = (
     ) => {
       let qf = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
       let stateSchema = R.Spec.stateSchema->S.castToUnknown
-      let (labelField, searchableFields) = labelFieldsFromStateSchema(
-        ~entityName=R.Spec.name,
-        stateSchema,
-      )
+      let label = labelFieldsFromStateSchema(~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
@@ -423,9 +570,10 @@ let make = (
         schema: stateSchema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
         consumedEventTypes: consumed,
         linkedWriteSide: linkedWriteSideFor(consumed),
-        labelField,
-        searchableFields,
-        statusField: statusFieldFromStateSchema(stateSchema),
+        labelField: label.field,
+        searchableFields: label.searchableFields,
+        labelFieldSource: Some(labelFieldSourceToString(label.source)),
+        statusField: statusFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
         visibility: visibilityTag(R.Spec.visibility),
         chapter: chapterOf(R.Spec.name),
       }: Reventless.Plugin.queryableDef)
@@ -436,19 +584,17 @@ let make = (
       let qf = Api_Naming.queryFieldNamesForStateView(~plugin=name, ~viewName=SVS.Spec.name)
       let (_, consumed) = svsConsumed->Array.getUnsafe(i)
       let stateSchema = SVS.Spec.stateSchema->S.castToUnknown
-      let (labelField, searchableFields) = labelFieldsFromStateSchema(
-        ~entityName=SVS.Spec.name,
-        stateSchema,
-      )
+      let label = labelFieldsFromStateSchema(~entityName=SVS.Spec.name, stateSchema)
       ({
         Reventless.Plugin.name: SVS.Spec.name,
         queryField: qf.listFieldName,
         schema: stateSchema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
         consumedEventTypes: consumed,
         linkedWriteSide: linkedWriteSideFor(consumed),
-        labelField,
-        searchableFields,
-        statusField: statusFieldFromStateSchema(stateSchema),
+        labelField: label.field,
+        searchableFields: label.searchableFields,
+        labelFieldSource: Some(labelFieldSourceToString(label.source)),
+        statusField: statusFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
         visibility: visibilityTag(SVS.Spec.visibility),
         chapter: chapterOf(SVS.Spec.name),
       }: Reventless.Plugin.queryableDef)
@@ -608,5 +754,6 @@ let make = (
     inboundTranslationSlices: inboundTranslationSliceDefs,
     extensions: extensionDefs,
     extensionPoints: Some(extensionPointDefs),
+    requiredStores: Some(requiredStores),
   }
 }