@reventlessdev/reventless-aws 3.0.0-alpha.344 → 3.0.0-alpha.345

package/src/adapter/EventCollector/EventCollectorChannel_Helpers.res

@@ -75,7 +75,9 @@ let subscribeQueue2SnsTopic = (
       ~topic=resource->ReventlessCore.AdapterDeploytime.resolvedToResource,
       ~opts,
     )
-    subscription.id->Pulumi.Output.apply(id => log.debug(~comp="EventCollector", `created SNS subscription: ${id} ${name}`))
+    subscription.id->Pulumi.Output.apply(id =>
+      log.debug(~comp="EventCollector", `created SNS subscription: ${id} ${name}`)
+    )
   })
 }
 
@@ -143,7 +145,9 @@ let connectLambda = (
     ->Pulumi.Output.flatMap(((eventTopicResources, queueArns, resources)) => {
       log.debug(
         ~comp="EventCollector",
-        `connectLambda ${name}: ${eventTopicResources->Array.length->Int.toString} topic resource(s), ${resources->Array.length->Int.toString} resource(s)`,
+        `connectLambda ${name}: ${eventTopicResources
+          ->Array.length
+          ->Int.toString} topic resource(s), ${resources->Array.length->Int.toString} resource(s)`,
       )
 
       let dynamoDbStreamResources = eventTopicResources->dynamoDbStreamResources

package/src/adapter/EventCollector/EventCollectorChannel_SQS.res

@@ -30,14 +30,19 @@ let connect = (
   lambda->connectLambda(name, lambdaRole, queues, eventTopics, resources, opts)
 }
 
-let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'context, channelParts> = (
-  ~name,
-  ~eventTopics,
-  ~owner, ~opts,
-) => {
+let make: ReventlessCore.EventCollector_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  channelParts,
+> = (~name, ~eventTopics, ~owner, ~opts) => {
   let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
 
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventCollector.componentType, ~role=EventCollector, ~owner?)
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.EventCollector.componentType,
+    ~role=EventCollector,
+    ~owner?,
+  )
   let queue = PulumiAws.SQS.Queue.make(
     ~name,
     ~args={
@@ -74,7 +79,9 @@ let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'con
 
   {
     ReventlessCore.EventCollector_Adapter.parts: {queue: queue},
-    resources: eventTopicResources->Array.concat([queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput)]),
+    resources: eventTopicResources->Array.concat([
+      queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput),
+    ]),
     enqueueEvent,
     handleChannelEvent,
   }

package/src/adapter/EventCollector/EventCollectorChannel_SQS_FIFO.res

@@ -4,14 +4,19 @@ type runtimeParts = Util.Lambda.runtimeParts
 
 let connect = EventCollectorChannel_SQS.connect
 
-let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'context, channelParts> = (
-  ~name,
-  ~eventTopics,
-  ~owner, ~opts,
-) => {
+let make: ReventlessCore.EventCollector_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  channelParts,
+> = (~name, ~eventTopics, ~owner, ~opts) => {
   let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
 
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventCollector.componentType, ~role=EventCollector, ~owner?)
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.EventCollector.componentType,
+    ~role=EventCollector,
+    ~owner?,
+  )
   let queue = PulumiAws.SQS.Queue.make(
     ~name,
     ~args={
@@ -52,7 +57,9 @@ let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'con
 
   {
     ReventlessCore.EventCollector_Adapter.parts: {queue: queue},
-    resources: eventTopicResources->Array.concat([queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput)]),
+    resources: eventTopicResources->Array.concat([
+      queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput),
+    ]),
     enqueueEvent,
     handleChannelEvent,
   }

package/src/adapter/EventCollector/EventCollectorChannel_SQS_Runtime.res

@@ -39,8 +39,7 @@ let handleDynamoDbOrSqsEvent = (queue, handleEvents) =>
       switch entries {
       | [] => Effect.succeed()
       | entries =>
-        Util.SQS_Runtime.deleteMessages(entries, queue)
-        ->Effect.catchAll(_err => Effect.succeed())
+        Util.SQS_Runtime.deleteMessages(entries, queue)->Effect.catchAll(_err => Effect.succeed())
       }
     )
   }
@@ -84,7 +83,11 @@ let enqueueFifoEvent = (queue: Util_SQS_Runtime.resolvedQueue, delay, id, messag
   )
   ->Effect.flatMap(_ =>
     Effect.promise(() =>
-      queue->Util_SQS_Runtime.sendFifoMessage(~delay, ~messageGroupId=Util_SQS_Runtime.safeGroupId(id), messageBody)
+      queue->Util_SQS_Runtime.sendFifoMessage(
+        ~delay,
+        ~messageGroupId=Util_SQS_Runtime.safeGroupId(id),
+        messageBody,
+      )
     )
   )
   ->Effect.map(_ => ())

package/src/adapter/EventLog/EventLogStorage_DynamoDbStream.res

@@ -1,5 +1,10 @@
 let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~owner, ~opts) => {
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventLog.componentType, ~role=EventLog, ~owner?)
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.EventLog.componentType,
+    ~role=EventLog,
+    ~owner?,
+  )
   let table = Util.DynamoDbStream.makeTable(
     name,
     ~attributes=[{name: "id", type_: "S"}, {name: "position", type_: "S"}],

package/src/adapter/EventLog/EventLogStorage_DynamoDb_Runtime.res

@@ -29,9 +29,8 @@ let transactWriteConditional = (tableName, jsons) => {
   let input: TransactWriteCommand.input = {
     transactItems: buildTransactItems(tableName, jsons),
   }
-  Effect.tryPromise(
-    ~catch=DynamoDb_Error.classify,
-    () => input->TransactWriteCommand.make->TransactWriteCommand.send,
+  Effect.tryPromise(~catch=DynamoDb_Error.classify, () =>
+    input->TransactWriteCommand.make->TransactWriteCommand.send
   )->Effect.map(_ => Ok())
 }
 
@@ -46,9 +45,8 @@ let appendWithCondition = (tableName, jsons) => {
       ),
     )
   } else if count == 1 {
-    Effect.tryPromise(
-      ~catch=DynamoDb_Error.classify,
-      () => putItemConditional(tableName, jsons->Array.getUnsafe(0)),
+    Effect.tryPromise(~catch=DynamoDb_Error.classify, () =>
+      putItemConditional(tableName, jsons->Array.getUnsafe(0))
     )->Effect.map(_ => Ok())
   } else {
     transactWriteConditional(tableName, jsons)
@@ -60,12 +58,13 @@ let append = table =>
     appendWithCondition(table.name, jsons)
     ->Effect.catchAll(err =>
       switch err {
-      | DynamoDb_Error.StaleState(_) =>
-        Effect.succeed(Error(ReventlessCore.EventLog.Conflict))
+      | DynamoDb_Error.StaleState(_) => Effect.succeed(Error(ReventlessCore.EventLog.Conflict))
       | _ =>
         let msg = DynamoDb_Error.message(err)
         Effect.succeed(
-          Error(ReventlessCore.EventLog.StorageFailure(`DynamoDB conditional append failed: ${msg}`)),
+          Error(
+            ReventlessCore.EventLog.StorageFailure(`DynamoDB conditional append failed: ${msg}`),
+          ),
         )
       }
     )
@@ -170,8 +169,9 @@ let writeSnapshot = table =>
 // pays for the events it returns.
 let replayStream = table =>
   (id, ~fromSeq=?) =>
-    queryStream(replayQueryInput(table.Util_DynamoDb_Runtime.name, id, ~fromSeq=?fromSeq))
-    ->Stream.catchAll(err => {
+    queryStream(
+      replayQueryInput(table.Util_DynamoDb_Runtime.name, id, ~fromSeq?),
+    )->Stream.catchAll(err => {
       let msg = DynamoDb_Error.message(err)
       Stream.fromEffect(Effect.fail(msg))
     })
@@ -185,8 +185,7 @@ let replay = table =>
       ReventlessCore.EffectLogger.logError(
         ~comp=__MODULE__,
         `Couldn't replay events for id ${id} after retries: ${msg}`,
-      )
-      ->Effect.flatMap(_ => Effect.fail(msg))
+      )->Effect.flatMap(_ => Effect.fail(msg))
     })
     ->Effect.runPromise
 
@@ -196,10 +195,7 @@ let appendStream = table =>
   (startingSeqNr, _id, stream) => {
     let seqNrRef = ref(startingSeqNr)
     stream->Stream.runForEach(json =>
-      Effect.tryPromise(
-        ~catch=DynamoDb_Error.classify,
-        () => putItemConditional(table.name, json),
-      )
+      Effect.tryPromise(~catch=DynamoDb_Error.classify, () => putItemConditional(table.name, json))
       ->Effect.map(_ => {
         seqNrRef := seqNrRef.contents + 1
       })

package/src/adapter/EventLog/EventLogStorage_Postgres.res

@@ -16,9 +16,10 @@ let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~owner as _, ~o
   // `event_log.log_name`. Register it so `makePlatform` can wire the change-feed
   // relay; the collector queue is attached later in forPluginEventCollector,
   // keyed by the aggregate name (the `~eventTopics` dict key).
-  let aggregateName = name->String.endsWith("EventLog")
-    ? name->String.slice(~start=0, ~end=name->String.length - 8)
-    : name
+  let aggregateName =
+    name->String.endsWith("EventLog")
+      ? name->String.slice(~start=0, ~end=name->String.length - 8)
+      : name
   EventLogBackend.registerRelayLog(~logName=name, ~aggregateName)
 
   let operations = switch EventLogBackend.get() {
@@ -28,7 +29,9 @@ let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~owner as _, ~o
     )
   | None =>
     // Selectable only routes here when a selection is set; guard defensively.
-    JsError.throwWithMessage("EventLogStorage_Postgres.make called without an EventLogBackend selection")
+    JsError.throwWithMessage(
+      "EventLogStorage_Postgres.make called without an EventLogBackend selection",
+    )
   }
   {
     ReventlessCore.EventLog_Adapter.resources: [],

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync.res

@@ -21,7 +21,7 @@ open PulumiAws
 // carrying `@/./:` etc. doesn't hit a silent-drop. Mirrors
 // AppSyncEventsSigner_Ops.pathSegment (the runtime handler's equivalent).
 let channelNameOf = (topicName: string): string =>
-  topicName->String.replaceRegExp(%re("/[^A-Za-z0-9-]/g"), "-")
+  topicName->String.replaceRegExp(/[^A-Za-z0-9-]/g, "-")
 
 // ── Deploy-time resource builder ──────────────────────────────────────────────
 
@@ -114,10 +114,7 @@ let make = (
 
   // IAM policy: SQS receive + AppSync Events publish
   let _ =
-    (
-      queue.arn,
-      eventsApi.api.apiArn,
-    )
+    (queue.arn, eventsApi.api.apiArn)
     ->Pulumi.Output.all2
     ->Pulumi.Output.apply(((queueArn, apiArn)) => {
       open PolicyDocument
@@ -165,7 +162,10 @@ let make = (
   // resolve-hook so `@rescript/runtime` resolves from the layer.
   let channelName = channelNameOf(topicName)
   let packageDirs = Dict.fromArray([
-    ("@reventlessdev/reventless-aws", Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws")),
+    (
+      "@reventlessdev/reventless-aws",
+      Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+    ),
   ])
   let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
     ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/EventLogSubscription/EventLogSubscription_AppSync_Ops.res.mjs",
@@ -192,7 +192,12 @@ let make = (
       memorySize: 128->Pulumi.Input.make,
       timeout: 30->Pulumi.Input.make,
       layers,
-      tags: AWS.Tags.make(~name=name ++ "EventLogSub", ~kind=ReventlessCore.EventTopic.componentType, ~role=EventLogSubscription, ~component=name),
+      tags: AWS.Tags.make(
+        ~name=name ++ "EventLogSub",
+        ~kind=ReventlessCore.EventTopic.componentType,
+        ~role=EventLogSubscription,
+        ~component=name,
+      ),
       environment: (
         {
           Lambda.Function.variables: Dict.fromArray([

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync_Ops.res

@@ -7,7 +7,6 @@
 // body, wraps it as a `{position, eventType, payload}` event, and publishes it
 // to the fixed plugin event-log channel on the AppSync Events API.
 
-
 // Baked at deploy time: the normalised channel segment for this event log.
 let channel = "/default/" ++ NodeProcess.env->Dict.get("EVENT_LOG_CHANNEL")->Option.getOr("")
 let endpoint = NodeProcess.env->Dict.get("APPSYNC_ENDPOINT")->Option.getOr("")
@@ -37,7 +36,10 @@ let processRecord = async (
       Dict.fromArray([
         ("id", JSON.Encode.string(record.messageId)),
         ("channel", JSON.Encode.string(channel)),
-        ("events", JSON.Encode.array([JSON.Encode.string(payload->JSON.Encode.object->JSON.stringify)])),
+        (
+          "events",
+          JSON.Encode.array([JSON.Encode.string(payload->JSON.Encode.object->JSON.stringify)]),
+        ),
       ])
       ->JSON.Encode.object
       ->JSON.stringify

package/src/adapter/EventTopic/EventTopicPublisher_DynamoDbStream.res

@@ -1,7 +1,8 @@
 let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (
   ~name as _,
   ~storageResources,
-  ~owner as _, ~opts as _,
+  ~owner as _,
+  ~opts as _,
 ) => {
   let storageResource = storageResources->Util.DynamoDbStream.findResource
 
@@ -20,6 +21,6 @@ let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (
       ->ReventlessCore.Adapter.outputToResource,
     ],
     publishJson: Pulumi.Output.make((_, _, _) => Promise.resolve()), // ignore
-    publishJsonStream: Pulumi.Output.make(_stream => Effect.succeed(())), // ignore
+    publishJsonStream: Pulumi.Output.make(_stream => Effect.succeed()), // ignore
   }
 }

package/src/adapter/EventTopic/EventTopicPublisher_SNS.res

@@ -4,14 +4,20 @@ open PulumiAws
     Read by subscriptionInfraHook (Phase 5) to skip non-SNS entries. */
 let snsRegistry: Set.t<string> = Set.make()
 
-let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageResources as _, ~owner, ~opts) => {
+let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (
+  ~name,
+  ~storageResources as _,
+  ~owner,
+  ~opts,
+) => {
   snsRegistry->Set.add(name)
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventTopic.componentType, ~role=EventTopic, ~owner?)
-  let topic = SNS.Topic.make(
+  let tags = AWS.Tags.make(
     ~name,
-    ~args={SNS.Topic.tags: tags},
-    ~opts,
+    ~kind=ReventlessCore.EventTopic.componentType,
+    ~role=EventTopic,
+    ~owner?,
   )
+  let topic = SNS.Topic.make(~name, ~args={SNS.Topic.tags: tags}, ~opts)
 
   let resolvedTopicOutput = topic->Util_SNS.toResolvedTopicOutput
 
@@ -26,13 +32,15 @@ let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageRes
         stream
         ->Stream.grouped(10)
         ->Stream.runForEach(items =>
-          Effect.promise(() =>
-            items
-            ->Array.map(({ReventlessInfra.EventTopic.service, meta, json}) =>
-              publishJson(service, meta, json)
-            )
-            ->Promise.all
-            ->Promise.thenResolve(_ => ())
+          Effect.promise(
+            () =>
+              items
+              ->Array.map(
+                ({ReventlessInfra.EventTopic.service: service, meta, json}) =>
+                  publishJson(service, meta, json),
+              )
+              ->Promise.all
+              ->Promise.thenResolve(_ => ()),
           )
         )
     }),

package/src/adapter/EventTopic/EventTopicPublisher_SNS_FIFO.res

@@ -1,7 +1,17 @@
 open PulumiAws
 
-let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageResources as _, ~owner, ~opts) => {
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventTopic.componentType, ~role=EventTopic, ~owner?)
+let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (
+  ~name,
+  ~storageResources as _,
+  ~owner,
+  ~opts,
+) => {
+  let tags = AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.EventTopic.componentType,
+    ~role=EventTopic,
+    ~owner?,
+  )
   let topic = SNS.Topic.make(
     ~name,
     ~args={
@@ -25,13 +35,15 @@ let make: ReventlessCore.EventTopic_Adapter.publisherMaker = (~name, ~storageRes
         stream
         ->Stream.grouped(10)
         ->Stream.runForEach(items =>
-          Effect.promise(() =>
-            items
-            ->Array.map(({ReventlessInfra.EventTopic.service, meta, json}) =>
-              publishJson(service, meta, json)
-            )
-            ->Promise.all
-            ->Promise.thenResolve(_ => ())
+          Effect.promise(
+            () =>
+              items
+              ->Array.map(
+                ({ReventlessInfra.EventTopic.service: service, meta, json}) =>
+                  publishJson(service, meta, json),
+              )
+              ->Promise.all
+              ->Promise.thenResolve(_ => ()),
           )
         )
     }),

package/src/adapter/EventTopic/EventTopicPublisher_SNS_Runtime.res

@@ -1,5 +1,7 @@
-let publish = (topic, _id, _meta, json) =>
-  topic->Util_SNS_Runtime.publish(json->JSON.stringify)
+let publish = (topic, _id, _meta, json) => topic->Util_SNS_Runtime.publish(json->JSON.stringify)
 
 let publishFifo = (topic, id, _meta, json) =>
-  topic->Util_SNS_Runtime.publishFifo(~messageGroupId=Util_SQS_Runtime.safeGroupId(id), ~message=json->JSON.stringify)
+  topic->Util_SNS_Runtime.publishFifo(
+    ~messageGroupId=Util_SQS_Runtime.safeGroupId(id),
+    ~message=json->JSON.stringify,
+  )

package/src/adapter/Geocoder/Geocoder_AwsLocation_Resolver.res

@@ -31,8 +31,7 @@ type serviceOutputs = {resources: array<Pulumi.Output.t<string>>}
 // forwarded — geocoding is not scoped per caller (any authenticated user may
 // resolve any address), unlike the upload service which namespaces objects by the
 // verified `sub`.
-let invokeCode: Pulumi.Input.t<string> =
-  `import { util } from '@aws-appsync/utils';
+let invokeCode: Pulumi.Input.t<string> = `import { util } from '@aws-appsync/utils';
 export function request(ctx) {
   return { operation: 'Invoke', payload: { arguments: ctx.args } };
 }
@@ -79,7 +78,11 @@ let make = (
               {
                 sid: "AllowLambdaLogging",
                 effect: Allow,
-                actions: Actions(["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]),
+                actions: Actions([
+                  "logs:CreateLogGroup",
+                  "logs:CreateLogStream",
+                  "logs:PutLogEvents",
+                ]),
                 resources: Resource("arn:aws:logs:*:*:*"),
               },
               {

package/src/adapter/Mcp/MCP_Lambda.res

@@ -133,7 +133,7 @@ let generateAdminConfig = (
 
 /** Extract entity ID from the last path segment (before any query string). */
 let extractEntityId = (uri: string) => {
-  let pathPart = (uri->String.split("?"))->Array.getUnsafe(0)
+  let pathPart = uri->String.split("?")->Array.getUnsafe(0)
   let segments = pathPart->String.split("/")
   segments->Array.at(-1)->Option.getOr("")
 }
@@ -145,26 +145,21 @@ let parsePaginationParams = (uri: string) => {
   | None => (None, None)
   | Some(qs) =>
     let params = Dict.make()
-    qs->String.split("&")->Array.forEach(param => {
+    qs
+    ->String.split("&")
+    ->Array.forEach(param => {
       let kv = param->String.split("=")
       switch (kv->Array.get(0), kv->Array.get(1)) {
       | (Some(k), Some(v)) => params->Dict.set(k, v)
       | _ => ()
       }
     })
-    (
-      params->Dict.get("limit")->Option.flatMap(v => Int.fromString(v)),
-      params->Dict.get("after"),
-    )
+    (params->Dict.get("limit")->Option.flatMap(v => Int.fromString(v)), params->Dict.get("after"))
   }
 }
 
 /** Build a paginated response JSON with events and pagination metadata. */
-let paginatedResponse = (
-  ~events: array<JSON.t>,
-  ~hasMore: bool,
-  ~nextAfter: option<string>,
-) =>
+let paginatedResponse = (~events: array<JSON.t>, ~hasMore: bool, ~nextAfter: option<string>) =>
   Dict.fromArray([
     ("events", events->JSON.Encode.array),
     (
@@ -196,25 +191,24 @@ let readEventLogHistory = async (
 
   let expressionAttributeValues = [(":id", entityId->JSON.Encode.string)]->Dict.fromArray
 
-  let exclusiveStartKey = after->Option.map(afterPos =>
-    Dict.fromArray([
-      ("id", entityId->JSON.Encode.string),
-      ("position", afterPos->JSON.Encode.string),
-    ])
-  )
+  let exclusiveStartKey =
+    after->Option.map(afterPos =>
+      Dict.fromArray([
+        ("id", entityId->JSON.Encode.string),
+        ("position", afterPos->JSON.Encode.string),
+      ])
+    )
 
-  let stream =
-    Util_DynamoDb_Runtime.queryStream({
-      tableName: table.name,
-      consistentRead: true,
-      keyConditionExpression: "id=:id",
-      expressionAttributeValues,
-      ?exclusiveStartKey,
-    })
-    ->Stream.catchAll(err => {
-      let _ = DynamoDb_Error.message(err)
-      Stream.empty
-    })
+  let stream = Util_DynamoDb_Runtime.queryStream({
+    tableName: table.name,
+    consistentRead: true,
+    keyConditionExpression: "id=:id",
+    expressionAttributeValues,
+    ?exclusiveStartKey,
+  })->Stream.catchAll(err => {
+    let _ = DynamoDb_Error.message(err)
+    Stream.empty
+  })
 
   // Fetch limit+1 items to detect hasMore
   let bounded = switch limit {
@@ -225,8 +219,7 @@ let readEventLogHistory = async (
   let events = await bounded->Stream.runCollect->Effect.runPromise
 
   let (limited, hasMore) = switch limit {
-  | Some(n) when events->Array.length > n =>
-    (events->Array.slice(~start=0, ~end=n), true)
+  | Some(n) if events->Array.length > n => (events->Array.slice(~start=0, ~end=n), true)
   | _ => (events, false)
   }
 
@@ -258,10 +251,7 @@ let readDcbEventLogHistory = async (
     hashKey: "id",
   }
 
-  let result = await DcbEventLogStorage_DynamoDb_Runtime.read(table)(
-    ~query=[],
-    ~after?,
-  )
+  let result = await DcbEventLogStorage_DynamoDb_Runtime.read(table)(~query=[], ~after?)
 
   // Filter by entity ID tag value (events matching this entity)
   let filtered = if entityId->String.length > 0 {
@@ -272,8 +262,7 @@ let readDcbEventLogHistory = async (
 
   // Apply limit
   let (limited, hasMore) = switch limit {
-  | Some(n) when filtered->Array.length > n =>
-    (filtered->Array.slice(~start=0, ~end=n), true)
+  | Some(n) if filtered->Array.length > n => (filtered->Array.slice(~start=0, ~end=n), true)
   | _ => (filtered, false)
   }
 
@@ -381,11 +370,7 @@ let extractIdentity = (authHeader: option<string>): Reventless.Identity.t =>
 
 /** Dispatch an MCP tool call through makeGenerateCommand so the interceptor hook fires.
     The commandTopicArn from mcpConfig tells us which SQS FIFO queue to target. */
-let dispatchTool = async (
-  tool: mcpToolEntry,
-  args: JSON.t,
-  identity: Reventless.Identity.t,
-) => {
+let dispatchTool = async (tool: mcpToolEntry, args: JSON.t, identity: Reventless.Identity.t) => {
   let queueRef = makeQueueRef(tool.commandTopicArn)
   let publishJsons = sqsPublishJsons(queueRef, AWS.SQS_FIFO.service)
   let generateCommand = makeGenerateCommand(
@@ -448,12 +433,12 @@ let dispatchTool = async (
 
 /** Authentication mode for the Lambda Function URL. */
 type authType =
-  | /** AWS IAM auth — callers sign requests with SigV4. Suitable for
+  /** AWS IAM auth — callers sign requests with SigV4. Suitable for
         service-to-service or Cognito identity pool access. */
-  AwsIam
-  | /** No auth — the Function URL is publicly accessible. Suitable for
+  | AwsIam
+  /** No auth — the Function URL is publicly accessible. Suitable for
         development or when auth is handled at a different layer (API Gateway). */
-  None
+  | None
 
 /** Per-tool authorization scope. Tools can require specific Cognito groups
     or OAuth scopes before execution. */

package/src/adapter/Messaging/Messaging_Ses_Backend.res

@@ -20,8 +20,7 @@ here — `Messaging.UnsupportedChannel` is what a caller gets, which is settled
 rather than retried, so a preference for a channel this deployment does not run
 costs one refusal and not a retry budget.
 */
-let channels = (~sender: string): array<Reventless.Messaging.channel> =>
-  sender == "" ? [] : [Email]
+let channels = (~sender: string): array<Reventless.Messaging.channel> => sender == "" ? [] : [Email]
 
 /**
 Send one message.
@@ -77,8 +76,13 @@ let send = async (
   }
 
 /** The port, closed over the deployment's sender. What a Lambda entry point puts
-    on `Capabilities.messaging`. */
-let provider = (~sender: string): Reventless.Messaging.provider => {
-  channels: channels(~sender),
-  send: (~recipient, ~message) => send(~sender, ~recipient, ~message),
-}
+    on `Capabilities.messaging`.
+
+    No push service, so `makeProvider` publishes no `Push` channel. SES is an email
+    transport; a push one would be a separate provisioning with its own
+    credential. */
+let provider = (~sender: string): Reventless.Messaging.provider =>
+  Reventless.Messaging.makeProvider(~emailAndSms=channels(~sender), ~pushServices=[], ~send=(
+    ~recipient,
+    ~message,
+  ) => send(~sender, ~recipient, ~message))

package/src/adapter/Messaging/Messaging_Ses_Backend.res.mjs

@@ -3,6 +3,7 @@
 import * as SES$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SES.res.mjs";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ClientSesv2 from "@aws-sdk/client-sesv2";
 
@@ -103,10 +104,7 @@ async function send(sender, recipient, message) {
 }
 
 function provider(sender) {
-  return {
-    channels: channels(sender),
-    send: (recipient, message) => send(sender, recipient, message)
-  };
+  return Messaging$Reventless.makeProvider(channels(sender), [], (recipient, message) => send(sender, recipient, message));
 }
 
 let Send;