@reventlessdev/reventless-local 3.0.0-alpha.244 → 3.0.0-alpha.245

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 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.245 (2026-09-04)
+
+### Bug Fixes
+
+* **logging:** let a runtime declare whether a person reads its logs ([df7a6cb](https://github.com/ReventlessDev/reventless-core/commit/df7a6cbdff62b856ea6b9d1f169b913563ba13a1))
+### Features
+
+* **local:** one platform per app directory, and a reset that refuses a served store ([e0fd219](https://github.com/ReventlessDev/reventless-core/commit/e0fd219a8c1bbda85589374ffa75aaab0f3e4fda))
+* **local:** serve the event tap over a socket, on by default ([1babf96](https://github.com/ReventlessDev/reventless-core/commit/1babf960f032805418e3ac8f25d03ceb3dcd8d20))
+
+
 # 3.0.0-alpha.244 (2026-09-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.244",
+  "version": "3.0.0-alpha.245",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,18 +35,18 @@
     "sury": "11.0.0-rc.2",
     "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.27",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.9",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.255",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.202",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.156",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.103",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.119",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.128",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.18"
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.104",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.203",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.256",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.157",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.19",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.129",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.120"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/LocalPlatformRegistry.res

@@ -1,38 +1,14 @@
-// Where the local platforms running on this machine say who they are.
-//
-// A platform's store is otherwise invisible from outside its own process, so
-// every tool that wants to act on "the" store — `seed`, `seed:reset`, a `sqlite3`
-// poke — has to guess from its own environment. The guess is right exactly while
-// there is one platform and wrong exactly when there are two, which is the case
-// the tools exist for: a hand-started `pnpm run serve` on `local.db` beside the
-// VS Code runner's child on `runner.db`, same app, same directory. Both then
-// report success against different databases — a reset that empties an unserved
-// store, and a seed that refuses because the served one is full.
-//
-// So a platform publishes itself instead: one JSON entry per run, next to the
-// store it opened, removed on the way out. `LocalSeedTarget` turns that into the
-// answer to "which platform do you mean".
-//
-// ── Why one file per port ──────────────────────────────────────────────────
-//
-// The pair that broke is two platforms of the SAME app in the SAME package
-// directory, which is precisely what a single `platform.json` cannot represent.
-// The domain port is what already distinguishes them (`REVENTLESS_DOMAIN_PORT`,
-// added so the runner could start one child per app without colliding), so it
-// names the file.
-//
-// ── Why the path is absolute ───────────────────────────────────────────────
-//
-// `./.reventless/local.db` names a different file in every app. Relative to the
-// writer's cwd it is unambiguous and outside it means nothing, so the entry
-// carries the path `BackendState` resolved, not the env string it came from.
+// Where the local platforms running on this machine say who they are: one JSON
+// entry per run under `<cwd>/.reventless/running/<domainPort>.json`, removed on
+// exit. Keyed by domain port because the pair that broke is two platforms of the
+// SAME app in one directory. Paths are absolute — `./.reventless/local.db` names
+// a different file in every app. `LocalSeedTarget` turns this into the answer to
+// "which platform do you mean".
 
 @schema
 type store = {
-  // "sqlite" | "memory" | "postgres" — what a reader can DO with this platform's
-  // store, not which module implements it. A `:memory:` SQLite file reports
-  // "memory": it has nothing on disk to open, which is the only distinction a
-  // tool acting from outside can act on.
+  // What a reader can DO with the store, not which module implements it —
+  // "sqlite" | "memory" | "postgres". A `:memory:` SQLite file reports "memory".
   kind: string,
   // Some only for a store this machine can open by name.
   path: option<string>,
@@ -47,20 +23,21 @@ type entry = {
   loginEndpoint: string,
   store: store,
   startedAt: string,
+  // Where the NDJSON event tap is served, when it is. Must stay optional: `list`
+  // DELETES an entry it cannot decode, so requiring it would silently hide every
+  // platform from an older build. Absent ⇒ stdout only.
+  tapPort?: int,
 }
 
-// `~cwd` is the directory the platform was started from, which is where its
-// `.reventless/` already lives. Threaded rather than read at each use so the
-// tests can exercise a registry without moving the whole process.
+// Threaded rather than read at each use, so tests need not move the process.
 let runningDir = (~cwd=NodeProcess.cwd(), ()): string =>
   NodePath.join([cwd, ".reventless", "running"])
 
 let entryPath = (~port: int, ~cwd=NodeProcess.cwd()): string =>
   NodePath.join([runningDir(~cwd, ()), `${port->Int.toString}.json`])
 
-// The package this platform was started from, for the prompt line. Two platforms
-// of one app are told apart by port; the name is there for the case where they
-// are different apps and the port alone reads as an arbitrary number.
+// The package name, for the prompt line — port alone reads as an arbitrary
+// number when the platforms are different apps.
 let appName = (~cwd=NodeProcess.cwd(), ()): string => {
   let manifest = NodePath.join([cwd, "package.json"])
   let fromManifest = if NodeFs.existsSync(manifest) {
@@ -85,11 +62,8 @@ let removeQuietly = (path: string): unit =>
   | _ => ()
   }
 
-/** Whether a process is still there. Signal `0` performs no signalling — it only
-    runs the permission and existence checks and throws when either fails.
-
-    Liveness by pid rather than by probing the endpoint keeps this synchronous,
-    and prunes a wedged platform that holds its port but would never answer. */
+/** Signal `0` signals nothing — it runs the existence/permission checks and
+    throws when either fails. By pid, so a wedged platform is pruned too. */
 let alive = (pid: int): bool =>
   try {
     NodeProcess.kill(pid, 0)
@@ -103,12 +77,8 @@ let readEntry = (path: string): option<entry> =>
   | _ => None
   }
 
-/** Every platform currently running in this directory, oldest port first.
-
-    Removal on exit is best-effort — a `kill -9` leaves the entry behind — so
-    staleness is settled here, on read: an entry whose process is gone is deleted
-    rather than reported. A reader that trusted the file would offer a platform
-    nothing is serving, which is the failure this module exists to remove. */
+/** Every platform running here, lowest port first. Removal on exit is
+    best-effort (`kill -9`), so a dead entry is deleted here, on read. */
 let list = (~cwd=NodeProcess.cwd(), ()): array<entry> => {
   let dir = runningDir(~cwd, ())
   if !NodeFs.existsSync(dir) {
@@ -132,14 +102,14 @@ let list = (~cwd=NodeProcess.cwd(), ()): array<entry> => {
   }
 }
 
-/** Writes one entry and hands back the path it wrote, without touching the
-    process. Split from {!register} so a test can populate a registry without
-    installing exit handlers in the test runner. */
+/** Writes one entry and returns its path. Split from {!register} so a test can
+    populate a registry without installing exit handlers in the runner. */
 let write = (
   ~port: int,
   ~endpoint: string,
   ~loginEndpoint: string,
   ~store: store,
+  ~tapPort: option<int>=?,
   ~pid: int=NodeProcess.pid,
   ~cwd: string=NodeProcess.cwd(),
 ): string => {
@@ -152,6 +122,7 @@ let write = (
     loginEndpoint,
     store,
     startedAt: Date.make()->Date.toISOString,
+    ?tapPort,
   }
   try {
     NodeFs.mkdirSync(runningDir(~cwd, ()), {recursive: true})
@@ -160,23 +131,43 @@ let write = (
       entry->Reventless.Util_Sury.toJson(entrySchema)->JSON.stringify(~space=2),
     )
   } catch {
-  // A platform that cannot announce itself must still serve. The tools fall back
-  // to their endpoint default, which is what they did before this existed.
+  // A platform that cannot announce itself must still serve.
   | _ => ()
   }
   path
 }
 
-/** Publishes this process, and arranges for it to stop being published.
+/** Adds the tap port to an entry already written.
+
+    Separate from {!write} because the socket binds asynchronously: the entry is
+    published as soon as the servers are up, and this fills in the port once
+    `listen` calls back. So the entry only ever names a port that is genuinely
+    listening. A no-op when there is no entry to update. */
+let publishTapPort = (~port: int, ~tapPort: int, ~cwd=NodeProcess.cwd()): unit => {
+  let path = entryPath(~port, ~cwd)
+  switch readEntry(path) {
+  | None => ()
+  | Some(entry) =>
+    try NodeFs.writeFileSync(
+      path,
+      {...entry, tapPort}->Reventless.Util_Sury.toJson(entrySchema)->JSON.stringify(~space=2),
+    ) catch {
+    | _ => ()
+    }
+  }
+}
 
-    Both shutdown paths are covered because they are not the same event: `exit`
-    fires with the process already committed to leaving and may only do
-    synchronous work, while `SIGINT`/`SIGTERM` fire before that decision — and
-    registering a signal handler at all is what suppresses Node's default exit,
-    so each one has to leave explicitly (128 + signal number, as a shell reports
-    it). */
-let register = (~port: int, ~endpoint: string, ~loginEndpoint: string, ~store: store): unit => {
-  let path = write(~port, ~endpoint, ~loginEndpoint, ~store)
+/** Publishes this process, and unpublishes it on the way out. Both paths are
+    needed: `exit` is sync-only, and registering a signal handler suppresses
+    Node's default exit, so each signal must leave explicitly. */
+let register = (
+  ~port: int,
+  ~endpoint: string,
+  ~loginEndpoint: string,
+  ~store: store,
+  ~tapPort: option<int>=?,
+): unit => {
+  let path = write(~port, ~endpoint, ~loginEndpoint, ~store, ~tapPort?)
   NodeProcess.onExit(_ => removeQuietly(path))
   NodeProcess.onSignal(#SIGINT, () => {
     removeQuietly(path)

package/src/LocalPlatformRegistry.res.mjs

@@ -21,7 +21,8 @@ let entrySchema = Sury.$schema(s => ({
   endpoint: s.m(Sury.string),
   loginEndpoint: s.m(Sury.string),
   store: s.m(storeSchema),
-  startedAt: s.m(Sury.string)
+  startedAt: s.m(Sury.string),
+  tapPort: s.m(Sury.$option(Sury.int))
 }));
 
 function runningDir(cwdOpt, param) {
@@ -108,7 +109,7 @@ function list(cwdOpt, param) {
   }).toSorted((a, b) => Primitive_int.compare(a.port, b.port));
 }
 
-function write(port, endpoint, loginEndpoint, store, pidOpt, cwdOpt) {
+function write(port, endpoint, loginEndpoint, store, tapPort, pidOpt, cwdOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
   let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
   let path = entryPath(port, cwd);
@@ -121,7 +122,8 @@ function write(port, endpoint, loginEndpoint, store, pidOpt, cwdOpt) {
     endpoint: endpoint,
     loginEndpoint: loginEndpoint,
     store: store,
-    startedAt: entry_startedAt
+    startedAt: entry_startedAt,
+    tapPort: tapPort
   };
   try {
     Nodefs.mkdirSync(runningDir(cwd, undefined), {
@@ -134,8 +136,24 @@ function write(port, endpoint, loginEndpoint, store, pidOpt, cwdOpt) {
   return path;
 }
 
-function register(port, endpoint, loginEndpoint, store) {
-  let path = write(port, endpoint, loginEndpoint, store, undefined, undefined);
+function publishTapPort(port, tapPort, cwdOpt) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  let path = entryPath(port, cwd);
+  let entry = readEntry(path);
+  if (entry === undefined) {
+    return;
+  }
+  try {
+    let newrecord = {...entry};
+    Nodefs.writeFileSync(path, JSON.stringify(Util_Sury$Reventless.toJson((newrecord.tapPort = tapPort, newrecord), entrySchema), undefined, 2), "utf8");
+    return;
+  } catch (exn) {
+    return;
+  }
+}
+
+function register(port, endpoint, loginEndpoint, store, tapPort) {
+  let path = write(port, endpoint, loginEndpoint, store, tapPort, undefined, undefined);
   process.on("exit", param => removeQuietly(path));
   process.on("SIGINT", () => {
     removeQuietly(path);
@@ -158,6 +176,7 @@ export {
   readEntry,
   list,
   write,
+  publishTapPort,
   register,
 }
 /* storeSchema Not a pure module */

package/src/LocalPlatformStart.res

@@ -0,0 +1,84 @@
+// What a starter asks the registry before it starts a local platform: whether a
+// reset would wipe a store something is serving, and whether to start at all.
+// Scoped to <cwd>/.reventless/running/, so another app's store file is not
+// covered. See docs/plans/done/one-local-platform-one-store.md.
+
+// Naming a port IS the statement that this platform is meant to coexist — the
+// escape hatch the runner and the e2e suites already take.
+let bypassEnv = "REVENTLESS_DOMAIN_PORT"
+
+let envNamed = (key: string): bool =>
+  switch NodeProcess.env->Dict.get(key) {
+  | Some(v) if v->String.trim != "" => true
+  | _ => false
+  }
+
+type decision =
+  | Start
+  | AlreadyRunning(array<LocalPlatformRegistry.entry>)
+
+/** Whether this process should go on to build a platform. `~cwd` is threaded so a
+    test can exercise a registry without moving the whole process. */
+let decide = (~cwd=NodeProcess.cwd(), ()): decision =>
+  if envNamed(bypassEnv) {
+    Start
+  } else {
+    switch LocalPlatformRegistry.list(~cwd, ()) {
+    | [] => Start
+    | entries => AlreadyRunning(entries)
+    }
+  }
+
+// Through LocalSeedTarget, so the starters and the seed tools describe the same
+// platform the same way.
+let entryLine = (e: LocalPlatformRegistry.entry): string =>
+  `→ already running at :${e.port->Int.toString}  ·  ${e.store->LocalSeedTarget.storeLabel}  (pid ${e.pid->Int.toString})`
+
+/** What {!orAddressRunning} prints. Separate from the exit so it is testable. */
+let report = (entries: array<LocalPlatformRegistry.entry>): array<string> =>
+  switch entries {
+  | [e] => [e->entryLine, `  nothing started — ${e.endpoint} is serving this directory.`]
+  | entries =>
+    Array.concat(
+      [`→ ${entries->Array.length->Int.toString} platforms are already running in this directory:`],
+      entries->Array.map(entryLine),
+    )->Array.concat(["  nothing started — stop the ones you do not want, then start again."])
+  }
+
+/** The live platform serving this store file, if one is. Resolved against this
+    process's cwd, because the registry's paths are absolute. */
+let servedBy = (~path: string, ~cwd=NodeProcess.cwd(), ()): option<
+  LocalPlatformRegistry.entry,
+> => {
+  let resolved = NodePath.resolve([path])
+  LocalPlatformRegistry.list(~cwd, ())->Array.find(e => e.store.path == Some(resolved))
+}
+
+let refusalMessage = (~path: string, e: LocalPlatformRegistry.entry): string =>
+  `refusing to reset ${path}: it is the store of ${e.app} running at :${e.port->Int.toString} (pid ${e.pid->Int.toString}). ` ++
+  `Stop that platform first, or start this one without ?reset.`
+
+/** Throws rather than letting a reset unlink a store something is serving. Always
+    on: it must protect an app that never calls {!orAddressRunning}. */
+let guardReset = (~path: string, ~cwd=NodeProcess.cwd(), ()): unit =>
+  switch servedBy(~path, ~cwd, ()) {
+  | Some(e) => JsError.throwWithMessage(refusalMessage(~path, e))
+  | None => ()
+  }
+
+/** Start, or address the one already running. An app's `Main.res` calls this as
+    its first line, before `Platform.Make()`. */
+let orAddressRunning = (~cwd=NodeProcess.cwd(), ()): unit => {
+  // The reset is checked first and throws: exit 0 is for a start that was merely
+  // redundant, never for a destructive one that did not happen.
+  switch Backend.fromEnv() {
+  | Backend.Sqlite({path, resetOnStart: true}) => guardReset(~path, ~cwd, ())
+  | Backend.Sqlite(_) | Backend.Memory | Backend.Postgres(_) => ()
+  }
+  switch decide(~cwd, ()) {
+  | Start => ()
+  | AlreadyRunning(entries) =>
+    report(entries)->Array.forEach(Console.log)
+    NodeProcess.exit(0)
+  }
+}

package/src/LocalPlatformStart.res.mjs

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Backend$ReventlessLocal from "./adapter/Backend.res.mjs";
+import * as LocalSeedTarget$ReventlessLocal from "./LocalSeedTarget.res.mjs";
+import * as LocalPlatformRegistry$ReventlessLocal from "./LocalPlatformRegistry.res.mjs";
+
+let bypassEnv = "REVENTLESS_DOMAIN_PORT";
+
+function envNamed(key) {
+  let v = process.env[key];
+  if (v !== undefined) {
+    return v.trim() !== "";
+  } else {
+    return false;
+  }
+}
+
+function decide(cwdOpt, param) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  if (envNamed(bypassEnv)) {
+    return "Start";
+  }
+  let entries = LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined);
+  if (entries.length !== 0) {
+    return {
+      TAG: "AlreadyRunning",
+      _0: entries
+    };
+  } else {
+    return "Start";
+  }
+}
+
+function entryLine(e) {
+  return `→ already running at :` + e.port.toString() + `  ·  ` + LocalSeedTarget$ReventlessLocal.storeLabel(e.store) + `  (pid ` + e.pid.toString() + `)`;
+}
+
+function report(entries) {
+  if (entries.length !== 1) {
+    return [`→ ` + entries.length.toString() + ` platforms are already running in this directory:`].concat(entries.map(entryLine)).concat(["  nothing started — stop the ones you do not want, then start again."]);
+  }
+  let e = entries[0];
+  return [
+    entryLine(e),
+    `  nothing started — ` + e.endpoint + ` is serving this directory.`
+  ];
+}
+
+function servedBy(path, cwdOpt, param) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  let resolved = Nodepath.resolve(path);
+  return LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined).find(e => Primitive_object.equal(e.store.path, resolved));
+}
+
+function refusalMessage(path, e) {
+  return `refusing to reset ` + path + `: it is the store of ` + e.app + ` running at :` + e.port.toString() + ` (pid ` + e.pid.toString() + `). Stop that platform first, or start this one without ?reset.`;
+}
+
+function guardReset(path, cwdOpt, param) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  let e = servedBy(path, cwd, undefined);
+  if (e !== undefined) {
+    return Stdlib_JsError.throwWithMessage(refusalMessage(path, e));
+  }
+}
+
+function orAddressRunning(cwdOpt, param) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  let match = Backend$ReventlessLocal.fromEnv();
+  if (typeof match === "object" && match.TAG === "Sqlite") {
+    if (match.resetOnStart) {
+      guardReset(match.path, cwd, undefined);
+    }
+  }
+  let entries = decide(cwd, undefined);
+  if (typeof entries !== "object") {
+    return;
+  }
+  report(entries._0).forEach(prim => {
+    console.log(prim);
+  });
+  process.exit(0);
+}
+
+export {
+  bypassEnv,
+  envNamed,
+  decide,
+  entryLine,
+  report,
+  servedBy,
+  refusalMessage,
+  guardReset,
+  orAddressRunning,
+}
+/* node:path Not a pure module */

package/src/Platform.res

@@ -17,6 +17,12 @@ let _ = ReventlessCore.EffectLogger.install
 // LOG_LEVEL env var still overrides this (e.g. LOG_LEVEL=info or =silent).
 ReventlessCore.EffectLogger.setDefaultMinLevel(ReventlessCore.Logger.Debug)
 
+// Same reasoning, for the format: a person reads these logs, including when
+// `dev:full`'s concurrently, `serve:watch`'s tsx or an IDE pipes them — which is
+// where the TTY probe alone concludes "log collector" and emits JSON. An explicit
+// REVENTLESS_LOG_FORMAT still wins.
+Reventless.AnsiStyle.setDefaultFormat(#text)
+
 let log = ReventlessCore.Logger.fromEnv()
 
 // Module-level ref to hold the platform GraphQL server instance in split mode.
@@ -114,6 +120,10 @@ module MakeWithConfig = (
   // full replay needs no checkpoint.
   | Backend.Sqlite({path, resetOnStart}) =>
     if resetOnStart {
+      // Before the unlink: the ports are bound at the very end of construction,
+      // so a second `serve:reset` used to wipe a served store and only then
+      // discover it could not listen.
+      LocalPlatformStart.guardReset(~path, ())
       Backend.removeFileIfExists(path)
     }
     let db = SqliteDriver.openDb(~path)
@@ -1316,6 +1326,12 @@ module MakeWithConfig = (
       ~loginEndpoint=`http://localhost:${domainPort->Int.toString}/__inmemory/login`,
       ~store={kind, path},
     )
+    // After the register, and it fills the tap port in once the socket is bound:
+    // the port is ephemeral by default, so it is not known until `listen` calls
+    // back. The entry therefore never names a port that is not listening.
+    LocalEventTap.start(~onBound=tapPort =>
+      LocalPlatformRegistry.publishTapPort(~port=domainPort, ~tapPort)
+    , ())
     // Fire onPlatformDeployed after all servers are started so late-deployed
     // plugins (e.g. PlatformInspector) have their handler refs populated.
     ReventlessCore.Plugin_Helpers.firePlatformDeployedHook({

package/src/Platform.res.mjs

@@ -13,6 +13,7 @@ import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
@@ -35,6 +36,7 @@ import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/sr
 import * as SqliteDriver$ReventlessLocal from "./adapter/SqliteDriver.res.mjs";
 import * as Task_Builder$ReventlessLocal from "./components/Task_Builder.res.mjs";
 import * as BakedManifest$ReventlessLocal from "./BakedManifest.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "./adapter/LocalEventTap.res.mjs";
 import * as Platform_Admin$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin.res.mjs";
 import * as PluginBehavior$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
@@ -59,6 +61,7 @@ import * as ProjectionPending$ReventlessLocal from "./adapter/ProjectionPending.
 import * as ReadModel_Builder$ReventlessLocal from "./components/ReadModel_Builder.res.mjs";
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "./adapter/Api/LocalEvents_Server.res.mjs";
+import * as LocalPlatformStart$ReventlessLocal from "./LocalPlatformStart.res.mjs";
 import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Server.res.mjs";
 import * as ResourceAttribution$ReventlessCore from "@reventlessdev/reventless-core/src/ResourceAttribution.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
@@ -102,6 +105,8 @@ import * as InboundTranslationResolvers_GraphQL$ReventlessLocal from "./adapter/
 
 EffectLogger$ReventlessCore.setDefaultMinLevel("Debug");
 
+AnsiStyle$Reventless.setDefaultFormat("text");
+
 let log = Logger$ReventlessCore.fromEnv();
 
 let platformGraphQLRef = {
@@ -141,6 +146,7 @@ function MakeWithConfig(Config) {
     let resetOnStart = match.resetOnStart;
     let path = match.path;
     if (resetOnStart) {
+      LocalPlatformStart$ReventlessLocal.guardReset(path, undefined, undefined);
       Backend$ReventlessLocal.removeFileIfExists(path);
     }
     let db = SqliteDriver$ReventlessLocal.openDb(path);
@@ -1117,7 +1123,8 @@ function MakeWithConfig(Config) {
     LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
       kind: match[0],
       path: match[1]
-    });
+    }, undefined);
+    LocalEventTap$ReventlessLocal.start(undefined, tapPort => LocalPlatformRegistry$ReventlessLocal.publishTapPort(domainPort, tapPort, undefined), undefined);
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),
@@ -1889,6 +1896,7 @@ function Make($star) {
     let resetOnStart = backend.resetOnStart;
     let path = backend.path;
     if (resetOnStart) {
+      LocalPlatformStart$ReventlessLocal.guardReset(path, undefined, undefined);
       Backend$ReventlessLocal.removeFileIfExists(path);
     }
     let db = SqliteDriver$ReventlessLocal.openDb(path);
@@ -2855,7 +2863,8 @@ function Make($star) {
     LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
       kind: match[0],
       path: match[1]
-    });
+    }, undefined);
+    LocalEventTap$ReventlessLocal.start(undefined, tapPort => LocalPlatformRegistry$ReventlessLocal.publishTapPort(domainPort, tapPort, undefined), undefined);
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),