@reventlessdev/reventless-local 3.0.0-alpha.301 → 3.0.0-alpha.302

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.302 (2026-10-29)
+
+### Bug Fixes
+
+* **local:** emit-capabilities writes an empty manifest for a plugin with no parts yet ([56586a6](https://github.com/ReventlessDev/reventless-core/commit/56586a687aa4658e2357c836878b44050b424d41))
+* refactor!: drop `dcbSources`, the cross-plugin DCB subscription nobody declared ([cf3b66d](https://github.com/ReventlessDev/reventless-core/commit/cf3b66d8c1b5d87673197b64eaee174598bb8253))
+* refactor!: a read model hears another plugin only through an Extension and a slice ([15c7cae](https://github.com/ReventlessDev/reventless-core/commit/15c7cae214d5aa04404779fcd87a8429aad1965c))
+### Features
+
+* **core:** a handler drops a command it has already handled ([605862b](https://github.com/ReventlessDev/reventless-core/commit/605862bba765b1501eb19d08f3924bf619159e21))
+
+### BREAKING CHANGES
+
+* `Reventless.Plugin.extensionDefinition` has no `dcbSources`
+field, and `Platform_PluginExtensions.dcbSources` is gone from the GraphQL
+schema. A query that selects it fails as a whole; drop the selection.
+* `ReventlessInfra.Extension.T.make` and the core
+`Extension_Builder.make` no longer take `~readModelNamesForSourceName` and
+`~publishToReadModels`. Both arguments did nothing; drop them at the call site.
+
+
+
 # 3.0.0-alpha.301 (2026-10-25)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.301",
+  "version": "3.0.0-alpha.302",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -37,16 +37,16 @@
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
     "@reventlessdev/rescript-node": "2.0.0-alpha.23",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.310",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.258",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.158",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.207",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.311",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.259",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.208",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.175",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.38",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.174",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.178"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.179",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.159"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/EmitCapabilities.res

@@ -25,9 +25,19 @@
 
 type platform
 type localPlatformExports = {"Make": unit => platform}
-type builtPlugin = {"pluginStructure": Reventless.Plugin.pluginStructure}
+// A plugin with no parts yet has no structure: `generate-plugin` leaves `pluginStructure` out of
+// its composition root.
+type builtPlugin = {"pluginStructure": Nullable.t<Reventless.Plugin.pluginStructure>}
 type compositionExports = {"Make": platform => builtPlugin}
 
+/** The manifest's text for a plugin's structure. A plugin with no parts yet has none and
+    declares nothing: its manifest says so, as one for a structure with no declarations does. */
+let manifestText = (structure: option<Reventless.Plugin.pluginStructure>): string =>
+  switch structure {
+  | Some(structure) => Reventless.CapabilityManifest.renderForStructure(structure)
+  | None => Reventless.CapabilityManifest.render({capabilities: []})
+  }
+
 // ── Which module holds the composition root ──────────────────────────────────
 
 /** `Plugin.res.mjs` is what `generate-plugin` emits, so it is the default and
@@ -99,10 +109,7 @@ let main = () =>
     let built = composition["Make"](platform)
 
     let manifestPath = NodePath.join([srcDir, "capabilities.json"])
-    NodeFs.writeFileSync(
-      manifestPath,
-      Reventless.CapabilityManifest.renderForStructure(built["pluginStructure"]),
-    )
+    NodeFs.writeFileSync(manifestPath, manifestText(built["pluginStructure"]->Nullable.toOption))
     Console.log("Generated: " ++ manifestPath)
 
     // Applying the platform functor wires in-process infrastructure; exit

package/src/EmitCapabilities.res.mjs

@@ -4,9 +4,20 @@ import * as Nodefs from "node:fs";
 import * as Nodeurl from "node:url";
 import * as Nodepath from "node:path";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as CliArgs$Reventless from "@reventlessdev/reventless-spec/src/CliArgs.res.mjs";
 import * as CapabilityManifest$Reventless from "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs";
 
+function manifestText(structure) {
+  if (structure !== undefined) {
+    return CapabilityManifest$Reventless.renderForStructure(structure);
+  } else {
+    return CapabilityManifest$Reventless.render({
+      capabilities: []
+    });
+  }
+}
+
 function compositionModulePath(srcDir, moduleArg) {
   let withExtension = name => {
     if (name.endsWith(".mjs")) {
@@ -84,13 +95,14 @@ function main() {
     let composition = await import(Nodeurl.pathToFileURL(modulePath).href);
     let built = composition.Make(platform);
     let manifestPath = Nodepath.join(srcDir, "capabilities.json");
-    Nodefs.writeFileSync(manifestPath, CapabilityManifest$Reventless.renderForStructure(built.pluginStructure), "utf8");
+    Nodefs.writeFileSync(manifestPath, manifestText(Primitive_option.fromNullable(built.pluginStructure)), "utf8");
     console.log("Generated: " + manifestPath);
     process.exit(0);
   });
 }
 
 export {
+  manifestText,
   compositionModulePath,
   fail,
   usage,

package/src/Platform.res

@@ -1255,7 +1255,6 @@ module MakeWithConfig = (
               ((_, ext: ReventlessInfra.Extension.outputs)) => {
                 Reventless.Plugin.name: ext.name,
                 extensionPointName: ext.extensionPointName,
-                dcbSources: [],
               },
             ),
             extensionProtocols: [],

package/src/Platform.res.mjs

@@ -1063,8 +1063,7 @@ function MakeWithConfig(Config) {
             let ext = param[1];
             return {
               name: ext.name,
-              extensionPointName: ext.extensionPointName,
-              dcbSources: []
+              extensionPointName: ext.extensionPointName
             };
           }),
           eventCollector: param[2].name,
@@ -2858,8 +2857,7 @@ function Make($star) {
             let ext = param[1];
             return {
               name: ext.name,
-              extensionPointName: ext.extensionPointName,
-              dcbSources: []
+              extensionPointName: ext.extensionPointName
             };
           }),
           eventCollector: param[2].name,

package/tests/EmitCapabilitiesTest.res

@@ -19,6 +19,12 @@ describe("EmitCapabilities.parseArgs", () => {
   )
 })
 
+describe("EmitCapabilities.manifestText", () => {
+  testSync("a plugin with no parts yet declares nothing", () =>
+    expect(EmitCapabilities.manifestText(None))->toBe(`{\n  "capabilities": []\n}\n`)
+  )
+})
+
 describe("emit-capabilities on the command line", () => {
   module CliArgs = Reventless.CliArgs
   let usage = EmitCapabilities.usage->String.trim

package/tests/EmitCapabilitiesTest.res.mjs

@@ -30,6 +30,12 @@ globalThis.describe("EmitCapabilities.parseArgs", () => {
   });
 });
 
+globalThis.describe("EmitCapabilities.manifestText", () => {
+  globalThis.test("a plugin with no parts yet declares nothing", () => {
+    globalThis.expect(EmitCapabilities$ReventlessLocal.manifestText(undefined)).toBe(`{\n  "capabilities": []\n}\n`);
+  });
+});
+
 globalThis.describe("emit-capabilities on the command line", () => {
   let usage = EmitCapabilities$ReventlessLocal.usage.trim();
   globalThis.test("--help anywhere prints the usage to stdout and exits 0", async () => {

package/tests/components/dcb/DcbRepeatTest.res

@@ -0,0 +1,291 @@
+// Another plugin's fact arrives through an Extension and a slice, and delivery is
+// at-least-once. The slice here has no check of its own — every RecordDemand
+// appends — so what keeps a redelivered ItemOrdered from counting twice is the
+// framework: the Extension's command carries a stable id, and the handler drops a
+// command the partition already holds events for. On both local backends, and
+// for two concurrent copies.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+module Message = ReventlessCore.Message
+
+// ─── The provider's extension point and the consumer's slice ────────────────
+
+module Port = {
+  let name = "Ordering.Orders"
+
+  @schema
+  type command = Noop
+
+  @schema
+  type event = ItemOrdered({productId: string, orderId: string})
+
+  @schema
+  type directive = NoDirective
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+module DemandSlice = {
+  let name = "RecordDemandNoCheck"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  // The produced event joins a product and an order, so the partition is
+  // declared, as the shop's RecordProductDemand does.
+  @schema
+  type event =
+    DemandRecorded({productId: @s.matches(Reventless.DcbTag.partition) string, orderId: string})
+
+  @schema
+  type consumedEvent =
+    DemandRecorded({productId: @s.matches(Reventless.DcbTag.string) string, orderId: string})
+
+  @schema
+  type command =
+    RecordDemand({productId: @s.matches(Reventless.DcbTag.string) string, orderId: string})
+
+  @schema
+  type error = Never
+
+  type role = Reventless.Role.name
+  let authorizationOf = (_: string): Reventless.Authorization.rule<role> => AllowAuthenticated
+  type lifecycleState = unit
+  let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
+  let traits: array<Reventless.Trait.t> = []
+}
+
+module DemandDecision = {
+  type state = {orders: array<string>}
+  let initialState = {orders: []}
+  let moduleUrl = DemandSlice.moduleUrl
+
+  let evolve = (state, event: DemandSlice.consumedEvent) =>
+    switch event {
+    | DemandRecorded({orderId}) => {orders: state.orders->Array.concat([orderId])}
+    }
+
+  // Deliberately no "already counted" rule.
+  let decide = (_state, command: DemandSlice.command): result<
+    array<DemandSlice.event>,
+    DemandSlice.error,
+  > =>
+    switch command {
+    | RecordDemand({productId, orderId}) => Ok([DemandRecorded({productId, orderId})])
+    }
+}
+
+module DemandHandler = ReventlessCore.StateChangeSlice_Callback.Make(DemandSlice, DemandDecision)
+
+let partitionTag = Reventless.DcbTag.Simple({key: "productId"})
+
+// The consumer's Extension, as the catalog's Orders_Extension is written.
+module DemandExtension = ReventlessInfra.ExtensionMapping.Make({
+  module ExtensionPoint = Port
+  module Delegate = DemandSlice
+  let moduleUrl: string = %raw(`import.meta.url`)
+  let delegateModuleUrl = DemandSlice.moduleUrl
+  let mapIncomingEvent = (_id, event: Port.event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ItemOrdered({productId, orderId}) => [
+        ReventlessInfra.ExtensionMapping.PublishStateChangeSliceCommand(
+          DemandSlice.RecordDemand({productId, orderId}),
+        ),
+      ]
+    }
+  let mapOutgoingEvent = None
+  let handledEvents = []
+  let issuedCommands = []
+})
+
+let queryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+let pluginDefinition: Reventless.Plugin.pluginDefinition = {
+  id: "Catalog@1",
+  name: "Catalog",
+  version: "1",
+  extensionPoints: [],
+  extensions: [{name: "Catalog", extensionPointName: Port.name}],
+  eventCollector: "eventCollector",
+  extensionProtocols: [],
+  apiSchemaFragment: None,
+  structure: None,
+  kind: Domain,
+}
+
+// One published ItemOrdered, as the extension point stored and published it;
+// every delivery of it carries this same envelope.
+let published: Message.event'<string, Port.event> = {
+  id: "order-1",
+  meta: {
+    service: Port.name,
+    time: "2024-01-01T00:00:00Z",
+    msgId: "item-ordered-msg",
+    correlationId: "place-order-cmd",
+    causationId: "order-placed-event",
+  },
+  event: ItemOrdered({productId: "product-1", orderId: "order-1"}),
+}
+
+// What the Extension sends for one delivery of `published`.
+let commandOf = (event': Message.event'<string, Port.event>) =>
+  switch DemandExtension.mapIncomingEvent(event', pluginDefinition, queryEngine) {
+  | [ReventlessInfra.ExtensionMapping.AbstractPublishAggregateCommand(_, cmdJson)] => cmdJson
+  | _ => JsError.throwWithMessage("expected one slice command")
+  }
+
+// ─── Backends ───────────────────────────────────────────────────────────────
+
+let eventLogOn = async (~name) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalDcbEventLogStorage.Make(Bus)
+  let s = Storage.make(~name, ~indexes=[], ~partitionTag, ~opts)
+  let storage = await s.operations->TestRunner.resolve
+  module Log = ReventlessCore.DcbEventLog_Operations.Make({
+    let name = name
+    let serviceName = name
+    let storage = storage
+    let publishJson = async (_, _, _) => ()
+  })
+  let eventLog: ReventlessCore.DcbEventLog.operations = {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream,
+  }
+  eventLog
+}
+
+let runUnderMemory = async fn => {
+  BackendState.setMemory()
+  await fn()
+}
+
+let runUnderSqlite = async fn => {
+  let db = SqliteDriver.openDb(~path=":memory:")
+  BackendState.setSqlite(~db, ~path=":memory:")
+  await fn()
+  BackendState.setMemory()
+  db->SqliteDriver.close
+}
+
+let deliver = (eventLog, cmd: Message.commandJson) =>
+  DemandHandler.handleCommands(
+    ~partitionTag,
+    eventLog,
+    Stream.fromIterable([
+      {
+        ReventlessInfra.CommandTopic.command: cmd
+        ->ReventlessCore.CommandTopic_Helpers.encodeCommandJson
+        ->Message.decodeCommand'(Reventless.Id.String.schema, DemandSlice.commandSchema),
+        reference: cmd.meta.msgId,
+      },
+    ]),
+  )->Effect.runPromise
+
+let recordedDemands = async (eventLog: ReventlessCore.DcbEventLog.operations) =>
+  (await eventLog.read(~query=[{eventTypes: ["DemandRecorded"]}])).events
+
+let counter = ref(0)
+let fresh = prefix => {
+  counter := counter.contents + 1
+  `${prefix}-${counter.contents->Int.toString}`
+}
+
+let _ = beforeEach(() => DemandHandler.resetCache())
+
+let backends = [("in-memory", runUnderMemory), ("SQLite", runUnderSqlite)]
+
+backends->Array.forEach(((label, runUnder)) =>
+  describe(`a redelivered fact is recorded once (${label} backend)`, () => {
+    testPromise(
+      "the same published event delivered twice appends one event",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatOnce"))
+            let first = await deliver(log, commandOf(published))
+            let again = await deliver(log, commandOf(published))
+            expect(first->Array.length)->toBe(1)
+            expect(again)->toEqual(first) // accepted both times
+            let events = await recordedDemands(log)
+            expect(events->Array.length)->toBe(1)
+            // The command is the stored event's cause, and the published event the command's.
+            let cmd = commandOf(published)
+            expect((events->Array.getUnsafe(0)).meta.causationId)->toEqual(Some(cmd.meta.msgId))
+            expect(cmd.meta.causationId)->toEqual(Some(published.meta.msgId))
+          },
+        ),
+    )
+
+    testPromise(
+      "a different order for the same product still counts",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatOther"))
+            let _ = await deliver(log, commandOf(published))
+            let second: Message.event'<string, Port.event> = {
+              id: "order-2",
+              meta: {...published.meta, msgId: "item-ordered-msg-2"},
+              event: Port.ItemOrdered({productId: "product-1", orderId: "order-2"}),
+            }
+            let _ = await deliver(log, commandOf(second))
+            let _ = await deliver(log, commandOf(published))
+            let _ = await deliver(log, commandOf(second))
+            expect((await recordedDemands(log))->Array.length)->toBe(2)
+          },
+        ),
+    )
+
+    testPromise(
+      "a command with a random id is decided every time",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatRandom"))
+            let cmd = commandOf(published)
+            // The envelope of a command nobody derived: fresh id, no mark.
+            let plain = {...cmd, meta: Message.deriveMeta(~parent=cmd.meta)}
+            let _ = await deliver(log, plain)
+            let _ = await deliver(log, plain)
+            expect((await recordedDemands(log))->Array.length)->toBe(2)
+          },
+        ),
+    )
+
+    testPromise(
+      "two concurrent copies append one event",
+      async () =>
+        await runUnder(
+          async () => {
+            let log = await eventLogOn(~name=fresh("RepeatConcurrent"))
+            let cmd = commandOf(published)
+            // Both read an empty partition; the second append conflicts, re-reads,
+            // and finds the first one's event.
+            let (a, b) = await Promise.all2((deliver(log, cmd), deliver(log, cmd)))
+            expect(a->Array.length)->toBe(1)
+            expect(b->Array.length)->toBe(1)
+            expect(a->Array.getUnsafe(0)->Result.isOk && b->Array.getUnsafe(0)->Result.isOk)->toBe(
+              true,
+            )
+            expect((await recordedDemands(log))->Array.length)->toBe(1)
+          },
+        ),
+    )
+  })
+)

package/tests/components/dcb/DcbRepeatTest.res.mjs

@@ -0,0 +1,420 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as BackendState$ReventlessLocal from "../../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../../src/adapter/SqliteDriver.res.mjs";
+import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let name = "Ordering.Orders";
+
+let commandSchema = Sury.literal("Noop");
+
+let eventSchema = Sury.$schema(s => ({
+  TAG: "ItemOrdered",
+  productId: s.m(Sury.string),
+  orderId: s.m(Sury.string)
+}));
+
+let directiveSchema = Sury.literal("NoDirective");
+
+let moduleUrl = import.meta.url;
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let Port = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let name$1 = "RecordDemandNoCheck";
+
+let moduleUrl$1 = import.meta.url;
+
+let eventSchema$1 = Sury.$schema(s => ({
+  TAG: "DemandRecorded",
+  productId: s.m(DcbTag$Reventless.partition),
+  orderId: s.m(Sury.string)
+}));
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "DemandRecorded",
+  productId: s.m(DcbTag$Reventless.string),
+  orderId: s.m(Sury.string)
+}));
+
+let commandSchema$1 = Sury.$schema(s => ({
+  TAG: "RecordDemand",
+  productId: s.m(DcbTag$Reventless.string),
+  orderId: s.m(Sury.string)
+}));
+
+let errorSchema = Sury.literal("Never");
+
+function authorizationOf$1(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition$1(param) {
+  return "Unrestricted";
+}
+
+let traits$1 = [];
+
+let DemandSlice = {
+  name: name$1,
+  Id: undefined,
+  moduleUrl: moduleUrl$1,
+  eventSchema: eventSchema$1,
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema$1,
+  errorSchema: errorSchema,
+  authorizationOf: authorizationOf$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  orders: []
+};
+
+function evolve(state, event) {
+  return {
+    orders: state.orders.concat([event.orderId])
+  };
+}
+
+function decide(_state, command) {
+  return {
+    TAG: "Ok",
+    _0: [{
+        TAG: "DemandRecorded",
+        productId: command.productId,
+        orderId: command.orderId
+      }]
+  };
+}
+
+let DemandDecision = {
+  initialState: initialState,
+  moduleUrl: moduleUrl$1,
+  evolve: evolve,
+  decide: decide
+};
+
+let DemandHandler = StateChangeSlice_Callback$ReventlessCore.Make({
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema$1,
+  commandSchema: commandSchema$1,
+  authorizationOf: authorizationOf$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl$1
+});
+
+let partitionTag = {
+  TAG: "Simple",
+  _0: {
+    key: "productId"
+  }
+};
+
+let moduleUrl$2 = import.meta.url;
+
+function mapIncomingEvent(_id, event, _meta, _pluginDef, _queryEngine) {
+  return [{
+      TAG: "PublishStateChangeSliceCommand",
+      _0: {
+        TAG: "RecordDemand",
+        productId: event.productId,
+        orderId: event.orderId
+      }
+    }];
+}
+
+let handledEvents = [];
+
+let issuedCommands = [];
+
+let DemandExtension = ExtensionMapping$ReventlessInfra.Make({
+  ExtensionPoint: {
+    name: name,
+    moduleUrl: moduleUrl,
+    commandSchema: commandSchema,
+    eventSchema: eventSchema,
+    directiveSchema: directiveSchema
+  },
+  Delegate: {
+    Id: Id$Reventless.$$String,
+    name: name$1,
+    eventSchema: eventSchema$1,
+    errorSchema: errorSchema,
+    commandSchema: commandSchema$1,
+    moduleUrl: moduleUrl$1,
+    authorizationOf: authorizationOf$1,
+    commandTransition: commandTransition$1,
+    traits: traits$1
+  },
+  moduleUrl: moduleUrl$2,
+  delegateModuleUrl: moduleUrl$1,
+  mapIncomingEvent: mapIncomingEvent,
+  mapOutgoingEvent: undefined,
+  handledEvents: handledEvents,
+  issuedCommands: issuedCommands
+});
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let pluginDefinition = {
+  id: "Catalog@1",
+  name: "Catalog",
+  version: "1",
+  extensionPoints: [],
+  extensions: [{
+      name: "Catalog",
+      extensionPointName: name
+    }],
+  eventCollector: "eventCollector",
+  extensionProtocols: [],
+  apiSchemaFragment: undefined,
+  structure: undefined,
+  kind: "Domain"
+};
+
+let published_meta = {
+  service: name,
+  time: "2024-01-01T00:00:00Z",
+  msgId: "item-ordered-msg",
+  correlationId: "place-order-cmd",
+  causationId: "order-placed-event"
+};
+
+let published_event = {
+  TAG: "ItemOrdered",
+  productId: "product-1",
+  orderId: "order-1"
+};
+
+let published = {
+  id: "order-1",
+  meta: published_meta,
+  event: published_event
+};
+
+function commandOf(event$p) {
+  let match = DemandExtension.mapIncomingEvent(event$p, pluginDefinition, queryEngine);
+  if (match.length !== 1) {
+    return Stdlib_JsError.throwWithMessage("expected one slice command");
+  }
+  let match$1 = match[0];
+  if (match$1.TAG === "AbstractPublishAggregateCommand") {
+    return match$1._1;
+  } else {
+    return Stdlib_JsError.throwWithMessage("expected one slice command");
+  }
+}
+
+async function eventLogOn(name) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(Bus);
+  let s = Storage.make(name, [], partitionTag, undefined, opts);
+  let storage = await TestRunner$ReventlessLocal.resolve(s.operations);
+  let publishJson = async (param, param$1, param$2) => {};
+  let Log = DcbEventLog_Operations$ReventlessCore.Make({
+    name: name,
+    serviceName: name,
+    storage: storage,
+    publishJson: publishJson
+  });
+  return {
+    read: Log.read,
+    append: Log.append,
+    readStream: Log.readStream,
+    appendStream: Log.appendStream
+  };
+}
+
+async function runUnderMemory(fn) {
+  BackendState$ReventlessLocal.setMemory();
+  return await fn();
+}
+
+async function runUnderSqlite(fn) {
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+  await fn();
+  BackendState$ReventlessLocal.setMemory();
+  return SqliteDriver$ReventlessLocal.close(db);
+}
+
+function deliver(eventLog, cmd) {
+  return Effect.runPromise(DemandHandler.handleCommands(undefined, undefined, partitionTag, eventLog, Stream.fromIterable([{
+      command: Message$ReventlessCore.decodeCommand$p(CommandTopic_Helpers$ReventlessCore.encodeCommandJson(cmd), Id$Reventless.$$String.schema, commandSchema$1),
+      reference: cmd.meta.msgId
+    }])));
+}
+
+async function recordedDemands(eventLog) {
+  return (await eventLog.read([{
+      eventTypes: ["DemandRecorded"]
+    }], undefined)).events;
+}
+
+let counter = {
+  contents: 0
+};
+
+function fresh(prefix) {
+  counter.contents = counter.contents + 1 | 0;
+  return prefix + `-` + counter.contents.toString();
+}
+
+globalThis.beforeEach(() => DemandHandler.resetCache());
+
+let backends = [
+  [
+    "in-memory",
+    runUnderMemory
+  ],
+  [
+    "SQLite",
+    runUnderSqlite
+  ]
+];
+
+backends.forEach(param => {
+  let runUnder = param[1];
+  globalThis.describe(`a redelivered fact is recorded once (` + param[0] + ` backend)`, () => {
+    globalThis.test("the same published event delivered twice appends one event", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatOnce"));
+      let first = await deliver(log, commandOf(published));
+      let again = await deliver(log, commandOf(published));
+      globalThis.expect(first.length).toBe(1);
+      globalThis.expect(again).toEqual(first);
+      let events = await recordedDemands(log);
+      globalThis.expect(events.length).toBe(1);
+      let cmd = commandOf(published);
+      globalThis.expect(events[0].meta.causationId).toEqual(cmd.meta.msgId);
+      globalThis.expect(cmd.meta.causationId).toEqual(published_meta.msgId);
+    }));
+    globalThis.test("a different order for the same product still counts", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatOther"));
+      await deliver(log, commandOf(published));
+      let newrecord = {...published_meta};
+      let second_meta = (newrecord.msgId = "item-ordered-msg-2", newrecord);
+      let second_event = {
+        TAG: "ItemOrdered",
+        productId: "product-1",
+        orderId: "order-2"
+      };
+      let second = {
+        id: "order-2",
+        meta: second_meta,
+        event: second_event
+      };
+      await deliver(log, commandOf(second));
+      await deliver(log, commandOf(published));
+      await deliver(log, commandOf(second));
+      globalThis.expect((await recordedDemands(log)).length).toBe(2);
+    }));
+    globalThis.test("a command with a random id is decided every time", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatRandom"));
+      let cmd = commandOf(published);
+      let newrecord = {...cmd};
+      newrecord.meta = Message$ReventlessCore.deriveMeta(cmd.meta, undefined);
+      await deliver(log, newrecord);
+      await deliver(log, newrecord);
+      globalThis.expect((await recordedDemands(log)).length).toBe(2);
+    }));
+    globalThis.test("two concurrent copies append one event", async () => await runUnder(async () => {
+      let log = await eventLogOn(fresh("RepeatConcurrent"));
+      let cmd = commandOf(published);
+      let match = await Promise.all([
+        deliver(log, cmd),
+        deliver(log, cmd)
+      ]);
+      let b = match[1];
+      let a = match[0];
+      globalThis.expect(a.length).toBe(1);
+      globalThis.expect(b.length).toBe(1);
+      globalThis.expect(Stdlib_Result.isOk(a[0]) && Stdlib_Result.isOk(b[0])).toBe(true);
+      globalThis.expect((await recordedDemands(log)).length).toBe(1);
+    }));
+  });
+});
+
+let Message;
+
+export {
+  opts,
+  Message,
+  Port,
+  DemandSlice,
+  DemandDecision,
+  DemandHandler,
+  partitionTag,
+  DemandExtension,
+  queryEngine,
+  pluginDefinition,
+  published,
+  commandOf,
+  eventLogOn,
+  runUnderMemory,
+  runUnderSqlite,
+  deliver,
+  recordedDemands,
+  counter,
+  fresh,
+  backends,
+}
+/*  Not a pure module */

package/tests/components/readmodel/DcbReadModelTypoFailFastTest.res

@@ -1,6 +1,7 @@
-// Verifies Phase 2 of Plan 03: a ReadModel whose `Mapping.sourceName` doesn't
-// match any key in `allEventTopics` fails plugin assembly (here: ReadModel
-// construction) with a clear error, instead of silently producing zero events.
+// A ReadModel whose `Mapping.sourceName` doesn't match any key in `allEventTopics`
+// fails plugin assembly (here: ReadModel construction) with a clear error, instead
+// of silently producing zero events. A dotted name is an extension point's, and
+// the error then also says how another plugin's facts do reach a read model.
 
 open JestGlobals
 open Reventless
@@ -68,22 +69,77 @@ let allEventTopics: ReventlessInfra.EventTopic.allOutputs = Dict.fromArray([
   ("ProductCatalogDcbEventLog", {ReventlessInfra.EventTopic.resources: [topicResource]}),
 ])
 
+// A Source named like an extension point ("Ordering.Orders"): a read model
+// cannot subscribe to one, so the message must say where to go instead.
+module ExtensionPointSource = {
+  module Id = Reventless.Id.String
+  let name = "Ordering.Orders"
+
+  @schema
+  type event = ItemOrdered({productId: string, orderId: string})
+}
+
+module EpRmSpec = {
+  module Id = Reventless.Id.String
+  let name = "EpCheckReadModel"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {productId: string, orderCount: int}
+
+  let config = ReadModel.config()
+  let subIdConfig = None
+}
+
+module EpMapping = Mapping.Make(
+  ExtensionPointSource,
+  EpRmSpec,
+  {
+    let project = (msg: Message.event'<ExtensionPointSource.Id.t, ExtensionPointSource.event>) =>
+      switch msg.event {
+      | ItemOrdered({productId}) =>
+        Set(EpRmSpec.Id.makeFromString(productId), ({productId, orderCount: 1}: EpRmSpec.state))
+      }
+  },
+)
+
+module EpMappings: Mappings with module Target := EpRmSpec = {
+  module Mappings = Mappings.Make(EpRmSpec)
+  module type Mapping = Mappings.Mapping
+  let moduleUrl: string = %raw(`import.meta.url`)
+  let mappings: array<module(Mapping)> = [module(EpMapping)]
+}
+
 module ReadModelMaker = ReadModel_Builder.Make(Bus)
 module RmMaker = ReadModelMaker.Make(RmSpec, TypoMappings)
+module EpRmMaker = ReadModelMaker.Make(EpRmSpec, EpMappings)
+
+let messageOf = make => {
+  let msg = ref(None)
+  try {
+    let _ = make()
+  } catch {
+  | JsExn(err) => msg := Some(err->JsExn.message->Option.getOr(""))
+  }
+  msg.contents
+}
 
 describe("ReadModel source-name fail-fast:", () => {
   testSync("constructing a ReadModel whose Mapping.sourceName is missing throws", () => {
-    let threw = ref(false)
-    let msg = ref("")
-    try {
-      let _ = RmMaker.make(~api=(), ~apiRole=(), ~allEventTopics)
-    } catch {
-    | JsExn(err) =>
-      threw := true
-      msg := err->JsExn.message->Option.getOr("")
-    }
-    expect(threw.contents)->toBe(true)->ignore
-    expect(msg.contents->String.includes("MissingDcb"))->toBe(true)->ignore
-    expect(msg.contents->String.includes("ProductCatalogDcbEventLog"))->toBe(true)
+    let msg =
+      messageOf(() => RmMaker.make(~api=(), ~apiRole=(), ~allEventTopics))->Option.getOrThrow
+    expect(msg->String.includes("MissingDcb"))->toBe(true)
+    expect(msg->String.includes("ProductCatalogDcbEventLog"))->toBe(true)
+    // A typo keeps the plain message: no extension point is being named.
+    expect(msg->String.includes("extension point"))->toBe(false)
+  })
+
+  testSync("a dotted sourceName names the Extension → slice route instead", () => {
+    let msg =
+      messageOf(() => EpRmMaker.make(~api=(), ~apiRole=(), ~allEventTopics))->Option.getOrThrow
+    expect(msg->String.includes("Ordering.Orders"))->toBe(true)
+    expect(msg->String.includes("looks like an extension point name"))->toBe(true)
+    expect(msg->String.includes("Declare an Extension"))->toBe(true)
+    expect(msg->String.includes("Targeting a StateChangeSlice instead of an Aggregate"))->toBe(true)
   })
 })

package/tests/components/readmodel/DcbReadModelTypoFailFastTest.res.mjs

@@ -104,6 +104,84 @@ let allEventTopics = Object.fromEntries([[
     }
   ]]);
 
+let name$2 = "Ordering.Orders";
+
+let eventSchema$1 = Sury.$schema(s => ({
+  TAG: "ItemOrdered",
+  productId: s.m(Sury.string),
+  orderId: s.m(Sury.string)
+}));
+
+let ExtensionPointSource = {
+  Id: undefined,
+  name: name$2,
+  eventSchema: eventSchema$1
+};
+
+let name$3 = "EpCheckReadModel";
+
+let moduleUrl$2 = import.meta.url;
+
+let stateSchema$1 = Sury.$schema(s => ({
+  productId: s.m(Sury.string),
+  orderCount: s.m(Sury.int32)
+}));
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let EpRmSpec = {
+  Id: undefined,
+  name: name$3,
+  moduleUrl: moduleUrl$2,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project$1(msg) {
+  let match = msg.event;
+  let productId = match.productId;
+  return {
+    TAG: "Set",
+    _0: Id$Reventless.$$String.makeFromString(productId),
+    _1: {
+      productId: productId,
+      orderCount: 1
+    }
+  };
+}
+
+let EpMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$2,
+  eventSchema: eventSchema$1
+})({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  stateSchema: stateSchema$1,
+  subIdConfig: undefined
+})({
+  project: project$1
+});
+
+Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  stateSchema: stateSchema$1,
+  subIdConfig: undefined
+});
+
+let moduleUrl$3 = import.meta.url;
+
+let mappings$1 = [EpMapping];
+
+let EpMappings = {
+  moduleUrl: moduleUrl$3,
+  mappings: mappings$1
+};
+
 let ReadModelMaker = ReadModel_Builder$ReventlessLocal.Make(Bus);
 
 let RmMaker = ReadModelMaker.Make({
@@ -117,24 +195,45 @@ let RmMaker = ReadModelMaker.Make({
   visibility: "Public"
 })(TypoMappings);
 
+let EpRmMaker = ReadModelMaker.Make({
+  Id: Id$Reventless.$$String,
+  name: name$3,
+  moduleUrl: moduleUrl$2,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+})(EpMappings);
+
+function messageOf(make) {
+  let msg;
+  try {
+    make();
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      msg = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "");
+    } else {
+      throw err;
+    }
+  }
+  return msg;
+}
+
 globalThis.describe("ReadModel source-name fail-fast:", () => {
   globalThis.test("constructing a ReadModel whose Mapping.sourceName is missing throws", () => {
-    let threw = false;
-    let msg = "";
-    try {
-      RmMaker.make(undefined, undefined, allEventTopics, undefined, undefined);
-    } catch (raw_err) {
-      let err = Primitive_exceptions.internalToException(raw_err);
-      if (err.RE_EXN_ID === "JsExn") {
-        threw = true;
-        msg = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "");
-      } else {
-        throw err;
-      }
-    }
-    globalThis.expect(threw).toBe(true);
+    let msg = Stdlib_Option.getOrThrow(messageOf(() => RmMaker.make(undefined, undefined, allEventTopics, undefined, undefined)), undefined);
     globalThis.expect(msg.includes("MissingDcb")).toBe(true);
     globalThis.expect(msg.includes("ProductCatalogDcbEventLog")).toBe(true);
+    globalThis.expect(msg.includes("extension point")).toBe(false);
+  });
+  globalThis.test("a dotted sourceName names the Extension → slice route instead", () => {
+    let msg = Stdlib_Option.getOrThrow(messageOf(() => EpRmMaker.make(undefined, undefined, allEventTopics, undefined, undefined)), undefined);
+    globalThis.expect(msg.includes("Ordering.Orders")).toBe(true);
+    globalThis.expect(msg.includes("looks like an extension point name")).toBe(true);
+    globalThis.expect(msg.includes("Declare an Extension")).toBe(true);
+    globalThis.expect(msg.includes("Targeting a StateChangeSlice instead of an Aggregate")).toBe(true);
   });
 });
 
@@ -146,7 +245,13 @@ export {
   TypoMappings,
   topicResource,
   allEventTopics,
+  ExtensionPointSource,
+  EpRmSpec,
+  EpMapping,
+  EpMappings,
   ReadModelMaker,
   RmMaker,
+  EpRmMaker,
+  messageOf,
 }
 /* Bus Not a pure module */

package/tests/plugin/Plugin_Fixtures.res

@@ -7,9 +7,7 @@ let pluginDefinition: Reventless.Plugin.pluginDefinition = {
   name: "name",
   version: "1",
   extensionPoints: [],
-  extensions: [
-    {name: "Platform.Plugin.Test", extensionPointName: "Platform.Plugin", dcbSources: []},
-  ],
+  extensions: [{name: "Platform.Plugin.Test", extensionPointName: "Platform.Plugin"}],
   eventCollector: "eventCollector",
   extensionProtocols: [],
   apiSchemaFragment: None,

package/tests/plugin/Plugin_Fixtures.res.mjs

@@ -10,8 +10,7 @@ let pluginDefinition = {
   extensionPoints: [],
   extensions: [{
       name: "Platform.Plugin.Test",
-      extensionPointName: "Platform.Plugin",
-      dcbSources: []
+      extensionPointName: "Platform.Plugin"
     }],
   eventCollector: "eventCollector",
   extensionProtocols: [],