@reventlessdev/reventless-local 3.0.0-alpha.201 → 3.0.0-alpha.203

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.203 (2026-08-08)
+
+### Features
+
+* **core,aws,local:** add the RuntimeExtension cold-start seam ([143e30e](https://github.com/ReventlessDev/reventless-core/commit/143e30eeded6232ce7f0fcc18328939b2917bb31))
+
+
+# 3.0.0-alpha.202 (2026-08-07)
+
+### Features
+
+* **core,aws:** add the EventLogProvisioning seam for out-of-tree consumers ([82477b3](https://github.com/ReventlessDev/reventless-core/commit/82477b38c1ef90fbe3a6f4a114a9798770329470))
+
+
 # 3.0.0-alpha.201 (2026-08-05)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.201",
+  "version": "3.0.0-alpha.203",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,18 +35,18 @@
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
     "@reventlessdev/rescript-node": "2.0.0-alpha.2",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.213",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.61",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.63",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.215",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.162",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.79",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.9",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.160",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.101",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.77"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.101"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -1414,6 +1414,24 @@ module MakeWithConfig = (
         `backend: sqlite (${path}${resetOnStart ? ", resetOnStart" : ""})`
       },
     )
+    // Runtime extension seam. Fired before anything is built, so an extension's
+    // interception and publish hooks are registered before the first command or
+    // query can reach them.
+    //
+    // Off Lambda the seam means something slightly different, and deliberately
+    // so: every component runs in THIS process, so there is one cold start, not
+    // one per runtime. Firing per hosted component would hand an extension N
+    // identities for a single process and re-run registrations that are
+    // module-level refs anyway. `Platform` is the honest kind for a runtime that
+    // hosts all of them; an extension that routes on kind should treat this as
+    // "everything", which is what it is.
+    ReventlessCore.RuntimeExtension.notifyColdStart(
+      ~runtimeKind=ReventlessCore.ComponentType.Platform,
+      ~component="LocalPlatform",
+      ~plugin=ReventlessCore.ResourceAttribution.current.contents.plugin,
+      ~platform=ReventlessCore.ResourceAttribution.current.contents.platform,
+    )
+
     // Projection catch-up bound (plan B5): the highest persisted event position
     // BEFORE this session appends anything. Catch-up replays only (checkpoint,
     // bound] — this session's own events (Connect dispatches, user commands)

package/src/Platform.res.mjs

@@ -39,6 +39,7 @@ import * as Counter_Builder$ReventlessLocal from "./components/Counter_Builder.r
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as LocalPluginSpec$ReventlessLocal from "./adapter/LocalPluginSpec.res.mjs";
 import * as NoEventMappings$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/NoEventMappings.res.mjs";
+import * as RuntimeExtension$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
 import * as DomainMCP_Server$ReventlessLocal from "./adapter/DomainMCP_Server.res.mjs";
 import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
 import * as LocalObjectStore$ReventlessLocal from "./adapter/ObjectStore/LocalObjectStore.res.mjs";
@@ -54,6 +55,7 @@ import * as ReadModel_Builder$ReventlessLocal from "./components/ReadModel_Build
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "./adapter/Api/LocalEvents_Server.res.mjs";
 import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Server.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "@reventlessdev/reventless-core/src/ResourceAttribution.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
 import * as PgProjectionCatchup$ReventlessLocal from "./adapter/PgProjectionCatchup.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -1192,6 +1194,7 @@ function MakeWithConfig(Config) {
           ) + `)` : `backend: postgres (` + match.connection + `, event-logs only)`
       );
     log.info("Platform", undefined, tmp);
+    RuntimeExtension$ReventlessCore.notifyColdStart("Platform", "LocalPlatform", ResourceAttribution$ReventlessCore.current.contents.plugin, ResourceAttribution$ReventlessCore.current.contents.platform);
     let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),
@@ -2883,6 +2886,7 @@ function Make($star) {
           ) + `)` : `backend: postgres (` + backend.connection + `, event-logs only)`
       );
     log.info("Platform", undefined, tmp);
+    RuntimeExtension$ReventlessCore.notifyColdStart("Platform", "LocalPlatform", ResourceAttribution$ReventlessCore.current.contents.plugin, ResourceAttribution$ReventlessCore.current.contents.platform);
     let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),

package/tests/components/eventlog/EventLogProvisioningSeamTest.res

@@ -0,0 +1,110 @@
+// End-to-end check that the EventLogProvisioning seam fires from the real
+// builders, not just from its own registry: a backend registered before the
+// build sees both log styles as they are provisioned, through the local
+// in-memory storage adapters.
+//
+// Registration and construction happen at module load — the seam fires during
+// `Component.make`'s construct, so a backend registered inside a `test` body
+// would arrive too late. The assertions then read what was recorded.
+
+open JestGlobals
+
+type record = {
+  logStyle: ReventlessCore.EventLogProvisioning.logStyle,
+  name: string,
+  owner: option<ReventlessCore.ResourceAttribution.owner>,
+  plugin: option<string>,
+  resourceCount: int,
+}
+
+let provisioned: array<record> = []
+
+module Recorder: ReventlessCore.EventLogProvisioning.Backend = {
+  let onProvisioned = (~logStyle, ~name, ~owner, ~plugin, ~platform as _, ~resources, ~opts as _) =>
+    provisioned->Array.push({
+      logStyle,
+      name,
+      owner,
+      plugin,
+      resourceCount: resources->Array.length,
+    })
+}
+
+ReventlessCore.EventLogProvisioning.use(module(Recorder: ReventlessCore.EventLogProvisioning.Backend))
+
+module Bus = LocalBus.Make()
+
+let _ = TestRunner.setup()
+
+// ── Classic log ──────────────────────────────────────────────
+module SeamItemSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "SeamItemEventLog"
+
+  @schema
+  type event = | SeamItemCreated({name: string})
+}
+
+module ClassicMaker = ReventlessCore.EventLog_Builder.Make(
+  SeamItemSpec,
+  EventLogStorage_InMemory,
+  LocalEventTopicPublisher.Make(Bus),
+)
+
+// The plugin builder publishes this context around a plugin's construct; entering
+// it here is what a real plugin build does, so the seam should carry the names.
+let previousContext = ReventlessCore.ResourceAttribution.enter(~platform="seam-platform", ~plugin="SeamPlugin")
+
+let classicLog = ClassicMaker.make(
+  ~name="SeamItem",
+  ~owner={kind: ReventlessCore.ComponentType.Aggregate, name: "SeamItem"},
+)
+
+// ── DCB log ──────────────────────────────────────────────────
+module DcbMaker = DcbEventLog_Builder.Make(Bus)
+
+let dcbLog = DcbMaker.make(
+  ~name="SeamCatalog",
+  ~partitionTag=Reventless.DcbTag.Simple({key: "id"}),
+)
+
+ReventlessCore.ResourceAttribution.restore(previousContext)
+
+describe("EventLogProvisioning seam, driven by the real builders", () => {
+  testSync("fires once per log, for both styles", () => {
+    expect(provisioned->Array.map(r => (r.logStyle, r.name)))->toEqual([
+      (ReventlessCore.EventLogProvisioning.Classic, "SeamItemEventLog"),
+      (ReventlessCore.EventLogProvisioning.Dcb, "SeamCatalogDcbEventLog"),
+    ])
+  })
+
+  testSync("carries the owning element: the aggregate for classic, the plugin for DCB", () => {
+    expect(provisioned->Array.map(r => r.owner))->toEqual([
+      Some(({kind: ReventlessCore.ComponentType.Aggregate, name: "SeamItem"}: ReventlessCore.ResourceAttribution.owner)),
+      Some(({kind: ReventlessCore.ComponentType.Plugin, name: "SeamCatalog"}: ReventlessCore.ResourceAttribution.owner)),
+    ])
+  })
+
+  testSync("carries the ambient plugin attribution the builder published", () => {
+    expect(provisioned->Array.map(r => r.plugin))->toEqual([
+      Some("SeamPlugin"),
+      Some("SeamPlugin"),
+    ])
+  })
+
+  testSync("carries the adapter's resources — empty for in-memory storage", () => {
+    // In-memory logs have nothing attachable; the seam still fires, and a backend
+    // that only implements a provider arm ignores them.
+    expect(provisioned->Array.map(r => r.resourceCount))->toEqual([0, 0])
+  })
+
+  test("the components still build normally with a backend registered", async () => {
+    let classicOps = await classicLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let dcbOps = await dcbLog->DcbMaker.operations->TestRunner.resolve
+    // Resolving both operation records proves construction completed with a
+    // backend registered — the seam fires mid-construct, so a throwing backend
+    // would take the build down here.
+    expect(classicOps)->toBeTruthy
+    expect(dcbOps)->toBeTruthy
+  })
+})

package/tests/components/eventlog/EventLogProvisioningSeamTest.res.mjs

@@ -0,0 +1,141 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as EventLog_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventLog/EventLog_Builder.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "@reventlessdev/reventless-core/src/ResourceAttribution.res.mjs";
+import * as DcbEventLog_Builder$ReventlessLocal from "../../../src/components/DcbEventLog_Builder.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../../../src/adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+import * as LocalEventTopicPublisher$ReventlessLocal from "../../../src/adapter/EventTopic/LocalEventTopicPublisher.res.mjs";
+
+let provisioned = [];
+
+function onProvisioned(logStyle, name, owner, plugin, param, resources, param$1) {
+  provisioned.push({
+    logStyle: logStyle,
+    name: name,
+    owner: owner,
+    plugin: plugin,
+    resourceCount: resources.length
+  });
+}
+
+let Recorder = {
+  onProvisioned: onProvisioned
+};
+
+EventLogProvisioning$ReventlessCore.use(Recorder);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let name = "SeamItemEventLog";
+
+let eventSchema = S.schema(s => ({
+  TAG: "SeamItemCreated",
+  name: s.m(S.string)
+}));
+
+let SeamItemSpec = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let ClassicMaker = EventLog_Builder$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  eventSchema: eventSchema
+})({
+  make: EventLogStorage_InMemory$ReventlessLocal.make
+})(LocalEventTopicPublisher$ReventlessLocal.Make(Bus));
+
+let previousContext = ResourceAttribution$ReventlessCore.enter("seam-platform", "SeamPlugin");
+
+let classicLog = ClassicMaker.make("SeamItem", {
+  kind: "Aggregate",
+  name: "SeamItem"
+}, undefined);
+
+let DcbMaker = DcbEventLog_Builder$ReventlessLocal.Make(Bus);
+
+let dcbLog = DcbMaker.make("SeamCatalog", undefined, {
+  TAG: "Simple",
+  _0: {
+    key: "id"
+  }
+}, undefined);
+
+ResourceAttribution$ReventlessCore.restore(previousContext);
+
+globalThis.describe("EventLogProvisioning seam, driven by the real builders", () => {
+  globalThis.test("fires once per log, for both styles", () => {
+    globalThis.expect(provisioned.map(r => [
+      r.logStyle,
+      r.name
+    ])).toEqual([
+      [
+        "Classic",
+        "SeamItemEventLog"
+      ],
+      [
+        "Dcb",
+        "SeamCatalogDcbEventLog"
+      ]
+    ]);
+  });
+  globalThis.test("carries the owning element: the aggregate for classic, the plugin for DCB", () => {
+    globalThis.expect(provisioned.map(r => r.owner)).toEqual([
+      {
+        kind: "Aggregate",
+        name: "SeamItem"
+      },
+      {
+        kind: "Plugin",
+        name: "SeamCatalog"
+      }
+    ]);
+  });
+  globalThis.test("carries the ambient plugin attribution the builder published", () => {
+    globalThis.expect(provisioned.map(r => r.plugin)).toEqual([
+      "SeamPlugin",
+      "SeamPlugin"
+    ]);
+  });
+  globalThis.test("carries the adapter's resources — empty for in-memory storage", () => {
+    globalThis.expect(provisioned.map(r => r.resourceCount)).toEqual([
+      0,
+      0
+    ]);
+  });
+  globalThis.test("the components still build normally with a backend registered", async () => {
+    let classicOps = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(classicLog));
+    let dcbOps = await TestRunner$ReventlessLocal.resolve(DcbMaker.operations(dcbLog));
+    globalThis.expect(classicOps).toBeTruthy();
+    globalThis.expect(dcbOps).toBeTruthy();
+  });
+});
+
+export {
+  provisioned,
+  Recorder,
+  Bus,
+  SeamItemSpec,
+  ClassicMaker,
+  previousContext,
+  classicLog,
+  DcbMaker,
+  dcbLog,
+}
+/*  Not a pure module */