@sshkeda/task 0.0.0-stage → 1.0.1

package/src/lib/worker-thread/lib/provide-task-services/internal/spawn-reported-process.ts

@@ -0,0 +1,151 @@
+import { Duration, Effect, Deferred, Exit, PlatformError } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+import type { ChildProcess } from "effect/process";
+
+import { TASK_TRACE_LABEL_PREFIX } from "../../../../../shared/names-from-package-json.ts";
+import { TaskEvent } from "../../../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../../../shared/rpc.ts";
+import {
+  forgetEndedProcessGroups,
+  killTaskProcessGroups,
+  readProcessUnlessGone,
+  recordLeaderExit,
+  startedProcessGroup,
+} from "../../../../kill-leftover-processes/index.ts";
+import type { makeTaskBodyRecord } from "../../../shared/define-task-body-record.ts";
+import { WorkerState, reportToMainThread } from "../../../shared/provide-worker-state.ts";
+import { refuseStandardInputOutsideRootTask } from "./read-standard-input-from-main-thread.ts";
+import { formatProgramNames, spawnWithBun } from "./spawn-commands-with-bun.ts";
+
+const MICROSECONDS_PER_MILLISECOND = 1000;
+
+export const spawnReportedProcess = Effect.fn("spawnReportedProcess")(function* (
+  startMessage: typeof StartTaskFiber.Type,
+  body: ReturnType<typeof makeTaskBodyRecord>,
+  command: ChildProcess.Command,
+) {
+  const workerState = yield* WorkerState;
+  const spanEndedDeferred = yield* Deferred.make<void>();
+  const spawnedDeferred = yield* Deferred.make<
+    ChildProcessSpawner.ChildProcessHandle,
+    PlatformError.PlatformError
+  >();
+  const leaderExitsSeenBeforeRecord = new Map<number, string | null>();
+  const onLeaderExited = (processId: number, latestMemberStartTime: string | null) =>
+    Effect.sync(() => {
+      leaderExitsSeenBeforeRecord.set(processId, latestMemberStartTime);
+      recordLeaderExit(body.startedProcessGroups, processId, latestMemberStartTime);
+    });
+  const killMembersLeftByLeader = (processId: number, latestMemberStartTime: string) =>
+    killTaskProcessGroups(
+      new Map([
+        [
+          processId,
+          startedProcessGroup(
+            startMessage.taskName,
+            body.startedProcessGroups.get(processId)?.leaderStartTime ?? null,
+            latestMemberStartTime,
+          ),
+        ],
+      ]),
+      startMessage.taskName,
+      (processes) => workerState.claimProcessesToReport(startMessage.taskName, processes),
+    ).pipe(
+      workerState.provideRuntimeServices,
+      Effect.flatMap(forgetEndedProcessGroups(body.startedProcessGroups)),
+    );
+  yield* spawnWithBun(
+    command,
+    refuseStandardInputOutsideRootTask(startMessage),
+    startMessage.taskPackageDirectoryPath,
+    Duration.millis(startMessage.cleanupMilliseconds),
+    {
+      onLeaderExited,
+      killMembersLeftByLeader,
+    },
+  ).pipe(
+    Effect.tap((spawnedProcess) =>
+      readProcessUnlessGone(startMessage.taskName, spawnedProcess.handle.pid).pipe(
+        workerState.provideRuntimeServices,
+        Effect.mapError((readFailure) =>
+          PlatformError.systemError({
+            _tag: "Unknown",
+            module: "ChildProcess",
+            method: "spawn",
+            pathOrDescriptor: formatProgramNames(command),
+            description: readFailure.message,
+            cause: readFailure,
+          }),
+        ),
+        Effect.map((leader) => leader?.startTime ?? null),
+        Effect.tap((leaderStartTime) =>
+          Effect.sync(() => {
+            const processId = spawnedProcess.handle.pid;
+            body.startedProcessGroups.set(
+              processId,
+              startedProcessGroup(startMessage.taskName, leaderStartTime, null),
+            );
+            if (leaderExitsSeenBeforeRecord.has(processId)) {
+              recordLeaderExit(
+                body.startedProcessGroups,
+                processId,
+                leaderExitsSeenBeforeRecord.get(processId) ?? null,
+              );
+            }
+          }),
+        ),
+        Effect.flatMap((leaderStartTime) =>
+          workerState.reportStartedProcessAndAwaitRecord(
+            startMessage.taskName,
+            spawnedProcess.handle.pid,
+            leaderStartTime,
+          ),
+        ),
+      ),
+    ),
+    Effect.tap((spawnedProcess) =>
+      Effect.annotateCurrentSpan("process.pid", spawnedProcess.handle.pid),
+    ),
+    Effect.onExit((spawnExit) =>
+      Deferred.done(
+        spawnedDeferred,
+        Exit.map(spawnExit, (spawnedProcess) => spawnedProcess.handle),
+      ),
+    ),
+    Effect.flatMap((spawnedProcess) =>
+      spawnedProcess.exited.pipe(
+        Effect.tap((processExit) =>
+          reportToMainThread(
+            TaskEvent.cases.TaskFiberProcessLeaderExited.make({
+              taskName: startMessage.taskName,
+              processId: spawnedProcess.handle.pid,
+              latestMemberStartTime: processExit.latestMemberStartTime,
+            }),
+          ),
+        ),
+        Effect.tap((processExit) =>
+          processExit.usage === undefined
+            ? Effect.void
+            : Effect.annotateCurrentSpan({
+                [`${TASK_TRACE_LABEL_PREFIX}.process.cpu.milliseconds`]:
+                  Number(BigInt(processExit.usage.cpuTime.total)) / MICROSECONDS_PER_MILLISECOND,
+                [`${TASK_TRACE_LABEL_PREFIX}.process.memory.peak.bytes`]: processExit.usage.maxRSS,
+              }),
+        ),
+        Effect.andThen(spawnedProcess.handle.exitCode),
+      ),
+    ),
+    Effect.tap((exitCode) => Effect.annotateCurrentSpan("process.exit.code", exitCode)),
+    Effect.withSpan("process", {
+      attributes: { "process.executable.name": formatProgramNames(command) },
+    }),
+    Effect.exit,
+    Effect.andThen(Deferred.done(spanEndedDeferred, Exit.void)),
+    workerState.forkInWorkerScope,
+  );
+  const handle = yield* Deferred.await(spawnedDeferred);
+  return ChildProcessSpawner.makeHandle({
+    ...handle,
+    exitCode: Deferred.await(spanEndedDeferred).pipe(Effect.andThen(handle.exitCode)),
+  });
+});

package/src/lib/worker-thread/shared/await-main-thread-answers.ts

@@ -0,0 +1,76 @@
+import { Deferred, Effect, Ref, Semaphore } from "effect";
+import type { Fiber } from "effect";
+import type { RpcClient, RpcClientError } from "effect/rpc";
+
+import type { ProcessIdentity } from "../../../shared/claim-processes-to-report.ts";
+import { dieOnInvariantFailure } from "../../../shared/invariant-errors.ts";
+import { TaskEvent } from "../../../shared/rpc.ts";
+import type { MainThreadRpcs, StandardInputRead } from "../../../shared/rpc.ts";
+import { isAwaitedTaskFailed } from "../../../shared/task-errors.ts";
+
+const dieUnlessAnswered = dieOnInvariantFailure(
+  "worker protocol",
+  "the main thread answers each request the worker makes",
+);
+
+export const makeMainThreadAnswers = Effect.fn("makeMainThreadAnswers")(function* (
+  mainThread: RpcClient.FromGroup<typeof MainThreadRpcs, RpcClientError.RpcClientError>,
+  reportToMainThread: (event: typeof TaskEvent.Type) => Effect.Effect<void>,
+  forkInWorkerScope: (effect: Effect.Effect<void>) => Effect.Effect<Fiber.Fiber<void>>,
+) {
+  const unclaimedStandardInputRead = yield* Ref.make<Deferred.Deferred<
+    typeof StandardInputRead.Type
+  > | null>(null);
+  const oneStandardInputReadAtATime = Semaphore.makeUnsafe(1);
+  const sendOrReuseStandardInputRequest = (taskName: string) =>
+    Effect.gen(function* () {
+      const unclaimed = yield* Ref.get(unclaimedStandardInputRead);
+      if (unclaimed !== null) {
+        return unclaimed;
+      }
+      const readDeferred = Deferred.makeUnsafe<typeof StandardInputRead.Type>();
+      yield* Ref.set(unclaimedStandardInputRead, readDeferred);
+      yield* forkInWorkerScope(
+        mainThread.ReadStandardInput({ taskName }).pipe(
+          dieUnlessAnswered,
+          Effect.flatMap((read) => Deferred.succeed(readDeferred, read)),
+          Effect.asVoid,
+        ),
+      );
+      return readDeferred;
+    });
+  return {
+    requestStandardInputRead: (taskName: string) =>
+      Effect.uninterruptibleMask((restore) =>
+        sendOrReuseStandardInputRequest(taskName).pipe(
+          Effect.flatMap((readDeferred) => restore(Deferred.await(readDeferred))),
+          Effect.tap(() => Ref.set(unclaimedStandardInputRead, null)),
+        ),
+      ).pipe(oneStandardInputReadAtATime.withPermits(1)),
+    requestDependencyTaskResult: (dependencyTaskName: string, requestingTaskName: string) =>
+      mainThread.RequestTask({ taskName: requestingTaskName, dependencyTaskName }).pipe(
+        Effect.catchTag("RpcClientError", (error) => dieUnlessAnswered(Effect.fail(error))),
+        Effect.map((answered) => answered.value),
+        Effect.tapError((failure) =>
+          isAwaitedTaskFailed(failure)
+            ? reportToMainThread(
+                TaskEvent.cases.TaskFiberReceivedAwaitedFailure.make({
+                  taskName: requestingTaskName,
+                  awaitedTaskName: failure.awaitedTaskName,
+                }),
+              )
+            : Effect.void,
+        ),
+      ),
+    reportStartedProcessAndAwaitRecord: (
+      taskName: string,
+      processId: number,
+      startTime: string | null,
+    ) =>
+      mainThread.RecordStartedProcess({ taskName, processId, startTime }).pipe(dieUnlessAnswered),
+    claimProcessesToReport: (
+      taskName: string,
+      processes: readonly (typeof ProcessIdentity.Type)[],
+    ) => mainThread.ClaimProcessReports({ taskName, processes }).pipe(dieUnlessAnswered),
+  };
+});

package/src/lib/worker-thread/shared/decode-task-result-json.ts

@@ -0,0 +1,114 @@
+import { Array as Arrays, Effect, Formatter, Option, Redacted, Schema } from "effect";
+
+import {
+  holdsRedactedTaskResultKey,
+  REDACTED_TASK_RESULT_KEY,
+} from "../../../shared/task-results.ts";
+import { TaskResultNotJson } from "../../errors/index.ts";
+import { describeIssueInput, formatPropertyAccess, REPORT_INPUT } from "./describe-issue-input.ts";
+import { PlainObject } from "./plain-object.ts";
+
+export const OptionalJson = Schema.UndefinedOr(Schema.Json);
+
+const TaskResultPart = Schema.Union([
+  Schema.Null,
+  Schema.String,
+  Schema.Boolean,
+  Schema.Finite,
+  Schema.Redacted(Schema.String),
+  Schema.Array(Schema.Unknown),
+  PlainObject,
+]);
+
+const isJsonLeaf = Schema.is(
+  Schema.Union([Schema.Null, Schema.String, Schema.Boolean, Schema.Finite]),
+);
+
+const isRedactedString = Schema.is(Schema.Redacted(Schema.String));
+
+const decodeTaskResultPart = Schema.decodeUnknownEffect(TaskResultPart, REPORT_INPUT);
+
+const encodeTaskResultParts = (
+  notJson: (valuePath: string, valueDescription: string) => TaskResultNotJson,
+  decodingPart: ReturnType<typeof decodeTaskResultPart>,
+  valuePath: string,
+  onPath: WeakSet<WeakKey>,
+): Effect.Effect<Schema.Json, TaskResultNotJson> =>
+  Effect.gen(function* () {
+    const part = yield* decodingPart;
+    const isLeaf = part === null || typeof part !== "object";
+    if (isLeaf) {
+      return part;
+    }
+    if (isRedactedString(part)) {
+      return { [REDACTED_TASK_RESULT_KEY]: Redacted.value(part) };
+    }
+    if (onPath.has(part)) {
+      return yield* notJson(valuePath, "a reference back to an enclosing value");
+    }
+    if (Object.hasOwn(part, REDACTED_TASK_RESULT_KEY)) {
+      return yield* notJson(
+        valuePath,
+        `an object with the reserved key ${Formatter.format(REDACTED_TASK_RESULT_KEY)}`,
+      );
+    }
+    onPath.add(part);
+    const encoded = Arrays.isArray(part)
+      ? yield* Effect.forEach(part, (element, index) =>
+          isJsonLeaf(element)
+            ? Effect.succeed(element)
+            : encodeTaskResultParts(
+                notJson,
+                decodeTaskResultPart(element),
+                `${valuePath}${formatPropertyAccess(index)}`,
+                onPath,
+              ),
+        )
+      : Object.fromEntries(
+          yield* Effect.forEach(Object.entries(part), ([key, entry]) =>
+            Effect.map(
+              isJsonLeaf(entry)
+                ? Effect.succeed(entry)
+                : encodeTaskResultParts(
+                    notJson,
+                    decodeTaskResultPart(entry),
+                    `${valuePath}${formatPropertyAccess(key)}`,
+                    onPath,
+                  ),
+              (encodedEntry) => [key, encodedEntry] as const,
+            ),
+          ),
+        );
+    onPath.delete(part);
+    return encoded;
+  }).pipe(
+    Effect.catchTag("SchemaError", (cause) =>
+      Effect.fail(notJson(valuePath, describeIssueInput(cause.issue))),
+    ),
+  );
+
+export const decodeTaskResultJson = (
+  taskName: string,
+  handedOver: TaskResultNotJson["handedOver"],
+  value: unknown,
+) =>
+  Effect.gen(function* () {
+    const json = yield* Schema.decodeUnknownEffect(OptionalJson)(value).pipe(
+      Effect.asSome,
+      Effect.catchTag("SchemaError", () => Effect.succeedNone),
+    );
+    const jsonWithoutReservedKey = Option.filter(json, (candidate) => {
+      const isBranch = candidate !== null && typeof candidate === "object";
+      return !isBranch || !holdsRedactedTaskResultKey(candidate);
+    });
+    if (Option.isSome(jsonWithoutReservedKey)) {
+      return jsonWithoutReservedKey.value;
+    }
+    return yield* encodeTaskResultParts(
+      (valuePath, valueDescription) =>
+        new TaskResultNotJson({ taskName, handedOver, valuePath, valueDescription }),
+      Schema.decodeUnknownEffect(TaskResultPart, REPORT_INPUT)(value),
+      "",
+      new WeakSet(),
+    );
+  });

package/src/lib/worker-thread/shared/define-task-body-record.ts

@@ -0,0 +1,11 @@
+import { Option } from "effect";
+import type { Cause } from "effect";
+
+import type { startedProcessGroup } from "../../kill-leftover-processes/index.ts";
+
+export const makeTaskBodyRecord = () => ({
+  logs: new Array<string>(),
+  startedProcessGroups: new Map<number, ReturnType<typeof startedProcessGroup>>(),
+  startedAtMilliseconds: 0,
+  causeReportedBeforeCleanup: Option.none<Cause.Cause<unknown>>(),
+});

package/src/lib/worker-thread/shared/describe-issue-input.ts

@@ -0,0 +1,52 @@
+import { Formatter, Predicate, SchemaIssue } from "effect";
+
+export const REPORT_INPUT = { reportInput: true } as const;
+
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+
+export const formatPropertyAccess = (key: PropertyKey) => {
+  if (Predicate.isNumber(key)) {
+    return `[${key}]`;
+  }
+  const isIdentifierKey = Predicate.isString(key) && IDENTIFIER.test(key);
+  if (isIdentifierKey) {
+    return `.${key}`;
+  }
+  return `[${Formatter.format(key)}]`;
+};
+
+const withArticle = (typeName: string) => `${/^[aeiou]/iu.test(typeName) ? "an" : "a"} ${typeName}`;
+
+export const describeIssueInput = (issue: SchemaIssue.Issue) => {
+  if (!SchemaIssue.hasInput(issue)) {
+    return "missing";
+  }
+  const input = issue.input;
+  const isPrintedAsIs = input === undefined || input === null || Predicate.isNumber(input);
+  if (isPrintedAsIs) {
+    return String(input);
+  }
+  if (Predicate.isString(input)) {
+    return `the string ${Formatter.format(input)}`;
+  }
+  if (typeof input !== "object") {
+    return withArticle(typeof input);
+  }
+  if (Array.isArray(input)) {
+    return "an array";
+  }
+  const prototype: unknown = Object.getPrototypeOf(input);
+  const isPlainObject = prototype === Object.prototype || prototype === null;
+  if (isPlainObject) {
+    return "an object";
+  }
+  const hasNamedConstructor =
+    Predicate.hasProperty(prototype, "constructor") &&
+    Predicate.hasProperty(prototype.constructor, "name");
+  const constructorName = hasNamedConstructor ? prototype.constructor.name : undefined;
+  const isInstanceOfANamedClass =
+    Predicate.isString(constructorName) && constructorName !== "" && constructorName !== "Object";
+  return isInstanceOfANamedClass
+    ? `an instance of ${constructorName}`
+    : "an object whose prototype isn't Object.prototype";
+};

package/src/lib/worker-thread/shared/plain-object.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+
+export const PlainObject = Schema.ObjectKeyword.check(
+  Schema.makeFilter((candidate) => {
+    const prototype: unknown = Object.getPrototypeOf(candidate);
+    return prototype === Object.prototype || prototype === null;
+  }),
+);

package/src/lib/worker-thread/shared/provide-worker-state.ts

@@ -0,0 +1,160 @@
+import { workerData } from "node:worker_threads";
+
+import type * as BunServices from "@effect/platform-bun/BunServices";
+import {
+  Context,
+  Deferred,
+  Effect,
+  Layer,
+  Schema,
+  Fiber,
+  FiberMap,
+  FiberSet,
+  Option,
+} from "effect";
+import type { HttpClient } from "effect/http";
+import { RpcClient, RpcSerialization, RpcWorker } from "effect/rpc";
+import type { RpcMessage } from "effect/rpc";
+
+import { completeOnceSent } from "../../../shared/complete-discarded-calls-once-sent.ts";
+import { setProjectDirectoryPath } from "../../../shared/find-user-locations-in-stack-traces.ts";
+import { dieOnInvariantFailure } from "../../../shared/invariant-errors.ts";
+import { standardErrorLinesToTheMainThreadDeferred } from "../../../shared/print-to-standard-error.ts";
+import {
+  MainThreadRpcs,
+  MessageFromMainThreadRpcServer,
+  TaskEvent,
+  WorkerData,
+  WorkerInitialMessage,
+} from "../../../shared/rpc.ts";
+import { TASK_PACKAGE } from "../../../shared/task-package.ts";
+import { makeMainThreadAnswers } from "./await-main-thread-answers.ts";
+
+const decodeMessageFromMainThreadRpcServer = Schema.decodeUnknownEffect(
+  MessageFromMainThreadRpcServer,
+);
+
+const makeMainThreadRpcProtocol = (mainThreadPort: MessagePort) =>
+  RpcClient.Protocol.make((writeResponse, clientIds) =>
+    Effect.gen(function* () {
+      const runInWorkerScope = yield* FiberSet.makeRuntime<never, void, never>();
+      const onMessage = (event: { readonly data: unknown }) => {
+        runInWorkerScope(
+          decodeMessageFromMainThreadRpcServer(event.data).pipe(
+            dieOnInvariantFailure("worker protocol", "main-thread answers match the RPC protocol"),
+            Effect.flatMap((response) =>
+              Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response), {
+                discard: true,
+              }),
+            ),
+          ),
+        );
+      };
+      yield* Effect.acquireRelease(
+        Effect.sync(() => {
+          mainThreadPort.addEventListener("message", onMessage);
+          mainThreadPort.start();
+        }),
+        () =>
+          Effect.sync(() => {
+            mainThreadPort.removeEventListener("message", onMessage);
+            mainThreadPort.close();
+          }),
+      );
+      return {
+        send: (_clientId: number, request: RpcMessage.FromClientEncoded) =>
+          Effect.sync(() => {
+            mainThreadPort.postMessage(request);
+          }),
+        supportsAck: false,
+        supportsTransferables: false,
+        codecFor: RpcSerialization.json.codecFor,
+      };
+    }),
+  );
+
+const makeTaskBodyFiberTracker = (
+  reportToMainThread: (event: typeof TaskEvent.Type) => Effect.Effect<void>,
+) =>
+  Effect.gen(function* () {
+    const taskBodyFibersByTaskName = yield* FiberMap.make<string>();
+    const taskNamesAskedToStop = new Set<string>();
+    const lifetimeScope = yield* Effect.scope;
+    return {
+      startTaskBodyFiber: <Success, Failure, Services>(
+        taskName: string,
+        effect: Effect.Effect<Success, Failure, Services>,
+      ) => FiberMap.run(taskBodyFibersByTaskName, taskName, effect).pipe(Effect.asVoid),
+      requestTaskBodyInterruption: (taskName: string) =>
+        Effect.gen(function* () {
+          taskNamesAskedToStop.add(taskName);
+          yield* reportToMainThread(TaskEvent.cases.TaskFiberStartedCleanUp.make({ taskName }));
+          const bodyFiber = FiberMap.getUnsafe(taskBodyFibersByTaskName, taskName);
+          if (Option.isSome(bodyFiber)) {
+            yield* Effect.forkIn(Fiber.interrupt(bodyFiber.value), lifetimeScope);
+          }
+        }),
+      wasAskedToStop: (taskName: string) => Effect.sync(() => taskNamesAskedToStop.has(taskName)),
+      forkInWorkerScope: <Success, Failure, Services>(
+        effect: Effect.Effect<Success, Failure, Services>,
+      ) => Effect.forkIn(effect, lifetimeScope),
+    };
+  });
+
+const connectToMainThread = Effect.gen(function* () {
+  const decodedWorkerData = yield* Schema.decodeUnknownEffect(WorkerData)(workerData).pipe(
+    dieOnInvariantFailure("worker startup", "worker data matches the worker protocol"),
+  );
+  yield* setProjectDirectoryPath(decodedWorkerData.projectDirectoryPath);
+  const { mainThreadPort } = yield* RpcWorker.initialMessage(WorkerInitialMessage).pipe(
+    dieOnInvariantFailure("worker startup", "the main thread hands over its RPC port first"),
+  );
+  const mainThread = yield* RpcClient.make(MainThreadRpcs, { disableTracing: true }).pipe(
+    Effect.provideServiceEffect(RpcClient.Protocol, makeMainThreadRpcProtocol(mainThreadPort)),
+  );
+  const reportScope = yield* Effect.scope;
+  const reportToMainThread = (event: typeof TaskEvent.Type) =>
+    mainThread
+      .ReportTaskEvent(event, { discard: true })
+      .pipe(
+        dieOnInvariantFailure("worker protocol", "reports reach the main thread"),
+        completeOnceSent(reportScope),
+      );
+  const runInWorkerScope = yield* FiberSet.makeRuntime<never, void, never>();
+  const reportToMainThreadNow = (event: typeof TaskEvent.Type) => {
+    runInWorkerScope(reportToMainThread(event));
+  };
+  yield* Deferred.succeed(standardErrorLinesToTheMainThreadDeferred, (logLevel, text) =>
+    reportToMainThread(TaskEvent.cases.StandardErrorLineRequested.make({ logLevel, text })),
+  );
+  return { ...decodedWorkerData, mainThread, reportToMainThread, reportToMainThreadNow };
+});
+
+const makeWorkerState = Effect.gen(function* () {
+  const mainThreadConnection = yield* connectToMainThread;
+  const taskBodyFibers = yield* makeTaskBodyFiberTracker(mainThreadConnection.reportToMainThread);
+  const runtimeServices = yield* Effect.context<BunServices.BunServices | HttpClient.HttpClient>();
+  const mainThreadAnswers = yield* makeMainThreadAnswers(
+    mainThreadConnection.mainThread,
+    mainThreadConnection.reportToMainThread,
+    taskBodyFibers.forkInWorkerScope,
+  );
+  return {
+    ...mainThreadConnection,
+    provideRuntimeServices: <Success, Failure, Services>(
+      effect: Effect.Effect<Success, Failure, Services>,
+    ) => Effect.provide(effect, runtimeServices),
+    ...taskBodyFibers,
+    ...mainThreadAnswers,
+  };
+});
+
+export class WorkerState extends Context.Service<
+  WorkerState,
+  Effect.Success<typeof makeWorkerState>
+>()(`${TASK_PACKAGE.name}/WorkerState`) {}
+
+export const WorkerStateLive = Layer.effect(WorkerState, makeWorkerState);
+
+export const reportToMainThread = (event: typeof TaskEvent.Type) =>
+  WorkerState.use((workerState) => workerState.reportToMainThread(event));

package/src/lib/worker-thread/shared/worker-thread-errors.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "../../../shared/error-fields.ts";
+import { describeCauseMessage } from "../../../shared/report-errors.ts";
+
+export class ProcessGroupNotSignaledByWorker extends Schema.TaggedError<ProcessGroupNotSignaledByWorker>()(
+  "ProcessGroupNotSignaledByWorker",
+  {
+    ...TASK_ERROR_FIELDS,
+    processGroupId: Schema.Int,
+    programName: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  public override get message() {
+    return `worker could not signal process group ${this.processGroupId} of ${this.programName} because ${describeCauseMessage(this.cause)}`;
+  }
+}
+
+export class TaskNotRegisteredInWorker extends Schema.TaggedError<TaskNotRegisteredInWorker>()(
+  "TaskNotRegisteredInWorker",
+  { ...TASK_ERROR_FIELDS, taskName: Schema.String, filePath: Schema.String },
+) {
+  public override get message() {
+    return `importing this file in a worker made no task named "${this.taskName}"`;
+  }
+}
+
+export class TaskRegisteredAgainInWorker extends Schema.TaggedError<TaskRegisteredAgainInWorker>()(
+  "TaskRegisteredAgainInWorker",
+  {
+    ...TASK_ERROR_FIELDS,
+    taskName: Schema.String,
+    filePath: Schema.String,
+    madeCount: Schema.Int,
+  },
+) {
+  public override get message() {
+    return `importing this file in a worker made ${this.madeCount} tasks named "${this.taskName}"`;
+  }
+}

package/src/shared/attribute-reported-failures.ts

@@ -0,0 +1,25 @@
+import { Array as Arrays } from "effect";
+
+import type { PrintableError } from "../lib/errors/index.ts";
+import { UNTAGGED_FAILURE_TAG, withLocationOrElse } from "./report-errors.ts";
+
+export const attributeFailures = (
+  carrier: {
+    readonly _tag: string;
+    readonly taskName: string;
+    readonly failures: Arrays.NonEmptyReadonlyArray<PrintableError>;
+  },
+  describeUntaggedFailure: (failureMessage: string) => string,
+): Arrays.NonEmptyReadonlyArray<PrintableError> =>
+  Arrays.map(carrier.failures, (failure) =>
+    failure.tag === UNTAGGED_FAILURE_TAG
+      ? {
+          tag: carrier._tag,
+          location: failure.location ?? carrier.taskName,
+          message: describeUntaggedFailure(failure.message),
+        }
+      : withLocationOrElse(failure, carrier.taskName),
+  );
+
+export const joinMessages = (reportedErrors: readonly PrintableError[]) =>
+  reportedErrors.map((reportedError) => reportedError.message).join("\n");

package/src/shared/claim-processes-to-report.ts

@@ -0,0 +1,22 @@
+import { Effect, Schema } from "effect";
+
+export const ProcessIdentity = Schema.Struct({ processId: Schema.Int, startTime: Schema.String });
+
+export const processIdentityKey = (identity: typeof ProcessIdentity.Type) =>
+  `${identity.processId}@${identity.startTime}`;
+
+export const makeProcessReportClaimer = () => {
+  const reportedProcessKeys = new Set<string>();
+  const claimProcessesToReport = (processes: readonly (typeof ProcessIdentity.Type)[]) =>
+    Effect.sync(() =>
+      processes.filter((identity) => {
+        const key = processIdentityKey(identity);
+        if (reportedProcessKeys.has(key)) {
+          return false;
+        }
+        reportedProcessKeys.add(key);
+        return true;
+      }),
+    );
+  return { claimProcessesToReport };
+};