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

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.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
+
+* **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.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-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-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-infra": "3.0.0-alpha.127",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
     "@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/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/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([