@reventlessdev/reventless-aws 3.0.0-alpha.227 → 3.0.0-alpha.229

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.229 (2026-07-26)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
+# 3.0.0-alpha.228 (2026-07-26)
+
+### Features
+
+* **auto-ui:** write ui-hints.json from the host-ui AWS deploy ([cbb334c](https://github.com/ReventlessDev/reventless-core/commit/cbb334c5bc574d7be56746100bae93457a8831ce)), closes [#1](https://github.com/ReventlessDev/reventless-core/issues/1)
+* **aws:** geocoder + upload presign Lambda Function URL services ([be43179](https://github.com/ReventlessDev/reventless-core/commit/be4317972e781dbe3c378f21a28975d1ac8b9add))
+* **aws:** presign service returns the object URL as storageRef ([ec551e6](https://github.com/ReventlessDev/reventless-core/commit/ec551e69cfa82c0fa80122ebe122f827ddf280ec))
+* **dcb:** emit decision-model cache hit/miss + delta metrics ([967fb7f](https://github.com/ReventlessDev/reventless-core/commit/967fb7fb42f00d22b9dd6f6261e2f5308a6e9516))
+* **platform:** serve a private bucket to the UI under a same-origin prefix ([793c8b2](https://github.com/ReventlessDev/reventless-core/commit/793c8b25e13969b42ce331c698bad473be4c0c88))
+
+
 # 3.0.0-alpha.227 (2026-07-24)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,24 +1,27 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.227",
+  "version": "3.0.0-alpha.229",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
     "@aws-sdk/client-appsync": "3.970.0",
     "@aws-sdk/client-cloudfront": "3.970.0",
+    "@aws-sdk/client-location": "3.970.0",
+    "@aws-sdk/client-s3": "3.970.0",
+    "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.24",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.59",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.60",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.180",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.44",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.80"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.182",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.46",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -1001,6 +1001,30 @@ module MakeWithConfig = (
   type hostUiBundleConfig = {
     assetsDir: string,
     bundleVersion: string,
+    // Optional path to a static AutoUI `ui-hints.json` (assistant-authored,
+    // plain data — no app rebuild). When set, the deploy reads it and writes it
+    // verbatim as a `ui-hints.json` BucketObject beside `config.json`, so the
+    // shell's static-hints path works in a deployed app. Unset ⇒ no file
+    // written; the shell treats the resulting 404 as "no hints" and boots
+    // unchanged. Single-mode shape: one origin-relative file per deployment.
+    uiHintsFile?: string,
+    // Optional AWS Location place-index name. When set, the deploy provisions a
+    // public geocoder Lambda Function URL (Geocoder_AwsLocation) and threads its
+    // URL into config.json as `geocoderEndpoint`. Unset ⇒ no service, field
+    // omitted (byte-identical config.json).
+    geocoderPlaceIndex?: Pulumi.Input.t<string>,
+    // Opt into the direct-to-S3 upload presign service (Upload_Presign_S3). Both
+    // this flag and `uploadBucketName` must be set; the deploy then provisions a
+    // public presign Lambda Function URL and threads its URL into config.json as
+    // `uploadEndpoint`. Unset ⇒ no service, field omitted.
+    enableUploads?: bool,
+    // S3 bucket the upload presign service issues PUT URLs against. Required when
+    // `enableUploads` is true.
+    uploadBucketName?: Pulumi.Input.t<string>,
+    // Buckets served read-only to the UI under a path prefix on the host-shell
+    // CloudFront distribution (same-origin, private, OAC-read). Each entry adds a
+    // `{prefix}/*` ordered cache behavior + origin + scoped BucketPolicy.
+    servedBuckets?: array<ReventlessInfra.Platform.servedBucket>,
   }
 
   // Merged-mode outputs of deployPlatform — the merged API(s), plus the
@@ -1465,13 +1489,19 @@ module MakeWithConfig = (
         ~assetsDir=cfg.assetsDir,
         ~spaFallback=true,
         ~stableName=true,
-        // The explicit BucketObject below writes the production config.json
-        // with the resolved API endpoints + Cognito IDs. The host-shell
-        // bundle's public/config.json is the dev-mode fallback — exclude
-        // it from the bundle upload so both BucketObjects don't race on
-        // the same S3 key.
-        ~excludeFiles=["config.json"],
+        // The explicit BucketObjects below write the production config.json
+        // (resolved API endpoints + Cognito IDs) and, when configured, a
+        // ui-hints.json. The host-shell bundle's public/config.json and
+        // public/ui-hints.json are dev-mode fallbacks — exclude them from the
+        // bundle upload so the explicit BucketObjects don't race the bundle on
+        // the same S3 keys.
+        ~excludeFiles=["config.json", "ui-hints.json"],
         ~customDomain?,
+        // Served buckets front the host-shell distribution with `{prefix}/*`
+        // read paths (private, OAC-read) — same origin as the SPA, so served
+        // objects are addressable by same-origin relative URL with no config.json
+        // change. Unset ⇒ [] ⇒ distribution byte-identical to today.
+        ~servedBuckets=cfg.servedBuckets->Option.getOr([]),
       )
 
       let regionStr =
@@ -1494,6 +1524,27 @@ module MakeWithConfig = (
       | None => Pulumi.Output.make(None)
       }
 
+      // Optional public geocoder Function URL. Provisioned only when a place
+      // index is configured; its resolved URL becomes config.json's
+      // `geocoderEndpoint`. Unset ⇒ Output<None> ⇒ field omitted below.
+      let geocoderEndpointOutput: Pulumi.Output.t<option<string>> = switch cfg.geocoderPlaceIndex {
+      | Some(placeIndexName) =>
+        Geocoder_AwsLocation.make(~placeIndexName).url->Pulumi.Output.apply(u => Some(u))
+      | None => Pulumi.Output.make(None)
+      }
+
+      // Optional public upload presign Function URL. Needs both the opt-in flag
+      // and a target bucket; its resolved URL becomes config.json's
+      // `uploadEndpoint`. Otherwise Output<None> ⇒ field omitted below.
+      let uploadEndpointOutput: Pulumi.Output.t<option<string>> = switch (
+        cfg.enableUploads,
+        cfg.uploadBucketName,
+      ) {
+      | (Some(true), Some(bucketName)) =>
+        Upload_Presign_S3.make(~bucketName).url->Pulumi.Output.apply(u => Some(u))
+      | _ => Pulumi.Output.make(None)
+      }
+
       let configJsonContent =
         (
           (
@@ -1503,9 +1554,16 @@ module MakeWithConfig = (
             cognitoPool.clientId,
           )->Pulumi.Output.all4,
           domainEventsEndpointOutput,
+          geocoderEndpointOutput,
+          uploadEndpointOutput,
         )
-        ->Pulumi.Output.all2
-        ->Pulumi.Output.apply((((domainEp, platformEp, poolId, clientId), eventsEpOpt)) => {
+        ->Pulumi.Output.all4
+        ->Pulumi.Output.apply(((
+          (domainEp, platformEp, poolId, clientId),
+          eventsEpOpt,
+          geocoderEpOpt,
+          uploadEpOpt,
+        )) => {
           let fields = [
             ("apiEndpoint", JSON.Encode.string(domainEp)),
             ("platformApiEndpoint", JSON.Encode.string(platformEp)),
@@ -1526,7 +1584,15 @@ module MakeWithConfig = (
             )
           | None => fields
           }
-          withEvents->Dict.fromArray->JSON.Encode.object->JSON.stringify
+          let withGeocoder = switch geocoderEpOpt {
+          | Some(ep) => Array.concat(withEvents, [("geocoderEndpoint", JSON.Encode.string(ep))])
+          | None => withEvents
+          }
+          let withUpload = switch uploadEpOpt {
+          | Some(ep) => Array.concat(withGeocoder, [("uploadEndpoint", JSON.Encode.string(ep))])
+          | None => withGeocoder
+          }
+          withUpload->Dict.fromArray->JSON.Encode.object->JSON.stringify
         })
 
       let _ = PulumiAws.S3.BucketObject.make(
@@ -1539,6 +1605,29 @@ module MakeWithConfig = (
         },
       )
 
+      // Optional static AutoUI hints. Read + JSON-validated at deploy time
+      // (a malformed file fails the deploy rather than shipping a file the
+      // shell warn-and-ignores), then written verbatim beside config.json.
+      // Unset ⇒ nothing written ⇒ GET /ui-hints.json 404 ⇒ shell boots
+      // unchanged, byte-identical to a hints-less deploy.
+      switch cfg.uiHintsFile {
+      | None => ()
+      | Some(hintsPath) =>
+        let hintsContent = Util_StaticBundle.readJsonFileVerbatim(
+          ~path=hintsPath,
+          ~label="host-ui ui-hints",
+        )
+        let _ = PulumiAws.S3.BucketObject.make(
+          ~name="host-ui-ui-hints-json",
+          ~args={
+            bucket: bucketName->Pulumi.Output.asInput,
+            key: Pulumi.Input.make("ui-hints.json"),
+            content: Pulumi.Input.make(hintsContent),
+            contentType: Pulumi.Input.make("application/json"),
+          },
+        )
+      }
+
       Pulumi.Pulumi.export("hostShellUrl", distributionUrl)
     }
 

package/src/Platform.res.mjs

@@ -40,7 +40,9 @@ import * as AppSync_EventsApi$ReventlessAws from "./adapter/Api/AppSync_EventsAp
 import * as AppSync_MergedApi$ReventlessAws from "./components/Api/AppSync_MergedApi.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as NoEventMappings$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/NoEventMappings.res.mjs";
+import * as Upload_Presign_S3$ReventlessAws from "./adapter/Upload/Upload_Presign_S3.res.mjs";
 import * as Util_HostUiDomain$ReventlessAws from "./util/Util_HostUiDomain.res.mjs";
+import * as Util_StaticBundle$ReventlessAws from "./util/Util_StaticBundle.res.mjs";
 import * as DcbEventLogStorage$ReventlessAws from "./adapter/DcbEventLog/DcbEventLogStorage.res.mjs";
 import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
 import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_AdminApi.res.mjs";
@@ -50,6 +52,7 @@ import * as AppSync_SdlDecorate$ReventlessAws from "./components/Api/AppSync_Sdl
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 import * as Util_ResourceNaming$ReventlessAws from "./util/Util_ResourceNaming.res.mjs";
 import * as ClonerRunner_Fargate$ReventlessAws from "./plugin/cloner/ClonerRunner_Fargate.res.mjs";
+import * as Geocoder_AwsLocation$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation.res.mjs";
 import * as QueryEngine_DynamoDb$ReventlessAws from "./adapter/QueryEngine/QueryEngine_DynamoDb.res.mjs";
 import * as PluginRuntime_Builder$ReventlessAws from "./plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -880,10 +883,19 @@ function MakeWithConfig(Config) {
       } else {
         customDomain = undefined;
       }
-      let match$3 = Plugin_Stack$ReventlessAws.makeUiBundleDistribution("host-ui", hostUiBundle.bundleVersion, hostUiBundle.assetsDir, true, undefined, true, ["config.json"], customDomain);
+      let match$3 = Plugin_Stack$ReventlessAws.makeUiBundleDistribution("host-ui", hostUiBundle.bundleVersion, hostUiBundle.assetsDir, true, undefined, true, [
+        "config.json",
+        "ui-hints.json"
+      ], customDomain, Stdlib_Option.getOr(hostUiBundle.servedBuckets, []));
+      let bucketName = match$3.bucketName;
       let regionStr = Stdlib_Option.getOr(new Pulumi.Config("aws").get("region"), "unknown");
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
+      let placeIndexName = hostUiBundle.geocoderPlaceIndex;
+      let geocoderEndpointOutput = placeIndexName !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(placeIndexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
+      let match$4 = hostUiBundle.enableUploads;
+      let match$5 = hostUiBundle.uploadBucketName;
+      let uploadEndpointOutput = match$4 !== undefined && match$4 && match$5 !== undefined ? Upload_Presign_S3$ReventlessAws.make(match$5, undefined, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
       let configJsonContent = Pulumi.all([
         Pulumi.all([
           resolvedDomainApiEndpoint,
@@ -891,8 +903,12 @@ function MakeWithConfig(Config) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput
+        domainEventsEndpointOutput,
+        geocoderEndpointOutput,
+        uploadEndpointOutput
       ]).apply(param => {
+        let uploadEpOpt = param[3];
+        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let fields = [
@@ -935,14 +951,32 @@ function MakeWithConfig(Config) {
               eventsEpOpt
             ]
           ]) : fields;
-        return JSON.stringify(Object.fromEntries(withEvents));
+        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
+              "geocoderEndpoint",
+              geocoderEpOpt
+            ]]) : withEvents;
+        let withUpload = uploadEpOpt !== undefined ? withGeocoder.concat([[
+              "uploadEndpoint",
+              uploadEpOpt
+            ]]) : withGeocoder;
+        return JSON.stringify(Object.fromEntries(withUpload));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
-        bucket: match$3.bucketName,
+        bucket: bucketName,
         key: "config.json",
         content: configJsonContent,
         contentType: "application/json"
       });
+      let hintsPath = hostUiBundle.uiHintsFile;
+      if (hintsPath !== undefined) {
+        let hintsContent = Util_StaticBundle$ReventlessAws.readJsonFileVerbatim(hintsPath, "host-ui ui-hints");
+        new (Aws.s3.BucketObject)("host-ui-ui-hints-json", {
+          bucket: bucketName,
+          key: "ui-hints.json",
+          content: hintsContent,
+          contentType: "application/json"
+        });
+      }
       Pulumi$Pulumi.$$export("hostShellUrl", match$3.distributionUrl);
     }
     return Pulumi$Pulumi.getOutputs();
@@ -1832,10 +1866,19 @@ function Make($star) {
       } else {
         customDomain = undefined;
       }
-      let match$3 = Plugin_Stack$ReventlessAws.makeUiBundleDistribution("host-ui", hostUiBundle.bundleVersion, hostUiBundle.assetsDir, true, undefined, true, ["config.json"], customDomain);
+      let match$3 = Plugin_Stack$ReventlessAws.makeUiBundleDistribution("host-ui", hostUiBundle.bundleVersion, hostUiBundle.assetsDir, true, undefined, true, [
+        "config.json",
+        "ui-hints.json"
+      ], customDomain, Stdlib_Option.getOr(hostUiBundle.servedBuckets, []));
+      let bucketName = match$3.bucketName;
       let regionStr = Stdlib_Option.getOr(new Pulumi.Config("aws").get("region"), "unknown");
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
+      let placeIndexName = hostUiBundle.geocoderPlaceIndex;
+      let geocoderEndpointOutput = placeIndexName !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(placeIndexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
+      let match$4 = hostUiBundle.enableUploads;
+      let match$5 = hostUiBundle.uploadBucketName;
+      let uploadEndpointOutput = match$4 !== undefined && match$4 && match$5 !== undefined ? Upload_Presign_S3$ReventlessAws.make(match$5, undefined, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
       let configJsonContent = Pulumi.all([
         Pulumi.all([
           resolvedDomainApiEndpoint,
@@ -1843,8 +1886,12 @@ function Make($star) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput
+        domainEventsEndpointOutput,
+        geocoderEndpointOutput,
+        uploadEndpointOutput
       ]).apply(param => {
+        let uploadEpOpt = param[3];
+        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let fields = [
@@ -1887,14 +1934,32 @@ function Make($star) {
               eventsEpOpt
             ]
           ]) : fields;
-        return JSON.stringify(Object.fromEntries(withEvents));
+        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
+              "geocoderEndpoint",
+              geocoderEpOpt
+            ]]) : withEvents;
+        let withUpload = uploadEpOpt !== undefined ? withGeocoder.concat([[
+              "uploadEndpoint",
+              uploadEpOpt
+            ]]) : withGeocoder;
+        return JSON.stringify(Object.fromEntries(withUpload));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
-        bucket: match$3.bucketName,
+        bucket: bucketName,
         key: "config.json",
         content: configJsonContent,
         contentType: "application/json"
       });
+      let hintsPath = hostUiBundle.uiHintsFile;
+      if (hintsPath !== undefined) {
+        let hintsContent = Util_StaticBundle$ReventlessAws.readJsonFileVerbatim(hintsPath, "host-ui ui-hints");
+        new (Aws.s3.BucketObject)("host-ui-ui-hints-json", {
+          bucket: bucketName,
+          key: "ui-hints.json",
+          content: hintsContent,
+          contentType: "application/json"
+        });
+      }
       Pulumi$Pulumi.$$export("hostShellUrl", match$3.distributionUrl);
     }
     return Pulumi$Pulumi.getOutputs();

package/src/adapter/Geocoder/Geocoder_AwsLocation.res

@@ -0,0 +1,233 @@
+// AWS Location Service geocoder behind a public Lambda Function URL.
+//
+// Deploy-time: `make` provisions a CallbackFunction (its handler closure is
+// serialized by Pulumi), an IAM execution role scoped to
+// `geo:SearchPlaceIndexForText` on the target place index, and a Function URL
+// (no auth) so a browser can geocode directly.
+//
+// Runtime: `handleGeocode` reads a `q` query-string param from the Function URL
+// event, calls SearchPlaceIndexForText against the place index named in
+// `PLACE_INDEX_NAME`, and returns `[{label, lat, lng}]` as JSON. Any failure
+// degrades to an empty array so the caller never sees a hard error.
+
+open PulumiAws
+
+// ── AWS Location SDK bindings (AWS SDK v3, client.send(new Command(...))) ────
+
+type locationClient
+
+type searchPlaceIndexForTextInput = {
+  @as("IndexName") indexName: string,
+  @as("Text") text: string,
+  @as("MaxResults") maxResults?: int,
+}
+// GeoJSON order: [lng, lat].
+type point = array<float>
+type geometry = {@as("Point") point?: point}
+type place = {@as("Label") label?: string, @as("Geometry") geometry?: geometry}
+type searchResult = {@as("Place") place?: place}
+type searchResponse = {@as("Results") results?: array<searchResult>}
+type searchCommand
+
+@module("@aws-sdk/client-location") @new
+external makeLocationClient: unit => locationClient = "LocationClient"
+
+@module("@aws-sdk/client-location") @new
+external makeSearchPlaceIndexForTextCommand: searchPlaceIndexForTextInput => searchCommand =
+  "SearchPlaceIndexForTextCommand"
+
+@send external send: (locationClient, searchCommand) => promise<searchResponse> = "send"
+
+@val external decodeURIComponent: string => string = "decodeURIComponent"
+
+// ── Function URL event / response shapes (payload format 2.0) ────────────────
+
+type functionUrlEvent = {
+  rawQueryString?: string,
+  queryStringParameters?: dict<string>,
+}
+
+type response = {
+  statusCode: int,
+  headers?: dict<string>,
+  body: string,
+}
+
+// Read an env var at runtime, mapping "" / unset to None.
+let getEnv: string => option<string> = %raw(`
+  function(k) { var v = process.env[k]; return (v === undefined || v === null || v === "") ? undefined : v; }
+`)
+
+// Permissive CORS so the browser demo can call the endpoint from any origin.
+let corsHeaders = () =>
+  Dict.fromArray([
+    ("content-type", "application/json"),
+    ("access-control-allow-origin", "*"),
+    ("access-control-allow-methods", "GET,OPTIONS"),
+    ("access-control-allow-headers", "*"),
+  ])
+
+// Pull `q` from the parsed query-string params, falling back to the raw string.
+let readQueryParam = (event: functionUrlEvent): option<string> =>
+  switch event.queryStringParameters->Option.flatMap(p => p->Dict.get("q")) {
+  | Some(q) => Some(q)
+  | None =>
+    event.rawQueryString->Option.flatMap(raw =>
+      raw
+      ->String.split("&")
+      ->Array.findMap(pair =>
+        switch pair->String.split("=") {
+        | [k, v] if k == "q" => Some(v->decodeURIComponent)
+        | _ => None
+        }
+      )
+    )
+  }
+
+// ── Runtime handler ─────────────────────────────────────────────────────────
+
+let handleGeocode = async (event: functionUrlEvent, _context: Lambda.context): response => {
+  try {
+    let indexName = getEnv("PLACE_INDEX_NAME")->Option.getOr("")
+    let q = readQueryParam(event)->Option.getOr("")
+    if indexName == "" || q == "" {
+      {statusCode: 200, headers: corsHeaders(), body: "[]"}
+    } else {
+      let client = makeLocationClient()
+      let resp = await client->send(
+        makeSearchPlaceIndexForTextCommand({indexName, text: q, maxResults: 5}),
+      )
+      let results =
+        resp.results
+        ->Option.getOr([])
+        ->Array.filterMap(r =>
+          switch r.place {
+          | Some(place) =>
+            let label = place.label->Option.getOr("")
+            switch place.geometry->Option.flatMap(g => g.point) {
+            | Some(pt) if pt->Array.length >= 2 =>
+              let lng = pt->Array.getUnsafe(0)
+              let lat = pt->Array.getUnsafe(1)
+              Some(
+                Dict.fromArray([
+                  ("label", JSON.Encode.string(label)),
+                  ("lat", JSON.Encode.float(lat)),
+                  ("lng", JSON.Encode.float(lng)),
+                ])->JSON.Encode.object,
+              )
+            | _ => None
+            }
+          | None => None
+          }
+        )
+      {
+        statusCode: 200,
+        headers: corsHeaders(),
+        body: results->JSON.Encode.array->JSON.stringify,
+      }
+    }
+  } catch {
+  | _ => {statusCode: 200, headers: corsHeaders(), body: "[]"}
+  }
+}
+
+// ── Deploy-time factory ─────────────────────────────────────────────────────
+
+type serviceOutputs = {
+  url: Pulumi.Output.t<string>,
+  resources: array<Pulumi.Output.t<string>>,
+}
+
+let make = (
+  ~placeIndexName: Pulumi.Input.t<string>,
+  ~corsOrigins: array<string>=["*"],
+  ~opts=?,
+): serviceOutputs => {
+  let serviceName = "GeocoderService"
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+
+  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
+    ~name=serviceName,
+    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
+    ~tags=AWS.Tags.make(
+      ~name=serviceName,
+      ~kind=ReventlessCore.ComponentType.Platform,
+      ~role=Identity,
+      ~scope=Platform,
+    ),
+    ~opts?,
+  )
+
+  // Least-privilege: SearchPlaceIndexForText on the one place index.
+  let _policy =
+    placeIndexName
+    ->Pulumi.Output.fromInput
+    ->Pulumi.Output.apply(idx => {
+      let arn = `arn:aws:geo:*:*:place-index/${idx}`
+      let _ = IAM.RolePolicy.make(
+        ~name=`${serviceName}Policy`,
+        ~args={
+          policy: PolicyDocument.make(
+            ~id=`${serviceName}Policy`,
+            ~statements=[
+              {
+                sid: "AllowGeocode",
+                effect: Allow,
+                actions: Action("geo:SearchPlaceIndexForText"),
+                resources: Resource(arn),
+              },
+            ],
+          )
+          ->PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+        ~opts?,
+      )
+    })
+
+  let environment: Lambda.CallbackFunction.Args.functionEnvironment = {
+    // CallbackFunction under-types env values as `dict<string>`; Pulumi resolves
+    // Output-valued variables at deploy time, so bridge the Input here.
+    variables: Dict.fromArray([("PLACE_INDEX_NAME", placeIndexName)])->Obj.magic,
+  }
+
+  let lambda = Lambda.CallbackFunction.make(
+    ~name=serviceName,
+    ~args=Lambda.CallbackFunction.Args.make(
+      ~callback=handleGeocode,
+      ~role=lambdaRole,
+      ~environment,
+      ~timeout=30->Pulumi.Input.make,
+      ~tags=AWS.Tags.make(
+        ~name=serviceName,
+        ~kind=ReventlessCore.ComponentType.Platform,
+        ~role=Runtime,
+        ~scope=Platform,
+      ),
+    ),
+    ~opts?,
+  )
+
+  let functionUrl = FunctionUrl.make(
+    ~name=`${serviceName}Url`,
+    ~args={
+      authorizationType: FunctionUrl.None,
+      functionName: lambda.name->Pulumi.Output.asInput,
+      cors: (
+        {
+          allowMethods: ["GET"]->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
+          allowOrigins: corsOrigins->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
+          allowHeaders: ["*"]->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
+        }: FunctionUrl.cors
+      )->Pulumi.Input.make,
+    },
+    ~opts?,
+  )
+
+  {
+    url: functionUrl.functionUrl,
+    resources: [lambda.arn, functionUrl.functionArn],
+  }
+}