@reventlessdev/reventless-core 3.0.0-alpha.149 → 3.0.0-alpha.151

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.151 (2026-07-10)
+
+### Bug Fixes
+
+* **plugin-lifecycle:** backfill plugin kind onto existing rows via deploy-time RedetectPlugin ([502dbd6](https://github.com/ReventlessDev/reventless-core/commit/502dbd65d1fdd5b8beae8a7b96df06dcfa32fe3e))
+* **plugin-lifecycle:** make read-model kind nullable so kind-less rows don't null the admin Plugins query ([671c4f6](https://github.com/ReventlessDev/reventless-core/commit/671c4f6cbbdde32a8dced7290fc8aa5b0063536f))
+
+
+# 3.0.0-alpha.150 (2026-07-10)
+
+### Features
+
+* **reventless-ppx:** add [@group](https://github.com/group)By state-field annotation → x-reventless-group-by ([9e7a7b2](https://github.com/ReventlessDev/reventless-core/commit/9e7a7b29e54fb4eda1c6a145c0e7b6dcf26940ee))
+
+
 # 3.0.0-alpha.149 (2026-07-09)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.149",
+  "version": "3.0.0-alpha.151",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -30,20 +30,20 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.24"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.93",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.71"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.51"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.52"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/components/Api/SuryToJsonSchema.res

@@ -44,6 +44,11 @@ let mergeAnnotations = (
     if spec.summary->Array.includes(fieldName) {
       obj->Dict.set("x-reventless-summary", JSON.Encode.bool(true))
     }
+    switch spec.groupBy {
+    | Some(name) if name === fieldName =>
+      obj->Dict.set("x-reventless-group-by", JSON.Encode.bool(true))
+    | _ => ()
+    }
     switch spec.drillTargets->Array.find(((field, _)) => field === fieldName) {
     | Some((_, sliceName)) =>
       obj->Dict.set("x-reventless-drillTarget", JSON.Encode.string(sliceName))

package/src/components/Api/SuryToJsonSchema.res.mjs

@@ -41,6 +41,10 @@ function mergeAnnotations(fieldSchema, fieldName, spec) {
   if (spec.summary.includes(fieldName)) {
     obj["x-reventless-summary"] = true;
   }
+  let name = spec.groupBy;
+  if (name !== undefined && name === fieldName) {
+    obj["x-reventless-group-by"] = true;
+  }
   let match$1 = spec.drillTargets.find(param => param[0] === fieldName);
   if (match$1 !== undefined) {
     obj["x-reventless-drillTarget"] = match$1[1];

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -150,6 +150,14 @@ module Make = (Spec: Spec) => {
           // 1 additional minute to allow additional latency
           HandleDirective(directiveHandler, CreateDisconnectSchedule(id, interval + 2)),
         ]
+      | RedetectPlugin(interval) => [
+          // Deploy-time re-detect: drive Redetect (not Heartbeat) so an already-connected
+          // version re-runs the handshake and refreshes its stored definition. Still
+          // re-arm the disconnect schedule exactly like a heartbeat so liveness tracking
+          // continues from the deploy moment.
+          PublishCommand(Plugin.name(id), Delegate.Redetect(Plugin.version(id))),
+          HandleDirective(directiveHandler, CreateDisconnectSchedule(id, interval + 2)),
+        ]
       | ConnectPlugin(pluginDefinition) =>
         // Validate protocol versions declared by the connecting plugin.
         // On mismatch, emit a ReportIncompatibility command so that an

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -183,6 +183,26 @@ function Make(Spec) {
               _0: cmd._0
             }
           }];
+      case "RedetectPlugin" :
+        return [
+          {
+            TAG: "PublishCommand",
+            _0: Plugin$ReventlessCore.name(id),
+            _1: {
+              TAG: "Redetect",
+              _0: Plugin$ReventlessCore.version(id)
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "CreateDisconnectSchedule",
+              _0: id,
+              _1: cmd._0 + 2 | 0
+            }
+          }
+        ];
     }
   };
   let mapOutgoingEvent = (id, event, _meta, _queryEngine) => {

package/src/plugin/lifecycle/PluginBehavior.res

@@ -145,10 +145,24 @@ let decide = (state, command) =>
     | Some({status: Disconnected, definition}) => Ok(connectEvents(state, v, definition)) // reconnect
     | Some({status: Inactive | Retired}) => Ok([]) // not heartbeat-revivable (admin only)
     }
+  | Redetect(v) =>
+    // Deploy-time re-detect: unlike Heartbeat, a *connected* version re-runs the
+    // handshake (VersionDetected → ConnectPlugin → Connect) so the plugin re-answers
+    // with its current definition and Connect below refreshes the stored def. Unknown
+    // and disconnected versions detect exactly as a heartbeat would; archived versions
+    // stay admin-only.
+    switch state.known->Dict.get(v) {
+    | Some({status: Inactive | Retired}) => Ok([]) // archived — not re-detect-revivable
+    | None | Some({status: Connected | Disconnected}) => Ok([VersionDetected(v)])
+    }
   | Connect(def) =>
     let v = def.version
     switch state.known->Dict.get(v) {
-    | Some({status: Connected}) => Ok([]) // idempotent
+    // Idempotent when the definition is unchanged; when a redeploy carries a changed
+    // definition (e.g. a newly added `kind`, updated uiFragments/protocols) re-emit
+    // VersionConnected to overwrite the stored def and re-project the row. The version
+    // is already current, so connectEvents' supersede stays empty — a bare refresh.
+    | Some({status: Connected, definition}) => definition == def ? Ok([]) : Ok([VersionConnected(def)])
     | _ => Ok(connectEvents(state, v, def))
     }
   | Disconnect(v) =>

package/src/plugin/lifecycle/PluginBehavior.res.mjs

@@ -172,55 +172,94 @@ function decide(state, command) {
             _0: []
           };
       }
-    case "Connect" :
-      let def = command._0;
-      let v$1 = def.version;
+    case "Redetect" :
+      let v$1 = command._0;
       let match$1 = state.known[v$1];
-      if (match$1 !== undefined && match$1.status === "Connected") {
+      if (match$1 === undefined) {
         return {
           TAG: "Ok",
-          _0: []
+          _0: [{
+              TAG: "VersionDetected",
+              _0: v$1
+            }]
         };
+      }
+      switch (match$1.status) {
+        case "Connected" :
+        case "Disconnected" :
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionDetected",
+                _0: v$1
+              }]
+          };
+        case "Inactive" :
+        case "Retired" :
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+      }
+    case "Connect" :
+      let def = command._0;
+      let v$2 = def.version;
+      let match$2 = state.known[v$2];
+      if (match$2 !== undefined && match$2.status === "Connected") {
+        if (Primitive_object.equal(match$2.definition, def)) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionConnected",
+                _0: def
+              }]
+          };
+        }
       } else {
         return {
           TAG: "Ok",
-          _0: connectEvents(state, v$1, def)
+          _0: connectEvents(state, v$2, def)
         };
       }
     case "Disconnect" :
-      let v$2 = command._0;
-      let match$2 = state.known[v$2];
-      if (match$2 === undefined) {
+      let v$3 = command._0;
+      let match$3 = state.known[v$3];
+      if (match$3 === undefined) {
         return {
           TAG: "Ok",
           _0: []
         };
       }
-      if (match$2.status !== "Connected") {
+      if (match$3.status !== "Connected") {
         return {
           TAG: "Ok",
           _0: []
         };
       }
-      let definition = match$2.definition;
+      let definition = match$3.definition;
       return {
         TAG: "Ok",
         _0: [{
             TAG: "VersionDisconnected",
             _0: definition
-          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$2))
+          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$3))
       };
     case "Activate" :
-      let v$3 = command._0;
-      let match$3 = state.known[v$3];
-      if (match$3 === undefined) {
+      let v$4 = command._0;
+      let match$4 = state.known[v$4];
+      if (match$4 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$1 = match$3.definition;
-      switch (match$3.status) {
+      let definition$1 = match$4.definition;
+      switch (match$4.status) {
         case "Connected" :
           return {
             TAG: "Ok",
@@ -240,17 +279,17 @@ function decide(state, command) {
           _0: definition$1
         }].concat(uiRegisterEvents(definition$1.id, definition$1.uiFragments));
       let supersede;
-      if (currentAfterConnect(state.known, v$3) === v$3) {
+      if (currentAfterConnect(state.known, v$4) === v$4) {
         let c = state.current;
         if (c !== undefined) {
-          if (c !== v$3) {
-            let match$4 = state.known[c];
-            supersede = match$4 !== undefined ? [{
+          if (c !== v$4) {
+            let match$5 = state.known[c];
+            supersede = match$5 !== undefined ? [{
                   TAG: "VersionSuperseded",
                   _0: {
                     supersededVersion: c,
-                    supersededDefinition: match$4.definition,
-                    newVersion: v$3,
+                    supersededDefinition: match$5.definition,
+                    newVersion: v$4,
                     newDefinition: definition$1
                   }
                 }] : [];
@@ -269,16 +308,16 @@ function decide(state, command) {
       };
       break;
     case "Deactivate" :
-      let v$4 = command._0;
-      let match$5 = state.known[v$4];
-      if (match$5 === undefined) {
+      let v$5 = command._0;
+      let match$6 = state.known[v$5];
+      if (match$6 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$2 = match$5.definition;
-      switch (match$5.status) {
+      let definition$2 = match$6.definition;
+      switch (match$6.status) {
         case "Connected" :
         case "Disconnected" :
           break;
@@ -294,7 +333,7 @@ function decide(state, command) {
         _0: [{
             TAG: "VersionDeactivated",
             _0: definition$2
-          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$4))
+          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$5))
       };
       break;
     case "ReportIncompatibility" :
@@ -306,16 +345,16 @@ function decide(state, command) {
           }]
       };
     case "Retire" :
-      let v$5 = command._0;
-      let match$6 = state.known[v$5];
-      if (match$6 === undefined) {
+      let v$6 = command._0;
+      let match$7 = state.known[v$6];
+      if (match$7 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$3 = match$6.definition;
-      if (match$6.status === "Retired") {
+      let definition$3 = match$7.definition;
+      if (match$7.status === "Retired") {
         return {
           TAG: "Ok",
           _0: []
@@ -326,7 +365,7 @@ function decide(state, command) {
           _0: [{
               TAG: "VersionRetired",
               _0: definition$3
-            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$5))
+            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$6))
         };
       }
   }

package/src/plugin/lifecycle/PluginSpec.res

@@ -10,6 +10,10 @@ open Reventless.Plugin
 @schema
 type command =
   | @noApi Heartbeat(version)
+  // Deploy-time re-detect (from RedetectPlugin). Forces the connect handshake to
+  // re-run for an already-connected version so its definition is refreshed on the
+  // row — unlike Heartbeat, which no-ops a connected keep-alive.
+  | @noApi Redetect(version)
   | @noApi Connect(pluginDefinition)
   | @noApi Disconnect(version)
   // Admin lifecycle commands — API-exposed (auto-derived admin mutations,

package/src/plugin/lifecycle/PluginSpec.res.mjs

@@ -9,6 +9,10 @@ let commandSchema = S.union([
     TAG: "Heartbeat",
     _0: s.m(Plugin$Reventless.versionSchema)
   })),
+  S.schema(s => ({
+    TAG: "Redetect",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
   S.schema(s => ({
     TAG: "Connect",
     _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
@@ -117,6 +121,7 @@ let errorSchema = S.union([
 
 let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
   "Heartbeat",
+  "Redetect",
   "Connect",
   "Disconnect",
   "ReportIncompatibility"

package/src/plugin/lifecycle/PluginsProjection.res

@@ -58,7 +58,10 @@ let displayState = (
     uiFragments: def.uiFragments,
     structure: def.structure,
     dcbEventLog: def.dcbEventLog,
-    kind: def.kind,
+    // A freshly projected row always knows its kind (the definition carries it as a
+    // mandatory field). `option` here is purely for rows persisted before `kind`
+    // existed — see PluginsReadModelSpec.state.kind.
+    kind: Some(def.kind),
     // The current version is never listed among the "other" connected versions.
     otherConnectedVersions: otherConnectedVersions->Util.without(def.version),
   }

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -42,7 +42,18 @@ type state = {
   // @scan opts the field into server-side equality filtering so the connection gains
   // a `kindEq` filter — the panel split (main list vs System/Infrastructure) pages
   // correctly server-side rather than filtering a page client-side.
-  @scan kind: Reventless.Plugin.pluginKind,
+  // @groupBy tags this field as the list view's section key (emitted as
+  // `x-reventless-group-by`); AutoUI sections the admin Plugins view by kind.
+  //
+  // **Nullable on purpose.** Rows projected before `kind` existed carry no `kind`
+  // attribute, and the deploy-time RedetectPlugin backfill only stamps a row on the
+  // owning plugin's next deploy. A non-null `PluginKind!` would make GraphQL null the
+  // entire `Platform_Plugins` query the moment a single kind-less row is returned
+  // (existing rows, a newly-connecting plugin before it's stamped, or an internal
+  // bookkeeping row). Optional here → nullable `Platform_PluginKind` in the SDL, so a
+  // blank kind degrades to a missing group (AutoListView's trailing group) instead of
+  // taking down the whole list. Backfill then upgrades blanks to real kinds.
+  @scan @groupBy kind: option<Reventless.Plugin.pluginKind>,
   // Other versions of this name that are currently **Connected** — excludes this
   // row's own `version` (whose status is the `status` field above). Lets the
   // projection recompute which version is current (highest Connected) during a
@@ -67,7 +78,7 @@ type queryResult = {
   uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
   structure: option<Reventless.Plugin.pluginStructure>,
   dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
-  kind: Reventless.Plugin.pluginKind,
+  kind: option<Reventless.Plugin.pluginKind>,
 }
 
 

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -28,7 +28,7 @@ let stateSchema = S.schema(s => ({
   uiFragments: s.m(Plugin$Reventless.uiFragmentManifestOptionSchema),
   structure: s.m(Plugin$Reventless.pluginStructureOptionSchema),
   dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
-  kind: s.m(Plugin$Reventless.pluginKindSchema),
+  kind: s.m(S.option(Plugin$Reventless.pluginKindSchema)),
   otherConnectedVersions: s.m(S.array(Plugin$Reventless.versionSchema))
 }));
 
@@ -48,6 +48,7 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
   scan: ["kind"],
   scanSort: [],
   status: undefined,
+  groupBy: "kind",
   visibility: undefined
 });
 

package/tests/api/SuryToJsonSchemaTest.res

@@ -30,6 +30,7 @@ let emptySpec: Reventless.StateAnnotations.stateAnnotationSpec = {
   scan: [],
   scanSort: [],
   status: None,
+  groupBy: None,
   visibility: None,
 }
 
@@ -305,6 +306,25 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((Some(true), None))
     })
 
+    testSync("emits x-reventless-group-by on the field named by groupBy", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "kind": s.matches(S.string),
+        }
+      )->S.castToUnknown
+      let schema' = schema->withSpec({...emptySpec, groupBy: Some("kind")})
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let kindSchema = getPropertyOf(json, "kind")
+      let idSchema = getPropertyOf(json, "id")
+      expect((
+        kindSchema
+        ->Option.flatMap(s => getProperty(s, "x-reventless-group-by"))
+        ->Option.flatMap(JSON.Decode.bool),
+        idSchema->Option.flatMap(s => getProperty(s, "x-reventless-group-by")),
+      ))->toEqual((Some(true), None))
+    })
+
     testSync("emits x-reventless-collapsed on field listed in collapsed", () => {
       let schema = S.schema(s =>
         {

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -64,6 +64,7 @@ let emptySpec = {
   scan: emptySpec_scan,
   scanSort: emptySpec_scanSort,
   status: undefined,
+  groupBy: undefined,
   visibility: undefined
 };
 
@@ -100,6 +101,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -129,6 +131,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -161,6 +164,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -189,6 +193,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -217,6 +222,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -242,6 +248,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -267,6 +274,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -299,6 +307,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -334,6 +343,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -372,6 +382,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -400,6 +411,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -425,6 +437,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: ["status"],
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -457,6 +470,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: ["name"],
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -470,6 +484,39 @@ globalThis.describe("SuryToJsonSchema:", () => {
         undefined
       ]);
     });
+    globalThis.test("emits x-reventless-group-by on the field named by groupBy", () => {
+      let schema = S.schema(s => ({
+        id: s.m(S.string),
+        kind: s.m(S.string)
+      }));
+      let schema$p = withSpec(schema, {
+        ids: emptySpec_ids,
+        compositeIds: emptySpec_compositeIds,
+        subIds: emptySpec_subIds,
+        compositeSubIds: emptySpec_compositeSubIds,
+        indexes: emptySpec_indexes,
+        hidden: emptySpec_hidden,
+        summary: emptySpec_summary,
+        drillTargets: emptySpec_drillTargets,
+        drillTargetKeys: emptySpec_drillTargetKeys,
+        collapsed: emptySpec_collapsed,
+        scan: emptySpec_scan,
+        scanSort: emptySpec_scanSort,
+        status: undefined,
+        groupBy: "kind",
+        visibility: undefined
+      });
+      let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
+      let kindSchema = getPropertyOf(json, "kind");
+      let idSchema = getPropertyOf(json, "id");
+      globalThis.expect([
+        Stdlib_Option.flatMap(Stdlib_Option.flatMap(kindSchema, s => getProperty(s, "x-reventless-group-by")), Stdlib_JSON.Decode.bool),
+        Stdlib_Option.flatMap(idSchema, s => getProperty(s, "x-reventless-group-by"))
+      ]).toEqual([
+        true,
+        undefined
+      ]);
+    });
     globalThis.test("emits x-reventless-collapsed on field listed in collapsed", () => {
       let schema = S.schema(s => ({
         id: s.m(S.string),
@@ -489,6 +536,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -520,6 +568,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: "Internal"
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -543,6 +592,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -606,6 +656,7 @@ globalThis.describe("SuryToJsonSchema:", () => {
         scan: emptySpec_scan,
         scanSort: emptySpec_scanSort,
         status: undefined,
+        groupBy: undefined,
         visibility: undefined
       });
       let native = S.toJSONSchema(schema$p);

package/tests/plugin/StateViewSlice/PsAnnotatedView.res.mjs

@@ -65,6 +65,7 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
   scan: [],
   scanSort: [],
   status: undefined,
+  groupBy: undefined,
   visibility: undefined
 });