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

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.214 (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.213 (2026-08-05)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.213",
+  "version": "3.0.0-alpha.214",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,15 +29,15 @@
     "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-fast-csv": "2.0.0-alpha.2",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@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/reventless-interop": "3.0.0-alpha.30",
     "@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/reventless-spec": "3.0.0-alpha.101"
   },
   "devDependencies": {

package/src/adapter/EventLogProvisioning/EventLogProvisioning.res

@@ -0,0 +1,165 @@
+/**
+Deploy-time hook: every event log announces itself as it is provisioned, so an
+extension can attach behaviour to it inside the program that owns it.
+
+No-op by default. Zero behavioral change unless an extension registers a backend
+via `use` before the platform/plugin build. The seam fires once per log at
+provisioning time (inside the deploy program) — never at invocation, and it runs
+no code in production.
+
+What a backend does with a log is deliberately NOT a framework concern.
+Aggregation, CDC export, external indexing, replication and archival all want to
+react to an event log's changes; none of them belong in core, and each one added
+to core is maintenance its users pay for whether or not they use it. This only
+exposes the choke point through which the framework says "I just provisioned an
+event log, here is everything I know about it" and leaves the reaction to the
+listener.
+
+The alternative — discovering a log's resources from outside the owning program —
+is impractical on AWS: a DynamoDB stream ARN ends in a creation-time stream
+label, so it cannot be synthesised, and exporting it per plugin pushes framework
+internals into every deployment's stack outputs.
+
+See `docs/plans/done/event-log-provisioned-seam.md`.
+*/
+
+/**
+Which event-log family provisioned the log. The two differ in what a reader finds
+on the wire — a classic log is per-aggregate and its rows carry an aggregate id;
+a DCB log is per-plugin and its rows carry tags — so a backend that decodes
+records needs to know which it is looking at before it looks.
+*/
+type logStyle =
+  | /** per-aggregate log behind `EventLog_Builder` */ Classic
+  | /** per-plugin tagged log behind `DcbEventLog_Builder` */ Dcb
+
+/**
+An event-log backend, registered by an extension (a deploy program) before the
+platform builds. `onProvisioned` is called once per event log.
+
+`~name` is the log's STATIC logical name — the suffixed component name the
+builder passed to its storage maker (`ProductEventLog`, `CatalogDcbEventLog`). A
+Pulumi-based backend derives logical resource names from it, which must be stable
+and known at graph-construction time.
+
+`~owner` is the model element the log belongs to: `{kind: Aggregate, name:
+"Product"}` for a classic log, `{kind: Plugin, name: "Catalog"}` for a DCB log
+(the plugin owns it, not any one slice). `~plugin` / `~platform` come from the
+ambient `ResourceAttribution` context the plugin builder publishes during
+construction — the same source `AWS_Tags` and `Monitoring.notify` use. Both are
+`None` for a log provisioned outside any plugin construct.
+
+`~resources` is the adapter's deploy-time resources, not a stream: a stream is a
+DynamoDB-shaped idea and SQL-backed adapters have none. A backend derives
+whatever its store supports and does nothing for the rest — a Postgres log
+arrives with `resources: []`, and an in-memory one with nothing attachable. The
+contract is uniform on purpose; filtering belongs in the backend.
+
+`~opts` carries the log component's parent options. A backend that provisions
+anything needs them, or its resources land outside the component tree.
+
+Because `onProvisioned` fires during resource creation inside the deploy program,
+a Pulumi-based backend can create its resources in the same stack, parented
+naturally.
+
+**The reader budget.** A DynamoDB table has exactly one stream, and DynamoDB
+Streams throttles beyond two processes reading the same shard. Core already
+spends one slot: `EventCollectorChannel_Helpers` maps every event-log stream onto
+the plugin's event-collector Lambda. A backend that subscribes through this seam
+is therefore reader #2 — the ceiling. A second stream consumer would throttle the
+first, which is why registration is single-slot and loud (see `use`). If several
+consumers are ever needed the answer is a fan-out — routing through the existing
+collector, or a stream type that supports more readers — not more subscriptions.
+
+**Snapshots share the log's table.** Classic aggregate snapshots are written to
+the event-log table under `position = "SNAPSHOT"`, so a stream consumer sees them
+alongside events. The seam does not filter; a backend that only wants events must
+skip those rows itself.
+
+**No ordering guarantee against other seams.** This and `Monitoring.notify` both
+fire during provisioning, from different builders, in whatever order the graph is
+constructed. A backend must not depend on having seen one before the other.
+*/
+module type Backend = {
+  let onProvisioned: (
+    ~logStyle: logStyle,
+    ~name: string,
+    ~owner: option<ResourceAttribution.owner>,
+    ~plugin: option<string>,
+    ~platform: option<string>,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~opts: Pulumi.CustomResourceOptions.t,
+  ) => unit
+}
+
+/** Default backend: does nothing. Active unless an extension calls `use`. */
+module Noop: Backend = {
+  let onProvisioned = (
+    ~logStyle as _,
+    ~name as _,
+    ~owner as _,
+    ~plugin as _,
+    ~platform as _,
+    ~resources as _,
+    ~opts as _,
+  ) => ()
+}
+
+let backend: ref<module(Backend)> = ref(module(Noop: Backend))
+let registered = ref(false)
+
+/**
+Register the event-log backend. Must run before the platform/plugin build in the
+deploy program (plain statement order — the registry is consulted lazily at each
+provisioning site). Called once, by the extension, first.
+
+Single-slot and loud: a second `use` raises rather than silently winning, because
+the reader budget documented on `Backend` means two registered backends is not a
+last-writer-wins configuration question but two consumers competing for one
+stream slot — a defect that otherwise surfaces in production as iterator-age
+alarms on whichever one lost. `reset` clears the slot for tests.
+*/
+let use = (b: module(Backend)) => {
+  if registered.contents {
+    JsError.throwWithMessage(
+      "EventLogProvisioning.use called twice: only one event-log backend can be registered. " ++
+      "A DynamoDB stream supports two readers per shard and core's event collector already holds one, " ++
+      "so a second backend would throttle the first. Compose the two backends into one, or fan out " ++
+      "behind a single registration.",
+    )
+  }
+  registered := true
+  backend := b
+}
+
+/**
+Restore the default `Noop` backend and clear the registration slot. Test-support
+only — deploy programs never call this.
+*/
+let reset = () => {
+  backend := module(Noop: Backend)
+  registered := false
+}
+
+/**
+Announce a provisioned event log to the registered backend. Called by the
+`EventLog` and `DcbEventLog` builders at their storage-provisioning sites (once
+per log). Firing from the builders rather than from each storage adapter is what
+makes the contract uniform: every adapter — DynamoDB, Postgres, SQLite,
+in-memory, and any future one — is covered by construction, with nothing to
+remember when a new one is written. No-op until an extension registers a backend.
+*/
+let notify = (
+  ~logStyle: logStyle,
+  ~name: string,
+  ~owner: option<ResourceAttribution.owner>,
+  ~resources: array<ReventlessInfra.Adapter.resource>,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => {
+  module B = unpack(backend.contents)
+  // The owning plugin/platform come from the ambient context the plugin builder publishes
+  // (ResourceAttribution.enter) — populated exactly when this fires, so the call sites need not
+  // thread the names. `None` outside a plugin construct.
+  let {ResourceAttribution.plugin: plugin, platform} = ResourceAttribution.current.contents
+  B.onProvisioned(~logStyle, ~name, ~owner, ~plugin, ~platform, ~resources, ~opts)
+}

package/src/adapter/EventLogProvisioning/EventLogProvisioning.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.res.mjs";
+
+function onProvisioned(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  
+}
+
+let Noop = {
+  onProvisioned: onProvisioned
+};
+
+let backend = {
+  contents: Noop
+};
+
+let registered = {
+  contents: false
+};
+
+function use(b) {
+  if (registered.contents) {
+    Stdlib_JsError.throwWithMessage("EventLogProvisioning.use called twice: only one event-log backend can be registered. A DynamoDB stream supports two readers per shard and core's event collector already holds one, so a second backend would throttle the first. Compose the two backends into one, or fan out behind a single registration.");
+  }
+  registered.contents = true;
+  backend.contents = b;
+}
+
+function reset() {
+  backend.contents = Noop;
+  registered.contents = false;
+}
+
+function notify(logStyle, name, owner, resources, opts) {
+  let B = backend.contents;
+  let match = ResourceAttribution$ReventlessCore.current.contents;
+  B.onProvisioned(logStyle, name, owner, match.plugin, match.platform, resources, opts);
+}
+
+export {
+  Noop,
+  backend,
+  registered,
+  use,
+  reset,
+  notify,
+}
+/* No side effect */

package/src/components/DcbEventLog/DcbEventLog_Builder.res

@@ -16,21 +16,34 @@ module Make = (
   let construct = (indexes, partitionTag, crossPartitionTagKeys, self, name) => {
     let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
 
+    let logName = name->ComponentType.name(DcbEventLog.componentType)
+    // The DCB event log is shared across the plugin's slices, so the plugin owns
+    // it — not any one component.
+    let owner: ResourceAttribution.owner = {kind: ComponentType.Plugin, name}
     let storage = Storage.make(
-      ~name=name->ComponentType.name(DcbEventLog.componentType),
+      ~name=logName,
       ~indexes,
       ~partitionTag,
       ~crossPartitionTagKeys,
       ~opts,
     )
 
+    // Announce the log to any registered extension. No-op unless a deploy program
+    // registered a backend via EventLogProvisioning.use — see
+    // src/adapter/EventLogProvisioning/EventLogProvisioning.res.
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name=logName,
+      ~owner=Some(owner),
+      ~resources=storage.resources,
+      ~opts,
+    )
+
     module SpecificEventTopic = EventTopic_Builder.Make(EventTopicSpec, EventTopicPublisher)
     let eventTopic = SpecificEventTopic.make(
       ~name,
       ~storageResources=storage.resources,
-      // The DCB event log is shared across the plugin's slices, so the plugin
-      // owns it — not any one component.
-      ~owner={kind: ComponentType.Plugin, name},
+      ~owner,
       ~opts=opts->Util.Pulumi.ComponentResourceOptions.ofCustomResourceOptions,
     )
 

package/src/components/DcbEventLog/DcbEventLog_Builder.res.mjs

@@ -8,6 +8,7 @@ import * as DcbEventLog$ReventlessCore from "./DcbEventLog.res.mjs";
 import * as Util_Pulumi$ReventlessCore from "../../util/Util_Pulumi.res.mjs";
 import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
 import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Builder.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "../../adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
 import * as DcbEventLog_Operations$ReventlessCore from "./DcbEventLog_Operations.res.mjs";
 
 function Make(Storage) {
@@ -20,16 +21,19 @@ function Make(Storage) {
         let opts = {
           parent: opts_parent
         };
-        let storage = Storage.make(ComponentType$ReventlessCore.name(extra$1, DcbEventLog$ReventlessCore.componentType), indexes, partitionTag, crossPartitionTagKeys, opts);
+        let logName = ComponentType$ReventlessCore.name(extra$1, DcbEventLog$ReventlessCore.componentType);
+        let owner = {
+          kind: "Plugin",
+          name: extra$1
+        };
+        let storage = Storage.make(logName, indexes, partitionTag, crossPartitionTagKeys, opts);
+        EventLogProvisioning$ReventlessCore.notify("Dcb", logName, owner, storage.resources, opts);
         let SpecificEventTopic = EventTopic_Builder$ReventlessCore.Make({
           Id: Id$Reventless.$$String,
           name: "DcbEventLog",
           eventSchema: S.json
         })(EventTopicPublisher);
-        let eventTopic = SpecificEventTopic.make(extra$1, storage.resources, {
-          kind: "Plugin",
-          name: extra$1
-        }, Util_Pulumi$ReventlessCore.ComponentResourceOptions.ofCustomResourceOptions(opts));
+        let eventTopic = SpecificEventTopic.make(extra$1, storage.resources, owner, Util_Pulumi$ReventlessCore.ComponentResourceOptions.ofCustomResourceOptions(opts));
         Component$ReventlessCore.setOperations(extra, Pulumi.all([
           storage.operations,
           Component$ReventlessCore.operations(eventTopic)

package/src/components/EventLog/EventLog_Builder.res

@@ -18,9 +18,17 @@ module Make = (
   let construct = (~owner=?, self, name) => {
     let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
 
-    let storage = Storage.make(
-      ~name=name->ComponentType.name(EventLog.componentType),
+    let logName = name->ComponentType.name(EventLog.componentType)
+    let storage = Storage.make(~name=logName, ~owner, ~opts)
+
+    // Announce the log to any registered extension. No-op unless a deploy program
+    // registered a backend via EventLogProvisioning.use — see
+    // src/adapter/EventLogProvisioning/EventLogProvisioning.res.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name=logName,
       ~owner,
+      ~resources=storage.resources,
       ~opts,
     )
 

package/src/components/EventLog/EventLog_Builder.res.mjs

@@ -7,6 +7,7 @@ import * as Util_Pulumi$ReventlessCore from "../../util/Util_Pulumi.res.mjs";
 import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
 import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Builder.res.mjs";
 import * as EventLog_Operations$ReventlessCore from "./EventLog_Operations.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "../../adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
 
 function Make(Spec) {
   return Storage => (EventTopicPublisher => {
@@ -15,7 +16,9 @@ function Make(Spec) {
       let opts = {
         parent: opts_parent
       };
-      let storage = Storage.make(ComponentType$ReventlessCore.name(extra$1, EventLog$ReventlessCore.componentType), owner, opts);
+      let logName = ComponentType$ReventlessCore.name(extra$1, EventLog$ReventlessCore.componentType);
+      let storage = Storage.make(logName, owner, opts);
+      EventLogProvisioning$ReventlessCore.notify("Classic", logName, owner, storage.resources, opts);
       let SpecificEventTopic = EventTopic_Builder$ReventlessCore.Make(Spec)(EventTopicPublisher);
       let eventTopic = SpecificEventTopic.make(extra$1, storage.resources, owner, Util_Pulumi$ReventlessCore.ComponentResourceOptions.ofCustomResourceOptions(opts));
       Component$ReventlessCore.setOperations(extra, Pulumi.all([

package/tests/adapter/EventLogProvisioningTest.res

@@ -0,0 +1,207 @@
+open JestGlobals
+
+// The registry only forwards `~resources` and `~opts`; it never reads their
+// fields. A structural stand-in keeps @pulumi/pulumi (whose Output.make would
+// build a real resource) out of the Jest run — its ESM entry can't be imported
+// under Jest. Same reason as MonitoringTest's stub.
+let stubResource: ReventlessInfra.Adapter.resource = %raw(`{}`)
+let noOpts: Pulumi.CustomResourceOptions.t = {}
+
+let classicOwner: ResourceAttribution.owner = {kind: ComponentType.Aggregate, name: "Product"}
+let dcbOwner: ResourceAttribution.owner = {kind: ComponentType.Plugin, name: "Catalog"}
+
+describe("EventLogProvisioning", () => {
+  testSync("Noop default: notify is silent and does not throw", () => {
+    // No backend registered — the default Noop backend swallows the call.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    expect(true)->toBe(true)
+  })
+
+  testSync("use registers a backend that receives every notify, style and name", () => {
+    let recorded: array<(EventLogProvisioning.logStyle, string)> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => recorded->Array.push((logStyle, name))
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(recorded)->toEqual([
+      (EventLogProvisioning.Classic, "ProductEventLog"),
+      (EventLogProvisioning.Dcb, "CatalogDcbEventLog"),
+    ])
+
+    // Restore the default so registry state doesn't leak to other cases.
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen: ref<
+      option<(option<ResourceAttribution.owner>, array<ReventlessInfra.Adapter.resource>)>,
+    > = ref(None)
+    module Capture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) => seen := Some((owner, resources))
+    }
+    EventLogProvisioning.use(module(Capture: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[stubResource],
+      ~opts=noOpts,
+    )
+    switch seen.contents {
+    | Some((owner, resources)) =>
+      expect(owner)->toEqual(Some(classicOwner))
+      expect(resources)->toHaveLength(1)
+    | None => expect("no notify received")->toBe("a notify")
+    }
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    // Postgres and in-memory adapters return `resources: []`. Backends that only
+    // implement a DynamoDB arm ignore those; the seam does not filter for them.
+    let styles: array<EventLogProvisioning.logStyle> = []
+    module Recorder: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources,
+        ~opts as _,
+      ) =>
+        if resources->Array.length == 0 {
+          styles->Array.push(logStyle)
+        }
+    }
+    EventLogProvisioning.use(module(Recorder: EventLogProvisioning.Backend))
+
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(styles)->toEqual([EventLogProvisioning.Dcb])
+    EventLogProvisioning.reset()
+  })
+
+  testSync("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen: array<(option<string>, option<string>)> = []
+    module OwnerCapture: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin,
+        ~platform,
+        ~resources as _,
+        ~opts as _,
+      ) => seen->Array.push((plugin, platform))
+    }
+    EventLogProvisioning.use(module(OwnerCapture: EventLogProvisioning.Backend))
+
+    // Outside any plugin construct: both None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="ProductEventLog",
+      ~owner=Some(classicOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    // Inside a construct scope (what Plugin_Builder.construct establishes): both delivered.
+    let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Catalog")
+    EventLogProvisioning.notify(
+      ~logStyle=Dcb,
+      ~name="CatalogDcbEventLog",
+      ~owner=Some(dcbOwner),
+      ~resources=[],
+      ~opts=noOpts,
+    )
+    ResourceAttribution.restore(prev)
+
+    // After restore: back to None.
+    EventLogProvisioning.notify(
+      ~logStyle=Classic,
+      ~name="OrderEventLog",
+      ~owner=None,
+      ~resources=[],
+      ~opts=noOpts,
+    )
+
+    expect(seen)->toEqual([(None, None), (Some("Catalog"), Some("online-shop")), (None, None)])
+
+    EventLogProvisioning.reset()
+  })
+
+  testSync("use is single-slot: a second registration throws rather than silently winning", () => {
+    module First: EventLogProvisioning.Backend = {
+      let onProvisioned = (
+        ~logStyle as _,
+        ~name as _,
+        ~owner as _,
+        ~plugin as _,
+        ~platform as _,
+        ~resources as _,
+        ~opts as _,
+      ) => ()
+    }
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+
+    let threw = try {
+      EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+
+    // reset clears the slot, so a later registration succeeds again.
+    EventLogProvisioning.reset()
+    EventLogProvisioning.use(module(First: EventLogProvisioning.Backend))
+    EventLogProvisioning.reset()
+  })
+})

package/tests/adapter/EventLogProvisioningTest.res.mjs

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ResourceAttribution$ReventlessCore from "../../src/ResourceAttribution.res.mjs";
+import * as EventLogProvisioning$ReventlessCore from "../../src/adapter/EventLogProvisioning/EventLogProvisioning.res.mjs";
+
+let stubResource = {};
+
+let noOpts = {};
+
+let classicOwner = {
+  kind: "Aggregate",
+  name: "Product"
+};
+
+let dcbOwner = {
+  kind: "Plugin",
+  name: "Catalog"
+};
+
+globalThis.describe("EventLogProvisioning", () => {
+  globalThis.test("Noop default: notify is silent and does not throw", () => {
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("use registers a backend that receives every notify, style and name", () => {
+    let recorded = [];
+    let onProvisioned = (logStyle, name, param, param$1, param$2, param$3, param$4) => {
+      recorded.push([
+        logStyle,
+        name
+      ]);
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(recorded).toEqual([
+      [
+        "Classic",
+        "ProductEventLog"
+      ],
+      [
+        "Dcb",
+        "CatalogDcbEventLog"
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify forwards the owner and the adapter's resources unchanged", () => {
+    let seen = {
+      contents: undefined
+    };
+    let onProvisioned = (param, param$1, owner, param$2, param$3, resources, param$4) => {
+      seen.contents = [
+        owner,
+        resources
+      ];
+    };
+    let Capture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Capture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [stubResource], noOpts);
+    let match = seen.contents;
+    if (match !== undefined) {
+      globalThis.expect(match[0]).toEqual(classicOwner);
+      globalThis.expect(match[1]).toHaveLength(1);
+    } else {
+      globalThis.expect("no notify received").toBe("a notify");
+    }
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("a Postgres-style log with no resources still fires — the contract is uniform", () => {
+    let styles = [];
+    let onProvisioned = (logStyle, param, param$1, param$2, param$3, resources, param$4) => {
+      if (resources.length === 0) {
+        styles.push(logStyle);
+        return;
+      }
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(Recorder);
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    globalThis.expect(styles).toEqual(["Dcb"]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
+    let seen = [];
+    let onProvisioned = (param, param$1, param$2, plugin, platform, param$3, param$4) => {
+      seen.push([
+        plugin,
+        platform
+      ]);
+    };
+    let OwnerCapture = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(OwnerCapture);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "ProductEventLog", classicOwner, [], noOpts);
+    let prev = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    EventLogProvisioning$ReventlessCore.notify("Dcb", "CatalogDcbEventLog", dcbOwner, [], noOpts);
+    ResourceAttribution$ReventlessCore.restore(prev);
+    EventLogProvisioning$ReventlessCore.notify("Classic", "OrderEventLog", undefined, [], noOpts);
+    globalThis.expect(seen).toEqual([
+      [
+        undefined,
+        undefined
+      ],
+      [
+        "Catalog",
+        "online-shop"
+      ],
+      [
+        undefined,
+        undefined
+      ]
+    ]);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+  globalThis.test("use is single-slot: a second registration throws rather than silently winning", () => {
+    let onProvisioned = (param, param$1, param$2, param$3, param$4, param$5, param$6) => {};
+    let First = {
+      onProvisioned: onProvisioned
+    };
+    EventLogProvisioning$ReventlessCore.use(First);
+    let threw;
+    try {
+      EventLogProvisioning$ReventlessCore.use(First);
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    EventLogProvisioning$ReventlessCore.reset();
+    EventLogProvisioning$ReventlessCore.use(First);
+    EventLogProvisioning$ReventlessCore.reset();
+  });
+});
+
+export {
+  stubResource,
+  noOpts,
+  classicOwner,
+  dcbOwner,
+}
+/*  Not a pure module */