@reventlessdev/reventless-core 3.0.0-alpha.234 → 3.0.0-alpha.236

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.236 (2026-08-15)
+
+### Bug Fixes
+
+* **core:** describe a DCB event log by every event it carries ([047bc0b](https://github.com/ReventlessDev/reventless-core/commit/047bc0beb9be1468410fde37a7f787a3d68f92d2))
+### Features
+
+* **aws:** serve one baked manifest per journey ([16d6307](https://github.com/ReventlessDev/reventless-core/commit/16d63071f059cf1fc7025f9be9206dda51f71053))
+
+
+# 3.0.0-alpha.235 (2026-08-15)
+
+### Features
+
+* **core:** curate the pages a shell builds across a plugin's views ([589835a](https://github.com/ReventlessDev/reventless-core/commit/589835a1ad428c5e2dea8bf6e4c64e49d2f67e0d))
+
+
 # 3.0.0-alpha.234 (2026-08-14)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.234",
+  "version": "3.0.0-alpha.236",
   "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.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.6",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.7",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.7",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.6",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.6",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.141",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.31",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.7",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.113"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.142",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.31",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.114"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_BakedManifest.res

@@ -20,6 +20,22 @@ type error =
   | UnknownPlugin(string)
   | UnknownView({plugin: string, view: string})
   | UnknownCommand({plugin: string, command: string})
+  | UnknownDerived({plugin: string, kind: string})
+
+/** The pages a shell builds across a plugin's views rather than from any one of
+    them, as the vocabulary a deployment curates them by.
+
+    A closed set, and deliberately kinds rather than page names. A dashboard and
+    a lifecycle page are named by the framework, but a canvas is named by the
+    views it draws — from that deployment's hints and the view modes its shell
+    registered, neither of which this side can see. Curating by kind is the
+    question this side CAN answer, and it is also the question an author is
+    asking: "does this audience get calendars", not "does it get the one called
+    Deliveries".
+
+    Ordered as they appear in a menu (the dashboard tops the group, canvases and
+    schedulers tail it), so the vocabulary reads as the page set it curates. */
+let derivedKinds = ["dashboard", "lifecycles", "canvas", "scheduler"]
 
 let describe = (e: error): string =>
   switch e {
@@ -28,16 +44,26 @@ let describe = (e: error): string =>
     `baked manifest: plugin "${plugin}" has no view named "${view}"`
   | UnknownCommand({plugin, command}) =>
     `baked manifest: plugin "${plugin}" has no command named "${command}"`
+  | UnknownDerived({plugin, kind}) =>
+    `baked manifest: plugin "${plugin}" names derived page kind "${kind}" — ` ++
+    `known kinds: ${derivedKinds->Array.join(", ")}`
   }
 
 // Views are named by component name — a view IS the surface. Commands are named
 // by command name, not by the write-side component that carries them: the
 // command is what a user invokes, and which slice or aggregate it lives on is an
 // implementation detail the author should not have to know to curate a shop.
+//
+// `derived` is neither: it names page KINDS, for the reason `derivedKinds`
+// gives. Unlike the other two, what it selects is not filtered here — there is
+// nothing in a `pluginStructure` to filter, because the pages do not exist until
+// a shell builds them. It travels to the shell instead, which is the only place
+// that can honour it.
 type selection = {
   plugin: string,
   views: option<array<string>>,
   commands: option<array<string>>,
+  derived: option<array<string>>,
 }
 
 let publicViews = (def: pluginStructure): array<queryableDef> =>
@@ -65,7 +91,16 @@ let validate = (~def: pluginStructure, sel: selection): result<unit, error> => {
   | None =>
     switch sel.commands->known(def->commandNames) {
     | Some(command) => Error(UnknownCommand({plugin: sel.plugin, command}))
-    | None => Ok()
+    | None =>
+      // Against the vocabulary rather than against this plugin: a kind that
+      // generates no page here is a fact about the plugin's schemas, not a
+      // mistake — a shop naming `lifecycles` for a plugin whose views gain a
+      // status field next month is stating an intention, and failing it would
+      // punish the deployment for being early.
+      switch sel.derived->known(derivedKinds) {
+      | Some(kind) => Error(UnknownDerived({plugin: sel.plugin, kind}))
+      | None => Ok()
+      }
     }
   }
 }
@@ -169,6 +204,58 @@ let journeyKey = (~group: string): string => {
   `component-manifest-${slug}.json`
 }
 
+let toSelection = (s: ReventlessInfra.Platform.bakedManifestSelection): selection => {
+  plugin: s.plugin,
+  views: s.views,
+  commands: s.commands,
+  derived: s.derived,
+}
+
+/** One declared journey, with everything a platform needs to serve it: the group
+    it serves, the file it is written to, and the include-list that decides the
+    file's contents. */
+type journeyFile = {group: string, key: string, selections: array<selection>}
+
+/**
+ The declared journeys, in declaration order, with their keys resolved.
+
+ The default journey is deliberately not among them: it is the file
+ `manifestUrl` points at, which is what a caller matching no declared group reads
+ and what every deployment had before journeys existed.
+ */
+let journeyFiles = (~config: ReventlessInfra.Platform.bakedManifest): array<journeyFile> =>
+  config.journeys
+  ->Option.getOr([])
+  ->Array.map(j => {
+    group: j.group,
+    key: j.key->Option.getOr(journeyKey(~group=j.group)),
+    selections: j.components->Array.map(toSelection),
+  })
+
+/**
+ Every file a bake declaration produces, as (key, selections) pairs.
+
+ The default journey first and always — it is what a caller matching no declared
+ group gets, which includes the no-bearer identity a local dev session starts
+ from — then one per declared journey.
+
+ Here rather than on either platform because several separate things have to
+ agree about this set on a deploy: the objects the bake writes, the IAM grant
+ that lets it write them, and the URLs `config.json` sends a caller to. A key
+ derived twice is a shop whose file is written where nothing fetches it, and the
+ symptom is an empty menu rather than a missing file.
+ */
+let files = (
+  ~config: ReventlessInfra.Platform.bakedManifest,
+): array<(string, array<selection>)> =>
+  [
+    (config.key->Option.getOr(defaultKey), config.components->Array.map(toSelection)),
+  ]->Array.concat(journeyFiles(~config)->Array.map(j => (j.key, j.selections)))
+
+/** Each declared journey's group and the URL a shell fetches its file from. */
+let journeyUrls = (~config: ReventlessInfra.Platform.bakedManifest): array<(string, string)> =>
+  journeyFiles(~config)->Array.map(j => (j.group, urlForKey(Some(j.key))))
+
 // The whole file: one entry per selection, in the order the deployment declared
 // them, so the include-list also states the order a consumer reads plugins in.
 let curate = (
@@ -182,7 +269,11 @@ let curate = (
       | Some((pluginId, def)) =>
         curateStructure(~pluginId, ~def, sel)->Result.map(curated => {
           entries->Array.push(
-            Platform_ComponentDefinitionsApi.encodePluginStructureEntry(~pluginId, curated),
+            Platform_ComponentDefinitionsApi.encodePluginStructureEntry(
+              ~pluginId,
+              ~derived=?sel.derived,
+              curated,
+            ),
           )
           entries
         })

package/src/admin/Platform_BakedManifest.res.mjs

@@ -6,6 +6,13 @@ import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Plugin$ReventlessCore from "../plugin/component/Plugin.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
 
+let derivedKinds = [
+  "dashboard",
+  "lifecycles",
+  "canvas",
+  "scheduler"
+];
+
 function describe(e) {
   switch (e.TAG) {
     case "UnknownPlugin" :
@@ -14,6 +21,8 @@ function describe(e) {
       return `baked manifest: plugin "` + e.plugin + `" has no view named "` + e.view + `"`;
     case "UnknownCommand" :
       return `baked manifest: plugin "` + e.plugin + `" has no command named "` + e.command + `"`;
+    case "UnknownDerived" :
+      return `baked manifest: plugin "` + e.plugin + `" names derived page kind "` + e.kind + `" — known kinds: ` + derivedKinds.join(", ");
   }
 }
 
@@ -52,6 +61,17 @@ function validate(def, sel) {
         command: command
       }
     };
+  }
+  let kind = known(sel.derived, derivedKinds);
+  if (kind !== undefined) {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "UnknownDerived",
+        plugin: sel.plugin,
+        kind: kind
+      }
+    };
   } else {
     return {
       TAG: "Ok",
@@ -172,6 +192,40 @@ function journeyKey(group) {
   return `component-manifest-` + slug + `.json`;
 }
 
+function toSelection(s) {
+  return {
+    plugin: s.plugin,
+    views: s.views,
+    commands: s.commands,
+    derived: s.derived
+  };
+}
+
+function journeyFiles(config) {
+  return Stdlib_Option.getOr(config.journeys, []).map(j => ({
+    group: j.group,
+    key: Stdlib_Option.getOr(j.key, journeyKey(j.group)),
+    selections: j.components.map(toSelection)
+  }));
+}
+
+function files(config) {
+  return [[
+      Stdlib_Option.getOr(config.key, defaultKey),
+      config.components.map(toSelection)
+    ]].concat(journeyFiles(config).map(j => [
+    j.key,
+    j.selections
+  ]));
+}
+
+function journeyUrls(config) {
+  return journeyFiles(config).map(j => [
+    j.group,
+    urlForKey(j.key)
+  ]);
+}
+
 function curate(structures, selections) {
   return Stdlib_Result.map(Stdlib_Array.reduce(selections, {
     TAG: "Ok",
@@ -189,13 +243,14 @@ function curate(structures, selections) {
     }
     let pluginId = match[0];
     return Stdlib_Result.map(curateStructure(pluginId, match[1], sel), curated => {
-      entries.push(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry(pluginId, curated));
+      entries.push(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry(pluginId, sel.derived, curated));
       return entries;
     });
   })), prim => prim);
 }
 
 export {
+  derivedKinds,
   describe,
   publicViews,
   writeSides,
@@ -207,6 +262,10 @@ export {
   defaultKey,
   urlForKey,
   journeyKey,
+  toSelection,
+  journeyFiles,
+  files,
+  journeyUrls,
   curate,
 }
 /* No side effect */

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -207,8 +207,21 @@ let encodeExtensionDef = (e: extensionDef): JSON.t =>
     ("commandTypes", encodeStrings(e.commandTypes)),
   ])->JSON.Encode.object
 
-let encodePluginStructureEntry = (~pluginId: string, def: pluginStructure): JSON.t =>
-  Dict.fromArray([
+// `derived` is curation, not structure: it says which of the pages a shell
+// builds across this plugin's views that shell may build. It therefore arrives
+// as an argument rather than off `def` — nothing in a compiled plugin decides
+// it, and the admin path, which curates nothing, passes none.
+//
+// Absent key ⇒ every kind, which is what an uncurated entry means and what
+// every manifest written before the field says. A curated entry that wants none
+// says so with `[]`, and the two are only distinguishable because the key is
+// omitted rather than nulled.
+let encodePluginStructureEntry = (
+  ~pluginId: string,
+  ~derived: option<array<string>>=?,
+  def: pluginStructure,
+): JSON.t => {
+  let entry = Dict.fromArray([
     ("pluginId", JSON.Encode.string(Plugin.name(pluginId))),
     (
       "readModels",
@@ -247,4 +260,9 @@ let encodePluginStructureEntry = (~pluginId: string, def: pluginStructure): JSON
       ->JSON.Encode.array,
     ),
     ("extensions", def.extensions->Array.map(encodeExtensionDef)->JSON.Encode.array),
-  ])->JSON.Encode.object
+  ])
+  derived->Option.forEach(kinds =>
+    entry->Dict.set("derivedPages", kinds->Array.map(JSON.Encode.string)->JSON.Encode.array)
+  )
+  entry->JSON.Encode.object
+}

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -339,8 +339,8 @@ function encodeExtensionDef(e) {
   ]);
 }
 
-function encodePluginStructureEntry(pluginId, def) {
-  return Object.fromEntries([
+function encodePluginStructureEntry(pluginId, derived, def) {
+  let entry = Object.fromEntries([
     [
       "pluginId",
       Plugin$ReventlessCore.name(pluginId)
@@ -382,6 +382,10 @@ function encodePluginStructureEntry(pluginId, def) {
       def.extensions.map(encodeExtensionDef)
     ]
   ]);
+  Stdlib_Option.forEach(derived, kinds => {
+    entry["derivedPages"] = kinds.map(prim => prim);
+  });
+  return entry;
 }
 
 let sdlQueryField = `  Platform_ComponentDefinitions: [Platform_ComponentDefinitionEntry!]!`;

package/src/components/Dcb/Dcb_Builder.res

@@ -21,6 +21,52 @@ let toRelativePath: string => string = %raw(`function toRelativePath(moduleUrl)
   }
 }`)
 
+// The tag of one compiled variant arm: `{TAG: "<Name>", …}` for a payload-bearing
+// constructor, a bare string const for a payload-less one.
+let variantTag = (variant: S.t<unknown>) =>
+  switch variant {
+  | S.Object({properties}) =>
+    switch properties->Dict.get("TAG") {
+    | Some(String({const: ?Some(tag)})) => Some(tag)
+    | _ => None
+    }
+  | S.String({const: ?Some(tag)}) => Some(tag)
+  | _ => None
+  }
+
+/**
+The event schema of a DCB event log: one union over every event its slices produce.
+
+Flattened, not nested. Every reader of an `eventLogSchemaEntry` walks exactly one
+level — `Union` → per-variant `Object` with a `TAG` const — so a union OF unions
+would present each slice as an arm with no tag and read as a log carrying no
+event types at all. Arms are deduped by tag because two slices producing the same
+event would otherwise hand sury two arms with one discriminant.
+*/
+let mergedEventSchema = (schemas: array<S.t<unknown>>) =>
+  switch schemas {
+  | [single] => single
+  | many =>
+    let seen = Set.make()
+    many
+    ->Array.flatMap(schema =>
+      switch schema {
+      | S.Union({anyOf}) => anyOf
+      | other => [other]
+      }
+    )
+    ->Array.filter(arm =>
+      switch arm->variantTag {
+      | Some(tag) if seen->Set.has(tag) => false
+      | Some(tag) =>
+        seen->Set.add(tag)
+        true
+      | None => true
+      }
+    )
+    ->S.union
+  }
+
 type dcbResult = {
   dcbEventLogOutputs: option<DcbEventLog.outputs>,
   stateChangeSlicesOutputs: dict<StateChangeSlice.outputs>,
@@ -1047,7 +1093,11 @@ module Make = (
           }
         })
 
-        // Collect all event schemas from produced events for eventLogEntries
+        // Every event this plugin's slices produce lands in the one DCB event log,
+        // so the log's schema entry is the union of all of them. Taking the first
+        // slice's schema as representative left the readers of that entry — the
+        // upload claimer's `CLAIM_REF_FIELDS`, MCP's event-history resource —
+        // describing one slice and silently blind to the rest.
         let allProducedSchemas =
           stateChangeSlices->Array.map((module(Sc: StateChangeSlice.T)) =>
             Sc.Spec.eventSchema->S.castToUnknown
@@ -1102,12 +1152,11 @@ module Make = (
             ->Array.concat(outboundEntries)
             ->Array.concat(inboundEntries),
           eventLogEntries: if allProducedSchemas->Array.length > 0 {
-            // Use the first produced event schema as representative for the event log
             [
               {
                 ReventlessInfra.Api.busKey: name ++ "DcbEventLog",
                 displayName: name,
-                eventSchema: allProducedSchemas->Array.getUnsafe(0),
+                eventSchema: allProducedSchemas->mergedEventSchema,
               },
             ]
           } else {

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

@@ -48,6 +48,60 @@ let toRelativePath = (function toRelativePath(moduleUrl) {
   }
 });
 
+function variantTag(variant) {
+  switch (variant.type) {
+    case "string" :
+      let tag = variant.const;
+      if (tag !== undefined) {
+        return tag;
+      } else {
+        return;
+      }
+    case "object" :
+      let match = variant.properties["TAG"];
+      if (match === undefined) {
+        return;
+      }
+      if (match.type !== "string") {
+        return;
+      }
+      let tag$1 = match.const;
+      if (tag$1 !== undefined) {
+        return tag$1;
+      } else {
+        return;
+      }
+    default:
+      return;
+  }
+}
+
+function mergedEventSchema(schemas) {
+  if (schemas.length === 1) {
+    return schemas[0];
+  }
+  let seen = new Set();
+  return S.union(schemas.flatMap(schema => {
+    if (schema.type === "union") {
+      return schema.anyOf;
+    } else {
+      return [schema];
+    }
+  }).filter(arm => {
+    let tag = variantTag(arm);
+    if (tag !== undefined) {
+      if (seen.has(tag)) {
+        return false;
+      } else {
+        seen.add(tag);
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }));
+}
+
 let emptyResult_stateChangeSlicesOutputs = {};
 
 let emptyResult_stateViewSlicesOutputs = {};
@@ -583,7 +637,7 @@ function Make(DcbEventLogStorage) {
         eventLogEntries: allProducedSchemas.length !== 0 ? [{
               busKey: name + "DcbEventLog",
               displayName: name,
-              eventSchema: allProducedSchemas[0]
+              eventSchema: mergedEventSchema(allProducedSchemas)
             }] : []
       };
     };
@@ -596,6 +650,8 @@ function Make(DcbEventLogStorage) {
 export {
   log,
   toRelativePath,
+  variantTag,
+  mergedEventSchema,
   emptyResult,
   Make,
 }

package/tests/admin/Platform_BakedManifestTest.res

@@ -89,6 +89,15 @@ let structures = [("Ordering@1.0.0", structure)]
 let bake = selections =>
   Platform_BakedManifest.curate(~structures, ~selections)
 
+// Every case below varies one include-list and means "everything" by the rest,
+// which is exactly what an omitted labelled argument says.
+let sel = (~plugin, ~views=?, ~commands=?, ~derived=?): Platform_BakedManifest.selection => {
+  plugin,
+  views,
+  commands,
+  derived,
+}
+
 let entries = (json: JSON.t) => json->JSON.Decode.array->Option.getOr([])
 
 let names = (entry: JSON.t, field: string) =>
@@ -110,19 +119,17 @@ let firstEntry = (r: result<JSON.t, Platform_BakedManifest.error>) =>
 describe("curate", () => {
   testSync("selects exactly the named components", () => {
     let entry =
-      bake([{plugin: "Ordering", views: Some(["Orders"]), commands: Some(["PlaceOrder"])}])
-      ->firstEntry
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])->firstEntry
     expect((entry->names("stateViewSlices"), entry->names("readModels")))->toEqual((["Orders"], []))
   })
 
   testSync("drops a write side whose commands were all excluded", () => {
-    let entry =
-      bake([{plugin: "Ordering", views: Some([]), commands: Some(["PlaceOrder"])}])->firstEntry
+    let entry = bake([sel(~plugin="Ordering", ~views=[], ~commands=["PlaceOrder"])])->firstEntry
     expect(entry->names("stateChangeSlices"))->toEqual(["PlaceOrder"])
   })
 
   testSync("unset views and commands include every public component", () => {
-    let entry = bake([{plugin: "Ordering", views: None, commands: None}])->firstEntry
+    let entry = bake([sel(~plugin="Ordering")])->firstEntry
     expect((
       entry->names("readModels"),
       entry->names("stateViewSlices"),
@@ -134,34 +141,72 @@ describe("curate", () => {
   // from, so an Internal view a kept command points at has to survive the bake.
   testSync("carries an Internal view referenced by an included command", () => {
     let entry =
-      bake([{plugin: "Ordering", views: Some(["Orders"]), commands: Some(["PlaceOrder"])}])
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])
       ->firstEntry
     expect(entry->names("internalQueryables"))->toEqual(["AvailableProducts"])
   })
 
   testSync("omits an Internal view no included command references", () => {
     let entry =
-      bake([{plugin: "Ordering", views: Some(["Orders"]), commands: Some(["ImportOrders"])}])
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["ImportOrders"])])
       ->firstEntry
     expect(entry->names("internalQueryables"))->toEqual([])
   })
 
-  testSync("an Internal view is never selectable as a view", () =>
+  // The pages a shell builds across a plugin's views do not exist on this side,
+  // so what the bake can do about them is state which kinds an audience gets and
+  // carry that to the shell. Absent and empty therefore have to stay two
+  // different answers all the way out to the JSON, which is what these three
+  // cases pin: nothing said ⇒ no key ⇒ every kind, and `[]` ⇒ a key ⇒ none.
+  let derivedOf = (entry: JSON.t) =>
+    entry
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("derivedPages"))
+    ->Option.map(v => v->JSON.Decode.array->Option.getOr([])->Array.filterMap(JSON.Decode.string))
+
+  testSync("unset derived says nothing, leaving every kind to the shell", () =>
+    expect(bake([sel(~plugin="Ordering")])->firstEntry->derivedOf)->toEqual(None)
+  )
+
+  testSync("an empty derived list is carried, and is not the same as unset", () =>
+    expect(bake([sel(~plugin="Ordering", ~derived=[])])->firstEntry->derivedOf)->toEqual(Some([]))
+  )
+
+  testSync("carries exactly the derived kinds named", () =>
+    expect(
+      bake([sel(~plugin="Ordering", ~derived=["lifecycles", "canvas"])])->firstEntry->derivedOf,
+    )->toEqual(Some(["lifecycles", "canvas"]))
+  )
+
+  // Against the vocabulary, never against this plugin: a kind that generates no
+  // page for these schemas is a fact about the plugin, not a typo, and a shop
+  // that names `lifecycles` before its views carry a status is early, not wrong.
+  testSync("fails naming a derived kind outside the vocabulary", () =>
+    expect(bake([sel(~plugin="Ordering", ~derived=["dashboards"])]))->toEqual(
+      Error(Platform_BakedManifest.UnknownDerived({plugin: "Ordering", kind: "dashboards"})),
+    )
+  )
+
+  testSync("accepts a kind this plugin generates no page for", () =>
     expect(
-      bake([{plugin: "Ordering", views: Some(["AvailableProducts"]), commands: None}]),
-    )->toEqual(
+      bake([sel(~plugin="Ordering", ~derived=["scheduler"])])->firstEntry->derivedOf,
+    )->toEqual(Some(["scheduler"]))
+  )
+
+  testSync("an Internal view is never selectable as a view", () =>
+    expect(bake([sel(~plugin="Ordering", ~views=["AvailableProducts"])]))->toEqual(
       Error(Platform_BakedManifest.UnknownView({plugin: "Ordering", view: "AvailableProducts"})),
     )
   )
 
   testSync("fails naming an unknown plugin", () =>
-    expect(bake([{plugin: "Shipping", views: None, commands: None}]))->toEqual(
+    expect(bake([sel(~plugin="Shipping")]))->toEqual(
       Error(Platform_BakedManifest.UnknownPlugin("Shipping")),
     )
   )
 
   testSync("fails naming an unknown command", () =>
-    expect(bake([{plugin: "Ordering", views: None, commands: Some(["CancelOrder"])}]))->toEqual(
+    expect(bake([sel(~plugin="Ordering", ~commands=["CancelOrder"])]))->toEqual(
       Error(Platform_BakedManifest.UnknownCommand({plugin: "Ordering", command: "CancelOrder"})),
     )
   )
@@ -169,7 +214,7 @@ describe("curate", () => {
   // The anti-drift assertion: include everything and the baked entry IS the
   // served entry. Any future divergence in the encoder shows up here first.
   testSync("an all-inclusive bake is byte-identical to the served entry", () => {
-    let baked = bake([{plugin: "Ordering", views: None, commands: None}])->firstEntry
+    let baked = bake([sel(~plugin="Ordering")])->firstEntry
     let served = Platform_ComponentDefinitionsApi.encodePluginStructureEntry(
       ~pluginId="Ordering@1.0.0",
       structure,
@@ -182,8 +227,8 @@ describe("curate", () => {
       Platform_BakedManifest.curate(
         ~structures=[("Ordering@1.0.0", structure), ("Catalog@1.0.0", structure)],
         ~selections=[
-          {plugin: "Catalog", views: Some([]), commands: Some([])},
-          {plugin: "Ordering", views: Some([]), commands: Some([])},
+          sel(~plugin="Catalog", ~views=[], ~commands=[]),
+          sel(~plugin="Ordering", ~views=[], ~commands=[]),
         ],
       )
     let ids =
@@ -208,7 +253,7 @@ describe("curate", () => {
   // makes this hold — the assertion guards that property, not a second code path.
   testSync("a curated entry carries the owner field the served entry carries", () => {
     let entry =
-      bake([{plugin: "Ordering", views: Some(["Orders"]), commands: Some(["PlaceOrder"])}])
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])
       ->firstEntry
     let ownerOf = (key, name) =>
       entry

package/tests/admin/Platform_BakedManifestTest.res.mjs

@@ -109,6 +109,15 @@ function bake(selections) {
   return Platform_BakedManifest$ReventlessCore.curate(structures, selections);
 }
 
+function sel(plugin, views, commands, derived) {
+  return {
+    plugin: plugin,
+    views: views,
+    commands: commands,
+    derived: derived
+  };
+}
+
 function entries(json) {
   return Stdlib_Option.getOr(Stdlib_JSON.Decode.array(json), []);
 }
@@ -127,11 +136,7 @@ function firstEntry(r) {
 
 globalThis.describe("curate", () => {
   globalThis.test("selects exactly the named components", () => {
-    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: ["Orders"],
-        commands: ["PlaceOrder"]
-      }]));
+    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", ["Orders"], ["PlaceOrder"], undefined)]));
     globalThis.expect([
       names(entry, "stateViewSlices"),
       names(entry, "readModels")
@@ -141,18 +146,15 @@ globalThis.describe("curate", () => {
     ]);
   });
   globalThis.test("drops a write side whose commands were all excluded", () => {
-    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: [],
-        commands: ["PlaceOrder"]
-      }]));
+    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", [], ["PlaceOrder"], undefined)]));
     globalThis.expect(names(entry, "stateChangeSlices")).toEqual(["PlaceOrder"]);
   });
   globalThis.test("unset views and commands include every public component", () => {
     let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
         plugin: "Ordering",
         views: undefined,
-        commands: undefined
+        commands: undefined,
+        derived: undefined
       }]));
     globalThis.expect([
       names(entry, "readModels"),
@@ -168,27 +170,49 @@ globalThis.describe("curate", () => {
     ]);
   });
   globalThis.test("carries an Internal view referenced by an included command", () => {
-    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: ["Orders"],
-        commands: ["PlaceOrder"]
-      }]));
+    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", ["Orders"], ["PlaceOrder"], undefined)]));
     globalThis.expect(names(entry, "internalQueryables")).toEqual(["AvailableProducts"]);
   });
   globalThis.test("omits an Internal view no included command references", () => {
-    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: ["Orders"],
-        commands: ["ImportOrders"]
-      }]));
+    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", ["Orders"], ["ImportOrders"], undefined)]));
     globalThis.expect(names(entry, "internalQueryables")).toEqual([]);
   });
-  globalThis.test("an Internal view is never selectable as a view", () => {
-    globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [{
+  let derivedOf = entry => Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(entry), d => d["derivedPages"]), v => Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(v), []), Stdlib_JSON.Decode.string));
+  globalThis.test("unset derived says nothing, leaving every kind to the shell", () => {
+    globalThis.expect(derivedOf(firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
         plugin: "Ordering",
-        views: ["AvailableProducts"],
-        commands: undefined
-      }])).toEqual({
+        views: undefined,
+        commands: undefined,
+        derived: undefined
+      }])))).toEqual(undefined);
+  });
+  globalThis.test("an empty derived list is carried, and is not the same as unset", () => {
+    globalThis.expect(derivedOf(firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", undefined, undefined, [])])))).toEqual([]);
+  });
+  globalThis.test("carries exactly the derived kinds named", () => {
+    globalThis.expect(derivedOf(firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", undefined, undefined, [
+        "lifecycles",
+        "canvas"
+      ])])))).toEqual([
+      "lifecycles",
+      "canvas"
+    ]);
+  });
+  globalThis.test("fails naming a derived kind outside the vocabulary", () => {
+    globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", undefined, undefined, ["dashboards"])])).toEqual({
+      TAG: "Error",
+      _0: {
+        TAG: "UnknownDerived",
+        plugin: "Ordering",
+        kind: "dashboards"
+      }
+    });
+  });
+  globalThis.test("accepts a kind this plugin generates no page for", () => {
+    globalThis.expect(derivedOf(firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", undefined, undefined, ["scheduler"])])))).toEqual(["scheduler"]);
+  });
+  globalThis.test("an Internal view is never selectable as a view", () => {
+    globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", ["AvailableProducts"], undefined, undefined)])).toEqual({
       TAG: "Error",
       _0: {
         TAG: "UnknownView",
@@ -201,7 +225,8 @@ globalThis.describe("curate", () => {
     globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [{
         plugin: "Shipping",
         views: undefined,
-        commands: undefined
+        commands: undefined,
+        derived: undefined
       }])).toEqual({
       TAG: "Error",
       _0: {
@@ -211,11 +236,7 @@ globalThis.describe("curate", () => {
     });
   });
   globalThis.test("fails naming an unknown command", () => {
-    globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: undefined,
-        commands: ["CancelOrder"]
-      }])).toEqual({
+    globalThis.expect(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", undefined, ["CancelOrder"], undefined)])).toEqual({
       TAG: "Error",
       _0: {
         TAG: "UnknownCommand",
@@ -228,9 +249,10 @@ globalThis.describe("curate", () => {
     let baked = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
         plugin: "Ordering",
         views: undefined,
-        commands: undefined
+        commands: undefined,
+        derived: undefined
       }]));
-    let served = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering@1.0.0", structure);
+    let served = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering@1.0.0", undefined, structure);
     globalThis.expect(JSON.stringify(baked)).toEqual(JSON.stringify(served));
   });
   globalThis.test("one entry per selection, in declaration order", () => {
@@ -244,16 +266,8 @@ globalThis.describe("curate", () => {
         structure
       ]
     ], [
-      {
-        plugin: "Catalog",
-        views: [],
-        commands: []
-      },
-      {
-        plugin: "Ordering",
-        views: [],
-        commands: []
-      }
+      sel("Catalog", [], [], undefined),
+      sel("Ordering", [], [], undefined)
     ]);
     let ids;
     ids = json.TAG === "Ok" ? Stdlib_Array.filterMap(entries(json._0), e => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(e), d => d["pluginId"]), Stdlib_JSON.Decode.string)) : [];
@@ -263,11 +277,7 @@ globalThis.describe("curate", () => {
     ]);
   });
   globalThis.test("a curated entry carries the owner field the served entry carries", () => {
-    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [{
-        plugin: "Ordering",
-        views: ["Orders"],
-        commands: ["PlaceOrder"]
-      }]));
+    let entry = firstEntry(Platform_BakedManifest$ReventlessCore.curate(structures, [sel("Ordering", ["Orders"], ["PlaceOrder"], undefined)]));
     let ownerOf = (key, name) => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(entry), d => d[key]), Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.object).find(d => Primitive_object.equal(Stdlib_Option.flatMap(d["name"], Stdlib_JSON.Decode.string), name)), d => d["ownerField"]), Stdlib_JSON.Decode.string);
     let commandOwner = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Array.filterMap(Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(entry), d => d["stateChangeSlices"]), Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.object).flatMap(w => Stdlib_Option.getOr(Stdlib_Option.flatMap(w["commands"], Stdlib_JSON.Decode.array), [])), Stdlib_JSON.Decode.object)[0], d => d["ownerField"]), Stdlib_JSON.Decode.string);
     globalThis.expect([
@@ -287,6 +297,7 @@ export {
   structure,
   structures,
   bake,
+  sel,
   entries,
   names,
   firstEntry,

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -147,7 +147,7 @@ let structure = {
   requiredStoreDeclarations: undefined
 };
 
-let encoded = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", structure);
+let encoded = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, structure);
 
 let json = JSON.stringify(encoded);
 
@@ -255,7 +255,7 @@ globalThis.describe("translation-slice externalSystem round-trip", () => {
     requiredStores: undefined,
     requiredStoreDeclarations: undefined
   };
-  let externalJson = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", externalStructure));
+  let externalJson = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, externalStructure));
   globalThis.test("surfaces Some outbound externalSystem as its inner string", () => {
     globalThis.expect(externalJson.includes("\"externalSystem\":\"ShipperGateway\"")).toEqual(true);
   });
@@ -341,7 +341,7 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     requiredStores: undefined,
     requiredStoreDeclarations: undefined
   };
-  let mixedEntry = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering", mixed);
+  let mixedEntry = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering", undefined, mixed);
   let namesAt = (entry, key) => Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(entry), o => o[key]), Stdlib_JSON.Decode.array), []), c => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(c), o => o["name"]), Stdlib_JSON.Decode.string));
   globalThis.test("excludes an Internal queryableDef from the encoded read-side", () => {
     globalThis.expect(namesAt(mixedEntry, "readModels")).toEqual(["Products"]);
@@ -357,7 +357,7 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     ]);
   });
   globalThis.test("encodes internalQueryables as [] for an all-Public entry, not a missing key", () => {
-    let entry = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering", {
+    let entry = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering", undefined, {
       readModels: [qbl],
       stateViewSlices: [],
       stateChangeSlices: structure_stateChangeSlices,
@@ -459,7 +459,7 @@ globalThis.describe("allowedStates + statusField populated", () => {
     requiredStores: undefined,
     requiredStoreDeclarations: undefined
   };
-  let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Platform", structureWithStates));
+  let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Platform", undefined, structureWithStates));
   globalThis.test("encodes populated allowedStates as a JSON array", () => {
     globalThis.expect(json.includes("\"allowedStates\":[\"Inactive\"]")).toEqual(true);
   });
@@ -481,7 +481,7 @@ globalThis.describe("singleQueryField reaches the caller", () => {
     globalThis.expect(json.includes("\"singleQueryField\":\"Catalog_Product\"")).toEqual(true);
   });
   globalThis.test("encodes an unstated singular as null", () => {
-    let unstated = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", {
+    let unstated = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, {
       readModels: [{
           name: "Products",
           queryField: "Catalog_Products",
@@ -526,7 +526,7 @@ globalThis.describe("idField / idFieldSource reach the caller", () => {
     globalThis.expect(json.includes("\"idFieldSource\":\"convention\"")).toEqual(true);
   });
   globalThis.test("encodes an unresolved key as null on both fields", () => {
-    let unresolved = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", {
+    let unresolved = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, {
       readModels: [{
           name: "Products",
           queryField: "Catalog_Products",

package/tests/dcb/DcbEventLogSchemaTest.res

@@ -0,0 +1,77 @@
+// What a DCB event log tells its readers it carries.
+//
+// A plugin's slices all append to ONE log, but each slice declares only its own
+// events. The log's schema entry used to be the first slice's schema, taken as
+// representative — and every reader of that entry believed it: the upload
+// claimer granted and untagged refs for one slice's events, and MCP described
+// the log's history as carrying that slice's event types and no others. Nothing
+// failed; the rest was simply invisible, which for the claimer means objects
+// that keep their pending tag and expire while an event references them.
+//
+// So the assertions here are about completeness, and about the shape that
+// completeness has to arrive in: readers walk exactly one level, `Union` →
+// per-variant `Object` with a `TAG`, so a union of unions would be as blind as
+// the single schema it replaced while looking like it covered everything.
+
+open JestGlobals
+
+let variant = (~tag: string, fields: array<(string, S.t<unknown>)>): S.t<unknown> =>
+  S.object(s => {
+    let _ = s.field("TAG", S.literal(tag)->S.castToUnknown)
+    fields->Array.forEach(((name, schema)) => {
+      let _ = s.field(name, schema)
+    })
+    ()
+  })->S.castToUnknown
+
+let ref_ = (~store: string) => Reventless.StorageRef.forStore(~store)->S.castToUnknown
+
+let addCategory = S.union([
+  variant(~tag="CategoryAdded", [("imageUrl", ref_(~store="categoryImages"))]),
+])->S.castToUnknown
+
+let addProduct = S.union([
+  variant(~tag="ProductAdded", [("imageUrl", ref_(~store="productImages"))]),
+])->S.castToUnknown
+
+let renameCategory = S.union([
+  variant(~tag="CategoryRenamed", [("name", S.string->S.castToUnknown)]),
+])->S.castToUnknown
+
+describe("Dcb_Builder.mergedEventSchema", () => {
+  testSync("carries every slice's event types, not the first slice's", () => {
+    let merged = [addCategory, addProduct, renameCategory]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual([
+      "CategoryAdded",
+      "ProductAdded",
+      "CategoryRenamed",
+    ])
+  })
+
+  // The claimer's whole input. One slice short here is a store's objects
+  // expiring under a live reference.
+  testSync("surfaces the ref fields of every slice that declares one", () => {
+    let merged = [addCategory, addProduct, renameCategory]->Dcb_Builder.mergedEventSchema
+    expect(
+      StorageRefFields.fromEventSchema(~plugin="Catalog", merged)->Array.map(e => (
+        e.eventType,
+        e.fields->Array.map(f => f.store),
+      )),
+    )->toEqual([
+      ("CategoryAdded", ["Catalog.categoryImages"]),
+      ("ProductAdded", ["Catalog.productImages"]),
+    ])
+  })
+
+  // Two slices producing the same event would otherwise hand sury two arms
+  // under one discriminant, and every reader a duplicate.
+  testSync("keeps one arm per event type", () => {
+    let merged = [addProduct, addProduct]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual(["ProductAdded"])
+  })
+
+  testSync("leaves a lone slice's schema as it is", () => {
+    let merged = [addProduct]->Dcb_Builder.mergedEventSchema
+    expect(Reventless.DcbTag.extractVariantNames(merged))->toEqual(["ProductAdded"])
+  })
+})

package/tests/dcb/DcbEventLogSchemaTest.res.mjs

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as Dcb_Builder$ReventlessCore from "../../src/components/Dcb/Dcb_Builder.res.mjs";
+import * as StorageRefFields$ReventlessCore from "../../src/components/Api/StorageRefFields.res.mjs";
+
+function variant(tag, fields) {
+  return S.object(s => {
+    s.f("TAG", S.literal(tag));
+    fields.forEach(param => {
+      s.f(param[0], param[1]);
+    });
+  });
+}
+
+function ref_(store) {
+  return StorageRef$Reventless.forStore(undefined, store);
+}
+
+let addCategory = S.union([variant("CategoryAdded", [[
+      "imageUrl",
+      StorageRef$Reventless.forStore(undefined, "categoryImages")
+    ]])]);
+
+let addProduct = S.union([variant("ProductAdded", [[
+      "imageUrl",
+      StorageRef$Reventless.forStore(undefined, "productImages")
+    ]])]);
+
+let renameCategory = S.union([variant("CategoryRenamed", [[
+      "name",
+      S.string
+    ]])]);
+
+globalThis.describe("Dcb_Builder.mergedEventSchema", () => {
+  globalThis.test("carries every slice's event types, not the first slice's", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addCategory,
+      addProduct,
+      renameCategory
+    ]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual([
+      "CategoryAdded",
+      "ProductAdded",
+      "CategoryRenamed"
+    ]);
+  });
+  globalThis.test("surfaces the ref fields of every slice that declares one", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addCategory,
+      addProduct,
+      renameCategory
+    ]);
+    globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", merged).map(e => [
+      e.eventType,
+      e.fields.map(f => f.store)
+    ])).toEqual([
+      [
+        "CategoryAdded",
+        ["Catalog.categoryImages"]
+      ],
+      [
+        "ProductAdded",
+        ["Catalog.productImages"]
+      ]
+    ]);
+  });
+  globalThis.test("keeps one arm per event type", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([
+      addProduct,
+      addProduct
+    ]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual(["ProductAdded"]);
+  });
+  globalThis.test("leaves a lone slice's schema as it is", () => {
+    let merged = Dcb_Builder$ReventlessCore.mergedEventSchema([addProduct]);
+    globalThis.expect(DcbTag$Reventless.extractVariantNames(merged)).toEqual(["ProductAdded"]);
+  });
+});
+
+export {
+  variant,
+  ref_,
+  addCategory,
+  addProduct,
+  renameCategory,
+}
+/* addCategory Not a pure module */

package/tests/plugin/PluginStructureAccessTest.res.mjs

@@ -120,7 +120,7 @@ globalThis.describe("requiredAccess derived from the authorization rule", () =>
     globalThis.expect(viewNamed("Orders")).toEqual(undefined);
   });
   globalThis.test("nothing to require encodes as null, not an empty list", () => {
-    let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("AccessPlugin", structure));
+    let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("AccessPlugin", undefined, structure));
     globalThis.expect([
       json.includes(`"requiredAccess":null`),
       json.includes(`"requiredAccess":["Admin","Ops"]`),