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

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([

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -12,7 +12,6 @@
 // sury-encoded with the same shape as the in-memory adapter's
 // encodePluginStructureEntry, so it is wrapped with `pluginId` without decoding.
 
-
 let str = (item: dict<JSON.t>, key: string): option<string> =>
   item->Dict.get(key)->Option.flatMap(JSON.Decode.string)
 
@@ -37,7 +36,14 @@ type healSpec = {lists: array<string>, nested: array<(string, array<string>)>}
 let refLists = ["references"]
 
 let writeSideHeal = {
-  lists: ["commands", "linkedViews", "producedEventTypes", "consumedEventTypes", "events", "errors"],
+  lists: [
+    "commands",
+    "linkedViews",
+    "producedEventTypes",
+    "consumedEventTypes",
+    "events",
+    "errors",
+  ],
   nested: [("commands", refLists), ("events", refLists), ("errors", refLists)],
 }
 
@@ -52,10 +58,7 @@ let healByCollection: array<(string, healSpec)> = [
   ("stateChangeSlices", writeSideHeal),
   ("aggregates", writeSideHeal),
   ("automationSlices", {lists: ["consumedEventTypes", "producedCommandTypes"], nested: []}),
-  (
-    "outboundTranslationSlices",
-    {lists: ["consumedEventTypes", "inboundCommandTypes"], nested: []},
-  ),
+  ("outboundTranslationSlices", {lists: ["consumedEventTypes", "inboundCommandTypes"], nested: []}),
   ("inboundTranslationSlices", {lists: ["commandTypes"], nested: []}),
   ("extensions", {lists: ["delegateNames", "eventTypes", "commandTypes"], nested: []}),
 ]
@@ -116,21 +119,22 @@ let healStructure = (structure: dict<JSON.t>): dict<JSON.t> => {
   healByCollection->Array.forEach(((collection, spec)) =>
     out->mapMembers(collection, component => {
       component->fillLists(spec.lists)
-      spec.nested->Array.forEach(((key, keys)) =>
-        component->mapMembers(key, member => member->fillLists(keys))
+      spec.nested->Array.forEach(
+        ((key, keys)) => component->mapMembers(key, member => member->fillLists(keys)),
       )
     })
   )
-  readSideCollections->Array.forEach(collection =>
-    out->mapMembers(collection, fillLifecycleField)
-  )
+  readSideCollections->Array.forEach(collection => out->mapMembers(collection, fillLifecycleField))
   out
 }
 
 // Mirror ReventlessCore.Platform_ComponentDefinitionsApi.isPublicQueryable on
 // the read path: a component is public unless its visibility is "Internal".
 let isPublicQueryable = (q: JSON.t): bool =>
-  switch q->JSON.Decode.object->Option.flatMap(o => o->Dict.get("visibility"))->Option.flatMap(JSON.Decode.string) {
+  switch q
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get("visibility"))
+  ->Option.flatMap(JSON.Decode.string) {
   | Some("Internal") => false
   | _ => true
   }
@@ -147,8 +151,7 @@ let isPublicQueryable = (q: JSON.t): bool =>
 // duplicate list.
 let filterStructure = (structure: dict<JSON.t>): dict<JSON.t> => {
   let out = Dict.fromArray(structure->Dict.toArray)
-  let arrAt = key =>
-    out->Dict.get(key)->Option.flatMap(JSON.Decode.array)->Option.getOr([])
+  let arrAt = key => out->Dict.get(key)->Option.flatMap(JSON.Decode.array)->Option.getOr([])
   let readModels = arrAt("readModels")
   let stateViewSlices = arrAt("stateViewSlices")
   out->Dict.set("readModels", readModels->Array.filter(isPublicQueryable)->JSON.Encode.array)
@@ -192,7 +195,6 @@ let toEntryWith = (~filter: bool, item: dict<JSON.t>, ~name: string): option<JSO
   }
 }
 
-
 // The built-in Platform_Admin entry, written at deploy time as an asset file in
 // the code archive (the admin never Connects to itself, so its structure never
 // enters the Plugin read model). It rides the archive rather than an env var
@@ -204,27 +206,25 @@ let toEntryWith = (~filter: bool, item: dict<JSON.t>, ~name: string): option<JSO
 // extension points, so its filtered and complete encodings carry the same
 // components; the structure-level fields the complete entry adds are absent from
 // this JSON and resolve to null, which is what `extensionPoints: None` means.
-let adminEntry: option<JSON.t> =
-  try {
-    switch NodePath.join([NodeProcess.cwd(), "adminEntry.json"])
-    ->NodeFs.readFileSync
-    ->JSON.parseOrThrow {
-    | JSON.Null => None
-    | json => Some(json)
-    }
-  } catch {
-  | _ => None
+let adminEntry: option<JSON.t> = try {
+  switch NodePath.join([NodeProcess.cwd(), "adminEntry.json"])
+  ->NodeFs.readFileSync
+  ->JSON.parseOrThrow {
+  | JSON.Null => None
+  | json => Some(json)
   }
+} catch {
+| _ => None
+}
 
 // Resolve an offloaded `structure`: a large structure is content-addressed to the
 // offload bucket at deploy time and persisted as an `{$offload: {...}}` reference,
 // so fetch the object's bytes and substitute the real structure JSON before it is
 // filtered. Inline (or absent) structures pass through untouched. The `fetch` is
 // per-hash cached, so an identical structure shared across versions is read once.
-let resolveStructure = (
-  fetch: string => promise<string>,
-  item: dict<JSON.t>,
-): promise<dict<JSON.t>> =>
+let resolveStructure = (fetch: string => promise<string>, item: dict<JSON.t>): promise<
+  dict<JSON.t>,
+> =>
   switch item
   ->Dict.get("structure")
   ->Option.flatMap(JSON.Decode.object)
@@ -302,8 +302,7 @@ let structureOf = (item: dict<JSON.t>, ~name as _: string): option<(
     | exception _ =>
       JsError.throwWithMessage(
         `baked manifest: the structure persisted for "${pluginId}" cannot be decoded — ` ++
-        `it was written by a framework version this platform can no longer read. ` ++
-        `Redeploy that plugin, or drop it from the include-list.`,
+        `it was written by a framework version this platform can no longer read. ` ++ `Redeploy that plugin, or drop it from the include-list.`,
       )
     }
   | _ => None
@@ -357,8 +356,7 @@ let bakeSelections = (): array<ReventlessCore.Platform_BakedManifest.selection>
   | Some(raw) =>
     switch raw->JSON.parseOrThrow {
     | json => json->decodeSelections
-    | exception _ =>
-      JsError.throwWithMessage("baked manifest: BAKE_SELECTIONS is not a JSON array")
+    | exception _ => JsError.throwWithMessage("baked manifest: BAKE_SELECTIONS is not a JSON array")
     }
   }
 
@@ -612,8 +610,7 @@ let runBake = async (
   let selections = bakeSelections()
   if selections->Array.length == 0 {
     JsError.throwWithMessage(
-      "baked manifest: BAKE_SELECTIONS is empty — this platform declares no bake, " ++
-      "so there is nothing to write and a shell pointed at the file would find none.",
+      "baked manifest: BAKE_SELECTIONS is empty — this platform declares no bake, " ++ "so there is nothing to write and a shell pointed at the file would find none.",
     )
   }
   // The default journey first and always — the caller supplies its key, because
@@ -677,8 +674,7 @@ let handler = async (event: JSON.t): array<JSON.t> => {
     switch bakeTarget {
     | Some(_) =>
       JsError.throwWithMessage(
-        "baked manifest: PLUGIN_RM_TABLE env var not set — the bake would write an " ++
-        "empty shop rather than fail.",
+        "baked manifest: PLUGIN_RM_TABLE env var not set — the bake would write an " ++ "empty shop rather than fail.",
       )
     | None => admin
     }
@@ -699,11 +695,7 @@ let handler = async (event: JSON.t): array<JSON.t> => {
     | Some(target) =>
       // Checked on the raw rows: the refs are what the deploy can predict, and a
       // row that is behind should not have its structure fetched at all.
-      let regs = registrations(
-        rawItems,
-        ~expect=bakeExpectations(event),
-        ~since=bakeSince(event),
-      )
+      let regs = registrations(rawItems, ~expect=bakeExpectations(event), ~since=bakeSince(event))
       switch regs->Array.filter(isPending) {
       | [] =>
         // The built-in admin entry is deliberately absent: it never enters the
@@ -720,8 +712,7 @@ let handler = async (event: JSON.t): array<JSON.t> => {
         // file. What the summary adds is orthogonal to the files — it says what
         // the convergence check proved, not what the bake wrote.
         Array.concat(written, [encodeSummary(regs)])
-      | pending =>
-        // Not an error — the deploy just has not finished arriving. Reported so the
+      | pending => // Not an error — the deploy just has not finished arriving. Reported so the
         // caller can invoke again rather than bake the previous deployment, and
         // reported with both keys and the row's date so that when it never does
         // arrive, the job says which of the causes it was.
@@ -734,12 +725,11 @@ let handler = async (event: JSON.t): array<JSON.t> => {
         ]
       }
     | None =>
-      let userEntries =
-        Platform_AdminScan_Ops.latestByName(
-          await resolveAll(),
-          ~nameVersionOf=item => item->str("name"),
-          ~toEntry,
-        )
+      let userEntries = Platform_AdminScan_Ops.latestByName(
+        await resolveAll(),
+        ~nameVersionOf=item => item->str("name"),
+        ~toEntry,
+      )
       Array.concat(admin, userEntries)
     }
   }

package/src/adapter/Api/Platform_UIFragments_Lambda.res

@@ -44,42 +44,44 @@ let make = (
     ~opts,
   )
 
-  let _ =
-    uiFragmentRegistryTableName->Pulumi.Output.apply(tableName => {
-      open PolicyDocument
-      let _rolePolicy = IAM.RolePolicy.make(
-        ~name=name ++ "LambdaPolicy",
-        ~args={
-          IAM.RolePolicy.policy: PolicyDocument.make(
-            ~id=name ++ "LambdaPolicy",
-            ~statements=[
-              {
-                sid: "AllowLambdaLogging",
-                effect: Allow,
-                actions: Action("logs:*"),
-                resources: Resource("arn:aws:logs:*:*:*"),
-              },
-              {
-                sid: "AllowScanUiFragmentsTable",
-                effect: Allow,
-                actions: Actions(["dynamodb:Scan"]),
-                resources: Resource("arn:aws:dynamodb:*:*:table/" ++ tableName),
-              },
-            ],
-          )
-          ->PolicyDocument.toJsonString
-          ->Pulumi.Input.make,
-          role: lambdaRole.id->Pulumi.Output.asInput,
-        },
-        ~opts,
-      )
-    })
+  let _ = uiFragmentRegistryTableName->Pulumi.Output.apply(tableName => {
+    open PolicyDocument
+    let _rolePolicy = IAM.RolePolicy.make(
+      ~name=name ++ "LambdaPolicy",
+      ~args={
+        IAM.RolePolicy.policy: PolicyDocument.make(
+          ~id=name ++ "LambdaPolicy",
+          ~statements=[
+            {
+              sid: "AllowLambdaLogging",
+              effect: Allow,
+              actions: Action("logs:*"),
+              resources: Resource("arn:aws:logs:*:*:*"),
+            },
+            {
+              sid: "AllowScanUiFragmentsTable",
+              effect: Allow,
+              actions: Actions(["dynamodb:Scan"]),
+              resources: Resource("arn:aws:dynamodb:*:*:table/" ++ tableName),
+            },
+          ],
+        )
+        ->PolicyDocument.toJsonString
+        ->Pulumi.Input.make,
+        role: lambdaRole.id->Pulumi.Output.asInput,
+      },
+      ~opts,
+    )
+  })
 
   // Bundle reventless-aws (the compiled `_Ops` handler lives inside it) and
   // re-export its `handler`; buildCodeArchive also ships the ESM resolve-hook so
   // the handler's bare @aws-sdk/* specifiers resolve from the managed runtime.
   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_UIFragments_Lambda_Ops.res.mjs",
@@ -118,7 +120,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([