@reventlessdev/reventless-local 3.0.0-alpha.183 → 3.0.0-alpha.184

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.184 (2026-07-31)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
 # 3.0.0-alpha.183 (2026-07-30)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.183",
+  "version": "3.0.0-alpha.184",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,17 +34,18 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.25",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.195",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.142",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.59",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.88",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.43",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.113"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.196",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.143",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.44",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.60",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.114",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.89"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/rescript.json

@@ -24,6 +24,7 @@
   ],
   "dependencies": [
     "sury",
+    "@reventlessdev/rescript-node",
     "@reventlessdev/rescript-jest",
     "@reventlessdev/rescript-effect",
     "@reventlessdev/rescript-pulumi-pulumi",

package/src/EmitCapabilities.res

@@ -20,21 +20,6 @@
 // Usage: emit-capabilities <srcDir> [<compositionModule>]
 //   (run from the plugin package, after `rescript build`)
 
-// ── Node ─────────────────────────────────────────────────────────────────────
-
-@module("node:fs") external existsSync: string => bool = "existsSync"
-@module("node:fs") external writeFileSync: (string, string, @as("utf8") _) => unit = "writeFileSync"
-
-@module("node:path") @variadic external join: array<string> => string = "join"
-@module("node:path") @variadic external resolve: array<string> => string = "resolve"
-@module("node:path") @val external sep: string = "sep"
-
-@module("node:url") external pathToFileURL: string => {"href": string} = "pathToFileURL"
-
-@val @scope("process") external argv: array<string> = "argv"
-@val @scope("process") external env: Dict.t<string> = "env"
-@val external processExit: int => unit = "process.exit"
-
 // Emitted by ReScript as a literal `import(...)` expression — the composition
 // root's path is only known at run time, so it cannot be a static binding.
 @val external dynImport: string => promise<'a> = "import"
@@ -56,11 +41,11 @@ type compositionExports = {"Make": platform => builtPlugin}
 let compositionModulePath = (~srcDir: string, ~moduleArg: option<string>): string => {
   let withExtension = name => name->String.endsWith(".mjs") ? name : name ++ ".res.mjs"
   switch moduleArg {
-  | None | Some("") => join([srcDir, "Plugin.res.mjs"])
+  | None | Some("") => NodePath.join([srcDir, "Plugin.res.mjs"])
   | Some(name) =>
-    name->String.includes("/") || name->String.includes(sep)
-      ? resolve([withExtension(name)])
-      : join([srcDir, withExtension(name)])
+    name->String.includes("/") || name->String.includes(NodePath.sep)
+      ? NodePath.resolve([withExtension(name)])
+      : NodePath.join([srcDir, withExtension(name)])
   }
 }
 
@@ -68,25 +53,25 @@ let compositionModulePath = (~srcDir: string, ~moduleArg: option<string>): strin
 
 let fail = (message: string) => {
   Console.error("emit-capabilities: " ++ message)
-  processExit(1)
+  NodeProcess.exit(1)
 }
 
 let main = async () => {
   // The local platform defaults to Debug-level logging; a build step should not.
-  switch env->Dict.get("LOG_LEVEL") {
+  switch NodeProcess.env->Dict.get("LOG_LEVEL") {
   | Some(_) => ()
-  | None => env->Dict.set("LOG_LEVEL", "warn")
+  | None => NodeProcess.env->Dict.set("LOG_LEVEL", "warn")
   }
 
-  switch argv->Array.get(2) {
+  switch NodeProcess.argv->Array.get(2) {
   | None | Some("") => {
       Console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]")
-      processExit(1)
+      NodeProcess.exit(1)
     }
   | Some(srcDirArg) => {
-      let srcDir = resolve([srcDirArg])
-      let modulePath = compositionModulePath(~srcDir, ~moduleArg=argv->Array.get(3))
-      if !existsSync(modulePath) {
+      let srcDir = NodePath.resolve([srcDirArg])
+      let modulePath = compositionModulePath(~srcDir, ~moduleArg=NodeProcess.argv->Array.get(3))
+      if !NodeFs.existsSync(modulePath) {
         fail(`${modulePath} not found — run \`rescript build\` first.`)
       }
 
@@ -95,11 +80,11 @@ let main = async () => {
       let platformModule: localPlatformExports = await dynImport("./Platform.res.mjs")
       let platform = platformModule["Make"]()
 
-      let composition: compositionExports = await dynImport(pathToFileURL(modulePath)["href"])
+      let composition: compositionExports = await dynImport(NodeUrl.pathToFileURL(modulePath)["href"])
       let built = composition["Make"](platform)
 
-      let manifestPath = join([srcDir, "capabilities.json"])
-      writeFileSync(
+      let manifestPath = NodePath.join([srcDir, "capabilities.json"])
+      NodeFs.writeFileSync(
         manifestPath,
         Reventless.CapabilityManifest.renderForStructure(built["pluginStructure"]),
       )
@@ -107,7 +92,7 @@ let main = async () => {
 
       // Applying the platform functor wires in-process infrastructure; exit
       // explicitly so no lingering handle keeps the build step alive.
-      processExit(0)
+      NodeProcess.exit(0)
     }
   }
 }

package/src/Platform.res

@@ -821,15 +821,14 @@ module MakeWithConfig = (
     component->ReventlessCore.Component.operations
   }
 
-  @val external processEnv: dict<string> = "process.env"
-  let graphqlDebug = processEnv->Dict.get("GRAPHQL_DEBUG")->Option.isSome
+  let graphqlDebug = NodeProcess.env->Dict.get("GRAPHQL_DEBUG")->Option.isSome
 
   // Per-session server ports for the VS Code local platform runner (features
   // plan Phase 9). The runner spawns one platform child per app folder; default
   // ports (4000/4001/3001/3002) collide when several run, so each is overridable
   // via env. Defaults preserve today's behaviour for all non-runner callers.
   let resolvePort = (key, fallback) =>
-    processEnv->Dict.get(key)->Option.flatMap(v => Int.fromString(v))->Option.getOr(fallback)
+    NodeProcess.env->Dict.get(key)->Option.flatMap(v => Int.fromString(v))->Option.getOr(fallback)
   let domainPort = resolvePort("REVENTLESS_DOMAIN_PORT", 4000)
   let domainMcpPort = resolvePort("REVENTLESS_DOMAIN_MCP_PORT", 3001)
   let platformPort = resolvePort("REVENTLESS_PLATFORM_PORT", 4001)

package/src/adapter/Auth/LocalAuth.res

@@ -95,24 +95,15 @@ module Login = {
   // after a backend reload. When unset, falls back to a random per-process
   // secret — secure for ephemeral test runs but invalidates every previously
   // issued token on every restart.
-  type buf
-  @module("node:crypto") external _randomBytes: int => buf = "randomBytes"
-  @send external _bufToString: (buf, string) => string = "toString"
-  type hmac
-  @module("node:crypto") external _createHmac: (string, string) => hmac = "createHmac"
-  @send external _update: (hmac, string) => hmac = "update"
-  @send external _digest: (hmac, string) => string = "digest"
-
-  @val external _processEnv: Dict.t<string> = "process.env"
 
   let _secret: ref<option<string>> = ref(None)
   let _getSecret = (): string =>
     switch _secret.contents {
     | Some(s) => s
     | None =>
-      let s = switch _processEnv->Dict.get("REVENTLESS_INMEMORY_TOKEN_SECRET") {
+      let s = switch NodeProcess.env->Dict.get("REVENTLESS_INMEMORY_TOKEN_SECRET") {
       | Some(envSecret) if String.length(envSecret) >= 16 => envSecret
-      | _ => _randomBytes(32)->_bufToString("hex")
+      | _ => NodeCrypto.randomBytes(32)->NodeCrypto.bufferToString("hex")
       }
       _secret := Some(s)
       s
@@ -121,7 +112,9 @@ module Login = {
   let setTokenSecret = (s: string): unit => _secret := Some(s)
 
   let _sign = (payload: string): string =>
-    _createHmac("sha256", _getSecret())->_update(payload)->_digest("base64url")
+    NodeCrypto.createHmac("sha256", _getSecret())
+    ->NodeCrypto.hmacUpdate(payload)
+    ->NodeCrypto.hmacDigest("base64url")
 
   // base64url over arbitrary JSON strings: btoa-encode + URL-safe alphabet,
   // strip `=` padding. Avoids pulling in Buffer for a single-line conversion.

package/src/adapter/Auth/UserStore.res

@@ -26,10 +26,6 @@ type entry = {
 // ── YAML parsing (eemeli/yaml) ──────────────────────────────────────────────
 
 @module("yaml") external _yamlParse: string => unknown = "parse"
-@module("node:fs") external _readFileSync: (string, string) => string = "readFileSync"
-@module("node:fs") external _existsSync: string => bool = "existsSync"
-@module("node:path") external _join: (string, string) => string = "join"
-@val external _processCwd: unit => string = "process.cwd"
 
 let _entriesSchema = S.array(entrySchema)
 
@@ -46,7 +42,7 @@ let parseString = (yamlText: string): result<array<entry>, string> =>
 /** Reads + parses a YAML file. */
 let parseFile = (path: string): result<array<entry>, string> =>
   try {
-    let text = _readFileSync(path, "utf8")
+    let text = NodeFs.readFileSync(path)
     parseString(text)
   } catch {
   | JsExn(err) => Error(JsExn.message(err)->Option.getOr(`Cannot read ${path}`))
@@ -66,7 +62,7 @@ let _registerEntries = (entries: array<entry>): unit =>
     LocalAuth.Login.setCredentials(~username, ~password, ~identity=id)
   })
 
-let _defaultPath = (): string => _join(_processCwd(), ".reventless/users.yaml")
+let _defaultPath = (): string => NodePath.join([NodeProcess.cwd(), ".reventless/users.yaml"])
 
 /**
  * Hydrates the Login store. Returns the resolution path actually used
@@ -106,7 +102,7 @@ let load = (
       })
     | None =>
       let defaultPath = _defaultPath()
-      if _existsSync(defaultPath) {
+      if NodeFs.existsSync(defaultPath) {
         parseFile(defaultPath)->Result.map(entries => {
           _registerEntries(entries)
           DefaultFile(defaultPath)

package/src/adapter/Auth/UserStore.res.mjs

@@ -106,7 +106,7 @@ function load(users, usersFile, param) {
       };
     });
   }
-  let defaultPath = Nodepath.join(process.cwd(), ".reventless/users.yaml");
+  let defaultPath = _defaultPath();
   if (Nodefs.existsSync(defaultPath)) {
     return Stdlib_Result.map(parseFile(defaultPath), entries => {
       _registerEntries(entries);

package/src/adapter/Backend.res

@@ -34,13 +34,11 @@ let postgres = async (~connection, ~resetOnStart=false) => {
   Postgres({pool, initialCount, connection})
 }
 
-@val external processEnv: dict<string> = "process.env"
 
 // Deletes a file if it exists. No-op if the path is missing.
-@module("node:fs") external _unlinkSync: string => unit = "unlinkSync"
 
 let removeFileIfExists = (path: string) =>
-  try _unlinkSync(path) catch {
+  try NodeFs.unlinkSync(path) catch {
   | _ => ()
   }
 
@@ -50,7 +48,7 @@ let removeFileIfExists = (path: string) =>
 //   memory                   — explicit Memory selector
 // Anything else (including unset) yields Memory.
 let fromEnv = () =>
-  switch processEnv->Dict.get("REVENTLESS_LOCAL_BACKEND") {
+  switch NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND") {
   | None => Memory
   | Some(raw) =>
     let trimmed = raw->String.trim

package/src/adapter/DomainGraphQL_Server.res

@@ -37,7 +37,6 @@ type nodeResponse
 // 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("")
@@ -155,7 +154,7 @@ let handleUploadPresign = (req: nodeRequest, res: nodeResponse): unit =>
       }
     let fileName =
       parsed->Dict.get("fileName")->Option.flatMap(JSON.Decode.string)->Option.getOr("upload")
-    let ref = `/${LocalObjectStore.defaultUploadPrefix}/${randomUUID()}/${fileName}`
+    let ref = `/${LocalObjectStore.defaultUploadPrefix}/${NodeCrypto.randomUUID()}/${fileName}`
     _writeJson(
       res,
       ~status=200,
@@ -496,8 +495,7 @@ let buildNodeResolver = (): option<(string, resolverFn)> =>
 
 // -- Server lifecycle ------------------------------------------------------
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("GRAPHQL_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("GRAPHQL_DEBUG")->Option.isSome
 
 let activeServer: ref<option<YG.httpServer>> = ref(None)
 let activeSchema: ref<option<YG.schema>> = ref(None)

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -2,11 +2,11 @@
 
 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";
 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";
@@ -117,7 +117,7 @@ function handleUploadPresign(req, res) {
       parsed = {};
     }
     let fileName = Stdlib_Option.getOr(Stdlib_Option.flatMap(parsed["fileName"], Stdlib_JSON.Decode.string), "upload");
-    let ref = `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Crypto.randomUUID() + `/` + fileName;
+    let ref = `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Nodecrypto.randomUUID() + `/` + fileName;
     _writeJson(res, 200, Object.fromEntries([
       [
         "uploadUrl",

package/src/adapter/DomainMCP_Server.res

@@ -132,8 +132,7 @@ let registerEventHistoryResourcesFromEntries = (
 
 let activeServer: ref<option<McpSdk.httpServer>> = ref(None)
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("MCP_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("MCP_DEBUG")->Option.isSome
 
 // Extract identity from an HTTP IncomingMessage via the X-Identity header.
 // Falls back to Identity.anonymous when the header is absent or malformed.

package/src/adapter/LocalBus.res

@@ -98,10 +98,9 @@ let makeStateChangeDescriptor = (
 // so the runner's line parser can pick it out of the platform's ANSI log noise on
 // stdout. The emit is a plain Console.log, so it never perturbs publishEvent's
 // subscriber-countdown delivery semantics.
-@val external tapProcessEnv: dict<string> = "process.env"
 // Read per publish (not once at import) so the runner can toggle it live and so
 // hermetic tests can flip it between cases. The cost is one dict lookup per event.
-let eventTapEnabled = () => tapProcessEnv->Dict.get("REVENTLESS_EVENT_TAP")->Option.isSome
+let eventTapEnabled = () => NodeProcess.env->Dict.get("REVENTLESS_EVENT_TAP")->Option.isSome
 let eventTapSeq = ref(0)
 // Seed the in-memory tap counter from a persistent store's existing event count
 // so the timeline's #N continues across process restarts / app switches instead

package/src/adapter/MCP_ServerInstance.res

@@ -51,8 +51,7 @@ type t = {
   printDiagnostics: unit => unit,
 }
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("MCP_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("MCP_DEBUG")->Option.isSome
 
 let make = (~label: string="MCP"): t => {
   let tools: ref<dict<registeredTool>> = ref(Dict.make())

package/src/adapter/SqliteDriver.res

@@ -7,10 +7,6 @@ type statement
 @module("node:sqlite") @new
 external openDatabaseSync: string => t = "DatabaseSync"
 
-@module("node:path") external dirname: string => string = "dirname"
-type mkdirOpts = {recursive: bool}
-@module("node:fs") external mkdirSync: (string, mkdirOpts) => unit = "mkdirSync"
-
 @send external _close: t => unit = "close"
 @send external _exec: (t, string) => unit = "exec"
 @send external _prepare: (t, string) => statement = "prepare"
@@ -25,7 +21,7 @@ let _iterateApply: (statement, array<JSON.t>) => Iterator.t<dict<JSON.t>> = %raw
 
 let openDb = (~path) => {
   if path !== ":memory:" {
-    mkdirSync(dirname(path), {recursive: true})
+    NodeFs.mkdirSync(NodePath.dirname(path), {recursive: true})
   }
   let db = openDatabaseSync(path)
   // Connection pragmas. WAL lets readers proceed concurrently with a writer and

package/tests/adapter/BackendParityTest.res

@@ -10,13 +10,12 @@
 
 open JestGlobals
 
-@val external processEnv: dict<string> = "process.env"
 
 let _ = TestRunner.setup()
 let opts: Pulumi.CustomResourceOptions.t = {}
 
 let pgPool =
-  processEnv
+  NodeProcess.env
   ->Dict.get("PG_URL")
   ->Option.map(url => ReventlessPostgres.PgDriver.makePool({connectionString: url}))
 

package/tests/adapter/EventTapTest.res

@@ -17,7 +17,6 @@ let defaultMeta: Reventless.Message.meta = {
   correlationId: "",
 }
 
-@val external processEnv: Dict.t<string> = "process.env"
 
 type consoleObj = {mutable log: string => unit}
 @val external console: consoleObj = "console"
@@ -48,7 +47,7 @@ let tapLines = (logs: array<string>): array<string> =>
 
 describe("LocalBus event tap (Phase 9)", () => {
   // Each test owns the env flag; always clear it afterwards so cases don't leak.
-  let clearEnv = () => processEnv->Dict.delete("REVENTLESS_EVENT_TAP")
+  let clearEnv = () => NodeProcess.env->Dict.delete("REVENTLESS_EVENT_TAP")
 
   testPromise("tap off → no sentinel line is emitted", async () => {
     clearEnv()
@@ -60,7 +59,7 @@ describe("LocalBus event tap (Phase 9)", () => {
   })
 
   testPromise("tap on → one well-formed line per published event", async () => {
-    processEnv->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
+    NodeProcess.env->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
     module TestBus = LocalBus.MakeSilent()
     let logs = await captureLogs(async () => {
       await TestBus.publishEvent(
@@ -90,7 +89,7 @@ describe("LocalBus event tap (Phase 9)", () => {
   })
 
   testPromise("tap emits even when the topic has no subscribers", async () => {
-    processEnv->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
+    NodeProcess.env->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
     module TestBus = LocalBus.MakeSilent()
     let logs = await captureLogs(async () => {
       // No subscribeToEvents call — the tap fires before the subscriber-count gate.

package/tests/adapter/LocalAuthUserStoreTest.res

@@ -4,11 +4,6 @@
 
 open JestGlobals
 
-@module("node:fs") external _writeFileSync: (string, string, string) => unit = "writeFileSync"
-@module("node:fs") external _mkdtempSync: string => string = "mkdtempSync"
-@module("node:fs") external _rmSync: (string, {..}) => unit = "rmSync"
-@module("node:path") external _join: (string, string) => string = "join"
-@module("node:os") external _tmpdir: unit => string = "tmpdir"
 
 let resetAll = () => {
   LocalAuth.resetUsers()
@@ -17,9 +12,9 @@ let resetAll = () => {
 }
 
 let _writeYamlFile = (contents: string): string => {
-  let dir = _mkdtempSync(_join(_tmpdir(), "reventless-userstore-"))
-  let path = _join(dir, "users.yaml")
-  _writeFileSync(path, contents, "utf8")
+  let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-userstore-"]))
+  let path = NodePath.join([dir, "users.yaml"])
+  NodeFs.writeFileSync(path, contents)
   path
 }
 
@@ -102,7 +97,7 @@ testPromise("load(~usersFile) reads a YAML file from disk", async () => {
   | Ok(_) => ()
   | Error(msg) => JsError.throwWithMessage("issue rejected file-loaded credentials: " ++ msg)
   }
-  _rmSync(path, {"force": true})
+  NodeFs.rmSync(path, {force: true})
 })
 
 testPromise("load(~usersFile) returns Error when the file is missing", async () => {
@@ -152,7 +147,7 @@ testPromise("inline users win over a file path", async () => {
   | Some(_) => ()
   | None => JsError.throwWithMessage("inline-user missing from registry")
   }
-  _rmSync(path, {"force": true})
+  NodeFs.rmSync(path, {force: true})
 })
 
 testPromise("autoLoadOnce is a no-op after an explicit load", async () => {

package/tests/adapter/PgProjectionCatchupTest.res

@@ -10,7 +10,6 @@
 
 open JestGlobals
 
-@val external processEnv: dict<string> = "process.env"
 let opts: Pulumi.CustomResourceOptions.t = {}
 
 // Flat stored aggregate event — the exact shape EventLog_Operations.encodeEvent'
@@ -58,7 +57,7 @@ let recorder = () => {
   (received, handler)
 }
 
-switch processEnv->Dict.get("PG_URL") {
+switch NodeProcess.env->Dict.get("PG_URL") {
 | None => testSync("Postgres projection catch-up (skipped — set PG_URL)", () => expect(true)->toBe(true))
 | Some(url) =>
   let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})

package/tests/adapter/SqliteDriverTest.res

@@ -64,23 +64,23 @@ describe("SqliteDriver", () => {
 
   testPromise("Backend.fromEnv parses sqlite path and reset flag", async () => {
     let originalEnv =
-      Backend.processEnv->Dict.get("REVENTLESS_LOCAL_BACKEND")
+      NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND")
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
     let parsed = Backend.fromEnv()
     expect(parsed)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: false}))
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db?reset")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db?reset")
     let parsedReset = Backend.fromEnv()
     expect(parsedReset)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: true}))
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "memory")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "memory")
     let parsedMem = Backend.fromEnv()
     expect(parsedMem)->toEqual(Backend.Memory)
 
     switch originalEnv {
-    | Some(v) => Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", v)
-    | None => Backend.processEnv->Dict.delete("REVENTLESS_LOCAL_BACKEND")
+    | Some(v) => NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", v)
+    | None => NodeProcess.env->Dict.delete("REVENTLESS_LOCAL_BACKEND")
     }
   })
 })