envio 3.12.1 → 3.13.0-alpha.0

package/src/Main.res

@@ -1,80 +1,3 @@
-// The public console/state chain shape. Kept to exactly this field set for
-// backward compatibility with consumers like RACE — new metric fields stay off
-// the HTTP response.
-type chainData = {
-  chainId: ChainId.t,
-  poweredByHyperSync: bool,
-  firstEventBlockNumber: option<int>,
-  latestProcessedBlock: option<int>,
-  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
-  numEventsProcessed: float,
-  latestFetchedBlockNumber: int,
-  // Need this for API backwards compatibility
-  @as("currentBlockHeight")
-  knownHeight: int,
-  numBatchesFetched: int,
-  startBlock: int,
-  endBlock: option<int>,
-  numAddresses: int,
-}
-@tag("status")
-type state =
-  | @as("disabled") Disabled({})
-  | @as("initializing") Initializing({})
-  | @as("active")
-  Active({
-      envioVersion: string,
-      chains: array<chainData>,
-      indexerStartTime: Date.t,
-      isPreRegisteringDynamicContracts: bool,
-      rollbackOnReorg: bool,
-    })
-
-let toChainData = (m: Metrics.chainMetrics): chainData => {
-  chainId: m.chainId,
-  poweredByHyperSync: m.poweredByHyperSync,
-  firstEventBlockNumber: m.firstEventBlockNumber,
-  latestProcessedBlock: m.latestProcessedBlock,
-  timestampCaughtUpToHeadOrEndblock: m.timestampCaughtUpToHeadOrEndblock,
-  numEventsProcessed: m.numEventsProcessed,
-  latestFetchedBlockNumber: m.latestFetchedBlockNumber,
-  knownHeight: m.knownHeight,
-  numBatchesFetched: m.numBatchesFetched,
-  startBlock: m.startBlock,
-  endBlock: m.endBlock,
-  numAddresses: m.numAddresses,
-}
-
-let chainDataSchema = S.schema((s): chainData => {
-  chainId: s.matches(ChainId.schema),
-  poweredByHyperSync: s.matches(S.bool),
-  firstEventBlockNumber: s.matches(S.option(S.int)),
-  latestProcessedBlock: s.matches(S.option(S.int)),
-  timestampCaughtUpToHeadOrEndblock: s.matches(S.option(S.datetime(S.string))),
-  numEventsProcessed: s.matches(S.float),
-  latestFetchedBlockNumber: s.matches(S.int),
-  knownHeight: s.matches(S.int),
-  numBatchesFetched: s.matches(S.int),
-  startBlock: s.matches(S.int),
-  endBlock: s.matches(S.option(S.int)),
-  numAddresses: s.matches(S.int),
-})
-let stateSchema = S.union([
-  S.literal(Disabled({})),
-  S.literal(Initializing({})),
-  S.schema(s => Active({
-    envioVersion: s.matches(S.string),
-    chains: s.matches(S.array(chainDataSchema)),
-    indexerStartTime: s.matches(S.datetime(S.string)),
-    // Keep the field, since Dev Console expects it to be present
-    isPreRegisteringDynamicContracts: false,
-    rollbackOnReorg: s.matches(S.bool),
-  })),
-])
-
-// Runtime state lives in the process-wide `EnvioGlobal` record (shared
-// across duplicate envio module instances); the slots are opaque there, so
-// cast them to the real types here.
 let getIndexerState = () =>
   EnvioGlobal.value.indexerState->(Utils.magic: option<unknown> => option<IndexerState.t>)
 let setIndexerState = (state: IndexerState.t) =>
@@ -488,111 +411,8 @@ let getGlobalIndexer = (): 'indexer => {
   Utils.Proxy.make(Utils.Object.createNullObject(), traps)->(Utils.magic: {..} => 'indexer)
 }
 
-let startServer = (
-  ~getMetrics: unit => option<Metrics.t>,
-  ~envioVersion: string,
-  ~persistence: Persistence.t,
-  ~isDevelopmentMode: bool,
-) => {
-  open Express
-
-  let app = make()
-
-  let consoleCorsMiddleware = (req, res, next) => {
-    switch req.headers->Dict.get("origin") {
-    | Some(origin) if origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl =>
-      res->setHeader("Access-Control-Allow-Origin", origin)
-    | _ => ()
-    }
-
-    res->setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-    res->setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
-
-    if req.method === Rest.Options {
-      res->sendStatus(200)
-    } else {
-      next()
-    }
-  }
-  app->useFor("/console", consoleCorsMiddleware)
-  app->useFor("/metrics", consoleCorsMiddleware)
-  app->useFor("/metrics/runtime", consoleCorsMiddleware)
-
-  app->get("/healthz", (_req, res) => {
-    // this is the machine readable port used in kubernetes to check the health of this service.
-    //   aditional health information could be added in the future (info about errors, back-offs, etc).
-    res->sendStatus(200)
-  })
-
-  app->get("/console/state", (_req, res) => {
-    let state = if !isDevelopmentMode {
-      Disabled({})
-    } else {
-      switch getMetrics() {
-      | None => Initializing({})
-      | Some(metrics) =>
-        Active({
-          envioVersion,
-          chains: metrics.chains->Array.map(toChainData),
-          indexerStartTime: metrics.startTime,
-          isPreRegisteringDynamicContracts: false,
-          rollbackOnReorg: metrics.rollbackEnabled,
-        })
-      }
-    }
-
-    res->json(state->S.reverseConvertToJsonOrThrow(stateSchema))
-  })
-
-  app->post("/console/syncCache", (_req, res) => {
-    if isDevelopmentMode {
-      (persistence->Persistence.getInitializedStorageOrThrow).dumpEffectCache()
-      ->Promise.thenResolve(_ => res->json(Boolean(true)))
-      ->Promise.ignore
-    } else {
-      res->json(Boolean(false))
-    }
-  })
-
-  Metrics.startRuntimeCollectors()
-
-  app->get("/metrics", (_req, res) => {
-    res->set("Content-Type", Metrics.contentType)
-    let _ = res->endWithData(Metrics.collect(~metrics=getMetrics()))
-  })
-
-  app->get("/metrics/runtime", (_req, res) => {
-    res->set("Content-Type", Metrics.contentType)
-    let _ = res->endWithData(Metrics.collectRuntime())
-  })
-
-  let server = app->listen(Env.serverPort)
-  server->Express.onError(err => {
-    let code = (err->(Utils.magic: JsExn.t => {..}))["code"]
-    if code === "EADDRINUSE" {
-      Logging.error(
-        `Port ${Env.serverPort->Int.toString} is already in use. To fix this either:` ++
-        `\n  1. Kill the process using the port: lsof -ti :${Env.serverPort->Int.toString} | xargs kill -9` ++ `\n  2. Use a different port by setting the ENVIO_INDEXER_PORT environment variable: ENVIO_INDEXER_PORT=9899 envio start`,
-      )
-    } else {
-      Logging.errorWithExn(err, "Failed to start indexer server")
-    }
-    NodeJs.process->NodeJs.exitWithCode(Failure)
-  })
-}
-
-type args = {@as("tui-off") tuiOff?: bool}
-
-type process
-@val external process: process = "process"
-@get external argv: process => 'a = "argv"
-
-type mainArgs = Yargs.parsedArgs<args>
-
 // The RPC-stripped public config that the storage layer persists in
 // `envio_info` (on initialize) and validates against (on resume).
-let getEnvioInfo = () => Config.getPublicConfigJson()->Config.stripSensitiveData
-
 let migrate = async (~reset) => {
   let config = Config.load()
   let persistence = PgStorage.makePersistenceFromConfig(~config)
@@ -600,7 +420,7 @@ let migrate = async (~reset) => {
     ~reset,
     ~chainConfigs=config.chainMap->ChainMap.values,
     ~contractMapping=config.contractMapping,
-    ~envioInfo=getEnvioInfo(),
+    ~envioInfo=Config.envioInfo(),
     ~resetCommand="envio local db-migrate setup",
     ~runCommand=None,
     ~lowercaseAddresses=config.lowercaseAddresses,
@@ -622,6 +442,118 @@ let dropSchema = async () => {
 // context, so callers should act on it (exit / re-throw) without logging again.
 exception FatalError(exn)
 
+%%private(
+  let startIndexer = async (
+    ~config: Config.t,
+    ~persistence: option<Persistence.t>=?,
+    ~reset=false,
+    ~isTest=false,
+    ~exitAfterFirstEventBlock=false,
+    ~patchConfig: option<(Config.t, HandlerRegister.registrationsByChainId) => Config.t>=?,
+  ) => {
+    // A worker reports to its supervisor, which draws for the whole run.
+    let shouldUseTui = Tui.shouldUse(~suppressed=isTest || Worker.isEnabled)
+    // In per-chain mode every line this process writes belongs to the chains it
+    // drives, whether or not a supervisor split the run across processes.
+    config->Config.logContext->Option.forEach(Logging.setContext)
+    // isDevelopmentMode controls whether the indexer stays alive after all
+    // chains finish (keepProcessAlive) and whether the console API is exposed.
+    // Set by `envio dev` via the public config's `isDev` field; `envio start`
+    // leaves it false so the process exits cleanly when indexing completes.
+    let isDevelopmentMode = !isTest && config.isDev
+    // Initialized first so the exported indexer value contains state from the
+    // database when handler files are loaded (they may access the indexer at
+    // module top level).
+    let persistence = switch persistence {
+    | Some(p) => p
+    | None => PgStorage.makePersistenceFromConfig(~config)
+    }
+    setGlobalPersistence(persistence)
+    await persistence->Persistence.initForRun(
+      ~config,
+      ~reset,
+      ~isDevelopmentMode,
+      ~requireInitialized=config.isolated,
+    )
+
+    // Loads user handler files, which register handler/contractRegister/where
+    // state into the global `HandlerRegister` registry as a side effect; this
+    // returns that state resolved into per-chain registrations. `config` itself
+    // is never mutated by registration — it holds only event definitions.
+    let registrationsByChainId = await HandlerLoader.registerAllHandlers(~config)
+    let config = if isTest {
+      {...config, shouldRollbackOnReorg: false}
+    } else {
+      config
+    }
+
+    let config = switch patchConfig {
+    | Some(patchConfig) => patchConfig(config, registrationsByChainId)
+    | None => config
+    }
+    // The single fatal-error handler, invoked once via IndexerState.errorExit.
+    // It logs the failure once (with chain context) and rejects the run wrapped in
+    // `FatalError` so callers know it's already logged — `Bin.res` just exits, the
+    // test worker unwraps and re-throws it to the parent thread. `runUntilFatalError`
+    // only ever rejects: on a clean run it stays pending and the process exits via
+    // ExitOnCaughtUp / when the indexer loop drains.
+    let onErrorReject = ref(None)
+    let runUntilFatalError: promise<unit> = Promise.make((_resolve, reject) =>
+      onErrorReject := Some(reject)
+    )
+    // `onErrorReject` is filled synchronously by `Promise.make` above, before the
+    // indexer can run and call `onError`, so it's always present here.
+    let onError = (errHandler: ErrorHandling.t) => {
+      errHandler->ErrorHandling.log
+      (onErrorReject.contents->Option.getUnsafe)(FatalError(errHandler.exn->Utils.prettifyExn))
+    }
+    let envioVersion = Utils.EnvioPackage.value.version
+
+    let getMetrics = () => getIndexerState()->Option.map(IndexerState.toMetrics)
+    let dumpEffectCache = () =>
+      (persistence->Persistence.getInitializedStorageOrThrow).dumpEffectCache()
+
+    // A worker reports through its supervisor, which owns the one server and the
+    // one display the run has.
+    if !isTest && !Worker.isEnabled {
+      Metrics.startRuntimeCollectors()
+      Server.startServer(
+        ~onSyncCache=() => dumpEffectCache()->Promise.thenResolve(ignore),
+        ~collectRuntime=Metrics.collectRuntime,
+        ~isDevelopmentMode,
+        ~envioVersion,
+        ~getMetrics,
+      )
+    }
+
+    let state = IndexerState.makeFromDbState(
+      ~config,
+      ~persistence,
+      ~initialState=persistence->Persistence.getInitializedState,
+      ~registrationsByChainId,
+      ~isDevelopmentMode,
+      ~shouldUseTui,
+      ~exitAfterFirstEventBlock,
+      ~holdRealtime=Worker.config->Option.mapOr(false, worker => worker.holdRealtime),
+      ~onError,
+    )
+    if shouldUseTui {
+      let _rerender = Tui.start(~config, ~getMetrics=() => state->IndexerState.toMetrics)
+    }
+    Worker.bindRun(
+      ~getMetrics=() => state->IndexerState.toMetrics,
+      ~onReleaseRealtime=() => state->IndexerState.releaseRealtime,
+    )
+    setIndexerState(state)
+    state->IndexerLoop.start
+    await runUntilFatalError
+  }
+)
+
+// Starts this process's part of a run: the group's supervisor when the budget
+// and the schema afford splitting the chains across processes, and the indexer
+// itself otherwise. A worker is already one process's part, so it never splits
+// again — `planForRun` refuses an isolated config.
 let start = async (
   ~persistence: option<Persistence.t>=?,
   ~reset=false,
@@ -629,93 +561,24 @@ let start = async (
   ~exitAfterFirstEventBlock=false,
   ~patchConfig: option<(Config.t, HandlerRegister.registrationsByChainId) => Config.t>=?,
 ) => {
-  let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
-  let explicitTui = switch mainArgs.tuiOff {
-  | Some(off) => Some(!off)
-  | None => Env.tuiEnvVar
-  }
-  let shouldUseTui = switch (isTest, explicitTui) {
-  | (true, _) => false
-  | (_, Some(tui)) => tui
-  | (_, None) => !Envio.isNonInteractive()
-  }
-  // Initialize persistence first so the exported indexer value contains state from the database
-  // when handler files are loaded (they may access the indexer at module top level).
-  let config = Config.load()
-  // isDevelopmentMode controls whether the indexer stays alive after all
-  // chains finish (keepProcessAlive) and whether the console API is exposed.
-  // Set by `envio dev` via the public config's `isDev` field; `envio start`
-  // leaves it false so the process exits cleanly when indexing completes.
-  let isDevelopmentMode = !isTest && config.isDev
-  let persistence = switch persistence {
-  | Some(p) => p
-  | None => PgStorage.makePersistenceFromConfig(~config)
-  }
-  setGlobalPersistence(persistence)
-  await persistence->Persistence.init(
-    ~reset,
-    ~chainConfigs=config.chainMap->ChainMap.values,
-    ~contractMapping=config.contractMapping,
-    ~envioInfo=getEnvioInfo(),
-    ~resetCommand=isDevelopmentMode ? "envio dev -r" : "envio start -r",
-    ~runCommand=Some(isDevelopmentMode ? "envio dev" : "envio start"),
-    ~lowercaseAddresses=config.lowercaseAddresses,
-    ~requireInitialized=config.isolated,
+  // A worker parses the same config its supervisor did and narrows it to the
+  // chains it was handed, rather than being told what to index: the storage it
+  // resumes refuses a config that disagrees with the one the run was created
+  // from, which is a stronger guarantee than a handover could give.
+  Worker.config->Option.forEach(({chainIds}) =>
+    Config.prime(Config.getPublicConfigJson()->Config.withIsolatedChains(~chainIds))
   )
-
-  // Loads user handler files, which register handler/contractRegister/where
-  // state into the global `HandlerRegister` registry as a side effect; this
-  // returns that state resolved into per-chain registrations. `config` itself
-  // is never mutated by registration — it holds only event definitions.
-  let registrationsByChainId = await HandlerLoader.registerAllHandlers(~config)
-  let config = if isTest {
-    {...config, shouldRollbackOnReorg: false}
-  } else {
-    config
-  }
-
-  let config = switch patchConfig {
-  | Some(patchConfig) => patchConfig(config, registrationsByChainId)
-  | None => config
-  }
-  // The single fatal-error handler, invoked once via IndexerState.errorExit.
-  // It logs the failure once (with chain context) and rejects the run wrapped in
-  // `FatalError` so callers know it's already logged — `Bin.res` just exits, the
-  // test worker unwraps and re-throws it to the parent thread. `runUntilFatalError`
-  // only ever rejects: on a clean run it stays pending and the process exits via
-  // ExitOnCaughtUp / when the indexer loop drains.
-  let onErrorReject = ref(None)
-  let runUntilFatalError: promise<unit> = Promise.make((_resolve, reject) =>
-    onErrorReject := Some(reject)
-  )
-  // `onErrorReject` is filled synchronously by `Promise.make` above, before the
-  // indexer can run and call `onError`, so it's always present here.
-  let onError = (errHandler: ErrorHandling.t) => {
-    errHandler->ErrorHandling.log
-    (onErrorReject.contents->Option.getUnsafe)(FatalError(errHandler.exn->Utils.prettifyExn))
-  }
-  let envioVersion = Utils.EnvioPackage.value.version
-
-  let getMetrics = () => getIndexerState()->Option.map(IndexerState.toMetrics)
-
-  if !isTest {
-    startServer(~persistence, ~isDevelopmentMode, ~envioVersion, ~getMetrics)
-  }
-
-  let state = IndexerState.makeFromDbState(
-    ~config,
-    ~persistence,
-    ~initialState=persistence->Persistence.getInitializedState,
-    ~registrationsByChainId,
-    ~isDevelopmentMode,
-    ~shouldUseTui,
-    ~exitAfterFirstEventBlock,
-    ~onError,
-  )
-  if shouldUseTui {
-    let _rerender = Tui.start(~config, ~getMetrics=() => state->IndexerState.toMetrics)
+  let config = Config.load()
+  switch isTest ? None : Supervisor.planForRun(~config) {
+  | Some(workers) => await Supervisor.run(~config, ~workers, ~reset)
+  | None =>
+    await startIndexer(
+      ~config,
+      ~persistence?,
+      ~reset,
+      ~isTest,
+      ~exitAfterFirstEventBlock,
+      ~patchConfig?,
+    )
   }
-  setIndexerState(state)
-  state->IndexerLoop.start
-  await runUntilFatalError
 }

package/src/Main.res.mjs

@@ -1,85 +1,32 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Env from "./Env.res.mjs";
 import * as Tui from "./tui/Tui.res.mjs";
-import * as Envio from "./Envio.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
+import * as Server from "./Server.res.mjs";
+import * as Worker from "./Worker.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Metrics from "./Metrics.res.mjs";
-import Express from "express";
-import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
+import * as Supervisor from "./Supervisor.res.mjs";
 import * as AddressRows from "./AddressRows.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
-import Yargs from "yargs/yargs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Helpers from "yargs/helpers";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function toChainData(m) {
-  return {
-    chainId: m.chainId,
-    poweredByHyperSync: m.poweredByHyperSync,
-    firstEventBlockNumber: m.firstEventBlockNumber,
-    latestProcessedBlock: m.latestProcessedBlock,
-    timestampCaughtUpToHeadOrEndblock: m.timestampCaughtUpToHeadOrEndblock,
-    numEventsProcessed: m.numEventsProcessed,
-    latestFetchedBlockNumber: m.latestFetchedBlockNumber,
-    currentBlockHeight: m.knownHeight,
-    numBatchesFetched: m.numBatchesFetched,
-    startBlock: m.startBlock,
-    endBlock: m.endBlock,
-    numAddresses: m.numAddresses
-  };
-}
-
-let chainDataSchema = S$RescriptSchema.schema(s => ({
-  chainId: s.m(ChainId.schema),
-  poweredByHyperSync: s.m(S$RescriptSchema.bool),
-  firstEventBlockNumber: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
-  latestProcessedBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
-  timestampCaughtUpToHeadOrEndblock: s.m(S$RescriptSchema.option(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined))),
-  numEventsProcessed: s.m(S$RescriptSchema.float),
-  latestFetchedBlockNumber: s.m(S$RescriptSchema.int),
-  currentBlockHeight: s.m(S$RescriptSchema.int),
-  numBatchesFetched: s.m(S$RescriptSchema.int),
-  startBlock: s.m(S$RescriptSchema.int),
-  endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
-  numAddresses: s.m(S$RescriptSchema.int)
-}));
-
-let stateSchema = S$RescriptSchema.union([
-  S$RescriptSchema.literal({
-    status: "disabled"
-  }),
-  S$RescriptSchema.literal({
-    status: "initializing"
-  }),
-  S$RescriptSchema.schema(s => ({
-    status: "active",
-    envioVersion: s.m(S$RescriptSchema.string),
-    chains: s.m(S$RescriptSchema.array(chainDataSchema)),
-    indexerStartTime: s.m(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined)),
-    isPreRegisteringDynamicContracts: false,
-    rollbackOnReorg: s.m(S$RescriptSchema.bool)
-  }))
-]);
-
 function getIndexerState() {
   return EnvioGlobal.value.indexerState;
 }
@@ -402,87 +349,10 @@ function getGlobalIndexer() {
   return new Proxy(Object.create(null), traps);
 }
 
-function startServer(getMetrics, envioVersion, persistence, isDevelopmentMode) {
-  let app = Express();
-  let consoleCorsMiddleware = (req, res, next) => {
-    let origin = req.headers["origin"];
-    if (origin !== undefined && (origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl)) {
-      res.setHeader("Access-Control-Allow-Origin", origin);
-    }
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
-    if (req.method === "OPTIONS") {
-      res.sendStatus(200);
-      return;
-    } else {
-      return next();
-    }
-  };
-  app.use("/console", consoleCorsMiddleware);
-  app.use("/metrics", consoleCorsMiddleware);
-  app.use("/metrics/runtime", consoleCorsMiddleware);
-  app.get("/healthz", (_req, res) => {
-    res.sendStatus(200);
-  });
-  app.get("/console/state", (_req, res) => {
-    let state;
-    if (isDevelopmentMode) {
-      let metrics = getMetrics();
-      state = metrics !== undefined ? ({
-          status: "active",
-          envioVersion: envioVersion,
-          chains: metrics.chains.map(toChainData),
-          indexerStartTime: metrics.startTime,
-          isPreRegisteringDynamicContracts: false,
-          rollbackOnReorg: metrics.rollbackEnabled
-        }) : ({
-          status: "initializing"
-        });
-    } else {
-      state = {
-        status: "disabled"
-      };
-    }
-    res.json(S$RescriptSchema.reverseConvertToJsonOrThrow(state, stateSchema));
-  });
-  app.post("/console/syncCache", (_req, res) => {
-    if (isDevelopmentMode) {
-      Persistence.getInitializedStorageOrThrow(persistence).dumpEffectCache().then(() => {
-        res.json(true);
-      });
-    } else {
-      res.json(false);
-    }
-  });
-  Metrics.startRuntimeCollectors();
-  app.get("/metrics", (_req, res) => {
-    res.set("Content-Type", Metrics.contentType);
-    res.end(Metrics.collect(getMetrics()));
-  });
-  app.get("/metrics/runtime", (_req, res) => {
-    res.set("Content-Type", Metrics.contentType);
-    res.end(Metrics.collectRuntime());
-  });
-  let server = app.listen(Env.serverPort);
-  server.on("error", err => {
-    let code = err.code;
-    if (code === "EADDRINUSE") {
-      Logging.error(`Port ` + Env.serverPort.toString() + ` is already in use. To fix this either:` + (`\n  1. Kill the process using the port: lsof -ti :` + Env.serverPort.toString() + ` | xargs kill -9`) + `\n  2. Use a different port by setting the ENVIO_INDEXER_PORT environment variable: ENVIO_INDEXER_PORT=9899 envio start`);
-    } else {
-      Logging.errorWithExn(err, "Failed to start indexer server");
-    }
-    Process.exit(1);
-  });
-}
-
-function getEnvioInfo() {
-  return Config.stripSensitiveData(Config.getPublicConfigJson());
-}
-
 async function migrate(reset) {
   let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset, config.lowercaseAddresses, undefined, "Once");
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.envioInfo(), "envio local db-migrate setup", undefined, reset, config.lowercaseAddresses, undefined, "Once");
   return await persistence.storage.close();
 }
 
@@ -495,21 +365,16 @@ async function dropSchema() {
 
 let FatalError = /* @__PURE__ */Primitive_exceptions.create("Main.FatalError");
 
-async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockOpt, patchConfig) {
+async function startIndexer(config, persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockOpt, patchConfig) {
   let reset = resetOpt !== undefined ? resetOpt : false;
   let isTest = isTestOpt !== undefined ? isTestOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
-  let mainArgs = Yargs(Helpers.hideBin(process.argv)).argv;
-  let off = mainArgs["tui-off"];
-  let explicitTui = off !== undefined ? !off : Env.tuiEnvVar;
-  let shouldUseTui = isTest ? false : (
-      explicitTui !== undefined ? explicitTui : !Envio.isNonInteractive()
-    );
-  let config = Config.load();
+  let shouldUseTui = Tui.shouldUse(isTest || Worker.isEnabled);
+  Stdlib_Option.forEach(Config.logContext(config), Logging.setContext);
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
   EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
-  await Persistence.init(persistence$1, ChainMap.values(config.chainMap), config.contractMapping, Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset, config.lowercaseAddresses, config.isolated, undefined);
+  await Persistence.initForRun(persistence$1, config, reset, isDevelopmentMode, config.isolated);
   let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1;
   if (isTest) {
@@ -535,22 +400,35 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   };
   let envioVersion = Utils.EnvioPackage.value.version;
   let getMetrics = () => Stdlib_Option.map(EnvioGlobal.value.indexerState, IndexerState.toMetrics);
-  if (!isTest) {
-    startServer(getMetrics, envioVersion, persistence$1, isDevelopmentMode);
+  if (!isTest && !Worker.isEnabled) {
+    Metrics.startRuntimeCollectors();
+    Server.startServer(getMetrics, envioVersion, () => Persistence.getInitializedStorageOrThrow(persistence$1).dumpEffectCache().then(prim => {}), Metrics.collectRuntime, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError, undefined);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, Stdlib_Option.mapOr(Worker.config, false, worker => worker.holdRealtime), onError, undefined);
   if (shouldUseTui) {
     Tui.start(config$2, () => IndexerState.toMetrics(state));
   }
+  Worker.bindRun(() => IndexerState.toMetrics(state), () => IndexerState.releaseRealtime(state));
   EnvioGlobal.value.indexerState = Primitive_option.some(state);
   IndexerLoop.start(state);
   return await runUntilFatalError;
 }
 
+async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockOpt, patchConfig) {
+  let reset = resetOpt !== undefined ? resetOpt : false;
+  let isTest = isTestOpt !== undefined ? isTestOpt : false;
+  let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
+  Stdlib_Option.forEach(Worker.config, param => Config.prime(Config.withIsolatedChains(Config.getPublicConfigJson(), param.chainIds)));
+  let config = Config.load();
+  let workers = isTest ? undefined : Supervisor.planForRun(config, undefined);
+  if (workers !== undefined) {
+    return await Supervisor.run(config, workers, reset);
+  } else {
+    return await startIndexer(config, persistence, reset, isTest, exitAfterFirstEventBlock, patchConfig);
+  }
+}
+
 export {
-  toChainData,
-  chainDataSchema,
-  stateSchema,
   getIndexerState,
   setIndexerState,
   getGlobalPersistence,
@@ -559,11 +437,9 @@ export {
   getInitialChainState,
   buildChainsObject,
   getGlobalIndexer,
-  startServer,
-  getEnvioInfo,
   migrate,
   dropSchema,
   FatalError,
   start,
 }
-/* chainDataSchema Not a pure module */
+/* Tui Not a pure module */