@reventlessdev/reventless-local 3.0.0-alpha.167 → 3.0.0-alpha.169

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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.169 (2026-07-26)
+
+### Bug Fixes
+
+* **api:** preserve nullability for optional enum fields in generated GraphQL ([3110a4a](https://github.com/ReventlessDev/reventless-core/commit/3110a4af032440ba2639519f61f221960ac78fba))
+
+
+# 3.0.0-alpha.168 (2026-07-26)
+
+### Bug Fixes
+
+* **core:** decode the event envelope in OutboundTranslationSlice ([66008a4](https://github.com/ReventlessDev/reventless-core/commit/66008a4dff411c85470f60aac5424e7b3eda6f01))
+* **graphql:** give InboundTranslationSlice mutations a resolvable result type ([381b545](https://github.com/ReventlessDev/reventless-core/commit/381b5458c16797404cb8ed95fa853fb1e1ca4199))
+### Features
+
+* **auto-ui:** declare field semantics + dashboard metrics ([@semantic](https://github.com/semantic), [@metric](https://github.com/metric)) ([d74ff77](https://github.com/ReventlessDev/reventless-core/commit/d74ff7721e18e8638a82931a370a549b304dac94)), closes [#4](https://github.com/ReventlessDev/reventless-core/issues/4)
+* **aws:** geocoder + upload presign Lambda Function URL services ([be43179](https://github.com/ReventlessDev/reventless-core/commit/be4317972e781dbe3c378f21a28975d1ac8b9add))
+* **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.167 (2026-07-24)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.167",
+  "version": "3.0.0-alpha.169",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -31,22 +31,22 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.25",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.24",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.180",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.27",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.127",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.44",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.80"
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.182",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.129",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.29",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.81",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.46"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.54"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.56"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Platform.res

@@ -1909,10 +1909,20 @@ module MakeWithConfig = (
   }
 
   // In-memory ignores `~hostUiBundle` — the host shell is served by `vite dev`
-  // against the running in-process GraphQL server, not from a CDN.
+  // against the running in-process GraphQL server, not from a CDN — including
+  // `uiHintsFile` (the AWS deploy writes it as a BucketObject; local dev serves
+  // `public/ui-hints.json` directly).
   type hostUiBundleConfig = {
     assetsDir: string,
     bundleVersion: string,
+    uiHintsFile?: string,
+    // AWS host-ui deploy knobs — carried to satisfy the shared Platform.T
+    // signature; the in-memory platform provisions no infrastructure and
+    // ignores them.
+    geocoderPlaceIndex?: Pulumi.Input.t<string>,
+    enableUploads?: bool,
+    uploadBucketName?: Pulumi.Input.t<string>,
+    servedBuckets?: array<ReventlessInfra.Platform.servedBucket>,
   }
   let deployPlatform = (~version, ~hostUiBundle as _: option<hostUiBundleConfig>=?) => {
     log.info(~comp="Platform", `deployPlatform v${version}`)

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res

@@ -10,11 +10,13 @@ open ReventlessCore
 // Pre-populated synchronously in Phase 1 via a queuing forwarder so callers
 // (e.g. PlatformInspector's onPlatformDeployedHook) can invoke receive before
 // Phase 2 bindReceive runs. Calls park in a Promise queue and drain once bound.
-let receiveRegistry: dict<JSON.t => promise<result<array<string>, string>>> = Dict.make()
+let receiveRegistry: dict<
+  JSON.t => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
+> = Dict.make()
 
 type pendingCall = {
   inputJson: JSON.t,
-  resolve: result<array<string>, string> => unit,
+  resolve: ReventlessInfra.InboundTranslationSlice.receiveResult => unit,
 }
 
 // Per-field pending-call queues — drained when bindReceive fires.
@@ -24,6 +26,12 @@ let pendingQueueRegistry: dict<ref<array<pendingCall>>> = Dict.make()
 // Also pre-registers a queuing forwarder in receiveRegistry so callers can
 // invoke receive immediately; calls are parked until bindReceive drains them.
 let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t) => {
+  // The mutation field returns CommandResult, so its union members must exist in
+  // this scope's document. Registered here rather than relying on a plugin's
+  // command handlers having registered them first — a plugin whose only mutation
+  // is an inbound translation must not depend on registration order.
+  CommandGeneratorResolvers_GraphQL.ensureCommandResultTypes(server)
+
   let sdlFields = switch GraphQL_FragmentGenerator.deriveMutationFieldFromObject(
     ~fieldName,
     ~collectedTypes=[],
@@ -31,7 +39,7 @@ let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server:
     externalInputSchema,
   ) {
   | Some(field) => [field]
-  | None => [`  ${fieldName}: String!`]
+  | None => [`  ${fieldName}: CommandResult!`]
   }
 
   // Queue of pending calls when receive is not yet bound.
@@ -49,10 +57,7 @@ let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server:
     let inputJson: JSON.t = args->Obj.magic
     let receive = receiveRegistry->Dict.getUnsafe(fieldName)
     let result = await receive(inputJson)
-    switch result {
-    | Ok(targetIds) => targetIds->Array.map(JSON.Encode.string)->JSON.Encode.array
-    | Error(msg) => msg->JSON.Encode.string
-    }
+    result->InboundTranslationSlice.receiveResultToOutcome->CommandTopic.commandOutcomeToJson
   }
 
   let resolvers = Dict.make()
@@ -62,7 +67,10 @@ let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server:
 
 // Phase 2: Bind the real receive function once Output.apply resolves.
 // Replaces the queuing forwarder in receiveRegistry and drains pending calls.
-let bindReceive = (~fieldName: string, ~receive: JSON.t => promise<result<array<string>, string>>) => {
+let bindReceive = (
+  ~fieldName: string,
+  ~receive: JSON.t => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
+) => {
   receiveRegistry->Dict.set(fieldName, receive)
   switch pendingQueueRegistry->Dict.get(fieldName) {
   | Some(pendingQueue) =>

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res.mjs

@@ -1,14 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as InboundTranslationSlice$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import * as CommandGeneratorResolvers_GraphQL$ReventlessLocal from "./CommandGeneratorResolvers_GraphQL.res.mjs";
 
 let receiveRegistry = {};
 
 let pendingQueueRegistry = {};
 
 function register(fieldName, externalInputSchema, server) {
+  CommandGeneratorResolvers_GraphQL$ReventlessLocal.ensureCommandResultTypes(server);
   let field = GraphQL_FragmentGenerator$ReventlessCore.deriveMutationFieldFromObject(fieldName, [], new Set(), externalInputSchema);
-  let sdlFields = field !== undefined ? [field] : [`  ` + fieldName + `: String!`];
+  let sdlFields = field !== undefined ? [field] : [`  ` + fieldName + `: CommandResult!`];
   let pendingQueue = {
     contents: []
   };
@@ -23,11 +27,7 @@ function register(fieldName, externalInputSchema, server) {
   let resolver = async (_root, args, _ctx) => {
     let receive = receiveRegistry[fieldName];
     let result = await receive(args);
-    if (result.TAG === "Ok") {
-      return result._0.map(prim => prim);
-    } else {
-      return result._0;
-    }
+    return CommandTopic$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice$ReventlessCore.receiveResultToOutcome(result));
   };
   let resolvers = {};
   resolvers[fieldName] = resolver;
@@ -54,4 +54,4 @@ export {
   register,
   bindReceive,
 }
-/* GraphQL_FragmentGenerator-ReventlessCore Not a pure module */
+/* CommandTopic-ReventlessCore Not a pure module */

package/src/adapter/DomainGraphQL_Server.res

@@ -26,11 +26,18 @@ type nodeResponse
 @send external writeHead: (nodeResponse, int, {..}) => unit = "writeHead"
 @send external end_: (nodeResponse, string) => unit = "end"
 @send external endEmpty: (nodeResponse, @as(json`null`) _) => unit = "end"
+// Binary response body — the served-object GET streams stored bytes verbatim.
+@send external endBuf: (nodeResponse, LocalObjectStore.buffer) => unit = "end"
 
 // Streaming body collector — request data fires once per chunk, end once at EOF.
 @send external _onData: (nodeRequest, @as("data") _, string => unit) => unit = "on"
 @send external _onEnd: (nodeRequest, @as("end") _, unit => unit) => unit = "on"
 @send external _setEncoding: (nodeRequest, string) => unit = "setEncoding"
+// Binary chunk stream — used by the served-object PUT so raw bytes aren't
+// mangled by utf8 decoding (setEncoding is deliberately NOT called).
+@send external _onDataBuf: (nodeRequest, @as("data") _, LocalObjectStore.buffer => unit) => unit = "on"
+
+@module("crypto") external randomUUID: unit => string = "randomUUID"
 
 let readBody = (req: nodeRequest, onBody: string => unit): unit => {
   let buf = ref("")
@@ -39,6 +46,14 @@ let readBody = (req: nodeRequest, onBody: string => unit): unit => {
   req->_onEnd(() => onBody(buf.contents))
 }
 
+// Binary body collector — accumulates raw Buffer chunks and concatenates once
+// at EOF. Kept separate from `readBody` (utf8) so file uploads stay byte-exact.
+let readBodyBuf = (req: nodeRequest, onBody: LocalObjectStore.buffer => unit): unit => {
+  let chunks: array<LocalObjectStore.buffer> = []
+  req->_onDataBuf(chunk => chunks->Array.push(chunk))
+  req->_onEnd(() => onBody(LocalObjectStore.concatBuffers(chunks)))
+}
+
 type requestHandler = (nodeRequest, nodeResponse) => unit
 @module("http") external createServerWithHandler: requestHandler => YG.httpServer = "createServer"
 
@@ -110,6 +125,76 @@ let handleLogout = (_req: nodeRequest, res: nodeResponse): unit => {
   res->endEmpty
 }
 
+// -- Served-bucket routes (local analogue of the AWS CloudFront read path) ----
+//
+// The dev platform has no object bucket, so these three routes back the same
+// UI contract locally against `LocalObjectStore`:
+//   POST /__inmemory/upload  {fileName,contentType} → {uploadUrl, storageRef}
+//   PUT  /{prefix}/{key}     raw bytes              → 200 (store)
+//   GET  /{prefix}/{key}                            → the stored bytes
+// `uploadUrl == storageRef == /{prefix}/{key}`, so the existing FileDropzone S3
+// adapter (POST-presign → PUT-bytes) works unchanged — no presigning needed.
+
+let uploadPresignPath = "/__inmemory/upload"
+
+// CORS for the browser PUT (a cross-origin preflight when the dev origin isn't
+// same-origin with the API); the seed uploads from Node and needs none.
+let _corsWriteHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "PUT,GET,OPTIONS",
+  "Access-Control-Allow-Headers": "*",
+}
+
+// Presign-shaped: mint a fresh uuid key under the served prefix and hand back a
+// same-origin `/{prefix}/{key}` for both the PUT target and the stored ref.
+let handleUploadPresign = (req: nodeRequest, res: nodeResponse): unit =>
+  readBody(req, body => {
+    let parsed =
+      try body->JSON.parseOrThrow->JSON.Decode.object->Option.getOr(Dict.make()) catch {
+      | _ => Dict.make()
+      }
+    let fileName =
+      parsed->Dict.get("fileName")->Option.flatMap(JSON.Decode.string)->Option.getOr("upload")
+    let ref = `/${LocalObjectStore.defaultUploadPrefix}/${randomUUID()}/${fileName}`
+    _writeJson(
+      res,
+      ~status=200,
+      JSON.Encode.object(
+        Dict.fromArray([
+          ("uploadUrl", JSON.Encode.string(ref)),
+          ("storageRef", JSON.Encode.string(ref)),
+        ]),
+      ),
+    )
+  })
+
+let handleObjectPut = (req: nodeRequest, res: nodeResponse, ~key: string): unit => {
+  let contentType =
+    req.headers->Dict.get("content-type")->Option.getOr("application/octet-stream")
+  readBodyBuf(req, bytes => {
+    LocalObjectStore.put(~key, ~bytes, ~contentType)
+    res->writeHead(200, _corsWriteHeaders)
+    res->end_("")
+  })
+}
+
+let handleObjectGet = (res: nodeResponse, ~key: string): unit =>
+  switch LocalObjectStore.get(~key) {
+  | Some({bytes, contentType}) =>
+    res->writeHead(
+      200,
+      {
+        "Content-Type": contentType,
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "public, max-age=31536000, immutable",
+      },
+    )
+    res->endBuf(bytes)
+  | None =>
+    res->writeHead(404, {"Access-Control-Allow-Origin": "*"})
+    res->endEmpty
+  }
+
 // Returns true when the request carries an `Authorization: Bearer <token>`
 // header whose token fails HMAC verification. No header (anonymous), or a
 // non-Bearer scheme (e.g. X-User flows), returns false — only an *invalid*
@@ -147,6 +232,16 @@ let _dispatch = (req: nodeRequest, res: nodeResponse, yoga: YG.yoga, getSdl: uni
     handleLogin(req, res)
   } else if path == "/__inmemory/logout" && req.method == "POST" {
     handleLogout(req, res)
+  } else if path == uploadPresignPath && req.method == "POST" {
+    handleUploadPresign(req, res)
+  } else if req.method == "OPTIONS" && LocalObjectStore.servedKey(path)->Option.isSome {
+    // Preflight for the cross-origin browser PUT to a served-object path.
+    res->writeHead(204, _corsWriteHeaders)
+    res->endEmpty
+  } else if req.method == "PUT" && LocalObjectStore.servedKey(path)->Option.isSome {
+    handleObjectPut(req, res, ~key=LocalObjectStore.servedKey(path)->Option.getOr(""))
+  } else if req.method == "GET" && LocalObjectStore.servedKey(path)->Option.isSome {
+    handleObjectGet(res, ~key=LocalObjectStore.servedKey(path)->Option.getOr(""))
   } else {
     (yoga->Obj.magic)(req, res)
   }
@@ -618,6 +713,7 @@ let reset = () => {
   nodeResolverCallback.contents = None
   activeSchema.contents = None
   lastFullSdl.contents = None
+  LocalObjectStore.reset()
 }
 
 // -- Inspection & diagnostics ---------------------------------------------

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -2,6 +2,7 @@
 
 import * as S from "sury/src/S.res.mjs";
 import * as Http from "http";
+import * as Crypto from "crypto";
 import * as Graphql from "graphql";
 import * as GraphqlYoga from "@reventlessdev/rescript-graphql-yoga/src/GraphqlYoga.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -17,6 +18,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as LocalAuth$ReventlessLocal from "./Auth/LocalAuth.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "./LocalObjectStore.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -32,6 +34,14 @@ function readBody(req, onBody) {
   req.on("end", () => onBody(buf.contents));
 }
 
+function readBodyBuf(req, onBody) {
+  let chunks = [];
+  req.on("data", chunk => {
+    chunks.push(chunk);
+  });
+  req.on("end", () => onBody(Buffer.concat(chunks)));
+}
+
 function _writeJson(res, status, body) {
   res.writeHead(status, {
     "Content-Type": "application/json",
@@ -89,6 +99,63 @@ function handleLogout(_req, res) {
   res.end(null);
 }
 
+let uploadPresignPath = "/__inmemory/upload";
+
+let _corsWriteHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "PUT,GET,OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+
+function handleUploadPresign(req, res) {
+  readBody(req, body => {
+    let parsed;
+    try {
+      parsed = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(body)), {});
+    } catch (exn) {
+      parsed = {};
+    }
+    let fileName = Stdlib_Option.getOr(Stdlib_Option.flatMap(parsed["fileName"], Stdlib_JSON.Decode.string), "upload");
+    let ref = `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Crypto.randomUUID() + `/` + fileName;
+    _writeJson(res, 200, Object.fromEntries([
+      [
+        "uploadUrl",
+        ref
+      ],
+      [
+        "storageRef",
+        ref
+      ]
+    ]));
+  });
+}
+
+function handleObjectPut(req, res, key) {
+  let contentType = Stdlib_Option.getOr(req.headers["content-type"], "application/octet-stream");
+  readBodyBuf(req, bytes => {
+    LocalObjectStore$ReventlessLocal.put(key, bytes, contentType);
+    res.writeHead(200, _corsWriteHeaders);
+    res.end("");
+  });
+}
+
+function handleObjectGet(res, key) {
+  let match = LocalObjectStore$ReventlessLocal.get(key);
+  if (match !== undefined) {
+    res.writeHead(200, {
+      "Content-Type": match.contentType,
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "public, max-age=31536000, immutable"
+    });
+    res.end(match.bytes);
+  } else {
+    res.writeHead(404, {
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(null);
+  }
+}
+
 function _isInvalidBearer(req) {
   let h = req.headers["authorization"];
   if (h === undefined) {
@@ -119,6 +186,16 @@ function _dispatch(req, res, yoga, getSdl) {
     return handleLogin(req, res);
   } else if (path === "/__inmemory/logout" && req.method === "POST") {
     return handleLogout(req, res);
+  } else if (path === uploadPresignPath && req.method === "POST") {
+    return handleUploadPresign(req, res);
+  } else if (req.method === "OPTIONS" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+    res.writeHead(204, _corsWriteHeaders);
+    res.end(null);
+    return;
+  } else if (req.method === "PUT" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+    return handleObjectPut(req, res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
+  } else if (req.method === "GET" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+    return handleObjectGet(res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
   } else {
     return yoga(req, res);
   }
@@ -515,6 +592,7 @@ function reset() {
   nodeResolverCallback.contents = undefined;
   activeSchema.contents = undefined;
   lastFullSdl.contents = undefined;
+  LocalObjectStore$ReventlessLocal.reset();
 }
 
 function getRegisteredSdl() {
@@ -671,10 +749,16 @@ export {
   YG,
   log,
   readBody,
+  readBodyBuf,
   _writeJson,
   _loginRejected,
   handleLogin,
   handleLogout,
+  uploadPresignPath,
+  _corsWriteHeaders,
+  handleUploadPresign,
+  handleObjectPut,
+  handleObjectGet,
   _isInvalidBearer,
   _dispatch,
   buildAuthContext,

package/src/adapter/GraphQL_Server.res.mjs

@@ -8,6 +8,8 @@ let log = DomainGraphQL_Server$ReventlessLocal.log;
 
 let readBody = DomainGraphQL_Server$ReventlessLocal.readBody;
 
+let readBodyBuf = DomainGraphQL_Server$ReventlessLocal.readBodyBuf;
+
 let _writeJson = DomainGraphQL_Server$ReventlessLocal._writeJson;
 
 let _loginRejected = DomainGraphQL_Server$ReventlessLocal._loginRejected;
@@ -16,6 +18,16 @@ let handleLogin = DomainGraphQL_Server$ReventlessLocal.handleLogin;
 
 let handleLogout = DomainGraphQL_Server$ReventlessLocal.handleLogout;
 
+let uploadPresignPath = DomainGraphQL_Server$ReventlessLocal.uploadPresignPath;
+
+let _corsWriteHeaders = DomainGraphQL_Server$ReventlessLocal._corsWriteHeaders;
+
+let handleUploadPresign = DomainGraphQL_Server$ReventlessLocal.handleUploadPresign;
+
+let handleObjectPut = DomainGraphQL_Server$ReventlessLocal.handleObjectPut;
+
+let handleObjectGet = DomainGraphQL_Server$ReventlessLocal.handleObjectGet;
+
 let _isInvalidBearer = DomainGraphQL_Server$ReventlessLocal._isInvalidBearer;
 
 let _dispatch = DomainGraphQL_Server$ReventlessLocal._dispatch;
@@ -120,10 +132,16 @@ export {
   YG,
   log,
   readBody,
+  readBodyBuf,
   _writeJson,
   _loginRejected,
   handleLogin,
   handleLogout,
+  uploadPresignPath,
+  _corsWriteHeaders,
+  handleUploadPresign,
+  handleObjectPut,
+  handleObjectGet,
   _isInvalidBearer,
   _dispatch,
   buildAuthContext,

package/src/adapter/LocalObjectStore.res

@@ -0,0 +1,64 @@
+// Process-local object store backing the dev platform's served-bucket routes.
+//
+// The AWS path fronts a private S3 bucket through CloudFront (served-buckets
+// plan); in dev there is no bucket, so uploaded and served objects live in this
+// process-local map. Ephemeral by design — contents are lost on restart, which
+// matches the plan's dev-only, non-durable stance. Held here (not in
+// EventLog/QueryDb storage) because it is raw bytes, not event/query state, and
+// has no SQLite arm — hence the `Local` prefix and no `_InMemory` suffix.
+
+// Node Buffer, opaque here — produced by the PUT handler (concat of request
+// chunks) and handed straight back to the response by the GET handler.
+type buffer
+
+@val @scope("Buffer") external concatBuffers: array<buffer> => buffer = "concat"
+
+type entry = {
+  bytes: buffer,
+  contentType: string,
+}
+
+let objects: dict<entry> = Dict.make()
+
+// The prefix the local upload route mints keys under. Mirrors the AWS presign
+// `SERVED_PREFIX` (default "uploads"); the hybrid example uses "uploads".
+let defaultUploadPrefix = "uploads"
+
+// Prefixes the dev server serves at `/{prefix}/*` (PUT stores, GET reads).
+// Seeded with the default upload prefix; a deployment serving another prefix
+// registers it before the servers start.
+let servedPrefixes: ref<array<string>> = ref([defaultUploadPrefix])
+
+let registerServedPrefix = (prefix: string): unit =>
+  if !(servedPrefixes.contents->Array.includes(prefix)) {
+    servedPrefixes.contents = servedPrefixes.contents->Array.concat([prefix])
+  }
+
+// A request path is a served-object path when its first segment is a registered
+// served prefix and at least one key segment follows. Returns the storage key
+// (the path without its leading slash), or None for GraphQL / other paths.
+let servedKey = (path: string): option<string> => {
+  let trimmed = path->String.startsWith("/") ? path->String.slice(~start=1, ~end=path->String.length) : path
+  let prefix = trimmed->String.split("/")->Array.get(0)->Option.getOr("")
+  if (
+    prefix->String.length > 0 &&
+    servedPrefixes.contents->Array.includes(prefix) &&
+    trimmed->String.length > prefix->String.length + 1
+  ) {
+    Some(trimmed)
+  } else {
+    None
+  }
+}
+
+let put = (~key: string, ~bytes: buffer, ~contentType: string): unit =>
+  objects->Dict.set(key, {bytes, contentType})
+
+let get = (~key: string): option<entry> => objects->Dict.get(key)
+
+// Clear stored objects and restore the default served prefix — used between
+// isolated test suites (called from DomainGraphQL_Server.reset).
+let reset = (): unit => {
+  objects->Dict.keysToArray->Array.forEach(k => objects->Dict.delete(k))
+  servedPrefixes.contents = [defaultUploadPrefix]
+}

package/src/adapter/LocalObjectStore.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let objects = {};
+
+let defaultUploadPrefix = "uploads";
+
+let servedPrefixes = {
+  contents: [defaultUploadPrefix]
+};
+
+function registerServedPrefix(prefix) {
+  if (!servedPrefixes.contents.includes(prefix)) {
+    servedPrefixes.contents = servedPrefixes.contents.concat([prefix]);
+    return;
+  }
+}
+
+function servedKey(path) {
+  let trimmed = path.startsWith("/") ? path.slice(1, path.length) : path;
+  let prefix = Stdlib_Option.getOr(trimmed.split("/")[0], "");
+  if (prefix.length > 0 && servedPrefixes.contents.includes(prefix) && trimmed.length > (prefix.length + 1 | 0)) {
+    return trimmed;
+  }
+}
+
+function put(key, bytes, contentType) {
+  objects[key] = {
+    bytes: bytes,
+    contentType: contentType
+  };
+}
+
+function get(key) {
+  return objects[key];
+}
+
+function reset() {
+  Object.keys(objects).forEach(k => Stdlib_Dict.$$delete(objects, k));
+  servedPrefixes.contents = [defaultUploadPrefix];
+}
+
+export {
+  objects,
+  defaultUploadPrefix,
+  servedPrefixes,
+  registerServedPrefix,
+  servedKey,
+  put,
+  get,
+  reset,
+}
+/* No side effect */

package/src/adapter/PgProjectionCatchup.res

@@ -104,7 +104,7 @@ let runCatchup = async (
 
   // --- DCB axis: reconstruct the published envelope, position order ---
   let dcbRows = await pool->Pg.query(
-    "SELECT log_name, event_type, data, meta, tags FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC",
+    "SELECT log_name, event_type, data, meta, tags, recorded_at FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC",
     [JSON.Encode.int(bounds.dcbBound)],
   )
   for i in 0 to dcbRows->Array.length - 1 {
@@ -116,11 +116,16 @@ let runCatchup = async (
       row->Dict.get("meta"),
     ) {
     | (Some(JSON.String(logName)), Some(JSON.String(eventType)), Some(data), Some(meta)) =>
+      let recordedAt = switch row->Dict.get("recorded_at") {
+      | Some(JSON.String(v)) => v
+      | _ => ""
+      }
       switch ProjectionCheckpoint.dcbCatchupEnvelope(
         ~logName,
         ~eventType,
         ~dataText=JSON.stringify(data),
         ~metaText=JSON.stringify(meta),
+        ~recordedAt,
         ~firstTagValue=firstTagValue(row),
       ) {
       | Some(envelope) => await deliver(handlers, envelope)

package/src/adapter/PgProjectionCatchup.res.mjs

@@ -77,7 +77,7 @@ async function runCatchup(pool, bounds, handlers) {
       }
     }
   }
-  let dcbRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT log_name, event_type, data, meta, tags FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC", [bounds.dcbBound]);
+  let dcbRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT log_name, event_type, data, meta, tags, recorded_at FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC", [bounds.dcbBound]);
   for (let i$1 = 0, i_finish$1 = dcbRows.length; i$1 < i_finish$1; ++i$1) {
     let row$1 = dcbRows[i$1];
     let match = row$1["log_name"];
@@ -85,7 +85,9 @@ async function runCatchup(pool, bounds, handlers) {
     let match$2 = row$1["data"];
     let match$3 = row$1["meta"];
     if (typeof match === "string" && typeof match$1 === "string" && match$2 !== undefined && match$3 !== undefined) {
-      let envelope$1 = ProjectionCheckpoint$ReventlessLocal.dcbCatchupEnvelope(match, match$1, JSON.stringify(match$2), JSON.stringify(match$3), firstTagValue(row$1));
+      let match$4 = row$1["recorded_at"];
+      let recordedAt = typeof match$4 === "string" ? match$4 : "";
+      let envelope$1 = ProjectionCheckpoint$ReventlessLocal.dcbCatchupEnvelope(match, match$1, JSON.stringify(match$2), JSON.stringify(match$3), recordedAt, firstTagValue(row$1));
       if (envelope$1 !== undefined) {
         await deliver(handlers, envelope$1);
       }