@reventlessdev/reventless-aws 3.0.0-alpha.259 → 3.0.0-alpha.260

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -198,6 +198,16 @@ let finish = () =>
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+        // Deploy-derived capability endpoints — a geocoder URL today. Plugin-wide
+        // rather than per-handler, which is why they sit here and not inside
+        // HANDLER_CONFIG: this is one shared Lambda and every slice on it reaches
+        // the same capability. A capability the platform did not provision arrives
+        // as "", which its client reads as "not configured" and reports as a
+        // retryable `Unavailable` — a modelled outcome rather than a missing
+        // variable that fails as a crash.
+        PluginRuntime_Builder.capabilityEnv()->Array.forEach(((name, value)) =>
+          envVars->Dict.set(name, value->Pulumi.Output.asInput)
+        )
 
         let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
           ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",
@@ -310,6 +320,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
 
         let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
         envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+        // Deploy-derived capability endpoints — a geocoder URL today. Plugin-wide
+        // rather than per-handler, which is why they sit here and not inside
+        // HANDLER_CONFIG: this is one shared Lambda and every slice on it reaches
+        // the same capability. A capability the platform did not provision arrives
+        // as "", which its client reads as "not configured" and reports as a
+        // retryable `Unavailable` — a modelled outcome rather than a missing
+        // variable that fails as a crash.
+        PluginRuntime_Builder.capabilityEnv()->Array.forEach(((name, value)) =>
+          envVars->Dict.set(name, value->Pulumi.Output.asInput)
+        )
 
         let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
           ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as PluginRuntime_Builder$ReventlessAws from "../../plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -129,6 +130,9 @@ function finish() {
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      PluginRuntime_Builder$ReventlessAws.capabilityEnv().forEach(param => {
+        envVars[param[0]] = param[1];
+      });
       let match$1 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
       let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, undefined, opts);
       let channelSpecs = storedSpecs.map(param => param.channelSpec);
@@ -188,6 +192,9 @@ function finishWithDcbEventLog(dcbEventLog) {
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      PluginRuntime_Builder$ReventlessAws.capabilityEnv().forEach(param => {
+        envVars[param[0]] = param[1];
+      });
       let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
       let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match.code, match.sourceCodeHash, envVars, 1024, 30, undefined, undefined, undefined, undefined, undefined, opts);
       EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllAutomationSlices", [{

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -331,26 +331,13 @@ let makeFromCodeAsset: (
     // is no race against Lambda's lazy auto-created group. Namespace/dimension
     // are CloudWatch-specific and live here, not in core (provider-neutral).
     if dcbMetrics {
-      [
-        "AppendRetry",
-        "AppendConflict",
-        "DcbDecisionModelCacheHit",
-        "DcbDecisionModelCacheMiss",
-        "DcbDecisionModelDeltaEventCount",
-      ]->Array.forEach(metricName => {
+      Util_DcbMetrics.metricNames->Array.forEach(metricName => {
         let _ = Cloudwatch.LogMetricFilter.make(
           ~name=`${name}${metricName}Filter`,
           ~args={
-            pattern: `{ $.reventlessMetric = "${metricName}" }`->Pulumi.Input.make,
+            pattern: Util_DcbMetrics.patternFor(metricName)->Pulumi.Input.make,
             logGroupName: logGroup.name->Pulumi.Output.asInput,
-            metricTransformation: ({
-              name: metricName->Pulumi.Input.make,
-              namespace: "Reventless/DCB"->Pulumi.Input.make,
-              value: "$.value"->Pulumi.Input.make,
-              defaultValue: "0"->Pulumi.Input.make,
-              unit: "Count"->Pulumi.Input.make,
-              dimensions: Dict.fromArray([("slice", "$.slice")])->Pulumi.Input.make,
-            }: Cloudwatch.LogMetricFilter.metricTransformation)->Pulumi.Input.make,
+            metricTransformation: Util_DcbMetrics.transformationFor(metricName)->Pulumi.Input.make,
           },
           ~opts?,
         )

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs

@@ -20,6 +20,7 @@ import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as Util_Lambda$ReventlessAws from "../../util/Util_Lambda.res.mjs";
 import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
 import * as Util_IAM_Role$ReventlessAws from "../../util/Util_IAM_Role.res.mjs";
+import * as Util_DcbMetrics$ReventlessAws from "../../util/Util_DcbMetrics.res.mjs";
 import * as Util_LocalConfig$ReventlessAws from "../../util/Util_LocalConfig.res.mjs";
 import * as Util_HostUiDomain$ReventlessAws from "../../util/Util_HostUiDomain.res.mjs";
 import * as Util_LogRetention$ReventlessAws from "../../util/Util_LogRetention.res.mjs";
@@ -136,27 +137,11 @@ function makeFromCodeAsset(name, unitKind, componentKind, code, sourceCodeHash,
       tags: tagsFor(name + `LogGroup`, "Logs")
     }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
     if (dcbMetrics) {
-      [
-        "AppendRetry",
-        "AppendConflict",
-        "DcbDecisionModelCacheHit",
-        "DcbDecisionModelCacheMiss",
-        "DcbDecisionModelDeltaEventCount"
-      ].forEach(metricName => {
+      Util_DcbMetrics$ReventlessAws.metricNames.forEach(metricName => {
         new (Aws.cloudwatch.LogMetricFilter)(name + metricName + `Filter`, {
-          pattern: `{ $.reventlessMetric = "` + metricName + `" }`,
+          pattern: Util_DcbMetrics$ReventlessAws.patternFor(metricName),
           logGroupName: logGroup.name,
-          metricTransformation: {
-            name: metricName,
-            namespace: "Reventless/DCB",
-            value: "$.value",
-            defaultValue: "0",
-            unit: "Count",
-            dimensions: Object.fromEntries([[
-                "slice",
-                "$.slice"
-              ]])
-          }
+          metricTransformation: Util_DcbMetrics$ReventlessAws.transformationFor(metricName)
         }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
       });
       return;

package/src/components/OutboundTranslationSlice_Builder.res

@@ -38,8 +38,8 @@ module Make = (Api: {
     type component = InnerMake.component
     let queryDbName = InnerMake.queryDbName
 
-    let make = (~dcbEventLog, ~publishJsons, ~runtime=?, ~opts=?): component => {
-      let ots = InnerMake.make(~dcbEventLog, ~publishJsons, ~runtime?, ~opts?)
+    let make = (~dcbEventLog, ~allEventTopics=Dict.make(), ~publishJsons, ~runtime=?, ~opts=?): component => {
+      let ots = InnerMake.make(~dcbEventLog, ~allEventTopics, ~publishJsons, ~runtime?, ~opts?)
 
       let queryDbOutputs = (ots->ReventlessCore.Component.outputs).queryDb
       let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -43,8 +43,9 @@ function Make(Api) {
   })(Api);
   let Make$1 = Spec => (Translation => {
     let InnerMake = Inner.Make(Spec)(Translation);
-    let make = (dcbEventLog, publishJsons, runtime, opts) => {
-      let ots = InnerMake.make(dcbEventLog, publishJsons, runtime, opts);
+    let make = (dcbEventLog, allEventTopicsOpt, publishJsons, runtime, opts) => {
+      let allEventTopics = allEventTopicsOpt !== undefined ? allEventTopicsOpt : ({});
+      let ots = InnerMake.make(dcbEventLog, allEventTopics, publishJsons, runtime, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(ots).queryDb;
       let tableResource = queryDbOutputs.resources[0];
       let queryDbTableName = tableResource.name;

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -20,6 +20,37 @@ let configRef: ref<adminConfig> = ref({
   clonerEnabled: false,
 })
 
+/**
+Deploy-derived environment for a plugin's slice Lambdas, keyed by variable name.
+
+A capability the platform provisions — a geocoder, and the same shape whenever
+the next one arrives — is reachable only through a value the platform computes:
+a URL, an index name, a queue. The deployer never types it, which is what keeps
+it out of `commandHandlerConfig` (memory, timeout, the knobs a human chooses)
+and out of the hand-edited config files this framework exists to remove.
+
+Kept apart from `configRef` because the two are filled at different moments and
+by different halves: `registerConfig` runs inside `deployPlatform` and replaces
+its record wholesale, while these values are only knowable in `deployPlugin`,
+where a plugin stack reads them off the platform's stack reference.
+
+Keyed by the variable name rather than by capability so the runtime builders
+merge a dict they need no knowledge of. Naming a capability's variable is then
+a single decision at the single call site that knows which capability it is —
+not a table two modules have to agree on.
+*/
+let capabilityEnvRef: dict<Pulumi.Output.t<string>> = Dict.make()
+
+/** Registers one deploy-derived variable. Must be called before the plugin
+    builds — the slice runtimes read the dict when their finalizer runs. */
+let registerCapabilityEnv = (name: string, value: Pulumi.Output.t<string>) =>
+  capabilityEnvRef->Dict.set(name, value)
+
+/** The registered variables, for a runtime builder to merge into its Lambda's
+    environment. Empty is the ordinary answer for a platform that provisions no
+    capability, so this returns `[]` rather than throwing. */
+let capabilityEnv = () => capabilityEnvRef->Dict.toArray
+
 type sliceModulePaths = {
   specPath: string,
   behaviorPath: string,

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -34,6 +34,16 @@ let configRef = {
   }
 };
 
+let capabilityEnvRef = {};
+
+function registerCapabilityEnv(name, value) {
+  capabilityEnvRef[name] = value;
+}
+
+function capabilityEnv() {
+  return Object.entries(capabilityEnvRef);
+}
+
 let dcbConfigRef = {
   contents: {
     pluginName: "",
@@ -493,6 +503,9 @@ function Make(EventCollectorChannel) {
 export {
   log,
   configRef,
+  capabilityEnvRef,
+  registerCapabilityEnv,
+  capabilityEnv,
   dcbConfigRef,
   registeredSliceModulePaths,
   registerStateChangeSliceSpec,

package/src/util/Util_DcbMetrics.res

@@ -0,0 +1,48 @@
+// The CloudWatch half of DCB metrics: the provider-neutral metric lines that
+// StateChangeSlice_Callback emits (`{reventlessMetric, slice, value}`) become
+// CloudWatch metrics through a log metric filter per metric name. Namespace and
+// dimension are CloudWatch-specific and belong here rather than in core.
+//
+// Pure on purpose. The filters are only built for a Lambda that has a MANAGED log
+// group to attach to, so no stack exercised this code until managed groups existed
+// — and an invalid transformation therefore shipped without any deploy catching it.
+// Keeping the transformation a plain function makes the one rule CloudWatch enforces
+// testable without standing up a Pulumi resource.
+
+open PulumiAws
+
+/** The metrics extracted from a DCB command handler's logs. */
+let metricNames = [
+  "AppendRetry",
+  "AppendConflict",
+  "DcbDecisionModelCacheHit",
+  "DcbDecisionModelCacheMiss",
+  "DcbDecisionModelDeltaEventCount",
+]
+
+let namespace = "Reventless/DCB"
+
+/** Filter pattern selecting one metric's lines out of the log stream. */
+let patternFor = (metricName: string): string => `{ $.reventlessMetric = "${metricName}" }`
+
+/**
+The metric transformation for one DCB metric, dimensioned by slice.
+
+`dimensions` and `defaultValue` are **mutually exclusive** — `PutMetricFilter`
+rejects a transformation carrying both with `InvalidParameterException: Invalid
+metric transformation: dimensions and default value are mutually exclusive
+properties`. The reason is that a default value is emitted when the pattern does not
+match, and for a dimensioned metric there is no dimension value to attribute such a
+point to.
+
+The `slice` dimension is the half worth keeping: without it every slice's counts
+collapse into one undifferentiated series. So this sets no `defaultValue`, and a
+metric simply reports no data point for a period in which nothing matched.
+*/
+let transformationFor = (metricName: string): Cloudwatch.LogMetricFilter.metricTransformation => {
+  name: metricName->Pulumi.Input.make,
+  namespace: namespace->Pulumi.Input.make,
+  value: "$.value"->Pulumi.Input.make,
+  unit: "Count"->Pulumi.Input.make,
+  dimensions: Dict.fromArray([("slice", "$.slice")])->Pulumi.Input.make,
+}

package/src/util/Util_DcbMetrics.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let metricNames = [
+  "AppendRetry",
+  "AppendConflict",
+  "DcbDecisionModelCacheHit",
+  "DcbDecisionModelCacheMiss",
+  "DcbDecisionModelDeltaEventCount"
+];
+
+let namespace = "Reventless/DCB";
+
+function patternFor(metricName) {
+  return `{ $.reventlessMetric = "` + metricName + `" }`;
+}
+
+function transformationFor(metricName) {
+  return {
+    name: metricName,
+    namespace: namespace,
+    value: "$.value",
+    unit: "Count",
+    dimensions: Object.fromEntries([[
+        "slice",
+        "$.slice"
+      ]])
+  };
+}
+
+export {
+  metricNames,
+  namespace,
+  patternFor,
+  transformationFor,
+}
+/* No side effect */

package/src/util/Util_ShellConfig.res

@@ -0,0 +1,72 @@
+// Assembly of the `config.json` the deploy writes beside the host shell's
+// `index.html`.
+//
+// The keys split in two: the ones the deploy *computes* (endpoints, region,
+// pool ids — resolved Pulumi Outputs by the time they get here) and the ones a
+// deployment *chooses*. This module is the pure join of the two, so the whole
+// key set is reachable from a test instead of living inside deployPlatform's
+// `Pulumi.Output.apply`, where nothing could assert a single key of it.
+
+module Platform = ReventlessInfra.Platform
+
+// A mode's options, flattened to the wire shape. They are payloads of their arm
+// on the deploy side (so `mapStyle` with the map off cannot be expressed) and
+// flat siblings of `viewModes` on the wire (because that is where the released
+// shell reads them). This function is the whole of that translation.
+let modeOptions = (mode: Platform.viewMode): array<(string, JSON.t)> =>
+  switch mode {
+  | Map(opts) =>
+    switch opts.style {
+    | Some(style) => [("mapStyle", JSON.Encode.string(style))]
+    | None => []
+    }
+  | Graph(opts) =>
+    switch opts.layout {
+    | Some(layout) => [("graphLayout", JSON.Encode.string(layout))]
+    | None => []
+    }
+  }
+
+/**
+The config.json field set.
+
+`computed` arrives in wire order and keeps it. `viewModes` unset ⇒ no
+`viewModes` key and no per-mode key, so a deployment that wants no optional mode
+gets byte-identical output to before this input existed. `shellConfig` merges in
+last; a key it shares with one already present fails the deploy naming it,
+because silently resolving the collision either way produces an app pointed
+somewhere unintended with nothing in the diff to say so.
+*/
+let fields = (
+  ~computed: array<(string, JSON.t)>,
+  ~viewModes: option<array<Platform.viewMode>>=?,
+  ~shellConfig: option<dict<JSON.t>>=?,
+): dict<JSON.t> => {
+  let out = computed->Dict.fromArray
+
+  switch viewModes {
+  | Some(modes) =>
+    out->Dict.set(
+      "viewModes",
+      modes->Array.map(m => m->Platform.viewModeToString->JSON.Encode.string)->JSON.Encode.array,
+    )
+    modes->Array.forEach(m => m->modeOptions->Array.forEach(((k, v)) => out->Dict.set(k, v)))
+  | None => ()
+  }
+
+  switch shellConfig {
+  | Some(extra) =>
+    let collisions = extra->Dict.keysToArray->Array.filter(k => out->Dict.get(k)->Option.isSome)
+    if collisions->Array.length > 0 {
+      failwith(
+        "host UI config.json: shellConfig sets key(s) the deploy already computes — " ++
+        collisions->Array.join(", ") ++
+        ". Remove them from shellConfig; a passthrough cannot redirect a computed key.",
+      )
+    }
+    extra->Dict.forEachWithKey((v, k) => out->Dict.set(k, v))
+  | None => ()
+  }
+
+  out
+}

package/src/util/Util_ShellConfig.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pervasives from "@rescript/runtime/lib/es6/Pervasives.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Platform$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/Platform.res.mjs";
+
+function modeOptions(mode) {
+  if (mode.TAG === "Map") {
+    let style = mode._0.style;
+    if (style !== undefined) {
+      return [[
+          "mapStyle",
+          style
+        ]];
+    } else {
+      return [];
+    }
+  }
+  let layout = mode._0.layout;
+  if (layout !== undefined) {
+    return [[
+        "graphLayout",
+        layout
+      ]];
+  } else {
+    return [];
+  }
+}
+
+function fields(computed, viewModes, shellConfig) {
+  let out = Object.fromEntries(computed);
+  if (viewModes !== undefined) {
+    out["viewModes"] = viewModes.map(Platform$ReventlessInfra.viewModeToString);
+    viewModes.forEach(m => {
+      modeOptions(m).forEach(param => {
+        out[param[0]] = param[1];
+      });
+    });
+  }
+  if (shellConfig !== undefined) {
+    let collisions = Object.keys(shellConfig).filter(k => Stdlib_Option.isSome(out[k]));
+    if (collisions.length !== 0) {
+      Pervasives.failwith("host UI config.json: shellConfig sets key(s) the deploy already computes — " + collisions.join(", ") + ". Remove them from shellConfig; a passthrough cannot redirect a computed key.");
+    }
+    Stdlib_Dict.forEachWithKey(shellConfig, (v, k) => {
+      out[k] = v;
+    });
+  }
+  return out;
+}
+
+let Platform;
+
+export {
+  Platform,
+  modeOptions,
+  fields,
+}
+/* No side effect */

package/tests/Geocoder_AwsLocation_OpsTest.res

@@ -0,0 +1,78 @@
+// Guards the geocoder Function URL's *status* contract, which is the whole
+// reason one endpoint can serve two callers that want opposite things from it.
+//
+// A browser search box reads the body and must degrade quietly: never an error,
+// just no results. An unattended translator reads the status, because it has to
+// tell "there is no such address" (write a verdict, do not retry) from "the
+// service cannot answer" (retry). The two only ever disagree about which half of
+// the response they read, so:
+//
+//   200 + a possibly-empty array  — an answer
+//   anything else                 — no answer
+//
+// The arms below are the ones reachable without a live AWS Location call. The
+// success path and the thrown-error path both need the SDK and stay unasserted
+// here — see the plan's Verification note.
+
+open JestGlobals
+
+let setIndex = v => NodeProcess.env->Dict.set("PLACE_INDEX_NAME", v)
+let clearIndex = () => NodeProcess.env->Dict.delete("PLACE_INDEX_NAME")
+
+describe("Geocoder_AwsLocation_Ops.handler status contract", () => {
+  test("an unset PLACE_INDEX_NAME is a service failure, not a verdict", async () => {
+    clearIndex()
+    let resp = await Geocoder_AwsLocation_Ops.handler({
+      queryStringParameters: Dict.fromArray([("q", "10 Downing Street")]),
+    })
+    // The arm that matters most: `200 []` here would tell a translator this
+    // address does not exist, and it would record that permanently — for every
+    // address handed to it while the deployment stayed misconfigured.
+    expect(resp.statusCode)->toBe(502)
+    expect(resp.body)->toBe("[]")
+  })
+
+  test("an empty query is an answer — nothing was asked", async () => {
+    setIndex("some-index")
+    let resp = await Geocoder_AwsLocation_Ops.handler({
+      queryStringParameters: Dict.fromArray([("q", "")]),
+    })
+    // 200, unlike the case above: "no results for nothing" is true and final,
+    // and a search box sends exactly this on every cleared input.
+    expect(resp.statusCode)->toBe(200)
+    expect(resp.body)->toBe("[]")
+    clearIndex()
+  })
+
+  test("a missing q param is treated as an empty one", async () => {
+    setIndex("some-index")
+    let resp = await Geocoder_AwsLocation_Ops.handler({})
+    expect(resp.statusCode)->toBe(200)
+    clearIndex()
+  })
+})
+
+describe("Geocoder_AwsLocation_Ops.readQueryParam", () => {
+  testSync("prefers the parsed params", () => {
+    expect(
+      Geocoder_AwsLocation_Ops.readQueryParam({
+        queryStringParameters: Dict.fromArray([("q", "Berlin")]),
+      }),
+    )->toEqual(Some("Berlin"))
+  })
+
+  testSync("falls back to the raw query string, percent-decoded", () => {
+    // Payload format 2.0 populates both fields, but a caller that builds its own
+    // URL is the reason the fallback exists — and the encoding is where a plain
+    // `split("=")` would hand back `10%20Downing%20Street`.
+    expect(
+      Geocoder_AwsLocation_Ops.readQueryParam({
+        rawQueryString: "lang=en&q=10%20Downing%20Street",
+      }),
+    )->toEqual(Some("10 Downing Street"))
+  })
+
+  testSync("no q anywhere is None", () => {
+    expect(Geocoder_AwsLocation_Ops.readQueryParam({rawQueryString: "lang=en"}))->toEqual(None)
+  })
+})

package/tests/Geocoder_AwsLocation_OpsTest.res.mjs

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Geocoder_AwsLocation_Ops$ReventlessAws from "../src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res.mjs";
+
+function setIndex(v) {
+  process.env["PLACE_INDEX_NAME"] = v;
+}
+
+function clearIndex() {
+  Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+}
+
+globalThis.describe("Geocoder_AwsLocation_Ops.handler status contract", () => {
+  globalThis.test("an unset PLACE_INDEX_NAME is a service failure, not a verdict", async () => {
+    Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          "10 Downing Street"
+        ]])
+    });
+    globalThis.expect(resp.statusCode).toBe(502);
+    globalThis.expect(resp.body).toBe("[]");
+  });
+  globalThis.test("an empty query is an answer — nothing was asked", async () => {
+    setIndex("some-index");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          ""
+        ]])
+    });
+    globalThis.expect(resp.statusCode).toBe(200);
+    globalThis.expect(resp.body).toBe("[]");
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+  globalThis.test("a missing q param is treated as an empty one", async () => {
+    setIndex("some-index");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({});
+    globalThis.expect(resp.statusCode).toBe(200);
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+});
+
+globalThis.describe("Geocoder_AwsLocation_Ops.readQueryParam", () => {
+  globalThis.test("prefers the parsed params", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          "Berlin"
+        ]])
+    })).toEqual("Berlin");
+  });
+  globalThis.test("falls back to the raw query string, percent-decoded", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      rawQueryString: "lang=en&q=10%20Downing%20Street"
+    })).toEqual("10 Downing Street");
+  });
+  globalThis.test("no q anywhere is None", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      rawQueryString: "lang=en"
+    })).toEqual(undefined);
+  });
+});
+
+export {
+  setIndex,
+  clearIndex,
+}
+/*  Not a pure module */

package/tests/Util_DcbMetricsTest.res

@@ -0,0 +1,35 @@
+open JestGlobals
+
+// The rule that matters is CloudWatch's, not ours: a metric transformation may carry
+// `dimensions` OR `defaultValue`, never both. Violating it is not caught at compile
+// time — both fields are optional in the binding — and not caught at deploy time
+// either unless the stack happens to have a managed log group for the filter to
+// attach to. So it is asserted here.
+
+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)
+    )
+  )
+
+  testSync("dimensions the metric by slice", () =>
+    expect(
+      Util_DcbMetrics.transformationFor("AppendRetry").dimensions->Option.isSome,
+    )->toBe(true)
+  )
+
+  testSync("counts into the DCB namespace", () =>
+    expect(Util_DcbMetrics.transformationFor("AppendRetry").namespace)->toBe("Reventless/DCB")
+  )
+
+  testSync("names the metric after the emitted marker", () =>
+    expect(Util_DcbMetrics.transformationFor("AppendConflict").name)->toBe("AppendConflict")
+  )
+})
+
+describe("Util_DcbMetrics.patternFor", () => {
+  testSync("selects one metric's lines by its marker", () =>
+    expect(Util_DcbMetrics.patternFor("AppendRetry"))->toBe(`{ $.reventlessMetric = "AppendRetry" }`)
+  )
+})

package/tests/Util_DcbMetricsTest.res.mjs

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Util_DcbMetrics$ReventlessAws from "../src/util/Util_DcbMetrics.res.mjs";
+
+globalThis.describe("Util_DcbMetrics.transformationFor", () => {
+  globalThis.test("never sets defaultValue — it is mutually exclusive with dimensions", () => {
+    Util_DcbMetrics$ReventlessAws.metricNames.forEach(m => {
+      globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor(m).defaultValue).toBe(undefined);
+    });
+  });
+  globalThis.test("dimensions the metric by slice", () => {
+    globalThis.expect(Stdlib_Option.isSome(Util_DcbMetrics$ReventlessAws.transformationFor("AppendRetry").dimensions)).toBe(true);
+  });
+  globalThis.test("counts into the DCB namespace", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor("AppendRetry").namespace).toBe("Reventless/DCB");
+  });
+  globalThis.test("names the metric after the emitted marker", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor("AppendConflict").name).toBe("AppendConflict");
+  });
+});
+
+globalThis.describe("Util_DcbMetrics.patternFor", () => {
+  globalThis.test("selects one metric's lines by its marker", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.patternFor("AppendRetry")).toBe(`{ $.reventlessMetric = "AppendRetry" }`);
+  });
+});
+
+/*  Not a pure module */