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

package/tests/StateViewSliceEntryPoint_OpsTest.res

@@ -33,34 +33,39 @@ describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("expands compact-v2 entries against shared base/sourceUrn/pgConnection", () => {
-    let config = obj([
-      ("v", JSON.Encode.int(2)),
-      ("base", str("@x/plugin/src/StateViewSlice/")),
-      ("sourceUrn", str("arn:shared")),
-      (
-        "pgConnection",
-        obj([
-          ("host", str("db.local")),
-          ("port", JSON.Encode.int(5432)),
-          ("database", str("app")),
-          ("username", str("master")),
-          ("secretArn", str("arn:secret")),
-        ]),
-      ),
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([("s", str("Carts.res.mjs")), ("p", str("Carts_Projection.res.mjs")), ("q", str("qdb_Carts"))]),
+    let config =
+      obj([
+        ("v", JSON.Encode.int(2)),
+        ("base", str("@x/plugin/src/StateViewSlice/")),
+        ("sourceUrn", str("arn:shared")),
+        (
+          "pgConnection",
           obj([
-            ("s", str("Totals.res.mjs")),
-            ("p", str("Totals_Projection.res.mjs")),
-            ("q", str("qdb_Totals")),
-            ("u", str("arn:override")),
-            ("t", str("cartTotals")),
+            ("host", str("db.local")),
+            ("port", JSON.Encode.int(5432)),
+            ("database", str("app")),
+            ("username", str("master")),
+            ("secretArn", str("arn:secret")),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("s", str("Carts.res.mjs")),
+              ("p", str("Carts_Projection.res.mjs")),
+              ("q", str("qdb_Carts")),
+            ]),
+            obj([
+              ("s", str("Totals.res.mjs")),
+              ("p", str("Totals_Projection.res.mjs")),
+              ("q", str("qdb_Totals")),
+              ("u", str("arn:override")),
+              ("t", str("cartTotals")),
+            ]),
+          ]),
+        ),
+      ])->JSON.stringify
     let entries = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(2)
     let first = entries->Array.getUnsafe(0)
@@ -76,21 +81,22 @@ describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("passes legacy full-key entries through with per-entry fields", () => {
-    let config = obj([
-      ("base", str("ignored/")),
-      ("sourceUrn", str("arn:shared")),
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("full/Carts.res.mjs")),
-            ("projectionModule", str("full/Carts_Projection.res.mjs")),
-            ("queryDbTableName", str("qdb_Carts")),
-            ("sourceUrn", str("arn:own")),
+    let config =
+      obj([
+        ("base", str("ignored/")),
+        ("sourceUrn", str("arn:shared")),
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("full/Carts.res.mjs")),
+              ("projectionModule", str("full/Carts_Projection.res.mjs")),
+              ("queryDbTableName", str("qdb_Carts")),
+              ("sourceUrn", str("arn:own")),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
     // Legacy entries are NOT base-prefixed and keep their own sourceUrn.
     expect(e.specModule)->toBe("full/Carts.res.mjs")
@@ -142,9 +148,9 @@ describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
 
   // String-typed consumed events keep the pipeline test independent of any
   // real slice: each event value becomes the row id, `recordedAt` the state.
-  let project = (
-    {event, recordedAt, _}: Reventless.StateViewSlice.consumed<string>,
-  ): array<Reventless.Projection.action<string, JSON.t>> => [Set(event, str(recordedAt))]
+  let project = ({event, recordedAt, _}: Reventless.StateViewSlice.consumed<string>): array<
+    Reventless.Projection.action<string, JSON.t>,
+  > => [Set(event, str(recordedAt))]
 
   test("decodes envelopes, projects, and runs actions against the ops", async () => {
     let saved = []
@@ -205,7 +211,12 @@ describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
         "row-1",
         obj([
           ("lifecycle", str("Placed")),
-          ("trail", JSON.Encode.array([obj([("state", str("Placed")), ("at", str("2026-03-02T09:00:00Z"))])])),
+          (
+            "trail",
+            JSON.Encode.array([
+              obj([("state", str("Placed")), ("at", str("2026-03-02T09:00:00Z"))]),
+            ]),
+          ),
         ]),
       ),
     ])

package/tests/TaskBucketEntryPoint_OpsTest.res

@@ -11,7 +11,6 @@ open JestGlobals
 let str = JSON.Encode.string
 let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
 
-
 describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
   testSync("empty raw config decodes to empty defaults", () => {
     let c = TaskBucketEntryPoint_Ops.parseHandlerConfig("")
@@ -21,18 +20,19 @@ describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes callbackModule, publishToAggregates, and scheduler env names", () => {
-    let config = obj([
-      ("callbackModule", str("@x/plugin/src/Task/ImportCatalog.res.mjs")),
-      ("publishToAggregates", obj([("Product", str("PTA_Product_QUEUE_URL"))])),
-      (
-        "scheduler",
-        obj([
-          ("roleArnEnv", str("SCHEDULER_ROLE_ARN")),
-          ("targetArnEnv", str("SCHEDULER_TARGET_ARN")),
-          ("targetNameEnv", str("SCHEDULER_TARGET_NAME")),
-        ]),
-      ),
-    ])->JSON.stringify
+    let config =
+      obj([
+        ("callbackModule", str("@x/plugin/src/Task/ImportCatalog.res.mjs")),
+        ("publishToAggregates", obj([("Product", str("PTA_Product_QUEUE_URL"))])),
+        (
+          "scheduler",
+          obj([
+            ("roleArnEnv", str("SCHEDULER_ROLE_ARN")),
+            ("targetArnEnv", str("SCHEDULER_TARGET_ARN")),
+            ("targetNameEnv", str("SCHEDULER_TARGET_NAME")),
+          ]),
+        ),
+      ])->JSON.stringify
     let c = TaskBucketEntryPoint_Ops.parseHandlerConfig(config)
     expect(c.callbackModule)->toBe("@x/plugin/src/Task/ImportCatalog.res.mjs")
     expect(c.publishToAggregates->Dict.get("Product"))->toEqual(Some("PTA_Product_QUEUE_URL"))

package/tests/Upload_ClaimTest.res

@@ -29,9 +29,9 @@ describe("Upload_Claim_S3_Ops.tableNameFromEventSourceArn", () => {
   )
 
   testSync("returns None for an ARN that is not a table stream", () =>
-    expect(Ops.tableNameFromEventSourceArn("arn:aws:sqs:eu-west-1:123456789012:SomeQueue"))->toEqual(
-      None,
-    )
+    expect(
+      Ops.tableNameFromEventSourceArn("arn:aws:sqs:eu-west-1:123456789012:SomeQueue"),
+    )->toEqual(None)
   )
 })
 

package/tests/Util_AwsErrorTest.res

@@ -52,9 +52,7 @@ describe("Util_AwsError.isNotFound", () => {
   // the original guard tested, and it is false for the real error.
   testSync("...and its message does not carry the code, which is why", () =>
     expect(
-      AwsError.describe(dynamoNotFound)->String.includes(
-        "Requested resource not found",
-      ),
+      AwsError.describe(dynamoNotFound)->String.includes("Requested resource not found"),
     )->toBe(true)
   )
 
@@ -118,10 +116,9 @@ describe("Util_AwsError.describe", () => {
   // failure with another.
   testSync("every shape yields something an operator can read", () =>
     expect(
-      [
-        awsError(~name="X", ~message="y"),
-        Not_found,
-      ]->Array.every(e => AwsError.describe(e)->String.length > 0),
+      [awsError(~name="X", ~message="y"), Not_found]->Array.every(
+        e => AwsError.describe(e)->String.length > 0,
+      ),
     )->toBe(true)
   )
 })

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)
@@ -130,7 +139,10 @@ describe("Util_Bundle — bundled user packages carry their imports", () => {
     // 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_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", () => {
@@ -57,4 +59,29 @@ describe("Util_OwnerScopeEnv — the elevated-groups carrier", () => {
     withElevated([], () => Util_OwnerScopeEnv.applyElevatedGroupsDefault(variables))
     expect(variables->Dict.get(Util_OwnerScopeEnv.key)->Option.isNone)->toBe(true)
   })
+
+  // The whole path the "administrator sees empty screens" trap ran through: the
+  // platform entry point defaults the list, and this composes it into a Lambda's
+  // environment. Asserted end to end rather than at either half, because both
+  // halves were already correct while the trap was open — the pipe was laid and
+  // nothing ever put a value in.
+  testSync("the platform's administrator default reaches a composed environment", () => {
+    Reventless.OwnerScope.clearElevatedGroups()
+    NodeProcess.env->Dict.delete(Util_OwnerScopeEnv.key)
+    Reventless.OwnerScope.defaultElevatedGroups([Reventless.AdminGroup.name])
+
+    let variables = Dict.make()
+    Util_OwnerScopeEnv.applyElevatedGroupsDefault(variables)
+    let encoded = switch variables->Dict.get(Util_OwnerScopeEnv.key) {
+    | Some(value) => value->Obj.magic
+    | None => ""
+    }
+    Reventless.OwnerScope.clearElevatedGroups()
+
+    // Round-tripped, like the first case above: the runtime reads this back with
+    // `parseElevatedGroups`, so the encoding is asserted rather than the spelling.
+    expect(Reventless.OwnerScope.parseElevatedGroups(encoded))->toEqual([
+      Reventless.AdminGroup.name,
+    ])
+  })
 })