envio 3.13.0 → 3.14.0

package/src/ResumePlan.res

@@ -0,0 +1,172 @@
+// A chain as its storage holds it: what its `envio_chains` row keeps of its
+// config, and the addresses the config declared for it.
+type storedChain = {
+  id: ChainId.t,
+  ecosystem: string,
+  startBlock: int,
+  endBlock: option<int>,
+  maxReorgDepth: int,
+  configAddresses: array<AddressRows.row>,
+}
+
+// What a storage holds of the config it was built from. `envioInfo` is `None`
+// for a storage an older envio built, which kept no such record.
+type stored = {
+  envioInfo: option<JSON.t>,
+  chains: array<storedChain>,
+  contractMapping: ContractMapping.t,
+}
+
+type t =
+  | Resume
+  // Configured since the storage was built, and the only chain its
+  // `envio start --chain` process drives.
+  | AddChain(Config.chain)
+  | Incompatible(array<string>)
+
+// The part of a chain's config its storage keeps, shaped so a stored chain and
+// a configured one diff by the path config.yaml spells: `chains.137.endBlock`,
+// `chains.137.contracts.Token.addresses.0x…`.
+let chainEntry = (
+  ~startBlock: option<int>,
+  ~endBlock: option<int>,
+  ~maxReorgDepth: int,
+  ~addresses: array<(string, string)>,
+) => {
+  let contracts = Dict.make()
+  addresses->Array.forEach(((contractName, address)) =>
+    contracts->Utils.Dict.push(contractName, address)
+  )
+  let entry = dict{
+    "maxReorgDepth": JSON.Number(maxReorgDepth->Int.toFloat),
+    "contracts": JSON.Object(
+      contracts->Dict.mapValues(addresses => JSON.Object(
+        dict{
+          "addresses": JSON.Object(
+            addresses->Array.map(address => (address, JSON.Boolean(true)))->Dict.fromArray,
+          ),
+        },
+      )),
+    ),
+  }
+  startBlock->Option.forEach(startBlock =>
+    entry->Dict.set("startBlock", JSON.Number(startBlock->Int.toFloat))
+  )
+  endBlock->Option.forEach(endBlock =>
+    entry->Dict.set("endBlock", JSON.Number(endBlock->Int.toFloat))
+  )
+  JSON.Object(entry)
+}
+
+let withChains = (envioInfo: JSON.t, ~chains: array<(ChainId.t, JSON.t)>) =>
+  switch envioInfo {
+  | Object(fields) =>
+    let joined = fields->Dict.copy
+    joined->Dict.set(
+      "chains",
+      JSON.Object(
+        chains->Array.map(((chainId, entry)) => (chainId->ChainId.toString, entry))->Dict.fromArray,
+      ),
+    )
+    JSON.Object(joined)
+  | _ => envioInfo
+  }
+
+// `envioInfo` is the running config's, `chainConfigs` the chains this process
+// drives. An isolated process answers for `envioInfo` and its own chains only:
+// the ones it leaves out are checked, and added, by the processes that drive
+// them.
+let make = (
+  ~stored: stored,
+  ~envioInfo: JSON.t,
+  ~chainConfigs: array<Config.chain>,
+  ~contractMapping: ContractMapping.t,
+  ~lowercaseAddresses: bool,
+  ~isolated: bool,
+) =>
+  switch stored.envioInfo {
+  | None => Incompatible(["storage was initialized by an older envio version"])
+  | Some(storedEnvioInfo) =>
+    let storedChainOf = chainId => stored.chains->Array.find(chain => chain.id == chainId)
+    let added = switch (isolated, chainConfigs) {
+    | (true, [chain]) if storedChainOf(chain.id)->Option.isNone => Some(chain)
+    | _ => None
+    }
+    let storedChains = isolated
+      ? stored.chains->Array.filter(storedChain =>
+          chainConfigs->Array.some(chain => chain.id == storedChain.id)
+        )
+      : stored.chains
+    let storedEntries = storedChains->Array.map(storedChain => {
+      let addresses =
+        storedChain.configAddresses
+        ->AddressRows.render(~ecosystem=storedChain.ecosystem, ~shouldChecksum=!lowercaseAddresses)
+        ->Array.mapWithIndex((address, idx) => (
+          stored.contractMapping->ContractMapping.nameOfOrThrow(
+            (storedChain.configAddresses->Array.getUnsafe(idx)).contractId,
+          ),
+          address->Address.toString,
+        ))
+      (
+        storedChain.id,
+        chainEntry(
+          ~startBlock=Some(storedChain.startBlock),
+          ~endBlock=storedChain.endBlock,
+          ~maxReorgDepth=storedChain.maxReorgDepth,
+          ~addresses,
+        ),
+      )
+    })
+    let currentEntries = chainConfigs->Array.filterMap(chain =>
+      switch added {
+      | Some(added) if added.id == chain.id => None
+      | _ =>
+        Some((
+          chain.id,
+          chainEntry(
+            // `latest` is whatever it resolved to when the chain was first
+            // stored, so it matches any stored block.
+            ~startBlock=switch chain.startBlock {
+            | Block(startBlock) => Some(startBlock)
+            | Latest => storedChainOf(chain.id)->Option.map(storedChain => storedChain.startBlock)
+            },
+            ~endBlock=chain.endBlock,
+            ~maxReorgDepth=chain.maxReorgDepth,
+            ~addresses=chain.contracts->Array.flatMap(contract =>
+              contract.addresses->Array.map(address => (contract.name, address->Address.toString))
+            ),
+          ),
+        ))
+      }
+    )
+    let changedPaths = Config.diffPaths(
+      ~stored=storedEnvioInfo->withChains(~chains=storedEntries),
+      ~current=envioInfo->withChains(~chains=currentEntries),
+    )
+    let changedPaths =
+      stored.contractMapping->ContractMapping.isEqual(contractMapping)
+        ? changedPaths
+        : changedPaths->Array.concat(["contracts"])
+    switch (changedPaths, added) {
+    | ([], None) => Resume
+    | ([], Some(chain)) => AddChain(chain)
+    | (changedPaths, _) => Incompatible(changedPaths)
+    }
+  }
+
+let incompatibleMessage = (
+  changedPaths,
+  ~envioInfo: JSON.t,
+  ~resetCommand: string,
+  ~runCommand: option<string>,
+) => {
+  let hasClickhouse = switch envioInfo {
+  | Object(d) =>
+    switch d->Dict.get("storage") {
+    | Some(Object(s)) => s->Dict.get("clickhouse") == Some(Boolean(true))
+    | _ => false
+    }
+  | _ => false
+  }
+  Config.incompatibleMessage(changedPaths, ~resetCommand, ~runCommand, ~hasClickhouse)
+}

package/src/ResumePlan.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as AddressRows from "./AddressRows.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ContractMapping from "./ContractMapping.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function chainEntry(startBlock, endBlock, maxReorgDepth, addresses) {
+  let contracts = {};
+  addresses.forEach(param => Utils.Dict.push(contracts, param[0], param[1]));
+  let entry = {
+    maxReorgDepth: maxReorgDepth,
+    contracts: Stdlib_Dict.mapValues(contracts, addresses => ({
+      addresses: Object.fromEntries(addresses.map(address => [
+        address,
+        true
+      ]))
+    }))
+  };
+  Stdlib_Option.forEach(startBlock, startBlock => {
+    entry["startBlock"] = startBlock;
+  });
+  Stdlib_Option.forEach(endBlock, endBlock => {
+    entry["endBlock"] = endBlock;
+  });
+  return entry;
+}
+
+function withChains(envioInfo, chains) {
+  if (typeof envioInfo !== "object" || envioInfo === null || Array.isArray(envioInfo)) {
+    return envioInfo;
+  }
+  let joined = Object.assign({}, envioInfo);
+  joined["chains"] = Object.fromEntries(chains.map(param => [
+    ChainId.toString(param[0]),
+    param[1]
+  ]));
+  return joined;
+}
+
+function make(stored, envioInfo, chainConfigs, contractMapping, lowercaseAddresses, isolated) {
+  let storedEnvioInfo = stored.envioInfo;
+  if (storedEnvioInfo === undefined) {
+    return {
+      TAG: "Incompatible",
+      _0: ["storage was initialized by an older envio version"]
+    };
+  }
+  let storedChainOf = chainId => stored.chains.find(chain => Primitive_object.equal(chain.id, chainId));
+  let added;
+  if (isolated && chainConfigs.length === 1) {
+    let chain = chainConfigs[0];
+    added = Stdlib_Option.isNone(storedChainOf(chain.id)) ? chain : undefined;
+  } else {
+    added = undefined;
+  }
+  let storedChains = isolated ? stored.chains.filter(storedChain => chainConfigs.some(chain => Primitive_object.equal(chain.id, storedChain.id))) : stored.chains;
+  let storedEntries = storedChains.map(storedChain => {
+    let addresses = AddressRows.render(storedChain.configAddresses, storedChain.ecosystem, !lowercaseAddresses).map((address, idx) => [
+      ContractMapping.nameOfOrThrow(stored.contractMapping, storedChain.configAddresses[idx].contractId),
+      address
+    ]);
+    return [
+      storedChain.id,
+      chainEntry(storedChain.startBlock, storedChain.endBlock, storedChain.maxReorgDepth, addresses)
+    ];
+  });
+  let currentEntries = Stdlib_Array.filterMap(chainConfigs, chain => {
+    if (added !== undefined && Primitive_object.equal(added.id, chain.id)) {
+      return;
+    }
+    let startBlock = chain.startBlock;
+    let tmp;
+    tmp = startBlock === "latest" ? Stdlib_Option.map(storedChainOf(chain.id), storedChain => storedChain.startBlock) : startBlock;
+    return [
+      chain.id,
+      chainEntry(tmp, chain.endBlock, chain.maxReorgDepth, chain.contracts.flatMap(contract => contract.addresses.map(address => [
+        contract.name,
+        address
+      ])))
+    ];
+  });
+  let changedPaths = Config.diffPaths(withChains(storedEnvioInfo, storedEntries), withChains(envioInfo, currentEntries));
+  let changedPaths$1 = ContractMapping.isEqual(stored.contractMapping, contractMapping) ? changedPaths : changedPaths.concat(["contracts"]);
+  if (changedPaths$1.length !== 0) {
+    return {
+      TAG: "Incompatible",
+      _0: changedPaths$1
+    };
+  } else if (added !== undefined) {
+    return {
+      TAG: "AddChain",
+      _0: added
+    };
+  } else {
+    return "Resume";
+  }
+}
+
+function incompatibleMessage(changedPaths, envioInfo, resetCommand, runCommand) {
+  let hasClickhouse;
+  if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
+    let match = envioInfo["storage"];
+    hasClickhouse = typeof match === "object" && match !== null && !Array.isArray(match) ? Primitive_object.equal(match["clickhouse"], true) : false;
+  } else {
+    hasClickhouse = false;
+  }
+  return Config.incompatibleMessage(changedPaths, resetCommand, runCommand, hasClickhouse);
+}
+
+export {
+  chainEntry,
+  withChains,
+  make,
+  incompatibleMessage,
+}
+/* Utils Not a pure module */

package/src/Supervisor.res

@@ -183,7 +183,7 @@ let fork = (
   )
   if pipeOutput {
     // The supervisor writes a worker's lines the way it writes its own, which is
-    // the only way ink can keep them out of its frame. Each stream keeps the one
+    // the only way the display can print them above its frame. Each stream keeps the one
     // it was written to, so a worker's errors stay on stderr for whoever is
     // redirecting it.
     [
@@ -430,12 +430,12 @@ let run = async (~config: Config.t, ~workers: array<worker>, ~reset) => {
   // same initialization an unsplit run does, and the supervisor hands the
   // connections it used to its workers.
   let persistence = PgStorage.makePersistenceFromConfig(~config)
-  await persistence->Persistence.initForRun(
-    ~config,
-    ~reset,
-    ~isDevelopmentMode=config.isDev,
-    ~requireInitialized=false,
-  )
+  // Checked here once, so the workers don't each check the same handlers.
+  let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(~config)
+  let _ = await Promise.all2((
+    persistence->Persistence.initForRun(~config, ~reset, ~isDevelopmentMode=config.isDev),
+    HandlerLoader.typeCheck(~config, ~autoLoadFiles),
+  ))
   await persistence.storage.close()
 
   let startTime = Date.make()
@@ -508,7 +508,7 @@ let run = async (~config: Config.t, ~workers: array<worker>, ~reset) => {
   )
 
   if shouldUseTui {
-    let _rerender = Tui.start(~config, ~getMetrics=() =>
+    Tui.start(~config, ~getMetrics=() =>
       switch reported() {
       | [] => {...[]->merge, chains: configuredChains(config)}
       | snapshots => snapshots->merge

package/src/Supervisor.res.mjs

@@ -15,6 +15,7 @@ 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 HandlerLoader from "./HandlerLoader.res.mjs";
 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";
@@ -367,7 +368,11 @@ function configuredChains(config) {
 
 async function run(config, workers, reset) {
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.initForRun(persistence, config, reset, config.isDev, false);
+  let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(config);
+  await Promise.all([
+    Persistence.initForRun(persistence, config, reset, config.isDev),
+    HandlerLoader.typeCheck(config, autoLoadFiles)
+  ]);
   await persistence.storage.close();
   let startTime = new Date();
   let startTimeRef = Performance.now();

package/src/TestIndexer.res

@@ -275,7 +275,6 @@ let makeInitialState = (
   {
     cleanRun: true,
     contractMapping,
-    envioInfo: Some(JSON.Encode.object(Dict.make())),
     cache: Dict.make(),
     chains,
     checkpointFrontier: Frontier.empty(),
@@ -567,7 +566,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   isInitialized: async () => true,
   // The runner injects the config-derived initial state by setting
   // `persistence.storageStatus = Ready(...)` directly, bypassing `Persistence.init`,
-  // so neither of these is reached.
+  // so none of these is reached.
   initialize: async (
     ~chainConfigs as _=?,
     ~entities as _=?,
@@ -578,7 +577,15 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~chainIds as _, ~throwIfIncompatible as _) =>
+  readStoredConfig: async () =>
+    JsError.throwWithMessage(
+      "TestIndexer: readStoredConfig should not be called; the initial state is derived from config.",
+    ),
+  addChain: async (~chainConfig as _, ~entities as _, ~contractMapping as _) =>
+    JsError.throwWithMessage(
+      "TestIndexer: addChain should not be called; the initial state is derived from config.",
+    ),
+  resumeInitialState: async (~entities as _, ~chainIds as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -666,7 +673,10 @@ let getRegistrations = (~config) =>
   switch registrationsRef.contents {
   | Some(promise) => promise
   | None =>
-    let promise = HandlerLoader.registerAllHandlers(~config)
+    let promise =
+      HandlerLoader.getAutoLoadFiles(~config)->Promise.then(autoLoadFiles =>
+        HandlerLoader.registerAllHandlers(~config, ~autoLoadFiles)
+      )
     registrationsRef := Some(promise)
     promise
   }

package/src/TestIndexer.res.mjs

@@ -195,7 +195,6 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
   return {
     cleanRun: true,
     contractMapping: contractMapping,
-    envioInfo: {},
     cache: {},
     chains: chains,
     checkpointFrontier: Frontier.empty(),
@@ -388,6 +387,8 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    readStoredConfig: async () => Stdlib_JsError.throwWithMessage("TestIndexer: readStoredConfig should not be called; the initial state is derived from config."),
+    addChain: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
     resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1, param$2) => {},
@@ -427,7 +428,7 @@ function getRegistrations(config) {
   if (promise !== undefined) {
     return promise;
   }
-  let promise$1 = HandlerLoader.registerAllHandlers(config);
+  let promise$1 = HandlerLoader.getAutoLoadFiles(config).then(autoLoadFiles => HandlerLoader.registerAllHandlers(config, autoLoadFiles));
   registrationsRef.contents = promise$1;
   return promise$1;
 }

package/src/TsModuleHooks.mjs

@@ -0,0 +1,121 @@
+import module from "node:module";
+import { fileURLToPath } from "node:url";
+import { unsupportedNodeMessage } from "./NodeVersion.mjs";
+
+const TS_URL = /\.[cm]?tsx?$/;
+const JSON_URL = /\.json($|\?)/;
+const NOT_FOUND_CODES = new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+]);
+
+let registered = false;
+
+// Node's own resolver still resolves every candidate the addon offers, so
+// package exports and conditions behave as they do without the hooks.
+export const register = (addon) => {
+  if (registered) return;
+  registered = true;
+
+  // The CLI checks this first thing; a test indexer gets here without it.
+  const unsupported = unsupportedNodeMessage();
+  if (unsupported !== undefined) throw new Error(unsupported);
+
+  // Node ignores the source maps `loadTs` inlines unless this is on.
+  module.setSourceMapsSupport(true);
+
+  // What legacy decorators lower to; tslib's `__decorate`, `__param` and
+  // `__metadata`.
+  const helpers = (globalThis.babelHelpers ??= {});
+  // A function rather than an arrow: the argument count tells a class
+  // decorator from a member's.
+  helpers.decorate ??= function (decorators, target, key, descriptor) {
+    const argumentCount = arguments.length;
+    let result =
+      argumentCount < 3
+        ? target
+        : descriptor === null
+          ? (descriptor = Object.getOwnPropertyDescriptor(target, key))
+          : descriptor;
+    for (let index = decorators.length - 1; index >= 0; index--) {
+      const decorator = decorators[index];
+      if (decorator) {
+        result =
+          (argumentCount < 3
+            ? decorator(result)
+            : argumentCount > 3
+              ? decorator(target, key, result)
+              : decorator(target, key)) || result;
+      }
+    }
+    if (argumentCount > 3 && result) Object.defineProperty(target, key, result);
+    return result;
+  };
+  helpers.decorateParam ??= (index, decorator) => (target, key) => decorator(target, key, index);
+  helpers.decorateMetadata ??= (key, value) =>
+    typeof Reflect === "object" && typeof Reflect.metadata === "function"
+      ? Reflect.metadata(key, value)
+      : undefined;
+
+  const firstResolved = (candidates, context, nextResolve) => {
+    for (const candidate of candidates) {
+      try {
+        return nextResolve(candidate, context);
+      } catch (error) {
+        if (!NOT_FOUND_CODES.has(error?.code)) throw error;
+      }
+    }
+    return undefined;
+  };
+
+  module.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      // Handlers are ES modules, so `require()` only comes from dependencies,
+      // including the one Node makes to read a CommonJS module's named
+      // exports. It resolves as it would without the hooks.
+      if (specifier.startsWith("node:") || context.conditions?.includes("require")) {
+        return nextResolve(specifier, context);
+      }
+      const [path, query] = specifier.split("?");
+      let resolved = firstResolved(
+        addon.tsResolveCandidates(path, context.parentURL ?? null),
+        context,
+        nextResolve
+      );
+      if (resolved === undefined) {
+        try {
+          resolved = nextResolve(path, context);
+        } catch (error) {
+          resolved =
+            NOT_FOUND_CODES.has(error?.code) &&
+            firstResolved(
+              addon.tsNotFoundCandidates(error.code, error.url ?? null, error.message),
+              context,
+              nextResolve
+            );
+          if (!resolved) throw error;
+        }
+      }
+      const url = query ? `${resolved.url}?${query}` : resolved.url;
+      // TypeScript's `resolveJsonModule` imports JSON without the
+      // `type: "json"` attribute Node requires.
+      if (JSON_URL.test(url) && context.importAttributes?.type === undefined) {
+        return {
+          ...resolved,
+          url,
+          importAttributes: { ...context.importAttributes, type: "json" },
+          shortCircuit: true,
+        };
+      }
+      return { ...resolved, url, shortCircuit: true };
+    },
+
+    load(url, context, nextLoad) {
+      if (!url.startsWith("file:") || !TS_URL.test(new URL(url).pathname)) {
+        return nextLoad(url, context);
+      }
+      return { format: "module", source: addon.loadTs(fileURLToPath(url)), shortCircuit: true };
+    },
+  });
+};

package/src/Utils.res

@@ -10,14 +10,6 @@ external toMethod: 'a => 'a = "%unsafe_to_method"
 
 @val external importPath: string => promise<unknown> = "import"
 
-@val
-external importPathWithJson: (
-  string,
-  @as(json`{with: {type: "json"}}`) _,
-) => promise<{
-  "default": JSON.t,
-}> = "import"
-
 // Half the delay fixed, half spread across it. Every indexer pointed at one
 // provider loses its stream, or gives up on a quiet chain, in the same instant
 // that provider blinks, and putting them all back on the same schedule is how a

package/src/Worker.res

@@ -82,6 +82,14 @@ let bindToSupervisor = () => {
 
 %%private(let send = (message: workerMessage) => NodeJs.Process.sendToParent(message)->ignore)
 
+// A worker done with its chains exits only once its final snapshot is on the
+// channel: the last periodic one can be up to an interval old, and the
+// supervisor would go on reporting those chains as it left them.
+let exitAfterReporting = (~metrics: Metrics.t) =>
+  NodeJs.Process.sendToParentThen(Snapshot({metrics, runtime: Metrics.sampleRuntime()}), () =>
+    NodeJs.process->NodeJs.exitWithCode(Success)
+  )->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.

package/src/Worker.res.mjs

@@ -51,6 +51,16 @@ function bindToSupervisor() {
   });
 }
 
+function exitAfterReporting(metrics) {
+  process.send({
+    kind: "snapshot",
+    metrics: metrics,
+    runtime: Metrics.sampleRuntime()
+  }, () => {
+    Process.exit(0);
+  });
+}
+
 function bindRun(getMetrics, onReleaseRealtime) {
   if (isEnabled) {
     Metrics.startRuntimeCollectors();
@@ -76,6 +86,7 @@ export {
   config,
   isEnabled,
   bindToSupervisor,
+  exitAfterReporting,
   bindRun,
 }
 /* configSchema Not a pure module */

package/src/bindings/NodeJs.res

@@ -69,9 +69,17 @@ module Process = {
   // `process` rather than off a namespace import, which would drop the
   // receiver Node's own implementations read.
   @val @scope("process") external sendToParent: 'msg => bool = "send"
+  // The callback runs once the message is handed to the channel.
+  @val @scope("process") external sendToParentThen: ('msg, unit => unit) => bool = "send"
   @val @scope("process")
   external onMessage: (@as("message") _, 'msg => unit) => unit = "on"
   @val @scope("process") external onSignal: (string, unit => unit) => unit = "on"
+  @val @scope("process") external offSignal: (string, unit => unit) => unit = "removeListener"
+  @val @scope("process") external listenerCount: string => int = "listenerCount"
+  @val @scope("process") external pid: int = "pid"
+  @val @scope("process") external kill: (int, string) => bool = "kill"
+  @val @scope("process")
+  external onExit: (@as("exit") _, unit => unit) => unit = "on"
   // Present only in a process forked with an IPC channel.
   @val @scope("process") external channel: Nullable.t<unknown> = "channel"
   @val @scope("process")
@@ -205,17 +213,10 @@ module Url = {
 module ImportMeta = {
   type t = {url: Url.t}
   @val external importMeta: t = "import.meta"
-  // Get import.meta.url as string for module registration
-  @val external url: string = "import.meta.url"
   // Resolve module specifier to file:// URL
   @val external resolve: string => string = "import.meta.resolve"
 }
 
-module Module = {
-  // Register ESM loader hooks (e.g., for TypeScript support via tsx)
-  @module("node:module") external register: (string, string) => unit = "register"
-}
-
 module Path = {
   type t
 

package/src/bindings/NodeJs.res.mjs

@@ -41,8 +41,6 @@ let Url$1 = {};
 
 let ImportMeta = {};
 
-let Module = {};
-
 function getDirname(importMeta) {
   return Path.dirname(Url.fileURLToPath(importMeta.url));
 }
@@ -68,7 +66,6 @@ export {
   ChildProcess,
   Url$1 as Url,
   ImportMeta,
-  Module,
   Path$1 as Path,
   WorkerThreads,
   Fs,

package/src/bindings/Pino.res

@@ -113,8 +113,8 @@ module ECS = {
 }
 
 /**
-Jank solution to make logs use console log wrather than stream.write so that ink 
-can render the logs statically.
+Logs through `console.log` rather than `stream.write`, so that the TUI can print
+them above its frame.
 */
 module MultiStreamLogger = {
   type stream = {write: string => unit}