@reventlessdev/reventless-local 3.0.0-alpha.117 → 3.0.0-alpha.119

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.119 (2026-07-05)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.118 (2026-07-05)
+
+### Features
+
+* **postgres:** add reventless-postgres backend + local-platform integration ([6913200](https://github.com/ReventlessDev/reventless-core/commit/69132001f9271e832a5af33416acd5b645feaf47))
+
+
 # 3.0.0-alpha.117 (2026-07-04)
 
 **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.117",
+  "version": "3.0.0-alpha.119",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -31,15 +31,16 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.17",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.16",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.17",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.16",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.138",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.64",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.84",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.78"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.140",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.80",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.2",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.86",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.64"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/rescript.json

@@ -32,7 +32,8 @@
     "@reventlessdev/reventless-infra",
     "@reventlessdev/reventless-spec",
     "@reventlessdev/reventless-core",
-    "@reventlessdev/reventless-gwt"
+    "@reventlessdev/reventless-gwt",
+    "@reventlessdev/reventless-postgres"
   ],
   "compiler-flags": [],
   "suffix": ".res.mjs"

package/src/Platform.res

@@ -79,6 +79,22 @@ module MakeWithConfig = (
   // SQLite handle. resetOnStart truncates the file at construction.
   let _ = switch Config.backend {
   | Backend.Memory => BackendState.setMemory()
+  | Backend.Postgres({pool, initialCount}) =>
+    // Async setup (connect + ensureSchema + count) already ran in the
+    // Backend.postgres smart constructor — the sync functor only stores the
+    // ready pool and seeds the event-tap counter from the persisted totals.
+    BackendState.setPostgres(~pool)
+    LocalBus.seedEventTapSeq(initialCount)
+  // SCOPE: Backend.Postgres persists the durable event logs (classic + DCB) via
+  // the reventless-postgres runtime. Read models use the in-memory live-query
+  // path — the LocalBus scan/stream registrations are synchronous, which async pg
+  // cannot satisfy without a broader bus refactor; the package's
+  // QueryDbStorage_Postgres remains available to deploy-time compute layers.
+  // Because read models are in-memory (empty on start), they are rebuilt on every
+  // startup by full-replaying the durable pg event log through the projection
+  // handlers (PgProjectionCatchup, wired below). The runtime ProjectionPending
+  // low-watermark (a SQLite-only persisted-checkpoint optimisation) stays off —
+  // full replay needs no checkpoint.
   | Backend.Sqlite({path, resetOnStart}) =>
     if resetOnStart {
       Backend.removeFileIfExists(path)
@@ -741,7 +757,7 @@ module MakeWithConfig = (
       LocalRuntimeEnvironment,
       EventCollectorChannel,
     ),
-    DcbEventLogStorage_InMemory.Make(Bus),
+    LocalDcbEventLogStorage.Make(Bus),
     LocalEventTopicPublisher.Make(Bus),
     LocalCommandTopicChannel.Make(Bus),
     LocalCommandTopicChannel.Make(Bus),
@@ -799,7 +815,7 @@ module MakeWithConfig = (
   // Backend-aware storage for the UIFragment registry — the same functor every
   // other read model uses. Replaces a hand-rolled memory-only store that ignored
   // BackendState, so the registry now persists under SQLite too.
-  module UIFragmentStorage = QueryDbStorage_InMemory.Make(Bus)
+  module UIFragmentStorage = LocalQueryDbStorage.Make(Bus)
 
   let ensureUIFragmentRegistryQueryDbStore = () => {
     switch uiFragmentQueryDbOpsRef.contents {
@@ -1274,6 +1290,7 @@ module MakeWithConfig = (
       ~comp="Platform",
       switch Config.backend {
       | Backend.Memory => "backend: memory"
+      | Backend.Postgres({connection}) => `backend: postgres (${connection}, event-logs only)`
       | Backend.Sqlite({path, resetOnStart}) =>
         `backend: sqlite (${path}${resetOnStart ? ", resetOnStart" : ""})`
       },
@@ -1282,11 +1299,16 @@ module MakeWithConfig = (
     // BEFORE this session appends anything. Catch-up replays only (checkpoint,
     // bound] — this session's own events (Connect dispatches, user commands)
     // are live-delivered and must not be redelivered.
-    let projectionCatchup = BackendState.getDb()->Option.map(db => (
+    let projectionCatchup = BackendState.getSqliteDb()->Option.map(db => (
       db,
       ProjectionCheckpoint.maxPosition(db, ProjectionPending.Aggregate),
       ProjectionCheckpoint.maxPosition(db, ProjectionPending.Dcb),
     ))
+    // Postgres: read models are in-memory (rebuilt on every start), so capture the
+    // pre-session head NOW — before plugins build or this session appends — and
+    // full-replay (0, head] after the plugins register their projection handlers.
+    let pgProjectionCatchup =
+      BackendState.getPostgresPool()->Option.map(pool => (pool, PgProjectionCatchup.captureBounds(pool)))
 
     // Create scheduler and populate platform context refs.
     let scheduler = makeScheduler()
@@ -1389,8 +1411,8 @@ module MakeWithConfig = (
       seedUIFragmentRegistryQueryDb(~pluginComponents=plugins)
       seedPluginStructuresStore(~pluginComponents=plugins)
     }
-    switch projectionCatchup {
-    | Some((db, upperBound, dcbUpperBound)) =>
+    switch (projectionCatchup, pgProjectionCatchup) {
+    | (Some((db, upperBound, dcbUpperBound)), _) =>
       let _ =
         ProjectionCheckpoint.startupCatchup(~db, ~upperBound, ~dcbUpperBound, ~handlers=() =>
           Bus.projectionCatchupHandlers()
@@ -1403,7 +1425,23 @@ module MakeWithConfig = (
           seedAdminStores()
           Promise.resolve()
         })
-    | None => seedAdminStores()
+    | (_, Some((pool, boundsPromise))) =>
+      let _ =
+        boundsPromise
+        ->Promise.then(bounds =>
+          PgProjectionCatchup.startupCatchup(~pool, ~bounds, ~handlers=() =>
+            Bus.projectionCatchupHandlers()
+          )
+        )
+        ->Promise.catch(e => {
+          Console.error2("[Platform] postgres projection catch-up failed:", e)
+          Promise.resolve()
+        })
+        ->Promise.then(() => {
+          seedAdminStores()
+          Promise.resolve()
+        })
+    | (None, None) => seedAdminStores()
     }
 
     // Seed the built-in admin plugin's structure so its Auto UI (Plugin list with

package/src/Platform.res.mjs

@@ -50,6 +50,8 @@ import * as ProjectionPending$ReventlessLocal from "./adapter/ProjectionPending.
 import * as ReadModel_Builder$ReventlessLocal from "./components/ReadModel_Builder.res.mjs";
 import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Server.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
+import * as LocalQueryDbStorage$ReventlessLocal from "./adapter/QueryDb/LocalQueryDbStorage.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 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";
@@ -62,17 +64,16 @@ import * as PlatformGraphQL_Server$ReventlessLocal from "./adapter/PlatformGraph
 import * as Platform_UIFragmentsApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_UIFragmentsApi.res.mjs";
 import * as StateViewSlice_Builder$ReventlessLocal from "./components/StateViewSlice_Builder.res.mjs";
 import * as AutomationSlice_Builder$ReventlessLocal from "./components/AutomationSlice_Builder.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "./adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
 import * as LocalRuntimeEnvironment$ReventlessLocal from "./adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
 import * as LocalScheduledPublisher$ReventlessLocal from "./adapter/Scheduler/LocalScheduledPublisher.res.mjs";
 import * as Platform_Admin_Structure$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin_Structure.res.mjs";
-import * as QueryDbStorage_InMemory$ReventlessLocal from "./adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
 import * as LocalCommandTopicChannel$ReventlessLocal from "./adapter/CommandTopic/LocalCommandTopicChannel.res.mjs";
 import * as LocalEventTopicPublisher$ReventlessLocal from "./adapter/EventTopic/LocalEventTopicPublisher.res.mjs";
 import * as StateChangeSlice_Builder$ReventlessLocal from "./components/StateChangeSlice_Builder.res.mjs";
 import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "./adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res.mjs";
 import * as LocalEventCollectorChannel$ReventlessLocal from "./adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
 import * as PluginRuntime_Builder_Micro$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/PluginRuntime_Builder_Micro.res.mjs";
-import * as DcbEventLogStorage_InMemory$ReventlessLocal from "./adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs";
 import * as UIFragmentRegistryReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UIFragmentRegistryReadModelSpec.res.mjs";
 import * as InboundTranslationSlice_Builder$ReventlessLocal from "./components/InboundTranslationSlice_Builder.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_ComponentDefinitionsApi.res.mjs";
@@ -110,7 +111,7 @@ function MakeWithConfig(Config) {
   let match = Config.backend;
   if (typeof match !== "object") {
     BackendState$ReventlessLocal.setMemory();
-  } else {
+  } else if (match.TAG === "Sqlite") {
     let path = match.path;
     if (match.resetOnStart) {
       Backend$ReventlessLocal.removeFileIfExists(path);
@@ -124,6 +125,9 @@ function MakeWithConfig(Config) {
       let msgIds = metas !== undefined ? metas.map(m => m.msgId) : Stdlib_Array.filterMap(publishedEvent.eventsJson, json => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string));
       return ProjectionCheckpoint$ReventlessLocal.completePublished(db, msgIds);
     });
+  } else {
+    BackendState$ReventlessLocal.setPostgres(match.pool);
+    LocalBus$ReventlessLocal.seedEventTapSeq(match.initialCount);
   }
   let Bus = LocalBus$ReventlessLocal.Impl({
     capacity: undefined,
@@ -704,7 +708,7 @@ function MakeWithConfig(Config) {
     extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
     asEventHandler: prim => prim,
     asEffectHandler: prim => prim
-  })(EventCollectorChannel))(DcbEventLogStorage_InMemory$ReventlessLocal.Make(Bus))(LocalEventTopicPublisher$ReventlessLocal.Make(Bus))({
+  })(EventCollectorChannel))(LocalDcbEventLogStorage$ReventlessLocal.Make(Bus))(LocalEventTopicPublisher$ReventlessLocal.Make(Bus))({
     make: $$let$1.make
   })({
     make: $$let$2.make
@@ -730,7 +734,7 @@ function MakeWithConfig(Config) {
   let uiFragmentQueryDbOpsRef = {
     contents: undefined
   };
-  let UIFragmentStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
+  let UIFragmentStorage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
   let ensureUIFragmentRegistryQueryDbStore = () => {
     let ops = uiFragmentQueryDbOpsRef.contents;
     if (ops !== undefined) {
@@ -1094,15 +1098,21 @@ function MakeWithConfig(Config) {
     log.info("Platform", undefined, `silent: ` + Stdlib_Bool.toString(Config.silent) + `, splitApi: ` + Stdlib_Bool.toString(Config.splitApi) + `, cloner: ` + Stdlib_Bool.toString(Config.cloner));
     let match = Config.backend;
     let tmp;
-    tmp = typeof match !== "object" ? "backend: memory" : `backend: sqlite (` + match.path + (
-        match.resetOnStart ? ", resetOnStart" : ""
-      ) + `)`;
+    tmp = typeof match !== "object" ? "backend: memory" : (
+        match.TAG === "Sqlite" ? `backend: sqlite (` + match.path + (
+            match.resetOnStart ? ", resetOnStart" : ""
+          ) + `)` : `backend: postgres (` + match.connection + `, event-logs only)`
+      );
     log.info("Platform", undefined, tmp);
-    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getDb(), db => [
+    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb")
     ]);
+    let pgProjectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getPostgresPool(), pool => [
+      pool,
+      PgProjectionCatchup$ReventlessLocal.captureBounds(pool)
+    ]);
     let scheduler = makeScheduler();
     hooks_scheduler.contents = scheduler;
     hooks_api.contents = {
@@ -1174,6 +1184,15 @@ function MakeWithConfig(Config) {
         seedAdminStores();
         return Promise.resolve();
       });
+    } else if (pgProjectionCatchup !== undefined) {
+      let pool = pgProjectionCatchup[0];
+      Stdlib_Promise.$$catch(pgProjectionCatchup[1].then(bounds => PgProjectionCatchup$ReventlessLocal.startupCatchup(pool, bounds, () => Bus.projectionCatchupHandlers())), e => {
+        console.error("[Platform] postgres projection catch-up failed:", e);
+        return Promise.resolve();
+      }).then(() => {
+        seedAdminStores();
+        return Promise.resolve();
+      });
     } else {
       seedAdminStores();
     }
@@ -1725,7 +1744,7 @@ function Make($star) {
   TestRunner$ReventlessLocal.setup();
   if (typeof backend !== "object") {
     BackendState$ReventlessLocal.setMemory();
-  } else {
+  } else if (backend.TAG === "Sqlite") {
     let path = backend.path;
     if (backend.resetOnStart) {
       Backend$ReventlessLocal.removeFileIfExists(path);
@@ -1739,6 +1758,9 @@ function Make($star) {
       let msgIds = metas !== undefined ? metas.map(m => m.msgId) : Stdlib_Array.filterMap(publishedEvent.eventsJson, json => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string));
       return ProjectionCheckpoint$ReventlessLocal.completePublished(db, msgIds);
     });
+  } else {
+    BackendState$ReventlessLocal.setPostgres(backend.pool);
+    LocalBus$ReventlessLocal.seedEventTapSeq(backend.initialCount);
   }
   let Bus = LocalBus$ReventlessLocal.Impl({
     capacity: undefined,
@@ -2312,7 +2334,7 @@ function Make($star) {
     extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
     asEventHandler: prim => prim,
     asEffectHandler: prim => prim
-  })(EventCollectorChannel))(DcbEventLogStorage_InMemory$ReventlessLocal.Make(Bus))(LocalEventTopicPublisher$ReventlessLocal.Make(Bus))({
+  })(EventCollectorChannel))(LocalDcbEventLogStorage$ReventlessLocal.Make(Bus))(LocalEventTopicPublisher$ReventlessLocal.Make(Bus))({
     make: $$let$1.make
   })({
     make: $$let$2.make
@@ -2338,7 +2360,7 @@ function Make($star) {
   let uiFragmentQueryDbOpsRef = {
     contents: undefined
   };
-  let UIFragmentStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
+  let UIFragmentStorage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
   let ensureUIFragmentRegistryQueryDbStore = () => {
     let ops = uiFragmentQueryDbOpsRef.contents;
     if (ops !== undefined) {
@@ -2697,15 +2719,21 @@ function Make($star) {
     log.info("Platform", undefined, `v` + version);
     log.info("Platform", undefined, `silent: ` + Stdlib_Bool.toString(false) + `, splitApi: ` + Stdlib_Bool.toString(true) + `, cloner: ` + Stdlib_Bool.toString(false));
     let tmp;
-    tmp = typeof backend !== "object" ? "backend: memory" : `backend: sqlite (` + backend.path + (
-        backend.resetOnStart ? ", resetOnStart" : ""
-      ) + `)`;
+    tmp = typeof backend !== "object" ? "backend: memory" : (
+        backend.TAG === "Sqlite" ? `backend: sqlite (` + backend.path + (
+            backend.resetOnStart ? ", resetOnStart" : ""
+          ) + `)` : `backend: postgres (` + backend.connection + `, event-logs only)`
+      );
     log.info("Platform", undefined, tmp);
-    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getDb(), db => [
+    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),
       ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb")
     ]);
+    let pgProjectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getPostgresPool(), pool => [
+      pool,
+      PgProjectionCatchup$ReventlessLocal.captureBounds(pool)
+    ]);
     let scheduler = makeScheduler();
     hooks_scheduler.contents = scheduler;
     hooks_api.contents = {
@@ -2777,6 +2805,15 @@ function Make($star) {
         seedAdminStores();
         return Promise.resolve();
       });
+    } else if (pgProjectionCatchup !== undefined) {
+      let pool = pgProjectionCatchup[0];
+      Stdlib_Promise.$$catch(pgProjectionCatchup[1].then(bounds => PgProjectionCatchup$ReventlessLocal.startupCatchup(pool, bounds, () => Bus.projectionCatchupHandlers())), e => {
+        console.error("[Platform] postgres projection catch-up failed:", e);
+        return Promise.resolve();
+      }).then(() => {
+        seedAdminStores();
+        return Promise.resolve();
+      });
     } else {
       seedAdminStores();
     }

package/src/adapter/Backend.res

@@ -7,10 +7,33 @@
 type t =
   | Memory
   | Sqlite({path: string, resetOnStart: bool})
+  // Carries a live, schema-ensured pool: `pg` has no synchronous client, and
+  // Platform.MakeWithConfig is a synchronous functor, so the async setup
+  // (connect + ensureSchema + count) is done by the `postgres` smart constructor
+  // BEFORE Make. `initialCount` seeds the event-tap counter; `connection` is
+  // retained for diagnostics only.
+  | Postgres({pool: ReventlessPostgres.PgDriver.pool, initialCount: int, connection: string})
 
 let memory = Memory
 let sqlite = (~path, ~resetOnStart=false) => Sqlite({path, resetOnStart})
 
+// Async constructor for the Postgres backend. Connects a pool, ensures the
+// schema/functions exist, truncates when resetOnStart, and pre-counts persisted
+// events. Await this before Platform.MakeWithConfig:
+//   let backend = await Backend.postgres(~connection="postgres://…")
+//   module Platform = Platform.MakeWithConfig({ …; let backend })
+let postgres = async (~connection, ~resetOnStart=false) => {
+  let pool = ReventlessPostgres.PgDriver.makePool({connectionString: connection})
+  await ReventlessPostgres.PgSchema.ensureSchema(pool)
+  if resetOnStart {
+    await ReventlessPostgres.PgSchema.truncateAll(pool)
+  }
+  let initialCount =
+    (await ReventlessPostgres.EventLogStorage_Postgres.countAll(pool)) +
+      (await ReventlessPostgres.DcbEventLogStorage_Postgres.countAll(pool))
+  Postgres({pool, initialCount, connection})
+}
+
 @val external processEnv: dict<string> = "process.env"
 
 // Deletes a file if it exists. No-op if the path is missing.

package/src/adapter/Backend.res.mjs

@@ -1,6 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Nodefs from "node:fs";
+import * as PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as EventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
 
 function sqlite(path, resetOnStartOpt) {
   let resetOnStart = resetOnStartOpt !== undefined ? resetOnStartOpt : false;
@@ -11,6 +15,24 @@ function sqlite(path, resetOnStartOpt) {
   };
 }
 
+async function postgres(connection, resetOnStartOpt) {
+  let resetOnStart = resetOnStartOpt !== undefined ? resetOnStartOpt : false;
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: connection
+  });
+  await PgSchema$ReventlessPostgres.ensureSchema(pool);
+  if (resetOnStart) {
+    await PgSchema$ReventlessPostgres.truncateAll(pool);
+  }
+  let initialCount = await EventLogStorage_Postgres$ReventlessPostgres.countAll(pool) + await DcbEventLogStorage_Postgres$ReventlessPostgres.countAll(pool) | 0;
+  return {
+    TAG: "Postgres",
+    pool: pool,
+    initialCount: initialCount,
+    connection: connection
+  };
+}
+
 function removeFileIfExists(path) {
   try {
     Nodefs.unlinkSync(path);
@@ -60,6 +82,7 @@ let memory = "Memory";
 export {
   memory,
   sqlite,
+  postgres,
   removeFileIfExists,
   fromEnv,
 }

package/src/adapter/BackendState.res

@@ -12,6 +12,7 @@
 type active =
   | Memory
   | Sqlite({db: SqliteDriver.t, path: string})
+  | Postgres({pool: ReventlessPostgres.PgDriver.pool})
 
 let current: ref<active> = ref(Memory)
 
@@ -19,16 +20,20 @@ let setMemory = () => current := Memory
 
 let setSqlite = (~db, ~path) => current := Sqlite({db, path})
 
-let getDb = () =>
+let setPostgres = (~pool) => current := Postgres({pool: pool})
+
+// Per-backend handle accessors, symmetric across the SQL backends: each returns
+// Some only when that backend is active. Dispatching adapters
+// (LocalEventLogStorage, LocalDcbEventLogStorage, LocalQueryDbStorage,
+// LocalTaskBucket) switch on these to select their concrete implementation.
+let getSqliteDb = () =>
   switch current.contents {
   | Sqlite({db}) => Some(db)
-  | Memory => None
+  | Memory | Postgres(_) => None
   }
 
-// True when the active backend is SQLite — used by adapters that want to swap
-// their implementation entirely, not just their data access.
-let isSqlite = () =>
+let getPostgresPool = () =>
   switch current.contents {
-  | Sqlite(_) => true
-  | Memory => false
+  | Postgres({pool}) => Some(pool)
+  | Memory | Sqlite(_) => None
   }

package/src/adapter/BackendState.res.mjs

@@ -18,25 +18,37 @@ function setSqlite(db, path) {
   };
 }
 
-function getDb() {
+function setPostgres(pool) {
+  current.contents = {
+    TAG: "Postgres",
+    pool: pool
+  };
+}
+
+function getSqliteDb() {
   let match = current.contents;
-  if (typeof match !== "object") {
+  if (typeof match !== "object" || match.TAG !== "Sqlite") {
     return;
   } else {
     return Primitive_option.some(match.db);
   }
 }
 
-function isSqlite() {
+function getPostgresPool() {
   let match = current.contents;
-  return typeof match === "object";
+  if (typeof match !== "object" || match.TAG === "Sqlite") {
+    return;
+  } else {
+    return Primitive_option.some(match.pool);
+  }
 }
 
 export {
   current,
   setMemory,
   setSqlite,
-  getDb,
-  isSqlite,
+  setPostgres,
+  getSqliteDb,
+  getPostgresPool,
 }
 /* No side effect */

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res

@@ -144,7 +144,7 @@ let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _
     | None => false
     }
     if conflictDetected {
-      Error("conflict: condition check failed")
+      Error(ReventlessInfra.DcbEventLog.Conflict)
     } else {
       let base = events.contents->Array.length
       let storedEvents =
@@ -189,28 +189,9 @@ let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _
 // (true DCB semantics), so a single-tag clause already matches every carrier of
 // the tag regardless of partition — cross-partition reads work without special
 // routing. The flag is accepted for interface parity and ignored.
+// Pure in-memory storageMaker (no BackendState dispatch, no Bus). Backend
+// selection lives in LocalDcbEventLogStorage.Make.
 let make: DcbEventLog_Adapter.storageMaker = (~name, ~indexes, ~partitionTag, ~crossPartitionTagKeys as _=?, ~opts) => {
   let (_, _, storage) = makeStorage(~name, ~indexes, ~partitionTag, ~opts)
   storage
 }
-
-module Make = (Bus: LocalBus.T) => {
-  let make: DcbEventLog_Adapter.storageMaker = (~name, ~indexes, ~partitionTag, ~crossPartitionTagKeys as _=?, ~opts) => {
-    switch BackendState.getDb() {
-    | Some(db) =>
-      let (storageName, read, storage) = DcbEventLogStorage_Sqlite.makeStorage(
-        ~db,
-        ~name,
-        ~indexes,
-        ~partitionTag,
-        ~opts,
-      )
-      Bus.registerDcbEventLogRead(storageName, read)
-      storage
-    | None =>
-      let (storageName, read, storage) = makeStorage(~name, ~indexes, ~partitionTag, ~opts)
-      Bus.registerDcbEventLogRead(storageName, read)
-      storage
-    }
-  }
-}

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs

@@ -6,10 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
-import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
-import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "./DcbEventLogStorage_Sqlite.res.mjs";
 
 function posToInt(pos) {
   return Stdlib_Option.getOr(Stdlib_Int.fromString(pos, undefined), 0);
@@ -146,7 +143,7 @@ function makeStorage(_name, param, param$1, param$2) {
     if (conflictDetected) {
       return {
         TAG: "Error",
-        _0: "conflict: condition check failed"
+        _0: "Conflict"
       };
     }
     let base = events.contents.length;
@@ -194,23 +191,6 @@ function make(name, indexes, partitionTag, param, opts) {
   return makeStorage(name, indexes, partitionTag, opts)[2];
 }
 
-function Make(Bus) {
-  let make = (name, indexes, partitionTag, param, opts) => {
-    let db = BackendState$ReventlessLocal.getDb();
-    if (db !== undefined) {
-      let match = DcbEventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), name, indexes, partitionTag, opts);
-      Bus.registerDcbEventLogRead(match[0], match[1]);
-      return match[2];
-    }
-    let match$1 = makeStorage(name, indexes, partitionTag, opts);
-    Bus.registerDcbEventLogRead(match$1[0], match$1[1]);
-    return match$1[2];
-  };
-  return {
-    make: make
-  };
-}
-
 export {
   posToInt,
   matchesQuery,
@@ -218,6 +198,5 @@ export {
   intersectSorted,
   makeStorage,
   make,
-  Make,
 }
 /* effect/Effect Not a pure module */

package/src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res

@@ -322,7 +322,7 @@ let makeStorage = (
   let append = async (
     newEvents: array<DcbEventLog_Adapter.rawStoredEvent>,
     ~condition=?,
-  ): result<DcbTag.sequencePosition, string> => {
+  ): result<DcbTag.sequencePosition, ReventlessInfra.DcbEventLog.appendError> => {
     let result = ref(Ok(""))
     // (msgId, dcb_event rowid) per inserted event, for the projection
     // checkpoint's DCB-axis pending set. The rowid is read immediately after
@@ -379,17 +379,20 @@ let makeStorage = (
       ProjectionPending.trackAppended(~axis=ProjectionPending.Dcb, appended)
       result.contents
     } catch {
-    | Failure(msg) => Error(msg)
+    // The deliberate append-condition failure throws Failure("conflict: …").
+    | Failure(msg) =>
+      msg->String.includes("conflict")
+        ? Error(ReventlessInfra.DcbEventLog.Conflict)
+        : Error(StorageFailure(msg))
     | exn =>
-      // The deliberate append-condition failure above throws
-      // Failure("conflict: …"); a lost race on the computed position shows up here
-      // as a PRIMARY KEY / UNIQUE violation — also a genuine conflict. Every other
-      // failure (disk full, SQL error, locked db) must surface as a real error,
-      // not the retryable "conflict" sentinel that would be retried forever.
+      // A lost race on the computed position shows up here as a PRIMARY KEY /
+      // UNIQUE violation — also a genuine conflict. Every other failure (disk
+      // full, SQL error, locked db) is a real StorageFailure, not the retryable
+      // Conflict sentinel that would be retried forever.
       let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("")
       msg->String.includes("constraint failed")
-        ? Error("conflict")
-        : Error(msg == "" ? "storage error" : msg)
+        ? Error(ReventlessInfra.DcbEventLog.Conflict)
+        : Error(StorageFailure(msg == "" ? "storage error" : msg))
     }
   }
 
@@ -414,4 +417,4 @@ let makeStorage = (
 }
 
 // No `Make(Bus)` functor here on purpose — dispatch is centralised in
-// DcbEventLogStorage_InMemory.Make so callers only ever wire one module.
+// LocalDcbEventLogStorage.Make so callers only ever wire one module.