@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.251

package/src/adapter/DomainMCP_Server.res

@@ -91,6 +91,7 @@ let registerResourcesFromEntries = (
         ],
       }
     }
+
     // URIs with template parameters ({id}) go into resource templates;
     // fixed URIs (list endpoints) go into regular resources.
     if def.uriTemplate->String.includes("{") {
@@ -237,9 +238,7 @@ let createServerInstance = (identity: Reventless.Identity.t) => {
         }
         await handler(uri)
       | None => {
-          McpSdk.contents: [
-            {McpSdk.uri, text: `{"error": "Resource not found: ${uri}"}`},
-          ],
+          McpSdk.contents: [{McpSdk.uri, text: `{"error": "Resource not found: ${uri}"}`}],
         }
       }
     }
@@ -250,45 +249,47 @@ let createServerInstance = (identity: Reventless.Identity.t) => {
 
 let start = (~port: int=3001, ()) => {
   let httpServer = McpSdk.createHttpServer((req, res) => {
-    let _ = (async () => {
-      let reqMethod = req->McpSdk.method
-      let reqUrl = req->McpSdk.url
-
-      // CORS headers for browser-based clients (e.g. MCP Inspector)
-      res->McpSdk.setHeader("Access-Control-Allow-Origin", "*")
-      res->McpSdk.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
-      res->McpSdk.setHeader("Access-Control-Allow-Headers", "Content-Type")
-
-      if reqUrl == "/mcp" || reqUrl->String.startsWith("/mcp?") {
-        switch reqMethod {
-        | "OPTIONS" =>
-          res->McpSdk.setStatusCode(204)
-          res->McpSdk.endResponseNoBody
-        | "POST" =>
-          let body = await McpSdk_Helpers.parseJsonBody(req)
-          let identity = extractIdentity(req)
-          // Stateless mode: fresh server + transport per request
-          let server = createServerInstance(identity)
-          let transport = McpSdk.newStreamableHTTPTransport({
-            enableJsonResponse: true,
-          })
-          let _ = await server->McpSdk.connect(transport)
-          let _ = await transport->McpSdk.handleRequest(req, res, body)
-        | "GET" =>
-          res->McpSdk.setHeader("Content-Type", "text/plain")
-          res->McpSdk.endResponse("MCP server running")
-        | "DELETE" =>
-          res->McpSdk.setStatusCode(200)
-          res->McpSdk.endResponseNoBody
-        | _ =>
-          res->McpSdk.setStatusCode(405)
-          res->McpSdk.endResponse("Method not allowed")
+    let _ = (
+      async () => {
+        let reqMethod = req->McpSdk.method
+        let reqUrl = req->McpSdk.url
+
+        // CORS headers for browser-based clients (e.g. MCP Inspector)
+        res->McpSdk.setHeader("Access-Control-Allow-Origin", "*")
+        res->McpSdk.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
+        res->McpSdk.setHeader("Access-Control-Allow-Headers", "Content-Type")
+
+        if reqUrl == "/mcp" || reqUrl->String.startsWith("/mcp?") {
+          switch reqMethod {
+          | "OPTIONS" =>
+            res->McpSdk.setStatusCode(204)
+            res->McpSdk.endResponseNoBody
+          | "POST" =>
+            let body = await McpSdk_Helpers.parseJsonBody(req)
+            let identity = extractIdentity(req)
+            // Stateless mode: fresh server + transport per request
+            let server = createServerInstance(identity)
+            let transport = McpSdk.newStreamableHTTPTransport({
+              enableJsonResponse: true,
+            })
+            let _ = await server->McpSdk.connect(transport)
+            let _ = await transport->McpSdk.handleRequest(req, res, body)
+          | "GET" =>
+            res->McpSdk.setHeader("Content-Type", "text/plain")
+            res->McpSdk.endResponse("MCP server running")
+          | "DELETE" =>
+            res->McpSdk.setStatusCode(200)
+            res->McpSdk.endResponseNoBody
+          | _ =>
+            res->McpSdk.setStatusCode(405)
+            res->McpSdk.endResponse("Method not allowed")
+          }
+        } else {
+          res->McpSdk.setStatusCode(404)
+          res->McpSdk.endResponse("Not found")
         }
-      } else {
-        res->McpSdk.setStatusCode(404)
-        res->McpSdk.endResponse("Not found")
       }
-    })()
+    )()
   })
 
   httpServer->McpSdk.listen(port, () => {
@@ -301,7 +302,10 @@ let start = (~port: int=3001, ()) => {
       toolNames->Array.forEach(t => log.info(~comp="MCP:Domain", `  - ${t}`))
       log.info(~comp="MCP:Domain", `resources (${resourceNames->Array.length->Int.toString}):`)
       resourceNames->Array.forEach(r => log.info(~comp="MCP:Domain", `  - ${r}`))
-      log.info(~comp="MCP:Domain", `resource templates (${templateNames->Array.length->Int.toString}):`)
+      log.info(
+        ~comp="MCP:Domain",
+        `resource templates (${templateNames->Array.length->Int.toString}):`,
+      )
       templateNames->Array.forEach(r => log.info(~comp="MCP:Domain", `  - ${r}`))
     }
   })

package/src/adapter/EventCollector/LocalEventCollectorChannel.res

@@ -10,11 +10,11 @@ module Make = (Bus: LocalBus.T) => {
   type channelParts = unit
   type runtimeParts = LocalRuntimeEnvironment.parts
 
-  let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'context, channelParts> = (
-    ~name as _,
-    ~eventTopics,
-    ~owner as _, ~opts as _,
-  ) => {
+  let make: ReventlessCore.EventCollector_Adapter.channelMaker<
+    callbackEvent,
+    'context,
+    channelParts,
+  > = (~name as _, ~eventTopics, ~owner as _, ~opts as _) => {
     // Collect all event topic resources as our channel resources
     let eventTopicResources =
       eventTopics
@@ -26,8 +26,8 @@ module Make = (Bus: LocalBus.T) => {
       resources: eventTopicResources,
       enqueueEvent: ((_, _, _) => Promise.resolve())->Pulumi.Output.make,
       handleChannelEvent: (handleEvents: ReventlessCore.EventCollector.jsonEventsHandler) =>
-        ((json: JSON.t, _ctx) =>
-          handleEvents(Stream.fromIterable([json]))->Effect.map(_ => ())
+        (
+          (json: JSON.t, _ctx) => handleEvents(Stream.fromIterable([json]))->Effect.map(_ => ())
         )->Pulumi.Output.make,
     }
   }
@@ -43,43 +43,54 @@ module Make = (Bus: LocalBus.T) => {
     let _reg =
       runtime.parts.handlerDeferred
       ->Deferred.await_
-      ->Effect.flatMap(handler => Effect.sync(() => Bus.registerEventCollectorHandler(name, handler)))
+      ->Effect.flatMap(handler =>
+        Effect.sync(() => Bus.registerEventCollectorHandler(name, handler))
+      )
       ->Effect.runPromise
       ->ignore
 
-    channelSpecs->Array.forEach(({eventTopics}: ReventlessCore.EventCollector_Adapter.channelSpec<
-      callbackEvent,
-      'context,
-      channelParts,
-    >) => {
+    channelSpecs->Array.forEach((
+      {eventTopics}: ReventlessCore.EventCollector_Adapter.channelSpec<
+        callbackEvent,
+        'context,
+        channelParts,
+      >,
+    ) => {
       eventTopics
       ->Dict.valuesToArray
       ->Array.forEach((topicOutputs: ReventlessCore.EventTopic.outputs) => {
-        topicOutputs.resources->Array.forEach(resource => {
-          // resource.name is the bus topic key set by LocalEventTopicPublisher
-          let _ = resource.name->Pulumi.Output.apply(topicName => {
-            // Stream-based drain: subscribeToEventStream returns a scoped Effect that
-            // yields Stream<queuedEvent>. done_ is run explicitly after each handler call
-            // to unblock publishEvent.
-            let drainEffect = Effect.scoped(
-              Bus.subscribeToEventStream(topicName)
-              ->Effect.flatMap(stream =>
-                stream->Stream.runForEach(msg =>
-                  Effect.promise(async () => {
-                    let handler =
-                      await runtime.parts.handlerDeferred->Deferred.await_->Effect.runPromise
-                    await handler(msg.json, ())
-                  })
-                  ->Effect.zipRight(msg.done_)
+        topicOutputs.resources->Array.forEach(
+          resource => {
+            // resource.name is the bus topic key set by LocalEventTopicPublisher
+            let _ = resource.name->Pulumi.Output.apply(
+              topicName => {
+                // Stream-based drain: subscribeToEventStream returns a scoped Effect that
+                // yields Stream<queuedEvent>. done_ is run explicitly after each handler call
+                // to unblock publishEvent.
+                let drainEffect = Effect.scoped(
+                  Bus.subscribeToEventStream(topicName)->Effect.flatMap(
+                    stream =>
+                      stream->Stream.runForEach(
+                        msg =>
+                          Effect.promise(
+                            async () => {
+                              let handler = await runtime.parts.handlerDeferred
+                              ->Deferred.await_
+                              ->Effect.runPromise
+                              await handler(msg.json, ())
+                            },
+                          )->Effect.zipRight(msg.done_),
+                      ),
+                  ),
                 )
-              ),
+                let _ = Effect.runFork(drainEffect)
+                // Signal that this topic's subscription is registered.
+                // Latch.open_ is idempotent — calling it for multiple topics is safe.
+                runtime.parts.subscriptionLatch->Latch.open_->Effect.runPromise->ignore
+              },
             )
-            let _ = Effect.runFork(drainEffect)
-            // Signal that this topic's subscription is registered.
-            // Latch.open_ is idempotent — calling it for multiple topics is safe.
-            runtime.parts.subscriptionLatch->Latch.open_->Effect.runPromise->ignore
-          })
-        })
+          },
+        )
       })
     })
     []

package/src/adapter/EventHistory/EventHistoryResolvers_GraphQL.res

@@ -123,10 +123,12 @@ let readFilter = (args: JSON.t): filter => {
     entityId: ?s("entityId"),
     tagKey: ?s("tagKey"),
     tagValue: ?s("tagValue"),
-    eventTypes: ?f
-    ->Dict.get("eventTypes")
-    ->Option.flatMap(JSON.Decode.array)
-    ->Option.map(a => a->Array.filterMap(JSON.Decode.string)),
+    eventTypes: ?(
+      f
+      ->Dict.get("eventTypes")
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.map(a => a->Array.filterMap(JSON.Decode.string))
+    ),
     user: ?s("user"),
     timeFrom: ?s("timeFrom"),
     timeTo: ?s("timeTo"),
@@ -193,7 +195,10 @@ let matchesTag = (r: record, f: filter): bool =>
 
 let matchesFilter = (r: record, f: filter): bool => {
   let userOf = () =>
-    r.meta->JSON.Decode.object->Option.flatMap(d => d->Dict.get("user"))->Option.flatMap(JSON.Decode.string)
+    r.meta
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("user"))
+    ->Option.flatMap(JSON.Decode.string)
   let timeOf = () =>
     r.meta
     ->JSON.Decode.object
@@ -309,8 +314,7 @@ module Make = (Bus: LocalBus.T) => {
     envelopes->Array.mapWithIndex((json, i) => {
       let obj = json->JSON.Decode.object->Option.getOr(Dict.make())
       let event = obj->Dict.get("event")->Option.getOr(JSON.Encode.null)
-      let id =
-        obj->Dict.get("id")->Option.flatMap(JSON.Decode.string)->Option.getOr(entityId)
+      let id = obj->Dict.get("id")->Option.flatMap(JSON.Decode.string)->Option.getOr(entityId)
       let meta = metaJsonFromEnvelope(obj)
       let time =
         meta
@@ -386,11 +390,10 @@ module Make = (Bus: LocalBus.T) => {
         // not disagree about arguments or return type. (The supporting types
         // reach the server separately, via `schemaTypeRegistrationHook` over
         // the fragment's `types`.)
-        let sdlFields =
-          Plugin_EventQuerySchema.generate(
-            ~plugin=params.pluginName,
-            ~eventLogEntries=[entry],
-          ).queryFields
+        let sdlFields = Plugin_EventQuerySchema.generate(
+          ~plugin=params.pluginName,
+          ~eventLogEntries=[entry],
+        ).queryFields
 
         server.registerQueries(~sdlFields, ~resolvers=Dict.fromArray([(fieldName, resolver)]))
       }

package/src/adapter/EventLog/EventLogStorage_InMemory.res

@@ -50,8 +50,9 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
   let replay: ReventlessCore.EventLog.replay<string, JSON.t> = id =>
     replayStream(id)->Stream.runCollect->Effect.runPromise
 
-  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id =>
-    Ok(snapshots->Dict.get(id))
+  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id => Ok(
+    snapshots->Dict.get(id),
+  )
 
   let writeSnapshot: ReventlessCore.EventLog.writeSnapshot<string> = async (id, snap) => {
     snapshots->Dict.set(id, snap)
@@ -60,7 +61,11 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
 
   // Appends each stream item sequentially to storage.
   // Node.js is single-threaded so a plain ref is safe for the seqNr counter.
-  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) => {
+  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (
+    startingSeqNr,
+    id,
+    stream,
+  ) => {
     let seqNrRef = ref(startingSeqNr)
     stream->Stream.runForEach(json =>
       Stm.TRef.modify(eventsRef, events => {
@@ -78,7 +83,7 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
         switch result {
         | Ok() =>
           seqNrRef := seqNrRef.contents + 1
-          Effect.succeed(())
+          Effect.succeed()
         | Error(msg) => Effect.fail(msg)
         }
       )

package/src/adapter/EventLog/EventLogStorage_Sqlite.res

@@ -58,27 +58,32 @@ let countAll = (db: SqliteDriver.t): int => {
 let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   ensureSchema(db)
 
-  let insertStmt = db->SqliteDriver.prepare(
-    "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)",
-  )
+  let insertStmt =
+    db->SqliteDriver.prepare(
+      "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)",
+    )
   // Expected next seq_nr for an aggregate. Events are always appended
   // contiguously from seq 0 (the OCC check below forbids gaps), so
   // `MAX(seq_nr)+1` equals the row count — but it reads the rightmost leaf of the
   // (log_name, aggregate_id, seq_nr) PK index in O(log n) instead of `COUNT(*)`
   // scanning every row for the aggregate. `COALESCE(…, -1)+1` yields 0 when empty.
-  let nextSeqStmt = db->SqliteDriver.prepare(
-    "SELECT COALESCE(MAX(seq_nr), -1) + 1 AS c FROM event_log WHERE log_name=? AND aggregate_id=?",
-  )
-  let selectByIdStmt = db->SqliteDriver.prepare(
-    "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? AND seq_nr >= ? ORDER BY seq_nr ASC",
-  )
+  let nextSeqStmt =
+    db->SqliteDriver.prepare(
+      "SELECT COALESCE(MAX(seq_nr), -1) + 1 AS c FROM event_log WHERE log_name=? AND aggregate_id=?",
+    )
+  let selectByIdStmt =
+    db->SqliteDriver.prepare(
+      "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? AND seq_nr >= ? ORDER BY seq_nr ASC",
+    )
   let lastRowidStmt = db->SqliteDriver.prepare("SELECT last_insert_rowid() AS r")
-  let upsertSnapshotStmt = db->SqliteDriver.prepare(
-    "INSERT OR REPLACE INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash) VALUES(?,?,?,?,?)",
-  )
-  let selectSnapshotStmt = db->SqliteDriver.prepare(
-    "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name=? AND aggregate_id=?",
-  )
+  let upsertSnapshotStmt =
+    db->SqliteDriver.prepare(
+      "INSERT OR REPLACE INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash) VALUES(?,?,?,?,?)",
+    )
+  let selectSnapshotStmt =
+    db->SqliteDriver.prepare(
+      "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name=? AND aggregate_id=?",
+    )
 
   let expectedNextSeq = (id: string): int =>
     switch nextSeqStmt->SqliteDriver.get([JSON.Encode.string(name), JSON.Encode.string(id)]) {
@@ -118,6 +123,7 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
         | None => 0
         }
       })
+
       // Register the committed batch as appended-but-not-yet-published for the
       // projection checkpoint low-watermark; Platform's afterPublish hook
       // resolves the msgIds once the publish cycle completes. A transaction's
@@ -160,11 +166,7 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
 
   let replayArray = (id: string, ~fromSeq=0): array<JSON.t> =>
     selectByIdStmt
-    ->SqliteDriver.all([
-      JSON.Encode.string(name),
-      JSON.Encode.string(id),
-      JSON.Encode.int(fromSeq),
-    ])
+    ->SqliteDriver.all([JSON.Encode.string(name), JSON.Encode.string(id), JSON.Encode.int(fromSeq)])
     ->Array.map(decodePayload)
 
   let replay: EventLog.replay<string, JSON.t> = async id => replayArray(id)
@@ -172,7 +174,7 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   // node:sqlite's iterate() could back a lazy stream, but the current Stream
   // API only has array-based fromIterable. Small events, dev-only backend →
   // materialise via all() and wrap. Swap to a lazy adapter if it matters.
-  let replayStream = (id, ~fromSeq=?) => replayArray(id, ~fromSeq=?fromSeq)->Stream.fromIterable
+  let replayStream = (id, ~fromSeq=?) => replayArray(id, ~fromSeq?)->Stream.fromIterable
 
   let latestSnapshot: EventLog.latestSnapshot<string> = async id =>
     try {
@@ -197,7 +199,10 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
     } catch {
     | exn =>
       Error(
-        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("snapshot read error"),
+        exn
+        ->JsExn.fromException
+        ->Option.flatMap(JsExn.message)
+        ->Option.getOr("snapshot read error"),
       )
     }
 
@@ -230,7 +235,9 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
     stream
     ->Stream.runCollect
     ->Effect.flatMap(jsons =>
-      Effect.promise(() => appendTracked(~track=false, startingSeqNr, id, jsons))->Effect.flatMap(result =>
+      Effect.promise(() =>
+        appendTracked(~track=false, startingSeqNr, id, jsons)
+      )->Effect.flatMap(result =>
         switch result {
         | Ok() => Effect.succeed()
         // appendStream's error channel is a string; map the typed append error.
@@ -257,7 +264,12 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   )
 }
 
-module Make = (Bus: LocalBus.T, DbProvider: {let db: SqliteDriver.t}) => {
+module Make = (
+  Bus: LocalBus.T,
+  DbProvider: {
+    let db: SqliteDriver.t
+  },
+) => {
   let make: EventLog_Adapter.storageMaker = (~name, ~owner as _, ~opts) => {
     let (storageName, replay, storage) = makeStorage(~db=DbProvider.db, ~name, ~opts)
     Bus.registerEventLogReplay(storageName, replay)

package/src/adapter/EventTopic/LocalEventTopicPublisher.res

@@ -2,7 +2,12 @@
 // The resource name doubles as the bus topic key that EventCollectorChannel subscribes to.
 
 module Make = (Bus: LocalBus.T) => {
-  let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageResources as _, ~owner as _, ~opts as _) => {
+  let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (
+    ~name,
+    ~storageResources as _,
+    ~owner as _,
+    ~opts as _,
+  ) => {
     let publishJson = (service, meta, json) => Bus.publishEvent(name, service, meta, json)
     let publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream = stream =>
       stream
@@ -10,8 +15,9 @@ module Make = (Bus: LocalBus.T) => {
       ->Stream.runForEach(items =>
         Effect.promise(() =>
           items
-          ->Array.map(({ReventlessInfra.EventTopic.service, meta, json}) =>
-            publishJson(service, meta, json)
+          ->Array.map(
+            ({ReventlessInfra.EventTopic.service: service, meta, json}) =>
+              publishJson(service, meta, json),
           )
           ->Promise.all
           ->Promise.thenResolve(_ => ())

package/src/adapter/Heartbeat/LocalHeartbeatRunner.res

@@ -32,20 +32,15 @@ let make: ReventlessCore.Heartbeat_Adapter.runnerMaker<runtimeParts> = (
 ) => {
   let handlerDeferred = runtime.parts.handlerDeferred
   let intervalMs = timeout * 60 * 1000
-  let handle = setIntervalJs(
-    () => {
-      // Await the handler Deferred on each tick. Since the Deferred is completed
-      // during make() setup, this resolves immediately after the first tick.
-      handlerDeferred
-      ->Deferred.await_
-      ->Effect.flatMap(handler =>
-        Effect.promise(() => handler(Obj.magic(()), ()))
-      )
-      ->Effect.runPromise
-      ->ignore
-    },
-    intervalMs,
-  )
+  let handle = setIntervalJs(() => {
+    // Await the handler Deferred on each tick. Since the Deferred is completed
+    // during make() setup, this resolves immediately after the first tick.
+    handlerDeferred
+    ->Deferred.await_
+    ->Effect.flatMap(handler => Effect.promise(() => handler(Obj.magic(), ())))
+    ->Effect.runPromise
+    ->ignore
+  }, intervalMs)
   activeTimers.contents->Dict.set(name, handle)
   {resources: []}
 }

package/src/adapter/LocalBus.res

@@ -66,6 +66,7 @@ let emitEventTap = (~topic: string, ~service: string, ~payload: JSON.t) => {
   // later sees is the event's ordinal rather than the ordinal of its own arrival.
   eventTapSeq := eventTapSeq.contents + 1
   let toStdout = LocalEventTap.stdoutEnabled()
+
   // The line is built only for somebody: serialising every event for no reader is
   // pure cost on the publish path.
   if toStdout || LocalEventTap.hasReaders() {
@@ -296,8 +297,8 @@ module Impl = (C: BusConfig): T => {
           // draining, and run `done_` via `ensuring` so the countdown always
           // advances regardless of outcome.
           Effect.tryPromise(~catch=e => e, () => handler(msg.service, msg.meta, msg.json))
-          ->Effect.catchAll(err =>
-            Effect.sync(() => Console.error2("[LocalBus] subscriber handler failed:", err))
+          ->Effect.catchAll(
+            err => Effect.sync(() => Console.error2("[LocalBus] subscriber handler failed:", err)),
           )
           ->Effect.ensuring(msg.done_)
         )
@@ -404,11 +405,10 @@ module Impl = (C: BusConfig): T => {
       let pending = queue.contents
       queue.contents = []
       pending->Array.forEach(json => {
-        let _ =
-          handler(json, ())->Promise.catch(e => {
-            Console.error2("[LocalBus] parked command handler failed:", e)
-            Promise.resolve()
-          })
+        let _ = handler(json, ())->Promise.catch(e => {
+          Console.error2("[LocalBus] parked command handler failed:", e)
+          Promise.resolve()
+        })
       })
     | None => ()
     }
@@ -461,14 +461,14 @@ module Impl = (C: BusConfig): T => {
   // Cross-plugin subscriptions are fire-and-forget: the handler is started asynchronously
   // and done_ is called immediately. This prevents a deadlock where publishEvent on the
   // EP topic would block until the downstream aggregate command chain completes.
-  let makeFireAndForgetHandler = handler => (_, _, json) => {
-    let _ =
-      handler(json, ())->Promise.catch(e => {
+  let makeFireAndForgetHandler = handler =>
+    (_, _, json) => {
+      let _ = handler(json, ())->Promise.catch(e => {
         Console.error2("[LocalBus] fire-and-forget handler failed:", e)
         Promise.resolve()
       })
-    Promise.resolve()
-  }
+      Promise.resolve()
+    }
 
   let registerEventCollectorHandler = (ecName, handler) => {
     eventCollectorHandlers.contents->Dict.set(ecName, handler)

package/src/adapter/LocalCapabilities.res

@@ -27,4 +27,10 @@ let registerMessagingSender = (sender: string) => messagingSenderRef := sender
 let capabilities = (): Reventless.Capabilities.t => {
   geocode: Reventless.Capabilities.none.geocode,
   messaging: ReventlessCore.Messaging_Log_Backend.provider(~sender=messagingSenderRef.contents),
+  // Refusing rather than absent: the seam exists so a deployment can be asked
+  // what it provisions. Nothing writes back to the local user store yet, and
+  // answering `Unavailable` leaves the work queued and visible instead of
+  // recording a verdict against a person who has done nothing wrong.
+  identityProvider: Reventless.Capabilities.none.identityProvider,
+  secrets: ReventlessCore.Secrets_Node_Backend.provider,
 }

package/src/adapter/LocalCapabilities.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as Secrets_Node_Backend$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Secrets/Secrets_Node_Backend.res.mjs";
 import * as Messaging_Log_Backend$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Messaging/Messaging_Log_Backend.res.mjs";
 
 let messagingSenderRef = {
@@ -14,7 +15,9 @@ function registerMessagingSender(sender) {
 function capabilities() {
   return {
     geocode: Capabilities$Reventless.none.geocode,
-    messaging: Messaging_Log_Backend$ReventlessCore.provider(messagingSenderRef.contents)
+    messaging: Messaging_Log_Backend$ReventlessCore.provider(messagingSenderRef.contents),
+    identityProvider: Capabilities$Reventless.none.identityProvider,
+    secrets: Secrets_Node_Backend$ReventlessCore.provider
   };
 }
 
@@ -23,4 +26,4 @@ export {
   registerMessagingSender,
   capabilities,
 }
-/* Messaging_Log_Backend-ReventlessCore Not a pure module */
+/* Capabilities-Reventless Not a pure module */

package/src/adapter/LocalGeocodeResolvers.res

@@ -56,8 +56,5 @@ let register = (server: ReventlessGraphqlServer.GraphQL_ServerInstance.t): unit
     }
   })
   server.registerTypes(~sdlTypes=ReventlessCore.Platform_AdminApi.geocodeTypes)
-  server.registerQueries(
-    ~sdlFields=ReventlessCore.Platform_AdminApi.geocodeQueryFields,
-    ~resolvers,
-  )
+  server.registerQueries(~sdlFields=ReventlessCore.Platform_AdminApi.geocodeQueryFields, ~resolvers)
 }

package/src/adapter/LocalSideEffectHandler.res

@@ -40,7 +40,7 @@ let make = (
         eventCollector: eventCollectorOutputs,
       })
     },
-    ~opts=opts,
+    ~opts,
   )
 }
 

package/src/adapter/LocalStateChangeDescriptor.res

@@ -25,7 +25,8 @@
     Over the cap the state is dropped and the downgrade logged — a metadata-only
     descriptor still tells the client to refetch, where a failed publish would
     tell it nothing. */
-let maxStateChars = 60 * 1024
+let maxStateChars =
+  60 * 1024
 
 /** The `@retired` field of a registered read model, or `None`.