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

package/src/Platform.res.mjs

@@ -687,7 +687,8 @@ function MakeWithConfig(Config) {
   };
   let provisionPgChangeFeedRelay = () => {
     let feedTargets = (connectionConfig, logName, feed, isClassic) => Stdlib_Array.filterMap(PgProjectionFeed$ReventlessAws.getFeedQueues(), fq => {
-      if (isClassic ? fq.includeClassic : fq.includeDcb) {
+      let included = isClassic ? fq.includeClassic : fq.includeDcb;
+      if (included) {
         return {
           connectionConfig: connectionConfig,
           logName: logName,
@@ -2086,7 +2087,8 @@ function Make($star) {
   };
   let provisionPgChangeFeedRelay = () => {
     let feedTargets = (connectionConfig, logName, feed, isClassic) => Stdlib_Array.filterMap(PgProjectionFeed$ReventlessAws.getFeedQueues(), fq => {
-      if (isClassic ? fq.includeClassic : fq.includeDcb) {
+      let included = isClassic ? fq.includeClassic : fq.includeDcb;
+      if (included) {
         return {
           connectionConfig: connectionConfig,
           logName: logName,

package/src/Platform_Casts.res

@@ -45,7 +45,9 @@
 // The "proper" fix — `inboundAppSyncResolverParams<'runtimeParts>` — would
 // require propagating `'runtimeParts` through `platformHooks`, `Plugin_Builder`,
 // and `Admin`.
-external asLambdaRuntime: ReventlessCore.Runtime.environment<unknown> => ReventlessCore.Runtime.environment<Util.Lambda.runtimeParts> = "%identity"
+external asLambdaRuntime: ReventlessCore.Runtime.environment<
+  unknown,
+> => ReventlessCore.Runtime.environment<Util.Lambda.runtimeParts> = "%identity"
 
 // ─────────────────────────────────────────────────────────────────────────────
 // CAST 2 — hook callback arguments (unknown → concrete component types)
@@ -62,8 +64,13 @@ external asLambdaRuntime: ReventlessCore.Runtime.environment<unknown> => Reventl
 // `reventless-core` cannot import `DcbEventLog.component`, `CommandTopic.component`,
 // or `CommandTopic_Adapter.remoteChannel`. The AWS platform registers these
 // callbacks and is the only caller, always passing the correct concrete value.
-external asDcbEventLogComponent: unknown => ReventlessCore.Component.t<unit, ReventlessCore.DcbEventLog.outputs, unit> = "%identity"
-external asDcbCommandTopicComponent: unknown => ReventlessCore.CommandTopic.component<unit> = "%identity"
+external asDcbEventLogComponent: unknown => ReventlessCore.Component.t<
+  unit,
+  ReventlessCore.DcbEventLog.outputs,
+  unit,
+> = "%identity"
+external asDcbCommandTopicComponent: unknown => ReventlessCore.CommandTopic.component<unit> =
+  "%identity"
 external asDcbEventLog: unknown => ReventlessCore.DcbEventLog.component = "%identity"
 external asRemoteChannel: unknown => ReventlessCore.CommandTopic_Adapter.remoteChannel = "%identity"
 
@@ -103,4 +110,6 @@ external asSqsChannelParts: 'a => Util.SQS.channelParts = "%identity"
 // level — it is a mismatch between ReScript's JS boxing convention and Pulumi's
 // Proxy-based lazy evaluation model.
 external _toUnknown: 'a => unknown = "%identity"
-let wrapHookedValue: 'a => ReventlessCore.Plugin_Helpers.hookedValue<unknown> = x => {val: x->_toUnknown}
+let wrapHookedValue: 'a => ReventlessCore.Plugin_Helpers.hookedValue<unknown> = x => {
+  val: x->_toUnknown,
+}

package/src/adapter/Api/AppSyncEventsSigner_Ops.res

@@ -17,7 +17,9 @@ let sha256hex = (data: string): string =>
 let hmacFromStr = (key: string, data: string): NodeCrypto.buffer =>
   NodeCrypto.createHmac("sha256", key)->NodeCrypto.hmacUpdate(data)->NodeCrypto.hmacDigestBuffer
 let hmacFromBuf = (key: NodeCrypto.buffer, data: string): NodeCrypto.buffer =>
-  NodeCrypto.createHmacFromBuffer("sha256", key)->NodeCrypto.hmacUpdate(data)->NodeCrypto.hmacDigestBuffer
+  NodeCrypto.createHmacFromBuffer("sha256", key)
+  ->NodeCrypto.hmacUpdate(data)
+  ->NodeCrypto.hmacDigestBuffer
 
 // ── SigV4 ───────────────────────────────────────────────────────────────────
 
@@ -71,7 +73,10 @@ let signedHeaders = (
   let kRegion = hmacFromBuf(kDate, region)
   let kService = hmacFromBuf(kRegion, "appsync")
   let kSigning = hmacFromBuf(kService, "aws4_request")
-  let signature = NodeCrypto.createHmacFromBuffer("sha256", kSigning)->NodeCrypto.hmacUpdate(stringToSign)->NodeCrypto.hmacDigest("hex")
+  let signature =
+    NodeCrypto.createHmacFromBuffer("sha256", kSigning)
+    ->NodeCrypto.hmacUpdate(stringToSign)
+    ->NodeCrypto.hmacDigest("hex")
 
   let authorization = `AWS4-HMAC-SHA256 Credential=${creds.accessKeyId}/${scope}, SignedHeaders=${signedHeaderList}, Signature=${signature}`
   let out = Dict.fromArray(sorted)
@@ -115,5 +120,4 @@ let postEvent = async (
 
 // AppSync Events channel segments allow only [A-Za-z0-9-]; anything else
 // collapses to `-`. Mirrors the UI's AutoLive.normalizeSegment.
-let pathSegment = (value: string): string =>
-  value->String.replaceRegExp(%re("/[^A-Za-z0-9-]/g"), "-")
+let pathSegment = (value: string): string => value->String.replaceRegExp(/[^A-Za-z0-9-]/g, "-")

package/src/adapter/Api/AppSync_EventsApi.res

@@ -43,7 +43,6 @@
     installed, subscribe goes through the API-level auth modes only
     (single-tenant open-core case).
 */
-
 module Api = PulumiAws.AwsNative.AppSync.Api
 module ChannelNamespace = PulumiAws.AwsNative.AppSync.ChannelNamespace
 
@@ -158,15 +157,18 @@ let make = (
   let subscribeAuth = subscribeAuthRef.contents
   let codeHandlersInput: option<Pulumi.Input.t<string>> =
     subscribeAuth->Option.map(c => c.codeHandlers->Pulumi.Input.make)
-  let handlerConfigsInput: option<Pulumi.Input.t<ChannelNamespace.handlerConfigsArgs>> =
-    subscribeAuth->Option.map(c => {
+  let handlerConfigsInput: option<
+    Pulumi.Input.t<ChannelNamespace.handlerConfigsArgs>,
+  > = subscribeAuth->Option.map(c =>
+    {
       ChannelNamespace.onSubscribe: {
         ChannelNamespace.behavior: ChannelNamespace.handlerBehaviorCode->Pulumi.Input.make,
         integration: {
           ChannelNamespace.dataSourceName: c.dataSourceName,
         }->Pulumi.Input.make,
       }->Pulumi.Input.make,
-    }->Pulumi.Input.make)
+    }->Pulumi.Input.make
+  )
   let defaultNamespace = ChannelNamespace.make(
     ~name=name ++ "DefaultNS",
     ~args={
@@ -182,14 +184,12 @@ let make = (
   // API-level `defaultPublishAuthModes` (IAM-only), so authenticated browsers
   // can publish ephemeral payloads on `/client/**` while `/default/**` change
   // descriptors stay Lambda-only.
-  let clientAuthModes: Pulumi.Input.t<
-    array<Pulumi.Input.t<ChannelNamespace.authMode>>,
-  > =
+  let clientAuthModes: Pulumi.Input.t<array<Pulumi.Input.t<ChannelNamespace.authMode>>> =
     [
-      ({authType: Api.amazonCognitoUserPools->Pulumi.Input.make}: ChannelNamespace.authMode)
-      ->Pulumi.Input.make,
-      ({authType: Api.awsIam->Pulumi.Input.make}: ChannelNamespace.authMode)
-      ->Pulumi.Input.make,
+      (
+        {authType: Api.amazonCognitoUserPools->Pulumi.Input.make}: ChannelNamespace.authMode
+      )->Pulumi.Input.make,
+      ({authType: Api.awsIam->Pulumi.Input.make}: ChannelNamespace.authMode)->Pulumi.Input.make,
     ]->Pulumi.Input.make
   let clientNamespace = ChannelNamespace.make(
     ~name=name ++ "ClientNS",
@@ -208,6 +208,4 @@ let make = (
 /** HTTP endpoint URL for use as Lambda `APPSYNC_ENDPOINT` env var.
     Constructs `https://{dns.http}` from the raw domain name in the API output. */
 let httpEndpoint = (eventsApi: t): Pulumi.Output.t<string> =>
-  eventsApi.api.dns->Pulumi.Output.apply(dns =>
-    "https://" ++ dns.http->Option.getOr("")
-  )
+  eventsApi.api.dns->Pulumi.Output.apply(dns => "https://" ++ dns.http->Option.getOr(""))

package/src/adapter/Api/AppSync_Resolver_Native.res

@@ -2,7 +2,6 @@
     `PulumiAws.AppSync.Resolver` that uses `@pulumi/aws-native` (Cloud Control
     API) so the CFN handler can internally wait out schema -> resolver
     propagation. See docs/plans/done/appsync-resolver-aws-native.md. */
-
 module Native = PulumiAws.AwsNative.AppSync.Resolver
 module Functions = PulumiAws.AppSync.Resolver.Functions
 
@@ -28,7 +27,7 @@ let makeUnitJsResolver = (
       code,
       runtime: Native.appsyncJs->Pulumi.Input.make,
     },
-    ~opts=opts,
+    ~opts,
   )
 
 let makeSubscriptionResolverCode = (~filter: option<string>): string => {
@@ -62,7 +61,7 @@ let makeSubscriptionResolver = (
       code: makeSubscriptionResolverCode(~filter=subscriptionFilter)->Pulumi.Input.make,
       runtime: Native.appsyncJs->Pulumi.Input.make,
     },
-    ~opts=opts,
+    ~opts,
   )
 
 let makePipelineJsResolver = (
@@ -89,5 +88,5 @@ let makePipelineJsResolver = (
         }: Native.pipelineConfig
       )->Pulumi.Input.make,
     },
-    ~opts=opts,
+    ~opts,
   )

package/src/adapter/Api/AppSync_Resolver_Retrying.res

@@ -17,8 +17,7 @@
     adopted in-place on first deploy (no delete+recreate).
 
     See docs/plans/done/appsync-resolver-aws-native-retry.md. */
-
-// ── AWS SDK bindings ─────────────────────────────────────────────────────────
+let // ── AWS SDK bindings ─────────────────────────────────────────────────────────
 //
 // Pulumi dynamic providers serialise the provider object (and its captured
 // closure of imports) into stack state. A static `@module("@aws-sdk/client-appsync")`
@@ -31,7 +30,7 @@
 // so the SDK module is NOT part of the captured closure. Each provider method
 // resolves the SDK on first use and caches an initialised client.
 
-let log = ReventlessCore.Logger.fromEnv()
+log = ReventlessCore.Logger.fromEnv()
 
 type appSyncClient
 
@@ -231,11 +230,12 @@ let rec runWithRaceRetry = async (
     let msg = jsExn->Option.flatMap(JsExn.message)->Option.getOr("(no message)")
     let isRetryable =
       attempt < maxAttempts &&
-      jsExn->Option.mapOr(false, e => isFieldNotFoundError(e) || isSchemaAlteringError(e))
+        jsExn->Option.mapOr(false, e => isFieldNotFoundError(e) || isSchemaAlteringError(e))
     if isRetryable {
       log.info(
         ~comp="AppSync_Resolver_Retrying",
-        `attempt ${(attempt + 1)->Int.toString}/${maxAttempts->Int.toString} failed, retrying in ${delayMs->Int.toString}ms: ${name}: ${msg}`,
+        `attempt ${(attempt + 1)
+            ->Int.toString}/${maxAttempts->Int.toString} failed, retrying in ${delayMs->Int.toString}ms: ${name}: ${msg}`,
       )
       let _ = await Promise.make((resolve, _) => setTimeout(resolve, delayMs)->ignore)
       let nextDelay = delayMs * 2
@@ -353,65 +353,62 @@ let makeOuts = (resolverArn: string, inputs: providerInputs): createOuts => {
 let create = async (inputs: providerInputs): createResult => {
   let sdk = await getSdk()
   let client = await getClient()
-  let arn =
-    try {
-      await runWithRaceRetry(() =>
-        client
-        ->sendCreate(newOf1(sdk.createCtor, inputs->buildSdkInput))
-        ->Promise.thenResolve(extractArn)
-      )
-    } catch {
-    | exn =>
-      // If the resolver already exists (AppSync / Pulumi state divergence from a
-      // previous partial deploy), update it to match desired config and adopt its ARN.
-      // This makes create idempotent and lets stuck stacks recover without manual intervention.
-      let handled =
-        exn->JsExn.fromException->Option.mapOr(false, isAlreadyExistsError)
-      if handled {
-        let resp = await client->sendUpdate(newOf1(sdk.updateCtor, inputs->buildSdkInput))
-        extractArn(resp)
-      } else {
-        let jsExn = exn->JsExn.fromException
-        switch jsExn {
-        | Some(e) => jsThrow(e)
-        | None => throw(exn)
-        }
+  let arn = try {
+    await runWithRaceRetry(() =>
+      client
+      ->sendCreate(newOf1(sdk.createCtor, inputs->buildSdkInput))
+      ->Promise.thenResolve(extractArn)
+    )
+  } catch {
+  | exn =>
+    // If the resolver already exists (AppSync / Pulumi state divergence from a
+    // previous partial deploy), update it to match desired config and adopt its ARN.
+    // This makes create idempotent and lets stuck stacks recover without manual intervention.
+    let handled = exn->JsExn.fromException->Option.mapOr(false, isAlreadyExistsError)
+    if handled {
+      let resp = await client->sendUpdate(newOf1(sdk.updateCtor, inputs->buildSdkInput))
+      extractArn(resp)
+    } else {
+      let jsExn = exn->JsExn.fromException
+      switch jsExn {
+      | Some(e) => jsThrow(e)
+      | None => throw(exn)
       }
     }
+  }
   {id: arn, outs: makeOuts(arn, inputs)}
 }
 
 let update = async (id: string, _olds: providerInputs, news: providerInputs): updateResult => {
   let sdk = await getSdk()
   let client = await getClient()
-  let arn =
-    try {
-      let _ = await runWithRaceRetry(() =>
-        client->sendUpdate(newOf1(sdk.updateCtor, news->buildSdkInput))
+  let arn = try {
+    let _ = await runWithRaceRetry(() =>
+      client->sendUpdate(newOf1(sdk.updateCtor, news->buildSdkInput))
+    )
+
+    // ARN is stable across updates — reuse the existing id
+    id
+  } catch {
+  | exn =>
+    // If the resolver was deleted from AppSync (e.g. by a schema replacement),
+    // fall back to CreateResolver so the resource is transparently recreated.
+    let handled = exn->JsExn.fromException->Option.mapOr(false, isAlreadyDeletedError)
+    if handled {
+      let resp = await runWithRaceRetry(() =>
+        client
+        ->sendCreate(newOf1(sdk.createCtor, news->buildSdkInput))
+        ->Promise.thenResolve(extractArn)
       )
-      // ARN is stable across updates — reuse the existing id
-      id
-    } catch {
-    | exn =>
-      // If the resolver was deleted from AppSync (e.g. by a schema replacement),
-      // fall back to CreateResolver so the resource is transparently recreated.
-      let handled =
-        exn->JsExn.fromException->Option.mapOr(false, isAlreadyDeletedError)
-      if handled {
-        let resp = await runWithRaceRetry(() =>
-          client
-          ->sendCreate(newOf1(sdk.createCtor, news->buildSdkInput))
-          ->Promise.thenResolve(extractArn)
-        )
-        resp
-      } else {
-        let jsExn = exn->JsExn.fromException
-        switch jsExn {
-        | Some(e) => jsThrow(e)
-        | None => throw(exn)
-        }
+      resp
+    } else {
+      let jsExn = exn->JsExn.fromException
+      switch jsExn {
+      | Some(e) => jsThrow(e)
+      | None => throw(exn)
       }
     }
+  }
   {outs: makeOuts(arn, news)}
 }
 
@@ -451,13 +448,28 @@ let isDefined: string => bool = %raw(`x => x !== undefined && x !== null`)
 /** Returns `true` for fields whose change requires delete+recreate.
     AppSync does not allow renaming the API, type, field, or kind in-place. */
 let diff_ = (_id: string, olds: providerInputs, news: providerInputs): diffResult => {
-  let replaces =
-    [
-      if isDefined(olds.apiId) && olds.apiId != news.apiId {Some("apiId")} else {None},
-      if isDefined(olds.typeName) && olds.typeName != news.typeName {Some("typeName")} else {None},
-      if isDefined(olds.fieldName) && olds.fieldName != news.fieldName {Some("fieldName")} else {None},
-      if isDefined(olds.kind) && olds.kind != news.kind {Some("kind")} else {None},
-    ]->Array.filterMap(x => x)
+  let replaces = [
+    if isDefined(olds.apiId) && olds.apiId != news.apiId {
+      Some("apiId")
+    } else {
+      None
+    },
+    if isDefined(olds.typeName) && olds.typeName != news.typeName {
+      Some("typeName")
+    } else {
+      None
+    },
+    if isDefined(olds.fieldName) && olds.fieldName != news.fieldName {
+      Some("fieldName")
+    } else {
+      None
+    },
+    if isDefined(olds.kind) && olds.kind != news.kind {
+      Some("kind")
+    } else {
+      None
+    },
+  ]->Array.filterMap(x => x)
   // For in-place update detection (non-replace changes): compare as-is.
   // If olds is from old state (missing fields), this may trigger an unnecessary
   // update, but that is safe — the update simply re-applies the resolver.
@@ -541,8 +553,7 @@ type constructorProps = {
 // Use the explicit /index.js path because @pulumi/pulumi/dynamic is a
 // directory import not resolvable in ESM mode.
 @module("@pulumi/pulumi/dynamic/index.js") @new
-external _newResource: ('provider, string, 'props, Pulumi.CustomResourceOptions.t) => t =
-  "Resource"
+external _newResource: ('provider, string, 'props, Pulumi.CustomResourceOptions.t) => t = "Resource"
 
 let makeResolver = (
   ~name: string,
@@ -551,11 +562,7 @@ let makeResolver = (
 ): t => {
   // Always include an alias for the aws-native resource previously in state —
   // prevents delete+recreate on first deploy (in-place adoption).
-  let migrationAlias = Pulumi.Alias.make(
-    ~type_="aws-native:appsync/resolver:Resolver",
-    ~name,
-    (),
-  )
+  let migrationAlias = Pulumi.Alias.make(~type_="aws-native:appsync/resolver:Resolver", ~name, ())
   let finalOpts: Pulumi.CustomResourceOptions.t = switch opts {
   | Some(o) => {...o, aliases: [migrationAlias]}
   | None => {aliases: [migrationAlias]}
@@ -576,7 +583,8 @@ let makeSubscriptionResolverCode = (~filter: option<string>): string =>
 export function response(ctx) {
   return ctx.result;
 }`
-  | Some(f) => `export function request(ctx) {
+  | Some(f) =>
+    `export function request(ctx) {
   extensions.setSubscriptionFilter(${f});
   return {};
 }
@@ -584,7 +592,7 @@ export function response(ctx) {
 export function response(ctx) {
   return ctx.result;
 }`
-}
+  }
 
 let makeSubscriptionResolver = (
   ~name,
@@ -623,7 +631,7 @@ let makeUnitJsResolver = (
       apiId: api->Pulumi.Output.flatMap(a => a.id)->Pulumi.Output.asInput,
       typeName: type_,
       fieldName: field,
-      dataSourceName: dataSourceName,
+      dataSourceName,
       kind: "UNIT"->Pulumi.Input.make,
       code,
     },

package/src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res

@@ -33,7 +33,6 @@
     state, and `Effect` (used by the in-process `AppSync_Error` retry) fails
     that serialisation, so the SDK is lazily imported and the backoff loop is
     hand-rolled here. */
-
 let log = ReventlessCore.Logger.fromEnv()
 
 // ── AWS SDK bindings (lazily imported — see AppSync_Resolver_Retrying) ─────────
@@ -187,17 +186,23 @@ let rec runWithRetry = async (
     let name = jsExn->Option.flatMap(exnName)->Option.getOr("(no name)")
     let msg = jsExn->Option.flatMap(JsExn.message)->Option.getOr("(no message)")
     let isRetryable =
-      attempt < maxAttempts &&
-      jsExn->Option.mapOr(false, isRetryableAssociationError)
+      attempt < maxAttempts && jsExn->Option.mapOr(false, isRetryableAssociationError)
     if isRetryable {
       log.info(
         ~comp="AppSync_SourceApiAssociation_Retrying",
-        `attempt ${(attempt + 1)->Int.toString}/${maxAttempts->Int.toString} failed, retrying in ${delayMs->Int.toString}ms: ${name}: ${msg}`,
+        `attempt ${(attempt + 1)
+            ->Int.toString}/${maxAttempts->Int.toString} failed, retrying in ${delayMs->Int.toString}ms: ${name}: ${msg}`,
       )
       let _ = await Promise.make((resolve, _) => setTimeout(resolve, delayMs)->ignore)
       let nextDelay = delayMs * 2
       let cappedDelay = nextDelay > maxDelayMs ? maxDelayMs : nextDelay
-      await runWithRetry(~attempt=attempt + 1, ~maxAttempts, ~delayMs=cappedDelay, ~maxDelayMs, makeCall)
+      await runWithRetry(
+        ~attempt=attempt + 1,
+        ~maxAttempts,
+        ~delayMs=cappedDelay,
+        ~maxDelayMs,
+        makeCall,
+      )
     } else {
       if attempt > 0 {
         log.warn(
@@ -286,9 +291,7 @@ let extractIds = (resp: createResult): (string, string) =>
   switch resp.sourceApiAssociation {
   | Some({associationArn: ?Some(arn), associationId: ?Some(aid)}) => (arn, aid)
   | _ =>
-    JsError.throwWithMessage(
-      "AssociateSourceGraphqlApi returned no associationArn / associationId",
-    )
+    JsError.throwWithMessage("AssociateSourceGraphqlApi returned no associationArn / associationId")
   }
 
 let create = async (inputs: providerInputs): createResultOut => {

package/src/adapter/Api/Platform_AdminScan_Ops.res

@@ -12,7 +12,8 @@
 
 type ddbClient
 type docClient
-@module("@aws-sdk/client-dynamodb") @new external makeDdbClient: unit => ddbClient = "DynamoDBClient"
+@module("@aws-sdk/client-dynamodb") @new
+external makeDdbClient: unit => ddbClient = "DynamoDBClient"
 @module("@aws-sdk/lib-dynamodb") @scope("DynamoDBDocumentClient")
 external docFrom: ddbClient => docClient = "from"
 
@@ -25,7 +26,8 @@ type scanInput = {
   @as("ExpressionAttributeValues") expressionAttributeValues?: dict<JSON.t>,
 }
 type scanCommand
-@module("@aws-sdk/lib-dynamodb") @new external makeScanCommand: scanInput => scanCommand = "ScanCommand"
+@module("@aws-sdk/lib-dynamodb") @new
+external makeScanCommand: scanInput => scanCommand = "ScanCommand"
 type scanOutput = {
   @as("Items") items?: array<dict<JSON.t>>,
   @as("LastEvaluatedKey") lastEvaluatedKey?: JSON.t,
@@ -46,17 +48,16 @@ let scanAll = async (
   let startKey = ref(None)
   let more = ref(true)
   while more.contents {
-    let out =
-      await doc->send(
-        makeScanCommand({
-          tableName,
-          limit: 1000,
-          exclusiveStartKey: ?startKey.contents,
-          filterExpression: ?filterExpression,
-          expressionAttributeNames: ?expressionAttributeNames,
-          expressionAttributeValues: ?expressionAttributeValues,
-        }),
-      )
+    let out = await doc->send(
+      makeScanCommand({
+        tableName,
+        limit: 1000,
+        exclusiveStartKey: ?startKey.contents,
+        ?filterExpression,
+        ?expressionAttributeNames,
+        ?expressionAttributeValues,
+      }),
+    )
     out.items->Option.forEach(is => is->Array.forEach(i => items->Array.push(i)))
     switch out.lastEvaluatedKey {
     | Some(k) => startKey := Some(k)
@@ -76,7 +77,7 @@ let scanAll = async (
 // numeric segments compared as numbers, others lexically). Mirrors the platform
 // invariant "one version per plugin at a time" ordering. Returns 1/-1/0.
 let compareVersions = (a: string, b: string): int => {
-  let norm = s => s->String.replaceRegExp(%re("/[-+]/g"), ".")->String.split(".")
+  let norm = s => s->String.replaceRegExp(/[-+]/g, ".")->String.split(".")
   let pa = norm(a)
   let pb = norm(b)
   let len = Math.Int.max(pa->Array.length, pb->Array.length)

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda.res

@@ -205,7 +205,10 @@ let make = (
   // 4096-byte UpdateFunctionConfiguration limit. Its content participates in
   // `sourceCodeHash`, so a change to the admin structure redeploys the code.
   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/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs",
@@ -245,7 +248,12 @@ let make = (
       memorySize: 512->Pulumi.Input.make,
       timeout: 30->Pulumi.Input.make,
       layers,
-      tags: AWS.Tags.make(~name=name ++ "Lambda", ~kind=ReventlessCore.ComponentType.Platform, ~role=Runtime, ~scope=Platform),
+      tags: AWS.Tags.make(
+        ~name=name ++ "Lambda",
+        ~kind=ReventlessCore.ComponentType.Platform,
+        ~role=Runtime,
+        ~scope=Platform,
+      ),
       environment: (
         {
           Lambda.Function.variables: Dict.fromArray([