@reventlessdev/reventless-local 3.0.0-alpha.200 → 3.0.0-alpha.202

package/tests/adapter/GraphQL_SubscriptionResolversTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalStateChangeDescriptor$ReventlessLocal from "../../src/adapter/LocalStateChangeDescriptor.res.mjs";
 import * as LocalGraphQL_SubscriptionResolvers$ReventlessLocal from "../../src/adapter/Api/LocalGraphQL_SubscriptionResolvers.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
@@ -68,7 +69,7 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
           "2026-05-19T12:00:00Z"
         ]
       ]);
-      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "prod-1", state);
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "prod-1", state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       TestBus.publishStateChange("Product", descriptor);
       let received = await consumerPromise;
       if (received !== null) {
@@ -84,10 +85,10 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
       let iter = ps.subscribe("onCatalogProduct_stateChanged");
       let consumerPromise = startConsumer(iter, 300);
       await yieldTick();
-      let foreignDescriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "cat-1", Object.fromEntries([[
+      let foreignDescriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "cat-1", Object.fromEntries([[
           "id",
           "cat-1"
-        ]]));
+        ]]), LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       TestBus.publishStateChange("Category", foreignDescriptor);
       let received = await consumerPromise;
       globalThis.expect(received === null ? undefined : Primitive_option.some(received)).toEqual(undefined);

package/tests/adapter/ObjectStorePersistenceTest.res

@@ -0,0 +1,243 @@
+// The local object store follows the active backend's durability: with a
+// file-backed SQLite database the bytes land beside it on disk, so uploads and
+// offloaded payloads survive the restart that their events survive; with Memory
+// they stay in-process.
+
+@@warning("-44")
+
+open JestGlobals
+
+let tempRoot = (): string =>
+  NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-objectstore-"]))
+
+let bytes = NodeBuffer.fromStringUtf8
+
+describe("ObjectStoreStorage_FileSystem", () => {
+  testSync("put then get round-trips the bytes and the content type", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("<svg/>"),
+      ~contentType="image/svg+xml",
+    )
+    expect(
+      ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg")->Option.map(
+        ((got, contentType)) => (got->NodeBuffer.toStringUtf8, contentType),
+      ),
+    )->toEqual(Some(("<svg/>", "image/svg+xml")))
+  })
+
+  testSync("the key's slashes become directories under objects/", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    expect(
+      NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc", "logo.svg"])),
+    )->toEqual(true)
+  })
+
+  testSync("get returns None for a missing key", () => {
+    let root = tempRoot()
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/none/x.svg"))->toEqual(None)
+  })
+
+  testSync("get returns None for a key naming a directory rather than an object", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc"))->toEqual(None)
+  })
+
+  testSync("delete removes the object, its content type, and the directory it emptied", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    ObjectStoreStorage_FileSystem.delete(~root, ~key="uploads/abc/logo.svg")
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg"))->toEqual(None)
+    expect(NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc"])))->toEqual(false)
+    expect(NodeFs.existsSync(NodePath.join([root, "object-meta", "uploads", "abc"])))->toEqual(
+      false,
+    )
+  })
+
+  testSync("delete of an absent key is a no-op", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.delete(~root, ~key="uploads/abc/gone.svg")
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/gone.svg"))->toEqual(None)
+  })
+
+  testSync("offload payloads round-trip in their own keyspace", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.putOffload(~root, ~key="sha256/deadbeef", ~bytes=`{"a":1}`)
+    expect(ObjectStoreStorage_FileSystem.getOffload(~root, ~key="sha256/deadbeef"))->toEqual(
+      Some(`{"a":1}`),
+    )
+    // Not reachable as a served object — the two trees are separate.
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="sha256/deadbeef"))->toEqual(None)
+  })
+
+  testSync("a traversing key is refused rather than written outside the root", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/../../escaped.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    // `objects/uploads/../../escaped.svg` resolves to `<root>/escaped.svg`.
+    expect(NodeFs.existsSync(NodePath.join([root, "escaped.svg"])))->toEqual(false)
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/../../escaped.svg"))->toEqual(
+      None,
+    )
+  })
+
+  testSync("reset clears the store's trees and leaves the rest of the root alone", () => {
+    let root = tempRoot()
+    NodeFs.writeFileSync(NodePath.join([root, "local.db"]), "not a real database")
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    ObjectStoreStorage_FileSystem.putOffload(~root, ~key="sha256/deadbeef", ~bytes="{}")
+
+    ObjectStoreStorage_FileSystem.reset(~root)
+
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg"))->toEqual(None)
+    expect(ObjectStoreStorage_FileSystem.getOffload(~root, ~key="sha256/deadbeef"))->toEqual(None)
+    expect(NodeFs.existsSync(NodePath.join([root, "local.db"])))->toEqual(true)
+  })
+})
+
+describe("LocalObjectStore backend dispatch", () => {
+  // Restore the module-global backend so a later assertion in this file (and the
+  // suite's own default) sees Memory rather than whichever db a test opened.
+  afterEach(() => BackendState.setMemory())
+
+  testSync("a file-backed SQLite backend puts the bytes on disk beside the database", () => {
+    let root = tempRoot()
+    let path = NodePath.join([root, "local.db"])
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+
+    LocalObjectStore.put(~key="uploads/abc/logo.svg", ~bytes=bytes("x"), ~contentType="image/png")
+
+    expect(
+      NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc", "logo.svg"])),
+    )->toEqual(true)
+    expect(
+      LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.map(e => e.contentType),
+    )->toEqual(Some("image/png"))
+  })
+
+  testSync("an object stored on disk outlives the process that stored it", () => {
+    let root = tempRoot()
+    let path = NodePath.join([root, "local.db"])
+
+    // First "process": store, then drop every trace of it from memory.
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+    LocalObjectStore.put(
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("kept"),
+      ~contentType="image/png",
+    )
+    LocalObjectStore.putOffload(~key="sha256/cafe", ~bytes=`{"structure":true}`)
+    BackendState.setMemory()
+    ObjectStoreStorage_InMemory.reset()
+
+    // Second "process": same database file, same directory.
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+    expect(
+      LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.map(e => e.contentType),
+    )->toEqual(Some("image/png"))
+    expect(LocalObjectStore.getOffload(~key="sha256/cafe"))->toEqual(Some(`{"structure":true}`))
+  })
+
+  testSync("a `:memory:` SQLite backend keeps objects in process, writing nothing", () => {
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path=":memory:"), ~path=":memory:")
+    expect(BackendState.getObjectStoreRoot())->toEqual(None)
+
+    LocalObjectStore.put(~key="uploads/abc/logo.svg", ~bytes=bytes("x"), ~contentType="image/png")
+    expect(LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.isSome)->toEqual(true)
+  })
+
+  testSync("the Memory backend keeps objects in process", () => {
+    BackendState.setMemory()
+    expect(BackendState.getObjectStoreRoot())->toEqual(None)
+
+    LocalObjectStore.put(~key="uploads/abc/mem.svg", ~bytes=bytes("x"), ~contentType="image/png")
+    expect(LocalObjectStore.get(~key="uploads/abc/mem.svg")->Option.isSome)->toEqual(true)
+    LocalObjectStore.delete(~key="uploads/abc/mem.svg")
+    expect(LocalObjectStore.get(~key="uploads/abc/mem.svg"))->toEqual(None)
+  })
+
+  testSync("servedKey refuses a path that would climb out of the store", () => {
+    expect(LocalObjectStore.servedKey("/uploads/../../etc/passwd"))->toEqual(None)
+    expect(LocalObjectStore.servedKey("/uploads/abc/logo.svg"))->toEqual(
+      Some("uploads/abc/logo.svg"),
+    )
+  })
+})
+
+describe("declared store prefixes", () => {
+  afterEach(() => LocalObjectStore.reset())
+
+  testSync("a declared store mints under uploads/{plugin}/{store}", () => {
+    LocalObjectStore.registerStore(
+      ~qualified="Catalog.productImages",
+      ~prefix=LocalObjectStore.localPrefixFor(~qualified="Catalog.productImages"),
+    )
+    let ref = LocalUploadResolvers.mintRef(~store="Catalog.productImages", ~fileName="logo.svg")
+    expect(ref->String.startsWith("/uploads/Catalog/productImages/"))->toEqual(true)
+    expect(ref->String.endsWith("/logo.svg"))->toEqual(true)
+  })
+
+  testSync("an undeclared store falls back to the shared uploads prefix", () => {
+    let ref = LocalUploadResolvers.mintRef(~store="Nobody.knows", ~fileName="logo.svg")
+    expect(ref->String.startsWith("/uploads/"))->toEqual(true)
+  })
+
+  testSync("a store's objects stay under the served uploads prefix", () => {
+    LocalObjectStore.registerStore(
+      ~qualified="Catalog.productImages",
+      ~prefix="uploads/Catalog/productImages",
+    )
+    expect(LocalObjectStore.servedKey("/uploads/Catalog/productImages/abc/logo.svg"))->toEqual(
+      Some("uploads/Catalog/productImages/abc/logo.svg"),
+    )
+    // Nesting the store under `uploads/` is what keeps a UI dev server's single
+    // `/uploads` proxy hop enough to reach it — a sibling top-level prefix would
+    // resolve against the UI server instead of the platform.
+    expect(LocalObjectStore.servedKey("/Catalog/productImages/abc/logo.svg"))->toEqual(None)
+    expect(LocalObjectStore.servedKey("/Ordering/invoices/abc/x.pdf"))->toEqual(None)
+  })
+
+  testSync("two plugins declaring the same store name stay apart", () => {
+    ["Catalog.images", "Ordering.images"]->Array.forEach(
+      q =>
+        LocalObjectStore.registerStore(
+          ~qualified=q,
+          ~prefix=LocalObjectStore.localPrefixFor(~qualified=q),
+        ),
+    )
+    expect(LocalObjectStore.storePrefix(~qualified="Catalog.images"))->toEqual(
+      Some("uploads/Catalog/images"),
+    )
+    expect(LocalObjectStore.storePrefix(~qualified="Ordering.images"))->toEqual(
+      Some("uploads/Ordering/images"),
+    )
+  })
+})

package/tests/adapter/ObjectStorePersistenceTest.res.mjs

@@ -0,0 +1,159 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "../../src/adapter/ObjectStore/LocalObjectStore.res.mjs";
+import * as LocalUploadResolvers$ReventlessLocal from "../../src/adapter/LocalUploadResolvers.res.mjs";
+import * as ObjectStoreStorage_InMemory$ReventlessLocal from "../../src/adapter/ObjectStore/ObjectStoreStorage_InMemory.res.mjs";
+import * as ObjectStoreStorage_FileSystem$ReventlessLocal from "../../src/adapter/ObjectStore/ObjectStoreStorage_FileSystem.res.mjs";
+
+function tempRoot() {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-objectstore-"));
+}
+
+function bytes(prim) {
+  return Buffer.from(prim, "utf8");
+}
+
+globalThis.describe("ObjectStoreStorage_FileSystem", () => {
+  globalThis.test("put then get round-trips the bytes and the content type", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("<svg/>", "utf8"), "image/svg+xml");
+    globalThis.expect(Stdlib_Option.map(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg"), param => [
+      param[0].toString("utf8"),
+      param[1]
+    ])).toEqual([
+      "<svg/>",
+      "image/svg+xml"
+    ]);
+  });
+  globalThis.test("the key's slashes become directories under objects/", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc", "logo.svg"))).toEqual(true);
+  });
+  globalThis.test("get returns None for a missing key", () => {
+    let root = tempRoot();
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/none/x.svg")).toEqual(undefined);
+  });
+  globalThis.test("get returns None for a key naming a directory rather than an object", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc")).toEqual(undefined);
+  });
+  globalThis.test("delete removes the object, its content type, and the directory it emptied", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.$$delete(root, "uploads/abc/logo.svg");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc"))).toEqual(false);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "object-meta", "uploads", "abc"))).toEqual(false);
+  });
+  globalThis.test("delete of an absent key is a no-op", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.$$delete(root, "uploads/abc/gone.svg");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/gone.svg")).toEqual(undefined);
+  });
+  globalThis.test("offload payloads round-trip in their own keyspace", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.putOffload(root, "sha256/deadbeef", `{"a":1}`);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.getOffload(root, "sha256/deadbeef")).toEqual(`{"a":1}`);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "sha256/deadbeef")).toEqual(undefined);
+  });
+  globalThis.test("a traversing key is refused rather than written outside the root", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/../../escaped.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "escaped.svg"))).toEqual(false);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/../../escaped.svg")).toEqual(undefined);
+  });
+  globalThis.test("reset clears the store's trees and leaves the rest of the root alone", () => {
+    let root = tempRoot();
+    Nodefs.writeFileSync(Nodepath.join(root, "local.db"), "not a real database", "utf8");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.putOffload(root, "sha256/deadbeef", "{}");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.reset(root);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.getOffload(root, "sha256/deadbeef")).toEqual(undefined);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "local.db"))).toEqual(true);
+  });
+});
+
+globalThis.describe("LocalObjectStore backend dispatch", () => {
+  globalThis.afterEach(() => BackendState$ReventlessLocal.setMemory());
+  globalThis.test("a file-backed SQLite backend puts the bytes on disk beside the database", () => {
+    let root = tempRoot();
+    let path = Nodepath.join(root, "local.db");
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc", "logo.svg"))).toEqual(true);
+    globalThis.expect(Stdlib_Option.map(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"), e => e.contentType)).toEqual("image/png");
+  });
+  globalThis.test("an object stored on disk outlives the process that stored it", () => {
+    let root = tempRoot();
+    let path = Nodepath.join(root, "local.db");
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("kept", "utf8"), "image/png");
+    LocalObjectStore$ReventlessLocal.putOffload("sha256/cafe", `{"structure":true}`);
+    BackendState$ReventlessLocal.setMemory();
+    ObjectStoreStorage_InMemory$ReventlessLocal.reset();
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    globalThis.expect(Stdlib_Option.map(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"), e => e.contentType)).toEqual("image/png");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.getOffload("sha256/cafe")).toEqual(`{"structure":true}`);
+  });
+  globalThis.test("a `:memory:` SQLite backend keeps objects in process, writing nothing", () => {
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(":memory:"), ":memory:");
+    globalThis.expect(BackendState$ReventlessLocal.getObjectStoreRoot()).toEqual(undefined);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"))).toEqual(true);
+  });
+  globalThis.test("the Memory backend keeps objects in process", () => {
+    BackendState$ReventlessLocal.setMemory();
+    globalThis.expect(BackendState$ReventlessLocal.getObjectStoreRoot()).toEqual(undefined);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/mem.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.get("uploads/abc/mem.svg"))).toEqual(true);
+    LocalObjectStore$ReventlessLocal.$$delete("uploads/abc/mem.svg");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.get("uploads/abc/mem.svg")).toEqual(undefined);
+  });
+  globalThis.test("servedKey refuses a path that would climb out of the store", () => {
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/../../etc/passwd")).toEqual(undefined);
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/abc/logo.svg")).toEqual("uploads/abc/logo.svg");
+  });
+});
+
+globalThis.describe("declared store prefixes", () => {
+  globalThis.afterEach(() => LocalObjectStore$ReventlessLocal.reset());
+  globalThis.test("a declared store mints under uploads/{plugin}/{store}", () => {
+    LocalObjectStore$ReventlessLocal.registerStore("Catalog.productImages", LocalObjectStore$ReventlessLocal.localPrefixFor("Catalog.productImages"));
+    let ref = LocalUploadResolvers$ReventlessLocal.mintRef("Catalog.productImages", "logo.svg");
+    globalThis.expect(ref.startsWith("/uploads/Catalog/productImages/")).toEqual(true);
+    globalThis.expect(ref.endsWith("/logo.svg")).toEqual(true);
+  });
+  globalThis.test("an undeclared store falls back to the shared uploads prefix", () => {
+    let ref = LocalUploadResolvers$ReventlessLocal.mintRef("Nobody.knows", "logo.svg");
+    globalThis.expect(ref.startsWith("/uploads/")).toEqual(true);
+  });
+  globalThis.test("a store's objects stay under the served uploads prefix", () => {
+    LocalObjectStore$ReventlessLocal.registerStore("Catalog.productImages", "uploads/Catalog/productImages");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/Catalog/productImages/abc/logo.svg")).toEqual("uploads/Catalog/productImages/abc/logo.svg");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/Catalog/productImages/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/Ordering/invoices/abc/x.pdf")).toEqual(undefined);
+  });
+  globalThis.test("two plugins declaring the same store name stay apart", () => {
+    [
+      "Catalog.images",
+      "Ordering.images"
+    ].forEach(q => LocalObjectStore$ReventlessLocal.registerStore(q, LocalObjectStore$ReventlessLocal.localPrefixFor(q)));
+    globalThis.expect(LocalObjectStore$ReventlessLocal.storePrefix("Catalog.images")).toEqual("uploads/Catalog/images");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.storePrefix("Ordering.images")).toEqual("uploads/Ordering/images");
+  });
+});
+
+export {
+  tempRoot,
+  bytes,
+}
+/*  Not a pure module */

package/tests/components/eventlog/EventLogProvisioningSeamTest.res

@@ -0,0 +1,110 @@
+// End-to-end check that the EventLogProvisioning seam fires from the real
+// builders, not just from its own registry: a backend registered before the
+// build sees both log styles as they are provisioned, through the local
+// in-memory storage adapters.
+//
+// Registration and construction happen at module load — the seam fires during
+// `Component.make`'s construct, so a backend registered inside a `test` body
+// would arrive too late. The assertions then read what was recorded.
+
+open JestGlobals
+
+type record = {
+  logStyle: ReventlessCore.EventLogProvisioning.logStyle,
+  name: string,
+  owner: option<ReventlessCore.ResourceAttribution.owner>,
+  plugin: option<string>,
+  resourceCount: int,
+}
+
+let provisioned: array<record> = []
+
+module Recorder: ReventlessCore.EventLogProvisioning.Backend = {
+  let onProvisioned = (~logStyle, ~name, ~owner, ~plugin, ~platform as _, ~resources, ~opts as _) =>
+    provisioned->Array.push({
+      logStyle,
+      name,
+      owner,
+      plugin,
+      resourceCount: resources->Array.length,
+    })
+}
+
+ReventlessCore.EventLogProvisioning.use(module(Recorder: ReventlessCore.EventLogProvisioning.Backend))
+
+module Bus = LocalBus.Make()
+
+let _ = TestRunner.setup()
+
+// ── Classic log ──────────────────────────────────────────────
+module SeamItemSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "SeamItemEventLog"
+
+  @schema
+  type event = | SeamItemCreated({name: string})
+}
+
+module ClassicMaker = ReventlessCore.EventLog_Builder.Make(
+  SeamItemSpec,
+  EventLogStorage_InMemory,
+  LocalEventTopicPublisher.Make(Bus),
+)
+
+// The plugin builder publishes this context around a plugin's construct; entering
+// it here is what a real plugin build does, so the seam should carry the names.
+let previousContext = ReventlessCore.ResourceAttribution.enter(~platform="seam-platform", ~plugin="SeamPlugin")
+
+let classicLog = ClassicMaker.make(
+  ~name="SeamItem",
+  ~owner={kind: ReventlessCore.ComponentType.Aggregate, name: "SeamItem"},
+)
+
+// ── DCB log ──────────────────────────────────────────────────
+module DcbMaker = DcbEventLog_Builder.Make(Bus)
+
+let dcbLog = DcbMaker.make(
+  ~name="SeamCatalog",
+  ~partitionTag=Reventless.DcbTag.Simple({key: "id"}),
+)
+
+ReventlessCore.ResourceAttribution.restore(previousContext)
+
+describe("EventLogProvisioning seam, driven by the real builders", () => {
+  testSync("fires once per log, for both styles", () => {
+    expect(provisioned->Array.map(r => (r.logStyle, r.name)))->toEqual([
+      (ReventlessCore.EventLogProvisioning.Classic, "SeamItemEventLog"),
+      (ReventlessCore.EventLogProvisioning.Dcb, "SeamCatalogDcbEventLog"),
+    ])
+  })
+
+  testSync("carries the owning element: the aggregate for classic, the plugin for DCB", () => {
+    expect(provisioned->Array.map(r => r.owner))->toEqual([
+      Some(({kind: ReventlessCore.ComponentType.Aggregate, name: "SeamItem"}: ReventlessCore.ResourceAttribution.owner)),
+      Some(({kind: ReventlessCore.ComponentType.Plugin, name: "SeamCatalog"}: ReventlessCore.ResourceAttribution.owner)),
+    ])
+  })
+
+  testSync("carries the ambient plugin attribution the builder published", () => {
+    expect(provisioned->Array.map(r => r.plugin))->toEqual([
+      Some("SeamPlugin"),
+      Some("SeamPlugin"),
+    ])
+  })
+
+  testSync("carries the adapter's resources — empty for in-memory storage", () => {
+    // In-memory logs have nothing attachable; the seam still fires, and a backend
+    // that only implements a provider arm ignores them.
+    expect(provisioned->Array.map(r => r.resourceCount))->toEqual([0, 0])
+  })
+
+  test("the components still build normally with a backend registered", async () => {
+    let classicOps = await classicLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let dcbOps = await dcbLog->DcbMaker.operations->TestRunner.resolve
+    // Resolving both operation records proves construction completed with a
+    // backend registered — the seam fires mid-construct, so a throwing backend
+    // would take the build down here.
+    expect(classicOps)->toBeTruthy
+    expect(dcbOps)->toBeTruthy
+  })
+})