ponder 0.14.13 → 0.15.0

package/dist/types/utils/abi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../src/utils/abi.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,GAAG,EACR,KAAK,QAAQ,EACb,KAAK,WAAW,EAEjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAEL,KAAK,GAAG,EAMT,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;GAGG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;KACnE;CACF;AAED,KAAK,YAAY,GAAG;IAGlB,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,GAAG,CAAC;IAEd,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF,KAAK,eAAe,GAAG;IAGrB,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,GAAG,CAAC;IAEd,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAAA;KAAE,CAAC;IACxD,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,GAAG,GAAG,YAAY,GAAG,SAAS,CAAA;KAAE,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,GAAG,GAAG,eAAe,GAAG,SAAS,CAAA;KAAE,CAAC;CACzD,CAAC;AAEF,eAAO,MAAM,cAAc;;eA0B1B,CAAC;AAEF,wBAAgB,WAAW,CACzB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,GACzD;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;CAC5B,EAAE,CAmBF;AAgBD,eAAO,MAAM,iBAAiB;;kBA0B7B,CAAC"}
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../src/utils/abi.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,GAAG,EACR,KAAK,QAAQ,EACb,KAAK,WAAW,EAEjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAEL,KAAK,GAAG,EAIT,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;GAGG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;KACnE;CACF;AAED,eAAO,MAAM,UAAU;;UAGF,QAAQ,GAAG,WAAW;YA8B1C,CAAC;AAEF,wBAAgB,WAAW,CACzB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,GACzD;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC;CAC5B,EAAE,CAmBF"}

package/dist/types/utils/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare const chunk: <T>(array: T[], size: number) => T[][];
+//# sourceMappingURL=chunk.d.ts.map

package/dist/types/utils/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/utils/chunk.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,wBAAyB,MAAM,UAMhD,CAAC"}

package/dist/types/utils/promiseAllSettledWithThrow.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Like `Promise.allSettled` but throws if any of the promises reject.
+ *
+ * @dev This is very useful when dealing with multiple concurrent promises
+ * in a database transaction.
+ */
+export declare function promiseAllSettledWithThrow<T>(promises: Promise<T>[]): Promise<T[]>;
+//# sourceMappingURL=promiseAllSettledWithThrow.d.ts.map

package/dist/types/utils/promiseAllSettledWithThrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseAllSettledWithThrow.d.ts","sourceRoot":"","sources":["../../../src/utils/promiseAllSettledWithThrow.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,CAAC,EAChD,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC,CAkBd"}

package/dist/types/utils/sql-parse.d.ts

@@ -0,0 +1,21 @@
+import type { Node } from "@pgsql/types";
+export declare const parseSQLQuery: (sql: string) => Promise<Node>;
+/**
+ * Validate a SQL query.
+ *
+ * @param sql - SQL query
+ */
+export declare const validateAllowableSQLQuery: (sql: string) => Promise<void>;
+/**
+ * Return `true` if the SQL query is readonly, else `false`.
+ *
+ * @param sql - SQL query
+ */
+export declare const isReadonlySQLQuery: (sql: string) => Promise<boolean>;
+/**
+ * Find all referenced relations in a SQL query.
+ *
+ * @param sql - SQL query
+ */
+export declare const getSQLQueryRelations: (sql: string) => Promise<Set<string>>;
+//# sourceMappingURL=sql-parse.d.ts.map

package/dist/types/utils/sql-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-parse.d.ts","sourceRoot":"","sources":["../../../src/utils/sql-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAqB,MAAM,cAAc,CAAC;AAe5D,eAAO,MAAM,aAAa,QAAe,MAAM,KAAG,QAAQ,IAAI,CAiC7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,QAAe,MAAM,kBAuD1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAe,MAAM,KAAG,QAAQ,OAAO,CA2BrE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAC1B,MAAM,KACV,QAAQ,IAAI,MAAM,CAAC,CAoDrB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ponder",
-  "version": "0.14.13",
+  "version": "0.15.0",
   "description": "An open-source framework for crypto application backends",
   "license": "MIT",
   "type": "module",
@@ -99,7 +99,7 @@
     "rimraf": "^5.0.5",
     "tsx": "^4.19.2",
     "vitest": "^1.0.2",
-    "@ponder/client": "0.14.13"
+    "@ponder/client": "0.15.0"
   },
   "engines": {
     "node": ">=18.14"

package/src/bin/commands/createViews.ts

@@ -10,6 +10,11 @@ import {
   createDatabase,
   getPonderMetaTable,
 } from "@/database/index.js";
+import {
+  getLiveQueryChannelName,
+  getLiveQueryNotifyProcedureName,
+  getViewsLiveQueryNotifyTriggerName,
+} from "@/drizzle/onchain.js";
 import { sql } from "@/index.js";
 import { createLogger } from "@/internal/logger.js";
 import { MetricsService } from "@/internal/metrics.js";
@@ -257,25 +262,40 @@ export async function createViews({
     ),
   );
 
-  const trigger = `status_${cliOptions.viewsSchema}_trigger`;
-  const notification = "status_notify()";
-  const channel = `${cliOptions.viewsSchema}_status_channel`;
+  const notifyProcedure = getLiveQueryNotifyProcedureName();
+  const channel = getLiveQueryChannelName(cliOptions.viewsSchema);
 
   await database.adminQB.wrap((db) =>
-    db.execute(
-      `
-CREATE OR REPLACE FUNCTION "${cliOptions.viewsSchema}".${notification}
-RETURNS TRIGGER
-LANGUAGE plpgsql
+    db.execute(`
+CREATE OR REPLACE FUNCTION "${cliOptions.viewsSchema}".${notifyProcedure}
+RETURNS TRIGGER LANGUAGE plpgsql
 AS $$
-BEGIN
-NOTIFY "${channel}";
-RETURN NULL;
-END;
-$$;`,
-    ),
+  DECLARE
+    table_names json;
+    table_exists boolean := false;
+  BEGIN
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.tables
+      WHERE table_name = 'live_query_tables'
+      AND table_type = 'LOCAL TEMPORARY'
+    ) INTO table_exists;
+
+    IF table_exists THEN
+      SELECT json_agg(table_name) INTO table_names
+      FROM live_query_tables;
+
+      table_names := COALESCE(table_names, '[]'::json);
+      PERFORM pg_notify('${channel}', table_names::text);
+    END IF;
+
+    RETURN NULL;
+  END;
+$$;`),
   );
 
+  const trigger = getViewsLiveQueryNotifyTriggerName(cliOptions.viewsSchema);
+
   await database.adminQB.wrap((db) =>
     db.execute(
       `
@@ -283,7 +303,7 @@ CREATE OR REPLACE TRIGGER "${trigger}"
 AFTER INSERT OR UPDATE OR DELETE
 ON "${cliOptions.schema!}"._ponder_checkpoint
 FOR EACH STATEMENT
-EXECUTE PROCEDURE "${cliOptions.viewsSchema}".${notification};`,
+EXECUTE PROCEDURE "${cliOptions.viewsSchema}".${notifyProcedure};`,
     ),
   );
 

package/src/bin/commands/dev.ts

@@ -19,7 +19,9 @@ import { createServer } from "@/server/index.js";
 import { createUi } from "@/ui/index.js";
 import { createQueue } from "@/utils/queue.js";
 import type { Result } from "@/utils/result.js";
+import { isolatedController } from "../isolatedController.js";
 import type { CliOptions } from "../ponder.js";
+import { runCodegen } from "../utils/codegen.js";
 import { createExit } from "../utils/exit.js";
 
 export async function dev({ cliOptions }: { cliOptions: CliOptions }) {
@@ -73,6 +75,8 @@ export async function dev({ cliOptions }: { cliOptions: CliOptions }) {
     );
   }
 
+  runCodegen({ common });
+
   const build = await createBuild({ common, cliOptions });
 
   if (cliOptions.disableUi !== true) {
@@ -174,7 +178,10 @@ export async function dev({ cliOptions }: { cliOptions: CliOptions }) {
           return;
         }
 
-        const compileSchemaResult = build.compileSchema(schemaResult.result);
+        const compileSchemaResult = build.compileSchema({
+          ...schemaResult.result,
+          preBuild: preCompileResult.result,
+        });
 
         if (compileSchemaResult.status === "error") {
           common.logger.error({
@@ -344,26 +351,41 @@ export async function dev({ cliOptions }: { cliOptions: CliOptions }) {
           schemaBuild: compileSchemaResult.result,
         });
 
-        if (preCompileResult.result.ordering === "omnichain") {
-          runOmnichain({
-            common,
-            database,
-            preBuild: preCompileResult.result,
-            namespaceBuild: { schema, viewsSchema: undefined },
-            schemaBuild: compileSchemaResult.result,
-            indexingBuild: indexingBuildResult.result,
-            crashRecoveryCheckpoint,
-          });
-        } else {
-          runMultichain({
-            common,
-            database,
-            preBuild: preCompileResult.result,
-            namespaceBuild: { schema, viewsSchema: undefined },
-            schemaBuild: compileSchemaResult.result,
-            indexingBuild: indexingBuildResult.result,
-            crashRecoveryCheckpoint,
-          });
+        switch (preCompileResult.result.ordering) {
+          case "omnichain":
+            runOmnichain({
+              common,
+              database,
+              preBuild: preCompileResult.result,
+              namespaceBuild: { schema, viewsSchema: undefined },
+              schemaBuild: compileSchemaResult.result,
+              indexingBuild: indexingBuildResult.result,
+              crashRecoveryCheckpoint,
+            });
+            break;
+          case "multichain":
+            runMultichain({
+              common,
+              database,
+              preBuild: preCompileResult.result,
+              namespaceBuild: { schema, viewsSchema: undefined },
+              schemaBuild: compileSchemaResult.result,
+              indexingBuild: indexingBuildResult.result,
+              crashRecoveryCheckpoint,
+            });
+            break;
+          case "experimental_isolated": {
+            isolatedController({
+              common,
+              database,
+              preBuild: preCompileResult.result,
+              namespaceBuild: { schema, viewsSchema: undefined },
+              schemaBuild: compileSchemaResult.result,
+              indexingBuild: indexingBuildResult.result,
+              crashRecoveryCheckpoint,
+            });
+            break;
+          }
         }
       } else {
         metrics.resetApiMetrics();

package/src/bin/commands/prune.ts

@@ -12,6 +12,10 @@ import {
 } from "@/database/index.js";
 import { TABLES } from "@/database/index.js";
 import { sqlToReorgTableName } from "@/drizzle/kit/index.js";
+import {
+  getLiveQueryNotifyProcedureName,
+  getLiveQueryProcedureName,
+} from "@/drizzle/onchain.js";
 import { createLogger } from "@/internal/logger.js";
 import { MetricsService } from "@/internal/metrics.js";
 import { buildOptions } from "@/internal/options.js";
@@ -215,6 +219,8 @@ export async function prune({ cliOptions }: { cliOptions: CliOptions }) {
         tablesToDrop.push(`"${schema}"."${sqlToReorgTableName(table)}"`);
         functionsToDrop.push(`"${schema}"."operation_reorg__${table}"`);
       }
+      functionsToDrop.push(`"${schema}".${getLiveQueryProcedureName()}`);
+      functionsToDrop.push(`"${schema}".${getLiveQueryNotifyProcedureName()}`);
       if ("view_names" in value) {
         for (const view of value.view_names) {
           viewsToDrop.push(`"${schema}"."${view}"`);

package/src/bin/commands/serve.ts

@@ -126,7 +126,10 @@ export async function serve({ cliOptions }: { cliOptions: CliOptions }) {
     return;
   }
 
-  const compileSchemaResult = build.compileSchema(schemaResult.result);
+  const compileSchemaResult = build.compileSchema({
+    ...schemaResult.result,
+    preBuild: preCompileResult.result,
+  });
 
   if (compileSchemaResult.status === "error") {
     common.logger.error({

package/src/bin/commands/start.ts

@@ -1,3 +1,4 @@
+import { runCodegen } from "@/bin/utils/codegen.js";
 import { createBuild } from "@/build/index.js";
 import { type Database, createDatabase } from "@/database/index.js";
 import type { Common } from "@/internal/common.js";
@@ -17,6 +18,7 @@ import type {
 import { runMultichain } from "@/runtime/multichain.js";
 import { runOmnichain } from "@/runtime/omnichain.js";
 import { createServer } from "@/server/index.js";
+import { isolatedController } from "../isolatedController.js";
 import type { CliOptions } from "../ponder.js";
 import { createExit } from "../utils/exit.js";
 
@@ -83,6 +85,8 @@ export async function start({
     );
   }
 
+  runCodegen({ common });
+
   const build = await createBuild({ common, cliOptions });
 
   // biome-ignore lint/style/useConst: <explanation>
@@ -146,7 +150,10 @@ export async function start({
     return;
   }
 
-  const compileSchemaResult = build.compileSchema(schemaResult.result);
+  const compileSchemaResult = build.compileSchema({
+    ...schemaResult.result,
+    preBuild: preCompileResult.result,
+  });
 
   if (compileSchemaResult.status === "error") {
     common.logger.error({
@@ -292,11 +299,19 @@ export async function start({
 
   metrics.initializeIndexingMetrics(app);
 
-  if (preCompileResult.result.ordering === "omnichain") {
-    runOmnichain(app);
-  } else {
-    runMultichain(app);
+  switch (preCompileResult.result.ordering) {
+    case "omnichain":
+      runOmnichain(app);
+      break;
+    case "multichain":
+      runMultichain(app);
+      break;
+    case "experimental_isolated": {
+      isolatedController(app);
+      break;
+    }
   }
+
   createServer(app);
 
   return shutdown.kill;

package/src/bin/isolatedController.ts

@@ -0,0 +1,300 @@
+import path from "node:path";
+import url from "node:url";
+import v8 from "node:v8";
+import { Worker } from "node:worker_threads";
+import { createIndexes, createViews } from "@/database/actions.js";
+import { type Database, getPonderMetaTable } from "@/database/index.js";
+import type { Common } from "@/internal/common.js";
+import {
+  NonRetryableUserError,
+  nonRetryableUserErrorNames,
+} from "@/internal/errors.js";
+import { AggregateMetricsService, getAppProgress } from "@/internal/metrics.js";
+import type {
+  CrashRecoveryCheckpoint,
+  IndexingBuild,
+  NamespaceBuild,
+  PreBuild,
+  SchemaBuild,
+} from "@/internal/types.js";
+import { runIsolated } from "@/runtime/isolated.js";
+import { chunk } from "@/utils/chunk.js";
+import { formatEta, formatPercentage } from "@/utils/format.js";
+import { startClock } from "@/utils/timer.js";
+import { isTable, isView, sql } from "drizzle-orm";
+import type { isolatedWorker } from "./isolatedWorker.js";
+
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+type WorkerState = "backfill" | "live" | "complete";
+
+export async function isolatedController({
+  common,
+  preBuild,
+  namespaceBuild,
+  schemaBuild,
+  indexingBuild,
+  crashRecoveryCheckpoint,
+  database,
+}: {
+  common: Common;
+  preBuild: PreBuild;
+  namespaceBuild: NamespaceBuild;
+  schemaBuild: SchemaBuild;
+  indexingBuild: IndexingBuild;
+  crashRecoveryCheckpoint: CrashRecoveryCheckpoint;
+  database: Database;
+}) {
+  const backfillEndClock = startClock();
+  const perChainState = new Map<number, WorkerState>();
+
+  const etaInterval = setInterval(async () => {
+    const { eta, progress } = await getAppProgress(common.metrics);
+
+    if (eta === undefined && progress === undefined) {
+      return;
+    }
+
+    common.logger.info({
+      msg: "Updated backfill indexing progress",
+      progress: progress === undefined ? undefined : formatPercentage(progress),
+      estimate: eta === undefined ? undefined : formatEta(eta * 1_000),
+    });
+  }, 5_000);
+
+  common.shutdown.add(() => {
+    clearInterval(etaInterval);
+  });
+
+  let isAllReady = false;
+  let isAllComplete = false;
+  const callback = async () => {
+    if (
+      isAllReady === false &&
+      indexingBuild.chains.every(
+        (chain) => perChainState.get(chain.id) !== "backfill",
+      )
+    ) {
+      isAllReady = true;
+
+      common.logger.info({
+        msg: "Completed backfill indexing across all chains",
+        duration: backfillEndClock(),
+      });
+      clearInterval(etaInterval);
+
+      let endClock = startClock();
+      await createIndexes(database.adminQB, {
+        statements: schemaBuild.statements,
+      });
+
+      if (schemaBuild.statements.indexes.sql.length > 0) {
+        common.logger.info({
+          msg: "Created database indexes",
+          count: schemaBuild.statements.indexes.sql.length,
+          duration: endClock(),
+        });
+      }
+
+      if (namespaceBuild.viewsSchema !== undefined) {
+        endClock = startClock();
+
+        const tables = Object.values(schemaBuild.schema).filter(isTable);
+        const views = Object.values(schemaBuild.schema).filter(isView);
+        await createViews(database.adminQB, { tables, views, namespaceBuild });
+
+        common.logger.info({
+          msg: "Created database views",
+          schema: namespaceBuild.viewsSchema,
+          count: tables.length,
+          duration: endClock(),
+        });
+
+        endClock = startClock();
+      }
+
+      await database.adminQB.wrap({ label: "update_ready" }, (db) =>
+        db
+          .update(getPonderMetaTable(namespaceBuild.schema))
+          .set({ value: sql`jsonb_set(value, '{is_ready}', to_jsonb(1))` }),
+      );
+
+      common.logger.info({
+        msg: "Started returning 200 responses",
+        endpoint: "/ready",
+      });
+    }
+
+    if (
+      isAllComplete === false &&
+      indexingBuild.chains.every(
+        (chain) => perChainState.get(chain.id) === "complete",
+      )
+    ) {
+      isAllComplete = true;
+    }
+  };
+
+  if (
+    common.options.command === "dev" ||
+    indexingBuild.chains.length === 1 ||
+    database.driver.dialect === "pglite" ||
+    common.options.maxThreads === 1
+  ) {
+    common.options.indexingCacheMaxBytes = Math.floor(
+      common.options.indexingCacheMaxBytes / indexingBuild.chains.length,
+    );
+    common.options.rpcMaxConcurrency = Math.floor(
+      common.options.rpcMaxConcurrency / indexingBuild.chains.length,
+    );
+    common.options.syncEventsQuerySize = Math.floor(
+      common.options.syncEventsQuerySize / indexingBuild.chains.length,
+    );
+
+    await Promise.all(
+      indexingBuild.chains.map(async (chain) => {
+        const chainIndex = indexingBuild.chains.findIndex(
+          (c) => c.id === chain.id,
+        );
+        const _indexingBuild = {
+          ...indexingBuild,
+          chains: [indexingBuild.chains[chainIndex]!],
+          rpcs: [indexingBuild.rpcs[chainIndex]!],
+          finalizedBlocks: [indexingBuild.finalizedBlocks[chainIndex]!],
+          eventCallbacks: [indexingBuild.eventCallbacks[chainIndex]!],
+          setupCallbacks: [indexingBuild.setupCallbacks[chainIndex]!],
+          contracts: [indexingBuild.contracts[chainIndex]!],
+        };
+
+        perChainState.set(chain.id, "backfill");
+
+        await runIsolated({
+          common,
+          preBuild,
+          namespaceBuild,
+          schemaBuild,
+          indexingBuild: _indexingBuild,
+          crashRecoveryCheckpoint,
+          database,
+          onReady: () => {
+            perChainState.set(chain.id, "live");
+            callback();
+          },
+        });
+
+        perChainState.set(chain.id, "complete");
+        callback();
+      }),
+    );
+  } else {
+    const workerPath = path.join(__dirname, "isolatedWorker.js");
+
+    const perThreadChains = chunk(
+      indexingBuild.chains,
+      Math.ceil(indexingBuild.chains.length / common.options.maxThreads),
+    );
+
+    const perThreadWorkers: Worker[] = [];
+    for (const chains of perThreadChains) {
+      const chainIds = chains.map((chain) => chain.id);
+
+      // Note: This is a hack to force color support in the worker threads
+      if (process.stdout.isTTY) {
+        process.env.FORCE_COLOR = "1";
+      }
+
+      const heapSizeLimit = v8.getHeapStatistics().heap_size_limit;
+      const perThreadHeapSizeLimit = Math.floor(
+        heapSizeLimit / (common.options.maxThreads + 1) / 1024 / 1024,
+      );
+
+      // Note: This sets `--max-old-space-size` for the worker thread.
+      // `resourceLimits` does not work because it gets overridden by
+      // CLI flags or environment variables. It does not change the heap
+      // size limit for the current main thread
+      v8.setFlagsFromString(`--max-old-space-size=${perThreadHeapSizeLimit}`);
+
+      const worker = new Worker(workerPath, {
+        workerData: {
+          options: common.options,
+          chainIds,
+          namespaceBuild,
+          crashRecoveryCheckpoint,
+        } satisfies Parameters<typeof isolatedWorker>[0],
+      });
+
+      for (const chainId of chainIds) {
+        perChainState.set(chainId, "backfill");
+      }
+
+      worker.on(
+        "message",
+        (
+          message:
+            | { type: "ready"; chainId: number }
+            | { type: "done"; chainId: number }
+            | { type: "error"; error: Error },
+        ) => {
+          switch (message.type) {
+            case "ready": {
+              perChainState.set(message.chainId, "live");
+              callback();
+              break;
+            }
+            case "done": {
+              perChainState.set(message.chainId, "complete");
+              callback();
+              break;
+            }
+            case "error": {
+              let error: Error;
+              if (nonRetryableUserErrorNames.includes(message.error.name)) {
+                error = new NonRetryableUserError(message.error.message);
+              } else {
+                error = new Error(message.error.message);
+              }
+              error.name = message.error.name;
+              error.stack = message.error.stack;
+              throw error;
+            }
+          }
+        },
+      );
+
+      worker.on("error", (error: Error) => {
+        if (nonRetryableUserErrorNames.includes(error.name)) {
+          error = new NonRetryableUserError(error.message);
+        } else {
+          error = new Error(error.message);
+        }
+        throw error;
+      });
+
+      worker.on("exit", (code: number) => {
+        const error = new Error(`Worker thread exited with code ${code}.`);
+        error.stack = undefined;
+        throw error;
+      });
+
+      perThreadWorkers.push(worker);
+    }
+
+    common.logger.debug({
+      msg: "Created worker threads",
+      count: perThreadWorkers.length,
+      duration: backfillEndClock(),
+    });
+
+    common.metrics = new AggregateMetricsService(
+      common.metrics,
+      perThreadWorkers,
+    );
+
+    common.shutdown.add(() => {
+      for (const worker of perThreadWorkers) {
+        worker.postMessage({ type: "kill" });
+      }
+    });
+  }
+}