@reventlessdev/reventless-local 3.0.0-alpha.248 → 3.0.0-alpha.250

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.mjs

@@ -23,4 +23,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`.
 

package/src/adapter/MCP_ServerInstance.res

@@ -26,9 +26,21 @@ type diagnostics = {
 }
 
 type t = {
-  registerTool: (~name: string, ~definition: ReventlessCore.MCP_SchemaGenerator.mcpToolDefinition, ~handler: toolHandler) => unit,
-  registerResource: (~name: string, ~definition: ReventlessCore.MCP_SchemaGenerator.mcpResourceDefinition, ~handler: resourceHandler) => unit,
-  registerResourceTemplate: (~name: string, ~definition: ReventlessCore.MCP_SchemaGenerator.mcpResourceDefinition, ~handler: resourceHandler) => unit,
+  registerTool: (
+    ~name: string,
+    ~definition: ReventlessCore.MCP_SchemaGenerator.mcpToolDefinition,
+    ~handler: toolHandler,
+  ) => unit,
+  registerResource: (
+    ~name: string,
+    ~definition: ReventlessCore.MCP_SchemaGenerator.mcpResourceDefinition,
+    ~handler: resourceHandler,
+  ) => unit,
+  registerResourceTemplate: (
+    ~name: string,
+    ~definition: ReventlessCore.MCP_SchemaGenerator.mcpResourceDefinition,
+    ~handler: resourceHandler,
+  ) => unit,
   registerToolsFromEntries: (
     ~pluginName: string,
     ~mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,
@@ -248,9 +260,7 @@ let make = (~label: string="MCP"): 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}"}`}],
           }
         }
       }
@@ -261,43 +271,45 @@ let make = (~label: string="MCP"): t => {
 
   let start = (~port: int=3001, ()) => {
     let httpServer = McpSdk.createHttpServer((req, res) => {
-      let _ = (async () => {
-        let reqMethod = req->McpSdk.method
-        let reqUrl = req->McpSdk.url
+      let _ = (
+        async () => {
+          let reqMethod = req->McpSdk.method
+          let reqUrl = req->McpSdk.url
 
-        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")
+          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)
-            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(`${label} server running`)
-          | "DELETE" =>
-            res->McpSdk.setStatusCode(200)
-            res->McpSdk.endResponseNoBody
-          | _ =>
-            res->McpSdk.setStatusCode(405)
-            res->McpSdk.endResponse("Method not allowed")
+          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)
+              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(`${label} 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, () => {

package/src/adapter/ObjectStore/LocalObjectStore.res

@@ -83,11 +83,14 @@ let declaredStoreList = (): array<(string, string)> => declaredStores->Dict.toAr
 // key becomes a path, and `uploads/../../etc/passwd` would otherwise escape the
 // store.
 let servedKey = (path: string): option<string> => {
-  let trimmed = path->String.startsWith("/") ? path->String.slice(~start=1, ~end=path->String.length) : path
+  let trimmed =
+    path->String.startsWith("/") ? path->String.slice(~start=1, ~end=path->String.length) : path
   let segments = trimmed->String.split("/")
   let underAPrefix =
     servedPrefixes.contents->Array.some(p =>
-      p->String.length > 0 && trimmed->String.startsWith(p ++ "/") && trimmed->String.length > p->String.length + 1
+      p->String.length > 0 &&
+      trimmed->String.startsWith(p ++ "/") &&
+      trimmed->String.length > p->String.length + 1
     )
   if underAPrefix && segments->Array.every(seg => seg != "" && seg != "." && seg != "..") {
     Some(trimmed)

package/src/adapter/ObjectStore/ObjectStoreStorage_FileSystem.res

@@ -178,8 +178,7 @@ let topLevelPrefixes = (~root: string): array<string> =>
   | _ => None
   } {
   | None => []
-  | Some(entries) =>
-    entries->Array.filter(NodeFs.isDirectory)->Array.map(NodeFs.direntName)
+  | Some(entries) => entries->Array.filter(NodeFs.isDirectory)->Array.map(NodeFs.direntName)
   }
 
 /** Deletes every object under `prefix`, returning how many were removed. Goes

package/src/adapter/PlatformGraphQL_Server.res

@@ -27,16 +27,20 @@
 // — without the wrapper, anonymous callers could trigger admin mutations
 // (Plugin_Activate / _Deactivate, etc.) just by hitting the platform port.
 
-let instance: ReventlessGraphqlServer.GraphQL_ServerInstance.t = ReventlessGraphqlServer.GraphQL_ServerInstance.make(~label="GraphQL:Platform")
+let instance: ReventlessGraphqlServer.GraphQL_ServerInstance.t = ReventlessGraphqlServer.GraphQL_ServerInstance.make(
+  ~label="GraphQL:Platform",
+)
 
 // Wrap a resolver dict so every value enforces the Admin group. Keys are
 // preserved; resolvers fall through to the underlying instance once the
 // group check passes.
-let wrapAdmin = (
-  resolvers: dict<ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn>,
-): dict<ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn> => {
+let wrapAdmin = (resolvers: dict<ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn>): dict<
+  ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn,
+> => {
   let wrapped = Dict.make()
-  resolvers->Dict.toArray->Array.forEach(((k, v)) =>
+  resolvers
+  ->Dict.toArray
+  ->Array.forEach(((k, v)) =>
     wrapped->Dict.set(k, Auth_GraphqlContext.requireGroup(~group="Admin", v))
   )
   wrapped