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

package/tests/Util_BundleDependencyClosureTest.res

@@ -62,8 +62,17 @@ export const rule = () => Rules.check();
     ),
   ],
 )
-let _ = writePkg(~root=rulesRoot, ~name=rulesName, [("src/Rules.res.mjs", `export const check = () => true;
-`)])
+let _ = writePkg(
+  ~root=rulesRoot,
+  ~name=rulesName,
+  [
+    (
+      "src/Rules.res.mjs",
+      `export const check = () => true;
+`,
+    ),
+  ],
+)
 
 let closureOf = (packageDirs: dict<string>) => {
   Util_Bundle.addImportedPackageClosure(packageDirs)
@@ -100,11 +109,40 @@ describe("Util_Bundle — bundled user packages carry their imports", () => {
     expect(bundled->Array.includes("@fixture/never-installed"))->toBe(false)
   })
 
+  testSync("a package the framework merely resolves is still bundled", () => {
+    // The layer carries reventless-aws's dependency closure and nothing else.
+    // A consumer with a hoisted node_modules puts every package at the root,
+    // where the framework's own resolution reaches it by walking up — so
+    // resolvability said "the layer has it" about packages the layer has never
+    // held, and they were dropped from the archive. `sury` above is genuinely a
+    // framework dependency; these are not, and must ride along.
+    expect(Util_Bundle.isFrameworkPackage("@fixture/closure-trait"))->toBe(false)
+    // A real, published, @reventlessdev-scoped package that is not a dependency
+    // of reventless-aws: scope is not what decides this.
+    expect(Util_Bundle.isFrameworkPackage("@reventlessdev/reventless-local"))->toBe(false)
+  })
+
+  testSync("the framework's own closure is recognised", () => {
+    expect(Util_Bundle.isFrameworkPackage("@reventlessdev/reventless-aws"))->toBe(true)
+    expect(Util_Bundle.isFrameworkPackage("sury"))->toBe(true)
+  })
+
+  testSync("a package the layer adds outside that closure counts as the layer's", () => {
+    // @rescript/runtime is a transitive of `rescript`, which the layer excludes
+    // as a build tool, so it is absent from the production closure while the
+    // layer carries it explicitly. Every compiled ReScript file imports it, and
+    // it is 19 MB — treating it as a user package puts that in every archive.
+    expect(Util_Bundle.isFrameworkPackage("@rescript/runtime"))->toBe(true)
+  })
+
   testSync("framework packages are starting points, not walked", () => {
     // Walking reventless-aws would reach its deploy-time-only imports (the
     // @pulumi bindings) and add tens of megabytes to every archive.
     let packageDirs = Dict.fromArray([
-      ("@reventlessdev/reventless-aws", Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws")),
+      (
+        "@reventlessdev/reventless-aws",
+        Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+      ),
     ])
     expect(closureOf(packageDirs)->Dict.keysToArray->Array.length)->toBe(1)
   })

package/tests/Util_BundleDependencyClosureTest.res.mjs

@@ -106,6 +106,17 @@ globalThis.describe("Util_Bundle — bundled user packages carry their imports",
     let bundled = Object.keys((Util_Bundle$ReventlessAws.addImportedPackageClosure(packageDirs), packageDirs));
     globalThis.expect(bundled.includes("@fixture/never-installed")).toBe(false);
   });
+  globalThis.test("a package the framework merely resolves is still bundled", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@fixture/closure-trait")).toBe(false);
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@reventlessdev/reventless-local")).toBe(false);
+  });
+  globalThis.test("the framework's own closure is recognised", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@reventlessdev/reventless-aws")).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("sury")).toBe(true);
+  });
+  globalThis.test("a package the layer adds outside that closure counts as the layer's", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@rescript/runtime")).toBe(true);
+  });
   globalThis.test("framework packages are starting points, not walked", () => {
     let packageDirs = Object.fromEntries([[
         "@reventlessdev/reventless-aws",

package/tests/Util_BundleEsmLoaderTest.res

@@ -22,9 +22,9 @@ describe("Util_Bundle ESM loader — env-var contract", () => {
 
 describe("Util_Bundle ESM loader — file cross-references", () => {
   testSync("register-hook registers exactly the layer-resolver filename", () => {
-    expect(Util_Bundle.registerHookSource->String.includes(Util_Bundle.layerResolverFileName))->toBe(
-      true,
-    )
+    expect(
+      Util_Bundle.registerHookSource->String.includes(Util_Bundle.layerResolverFileName),
+    )->toBe(true)
     expect(Util_Bundle.registerHookSource->String.includes("register("))->toBe(true)
   })
 

package/tests/Util_BundleResolveTest.res

@@ -5,14 +5,12 @@ open JestGlobals
 // than one of reventless-aws's own dependencies. realpath because macOS hands
 // out /var/... symlinks for tmpdir while require.resolve reports /private/var.
 let makeProject = (pkgName: string): (string, string) => {
-  let project =
-    NodeFs.realpathSync(NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "pulumi-project-"])))
+  let project = NodeFs.realpathSync(
+    NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "pulumi-project-"])),
+  )
   let pkgDir = NodePath.join([NodePath.join([project, "node_modules"]), pkgName])
   NodeFs.mkdirSync(pkgDir, {recursive: true})
-  NodeFs.writeFileSync(
-    NodePath.join([pkgDir, "package.json"]),
-    `{"name":"","version":"9.9.9"}`,
-  )
+  NodeFs.writeFileSync(NodePath.join([pkgDir, "package.json"]), `{"name":"","version":"9.9.9"}`)
   (project, pkgDir)
 }
 

package/tests/Util_BundleRuntimeExtensionTest.res

@@ -24,9 +24,10 @@ let makePkg = (name: string, files: array<(string, string)>): string => {
 
 let fileUrl = (absPath: string) => "file://" ++ absPath
 
-let extensionModule = (~companions: array<string>=[], url: string): module(
-  ReventlessCore.RuntimeExtension.Extension
-) => {
+let extensionModule = (
+  ~companions: array<string>=[],
+  url: string,
+): module(ReventlessCore.RuntimeExtension.Extension) => {
   module E = {
     let moduleUrl = url
     let companionModuleUrls = companions
@@ -104,8 +105,8 @@ describe("Util_Bundle — runtime-extension companion packages", () => {
   beforeEach(() => ReventlessCore.RuntimeExtension.reset())
   afterAll(() => {
     ReventlessCore.RuntimeExtension.reset()
-    [extRoot, companionRoot, badRoot]->Array.forEach(root =>
-      NodeFs.rmSync(root, {recursive: true, force: true})
+    [extRoot, companionRoot, badRoot]->Array.forEach(
+      root => NodeFs.rmSync(root, {recursive: true, force: true}),
     )
   })
 
@@ -135,10 +136,7 @@ describe("Util_Bundle — runtime-extension companion packages", () => {
 
     let companionFile = NodePath.join([companionRoot, "src/Companion.res.mjs"])
     let original = NodeFs.readFileSync(companionFile)
-    NodeFs.writeFileSync(
-      companionFile,
-      original ++ "export const changed = true;\n",
-    )
+    NodeFs.writeFileSync(companionFile, original ++ "export const changed = true;\n")
     let after = build().sourceCodeHash
     NodeFs.writeFileSync(companionFile, original)
 
@@ -147,21 +145,22 @@ describe("Util_Bundle — runtime-extension companion packages", () => {
 
   testSync("an empty registry leaves the archive byte-identical", () => {
     let withSeam = build().sourceCodeHash
-    let withoutSeam =
-      Util_Bundle.buildCodeArchive(
-        ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/Entry.res.mjs",
-        ~packageDirs=Dict.make(),
-        ~bundleRuntimeExtensions=false,
-      ).sourceCodeHash
+    let withoutSeam = Util_Bundle.buildCodeArchive(
+      ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/Entry.res.mjs",
+      ~packageDirs=Dict.make(),
+      ~bundleRuntimeExtensions=false,
+    ).sourceCodeHash
     expect(withSeam)->toBe(withoutSeam)
   })
 
   testSync("an undeclared, un-bundled import fails the archive build, naming the remedy", () => {
     ReventlessCore.RuntimeExtension.use(extensionModule(badUrl))
 
-    switch caughtMessage(() => {
-      let _ = build()
-    }) {
+    switch caughtMessage(
+      () => {
+        let _ = build()
+      },
+    ) {
     | None => JsError.throwWithMessage("expected buildCodeArchive to throw")
     | Some(message) =>
       expect(message->String.includes(badPkgName))->toBe(true)

package/tests/Util_DcbMetricsTest.res

@@ -8,15 +8,13 @@ open JestGlobals
 
 describe("Util_DcbMetrics.transformationFor", () => {
   testSync("never sets defaultValue — it is mutually exclusive with dimensions", () =>
-    Util_DcbMetrics.metricNames->Array.forEach(m =>
-      expect(Util_DcbMetrics.transformationFor(m).defaultValue)->toBe(None)
+    Util_DcbMetrics.metricNames->Array.forEach(
+      m => expect(Util_DcbMetrics.transformationFor(m).defaultValue)->toBe(None),
     )
   )
 
   testSync("dimensions the metric by slice", () =>
-    expect(
-      Util_DcbMetrics.transformationFor("AppendRetry").dimensions->Option.isSome,
-    )->toBe(true)
+    expect(Util_DcbMetrics.transformationFor("AppendRetry").dimensions->Option.isSome)->toBe(true)
   )
 
   testSync("counts into the DCB namespace", () =>
@@ -30,6 +28,8 @@ describe("Util_DcbMetrics.transformationFor", () => {
 
 describe("Util_DcbMetrics.patternFor", () => {
   testSync("selects one metric's lines by its marker", () =>
-    expect(Util_DcbMetrics.patternFor("AppendRetry"))->toBe(`{ $.reventlessMetric = "AppendRetry" }`)
+    expect(
+      Util_DcbMetrics.patternFor("AppendRetry"),
+    )->toBe(`{ $.reventlessMetric = "AppendRetry" }`)
   )
 })

package/tests/Util_DynamoDbStreamTest.res

@@ -33,11 +33,10 @@ describe("Util_DynamoDbStream.toStreamResource", () => {
   })
 
   test("answers its own stream ARN", async () => {
-    let arn =
-      await tableResource
-      ->Util_DynamoDbStream.toStreamResource
-      ->Util_DynamoDbStream.streamArnFromDynamoDbTableResource
-      ->resolve
+    let arn = await tableResource
+    ->Util_DynamoDbStream.toStreamResource
+    ->Util_DynamoDbStream.streamArnFromDynamoDbTableResource
+    ->resolve
     expect(arn)->toBe(streamArn)
   })
 })

package/tests/Util_DynamoDbTest.res

@@ -35,8 +35,9 @@ describe("Util_DynamoDb.toResourceInfo", () => {
   })
 
   test("carries a sort key when the table has one", async () => {
-    let resourceInfo =
-      await table(~rangeKey=Nullable.make("seq"))->Util_DynamoDb.toResourceInfo->resolve
+    let resourceInfo = await table(~rangeKey=Nullable.make("seq"))
+    ->Util_DynamoDb.toResourceInfo
+    ->resolve
     expect(resourceInfo)->toEqual(
       ReventlessInfra.Adapter.StorageKeys({partitionKey: "id", sortKey: Some("seq")}),
     )

package/tests/Util_LambdaEnvBudgetTest.res

@@ -21,8 +21,8 @@ let throws = (f: unit => 'a): option<string> =>
 
 describe("Util_LambdaEnvBudget.check", () => {
   testSync("passes a small environment", () => {
-    let msg = throws(() =>
-      Util_LambdaEnvBudget.check(~lambdaName="Small", ~handlerConfigJson=`{"queueUrl":"q"}`)
+    let msg = throws(
+      () => Util_LambdaEnvBudget.check(~lambdaName="Small", ~handlerConfigJson=`{"queueUrl":"q"}`),
     )
     expect(msg)->toEqual(None)
   })
@@ -39,19 +39,21 @@ describe("Util_LambdaEnvBudget.check", () => {
   testSync("counts the queue-URL var names toward the exact total", () => {
     // Sized so HANDLER_CONFIG alone fits and the var NAMES alone push it over —
     // the names are known at check time, so this must throw rather than warn.
-    let keys = Array.make(~length=40, "")->Array.mapWithIndex((_, i) =>
-      `PTA_AVeryLongAggregateNameNumber${i->Int.toString}_QUEUE_URL`
-    )
+    let keys =
+      Array.make(~length=40, "")->Array.mapWithIndex(
+        (_, i) => `PTA_AVeryLongAggregateNameNumber${i->Int.toString}_QUEUE_URL`,
+      )
     let keyBytes = keys->Array.reduce(0, (acc, k) => acc + String.length(k))
     let fixed = Util_LambdaEnvBudget.frameworkVarsBytes + String.length("HANDLER_CONFIG")
     // Just past the limit on the exact total alone — the names are enough.
     let json = String.repeat("a", budget - fixed - keyBytes + 1)
-    let msg = throws(() =>
-      Util_LambdaEnvBudget.check(
-        ~lambdaName="ManyTargets",
-        ~handlerConfigJson=json,
-        ~outputValuedKeys=keys,
-      )
+    let msg = throws(
+      () =>
+        Util_LambdaEnvBudget.check(
+          ~lambdaName="ManyTargets",
+          ~handlerConfigJson=json,
+          ~outputValuedKeys=keys,
+        ),
     )
     expect(msg->Option.isSome)->toBe(true)
   })
@@ -59,19 +61,21 @@ describe("Util_LambdaEnvBudget.check", () => {
   testSync("only estimating over the limit warns rather than throwing", () => {
     // Exact total sits under the limit; it is the per-URL allowance that crosses
     // it. The deploy must be allowed to proceed and find out.
-    let keys = Array.make(~length=20, "")->Array.mapWithIndex((_, i) => `PTA_A${i->Int.toString}_URL`)
+    let keys =
+      Array.make(~length=20, "")->Array.mapWithIndex((_, i) => `PTA_A${i->Int.toString}_URL`)
     let exact =
       Util_LambdaEnvBudget.frameworkVarsBytes +
       String.length("HANDLER_CONFIG") +
       keys->Array.reduce(0, (acc, k) => acc + String.length(k))
     let room = budget - exact - 100
     let json = String.repeat("a", room)
-    let msg = throws(() =>
-      Util_LambdaEnvBudget.check(
-        ~lambdaName="Estimated",
-        ~handlerConfigJson=json,
-        ~outputValuedKeys=keys,
-      )
+    let msg = throws(
+      () =>
+        Util_LambdaEnvBudget.check(
+          ~lambdaName="Estimated",
+          ~handlerConfigJson=json,
+          ~outputValuedKeys=keys,
+        ),
     )
     expect(msg)->toEqual(None)
   })

package/tests/Util_LambdaLoggingTest.res

@@ -21,9 +21,9 @@ describe("Util_LambdaLogging.logGroupNameFor", () => {
   })
 
   testSync("is stack-scoped, so environments of one project cannot collide", () =>
-    expect(nameFor(~stack="pr-42", ~name="AllReadModels"))->not_->toBe(
-      nameFor(~stack="alpha", ~name="AllReadModels"),
-    )
+    expect(nameFor(~stack="pr-42", ~name="AllReadModels"))
+    ->not_
+    ->toBe(nameFor(~stack="alpha", ~name="AllReadModels"))
   )
 
   // The regression this scoping exists for. Every plugin of one platform is its
@@ -54,17 +54,18 @@ describe("Util_LambdaLogging.logGroupNameFor", () => {
 // the estate and send an operator to a nonexistent group on the other half.
 describe("Util_LambdaLogging.autoCreatedLogGroupNameFor", () => {
   testSync("is the group Lambda makes from the PHYSICAL name, suffix and all", () =>
-    expect(Util_LambdaLogging.autoCreatedLogGroupNameFor(~physicalName="AllReadModels-0287438"))
-    ->toBe("/aws/lambda/AllReadModels-0287438")
+    expect(
+      Util_LambdaLogging.autoCreatedLogGroupNameFor(~physicalName="AllReadModels-0287438"),
+    )->toBe("/aws/lambda/AllReadModels-0287438")
   )
 
   // The two shapes must not converge: the managed name is chosen from the static
   // name so it survives a replacement, the auto-created one is not. If these ever
   // matched, the managed group would be racing the auto-create it exists to avoid.
   testSync("never equals the managed name for the same unit", () =>
-    expect(
-      Util_LambdaLogging.autoCreatedLogGroupNameFor(~physicalName="AllReadModels-0287438"),
-    )->not_->toBe(
+    expect(Util_LambdaLogging.autoCreatedLogGroupNameFor(~physicalName="AllReadModels-0287438"))
+    ->not_
+    ->toBe(
       Util_LambdaLogging.logGroupNameFor(
         ~project="online-shop-catalog-aws",
         ~stack="alpha",

package/tests/Util_LogGroup_AdoptingTest.res

@@ -27,7 +27,10 @@ describe("Util_LogGroup_Adopting.isAlreadyExistsError", () => {
   testSync("true for the error this provider exists to absorb", () =>
     expect(
       Adopting.isAlreadyExistsError(
-        mkErr(~name="ResourceAlreadyExistsException", ~message="The specified log group already exists"),
+        mkErr(
+          ~name="ResourceAlreadyExistsException",
+          ~message="The specified log group already exists",
+        ),
       ),
     )->toBe(true)
   )
@@ -42,7 +45,9 @@ describe("Util_LogGroup_Adopting.isAlreadyExistsError", () => {
 
   testSync("false for a permission failure, which must still fail loudly", () =>
     expect(
-      Adopting.isAlreadyExistsError(mkErr(~name="AccessDeniedException", ~message="not authorized")),
+      Adopting.isAlreadyExistsError(
+        mkErr(~name="AccessDeniedException", ~message="not authorized"),
+      ),
     )->toBe(false)
   )
 })
@@ -85,9 +90,9 @@ describe("Util_LogGroup_Adopting.sameTags", () => {
   )
 
   testSync("sees a changed value", () =>
-    expect(
-      Adopting.sameTags(Dict.fromArray([("a", "1")]), Dict.fromArray([("a", "2")])),
-    )->toBe(false)
+    expect(Adopting.sameTags(Dict.fromArray([("a", "1")]), Dict.fromArray([("a", "2")])))->toBe(
+      false,
+    )
   )
 
   testSync("sees an added key", () =>

package/tests/Util_LogRetentionTest.res

@@ -39,11 +39,15 @@ describe("Util_LogRetention.retentionDaysFor", () => {
   // The config key is the escape hatch — a stack dialled without a code change,
   // including `0` (never expire) as an explicit opt-in.
   testSync("a config override wins over the tier default", () =>
-    expect(Util_LogRetention.retentionDaysFor(~stack="alpha", ~prodStacks, ~configOverride=14))->toBe(14)
+    expect(
+      Util_LogRetention.retentionDaysFor(~stack="alpha", ~prodStacks, ~configOverride=14),
+    )->toBe(14)
   )
 
   testSync("0 = never expire is expressible via the override", () =>
-    expect(Util_LogRetention.retentionDaysFor(~stack="prod", ~prodStacks, ~configOverride=0))->toBe(0)
+    expect(Util_LogRetention.retentionDaysFor(~stack="prod", ~prodStacks, ~configOverride=0))->toBe(
+      0,
+    )
   )
 })
 

package/tests/Util_OwnerScopeEnvTest.res

@@ -19,11 +19,13 @@ let withElevated = (groups, f) => {
 
 describe("Util_OwnerScopeEnv — the elevated-groups carrier", () => {
   testSync("writes what OwnerScope reads back", () => {
-    let encoded = withElevated(["Admin", "Support"], () =>
-      switch Util_OwnerScopeEnv.entry() {
-      | Some((_, value)) => value->Obj.magic
-      | None => ""
-      }
+    let encoded = withElevated(
+      ["Admin", "Support"],
+      () =>
+        switch Util_OwnerScopeEnv.entry() {
+        | Some((_, value)) => value->Obj.magic
+        | None => ""
+        },
     )
     // The round trip, not the spelling: a separator change on either side fails.
     expect(Reventless.OwnerScope.parseElevatedGroups(encoded))->toEqual(["Admin", "Support"])
@@ -47,9 +49,9 @@ describe("Util_OwnerScopeEnv — the elevated-groups carrier", () => {
   testSync("a caller that pinned the variable wins", () => {
     let variables = Dict.fromArray([(Util_OwnerScopeEnv.key, "Pinned"->Obj.magic)])
     withElevated(["Admin"], () => Util_OwnerScopeEnv.applyElevatedGroupsDefault(variables))
-    expect(variables->Dict.get(Util_OwnerScopeEnv.key)->Option.getOr(""->Obj.magic)->Obj.magic)->toBe(
-      "Pinned",
-    )
+    expect(
+      variables->Dict.get(Util_OwnerScopeEnv.key)->Option.getOr(""->Obj.magic)->Obj.magic,
+    )->toBe("Pinned")
   })
 
   testSync("adds nothing when the deployment named no elevated groups", () => {

package/tests/Util_SQS_RuntimeTest.res

@@ -1,8 +1,7 @@
 open JestGlobals
 
 let shortId = "environment:alpha#platformName:online-shop#pluginName:Catalog"
-let longId =
-  "componentName:DcbEventLog#environment:alpha#platformName:online-shop-platform-aws#pluginName:Catalog#resourceName:CatalogDcbEventLog-428c0a8"
+let longId = "componentName:DcbEventLog#environment:alpha#platformName:online-shop-platform-aws#pluginName:Catalog#resourceName:CatalogDcbEventLog-428c0a8"
 
 describe("Util_SQS_Runtime.safeGroupId", () => {
   testSync("returns id unchanged when ≤ 128 chars", () => {
@@ -19,12 +18,11 @@ describe("Util_SQS_Runtime.safeGroupId", () => {
   })
 
   testSync("returns different hashes for different long ids", () => {
-    let longId2 =
-      "componentName:Products#environment:alpha#platformName:online-shop-platform-aws#pluginName:Catalog#resourceName:ProductsTable-abc1234"
+    let longId2 = "componentName:Products#environment:alpha#platformName:online-shop-platform-aws#pluginName:Catalog#resourceName:ProductsTable-abc1234"
     expect(longId2->String.length > 128)->toBe(true)
-    expect(
-      Util_SQS_Runtime.safeGroupId(longId) == Util_SQS_Runtime.safeGroupId(longId2)
-    )->toBe(false)
+    expect(Util_SQS_Runtime.safeGroupId(longId) == Util_SQS_Runtime.safeGroupId(longId2))->toBe(
+      false,
+    )
   })
 
   testSync("returns same hash for the same long id (deterministic)", () => {

package/tests/Util_ShellConfigTest.res

@@ -33,9 +33,7 @@ describe("Util_ShellConfig.fields — viewModes", () => {
     expect(out->get("viewModes"))->toEqual(
       JSON.Encode.array([JSON.Encode.string("map"), JSON.Encode.string("graph")]),
     )
-    expect(out->get("mapStyle"))->toEqual(
-      JSON.Encode.string("https://tiles.example/style.json"),
-    )
+    expect(out->get("mapStyle"))->toEqual(JSON.Encode.string("https://tiles.example/style.json"))
     expect(out->get("graphLayout"))->toEqual(JSON.Encode.string("dagre"))
   })
 })
@@ -43,7 +41,7 @@ describe("Util_ShellConfig.fields — viewModes", () => {
 describe("Util_ShellConfig.fields — bakedManifest", () => {
   let bake = (~key: option<string>=?): ReventlessInfra.Platform.bakedManifest => {
     components: [{plugin: "Catalog", views: ["Products"], commands: []}],
-    key: ?key,
+    ?key,
   }
 
   testSync("unset ⇒ no manifestUrl, so every caller keeps the admin path", () => {
@@ -202,8 +200,8 @@ describe("Util_ShellConfig.fields — journeys", () => {
       ->Array.filterMap(JSON.Decode.string),
     )
     expect(published)->toEqual(
-      ReventlessCore.Platform_BakedManifest.files(~config=bake)->Array.map(((key, _)) =>
-        "/" ++ key
+      ReventlessCore.Platform_BakedManifest.files(~config=bake)->Array.map(
+        ((key, _)) => "/" ++ key,
       ),
     )
   })
@@ -215,9 +213,7 @@ describe("Util_ShellConfig.fields — journeys", () => {
       let _ = Util_ShellConfig.fields(
         ~computed,
         ~bakedManifest=withJourneys(~journeys=[shopper]),
-        ~shellConfig=Dict.fromArray([
-          ("journeyManifestUrls", JSON.Encode.object(Dict.make())),
-        ]),
+        ~shellConfig=Dict.fromArray([("journeyManifestUrls", JSON.Encode.object(Dict.make()))]),
       )
       None
     } catch {
@@ -239,12 +235,7 @@ describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
         ("accessTiers", JSON.Encode.array([JSON.Encode.string("public")])),
       ]),
     )
-    expect(out->Dict.keysToArray)->toEqual([
-      "apiEndpoint",
-      "region",
-      "platformName",
-      "accessTiers",
-    ])
+    expect(out->Dict.keysToArray)->toEqual(["apiEndpoint", "region", "platformName", "accessTiers"])
     expect(out->get("platformName"))->toEqual(JSON.Encode.string("Online Shop"))
   })
 
@@ -277,8 +268,7 @@ describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
 // These assert the property that removes that window, not the spelling.
 describe("Util_ShellConfig.identityFields", () => {
   let fields = Util_ShellConfig.identityFields(~providerId="eu-west-1_x", ~clientId="7cl13nt")
-  let get = key =>
-    fields->Array.find(((k, _)) => k == key)->Option.map(((_, v)) => v)
+  let get = key => fields->Array.find(((k, _)) => k == key)->Option.map(((_, v)) => v)
 
   testSync("the new spelling is present", () =>
     expect((get("identityProviderId"), get("identityProviderClientId")))->toEqual((

package/tests/Util_StaticBundleTest.res

@@ -31,13 +31,9 @@ describe("Util_StaticBundle.contentTypeFor", () => {
     )
   )
   testSync("json", () =>
-    expect(Util_StaticBundle.contentTypeFor("data.json"))->toBe(
-      "application/json; charset=utf-8",
-    )
-  )
-  testSync("svg", () =>
-    expect(Util_StaticBundle.contentTypeFor("logo.svg"))->toBe("image/svg+xml")
+    expect(Util_StaticBundle.contentTypeFor("data.json"))->toBe("application/json; charset=utf-8")
   )
+  testSync("svg", () => expect(Util_StaticBundle.contentTypeFor("logo.svg"))->toBe("image/svg+xml"))
   testSync("woff2", () =>
     expect(Util_StaticBundle.contentTypeFor("font.woff2"))->toBe("font/woff2")
   )
@@ -92,8 +88,7 @@ describe("Util_StaticBundle.walk", () => {
   testSync("identical contents produce identical hashes", () => {
     let dir = makeFixture()
     let entries = Util_StaticBundle.walk(dir)
-    let indexEntry =
-      entries->Array.find(e => e.relativePath == "index.html")->Option.getUnsafe
+    let indexEntry = entries->Array.find(e => e.relativePath == "index.html")->Option.getUnsafe
     let indexHash = indexEntry.contentHash
     let dir2 = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "static-bundle-"]))
     NodeFs.writeFileSync(NodePath.join([dir2, "index.html"]), "<html></html>")

package/tests/Util_StoreLayoutTest.res

@@ -4,11 +4,15 @@ let prodStacks = Util_HostUiDomain.defaultProdStacks
 
 describe("Util_StoreLayout.layoutFor", () => {
   testSync("a prod-named stack gets a bucket per store", () =>
-    expect(Util_StoreLayout.layoutFor(~stack="prod", ~prodStacks))->toEqual(Util_StoreLayout.PerStore)
+    expect(Util_StoreLayout.layoutFor(~stack="prod", ~prodStacks))->toEqual(
+      Util_StoreLayout.PerStore,
+    )
   )
 
   testSync("'main' is production too, by the shared prod list", () =>
-    expect(Util_StoreLayout.layoutFor(~stack="main", ~prodStacks))->toEqual(Util_StoreLayout.PerStore)
+    expect(Util_StoreLayout.layoutFor(~stack="main", ~prodStacks))->toEqual(
+      Util_StoreLayout.PerStore,
+    )
   )
 
   testSync("alpha shares one bucket", () =>
@@ -34,9 +38,9 @@ describe("Util_StoreLayout.layoutFor", () => {
   )
 
   testSync("adding it to the prod list is the fix", () =>
-    expect(Util_StoreLayout.layoutFor(~stack="production", ~prodStacks=["prod", "production"]))->toEqual(
-      Util_StoreLayout.PerStore,
-    )
+    expect(
+      Util_StoreLayout.layoutFor(~stack="production", ~prodStacks=["prod", "production"]),
+    )->toEqual(Util_StoreLayout.PerStore)
   )
 })
 
@@ -91,18 +95,18 @@ describe("Util_StoreLayout.coverageFor", () => {
   )
 
   testSync("declaring nothing is covered, whatever the platform provisions", () =>
-    expect(Util_StoreLayout.coverageFor(~required=[], ~provisioned=["Catalog.productImages"]))->toEqual(
-      Util_StoreLayout.Covered,
-    )
+    expect(
+      Util_StoreLayout.coverageFor(~required=[], ~provisioned=["Catalog.productImages"]),
+    )->toEqual(Util_StoreLayout.Covered)
   )
 
   // A platform provisioning nothing has not adopted capability provisioning.
   // Failing it would break deployments that work today, so this is the arm that
   // must NOT be a hard error.
   testSync("a platform provisioning nothing has not adopted, rather than got it wrong", () =>
-    expect(Util_StoreLayout.coverageFor(~required=["Catalog.productImages"], ~provisioned=[]))->toEqual(
-      Util_StoreLayout.NotAdopted(["Catalog.productImages"]),
-    )
+    expect(
+      Util_StoreLayout.coverageFor(~required=["Catalog.productImages"], ~provisioned=[]),
+    )->toEqual(Util_StoreLayout.NotAdopted(["Catalog.productImages"]))
   )
 
   // The case that shipped: the platform declared the store under a lowercased
@@ -282,7 +286,8 @@ describe("Util_StoreLayout.pendingExpiryFor", () => {
   // Guessing at what a typo meant, in the one setting that deletes objects, is
   // not a service — an unreadable entry leaves the store accumulating.
   testSync("a malformed or non-positive entry is ignored, not defaulted", () => {
-    let of_ = c => Util_StoreLayout.pendingExpiryFor(~config=Some(c), ~store="Catalog.productImages")
+    let of_ = c =>
+      Util_StoreLayout.pendingExpiryFor(~config=Some(c), ~store="Catalog.productImages")
     expect((
       of_("Catalog.productImages"),
       of_("Catalog.productImages="),

package/tests/integration/AggregateEntryPoint_IntegrationTest.res

@@ -73,10 +73,7 @@ let buildAppSyncEvent = (~id, ~name): JSON.t => {
     ("id", id->JSON.Encode.string),
     ("name", name->JSON.Encode.string),
   ])
-  let meta = Dict.fromArray([
-    ("user", "agg-test"->JSON.Encode.string),
-    ("ip", JSON.Encode.null),
-  ])
+  let meta = Dict.fromArray([("user", "agg-test"->JSON.Encode.string), ("ip", JSON.Encode.null)])
   Dict.fromArray([
     ("command", "Add"->JSON.Encode.string),
     ("arguments", arguments->JSON.Encode.object),