envio 3.12.0 → 3.13.0-alpha.0

package/src/Supervisor.res.mjs

@@ -0,0 +1,325 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Tui from "./tui/Tui.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 * as Process from "process";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as PgStorage from "./PgStorage.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Child_process from "child_process";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function plan(chainIds, maxConnections) {
+  let workerCount = Primitive_int.min(chainIds.length, maxConnections / 2 | 0);
+  if (workerCount < 2) {
+    return;
+  }
+  let evenShare = Primitive_int.div(maxConnections, workerCount);
+  let remainder = Primitive_int.mod_(maxConnections, workerCount);
+  return Stdlib_Array.fromInitializer(workerCount, workerIndex => ({
+    chainIds: chainIds.filter((param, dealIndex) => {
+      let position = Primitive_int.mod_(dealIndex, workerCount);
+      let isReversePass = Primitive_int.div(dealIndex, workerCount) % 2 === 1;
+      return (
+        isReversePass ? (workerCount - 1 | 0) - position | 0 : position
+      ) === workerIndex;
+    }),
+    maxConnections: evenShare + (
+      workerIndex < remainder ? 1 : 0
+    ) | 0
+  }));
+}
+
+function planForRun(config, maxConnectionsOpt) {
+  let maxConnections = maxConnectionsOpt !== undefined ? maxConnectionsOpt : Env.Db.maxConnections;
+  if (config.isolated || !Config.isPerChain(config)) {
+    return;
+  } else {
+    return plan(ChainMap.values(config.chainMap).map(chain => chain.id), maxConnections);
+  }
+}
+
+function name(worker) {
+  return worker.chainIds.map(ChainId.toString).join(";");
+}
+
+function label(worker) {
+  return `[chain ` + name(worker) + `]`;
+}
+
+function logFilePath(workerIndex, pathOpt) {
+  let path = pathOpt !== undefined ? pathOpt : Env.logFilePath;
+  let suffix = `.worker-` + workerIndex.toString();
+  let dot = path.lastIndexOf(".");
+  if (dot > path.lastIndexOf("/")) {
+    return path.slice(0, dot) + suffix + path.slice(dot, path.length);
+  } else {
+    return path + suffix;
+  }
+}
+
+function readLines(onLine) {
+  let pending = {
+    contents: ""
+  };
+  let read = chunk => {
+    let parts = (pending.contents + chunk).split("\n");
+    pending.contents = Stdlib_Option.getOr(parts.pop(), "");
+    parts.forEach(onLine);
+  };
+  let flush = () => {
+    let line = pending.contents;
+    if (line === "") {
+      return;
+    }
+    pending.contents = "";
+    onLine(line);
+  };
+  return [
+    read,
+    flush
+  ];
+}
+
+function fork(worker, workerIndex, holdRealtime, entryPathOpt, pipeOutputOpt, onOutputOpt) {
+  let entryPath = entryPathOpt !== undefined ? entryPathOpt : process.argv[1];
+  let pipeOutput = pipeOutputOpt !== undefined ? pipeOutputOpt : false;
+  let onOutput = onOutputOpt !== undefined ? onOutputOpt : prim => {
+      console.log(prim);
+    };
+  let env = Object.assign({}, Process.env);
+  env[Worker.envVar] = S$RescriptSchema.reverseConvertToJsonStringOrThrow({
+    chainIds: worker.chainIds,
+    holdRealtime: holdRealtime
+  }, Worker.configSchema, undefined);
+  env["ENVIO_PG_MAX_CONNECTIONS"] = worker.maxConnections.toString();
+  env["LOG_FILE"] = logFilePath(workerIndex, undefined);
+  if (pipeOutput && Stdlib_Option.getOr((process.stdout.isTTY == null) ? undefined : Primitive_option.some(process.stdout.isTTY), false)) {
+    env["FORCE_COLOR"] = "1";
+  }
+  let child = Child_process.fork(entryPath, [], {
+    env: env,
+    serialization: "advanced",
+    stdio: pipeOutput ? [
+        "inherit",
+        "pipe",
+        "pipe",
+        "ipc"
+      ] : [
+        "inherit",
+        "inherit",
+        "inherit",
+        "ipc"
+      ]
+  });
+  if (pipeOutput) {
+    [
+      child.stdout,
+      child.stderr
+    ].forEach(stream => {
+      if (stream === null) {
+        return;
+      }
+      let match = readLines(onOutput);
+      stream.setEncoding("utf8");
+      stream.on("data", match[0]);
+      stream.on("end", match[1]);
+    });
+  }
+  let running = {
+    worker: worker,
+    child: child,
+    snapshot: undefined,
+    runtime: undefined,
+    settled: false
+  };
+  child.on("message", message => {
+    running.snapshot = message.metrics;
+    running.runtime = message.runtime;
+  });
+  return running;
+}
+
+function stop(group) {
+  group.stopping = true;
+  group.running.forEach(r => {
+    r.child.kill("SIGTERM");
+  });
+}
+
+let inFlight = {
+  contents: undefined
+};
+
+function syncCache(dump) {
+  let dumping = inFlight.contents;
+  if (dumping !== undefined) {
+    return dumping;
+  }
+  let dumping$1 = dump().finally(() => {
+    inFlight.contents = undefined;
+  });
+  inFlight.contents = dumping$1;
+  return dumping$1;
+}
+
+function dumpCache(config) {
+  let storage = PgStorage.makeStorageFromEnv(config, Primitive_option.some(PgStorage.makeClient(1)), undefined, undefined);
+  return storage.dumpEffectCache().finally(() => {
+    storage.close();
+  });
+}
+
+async function awaitExit(group) {
+  let failed = {
+    contents: false
+  };
+  let alive = {
+    contents: group.running.length
+  };
+  await new Promise((resolve, param) => {
+    let onGone = (r, failure) => {
+      if (!r.settled) {
+        r.settled = true;
+        if (failure) {
+          failed.contents = true;
+          if (!group.stopping) {
+            stop(group);
+          }
+        }
+        alive.contents = alive.contents - 1 | 0;
+        if (alive.contents === 0) {
+          return resolve();
+        } else {
+          return;
+        }
+      }
+    };
+    group.running.forEach(r => {
+      r.child.on("exit", (code, _signal) => onGone(r, !group.stopping && (
+        code === null ? undefined : Primitive_option.some(code)
+      ) !== 0));
+      r.child.on("error", exn => {
+        Logging.errorWithExn(exn, label(r.worker) + ` failed to start`);
+        onGone(r, true);
+      });
+    });
+  });
+  if (failed.contents) {
+    Stdlib_JsError.throwWithMessage("An indexer process exited with a failure. Stopped the others.");
+  }
+  if (group.stopping) {
+    return "Stopped";
+  } else {
+    return "Finished";
+  }
+}
+
+function isRunAtHead(snapshots, workerCount) {
+  if (snapshots.length === workerCount) {
+    return snapshots.every(snapshot => snapshot.hasArrivedAtHead);
+  } else {
+    return false;
+  }
+}
+
+async function run(config, workers, reset) {
+  let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
+  await Persistence.initForRun(persistence, config, reset, config.isDev, false);
+  await persistence.storage.close();
+  let startTime = new Date();
+  let startTimeRef = Performance.now();
+  Logging.info(`Splitting ` + ChainMap.values(config.chainMap).length.toString() + ` chains across ` + workers.length.toString() + ` processes, from a budget of ` + Env.Db.maxConnections.toString() + ` database connections.`);
+  let shouldUseTui = Tui.shouldUse(undefined);
+  let holdRealtime = Persistence.getInitializedState(persistence).chains.some(chain => Stdlib_Option.isNone(chain.timestampCaughtUpToHeadOrEndblock));
+  let group = {
+    running: workers.map((worker, workerIndex) => fork(worker, workerIndex, holdRealtime, undefined, shouldUseTui, undefined)),
+    stopping: false
+  };
+  let reported = () => Stdlib_Array.filterMap(group.running, r => r.snapshot);
+  let merge = snapshots => Metrics.merge(snapshots, startTime, new Date(), Performance.secondsSince(startTimeRef));
+  Server.startServer(() => {
+    let snapshots = reported();
+    if (snapshots.length !== 0) {
+      return merge(snapshots);
+    }
+  }, Utils.EnvioPackage.value.version, () => syncCache(() => dumpCache(config)), () => Metrics.renderRuntime(Stdlib_Array.filterMap(group.running, r => Stdlib_Option.map(r.runtime, runtime => [
+    `worker="` + name(r.worker) + `"`,
+    runtime
+  ]))), config.isDev);
+  let releaseCheck = {
+    contents: undefined
+  };
+  let stopReleaseCheck = () => {
+    Stdlib_Option.forEach(releaseCheck.contents, prim => {
+      clearInterval(prim);
+    });
+    releaseCheck.contents = undefined;
+  };
+  if (holdRealtime) {
+    releaseCheck.contents = Primitive_option.some(setInterval(() => {
+      if (isRunAtHead(reported(), group.running.length)) {
+        stopReleaseCheck();
+        group.running.forEach(r => {
+          r.child.send("release-realtime");
+        });
+        return Logging.info("Every chain has reached the head. Switching the run to realtime.");
+      }
+    }, 500));
+  }
+  if (shouldUseTui) {
+    Tui.start(config, () => merge(reported()));
+  }
+  process.on("SIGTERM", () => stop(group));
+  process.on("SIGINT", () => stop(group));
+  let outcome = await awaitExit(group);
+  stopReleaseCheck();
+  if (outcome === "Finished") {
+    if (shouldUseTui) {
+      process.on("SIGTERM", () => {
+        Process.exit(0);
+      });
+      process.on("SIGINT", () => {
+        Process.exit(0);
+      });
+    } else {
+      Logging.info("Exiting with success");
+      Process.exit(0);
+    }
+    return;
+  }
+  Process.exit(0);
+}
+
+let minConnectionsPerWorker = 2;
+
+export {
+  minConnectionsPerWorker,
+  plan,
+  planForRun,
+  name,
+  label,
+  logFilePath,
+  readLines,
+  fork,
+  stop,
+  syncCache,
+  dumpCache,
+  awaitExit,
+  isRunAtHead,
+  run,
+}
+/* Env Not a pure module */

package/src/TestIndexer.res

@@ -75,15 +75,10 @@ let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFi
   | None => []
   | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-    let matched =
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        // The store holds decoded entities and the filter carries decoded values,
-        // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filter->EntityFilter.matches(~entity=entityAsDict)
-      })
+    // The store holds decoded entities and the filter carries decoded values,
+    // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
+    let matcher = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
+    let matched = entityDict->Dict.valuesToArray->Array.filter(matcher)
     // The chain is already fixed by the scope the load ran for, so the loaded
     // entity is handed back in the shape the handlers see.
     switch entityConfig.table->Table.getChainIdField {
@@ -544,23 +539,12 @@ let makeEntityGetWhere = (~state: testIndexerState, ~entityConfig: Internal.enti
         `Cannot call ${entityConfig.name}.getWhere() while indexer.process() is running. ` ++ "Wait for process() to complete before accessing entities directly.",
       )
     }
-    let filters =
-      filter->EntityFilter.parseGetWhereOrThrow(
-        ~entityName=entityConfig.name,
-        ~table=entityConfig.table,
-      )
+    let matcher =
+      filter
+      ->EntityFilter.parseOrThrow(~entityName=entityConfig.name, ~table=entityConfig.table)
+      ->EntityFilter.makeMatcher(~table=entityConfig.table)
     let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
-    // parseGetWhereOrThrow expands an operator group into alternatives whose
-    // matches are disjoint, so the union needs no dedup.
-    Promise.resolve(
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filters->Array.some(filter => filter->EntityFilter.matches(~entity=entityAsDict))
-      })
-      ->Array.map(copyEntity),
-    )
+    Promise.resolve(entityDict->Dict.valuesToArray->Array.filter(matcher)->Array.map(copyEntity))
   }
 }
 

package/src/TestIndexer.res.mjs

@@ -56,7 +56,8 @@ function handleLoad(state, tableName, filter) {
     return [];
   }
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+  let matcher = EntityFilter.makeMatcher(filter, entityConfig.table);
+  let matched = Object.values(entityDict).filter(matcher);
   let field = Table.getChainIdField(entityConfig.table);
   if (field !== undefined) {
     return matched.map(entity => {
@@ -376,9 +377,9 @@ function makeEntityGetWhere(state, entityConfig) {
     if (state.processInProgress) {
       Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.getWhere() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
     }
-    let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
+    let matcher = EntityFilter.makeMatcher(EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table), entityConfig.table);
     let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-    return Promise.resolve(Object.values(entityDict).filter(entity => filters.some(filter => EntityFilter.matches(filter, entity))).map(copyEntity));
+    return Promise.resolve(Object.values(entityDict).filter(matcher).map(copyEntity));
   };
 }
 
@@ -638,7 +639,7 @@ function createTestIndexer() {
       };
       try {
         await new Promise((resolve, reject) => {
-          let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, errHandler => {
+          let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, undefined, errHandler => {
             ErrorHandling.log(errHandler);
             reject(Utils.prettifyExn(errHandler.exn));
           }, () => resolve());

package/src/UserContext.res

@@ -122,39 +122,20 @@ type entityContextParams = {
 // The handler context is always chain-scoped, so a per-chain entity resolves to
 // the chain the handler runs on and a cross-chain one to the shared partition.
 let entityScope = (params: entityContextParams) =>
-  params.entityConfig->InMemoryStore.entityScope(
-    ~chainId=params.item->Internal.getItemChainId,
-  )
-
-let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) => {
-  let entityConfig = params.entityConfig
-
-  @inline
-  let loadWithFilter = filter =>
-    LoadLayer.loadByFilter(
-      ~loadManager=params.loadManager,
-      ~persistence=params.persistence,
-      ~entityConfig,
-      ~scope=params->entityScope,
-      ~indexerState=params.indexerState,
-      ~shouldGroup=params.isPreload,
-      ~item=params.item,
-      ~ecosystem=params.config.ecosystem,
-      ~filter,
-    )
+  params.entityConfig->InMemoryStore.entityScope(~chainId=params.item->Internal.getItemChainId)
 
-  switch filter->EntityFilter.parseGetWhereOrThrow(
-    ~entityName=entityConfig.name,
-    ~table=entityConfig.table,
-  ) {
-  | [single] => loadWithFilter(single)
-  | filters =>
-    filters
-    ->Array.map(filter => loadWithFilter(filter))
-    ->Promise.all
-    ->Promise.thenResolve(results => results->Array.flat)
-  }
-}
+let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) =>
+  LoadLayer.loadByFilter(
+    ~loadManager=params.loadManager,
+    ~persistence=params.persistence,
+    ~entityConfig=params.entityConfig,
+    ~scope=params->entityScope,
+    ~indexerState=params.indexerState,
+    ~shouldGroup=params.isPreload,
+    ~item=params.item,
+    ~ecosystem=params.config.ecosystem,
+    ~filter,
+  )
 
 let noopSet = (_entity: Internal.entity) => ()
 let noopDeleteUnsafe = (_entityId: EntityId.t) => ()

package/src/UserContext.res.mjs

@@ -77,13 +77,7 @@ function entityScope(params) {
 }
 
 function getWhereHandler(params, filter) {
-  let entityConfig = params.entityConfig;
-  let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
-  if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
-  } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
-  }
+  return LoadLayer.loadByFilter(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter);
 }
 
 function noopSet(_entity) {

package/src/Utils.res

@@ -273,7 +273,7 @@ module Dict = {
 }
 
 module Math = {
-  let minOptInt = (a, b) =>
+  let minOptInt = (a: option<int>, b: option<int>) =>
     switch (a, b) {
     | (Some(a), Some(b)) => Some(a < b ? a : b)
     | (Some(a), None) => Some(a)
@@ -374,9 +374,6 @@ module Array = {
   /**
 Helper to check if a value exists in an array
 */
-  let includes = (arr: array<'a>, val: 'a) =>
-    arr->Array.find(item => item == val)->Stdlib.Option.isSome
-
   let isEmpty = (arr: array<_>) =>
     switch arr {
     | [] => true

package/src/Utils.res.mjs

@@ -6,11 +6,9 @@ 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 Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -221,19 +219,17 @@ let Dict = {
 };
 
 function minOptInt(a, b) {
-  if (a === undefined) {
+  if (a !== undefined) {
     if (b !== undefined) {
-      return Primitive_option.some(Primitive_option.valFromOption(b));
+      return a < b ? a : b;
     } else {
-      return;
+      return a;
     }
+  } else if (b !== undefined) {
+    return b;
+  } else {
+    return;
   }
-  let a$1 = Primitive_option.valFromOption(a);
-  if (b === undefined) {
-    return Primitive_option.some(a$1);
-  }
-  let b$1 = Primitive_option.valFromOption(b);
-  return Primitive_option.some(Primitive_object.lessthan(a$1, b$1) ? a$1 : b$1);
 }
 
 let $$Math = {
@@ -324,10 +320,6 @@ function transposeResults(results) {
   };
 }
 
-function includes(arr, val) {
-  return Stdlib_Option.isSome(arr.find(item => Primitive_object.equal(item, val)));
-}
-
 function isEmpty$1(arr) {
   return arr.length === 0;
 }
@@ -435,7 +427,6 @@ let $$Array$1 = {
   clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
-  includes: includes,
   isEmpty: isEmpty$1,
   notEmpty: notEmpty,
   awaitEach: awaitEach,

package/src/Worker.res

@@ -0,0 +1,95 @@
+// The worker side of a supervised run: a process the supervisor forked to drive
+// a subset of the chains. It has no server and no TUI of its own — it reports
+// through the IPC channel, and the supervisor is the one operational surface.
+
+// Set by a supervisor in the environment of the workers it forks. Internal:
+// it counts only together with the fork's own channel, so a copy left in a
+// shell starts nothing, and an indexer a user starts themselves takes every
+// path it takes today.
+let envVar = "ENVIO_INTERNAL_WORKER"
+
+// What the supervisor decided about this worker, handed over in the spawn
+// environment rather than over the channel: it is settled before the process
+// starts, and the worker needs it before it can load its own config.
+type config = {
+  chainIds: array<ChainId.t>,
+  // The chains this worker drives may reach the head while chains in another
+  // process are still backfilling, and an indexer goes realtime as a whole or
+  // not at all. Cleared by the supervisor's `ReleaseRealtime`.
+  holdRealtime: bool,
+}
+
+let configSchema = S.object((s): config => {
+  chainIds: s.field("chainIds", S.array(ChainId.schema)),
+  holdRealtime: s.fieldOr("holdRealtime", S.bool, false),
+})
+
+// Read as this module loads, which is before anything that could catch a bare
+// schema error and say where it came from.
+let detect = (~env: dict<string>, ~hasChannel) =>
+  switch (hasChannel, env->Dict.get(envVar)) {
+  | (true, Some(json)) =>
+    switch json->S.parseJsonStringOrThrow(configSchema) {
+    | config => Some(config)
+    | exception S.Raised(error) =>
+      JsError.throwWithMessage(
+        `Invalid ${envVar}: ${error->S.Error.message}. It is set by an indexer supervisor for the processes it forks, and isn't meant to be set by hand.`,
+      )
+    }
+  | _ => None
+  }
+
+let config = detect(
+  ~env=NodeJs.Process.process.env,
+  ~hasChannel=NodeJs.Process.channel->Nullable.toOption->Option.isSome,
+)
+
+let isEnabled = config->Option.isSome
+
+@tag("kind")
+type parentMessage =
+  // Every chain in the run has reached the head, so this worker may enter the
+  // reorg threshold and switch to realtime with the rest of them.
+  | @as("release-realtime") ReleaseRealtime
+
+@tag("kind")
+type workerMessage =
+  | @as("snapshot") Snapshot({metrics: Metrics.t, runtime: Metrics.runtimeSample})
+
+// How often a worker reports. Matches the TUI's own refresh, so the supervised
+// display moves at the same rate an unsplit run's does.
+%%private(let snapshotIntervalMillis = 500)
+
+// The supervisor is the one that stops a worker, and the one whose absence
+// ends it. A terminal's interrupt reaches the whole group at once, so the
+// worker leaves it to the supervisor, which stops every worker in turn; without
+// that, a worker gone on its own would read as a failure to the supervisor
+// still deciding what the interrupt meant. A supervisor that dies can't tear
+// the group down, so losing the channel is what ends the worker then.
+let bindToSupervisor = () => {
+  NodeJs.Process.onSignal("SIGINT", () => ())
+  NodeJs.Process.onDisconnect(() => {
+    Logging.error("The indexer supervisor is gone. Stopping this chain's process.")
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  })
+}
+
+%%private(let send = (message: workerMessage) => NodeJs.Process.sendToParent(message)->ignore)
+
+// Reports this process's chains and its own runtime for as long as it runs, so
+// the supervisor can merge every worker's into the one snapshot the run serves,
+// and listens for the one decision the supervisor makes on the run's behalf.
+// Does nothing in a process nobody forked.
+let bindRun = (~getMetrics: unit => Metrics.t, ~onReleaseRealtime: unit => unit) =>
+  if isEnabled {
+    Metrics.startRuntimeCollectors()
+    let _intervalId = setInterval(
+      () => send(Snapshot({metrics: getMetrics(), runtime: Metrics.sampleRuntime()})),
+      snapshotIntervalMillis,
+    )
+    NodeJs.Process.onMessage((message: parentMessage) =>
+      switch message {
+      | ReleaseRealtime => onReleaseRealtime()
+      }
+    )
+  }