@reventlessdev/reventless-spec 3.0.0-alpha.67 → 3.0.0-alpha.69

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.69 (2026-07-08)
+
+### Features
+
+* **reventless-core:** classify plugins by kind in the lifecycle read model ([64e3f22](https://github.com/ReventlessDev/reventless-core/commit/64e3f22b8114a771886b7c8ec023e95971413c0b))
+
+
+# 3.0.0-alpha.68 (2026-07-07)
+
+### Bug Fixes
+
+* **reventless-aws:** thread inferred DCB scope into the deployed command handler ([4d8327f](https://github.com/ReventlessDev/reventless-core/commit/4d8327fad8659a1cde8c36098c72392737437af1))
+
+
 # 3.0.0-alpha.67 (2026-07-06)
 
 **Note:** Version bump only for package @reventlessdev/reventless-spec

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.67",
+  "version": "3.0.0-alpha.69",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbTag.res

@@ -989,6 +989,74 @@ let sliceShapeFromSchemas = (
   }
 }
 
+/** One slice's sury schemas — the input to `deriveEffectiveScope`. */
+type sliceSchemas = {
+  name: string,
+  commandSchema: S.t<unknown>,
+  consumedEventSchema: S.t<unknown>,
+  eventSchema: S.t<unknown>,
+}
+
+/**
+The DCB decision-read scope threaded into every StateChangeSlice callback:
+- `crossPartitionTagKeys` — keys whose scalar command tag must be fanned into its
+  own single-tag clause (a cross-entity reference read), and
+- `tagKeysByEventType` — each produced event type's *indexed* tag keys, so a
+  decision query drops vacuous (type, tag) clause combinations.
+*/
+type effectiveScope = {
+  crossPartitionTagKeys: array<string>,
+  tagKeysByEventType: dict<array<string>>,
+}
+
+/**
+Derives the effective DCB decision-read scope for one consistency boundary from
+its slices' schemas.
+
+Prefers the slice-graph inference (`DcbScopeInference.infer`) and falls back to
+the `@crossPartition` / tag *annotations* only when a slice's partition is
+ambiguous — all-or-nothing, matching `Dcb_Builder`. This is the **single source of
+truth** shared by the deploy-time builder (`Dcb_Builder.res`) and the deployed
+command-handler entry point (`DcbCommandTopicEntryPoint.mjs`): both call this so
+the runtime decision query cannot diverge from the storage/GSI scope. Before this
+existed the entry point re-derived scope from annotations alone, silently dropping
+inferred cross-partition reference reads — see
+`docs/analysis/dcb-runtime-scope-annotation-drift.md`.
+*/
+let deriveEffectiveScope = (slices: array<sliceSchemas>): effectiveScope => {
+  let producedSchemas = slices->Array.map(s => s.eventSchema)
+  let annotatedCross = {
+    let seen = Set.make()
+    producedSchemas
+    ->Array.flatMap(extractCrossPartitionTagKeys)
+    ->Array.filter(k =>
+      if seen->Set.has(k) {
+        false
+      } else {
+        seen->Set.add(k)
+        true
+      }
+    )
+  }
+  let annotatedTagKeys =
+    producedSchemas->Array.map(extractTagKeysByEventType)->mergeTagKeysByEventType
+  let shapes =
+    slices->Array.map(s =>
+      sliceShapeFromSchemas(
+        ~name=s.name,
+        ~commandSchema=s.commandSchema,
+        ~consumedEventSchema=s.consumedEventSchema,
+        ~eventSchema=s.eventSchema,
+      )
+    )
+  let inferred = DcbScopeInference.infer(shapes)
+  let useInferred = inferred.ambiguities->Array.length == 0
+  {
+    crossPartitionTagKeys: useInferred ? inferred.crossPartitionTagKeys : annotatedCross,
+    tagKeysByEventType: useInferred ? inferred.tagKeysByEventType : annotatedTagKeys,
+  }
+}
+
 /**
 Checks whether any single variant in a schema has multiple tagged fields.
 If so, a partition tag annotation is needed to disambiguate.

package/src/components/DcbTag.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbScopeInference$Reventless from "./DcbScopeInference.res.mjs";
 
 let tagSchema = S.schema(s => ({
   key: s.m(S.string),
@@ -618,6 +619,27 @@ function sliceShapeFromSchemas(name, commandSchema, consumedEventSchema, eventSc
   };
 }
 
+function deriveEffectiveScope(slices) {
+  let producedSchemas = slices.map(s => s.eventSchema);
+  let seen = new Set();
+  let annotatedCross = producedSchemas.flatMap(extractCrossPartitionTagKeys).filter(k => {
+    if (seen.has(k)) {
+      return false;
+    } else {
+      seen.add(k);
+      return true;
+    }
+  });
+  let annotatedTagKeys = mergeTagKeysByEventType(producedSchemas.map(extractTagKeysByEventType));
+  let shapes = slices.map(s => sliceShapeFromSchemas(s.name, s.commandSchema, s.consumedEventSchema, s.eventSchema));
+  let inferred = DcbScopeInference$Reventless.infer(shapes);
+  let useInferred = inferred.ambiguities.length === 0;
+  return {
+    crossPartitionTagKeys: useInferred ? inferred.crossPartitionTagKeys : annotatedCross,
+    tagKeysByEventType: useInferred ? inferred.tagKeysByEventType : annotatedTagKeys
+  };
+}
+
 function hasMultiTagVariant(schema) {
   switch (schema.type) {
     case "object" :
@@ -866,6 +888,7 @@ export {
   eventShapesOfSchema,
   extractPartitionTagFields,
   sliceShapeFromSchemas,
+  deriveEffectiveScope,
   hasMultiTagVariant,
   findMultiTagVariantNames,
   extractCompositePartitionFieldsFromProperties,

package/src/components/Plugin.res

@@ -6,6 +6,23 @@ type name = string
 @schema
 type version = string
 
+/**
+Classifies the business role of a plugin, carried on `pluginDefinition` so the
+plugin-lifecycle read model can segregate infrastructure/commercial/marketplace
+plugins from domain plugins in the admin Plugins view. Absent (on definitions
+persisted before this field existed) is read as `Domain`.
+
+Canonical here in `reventless-spec` because `pluginDefinition` (a `@schema` type
+nested in the lifecycle Message union) needs the sury schema; `ReventlessCore.Plugin_BuiltHook`
+re-exports this same type for its deploy-time metadata registry.
+*/
+@schema
+type pluginKind =
+  | Domain
+  | PlatformInfrastructure
+  | Commercial
+  | Marketplace
+
 /**
 Describes an extension point exported by a plugin.
 Included in the plugin's `pluginDefinition` for use by the gateway / host.
@@ -373,5 +390,10 @@ type pluginDefinition = {
   // subscriptions from this plugin's DCB topic → peer EventCollectors.
   // None for plugins without a DCB EventLog.
   dcbEventLog: @s.matches(dcbEventLogOptionSchema) option<dcbEventLogDefinition>,
+  // Business role of this plugin. Mandatory: `Domain` is the default kind, resolved once
+  // at the deploy-metadata → definition boundary (Plugin_Builder). PlatformInfrastructure
+  // plugins are segregated out of the admin Plugins list. Payload-less variant → serialises
+  // as a bare JSON string, so it is JSON-safe inside the lifecycle Message union without js_nullable.
+  kind: pluginKind,
 }
 

package/src/components/Plugin.res.mjs

@@ -3,6 +3,13 @@
 import * as S from "sury/src/S.res.mjs";
 import * as SuryResMjs from "sury/src/Sury.res.mjs";
 
+let pluginKindSchema = S.union([
+  S.literal("Domain"),
+  S.literal("PlatformInfrastructure"),
+  S.literal("Commercial"),
+  S.literal("Marketplace")
+]);
+
 let extensionPointDefinitionSchema = S.schema(s => ({
   name: s.m(S.string),
   commandTopic: s.m(S.string),
@@ -204,7 +211,8 @@ let pluginDefinitionSchema = S.schema(s => ({
   apiTarget: s.m(stringOptionSchema),
   uiFragments: s.m(uiFragmentManifestOptionSchema),
   structure: s.m(pluginStructureOptionSchema),
-  dcbEventLog: s.m(dcbEventLogOptionSchema)
+  dcbEventLog: s.m(dcbEventLogOptionSchema),
+  kind: s.m(pluginKindSchema)
 }));
 
 let nameSchema = S.string;
@@ -214,6 +222,7 @@ let versionSchema = S.string;
 export {
   nameSchema,
   versionSchema,
+  pluginKindSchema,
   extensionPointDefinitionSchema,
   extensionDefinitionSchema,
   dcbEventLogDefinitionSchema,
@@ -248,4 +257,4 @@ export {
   platformEventGraphSchema,
   pluginDefinitionSchema,
 }
-/* extensionPointDefinitionSchema Not a pure module */
+/* pluginKindSchema Not a pure module */