@reventlessdev/reventless-local 3.0.0-alpha.186 → 3.0.0-alpha.188

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 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.188 (2026-08-01)
+
+* feat(aws,core,spec)!: qualify store prefixes by plugin and refuse name collisions ([da39405](https://github.com/ReventlessDev/reventless-core/commit/da394059d9f8f981bf7adc79e2c1ce2b429e0267))
+* feat(core,aws)!: name task buckets for their plugin and task ([05203cb](https://github.com/ReventlessDev/reventless-core/commit/05203cb3b0b019401a6f32cf78109f397b6799d5))
+
+### BREAKING CHANGES
+
+* objects minted under the old bare prefix are orphaned and their
+refs unresolvable. The migration is `seed:reset` for the owning plugin, then
+re-seed. Legacy-prefix grandfathering was considered and deliberately dropped —
+it would have added a permanent prefix SET across the deploy argument, both store
+configs, the presign IAM fan-out, the release scope check and the stack output,
+to spare a disposable stack one wipe.
+* a bucket name change is a replace. TaskBucket_S3 now sets
+forceDestroy on disposable stacks (Util_StoreLayout.protectionFor), so pr-*
+stacks recreate cleanly; protected stacks must have the task bucket drained by
+hand before the first deploy after this, or the replace fails BucketNotEmpty.
+
+
+
+# 3.0.0-alpha.187 (2026-08-01)
+
+### Features
+
+* **upload:** add the release half of the upload contract via the domain API ([448f887](https://github.com/ReventlessDev/reventless-core/commit/448f88714a5875be420f794a08d482fcf4ba8404))
+
+
 # 3.0.0-alpha.186 (2026-08-01)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.186",
+  "version": "3.0.0-alpha.188",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,18 +34,18 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.198",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.46",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.145",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.115",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.62",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.90"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.200",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.48",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.147",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.64",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.92",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.117"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -865,6 +865,40 @@ module MakeWithConfig = (
           }
         })
     })
+
+    // Two plugins declaring one store name is refused by the deployed platform
+    // before it provisions anything. Local provisions no stores, so nothing here
+    // breaks — but this is the only place a developer meets the rule while the
+    // fix is still free: once a store has deployed, its minted refs are in an
+    // append-only event log and renaming it strands them. Hence a warning at
+    // composition, and the authoritative refusal at deploy.
+    let declared =
+      pluginStructuresStore.contents
+      ->Dict.valuesToArray
+      ->Array.flatMap(structure =>
+        structure.requiredStores
+        ->Option.getOr([])
+        ->Array.map(qualified => {
+          ReventlessCore.StorePrefixCollision.qualified,
+          // Local provisions no stores, so it has no prefix of its own — it
+          // restates the deployed rule (`{plugin}/{store}`) so the warning it
+          // gives matches the refusal a deploy would give. Reporting a collision
+          // the deployed platform does not have would be worse than silence.
+          prefix: switch qualified->String.indexOfOpt(".") {
+          | Some(i) =>
+            qualified->String.slice(~start=0, ~end=i) ++
+            "/" ++
+            qualified->String.slice(~start=i + 1, ~end=qualified->String.length)
+          | None => qualified
+          },
+        })
+      )
+    ReventlessCore.StorePrefixCollision.collisionsFor(~stores=declared)->Array.forEach(c =>
+      log.warn(
+        ~comp="Platform:plugins",
+        ReventlessCore.StorePrefixCollision.collisionMessage(c),
+      )
+    )
   }
 
   // Bus keys for the admin Plugin aggregate (name-keyed). ComponentType.toName maps
@@ -1901,6 +1935,9 @@ module MakeWithConfig = (
       ~sdlFields=ReventlessCore.GraphQL_Stitcher.relayBaseQueries,
       ~resolvers=Dict.make(),
     )
+    // Upload service (route B) on the domain server — mirrors adding it to
+    // `domainBaseFragment` on AWS.
+    LocalUploadResolvers.register(DomainGraphQL_Server.asInterface)
     // In split mode, inject Relay base types (Node interface, PageInfo) into the platform
     // server so SDL fragments compile. The node(id) query is Domain-only — the Platform
     // API is consumed by admin tools and agents, not Relay clients.

package/src/Platform.res.mjs

@@ -55,8 +55,10 @@ import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Serve
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
 import * as PgProjectionCatchup$ReventlessLocal from "./adapter/PgProjectionCatchup.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
+import * as StorePrefixCollision$ReventlessCore from "@reventlessdev/reventless-core/src/util/StorePrefixCollision.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "./adapter/DomainGraphQL_Server.res.mjs";
 import * as EventPublish_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventLog/EventPublish_Callback.res.mjs";
+import * as LocalUploadResolvers$ReventlessLocal from "./adapter/LocalUploadResolvers.res.mjs";
 import * as ProjectionCheckpoint$ReventlessLocal from "./adapter/ProjectionCheckpoint.res.mjs";
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
 import * as UiFragments_Projection$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs";
@@ -823,6 +825,14 @@ function MakeWithConfig(Config) {
         }
       });
     });
+    let declared = Object.values(pluginStructuresStore.contents).flatMap(structure => Stdlib_Option.getOr(structure.requiredStores, []).map(qualified => {
+      let i = Stdlib_String.indexOfOpt(qualified, ".");
+      return {
+        qualified: qualified,
+        prefix: i !== undefined ? qualified.slice(0, i) + "/" + qualified.slice(i + 1 | 0, qualified.length) : qualified
+      };
+    }));
+    StorePrefixCollision$ReventlessCore.collisionsFor(declared).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
   };
   let pluginCmdTopicKey = PluginSpec$ReventlessCore.name + "AggrCmdTopic";
   let pluginEventTopicKey = PluginSpec$ReventlessCore.name + "AggrEventTopic";
@@ -1542,6 +1552,7 @@ function MakeWithConfig(Config) {
     });
     DomainGraphQL_Server$ReventlessLocal.registerTypes(GraphQL_Stitcher$ReventlessCore.relayBaseTypes);
     DomainGraphQL_Server$ReventlessLocal.registerQueries(GraphQL_Stitcher$ReventlessCore.relayBaseQueries, {});
+    LocalUploadResolvers$ReventlessLocal.register(DomainGraphQL_Server$ReventlessLocal.asInterface);
     if (Config.splitApi) {
       PlatformGraphQL_Server$ReventlessLocal.registerTypes(GraphQL_Stitcher$ReventlessCore.relayBaseTypes);
     }
@@ -2498,6 +2509,14 @@ function Make($star) {
         }
       });
     });
+    let declared = Object.values(pluginStructuresStore.contents).flatMap(structure => Stdlib_Option.getOr(structure.requiredStores, []).map(qualified => {
+      let i = Stdlib_String.indexOfOpt(qualified, ".");
+      return {
+        qualified: qualified,
+        prefix: i !== undefined ? qualified.slice(0, i) + "/" + qualified.slice(i + 1 | 0, qualified.length) : qualified
+      };
+    }));
+    StorePrefixCollision$ReventlessCore.collisionsFor(declared).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
   };
   let pluginCmdTopicKey = PluginSpec$ReventlessCore.name + "AggrCmdTopic";
   let pluginEventTopicKey = PluginSpec$ReventlessCore.name + "AggrEventTopic";
@@ -3212,6 +3231,7 @@ function Make($star) {
     });
     DomainGraphQL_Server$ReventlessLocal.registerTypes(GraphQL_Stitcher$ReventlessCore.relayBaseTypes);
     DomainGraphQL_Server$ReventlessLocal.registerQueries(GraphQL_Stitcher$ReventlessCore.relayBaseQueries, {});
+    LocalUploadResolvers$ReventlessLocal.register(DomainGraphQL_Server$ReventlessLocal.asInterface);
     PlatformGraphQL_Server$ReventlessLocal.registerTypes(GraphQL_Stitcher$ReventlessCore.relayBaseTypes);
     currentDeployTarget.contents = "Domain";
   };

package/src/adapter/DomainGraphQL_Server.res

@@ -126,15 +126,14 @@ let handleLogout = (_req: nodeRequest, res: nodeResponse): unit => {
 
 // -- 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"
+// The dev platform has no object bucket, so these routes back the same UI contract
+// locally against `LocalObjectStore`:
+//   PUT  /{prefix}/{key}     raw bytes → 200 (store)
+//   GET  /{prefix}/{key}              → the stored bytes
+// Minting (`Upload_Presign`) and release (`Upload_Release`) are platform-API
+// mutations under route B (see [docs/plans/upload-release-path.md], resolved in
+// Platform.res against this same `LocalObjectStore`); the presign returns
+// `uploadUrl == storageRef == /{prefix}/{key}`, so the byte PUT below is unchanged.
 
 // 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.
@@ -144,29 +143,6 @@ let _corsWriteHeaders = {
   "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}/${NodeCrypto.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")
@@ -231,8 +207,6 @@ 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 path == "/events" && req.method == "POST" {
     // Local AppSync Events publish endpoint (`/client/**` only). The
     // Authorization header carries the token raw (AWS Cognito-publish shape),

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -6,7 +6,6 @@ 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";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Nodecrypto from "node:crypto";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as GraphqlYoga$1 from "graphql-yoga";
@@ -100,37 +99,12 @@ 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 + `/` + Nodecrypto.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 => {
@@ -191,9 +165,6 @@ function _dispatch(req, res, yoga, getSdl) {
   if (path === "/__inmemory/logout" && req.method === "POST") {
     return handleLogout(req, res);
   }
-  if (path === uploadPresignPath && req.method === "POST") {
-    return handleUploadPresign(req, res);
-  }
   if (path !== "/events" || req.method !== "POST") {
     if (path === "/events" && req.method === "OPTIONS") {
       res.writeHead(204, {
@@ -776,9 +747,7 @@ export {
   _loginRejected,
   handleLogin,
   handleLogout,
-  uploadPresignPath,
   _corsWriteHeaders,
-  handleUploadPresign,
   handleObjectPut,
   handleObjectGet,
   _isInvalidBearer,

package/src/adapter/GraphQL_Server.res.mjs

@@ -18,12 +18,8 @@ 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;
@@ -137,9 +133,7 @@ export {
   _loginRejected,
   handleLogin,
   handleLogout,
-  uploadPresignPath,
   _corsWriteHeaders,
-  handleUploadPresign,
   handleObjectPut,
   handleObjectGet,
   _isInvalidBearer,

package/src/adapter/LocalObjectStore.res

@@ -56,6 +56,12 @@ let put = (~key: string, ~bytes: buffer, ~contentType: string): unit =>
 
 let get = (~key: string): option<entry> => objects->Dict.get(key)
 
+// Remove a stored object. Idempotent — deleting an absent key is a no-op, matching
+// the release contract (see docs/plans/upload-release-path.md, Step 3). The dev
+// store has no identities or clock, so the release resolver enforces only the
+// *shape* of the rule (key under a served prefix), not the identity/age conditions.
+let delete = (~key: string): unit => objects->Dict.delete(key)
+
 // Clear stored objects and restore the default served prefix — used between
 // isolated test suites (called from DomainGraphQL_Server.reset).
 let reset = (): unit => {

package/src/adapter/LocalObjectStore.res.mjs

@@ -37,6 +37,10 @@ function get(key) {
   return objects[key];
 }
 
+function $$delete(key) {
+  Stdlib_Dict.$$delete(objects, key);
+}
+
 function reset() {
   Object.keys(objects).forEach(k => Stdlib_Dict.$$delete(objects, k));
   servedPrefixes.contents = [defaultUploadPrefix];
@@ -50,6 +54,7 @@ export {
   servedKey,
   put,
   get,
+  $$delete,
   reset,
 }
 /* No side effect */

package/src/adapter/LocalUploadResolvers.res

@@ -0,0 +1,54 @@
+// Local upload resolver logic (route B), backed by `LocalObjectStore`. Shared by the
+// dev platform (`Platform.res` registers these on the domain server) and
+// `ServedBucketHttpTest`, so the mint/release behaviour has one definition.
+//
+// The dev store has no identities and no clock, so release enforces only the *shape*
+// of the rule (key under a served prefix), not the identity/age conditions AWS applies
+// — dev parity is about the client seeing the same contract, not reproducing AWS's
+// guarantees. See [docs/plans/upload-release-path.md] § Step 3.
+
+// Mint a same-origin `/{prefix}/{uuid}/{fileName}` ref: both the PUT target and the
+// stored value, mirroring the AWS presign ticket's shape.
+let mintRef = (~fileName: string): string =>
+  `/${LocalObjectStore.defaultUploadPrefix}/${NodeCrypto.randomUUID()}/${fileName}`
+
+// Release a ref: delete iff it sits under a served prefix; idempotent (deleting an
+// absent key still succeeds). Returns `(released, reason)`.
+let release = (~storageRef: string): (bool, option<string>) =>
+  switch LocalObjectStore.servedKey(storageRef) {
+  | Some(key) =>
+    LocalObjectStore.delete(~key)
+    (true, None)
+  | None => (false, Some("not_in_store"))
+  }
+
+// Register `Upload_Presign` / `Upload_Release` (types + mutation fields + resolvers) on
+// a GraphQL server instance — the local analogue of adding them to `domainBaseFragment`.
+let register = (server: ReventlessGraphqlServer.GraphQL_ServerInstance.t): unit => {
+  let resolvers = Dict.make()
+  resolvers->Dict.set("Upload_Presign", async (_root, args, _ctx): JSON.t => {
+    let obj = args->JSON.Decode.object->Option.getOr(Dict.make())
+    let fileName =
+      obj->Dict.get("fileName")->Option.flatMap(JSON.Decode.string)->Option.getOr("upload")
+    let ref = mintRef(~fileName)
+    Dict.fromArray([
+      ("uploadUrl", JSON.Encode.string(ref)),
+      ("storageRef", JSON.Encode.string(ref)),
+    ])->JSON.Encode.object
+  })
+  resolvers->Dict.set("Upload_Release", async (_root, args, _ctx): JSON.t => {
+    let obj = args->JSON.Decode.object->Option.getOr(Dict.make())
+    let storageRef =
+      obj->Dict.get("storageRef")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+    let (released, reason) = release(~storageRef)
+    Dict.fromArray([
+      ("released", JSON.Encode.bool(released)),
+      ("reason", reason->Option.mapOr(JSON.Null, JSON.Encode.string)),
+    ])->JSON.Encode.object
+  })
+  server.registerTypes(~sdlTypes=ReventlessCore.Platform_AdminApi.uploadTypes)
+  server.registerMutations(
+    ~sdlFields=ReventlessCore.Platform_AdminApi.uploadMutationFields,
+    ~resolvers,
+  )
+}

package/src/adapter/LocalUploadResolvers.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Nodecrypto from "node:crypto";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as LocalObjectStore$ReventlessLocal from "./LocalObjectStore.res.mjs";
+import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_AdminApi.res.mjs";
+
+function mintRef(fileName) {
+  return `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Nodecrypto.randomUUID() + `/` + fileName;
+}
+
+function release(storageRef) {
+  let key = LocalObjectStore$ReventlessLocal.servedKey(storageRef);
+  if (key !== undefined) {
+    LocalObjectStore$ReventlessLocal.$$delete(key);
+    return [
+      true,
+      undefined
+    ];
+  } else {
+    return [
+      false,
+      "not_in_store"
+    ];
+  }
+}
+
+function register(server) {
+  let resolvers = {};
+  resolvers["Upload_Presign"] = async (_root, args, _ctx) => {
+    let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(args), {});
+    let fileName = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["fileName"], Stdlib_JSON.Decode.string), "upload");
+    let ref = mintRef(fileName);
+    return Object.fromEntries([
+      [
+        "uploadUrl",
+        ref
+      ],
+      [
+        "storageRef",
+        ref
+      ]
+    ]);
+  };
+  resolvers["Upload_Release"] = async (_root, args, _ctx) => {
+    let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(args), {});
+    let storageRef = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["storageRef"], Stdlib_JSON.Decode.string), "");
+    let match = release(storageRef);
+    return Object.fromEntries([
+      [
+        "released",
+        match[0]
+      ],
+      [
+        "reason",
+        Stdlib_Option.mapOr(match[1], null, prim => prim)
+      ]
+    ]);
+  };
+  server.registerTypes(Platform_AdminApi$ReventlessCore.uploadTypes);
+  server.registerMutations(Platform_AdminApi$ReventlessCore.uploadMutationFields, resolvers);
+}
+
+export {
+  mintRef,
+  release,
+  register,
+}
+/* node:crypto Not a pure module */

package/tests/adapter/ServedBucketHttpTest.res

@@ -1,11 +1,15 @@
-// End-to-end test for the local served-bucket HTTP routes on DomainGraphQL_Server
-// (the dev analogue of the AWS CloudFront read path). Boots a real server on a
-// private port, then exercises the full upload → store → serve loop:
-//   POST /__inmemory/upload → {uploadUrl, storageRef}
-//   PUT  /{prefix}/{key}    → 200 (store)
-//   GET  /{prefix}/{key}    → the stored bytes + content-type
-// Talks to the server over node:http (Jest 27's VM strips global fetch), same
-// as LocalAuthHttpTest.
+// End-to-end test for the local upload contract on DomainGraphQL_Server (route B, the
+// dev analogue of the AWS presign + serve + release loop). Boots a real server on a
+// private port with the Upload resolvers registered (as `makePlatform` does), then
+// exercises the full loop:
+//   mutation Upload_Presign  → {uploadUrl, storageRef}
+//   PUT  /{prefix}/{key}     → 200 (store)
+//   GET  /{prefix}/{key}     → the stored bytes + content-type
+//   mutation Upload_Release  → {released: true}
+//   GET  /{prefix}/{key}     → 404 (gone)
+// Talks to the server over node:http (Jest 27's VM strips global fetch), same as
+// LocalAuthHttpTest. Mint and release are GraphQL mutations under route B; the byte
+// PUT/GET stay HTTP data-plane routes.
 
 @@warning("-44")
 
@@ -120,8 +124,37 @@ let getString = (j: JSON.t, k: string): string =>
 
 // ── Lifecycle ────────────────────────────────────────────────────────────────
 
+// Extract `data.r` from a GraphQL response body.
+let mutationResult = (body: JSON.t): JSON.t =>
+  body
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("data"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(d => d->Dict.get("r"))
+  ->Option.getOr(JSON.Encode.null)
+
+let presign = async (~fileName: string): JSON.t => {
+  let q = `mutation { r: Upload_Presign(store: "x.y", fileName: "${fileName}", contentType: "image/svg+xml") { uploadUrl storageRef } }`
+  let (_, body) = await postJson("/graphql", Dict.fromArray([("query", JSON.Encode.string(q))]))
+  mutationResult(body)
+}
+
+let releaseRef = async (~storageRef: string): JSON.t => {
+  let q = `mutation { r: Upload_Release(store: "x.y", storageRef: "${storageRef}") { released reason } }`
+  let (_, body) = await postJson("/graphql", Dict.fromArray([("query", JSON.Encode.string(q))]))
+  mutationResult(body)
+}
+
 beforeAllAsync(async () => {
   DomainGraphQL_Server.reset()
+  // Minimal valid schema: relay base (a Query type must exist) plus the Upload
+  // mutations, registered exactly as makePlatform does via LocalUploadResolvers.
+  DomainGraphQL_Server.registerTypes(~sdlTypes=ReventlessCore.GraphQL_Stitcher.relayBaseTypes)
+  DomainGraphQL_Server.registerQueries(
+    ~sdlFields=ReventlessCore.GraphQL_Stitcher.relayBaseQueries,
+    ~resolvers=Dict.make(),
+  )
+  LocalUploadResolvers.register(DomainGraphQL_Server.asInterface)
   DomainGraphQL_Server.start(~port, ())
   await Promise.make((resolve, _) => setTimeout(() => resolve(), 50)->ignore)
 })
@@ -132,31 +165,19 @@ afterAll(() => {
 
 // ── Tests ──────────────────────────────────────────────────────────────────
 
-testPromise("POST /__inmemory/upload returns matching uploadUrl + storageRef under the prefix", async () => {
-  let (status, body) =
-    await postJson(
-      "/__inmemory/upload",
-      Dict.fromArray([
-        ("fileName", JSON.Encode.string("logo.svg")),
-        ("contentType", JSON.Encode.string("image/svg+xml")),
-      ]),
-    )
-  expect(status)->toEqual(200)
-  let uploadUrl = getString(body, "uploadUrl")
-  let storageRef = getString(body, "storageRef")
+testPromise("Upload_Presign returns matching uploadUrl + storageRef under the prefix", async () => {
+  let r = await presign(~fileName="logo.svg")
+  let uploadUrl = getString(r, "uploadUrl")
+  let storageRef = getString(r, "storageRef")
   // Same same-origin ref serves as both the PUT target and the stored value.
   expect(uploadUrl)->toEqual(storageRef)
   expect(storageRef->String.startsWith("/uploads/"))->toEqual(true)
   expect(storageRef->String.endsWith("/logo.svg"))->toEqual(true)
 })
 
-testPromise("PUT then GET round-trips the bytes and content-type", async () => {
-  let (_, body) =
-    await postJson(
-      "/__inmemory/upload",
-      Dict.fromArray([("fileName", JSON.Encode.string("pixel.svg"))]),
-    )
-  let ref = getString(body, "storageRef")
+testPromise("presign → PUT → GET → release → GET(404) is the full loop", async () => {
+  let r = await presign(~fileName="pixel.svg")
+  let ref = getString(r, "storageRef")
   let svg = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'></svg>"
 
   let putStatus = await putRaw(ref, svg, ~contentType="image/svg+xml")
@@ -166,6 +187,23 @@ testPromise("PUT then GET round-trips the bytes and content-type", async () => {
   expect(getStatus)->toEqual(200)
   expect(gotBody)->toEqual(svg)
   expect(gotContentType)->toEqual("image/svg+xml")
+
+  let released = await releaseRef(~storageRef=ref)
+  expect(released->JSON.Decode.object->Option.flatMap(d => d->Dict.get("released")))->toEqual(
+    Some(JSON.Encode.bool(true)),
+  )
+
+  // After release the object is gone.
+  let (goneStatus, _, _) = await getRaw(ref)
+  expect(goneStatus)->toEqual(404)
+})
+
+testPromise("Upload_Release of a ref outside a served prefix is refused with a reason", async () => {
+  let r = await releaseRef(~storageRef="/not-a-store/x/y.svg")
+  expect(r->JSON.Decode.object->Option.flatMap(d => d->Dict.get("released")))->toEqual(
+    Some(JSON.Encode.bool(false)),
+  )
+  expect(getString(r, "reason"))->toEqual("not_in_store")
 })
 
 testPromise("GET a missing served object returns 404", async () => {

package/tests/adapter/ServedBucketHttpTest.res.mjs

@@ -4,7 +4,9 @@ import * as Nodehttp from "node:http";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+import * as LocalUploadResolvers$ReventlessLocal from "../../src/adapter/LocalUploadResolvers.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
 
@@ -115,8 +117,33 @@ function getString(j, k) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d[k]), Stdlib_JSON.Decode.string), "");
 }
 
+function mutationResult(body) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(body), d => d["data"]), Stdlib_JSON.Decode.object), d => d["r"]), null);
+}
+
+async function presign(fileName) {
+  let q = `mutation { r: Upload_Presign(store: "x.y", fileName: "` + fileName + `", contentType: "image/svg+xml") { uploadUrl storageRef } }`;
+  let match = await postJson("/graphql", Object.fromEntries([[
+      "query",
+      q
+    ]]));
+  return mutationResult(match[1]);
+}
+
+async function releaseRef(storageRef) {
+  let q = `mutation { r: Upload_Release(store: "x.y", storageRef: "` + storageRef + `") { released reason } }`;
+  let match = await postJson("/graphql", Object.fromEntries([[
+      "query",
+      q
+    ]]));
+  return mutationResult(match[1]);
+}
+
 globalThis.beforeAll(async () => {
   DomainGraphQL_Server$ReventlessLocal.reset();
+  DomainGraphQL_Server$ReventlessLocal.registerTypes(GraphQL_Stitcher$ReventlessCore.relayBaseTypes);
+  DomainGraphQL_Server$ReventlessLocal.registerQueries(GraphQL_Stitcher$ReventlessCore.relayBaseQueries, {});
+  LocalUploadResolvers$ReventlessLocal.register(DomainGraphQL_Server$ReventlessLocal.asInterface);
   DomainGraphQL_Server$ReventlessLocal.start(49322, undefined, undefined);
   return await new Promise((resolve, param) => {
     setTimeout(() => resolve(), 50);
@@ -125,39 +152,35 @@ globalThis.beforeAll(async () => {
 
 globalThis.afterAll(() => DomainGraphQL_Server$ReventlessLocal.stop());
 
-globalThis.test("POST /__inmemory/upload returns matching uploadUrl + storageRef under the prefix", async () => {
-  let match = await postJson("/__inmemory/upload", Object.fromEntries([
-    [
-      "fileName",
-      "logo.svg"
-    ],
-    [
-      "contentType",
-      "image/svg+xml"
-    ]
-  ]));
-  let body = match[1];
-  globalThis.expect(match[0]).toEqual(200);
-  let uploadUrl = getString(body, "uploadUrl");
-  let storageRef = getString(body, "storageRef");
+globalThis.test("Upload_Presign returns matching uploadUrl + storageRef under the prefix", async () => {
+  let r = await presign("logo.svg");
+  let uploadUrl = getString(r, "uploadUrl");
+  let storageRef = getString(r, "storageRef");
   globalThis.expect(uploadUrl).toEqual(storageRef);
   globalThis.expect(storageRef.startsWith("/uploads/")).toEqual(true);
   globalThis.expect(storageRef.endsWith("/logo.svg")).toEqual(true);
 });
 
-globalThis.test("PUT then GET round-trips the bytes and content-type", async () => {
-  let match = await postJson("/__inmemory/upload", Object.fromEntries([[
-      "fileName",
-      "pixel.svg"
-    ]]));
-  let ref = getString(match[1], "storageRef");
+globalThis.test("presign → PUT → GET → release → GET(404) is the full loop", async () => {
+  let r = await presign("pixel.svg");
+  let ref = getString(r, "storageRef");
   let svg = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'></svg>";
   let putStatus = await putRaw(ref, svg, "image/svg+xml");
   globalThis.expect(putStatus).toEqual(200);
+  let match = await getRaw(ref);
+  globalThis.expect(match[0]).toEqual(200);
+  globalThis.expect(match[1]).toEqual(svg);
+  globalThis.expect(match[2]).toEqual("image/svg+xml");
+  let released = await releaseRef(ref);
+  globalThis.expect(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(released), d => d["released"])).toEqual(true);
   let match$1 = await getRaw(ref);
-  globalThis.expect(match$1[0]).toEqual(200);
-  globalThis.expect(match$1[1]).toEqual(svg);
-  globalThis.expect(match$1[2]).toEqual("image/svg+xml");
+  globalThis.expect(match$1[0]).toEqual(404);
+});
+
+globalThis.test("Upload_Release of a ref outside a served prefix is refused with a reason", async () => {
+  let r = await releaseRef("/not-a-store/x/y.svg");
+  globalThis.expect(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(r), d => d["released"])).toEqual(false);
+  globalThis.expect(getString(r, "reason")).toEqual("not_in_store");
 });
 
 globalThis.test("GET a missing served object returns 404", async () => {
@@ -173,5 +196,8 @@ export {
   putRaw,
   getRaw,
   getString,
+  mutationResult,
+  presign,
+  releaseRef,
 }
 /*  Not a pure module */

package/tests/components/task/TaskTest.res

@@ -90,9 +90,12 @@ describe("Task_Builder.Make:", () => {
       let bucketNames = outputs.bucketNames->Option.getUnsafe
       let idOutput = bucketNames->Dict.get("Reports")->Option.getUnsafe
       let id = await idOutput->TestRunner.resolve
-      // In-memory bucket id = resource name: taskName ++ pascalCase(bucketName) ++ "Bucket"
-      // = "OneBucketTask" ++ "Reports" ++ "Bucket". The lookup key stays "Reports".
-      expect(id)->toBe("OneBucketTaskReportsBucket")
+      // In-memory bucket id = the bucket's resource name, which is kebab-cased
+      // and plugin-qualified because S3 lowercases a bucket name and a PascalCase
+      // one collapses into a run-on. No plugin segment here: the task is built
+      // outside any plugin, so there is no ambient plugin to qualify with.
+      // The runtime lookup key is a separate string and stays "Reports".
+      expect(id)->toBe("one-bucket-task-reports")
     })
   })
 })

package/tests/components/task/TaskTest.res.mjs

@@ -38,7 +38,7 @@ globalThis.describe("Task_Builder.Make:", () => {
       let bucketNames = outputs.bucketNames;
       let idOutput = bucketNames["Reports"];
       let id = await TestRunner$ReventlessLocal.resolve(idOutput);
-      globalThis.expect(id).toBe("OneBucketTaskReportsBucket");
+      globalThis.expect(id).toBe("one-bucket-task-reports");
     });
   });
 });