@sshkeda/task 0.0.0-stage → 1.0.0

package/src/lib/main-thread/lib/run-tasks-on-workers/shared/define-task-run-state.ts

@@ -0,0 +1,288 @@
+import { Cause, Deferred, Effect, Exit, FiberSet, Option, Schema } from "effect";
+import type { Fiber } from "effect";
+
+import {
+  dieOnInvariantFailure,
+  InternalInvariantBroken,
+} from "../../../../../shared/invariant-errors.ts";
+import type { WorkerExited } from "../../../../../shared/process-errors.ts";
+import type { TaskEvent, TaskFiberResult } from "../../../../../shared/rpc.ts";
+import { isAwaitedTasksFailure } from "../../../../../shared/task-errors.ts";
+import type {
+  AwaitedTasksFailure,
+  TaskBodyFailed,
+  TaskCleanupFailed,
+} from "../../../../../shared/task-errors.ts";
+import type { findTasksReachableFromRootTaskFile } from "../../../shared/find-tasks-reachable-from-root-task-file.ts";
+import { makeStopwatch } from "./make-stopwatch.ts";
+import { makeRootTaskStandardInput } from "./share-standard-input-with-root-task.ts";
+
+export const TaskRunStatus = Schema.TaggedUnion({
+  Preparing: {},
+  Running: { workerId: Schema.Int },
+  Serving: { workerId: Schema.Int },
+  Closed: { workerId: Schema.Int },
+  Passed: { workerId: Schema.Int },
+  Failed: {
+    workerId: Schema.NullOr(Schema.Int),
+    causedByAwaitedTasks: Schema.Boolean,
+  },
+  Cancelled: { workerId: Schema.NullOr(Schema.Int) },
+});
+
+export const makeTaskRun = (initial: {
+  readonly status: typeof TaskRunStatus.Type;
+  readonly stepBeforeBody: string | null;
+}) => ({
+  ...initial,
+  logMessages: new Array<string>(),
+  awaitedTaskNames: new Array<string>(),
+  requestFibersByDependencyRequestId: new Map<number, Fiber.Fiber<unknown, unknown>>(),
+  bodyRequestedTaskNames: new Set<string>(),
+  bodyWaitingOnRequestedTasks: makeStopwatch(),
+  bodyOutcomeDeferred: Deferred.makeUnsafe<
+    typeof TaskEvent.cases.TaskFiberServed.Type | typeof TaskFiberResult.cases.Returned.Type,
+    TaskBodyFailed | TaskCleanupFailed | WorkerExited | typeof AwaitedTasksFailure.Type
+  >(),
+  bodyLoadingDeferred: Deferred.makeUnsafe<void>(),
+  bodyStartedAtMillisecondsDeferred: Deferred.makeUnsafe<number>(),
+  bodyCleanupStartedDeferred: Deferred.makeUnsafe<void>(),
+  bodyFailedBeforeCleanupDeferred: Deferred.makeUnsafe<void>(),
+  bodyFinishedDeferred: Deferred.makeUnsafe<void>(),
+});
+
+export const findAssignedWorkerId = (status: typeof TaskRunStatus.Type) =>
+  "workerId" in status ? status.workerId : null;
+
+export const isUnfinishedOnWorker = (taskRun: ReturnType<typeof makeTaskRun>, workerId: number) =>
+  findAssignedWorkerId(taskRun.status) === workerId &&
+  !Deferred.isDoneUnsafe(taskRun.bodyFinishedDeferred);
+
+const isServingStatus = TaskRunStatus.isAnyOf(["Serving"]);
+
+const isServing = (taskRun: ReturnType<typeof makeTaskRun>) => isServingStatus(taskRun.status);
+
+const isOccupyingWorker = (taskRun: ReturnType<typeof makeTaskRun>) =>
+  !isServing(taskRun) && taskRun.requestFibersByDependencyRequestId.size === 0;
+
+export const findTaskNamesOccupyingWorker = (
+  runsByTaskName: ReadonlyMap<string, ReturnType<typeof makeTaskRun>>,
+  workerId: number,
+) =>
+  [...runsByTaskName]
+    .filter(([, taskRun]) => isUnfinishedOnWorker(taskRun, workerId) && isOccupyingWorker(taskRun))
+    .map(([taskName]) => taskName);
+
+export const formatWaitingForWorker = (
+  workerId: number,
+  longestOccupyingTaskName: string,
+  otherTaskNames: readonly string[],
+) => {
+  const others =
+    otherTaskNames.length === 0
+      ? ""
+      : ` and ${otherTaskNames.length} other task${otherTaskNames.length === 1 ? "" : "s"}`;
+  return `waiting for worker ${workerId}, which is running "${longestOccupyingTaskName}"${others}`;
+};
+
+export const countWorkerLoad = (
+  unfinishedTaskRunsOnWorker: readonly ReturnType<typeof makeTaskRun>[],
+) => ({
+  occupyingTaskCount: unfinishedTaskRunsOnWorker.filter((taskRun) => isOccupyingWorker(taskRun))
+    .length,
+  servingTaskCount: unfinishedTaskRunsOnWorker.filter((taskRun) => isServing(taskRun)).length,
+});
+
+export const formatTaskRunStatusForTrace = (status: typeof TaskRunStatus.Type) =>
+  TaskRunStatus.guards.Preparing(status) ? "running" : status._tag.toLowerCase();
+
+const withReadOnlyStatus = (
+  taskRun: ReturnType<typeof makeTaskRun>,
+): Omit<ReturnType<typeof makeTaskRun>, "status"> & {
+  readonly status: typeof TaskRunStatus.Type;
+} => taskRun;
+
+const requireAssignedWorkerId = (taskName: string, status: typeof TaskRunStatus.Type) => {
+  const workerId = findAssignedWorkerId(status);
+  return workerId === null
+    ? Effect.die(
+        new InternalInvariantBroken({
+          area: "task lifecycle",
+          invariant: `"${taskName}" has an assigned worker before its body completes`,
+        }),
+      )
+    : Effect.succeed(workerId);
+};
+
+export const makeTaskRunsState = Effect.gen(function* () {
+  const discoveredTasksByName: Effect.Success<
+    ReturnType<typeof findTasksReachableFromRootTaskFile>
+  > = new Map();
+  const taskNamesWhoseFailureReachedAnAwaitingTask = new Set<string>();
+  const taskRunsByName = new Map<string, ReturnType<typeof makeTaskRun>>();
+  const taskRunsSeenByCallers: ReadonlyMap<
+    string,
+    ReturnType<typeof withReadOnlyStatus>
+  > = taskRunsByName;
+  const taskNamesAssignedToWorker = new Map<number, Set<string>>();
+  const bodyBusyClocksByWorkerId = new Map<
+    number,
+    {
+      readonly busy: ReturnType<typeof makeStopwatch>;
+      readonly taskNamesRunningOccupyingBodies: Set<string>;
+    }
+  >();
+  return {
+    discoveredTasksByName,
+    taskNamesWhoseFailureReachedAnAwaitingTask,
+    runsByTaskName: taskRunsSeenByCallers,
+    taskFibers: yield* FiberSet.make(),
+    rootTaskStandardInput: yield* makeRootTaskStandardInput,
+    runSpan: yield* Effect.currentSpan.pipe(
+      dieOnInvariantFailure("task runs", "task execution has a run span"),
+    ),
+    createRecord: (taskName: string) => {
+      const taskRun = makeTaskRun({
+        status: TaskRunStatus.cases.Preparing.make({}),
+        stepBeforeBody: null,
+      });
+      taskRunsByName.set(taskName, taskRun);
+      return withReadOnlyStatus(taskRun);
+    },
+    recordWorkerAssignment: (taskName: string, workerId: number) =>
+      Effect.gen(function* () {
+        const taskRun = taskRunsByName.get(taskName);
+        const isNotAwaitingWorker =
+          taskRun === undefined || !TaskRunStatus.guards.Preparing(taskRun.status);
+        if (isNotAwaitingWorker) {
+          return yield* Effect.die(
+            new InternalInvariantBroken({
+              area: "task lifecycle",
+              invariant: `"${taskName}" is waiting before worker assignment`,
+            }),
+          );
+        }
+        taskRun.status = TaskRunStatus.cases.Running.make({ workerId });
+        const assignedTaskNames = taskNamesAssignedToWorker.get(workerId) ?? new Set();
+        taskNamesAssignedToWorker.set(workerId, assignedTaskNames.add(taskName));
+      }),
+    readWorkerLoad: (workerId: number) => {
+      const assignedTaskNames = taskNamesAssignedToWorker.get(workerId) ?? new Set();
+      const unfinishedTaskRuns: ReturnType<typeof makeTaskRun>[] = [];
+      for (const taskName of assignedTaskNames) {
+        const taskRun = taskRunsByName.get(taskName);
+        const isNoLongerOnWorker =
+          taskRun === undefined || !isUnfinishedOnWorker(taskRun, workerId);
+        if (isNoLongerOnWorker) {
+          assignedTaskNames.delete(taskName);
+        } else {
+          unfinishedTaskRuns.push(taskRun);
+        }
+      }
+      return countWorkerLoad(unfinishedTaskRuns);
+    },
+    refreshBodyClocks: (taskName: string, nowMilliseconds: number) => {
+      const taskRun = taskRunsByName.get(taskName);
+      if (taskRun === undefined) {
+        return;
+      }
+      taskRun.bodyWaitingOnRequestedTasks.update(
+        taskRun.requestFibersByDependencyRequestId.size > 0,
+        nowMilliseconds,
+      );
+      const workerId = findAssignedWorkerId(taskRun.status);
+      if (workerId === null) {
+        return;
+      }
+      const busyClock = bodyBusyClocksByWorkerId.get(workerId) ?? {
+        busy: makeStopwatch(),
+        taskNamesRunningOccupyingBodies: new Set<string>(),
+      };
+      bodyBusyClocksByWorkerId.set(workerId, busyClock);
+      const isRunningOccupyingBody =
+        Deferred.isDoneUnsafe(taskRun.bodyStartedAtMillisecondsDeferred) &&
+        isUnfinishedOnWorker(taskRun, workerId) &&
+        isOccupyingWorker(taskRun);
+      if (isRunningOccupyingBody) {
+        busyClock.taskNamesRunningOccupyingBodies.add(taskName);
+      } else {
+        busyClock.taskNamesRunningOccupyingBodies.delete(taskName);
+      }
+      busyClock.busy.update(busyClock.taskNamesRunningOccupyingBodies.size > 0, nowMilliseconds);
+    },
+    readWorkerBodyBusyMilliseconds: (workerId: number, nowMilliseconds: number) => {
+      const busyClock = bodyBusyClocksByWorkerId.get(workerId);
+      return busyClock === undefined ? 0 : busyClock.busy.readMilliseconds(nowMilliseconds);
+    },
+    markServing: (taskName: string) => {
+      const taskRun = taskRunsByName.get(taskName);
+      if (taskRun === undefined) {
+        return;
+      }
+      if (TaskRunStatus.guards.Running(taskRun.status)) {
+        taskRun.status = TaskRunStatus.cases.Serving.make({
+          workerId: taskRun.status.workerId,
+        });
+      }
+    },
+    markClosed: (taskName: string) => {
+      const taskRun = taskRunsByName.get(taskName);
+      if (taskRun === undefined) {
+        return false;
+      }
+      if (!TaskRunStatus.guards.Serving(taskRun.status)) {
+        return false;
+      }
+      taskRun.status = TaskRunStatus.cases.Closed.make({
+        workerId: taskRun.status.workerId,
+      });
+      return true;
+    },
+    markPassed: (taskName: string) =>
+      Effect.gen(function* () {
+        const taskRun = taskRunsByName.get(taskName);
+        if (taskRun !== undefined) {
+          taskRun.status = TaskRunStatus.cases.Passed.make({
+            workerId: yield* requireAssignedWorkerId(taskName, taskRun.status),
+          });
+        }
+      }),
+    markEndedFromExit: (
+      taskName: string,
+      taskExit: Exit.Exit<Schema.Json | undefined, unknown>,
+    ) => {
+      const taskRun = taskRunsByName.get(taskName);
+      const isNotEndingFromFailure =
+        taskRun === undefined ||
+        (!TaskRunStatus.guards.Preparing(taskRun.status) &&
+          !TaskRunStatus.guards.Running(taskRun.status)) ||
+        !Exit.isFailure(taskExit);
+      if (isNotEndingFromFailure) {
+        return;
+      }
+      const workerId = findAssignedWorkerId(taskRun.status);
+      if (Cause.hasInterruptsOnly(taskExit.cause)) {
+        taskRun.status = TaskRunStatus.cases.Cancelled.make({ workerId });
+        return;
+      }
+      const failure = Cause.findErrorOption(taskExit.cause);
+      taskRun.status = TaskRunStatus.cases.Failed.make({
+        workerId,
+        causedByAwaitedTasks: Option.exists(failure, isAwaitedTasksFailure),
+      });
+    },
+    recordFailureReachedAwaitingTask: (taskName: string) => {
+      taskNamesWhoseFailureReachedAnAwaitingTask.add(taskName);
+    },
+    markFailed: (taskName: string) =>
+      Effect.sync(() => {
+        const taskRun = taskRunsByName.get(taskName);
+        if (taskRun !== undefined) {
+          taskRun.status = TaskRunStatus.cases.Failed.make({
+            workerId: findAssignedWorkerId(taskRun.status),
+            causedByAwaitedTasks: false,
+          });
+        }
+      }),
+  };
+});

package/src/lib/main-thread/lib/run-tasks-on-workers/shared/make-stopwatch.ts

@@ -0,0 +1,39 @@
+import { Option } from "effect";
+
+const STOPPED_STOPWATCH = {
+  millisecondsBeforeRunningSince: 0,
+  runningSince: Option.none<number>(),
+};
+
+const readStopwatchMilliseconds = (stopwatch: typeof STOPPED_STOPWATCH, nowMilliseconds: number) =>
+  stopwatch.millisecondsBeforeRunningSince +
+  Option.match(stopwatch.runningSince, {
+    onNone: () => 0,
+    onSome: (runningSince) => nowMilliseconds - runningSince,
+  });
+
+const switchStopwatch = (
+  stopwatch: typeof STOPPED_STOPWATCH,
+  isRunning: boolean,
+  nowMilliseconds: number,
+) => {
+  const isAlreadyInState = isRunning === Option.isSome(stopwatch.runningSince);
+  if (isAlreadyInState) {
+    return stopwatch;
+  }
+  return {
+    millisecondsBeforeRunningSince: readStopwatchMilliseconds(stopwatch, nowMilliseconds),
+    runningSince: isRunning ? Option.some(nowMilliseconds) : Option.none(),
+  };
+};
+
+export const makeStopwatch = () => {
+  const stopwatch = { ...STOPPED_STOPWATCH };
+  return {
+    readMilliseconds: (nowMilliseconds: number) =>
+      readStopwatchMilliseconds(stopwatch, nowMilliseconds),
+    update: (isRunning: boolean, nowMilliseconds: number) => {
+      Object.assign(stopwatch, switchStopwatch(stopwatch, isRunning, nowMilliseconds));
+    },
+  };
+};

package/src/lib/main-thread/lib/run-tasks-on-workers/shared/share-standard-input-with-root-task.ts

@@ -0,0 +1,36 @@
+import { Cause, Effect, FiberSet, Pull, Scope, Stdio, Stream } from "effect";
+
+import { describeCauseMessage } from "../../../../../shared/report-errors.ts";
+import { StandardInputRead } from "../../../../../shared/rpc.ts";
+import { RunRootTaskConfig } from "../../../shared/provide-run-root-task-config.ts";
+
+export const makeRootTaskStandardInput = Effect.gen(function* () {
+  const stdio = yield* Stdio.Stdio;
+  const rootTaskName = (yield* RunRootTaskConfig).rootTask.name;
+  const isTerminal = yield* stdio.stdinIsTerminal;
+  const runScope = yield* Effect.scope;
+  const pullStandardInputChunks = yield* Effect.cached(
+    Stream.toPull(stdio.stdin).pipe(Scope.provide(runScope)),
+  );
+  const readFibers = yield* FiberSet.make();
+  const readNextChunks = pullStandardInputChunks.pipe(
+    Effect.flatMap((pull) =>
+      Pull.matchEffect(pull, {
+        onSuccess: (chunks) => Effect.succeed(StandardInputRead.cases.Chunks.make({ chunks })),
+        onDone: () => Effect.succeed(StandardInputRead.cases.Ended.make({})),
+        onFailure: (cause) =>
+          Effect.succeed(
+            StandardInputRead.cases.Failed.make({
+              reason: describeCauseMessage(Cause.squash(cause)),
+            }),
+          ),
+      }),
+    ),
+  );
+  return {
+    standardInput: { isTerminal, rootTaskName },
+    answerNextRead: <Failure, Services>(
+      answer: (read: typeof StandardInputRead.Type) => Effect.Effect<void, Failure, Services>,
+    ) => FiberSet.run(readFibers, Effect.flatMap(readNextChunks, answer)),
+  };
+});

package/src/lib/main-thread/lib/run-tasks-on-workers/shared/stop-task.ts

@@ -0,0 +1,166 @@
+import { Array as Arrays, Deferred, Effect, Option, Duration } from "effect";
+
+import { dieOnInvariantFailure } from "../../../../../shared/invariant-errors.ts";
+import { TASK_TRACE_LABEL_PREFIX } from "../../../../../shared/names-from-package-json.ts";
+import { printTaskLines } from "../../../../../shared/print-to-standard-error.ts";
+import { TASK_PACKAGE } from "../../../../../shared/task-package.ts";
+import { failTask } from "../../../shared/fail-run.ts";
+import {
+  TaskCleanupFrozeWorker,
+  TaskCleanupNotStarted,
+  TaskCleanupTimedOut,
+} from "../../../shared/main-thread-errors.ts";
+import { ProcessGroups } from "../../../shared/provide-process-groups.ts";
+import { StopState } from "../../../shared/provide-stop-state.ts";
+import { WorkerPool } from "../../../shared/provide-worker-pool.ts";
+import { findAssignedWorkerId, isUnfinishedOnWorker } from "./define-task-run-state.ts";
+import type { makeTaskRunsState } from "./define-task-run-state.ts";
+
+const STILL_STOPPING_NOTICE_SECONDS = 2;
+
+const STILL_STOPPING_NOTICE_AFTER = Duration.seconds(STILL_STOPPING_NOTICE_SECONDS);
+
+const failCleanup = Effect.fn("failCleanup")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  failure: TaskCleanupFrozeWorker | TaskCleanupNotStarted | TaskCleanupTimedOut,
+) {
+  yield* (yield* StopState).recordFirstFailure(failure);
+  yield* failTask(failure, taskRunsState.markFailed);
+});
+
+const findCleanupDuration = (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  taskName: string,
+) =>
+  Effect.fromNullishOr(taskRunsState.discoveredTasksByName.get(taskName)).pipe(
+    dieOnInvariantFailure("task lifecycle", "a task cleaning up on a worker was discovered"),
+    Effect.map((discoveredTask) => discoveredTask.cleanupDuration),
+  );
+
+const watchWorkerOfCleanupPastItsLimit = Effect.fn("watchWorkerOfCleanupPastItsLimit")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  taskName: string,
+  workerId: number,
+  cleanupDuration: Duration.Duration,
+) {
+  const workerPool = yield* WorkerPool;
+  const taskRun = yield* Effect.fromNullishOr(taskRunsState.runsByTaskName.get(taskName)).pipe(
+    dieOnInvariantFailure("task lifecycle", "a task whose cleanup is watched was started"),
+  );
+  const cleanupEnded = Deferred.await(taskRun.bodyFinishedDeferred).pipe(
+    Effect.as("cleanup ended" as const),
+  );
+  const checkWorkerAnswers = Effect.gen(function* () {
+    const cleanupDurationsOnWorker = yield* Effect.forEach(
+      [...taskRunsState.runsByTaskName].filter(
+        ([, otherTaskRun]) =>
+          isUnfinishedOnWorker(otherTaskRun, workerId) &&
+          (Deferred.isDoneUnsafe(otherTaskRun.bodyCleanupStartedDeferred) ||
+            Deferred.isDoneUnsafe(otherTaskRun.bodyFailedBeforeCleanupDeferred)),
+      ),
+      ([otherTaskName]) => findCleanupDuration(taskRunsState, otherTaskName),
+    );
+    const answerLimit = Arrays.max([cleanupDuration, ...cleanupDurationsOnWorker], Duration.Order);
+    const answer = yield* workerPool
+      .awaitAnswer(workerId)
+      .pipe(
+        Effect.raceFirst(cleanupEnded),
+        Effect.timeoutOption(answerLimit),
+        Effect.map(
+          Option.match({ onNone: () => "unanswered" as const, onSome: (outcome) => outcome }),
+        ),
+      );
+    if (answer === "answered") {
+      yield* cleanupEnded.pipe(Effect.timeoutOption(cleanupDuration));
+    }
+    return answer;
+  });
+  const lastAnswer = yield* checkWorkerAnswers.pipe(
+    Effect.repeat({ while: (answer) => answer === "answered" }),
+  );
+  if (lastAnswer !== "unanswered") {
+    return;
+  }
+  yield* workerPool.requestWorkerTermination(
+    workerId,
+    `because its cleanup of "${taskName}" ran past its ${Duration.format(cleanupDuration)} limit and then it stopped answering`,
+  );
+  yield* failCleanup(
+    taskRunsState,
+    new TaskCleanupFrozeWorker({
+      taskName,
+      cleanupMilliseconds: Duration.toMillis(cleanupDuration),
+    }),
+  );
+});
+
+export const stopTask = Effect.fn("stopTask")(function* (
+  taskRunsState: Effect.Success<typeof makeTaskRunsState>,
+  taskName: string,
+  watchUntilStopsEnd: <Services>(
+    watch: Effect.Effect<void, never, Services>,
+  ) => Effect.Effect<void, never, Services>,
+) {
+  yield* Effect.annotateCurrentSpan(`${TASK_TRACE_LABEL_PREFIX}.task`, taskName);
+  const processGroups = yield* ProcessGroups;
+  const discoveredTask = taskRunsState.discoveredTasksByName.get(taskName);
+  const taskRun = taskRunsState.runsByTaskName.get(taskName);
+  const isTaskNotStarted = discoveredTask === undefined || taskRun === undefined;
+  if (isTaskNotStarted) {
+    return;
+  }
+  const workerId = findAssignedWorkerId(taskRun.status);
+  const hasNoBodyToStop = workerId === null || Deferred.isDoneUnsafe(taskRun.bodyFinishedDeferred);
+  if (hasNoBodyToStop) {
+    return;
+  }
+
+  const workerPool = yield* WorkerPool;
+  yield* workerPool.stopTaskFiber(workerId, taskName);
+  const cleanupDuration = discoveredTask.cleanupDuration;
+  const awaitBodyFinished = Effect.gen(function* () {
+    const finishedBeforeNotice = yield* Deferred.await(taskRun.bodyFinishedDeferred).pipe(
+      Effect.timeoutOption(STILL_STOPPING_NOTICE_AFTER),
+    );
+    if (Option.isSome(finishedBeforeNotice)) {
+      return;
+    }
+    yield* printTaskLines(
+      "Warn",
+      taskName,
+      `still stopping after ${Duration.format(STILL_STOPPING_NOTICE_AFTER)}; ${TASK_PACKAGE.name} ends it when its ${Duration.format(cleanupDuration)} cleanup limit passes`,
+    );
+    yield* Deferred.await(taskRun.bodyFinishedDeferred);
+  });
+  const ended = yield* awaitBodyFinished.pipe(Effect.timeoutOption(cleanupDuration));
+  if (Option.isSome(ended)) {
+    return;
+  }
+
+  yield* Effect.uninterruptible(
+    Effect.gen(function* () {
+      const workerAnsweredStop = Deferred.isDoneUnsafe(taskRun.bodyCleanupStartedDeferred);
+      if (!workerAnsweredStop) {
+        yield* workerPool.requestWorkerTermination(
+          workerId,
+          `because it did not answer the stop of "${taskName}" within ${Duration.format(cleanupDuration)}`,
+        );
+      }
+      yield* processGroups.killForTask(taskName);
+      const cleanupMilliseconds = Duration.toMillis(cleanupDuration);
+      const cleanupStarted =
+        workerAnsweredStop || Deferred.isDoneUnsafe(taskRun.bodyFailedBeforeCleanupDeferred);
+      yield* failCleanup(
+        taskRunsState,
+        cleanupStarted
+          ? new TaskCleanupTimedOut({ taskName, cleanupMilliseconds })
+          : new TaskCleanupNotStarted({ taskName, cleanupMilliseconds }),
+      );
+      if (workerAnsweredStop) {
+        yield* watchUntilStopsEnd(
+          watchWorkerOfCleanupPastItsLimit(taskRunsState, taskName, workerId, cleanupDuration),
+        );
+      }
+    }),
+  );
+});

package/src/lib/main-thread/lib/scan-module-source/index.ts

@@ -0,0 +1 @@
+export { scanProjectModule } from "./internal/scan-module-text.ts";

package/src/lib/main-thread/lib/scan-module-source/internal/find-lexical-bindings.ts

@@ -0,0 +1,154 @@
+import { Visitor } from "oxc-parser";
+import type { BindingPattern, ParamPattern, Program } from "oxc-parser";
+
+class LexicalScope {
+  public readonly bindings = new Map<string, number>();
+
+  public readonly parent: LexicalScope | null;
+
+  public readonly holdsVarDeclarations: boolean;
+
+  public constructor(parent: LexicalScope | null, holdsVarDeclarations: boolean) {
+    this.parent = parent;
+    this.holdsVarDeclarations = holdsVarDeclarations;
+  }
+
+  public bindingFor(name: string): number | null {
+    return this.bindings.get(name) ?? this.parent?.bindingFor(name) ?? null;
+  }
+
+  public scopeForVar(): LexicalScope {
+    return this.holdsVarDeclarations ? this : (this.parent?.scopeForVar() ?? this);
+  }
+}
+
+const declarePattern = (scope: LexicalScope, pattern: BindingPattern | ParamPattern): void => {
+  if (pattern.type === "Identifier") {
+    if (!scope.bindings.has(pattern.name)) {
+      scope.bindings.set(pattern.name, pattern.start);
+    }
+  } else if (pattern.type === "AssignmentPattern") {
+    declarePattern(scope, pattern.left);
+  } else if (pattern.type === "RestElement") {
+    declarePattern(scope, pattern.argument);
+  } else if (pattern.type === "TSParameterProperty") {
+    declarePattern(scope, pattern.parameter);
+  } else if (pattern.type === "ObjectPattern") {
+    for (const property of pattern.properties) {
+      declarePattern(scope, property.type === "Property" ? property.value : property.argument);
+    }
+  } else {
+    for (const element of pattern.elements) {
+      if (element !== null) {
+        declarePattern(scope, element);
+      }
+    }
+  }
+};
+
+export const findLexicalBindings = (program: Program) => {
+  const current = { scope: new LexicalScope(null, true) };
+  const scopesAtIdentifierStarts = new Map<number, LexicalScope>();
+  const enterScope = () => {
+    current.scope = new LexicalScope(current.scope, false);
+  };
+  const leaveScope = () => {
+    current.scope = current.scope.parent ?? current.scope;
+  };
+  const enterFunction = (parameters: readonly ParamPattern[]) => {
+    current.scope = new LexicalScope(current.scope, true);
+    for (const parameter of parameters) {
+      declarePattern(current.scope, parameter);
+    }
+  };
+  new Visitor({
+    Identifier: (identifier) => {
+      scopesAtIdentifierStarts.set(identifier.start, current.scope);
+    },
+    VariableDeclaration: (declaration) => {
+      if (declaration.declare === true) {
+        return;
+      }
+      const declarationScope =
+        declaration.kind === "var" ? current.scope.scopeForVar() : current.scope;
+      for (const declarator of declaration.declarations) {
+        declarePattern(declarationScope, declarator.id);
+      }
+    },
+    ImportDeclaration: (declaration) => {
+      if (declaration.importKind === "type") {
+        return;
+      }
+      for (const specifier of declaration.specifiers) {
+        const importsValue =
+          specifier.type !== "ImportSpecifier" || specifier.importKind !== "type";
+        if (importsValue) {
+          declarePattern(current.scope, specifier.local);
+        }
+      }
+    },
+    TSImportEqualsDeclaration: (declaration) => {
+      if (declaration.importKind !== "type") {
+        declarePattern(current.scope, declaration.id);
+      }
+    },
+    FunctionDeclaration: (declaration) => {
+      if (declaration.id !== null) {
+        declarePattern(current.scope, declaration.id);
+      }
+      enterFunction(declaration.params);
+    },
+    "FunctionDeclaration:exit": leaveScope,
+    FunctionExpression: (expression) => {
+      enterFunction(expression.params);
+      if (expression.id !== null) {
+        declarePattern(current.scope, expression.id);
+      }
+    },
+    "FunctionExpression:exit": leaveScope,
+    ArrowFunctionExpression: (expression) => {
+      enterFunction(expression.params);
+    },
+    "ArrowFunctionExpression:exit": leaveScope,
+    BlockStatement: enterScope,
+    "BlockStatement:exit": leaveScope,
+    ForStatement: enterScope,
+    "ForStatement:exit": leaveScope,
+    ForInStatement: enterScope,
+    "ForInStatement:exit": leaveScope,
+    ForOfStatement: enterScope,
+    "ForOfStatement:exit": leaveScope,
+    SwitchStatement: enterScope,
+    "SwitchStatement:exit": leaveScope,
+    CatchClause: (clause) => {
+      enterScope();
+      if (clause.param !== null) {
+        declarePattern(current.scope, clause.param);
+      }
+    },
+    "CatchClause:exit": leaveScope,
+    ClassDeclaration: (declaration) => {
+      const { id, declare: declaresOnlyType } = declaration;
+      const declaresValue = id !== null && declaresOnlyType !== true;
+      if (declaresValue) {
+        declarePattern(current.scope, id);
+      }
+      enterScope();
+    },
+    "ClassDeclaration:exit": leaveScope,
+    ClassExpression: (expression) => {
+      enterScope();
+      if (expression.id !== null) {
+        declarePattern(current.scope, expression.id);
+      }
+    },
+    "ClassExpression:exit": leaveScope,
+    StaticBlock: () => {
+      current.scope = new LexicalScope(current.scope, true);
+    },
+    "StaticBlock:exit": leaveScope,
+  }).visit(program);
+
+  return (identifier: { readonly name: string; readonly start: number }) =>
+    scopesAtIdentifierStarts.get(identifier.start)?.bindingFor(identifier.name) ?? null;
+};