@sshkeda/task 0.0.0-stage → 1.0.0

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/follow-imports-from-entry-files.ts

@@ -0,0 +1,306 @@
+import { Cache, Effect, FileSystem, Option, Path } from "effect";
+
+import {
+  findBunLoaderForScript,
+  isDataLoader,
+} from "../../../../../shared/find-bun-loader-for-script.ts";
+import type { makeNodeModulesPackageFinder } from "../../../../../shared/find-node-modules-package-directory.ts";
+import { CodeFileUnreadable } from "../../../../../shared/module-graph-errors.ts";
+import { TASK_PACKAGE } from "../../../../../shared/task-package.ts";
+import { findPackageJsonDirectoryPath } from "../../../shared/find-package-directories.ts";
+import { listDirectoryPathsUpToRoot } from "../../../shared/list-directory-paths-up-to-root.ts";
+import { ImportNotFound } from "../../../shared/main-thread-errors.ts";
+import type { ModuleRefusal } from "../../../shared/main-thread-errors.ts";
+import {
+  PackageJsonUnreadable,
+  PackageJsonWithoutName,
+} from "../../../shared/package-json-errors.ts";
+import { readBarePackageName } from "../../../shared/read-bare-package-name.ts";
+import {
+  decodePackageJsonName,
+  decodePackageJsonText,
+  parsePackageJsonObject,
+  readPackageJsonText,
+  toPackageJsonUnreadable,
+} from "../../../shared/read-package-json.ts";
+import { scanProjectModule } from "../../scan-module-source/index.ts";
+import { loadAllReportingFirstFailure } from "./load-all-reporting-first-failure.ts";
+import { resolveSpecifierToRealFilePath } from "./resolve-module-specifiers.ts";
+
+const findPackageDirectoryNamed = Effect.fn("findPackageDirectoryNamed")(function* (
+  start: string,
+  name: string,
+) {
+  const path = yield* Path.Path;
+  for (const searchDirectoryPath of listDirectoryPathsUpToRoot(path, start)) {
+    const packageJsonFilePath = `${searchDirectoryPath}/package.json`;
+    const packageJsonText = yield* readPackageJsonText(packageJsonFilePath).pipe(
+      Effect.asSome,
+      Effect.catchReason("PlatformError", "NotFound", () => Effect.succeedNone),
+      Effect.mapError(toPackageJsonUnreadable(packageJsonFilePath)),
+    );
+    if (Option.isNone(packageJsonText)) {
+      continue;
+    }
+    const packageJsonObject = yield* parsePackageJsonObject(
+      packageJsonFilePath,
+      packageJsonText.value,
+    );
+    const packageName = yield* decodePackageJsonName(packageJsonFilePath, packageJsonObject);
+    if (Option.contains(packageName, name)) {
+      return searchDirectoryPath;
+    }
+  }
+  return null;
+});
+
+const resolveProjectImport = (
+  specifier: ReturnType<typeof scanProjectModule>["specifiers"][number],
+  importingFilePath: string,
+) =>
+  resolveSpecifierToRealFilePath(importingFilePath, specifier).pipe(
+    Effect.map(
+      ({
+        found,
+        realFilePath,
+      }): {
+        readonly resolvedFilePath: string | null;
+        readonly refusal: typeof ModuleRefusal.Type | null;
+      } =>
+        found
+          ? { resolvedFilePath: realFilePath, refusal: null }
+          : {
+              resolvedFilePath: null,
+              refusal: new ImportNotFound({ importingFilePath, specifier: specifier.value }),
+            },
+    ),
+    Effect.catchTag("ImportResolutionThrew", (refusal) =>
+      Effect.succeed({ resolvedFilePath: null, refusal }),
+    ),
+  );
+
+const listDependencies = (
+  packageJson: Effect.Success<ReturnType<ReturnType<typeof decodePackageJsonText>>>,
+) =>
+  Object.keys({
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.optionalDependencies,
+  });
+
+const mayMakeTasks = (
+  packageJson: Effect.Success<ReturnType<ReturnType<typeof decodePackageJsonText>>>,
+) =>
+  packageJson.name !== TASK_PACKAGE.name &&
+  listDependencies(packageJson).includes(TASK_PACKAGE.name);
+
+export const makeImportFollower = (input: {
+  readonly configuredLoaderOfExtension: ReadonlyMap<string, string>;
+  readonly taskSourceDirectoryPath: string;
+  readonly findNodeModulesPackageDirectoryPath: ReturnType<typeof makeNodeModulesPackageFinder>;
+  readonly concurrency: number;
+}) =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const { taskSourceDirectoryPath, findNodeModulesPackageDirectoryPath, concurrency } = input;
+
+    const packageJsonCache = yield* Cache.make({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: (packageDirectoryPath: string) => {
+        const packageJsonFilePath = path.join(packageDirectoryPath, "package.json");
+        return fileSystem.readFileString(packageJsonFilePath).pipe(
+          Effect.mapError(
+            (cause) => new PackageJsonUnreadable({ filePath: packageJsonFilePath, cause }),
+          ),
+          Effect.flatMap(decodePackageJsonText(packageJsonFilePath)),
+          Effect.flatMap((packageJson) => {
+            const { name } = packageJson;
+            return name === undefined
+              ? Effect.fail(new PackageJsonWithoutName({ filePath: packageJsonFilePath }))
+              : Effect.succeed({ ...packageJson, name });
+          }),
+        );
+      },
+    });
+
+    const packageJsonDirectoryPathCache = yield* Cache.make({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: findPackageJsonDirectoryPath,
+    });
+
+    const parsedModuleFileCache = yield* Cache.make({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: Effect.fn("readAndParseModuleFile")(function* (moduleFilePath: string) {
+        const script = findBunLoaderForScript(moduleFilePath, input.configuredLoaderOfExtension);
+        if (script === null) {
+          return null;
+        }
+        const text = yield* fileSystem
+          .readFileString(moduleFilePath)
+          .pipe(
+            Effect.mapError((cause) => new CodeFileUnreadable({ filePath: moduleFilePath, cause })),
+          );
+        const projectModuleScan = scanProjectModule(
+          moduleFilePath,
+          text,
+          script.isConfigured ? script.loader : null,
+        );
+        const resolvedSpecifiers = yield* Effect.forEach(
+          projectModuleScan.specifiers,
+          (specifier) =>
+            resolveProjectImport(specifier, moduleFilePath).pipe(
+              Effect.map((resolution) => ({ specifier, ...resolution })),
+            ),
+          { concurrency },
+        );
+        return {
+          text,
+          loader: script.loader,
+          resolvedSpecifiers,
+          madeTasks: projectModuleScan.madeTasks,
+          refusals: projectModuleScan.refusals.map((refusal): typeof ModuleRefusal.Type => ({
+            filePath: moduleFilePath,
+            refusal,
+          })),
+        };
+      }),
+    });
+
+    const MODULE_WITHOUT_CODE = { imports: [], madeTasks: [], refusals: [] };
+
+    const loadModule = Effect.fn("loadModule")(function* (importedModule: {
+      readonly filePath: string;
+      readonly packageDirectoryPathOutsideNodeModules: string | null;
+    }) {
+      const moduleFilePath = importedModule.filePath;
+      if (moduleFilePath.startsWith(taskSourceDirectoryPath)) {
+        return MODULE_WITHOUT_CODE;
+      }
+      const nodeModulesPackageDirectoryPath = findNodeModulesPackageDirectoryPath(moduleFilePath);
+      const isInstalled = nodeModulesPackageDirectoryPath !== null;
+      const isUnfollowedInstalledModule =
+        isInstalled &&
+        !mayMakeTasks(yield* Cache.get(packageJsonCache, nodeModulesPackageDirectoryPath));
+      if (isUnfollowedInstalledModule) {
+        return MODULE_WITHOUT_CODE;
+      }
+      const packageDirectoryPath =
+        nodeModulesPackageDirectoryPath ?? importedModule.packageDirectoryPathOutsideNodeModules;
+
+      const parsed = yield* Cache.get(parsedModuleFileCache, moduleFilePath);
+      if (parsed === null) {
+        return MODULE_WITHOUT_CODE;
+      }
+
+      const followsBarePackagesOutsideNodeModules =
+        !isInstalled &&
+        (importedModule.packageDirectoryPathOutsideNodeModules !== null ||
+          (yield* Cache.get(packageJsonDirectoryPathCache, path.dirname(moduleFilePath))) === null);
+      const findPackageDirectoryPathOutsideNodeModules = (
+        specifier: ReturnType<typeof scanProjectModule>["specifiers"][number],
+        importedFilePath: string,
+      ) => {
+        const packageName = readBarePackageName(specifier.value);
+        if (findNodeModulesPackageDirectoryPath(importedFilePath) !== null) {
+          return Effect.succeed(null);
+        }
+        const followsBarePackage =
+          followsBarePackagesOutsideNodeModules && packageName !== undefined;
+        if (followsBarePackage) {
+          return findPackageDirectoryNamed(path.dirname(importedFilePath), packageName);
+        }
+        const isInsideTheImportingPackage =
+          !isInstalled &&
+          packageDirectoryPath !== null &&
+          importedFilePath.startsWith(`${packageDirectoryPath}/`);
+        return Effect.succeed(isInsideTheImportingPackage ? packageDirectoryPath : null);
+      };
+      const refusals = [...parsed.refusals];
+      const imports: (typeof importedModule)[] = [];
+      for (const { specifier, resolvedFilePath, refusal } of parsed.resolvedSpecifiers) {
+        if (refusal !== null) {
+          refusals.push(refusal);
+          continue;
+        }
+        const isFollowedCodeImport =
+          resolvedFilePath !== null &&
+          specifier.kind !== "require.resolve" &&
+          !isDataLoader(specifier.loader);
+        if (isFollowedCodeImport) {
+          imports.push({
+            filePath: resolvedFilePath,
+            packageDirectoryPathOutsideNodeModules:
+              yield* findPackageDirectoryPathOutsideNodeModules(specifier, resolvedFilePath),
+          });
+        }
+      }
+      return { imports, madeTasks: parsed.madeTasks, refusals };
+    });
+
+    const walkReachableModules = Effect.fn("findReachableModules")(function* (
+      entryFilePath: string,
+    ) {
+      const reachable = new Map<string, Effect.Success<ReturnType<typeof loadModule>>>();
+      const loadWave = (wave: readonly Parameters<typeof loadModule>[0][]) =>
+        loadAllReportingFirstFailure(
+          wave,
+          (importedModule) =>
+            loadModule(importedModule).pipe(
+              Effect.map((module) => [importedModule.filePath, module] as const),
+            ),
+          concurrency,
+        );
+      const walkWave = (
+        wave: readonly Parameters<typeof loadModule>[0][],
+      ): Effect.Effect<
+        void,
+        Effect.Error<ReturnType<typeof loadWave>>,
+        Effect.Services<ReturnType<typeof loadWave>>
+      > =>
+        wave.length === 0
+          ? Effect.void
+          : loadWave(wave).pipe(
+              Effect.flatMap((loadedWave) => {
+                for (const [moduleFilePath, module] of loadedWave) {
+                  reachable.set(moduleFilePath, module);
+                }
+                const nextWave = new Map<string, Parameters<typeof loadModule>[0]>();
+                for (const [, module] of loadedWave) {
+                  for (const importedModule of module.imports) {
+                    const queuedPackageDirectoryPath = nextWave.get(
+                      importedModule.filePath,
+                    )?.packageDirectoryPathOutsideNodeModules;
+                    const importedPackageDirectoryPath =
+                      importedModule.packageDirectoryPathOutsideNodeModules;
+                    const isNewOrDeeperPackageImport =
+                      !reachable.has(importedModule.filePath) &&
+                      (queuedPackageDirectoryPath === undefined ||
+                        queuedPackageDirectoryPath === null ||
+                        (importedPackageDirectoryPath !== null &&
+                          importedPackageDirectoryPath.length > queuedPackageDirectoryPath.length));
+                    if (isNewOrDeeperPackageImport) {
+                      nextWave.set(importedModule.filePath, importedModule);
+                    }
+                  }
+                }
+                return walkWave([...nextWave.values()]);
+              }),
+            );
+      yield* walkWave([{ filePath: entryFilePath, packageDirectoryPathOutsideNodeModules: null }]);
+      return reachable;
+    });
+
+    const reachableModulesCache = yield* Cache.make({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: walkReachableModules,
+    });
+
+    return {
+      findReachableModules: (entryFilePath: string) =>
+        Cache.get(reachableModulesCache, entryFilePath),
+      readParsedModuleFile: (moduleFilePath: string) =>
+        Cache.get(parsedModuleFileCache, moduleFilePath),
+    };
+  });

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/load-all-reporting-first-failure.ts

@@ -0,0 +1,11 @@
+import { Effect, Result } from "effect";
+
+export const loadAllReportingFirstFailure = <Item, Loaded, Failure, Requirements>(
+  items: readonly Item[],
+  load: (item: Item) => Effect.Effect<Loaded, Failure, Requirements>,
+  concurrency: number,
+) =>
+  Effect.all(
+    items.map((item) => load(item)),
+    { concurrency, mode: "result" },
+  ).pipe(Effect.flatMap((results) => Effect.fromResult(Result.all(results))));

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/make-module-graph.ts

@@ -0,0 +1,48 @@
+import { Context, Effect, Path } from "effect";
+import type { FileSystem } from "effect";
+
+import { makeNodeModulesPackageFinder } from "../../../../../shared/find-node-modules-package-directory.ts";
+import { dieOnInvariantFailure } from "../../../../../shared/invariant-errors.ts";
+import { availableParallelism } from "../../../../../shared/read-environment-config.ts";
+import { TASK_PACKAGE } from "../../../../../shared/task-package.ts";
+import { RunRootTaskConfig } from "../../../shared/provide-run-root-task-config.ts";
+import { makeImportFollower } from "./follow-imports-from-entry-files.ts";
+import { readConfiguredLoaders } from "./read-configured-loaders.ts";
+import { makeWorkerImportRewriter } from "./rewrite-worker-imports.ts";
+
+export const makeModuleGraph = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const runRootTaskConfig = yield* RunRootTaskConfig;
+  const context = yield* Effect.context<FileSystem.FileSystem | Path.Path>();
+  const taskSourceDirectoryPath = yield* path
+    .fromFileUrl(new URL("../../../../../", import.meta.url))
+    .pipe(dieOnInvariantFailure("module graph", "the runtime source URL is a file URL"));
+  const findNodeModulesPackageDirectoryPath = makeNodeModulesPackageFinder(
+    runRootTaskConfig.rootTaskPackageJsonDirectoryPath,
+  );
+  const importFollower = yield* makeImportFollower({
+    configuredLoaderOfExtension: yield* readConfiguredLoaders({
+      labelCodeFile: (filePath) =>
+        path.relative(runRootTaskConfig.rootTaskPackageJsonDirectoryPath, filePath),
+      workingDirectoryPathAtStart: runRootTaskConfig.workingDirectoryPathAtStart,
+    }),
+    taskSourceDirectoryPath,
+    findNodeModulesPackageDirectoryPath,
+    concurrency: yield* availableParallelism,
+  });
+  const rewriteBareImports = makeWorkerImportRewriter(
+    importFollower,
+    findNodeModulesPackageDirectoryPath,
+  );
+  return {
+    rewriteBareImports: (roots: readonly string[]) =>
+      rewriteBareImports(roots).pipe(Effect.provide(context)),
+    findReachableModules: (entryFilePath: string) =>
+      importFollower.findReachableModules(entryFilePath).pipe(Effect.provide(context)),
+  };
+});
+
+export class ModuleGraph extends Context.Service<
+  ModuleGraph,
+  Effect.Success<typeof makeModuleGraph>
+>()(`${TASK_PACKAGE.name}/ModuleGraph`) {}

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/read-configured-loaders.ts

@@ -0,0 +1,64 @@
+import { Array as Arrays, Effect, FileSystem, Option, Path, Schema } from "effect";
+
+import { BunfigUnparsable, CodeFileUnreadable } from "../../../../../shared/module-graph-errors.ts";
+import { bunArguments } from "../../../../../shared/read-environment-config.ts";
+
+const listFlagValues = (
+  argumentList: readonly string[],
+  flag: { readonly name: string; readonly takesNextArgument: boolean },
+) =>
+  argumentList.flatMap((argument, index) => {
+    if (argument.startsWith(`${flag.name}=`)) {
+      return [argument.slice(flag.name.length + 1)];
+    }
+    const nextArgument = argumentList[index + 1];
+    const isFlagFollowedByValue =
+      flag.takesNextArgument && argument === flag.name && nextArgument !== undefined;
+    return isFlagFollowedByValue ? [nextArgument] : [];
+  });
+
+const decodeBunfigLoaders = Schema.decodeUnknownEffect(
+  Schema.Struct({ loader: Schema.optional(Schema.Record(Schema.String, Schema.String)) }),
+);
+
+export const readConfiguredLoaders = Effect.fn("readConfiguredLoaders")(function* (input: {
+  readonly labelCodeFile: (filePath: string) => string;
+  readonly workingDirectoryPathAtStart: string;
+}) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const startArguments = yield* bunArguments;
+  const configFilePath = Arrays.last(
+    listFlagValues(startArguments, { name: "--config", takesNextArgument: false }),
+  );
+  const bunfigFilePath = Option.isSome(configFilePath)
+    ? path.resolve(input.workingDirectoryPathAtStart, configFilePath.value)
+    : path.join(input.workingDirectoryPathAtStart, "bunfig.toml");
+  const bunfigText = yield* fileSystem.readFileString(bunfigFilePath).pipe(
+    Effect.asSome,
+    Effect.catchReason("PlatformError", "NotFound", () => Effect.succeedNone),
+    Effect.mapError((cause) => new CodeFileUnreadable({ filePath: bunfigFilePath, cause })),
+  );
+  const bunfigLoaders = Option.isNone(bunfigText)
+    ? {}
+    : ((yield* Effect.try(() => Bun.TOML.parse(bunfigText.value)).pipe(
+        Effect.flatMap(decodeBunfigLoaders),
+        Effect.mapError(
+          (cause) => new BunfigUnparsable({ filePath: input.labelCodeFile(bunfigFilePath), cause }),
+        ),
+      )).loader ?? {});
+  const argumentLoaders = ["--loader", "-l"]
+    .flatMap((name) => listFlagValues(startArguments, { name, takesNextArgument: true }))
+    .flatMap((extensionAndLoader) => {
+      const separatorIndex = extensionAndLoader.indexOf(":");
+      return separatorIndex === -1
+        ? []
+        : [
+            [
+              extensionAndLoader.slice(0, separatorIndex),
+              extensionAndLoader.slice(separatorIndex + 1),
+            ] as const,
+          ];
+    });
+  return new Map([...Object.entries(bunfigLoaders), ...argumentLoaders]);
+});

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/resolve-module-specifiers.ts

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
+
+import { ImportResolutionThrew } from "../../../../../shared/module-graph-errors.ts";
+import type { scanProjectModule } from "../../scan-module-source/index.ts";
+
+const isModuleNotFound = Schema.is(
+  Schema.Struct({ code: Schema.Literals(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"]) }),
+);
+
+const resolveSpecifier = (
+  importingFilePath: string,
+  specifier: Pick<ReturnType<typeof scanProjectModule>["specifiers"][number], "kind" | "value">,
+) =>
+  Path.Path.use((path) =>
+    specifier.kind === "import"
+      ? Effect.tryPromise({
+          try: () => Bun.resolve(specifier.value, path.dirname(importingFilePath)),
+          catch: (cause) =>
+            new ImportResolutionThrew({ importingFilePath, specifier: specifier.value, cause }),
+        })
+      : Effect.try({
+          try: () => createRequire(importingFilePath).resolve(specifier.value),
+          catch: (cause) =>
+            new ImportResolutionThrew({ importingFilePath, specifier: specifier.value, cause }),
+        }),
+  ).pipe(
+    Effect.asSome,
+    Effect.catchTag("ImportResolutionThrew", (failure) =>
+      isModuleNotFound(failure.cause) ? Effect.succeedNone : Effect.fail(failure),
+    ),
+  );
+
+export const resolveSpecifierToRealFilePath = (
+  importingFilePath: string,
+  specifier: Pick<ReturnType<typeof scanProjectModule>["specifiers"][number], "kind" | "value">,
+) =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const resolvedPath = yield* resolveSpecifier(importingFilePath, specifier);
+    if (Option.isNone(resolvedPath)) {
+      return { found: false, realFilePath: null };
+    }
+    if (!path.isAbsolute(resolvedPath.value)) {
+      return { found: true, realFilePath: null };
+    }
+    return {
+      found: true,
+      realFilePath: yield* fileSystem
+        .realPath(resolvedPath.value)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new ImportResolutionThrew({ importingFilePath, specifier: specifier.value, cause }),
+          ),
+        ),
+    };
+  });

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/rewrite-worker-imports.ts

@@ -0,0 +1,118 @@
+import { Array as Arrays, Chunk, Effect, Schema } from "effect";
+
+import { isDataLoader } from "../../../../../shared/find-bun-loader-for-script.ts";
+import type { makeNodeModulesPackageFinder } from "../../../../../shared/find-node-modules-package-directory.ts";
+import { dieOnInvariantFailure } from "../../../../../shared/invariant-errors.ts";
+import { readBarePackageName } from "../../../shared/read-bare-package-name.ts";
+import type { makeImportFollower } from "./follow-imports-from-entry-files.ts";
+import { WorkerImportRefused } from "./worker-import-errors.ts";
+
+const encodeQuotedString = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
+
+export const makeWorkerImportRewriter = (
+  importFollower: Effect.Success<ReturnType<typeof makeImportFollower>>,
+  findNodeModulesPackageDirectoryPath: ReturnType<typeof makeNodeModulesPackageFinder>,
+) => {
+  const { findReachableModules, readParsedModuleFile } = importFollower;
+  return Effect.fn("rewriteBareImports")(function* (roots: readonly string[]) {
+    const reachableModulesOfRoots = yield* Effect.forEach(roots, findReachableModules);
+    for (const reachableModules of reachableModulesOfRoots) {
+      for (const module of reachableModules.values()) {
+        const [firstRefusal] = module.refusals;
+        if (firstRefusal !== undefined) {
+          return yield* new WorkerImportRefused({ refusal: firstRefusal });
+        }
+      }
+    }
+    const followsPackageOutsideNodeModules = reachableModulesOfRoots.some((reachableModules) =>
+      [...reachableModules.values()].some((module) =>
+        module.imports.some(
+          (importedModule) => importedModule.packageDirectoryPathOutsideNodeModules !== null,
+        ),
+      ),
+    );
+    if (!followsPackageOutsideNodeModules) {
+      return {};
+    }
+
+    const visited = new Set<string>();
+    const pending = [...roots];
+    const rewriteImportsOfFile = (importingFilePath: string) =>
+      Effect.gen(function* () {
+        const parsed = yield* readParsedModuleFile(importingFilePath);
+        if (parsed === null) {
+          return [];
+        }
+        const replacements: {
+          readonly start: number;
+          readonly end: number;
+          readonly text: string;
+        }[] = [];
+        for (const { specifier, resolvedFilePath } of parsed.resolvedSpecifiers.toSorted(
+          (left, right) => right.specifier.start - left.specifier.start,
+        )) {
+          if (resolvedFilePath === null) {
+            continue;
+          }
+          const loadsCode = specifier.kind !== "require.resolve" && !isDataLoader(specifier.loader);
+          if (loadsCode) {
+            pending.push(resolvedFilePath);
+          }
+          const importsBarePackageOutsideNodeModules =
+            readBarePackageName(specifier.value) !== undefined &&
+            findNodeModulesPackageDirectoryPath(resolvedFilePath) === null;
+          if (importsBarePackageOutsideNodeModules) {
+            const quotedResolvedPath = yield* encodeQuotedString(resolvedFilePath).pipe(
+              dieOnInvariantFailure("module graph", "a resolved import path encodes to JSON text"),
+            );
+            replacements.push({
+              start: specifier.start,
+              end: specifier.end,
+              text: quotedResolvedPath,
+            });
+          }
+        }
+        const replacementsInTextOrder = replacements.toReversed();
+        const keptTextStarts = Arrays.prepend(
+          replacementsInTextOrder.map((replacement) => replacement.end),
+          0,
+        );
+        const rewrittenText = [
+          ...Arrays.zipWith(
+            keptTextStarts,
+            replacementsInTextOrder,
+            (keptTextStart, replacement) =>
+              `${parsed.text.slice(keptTextStart, replacement.start)}${replacement.text}`,
+          ),
+          parsed.text.slice(Arrays.lastNonEmpty(keptTextStarts)),
+        ].join("");
+        return rewrittenText === parsed.text
+          ? []
+          : [[importingFilePath, { contents: rewrittenText, loader: parsed.loader }] as const];
+      });
+    const visitNext = (
+      rewrittenSoFar: Chunk.Chunk<Effect.Success<ReturnType<typeof rewriteImportsOfFile>>[number]>,
+    ): Effect.Effect<
+      typeof rewrittenSoFar,
+      Effect.Error<ReturnType<typeof rewriteImportsOfFile>>
+    > => {
+      const importingFilePath = pending.pop();
+      if (importingFilePath === undefined) {
+        return Effect.succeed(rewrittenSoFar);
+      }
+      const isSkippedImportingFile =
+        visited.has(importingFilePath) ||
+        findNodeModulesPackageDirectoryPath(importingFilePath) !== null;
+      if (isSkippedImportingFile) {
+        return Effect.suspend(() => visitNext(rewrittenSoFar));
+      }
+      visited.add(importingFilePath);
+      return rewriteImportsOfFile(importingFilePath).pipe(
+        Effect.flatMap((rewrittenFile) =>
+          visitNext(Chunk.appendAll(rewrittenSoFar, Chunk.fromIterable(rewrittenFile))),
+        ),
+      );
+    };
+    return Object.fromEntries(yield* Effect.suspend(() => visitNext(Chunk.empty())));
+  });
+};

package/src/lib/main-thread/lib/find-code-each-task-depends-on/internal/worker-import-errors.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "../../../../../shared/error-fields.ts";
+import {
+  ModuleRefusal,
+  reportTaskDefinitionViolation,
+} from "../../../shared/main-thread-errors.ts";
+
+export class WorkerImportRefused extends Schema.TaggedError<WorkerImportRefused>()(
+  "WorkerImportRefused",
+  { ...TASK_ERROR_FIELDS, refusal: ModuleRefusal },
+) {
+  public get location() {
+    return reportTaskDefinitionViolation(this.refusal).location;
+  }
+  public override get message() {
+    return `could not rewrite the imports of worker modules because ${reportTaskDefinitionViolation(this.refusal).message}`;
+  }
+}

package/src/lib/main-thread/lib/run-tasks-on-workers/index.ts

@@ -0,0 +1,7 @@
+import { Layer } from "effect";
+
+import { makeTaskRuns, TaskRuns } from "./internal/make-task-runs.ts";
+
+export { TaskRuns } from "./internal/make-task-runs.ts";
+
+export const TaskRunsLive = Layer.effect(TaskRuns, makeTaskRuns);