@reventlessdev/reventless-core 3.0.0-alpha.214 → 3.0.0-alpha.215

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.215 (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.214 (2026-08-07)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.214",
+  "version": "3.0.0-alpha.215",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,16 +28,16 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.2",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.2",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.2",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.2",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.101"
   },
   "devDependencies": {

package/src/adapter/RuntimeExtension/RuntimeExtension.res

@@ -0,0 +1,194 @@
+/**
+Runtime hook: every provisioned runtime announces its cold start, so an extension
+can register the runtime callback hooks the framework already ships — before the
+runtime handles its first request.
+
+No-op by default. Zero behavioral change unless an extension registers one via
+`use` before the platform/plugin build: nothing is bundled, no env var is set, and
+no code runs.
+
+`Monitoring` and `EventLogProvisioning` are the deploy-time half of this shape —
+they let an extension attach behaviour to *what gets provisioned*. This is the
+runtime half: *what runs inside it*. Without it,
+`CommandGenerator_Callback.registerCommandInterceptor`,
+`QueryDb_Callback.registerQueryInterceptor` and the two
+`EventPublish_Callback` publish hooks are unreachable in a deployed runtime —
+each is a module-level `ref` consulted on the hot path, so it is useless unless
+something calls the registrar in the same process first, and the framework-owned
+entry shells import only framework and domain modules. Per-command authorisation,
+request tracing, rate limiting and request accounting are all built from those
+hooks, and each one is otherwise a change to the framework itself.
+
+What an extension does at cold start is deliberately NOT a framework concern.
+This only exposes the choke point through which the framework says "a runtime of
+this kind just started, here is who it is" and leaves the reaction to the
+listener.
+
+See `docs/plans/done/runtime-extension-seam.md`.
+*/
+
+/**
+What every registered extension is handed at cold start. Kept to the runtime's
+IDENTITY on purpose: an extension registering a command interceptor needs to know
+which runtime it is inside, not that runtime's storage ops or specs. Widening this
+to internals would make it a second, informal handler API — and the four hooks it
+exists to reach already receive their own per-request payloads
+(`commandInterceptor` gets `~componentName` / `~tag` / `~args` on every call).
+
+`~runtimeKind` is the modelling kind of the component the runtime runs — the same
+`ComponentType.t` every AWS runtime builder already passes to
+`RuntimeEnvironment_Lambda.makeFromCodeAsset`, so there is no third taxonomy to
+keep in step with `Monitoring.unitKind` and `ResourceAttribution.Role`.
+
+`~component` is the runtime's STATIC logical name — the shared Lambda's name where
+several components of one kind share a runtime (`AllAggregatesCmdHandler`), the
+component's own name where it does not. It identifies the runtime, not a single
+model element; use the per-request `~componentName` on the interception hooks to
+tell hosted components apart.
+
+`~plugin` / `~platform` are the owning plugin and platform, taken at provisioning
+time from the ambient `ResourceAttribution` context (the same source `AWS_Tags`,
+`Monitoring.notify` and `EventLogProvisioning.notify` use) and carried into the
+runtime as configuration — the runtime has no ambient deploy context of its own.
+Both are `None` for a runtime provisioned outside any plugin construct.
+*/
+type coldStartHook = (
+  ~runtimeKind: ComponentType.t,
+  ~component: string,
+  ~plugin: option<string>,
+  ~platform: option<string>,
+) => unit
+
+/**
+A runtime extension, registered by an extension (a deploy program) before the
+platform builds. `onColdStart` is called once per runtime process, before that
+runtime handles its first request.
+
+`moduleUrl` is the extension module's own `import.meta.url`. It is what makes the
+seam reachable in a *deployed* runtime: registering a first-class module only
+populates the deploy program's process, and the Lambda is a different one, so the
+framework bundles the module's package into the code archive and names the module
+in the runtime's config for the entry shell to import. Spec and behavior modules
+are carried into runtimes the same way. The convention matches
+`@@reventless.spec`'s injected `let moduleUrl`, so a ReScript extension can lift
+it from there.
+
+**Synchronous.** An async hook would have to be awaited before the first request
+and would put extension latency on every cold path. An extension needing I/O can
+start it here and not block on it.
+
+**Fired once, in registration order.** Unlike `EventLogProvisioning` there is no
+scarce resource here (no stream-reader budget), so several extensions compose —
+tracing and accounting are independent concerns. They run in the order they were
+registered; an extension that depends on another having run first is relying on
+its host's statement order, which is the only ordering the framework can promise.
+
+**A throwing extension does not take the runtime down.** Each hook is isolated:
+the failure is logged at ERROR and the remaining extensions still run. Failing the
+runtime instead would turn a broken extension into an outage, which is a worse
+trade than a loud, skipped hook.
+*/
+module type Extension = {
+  let moduleUrl: string
+  let onColdStart: coldStartHook
+}
+
+let extensions: ref<array<module(Extension)>> = ref([])
+
+/**
+Register a runtime extension. Must run before the platform/plugin build in the
+deploy program (plain statement order — the registry is read when each runtime's
+code archive and config are built). Additive: call once per extension.
+
+There is no `Noop` default to register. The neutral state is the empty registry,
+which is also the state that bundles nothing and sets no env var; a registered
+do-nothing extension would still cost a package in every runtime's archive.
+*/
+let use = (e: module(Extension)) => extensions := extensions.contents->Array.concat([e])
+
+/**
+Drop every registration. Test-support only — deploy programs never call this.
+*/
+let reset = () => extensions := []
+
+/** True when no extension is registered — the default. Deploy-time backends use
+    this to skip bundling and config emission entirely, so a deployment that
+    registers nothing produces a byte-identical archive. */
+let isEmpty = () => extensions.contents->Array.length == 0
+
+/**
+The `import.meta.url` of every registered extension, in registration order. Read
+by the provider's code-archive builder to bundle each extension's package and to
+name the modules a deployed runtime imports at cold start.
+*/
+let moduleUrls = (): array<string> =>
+  extensions.contents->Array.map(e => {
+    module E = unpack(e)
+    E.moduleUrl
+  })
+
+let log = Logger.fromEnv()
+
+/**
+Run one hook, isolated. A throwing extension is logged at ERROR and skipped; the
+caller keeps going. See the failure-policy note on `Extension`.
+*/
+let runHook = (
+  hook: coldStartHook,
+  ~index: int,
+  ~runtimeKind: ComponentType.t,
+  ~component: string,
+  ~plugin: option<string>,
+  ~platform: option<string>,
+) =>
+  try hook(~runtimeKind, ~component, ~plugin, ~platform) catch {
+  | exn =>
+    let message =
+      exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
+    log.error(
+      ~comp="RuntimeExtension",
+      `extension ${index->Int.toString} threw at cold start of ${runtimeKind->ComponentType.toString}(${component}); skipped: ${message}`,
+    )
+  }
+
+/**
+Fire the given cold-start hooks, in order, each isolated from the others. Used by
+runtimes that resolve their extensions themselves — a deployed entry point loads
+its extension modules dynamically, so it holds hooks rather than first-class
+modules.
+*/
+let notifyColdStartHooks = (
+  ~hooks: array<coldStartHook>,
+  ~runtimeKind: ComponentType.t,
+  ~component: string,
+  ~plugin: option<string>,
+  ~platform: option<string>,
+) =>
+  hooks->Array.forEachWithIndex((hook, index) =>
+    hook->runHook(~index, ~runtimeKind, ~component, ~plugin, ~platform)
+  )
+
+/**
+Announce a runtime's cold start to every extension registered in THIS process.
+Called by in-process runtimes (the local platform), where the deploy program and
+the runtime share a process so the registry is already populated. A deployed
+runtime cannot use this — its registry is empty until it imports the extension
+modules named in its config — and calls `notifyColdStartHooks` instead. No-op
+until an extension registers.
+*/
+let notifyColdStart = (
+  ~runtimeKind: ComponentType.t,
+  ~component: string,
+  ~plugin: option<string>,
+  ~platform: option<string>,
+) =>
+  notifyColdStartHooks(
+    ~hooks=extensions.contents->Array.map(e => {
+      module E = unpack(e)
+      E.onColdStart
+    }),
+    ~runtimeKind,
+    ~component,
+    ~plugin,
+    ~platform,
+  )

package/src/adapter/RuntimeExtension/RuntimeExtension.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+
+let extensions = {
+  contents: []
+};
+
+function use(e) {
+  extensions.contents = extensions.contents.concat([e]);
+}
+
+function reset() {
+  extensions.contents = [];
+}
+
+function isEmpty() {
+  return extensions.contents.length === 0;
+}
+
+function moduleUrls() {
+  return extensions.contents.map(e => e.moduleUrl);
+}
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function runHook(hook, index, runtimeKind, component, plugin, platform) {
+  try {
+    return hook(runtimeKind, component, plugin, platform);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let message = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
+    return log.error("RuntimeExtension", undefined, `extension ` + index.toString() + ` threw at cold start of ` + ComponentType$ReventlessCore.toString(runtimeKind) + `(` + component + `); skipped: ` + message);
+  }
+}
+
+function notifyColdStartHooks(hooks, runtimeKind, component, plugin, platform) {
+  hooks.forEach((hook, index) => runHook(hook, index, runtimeKind, component, plugin, platform));
+}
+
+function notifyColdStart(runtimeKind, component, plugin, platform) {
+  notifyColdStartHooks(extensions.contents.map(e => e.onColdStart), runtimeKind, component, plugin, platform);
+}
+
+export {
+  extensions,
+  use,
+  reset,
+  isEmpty,
+  moduleUrls,
+  log,
+  runHook,
+  notifyColdStartHooks,
+  notifyColdStart,
+}
+/* log Not a pure module */

package/tests/adapter/RuntimeExtensionHookReachTest.res

@@ -0,0 +1,84 @@
+open JestGlobals
+
+S.enableJson()
+
+// The point of the seam, end to end at the hook level: an extension that only
+// ever gets `onColdStart` can reach the framework's runtime callback hooks from
+// there, and they take effect on the requests that follow.
+//
+// `CommandGenerator_Callback.registerCommandInterceptor` stands in for all four
+// registrars — they share the shape (a module-level ref consulted on the hot
+// path), so what makes one reachable makes the others reachable too. What is
+// being proved is the ordering: registration happens inside the cold-start hook,
+// the command runs after it, and the interceptor is consulted.
+
+@schema
+type command = Add({@partitionTag productId: string, name: string})
+
+let published: ref<array<Message.commandJson>> = ref([])
+let publishJsons: CommandGenerator.publishJsons = async cmds =>
+  published := published.contents->Array.concat(cmds)
+
+let generateCommand = CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons,
+  ~serviceName="Product",
+  ~commandSchema=commandSchema->S.castToUnknown,
+  ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+let addChair = (): CommandGenerator.payload =>
+  Obj.magic({
+    "command": "Add",
+    "arguments": {"productId": "p1", "name": "Chair"},
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+let runAdd = async () => await generateCommand(addChair())->Effect.runPromise
+
+describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  beforeEach(() => {
+    RuntimeExtension.reset()
+    CommandGenerator_Callback.clearCommandInterceptor()
+    published := []
+  })
+
+  testPromise("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart: array<string> = []
+    module Gatekeeper: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/gatekeeper.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) => {
+        seenAtColdStart->Array.push(component)
+        CommandGenerator_Callback.registerCommandInterceptor(async (
+          ~identity as _,
+          ~componentName,
+          ~componentKind as _,
+          ~tag,
+          ~args as _,
+        ) => CommandGenerator_Callback.Deny(`${componentName}.${tag} refused`))
+      }
+    }
+    RuntimeExtension.use(module(Gatekeeper: RuntimeExtension.Extension))
+
+    RuntimeExtension.notifyColdStart(
+      ~runtimeKind=ComponentType.StateChangeSlice,
+      ~component="CatalogStateChanges",
+      ~plugin=Some("Catalog"),
+      ~platform=Some("Shop"),
+    )
+    expect(seenAtColdStart)->toEqual(["CatalogStateChanges"])
+
+    let denied = switch await runAdd() {
+    | _ => None
+    | exception exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+    }
+
+    expect(denied)->toEqual(Some("Product.Add refused"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("with nothing registered the same command publishes untouched", async () => {
+    let _ = await runAdd()
+    expect(published.contents->Array.length)->toBe(1)
+  })
+})

package/tests/adapter/RuntimeExtensionHookReachTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../../src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+S.enableJson();
+
+let commandSchema = S.schema(s => ({
+  TAG: "Add",
+  productId: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let published = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  published.contents = published.contents.concat(cmds);
+}
+
+let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "Product", commandSchema, "StateChangeSlice", false);
+
+function addChair() {
+  return {
+    command: "Add",
+    arguments: {
+      productId: "p1",
+      name: "Chair"
+    },
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+async function runAdd() {
+  return await Effect.runPromise(generateCommand(addChair()));
+}
+
+globalThis.describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  globalThis.beforeEach(() => {
+    RuntimeExtension$ReventlessCore.reset();
+    CommandGenerator_Callback$ReventlessCore.clearCommandInterceptor();
+    published.contents = [];
+  });
+  globalThis.test("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart = [];
+    let onColdStart = (param, component, param$1, param$2) => {
+      seenAtColdStart.push(component);
+      CommandGenerator_Callback$ReventlessCore.registerCommandInterceptor(async (param, componentName, param$1, tag, param$2) => ({
+        TAG: "Deny",
+        _0: componentName + `.` + tag + ` refused`
+      }));
+    };
+    let Gatekeeper = {
+      moduleUrl: "file:///pkg/gatekeeper.res.mjs",
+      onColdStart: onColdStart
+    };
+    RuntimeExtension$ReventlessCore.use(Gatekeeper);
+    RuntimeExtension$ReventlessCore.notifyColdStart("StateChangeSlice", "CatalogStateChanges", "Catalog", "Shop");
+    globalThis.expect(seenAtColdStart).toEqual(["CatalogStateChanges"]);
+    let denied;
+    try {
+      await runAdd();
+      denied = undefined;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      denied = Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+    }
+    globalThis.expect(denied).toEqual("Product.Add refused");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("with nothing registered the same command publishes untouched", async () => {
+    await runAdd();
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+});
+
+export {
+  commandSchema,
+  published,
+  publishJsons,
+  generateCommand,
+  addChair,
+  runAdd,
+}
+/*  Not a pure module */

package/tests/adapter/RuntimeExtensionTest.res

@@ -0,0 +1,127 @@
+open JestGlobals
+
+type call = {
+  runtimeKind: ComponentType.t,
+  component: string,
+  plugin: option<string>,
+  platform: option<string>,
+}
+
+let recorderNamed = (label: string, into: array<(string, call)>): module(
+  RuntimeExtension.Extension
+) => {
+  module R = {
+    let moduleUrl = `file:///pkg/${label}.res.mjs`
+    let onColdStart = (~runtimeKind, ~component, ~plugin, ~platform) =>
+      into->Array.push((label, {runtimeKind, component, plugin, platform}))
+  }
+  module(R: RuntimeExtension.Extension)
+}
+
+let fireAggregate = () =>
+  RuntimeExtension.notifyColdStart(
+    ~runtimeKind=ComponentType.Aggregate,
+    ~component="AllAggregatesCmdHandler",
+    ~plugin=Some("Catalog"),
+    ~platform=Some("Shop"),
+  )
+
+describe("RuntimeExtension", () => {
+  beforeEach(() => RuntimeExtension.reset())
+
+  testSync("empty registry is the default and notifyColdStart is silent", () => {
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(RuntimeExtension.moduleUrls())->toEqual([])
+    fireAggregate()
+    expect(true)->toBe(true)
+  })
+
+  testSync("a registered extension receives the runtime's full identity", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+
+    fireAggregate()
+
+    expect(calls)->toEqual([
+      (
+        "tracing",
+        {
+          runtimeKind: ComponentType.Aggregate,
+          component: "AllAggregatesCmdHandler",
+          plugin: Some("Catalog"),
+          platform: Some("Shop"),
+        },
+      ),
+    ])
+  })
+
+  testSync("several extensions compose, in registration order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["tracing", "accounting"])
+  })
+
+  testSync("moduleUrls reports every registration, in order", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    expect(RuntimeExtension.isEmpty())->toBe(false)
+    expect(RuntimeExtension.moduleUrls())->toEqual([
+      "file:///pkg/tracing.res.mjs",
+      "file:///pkg/accounting.res.mjs",
+    ])
+  })
+
+  testSync("a throwing extension is skipped; the runtime and its siblings survive", () => {
+    let calls: array<(string, call)> = []
+    module Broken: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/broken.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+        JsError.throwWithMessage("extension blew up")
+    }
+    RuntimeExtension.use(module(Broken: RuntimeExtension.Extension))
+    RuntimeExtension.use(recorderNamed("accounting", calls))
+
+    // Fails the test if the seam propagates: the acceptance criterion is that a
+    // broken extension does not take the runtime down.
+    fireAggregate()
+
+    expect(calls->Array.map(((label, _)) => label))->toEqual(["accounting"])
+  })
+
+  testSync("notifyColdStartHooks fires loose hooks — the deployed runtime's path", () => {
+    // A deployed entry point holds hooks lifted off dynamically imported
+    // modules, not first-class modules, so it never populates this process's
+    // registry. Same isolation and ordering apply.
+    let seen: array<string> = []
+    let hook = (label): RuntimeExtension.coldStartHook =>
+      (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) =>
+        seen->Array.push(`${label}:${component}`)
+
+    RuntimeExtension.notifyColdStartHooks(
+      ~hooks=[hook("a"), hook("b")],
+      ~runtimeKind=ComponentType.ReadModel,
+      ~component="AllReadModels",
+      ~plugin=None,
+      ~platform=None,
+    )
+
+    expect(seen)->toEqual(["a:AllReadModels", "b:AllReadModels"])
+  })
+
+  testSync("reset clears the registry", () => {
+    let calls: array<(string, call)> = []
+    RuntimeExtension.use(recorderNamed("tracing", calls))
+    RuntimeExtension.reset()
+
+    fireAggregate()
+
+    expect(RuntimeExtension.isEmpty())->toBe(true)
+    expect(calls)->toEqual([])
+  })
+})

package/tests/adapter/RuntimeExtensionTest.res.mjs

@@ -0,0 +1,111 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+
+function recorderNamed(label, into) {
+  let moduleUrl = `file:///pkg/` + label + `.res.mjs`;
+  let onColdStart = (runtimeKind, component, plugin, platform) => {
+    into.push([
+      label,
+      {
+        runtimeKind: runtimeKind,
+        component: component,
+        plugin: plugin,
+        platform: platform
+      }
+    ]);
+  };
+  return {
+    moduleUrl: moduleUrl,
+    onColdStart: onColdStart
+  };
+}
+
+function fireAggregate() {
+  RuntimeExtension$ReventlessCore.notifyColdStart("Aggregate", "AllAggregatesCmdHandler", "Catalog", "Shop");
+}
+
+globalThis.describe("RuntimeExtension", () => {
+  globalThis.beforeEach(() => RuntimeExtension$ReventlessCore.reset());
+  globalThis.test("empty registry is the default and notifyColdStart is silent", () => {
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(true);
+    globalThis.expect(RuntimeExtension$ReventlessCore.moduleUrls()).toEqual([]);
+    fireAggregate();
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("a registered extension receives the runtime's full identity", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    fireAggregate();
+    globalThis.expect(calls).toEqual([[
+        "tracing",
+        {
+          runtimeKind: "Aggregate",
+          component: "AllAggregatesCmdHandler",
+          plugin: "Catalog",
+          platform: "Shop"
+        }
+      ]]);
+  });
+  globalThis.test("several extensions compose, in registration order", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    fireAggregate();
+    globalThis.expect(calls.map(param => param[0])).toEqual([
+      "tracing",
+      "accounting"
+    ]);
+  });
+  globalThis.test("moduleUrls reports every registration, in order", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(false);
+    globalThis.expect(RuntimeExtension$ReventlessCore.moduleUrls()).toEqual([
+      "file:///pkg/tracing.res.mjs",
+      "file:///pkg/accounting.res.mjs"
+    ]);
+  });
+  globalThis.test("a throwing extension is skipped; the runtime and its siblings survive", () => {
+    let calls = [];
+    let onColdStart = (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("extension blew up");
+    let Broken = {
+      moduleUrl: "file:///pkg/broken.res.mjs",
+      onColdStart: onColdStart
+    };
+    RuntimeExtension$ReventlessCore.use(Broken);
+    RuntimeExtension$ReventlessCore.use(recorderNamed("accounting", calls));
+    fireAggregate();
+    globalThis.expect(calls.map(param => param[0])).toEqual(["accounting"]);
+  });
+  globalThis.test("notifyColdStartHooks fires loose hooks — the deployed runtime's path", () => {
+    let seen = [];
+    let hook = label => ((param, component, param$1, param$2) => {
+      seen.push(label + `:` + component);
+    });
+    RuntimeExtension$ReventlessCore.notifyColdStartHooks([
+      hook("a"),
+      hook("b")
+    ], "ReadModel", "AllReadModels", undefined, undefined);
+    globalThis.expect(seen).toEqual([
+      "a:AllReadModels",
+      "b:AllReadModels"
+    ]);
+  });
+  globalThis.test("reset clears the registry", () => {
+    let calls = [];
+    RuntimeExtension$ReventlessCore.use(recorderNamed("tracing", calls));
+    RuntimeExtension$ReventlessCore.reset();
+    fireAggregate();
+    globalThis.expect(RuntimeExtension$ReventlessCore.isEmpty()).toBe(true);
+    globalThis.expect(calls).toEqual([]);
+  });
+});
+
+export {
+  recorderNamed,
+  fireAggregate,
+}
+/*  Not a pure module */