@sshkeda/task 0.0.0-stage → 1.0.0

package/src/shared/command-errors.ts

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "./error-fields.ts";
+
+export class CommandPipelineRefused extends Schema.TaggedError<CommandPipelineRefused>()(
+  "CommandPipelineRefused",
+  { ...TASK_ERROR_FIELDS, programNames: Schema.String },
+) {
+  public override get message() {
+    return `task's process service refused the pipeline ${this.programNames}`;
+  }
+}
+
+export class CommandOptionsRefused extends Schema.TaggedError<CommandOptionsRefused>()(
+  "CommandOptionsRefused",
+  {
+    ...TASK_ERROR_FIELDS,
+    programName: Schema.String,
+    optionNames: Schema.NonEmptyArray(Schema.String),
+  },
+) {
+  public override get message() {
+    return `task's process service refused ${this.optionNames.join(", ")} for ${this.programName}`;
+  }
+}
+
+export class RedactedValueWithNulRefused extends Schema.TaggedError<RedactedValueWithNulRefused>()(
+  "RedactedValueWithNulRefused",
+  {
+    ...TASK_ERROR_FIELDS,
+    programName: Schema.String,
+    valueNames: Schema.NonEmptyArray(Schema.String),
+  },
+) {
+  public override get message() {
+    return `task's process service refused ${this.valueNames.join(", ")} for ${this.programName}, a Redacted value holding a NUL character`;
+  }
+}
+
+export const CommandRefusal = Schema.Union([
+  CommandPipelineRefused,
+  CommandOptionsRefused,
+  RedactedValueWithNulRefused,
+]);

package/src/shared/complete-discarded-calls-once-sent.ts

@@ -0,0 +1,12 @@
+import { Effect, Fiber } from "effect";
+import type { Scope } from "effect";
+
+export const completeOnceSent =
+  (scope: Scope.Scope) =>
+  <Success, Failure, Services>(discardedCall: Effect.Effect<Success, Failure, Services>) =>
+    discardedCall.pipe(
+      Effect.forkIn(scope, { startImmediately: true }),
+      Effect.flatMap((callFiber) =>
+        callFiber.pollUnsafe() === undefined ? Effect.void : Fiber.join(callFiber),
+      ),
+    );

package/src/shared/cut-to-graphemes.ts

@@ -0,0 +1,12 @@
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export const cutToGraphemes = (text: string, maxGraphemes: number) => {
+  const graphemes: string[] = [];
+  for (const { segment } of graphemeSegmenter.segment(text)) {
+    graphemes.push(segment);
+    if (graphemes.length > maxGraphemes) {
+      return `${graphemes.slice(0, maxGraphemes - 1).join("")}…`;
+    }
+  }
+  return text;
+};

package/src/shared/environment-config-errors.ts

@@ -0,0 +1,74 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "./error-fields.ts";
+
+export class StateDirectoryPathBlank extends Schema.TaggedError<StateDirectoryPathBlank>()(
+  "StateDirectoryPathBlank",
+  { ...TASK_ERROR_FIELDS, variableName: Schema.String, value: Schema.String },
+) {
+  public override get message() {
+    return `${this.variableName} is "${this.value}", which is blank`;
+  }
+}
+
+export class HomeDirectoryPathMissing extends Schema.TaggedError<HomeDirectoryPathMissing>()(
+  "HomeDirectoryPathMissing",
+  {
+    ...TASK_ERROR_FIELDS,
+    stateDirectoryVariableName: Schema.String,
+    homeValue: Schema.NullOr(Schema.String),
+  },
+) {
+  public override get message() {
+    return this.homeValue === null
+      ? `${this.stateDirectoryVariableName} and HOME are both unset`
+      : `${this.stateDirectoryVariableName} is unset and HOME is "${this.homeValue}", which is blank`;
+  }
+}
+
+export class WorkerCountInvalid extends Schema.TaggedError<WorkerCountInvalid>()(
+  "WorkerCountInvalid",
+  { ...TASK_ERROR_FIELDS, variableName: Schema.String, value: Schema.String },
+) {
+  public override get message() {
+    return `${this.variableName} is "${this.value}", not a whole decimal number above 0`;
+  }
+}
+
+export class SetupLimitInvalid extends Schema.TaggedError<SetupLimitInvalid>()(
+  "SetupLimitInvalid",
+  { ...TASK_ERROR_FIELDS, variableName: Schema.String, value: Schema.String },
+) {
+  public override get message() {
+    return `${this.variableName} is "${this.value}", not a duration above 0 such as "90 seconds"`;
+  }
+}
+
+export class WorkerCountAboveMaximum extends Schema.TaggedError<WorkerCountAboveMaximum>()(
+  "WorkerCountAboveMaximum",
+  {
+    ...TASK_ERROR_FIELDS,
+    variableName: Schema.String,
+    value: Schema.String,
+    maximum: Schema.Int,
+  },
+) {
+  public override get message() {
+    return `${this.variableName} is "${this.value}", above the maximum of ${this.maximum} worker threads`;
+  }
+}
+
+export class BunVersionUnsupported extends Schema.TaggedError<BunVersionUnsupported>()(
+  "BunVersionUnsupported",
+  {
+    ...TASK_ERROR_FIELDS,
+    bunVersion: Schema.String,
+    supportedRange: Schema.String,
+    taskPackageName: Schema.String,
+    taskVersion: Schema.String,
+  },
+) {
+  public override get message() {
+    return `${this.taskPackageName} ${this.taskVersion} needs Bun ${this.supportedRange}, but Bun ${this.bunVersion} is running`;
+  }
+}

package/src/shared/error-fields.ts

@@ -0,0 +1,13 @@
+import { Effect, Schema } from "effect";
+
+import { TASK_PACKAGE } from "./task-package.ts";
+
+export const UNATTRIBUTED_FAILURE_FIELDS = {
+  taskName: Schema.Null.pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+};
+
+export const TASK_ERROR_FIELDS = {
+  raisedBy: Schema.Literal(TASK_PACKAGE.name).pipe(
+    Schema.withConstructorDefault(Effect.succeed(TASK_PACKAGE.name)),
+  ),
+};

package/src/shared/find-bun-loader-for-script.ts

@@ -0,0 +1,32 @@
+export const SCRIPT_LOADERS = ["js", "jsx", "ts", "tsx"] as const;
+
+const LOADER_OF_SCRIPT_EXTENSION = new Map<string, (typeof SCRIPT_LOADERS)[number]>([
+  [".ts", "ts"],
+  [".mts", "ts"],
+  [".cts", "ts"],
+  [".tsx", "tsx"],
+  [".js", "js"],
+  [".mjs", "js"],
+  [".cjs", "js"],
+  [".jsx", "jsx"],
+]);
+
+export const isDataLoader = (loader: string | null) =>
+  loader !== null && !SCRIPT_LOADERS.some((scriptLoader) => scriptLoader === loader);
+
+export const findBunLoaderForScript = (
+  filePath: string,
+  configuredLoaderOfExtension: ReadonlyMap<string, string>,
+) => {
+  const extension = /\.[^./]+$/u.exec(filePath)?.[0];
+  if (extension === undefined) {
+    return null;
+  }
+  const configuredLoader = configuredLoaderOfExtension.get(extension);
+  if (configuredLoader === undefined) {
+    const loader = LOADER_OF_SCRIPT_EXTENSION.get(extension);
+    return loader === undefined ? null : { loader, isConfigured: false };
+  }
+  const loader = SCRIPT_LOADERS.find((scriptLoader) => scriptLoader === configuredLoader);
+  return loader === undefined ? null : { loader, isConfigured: true };
+};

package/src/shared/find-node-modules-package-directory.ts

@@ -0,0 +1,35 @@
+const NODE_MODULES_DIRECTORY_NAME = "node_modules";
+
+const SCOPED_PACKAGE_NAME_SEGMENT_COUNT = 2;
+
+const UNSCOPED_PACKAGE_NAME_SEGMENT_COUNT = 1;
+
+export const makeNodeModulesPackageFinder =
+  (projectDirectoryPath: string | null) =>
+  (filePath: string): string | null => {
+    const segments = filePath.split("/");
+    const isInsideTheProject =
+      projectDirectoryPath !== null && filePath.startsWith(`${projectDirectoryPath}/`);
+    const firstSegmentIndexBelowProject = isInsideTheProject
+      ? projectDirectoryPath.split("/").length
+      : 0;
+    const nodeModulesIndex = segments.lastIndexOf(NODE_MODULES_DIRECTORY_NAME);
+    const packageNameSegmentCount =
+      segments[nodeModulesIndex + 1]?.startsWith("@") === true
+        ? SCOPED_PACKAGE_NAME_SEGMENT_COUNT
+        : UNSCOPED_PACKAGE_NAME_SEGMENT_COUNT;
+    const hasPackageNameAfterNodeModulesBelowProject =
+      nodeModulesIndex >= firstSegmentIndexBelowProject &&
+      nodeModulesIndex + packageNameSegmentCount < segments.length;
+    if (!hasPackageNameAfterNodeModulesBelowProject) {
+      return null;
+    }
+    const packageDirectoryPath = segments
+      .slice(0, nodeModulesIndex + 1 + packageNameSegmentCount)
+      .join("/");
+    const holdsTheProject =
+      projectDirectoryPath !== null &&
+      (projectDirectoryPath === packageDirectoryPath ||
+        projectDirectoryPath.startsWith(`${packageDirectoryPath}/`));
+    return holdsTheProject ? null : packageDirectoryPath;
+  };

package/src/shared/find-user-locations-in-stack-traces.ts

@@ -0,0 +1,64 @@
+import { Ref } from "effect";
+
+import { makeNodeModulesPackageFinder } from "./find-node-modules-package-directory.ts";
+
+const TASK_SOURCE_DIRECTORY_PATH = Bun.fileURLToPath(new URL("../", import.meta.url));
+
+const EFFECT_PACKAGE_JSON_PATH = Bun.isStandaloneExecutable
+  ? null
+  : Bun.fileURLToPath(import.meta.resolve("effect/package.json"));
+const EFFECT_PACKAGE_DIRECTORY_PATH =
+  EFFECT_PACKAGE_JSON_PATH === null
+    ? null
+    : EFFECT_PACKAGE_JSON_PATH.slice(0, EFFECT_PACKAGE_JSON_PATH.lastIndexOf("/") + 1);
+
+const STACK_FRAME_LOCATION =
+  /^\s*at (?:.* \()?(?<filePath>\/.+?):(?<lineAndColumn>\d+(?::\d+)?)\)?$/u;
+
+const parseStackFrames = (stack: string) =>
+  stack.split("\n").flatMap((stackLine) => {
+    const [, filePath, lineAndColumn] = STACK_FRAME_LOCATION.exec(stackLine) ?? [];
+    const isFrameWithoutLocation = filePath === undefined || lineAndColumn === undefined;
+    return isFrameWithoutLocation ? [] : [{ filePath, lineAndColumn }];
+  });
+
+export const readStackAbove = (frameAboveConstruction: (...parameters: never) => unknown) => {
+  const stackHolder: { stack?: string } = {};
+  const previousStackTraceLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+  try {
+    Error.captureStackTrace(stackHolder, frameAboveConstruction);
+  } finally {
+    Error.stackTraceLimit = previousStackTraceLimit;
+  }
+  return stackHolder.stack;
+};
+
+const findNodeModulesPackageDirectoryPathRef = Ref.makeUnsafe(makeNodeModulesPackageFinder(null));
+
+export const setProjectDirectoryPath = (directoryPath: string) =>
+  Ref.set(findNodeModulesPackageDirectoryPathRef, makeNodeModulesPackageFinder(directoryPath));
+
+const isInsideInstalledPackage = (filePath: string) =>
+  Ref.getUnsafe(findNodeModulesPackageDirectoryPathRef)(filePath) !== null;
+
+const isUserFrame = (frame: { readonly filePath: string }) =>
+  !frame.filePath.startsWith(TASK_SOURCE_DIRECTORY_PATH) &&
+  !isInsideInstalledPackage(frame.filePath) &&
+  (EFFECT_PACKAGE_DIRECTORY_PATH === null ||
+    !frame.filePath.startsWith(EFFECT_PACKAGE_DIRECTORY_PATH));
+
+export const findUserLocationInStack = (stack: string): string | undefined => {
+  const userFrame = parseStackFrames(stack).find((frame) => isUserFrame(frame));
+  return userFrame === undefined ? undefined : `${userFrame.filePath}:${userFrame.lineAndColumn}`;
+};
+
+export const findConstructingLocation = (): string | undefined => {
+  const stack = readStackAbove(findConstructingLocation);
+  return stack === undefined ? undefined : findUserLocationInStack(stack);
+};
+
+export const findLocationInFile = (stack: string, filePath: string): string | undefined => {
+  const frameInFile = parseStackFrames(stack).find((frame) => frame.filePath === filePath);
+  return frameInFile === undefined ? undefined : `${filePath}:${frameInFile.lineAndColumn}`;
+};

package/src/shared/format-error-lines.ts

@@ -0,0 +1,53 @@
+import { Cause, String as Strings } from "effect";
+
+import type { PrintableError } from "../lib/errors/index.ts";
+import { cutToGraphemes } from "./cut-to-graphemes.ts";
+import { reportCause } from "./report-cause.ts";
+
+export const relativeToWorkingDirectory = (location: string) => {
+  const workingDirectoryPrefix = `${process.cwd()}/`;
+  return location.startsWith(workingDirectoryPrefix)
+    ? location.slice(workingDirectoryPrefix.length)
+    : location;
+};
+
+const indentContinuation = (continuationLine: string) =>
+  continuationLine === "" ? "" : `  ${continuationLine}`;
+
+const formatErrorLines = (printable: PrintableError) => {
+  const [firstLine, ...continuationLines] = Strings.split(printable.message, "\n");
+  const locationPrefix =
+    printable.location === undefined ? "" : `${relativeToWorkingDirectory(printable.location)}: `;
+  return [
+    `${locationPrefix}error ${printable.tag}: ${firstLine}`,
+    ...continuationLines.map((continuationLine) => indentContinuation(continuationLine)),
+  ];
+};
+
+const omitTaskNameLocation = (printable: PrintableError, taskName: string | null) => {
+  const { location, ...printableWithoutLocation } = printable;
+  const isLocationRedundant = location === undefined || location === taskName;
+  return isLocationRedundant ? printableWithoutLocation : { ...printableWithoutLocation, location };
+};
+
+export const formatCauseLines = <Failure>(cause: Cause.Cause<Failure>, taskName: string | null) =>
+  reportCause(cause)
+    .failures.flatMap((reported) => formatErrorLines(omitTaskNameLocation(reported, taskName)))
+    .join("\n");
+
+export const formatFailureLines = (failure: Error, taskName: string | null) =>
+  formatCauseLines(Cause.fail(failure), taskName);
+
+const FAILURE_REASON_LINE_MAX_LENGTH = 200;
+
+export const FAILURE_REASON_NOT_RECORDED_LINE = "TaskRunFailed: no reason recorded";
+
+export const formatFailureReasonLine = (reason: PrintableError) =>
+  cutToGraphemes(
+    `${reason.tag}: ${reason.message
+      .split("\n")
+      .map((messageLine) => messageLine.trim())
+      .filter((messageLine) => messageLine !== "")
+      .join(" | ")}`,
+    FAILURE_REASON_LINE_MAX_LENGTH,
+  );

package/src/shared/format-task-lines.ts

@@ -0,0 +1,21 @@
+import { DateTime } from "effect";
+
+const MILLISECONDS_PER_SECOND = 1000;
+
+export const formatSeconds = (elapsedMilliseconds: number) =>
+  `${(elapsedMilliseconds / MILLISECONDS_PER_SECOND).toFixed(1)}s`;
+
+export const formatIsoTimestamp = (millisecondsSinceEpoch: number) =>
+  DateTime.formatIso(DateTime.makeUnsafe(millisecondsSinceEpoch));
+
+export const formatTaskPassed = (elapsedMilliseconds: number) =>
+  `passed in ${formatSeconds(elapsedMilliseconds)}`;
+
+export const formatTaskServing = (elapsedMilliseconds: number) =>
+  `serving after ${formatSeconds(elapsedMilliseconds)}`;
+
+export const prefixLines = (taskName: string, text: string) =>
+  text
+    .split("\n")
+    .map((line) => `[${taskName}] ${line}`)
+    .join("\n");

package/src/shared/hold-task-logs.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+
+const TASK_LOGS_RELEASED = 0;
+const TASK_LOGS_HELD = 1;
+
+export const makeTaskLogHold = () =>
+  new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+
+export const holdTaskLogsDuring =
+  (taskLogHold: Int32Array) =>
+  <Success, Failure, Services>(effect: Effect.Effect<Success, Failure, Services>) =>
+    Effect.sync(() => Atomics.store(taskLogHold, 0, TASK_LOGS_HELD)).pipe(
+      Effect.andThen(effect),
+      Effect.ensuring(
+        Effect.sync(() => {
+          Atomics.store(taskLogHold, 0, TASK_LOGS_RELEASED);
+          Atomics.notify(taskLogHold, 0);
+        }),
+      ),
+    );
+
+export const waitWhileTaskLogsAreHeld = (taskLogHold: Int32Array) => {
+  Atomics.wait(taskLogHold, 0, TASK_LOGS_HELD);
+};

package/src/shared/invariant-errors.ts

@@ -0,0 +1,28 @@
+import { Effect, Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "./error-fields.ts";
+
+export class InternalInvariantBroken extends Schema.TaggedError<InternalInvariantBroken>()(
+  "InternalInvariantBroken",
+  {
+    ...TASK_ERROR_FIELDS,
+    area: Schema.String,
+    invariant: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {
+  public override get message() {
+    return `${this.area} broke the internal invariant that ${this.invariant}`;
+  }
+}
+
+export const dieOnInvariantFailure =
+  (area: string, invariant: string) =>
+  <Success, Failure, Services>(effect: Effect.Effect<Success, Failure, Services>) =>
+    effect.pipe(
+      Effect.matchEffect({
+        onFailure: (error) =>
+          Effect.die(new InternalInvariantBroken({ area, invariant, cause: error })),
+        onSuccess: (success) => Effect.succeed(success),
+      }),
+    );

package/src/shared/mark-task-worker-thread-contexts.ts

@@ -0,0 +1,29 @@
+import { workerData } from "node:worker_threads";
+
+import { Context, Effect, Fiber, Ref, Schema } from "effect";
+
+import { WorkerData } from "./rpc.ts";
+import { TASK_PACKAGE } from "./task-package.ts";
+
+const isTaskWorkerData = Schema.is(WorkerData);
+
+export const isInsideTaskWorkerThread = () => isTaskWorkerData(workerData);
+
+const taskModuleImportsInProgress = Ref.makeUnsafe(0);
+
+export const markImportingTaskModule = <Success, Failure, Services>(
+  importTaskModule: Effect.Effect<Success, Failure, Services>,
+) =>
+  Effect.acquireUseRelease(
+    Ref.update(taskModuleImportsInProgress, (inProgress) => inProgress + 1),
+    () => importTaskModule,
+    () => Ref.update(taskModuleImportsInProgress, (inProgress) => inProgress - 1),
+  );
+
+export const isImportingTaskModule = () => Ref.getUnsafe(taskModuleImportsInProgress) > 0;
+
+export const InsideTaskBody = Context.Reference<boolean>(`${TASK_PACKAGE.name}/InsideTaskBody`, {
+  defaultValue: () => false,
+});
+
+export const isInsideTaskBody = () => Fiber.getCurrent()?.getRef(InsideTaskBody) === true;

package/src/shared/module-graph-errors.ts

@@ -0,0 +1,49 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "./error-fields.ts";
+import { describeCauseMessage } from "./report-errors.ts";
+
+export class CodeFileUnreadable extends Schema.TaggedError<CodeFileUnreadable>()(
+  "CodeFileUnreadable",
+  { ...TASK_ERROR_FIELDS, filePath: Schema.String, cause: Schema.Defect() },
+) {
+  public override get message() {
+    return `could not read it because ${describeCauseMessage(this.cause)}`;
+  }
+}
+
+export class BunfigUnparsable extends Schema.TaggedError<BunfigUnparsable>()("BunfigUnparsable", {
+  ...TASK_ERROR_FIELDS,
+  filePath: Schema.String,
+  cause: Schema.Defect(),
+}) {
+  public override get message() {
+    return `could not read the loaders it configures because ${describeCauseMessage(this.cause)}`;
+  }
+}
+
+export class ImportResolutionThrew extends Schema.TaggedError<ImportResolutionThrew>()(
+  "ImportResolutionThrew",
+  {
+    ...TASK_ERROR_FIELDS,
+    importingFilePath: Schema.String,
+    specifier: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  public get location() {
+    return this.importingFilePath;
+  }
+  public override get message() {
+    return `resolving the import "${this.specifier}" threw ${describeCauseMessage(this.cause)}`;
+  }
+}
+
+export class RewrittenModuleUnloadable extends Schema.TaggedError<RewrittenModuleUnloadable>()(
+  "RewrittenModuleUnloadable",
+  { ...TASK_ERROR_FIELDS, filePath: Schema.String },
+) {
+  public override get message() {
+    return "is not a script among the rewritten worker imports";
+  }
+}

package/src/shared/name-config-key.ts

@@ -0,0 +1,42 @@
+import { ConfigProvider, Effect } from "effect";
+import type { Exit } from "effect";
+
+export const nameConfigKey = (configPath: readonly PropertyKey[]) =>
+  configPath.map(String).join(".");
+
+export const nameEnvironmentConfigVariable = (configPath: readonly PropertyKey[]) =>
+  configPath.map(String).join("_");
+
+const runtimeConfigProviders = new WeakSet<ConfigProvider.ConfigProvider>();
+
+export const markRuntimeConfigProvider = (provider: ConfigProvider.ConfigProvider) => {
+  runtimeConfigProviders.add(provider);
+  return provider;
+};
+
+export const observeConfigLoads =
+  (
+    onLoad: (load: {
+      readonly configPath: readonly PropertyKey[];
+      readonly readsRuntimeConfigProvider: boolean;
+      readonly loaded: Exit.Exit<ConfigProvider.Node | undefined, ConfigProvider.SourceError>;
+    }) => void,
+  ) =>
+  <Success, Failure, Services>(effect: Effect.Effect<Success, Failure, Services>) =>
+    Effect.gen(function* () {
+      const provider = yield* ConfigProvider.ConfigProvider;
+      const readsRuntimeConfigProvider = runtimeConfigProviders.has(provider);
+      const observed = ConfigProvider.make((configPath) =>
+        provider.load(configPath).pipe(
+          Effect.onExit((loaded) =>
+            Effect.sync(() => {
+              onLoad({ configPath, readsRuntimeConfigProvider, loaded });
+            }),
+          ),
+        ),
+      );
+      if (readsRuntimeConfigProvider) {
+        markRuntimeConfigProvider(observed);
+      }
+      return yield* Effect.provideService(effect, ConfigProvider.ConfigProvider, observed);
+    });

package/src/shared/names-from-package-json.ts

@@ -0,0 +1,7 @@
+import { TASK_PACKAGE } from "./task-package.ts";
+
+export const packageNameParts = TASK_PACKAGE.name.replace(/^@/u, "").split("/");
+
+export const TASK_STATE_DIRECTORY_NAME = `.${packageNameParts.join("-")}`;
+
+export const TASK_TRACE_LABEL_PREFIX = packageNameParts.join("_");

package/src/shared/print-to-standard-error.ts

@@ -0,0 +1,48 @@
+import { Deferred, Effect, Queue, Runtime, Schema } from "effect";
+import type { Cause, LogLevel } from "effect";
+
+import { TASK_ERROR_FIELDS, UNATTRIBUTED_FAILURE_FIELDS } from "./error-fields.ts";
+import { prefixLines } from "./format-task-lines.ts";
+import { isInsideTaskWorkerThread } from "./mark-task-worker-thread-contexts.ts";
+import type { StandardErrorLine } from "./rpc.ts";
+
+export class StandardErrorWriteFailed extends Schema.TaggedError<StandardErrorWriteFailed>()(
+  "StandardErrorWriteFailed",
+  {
+    ...TASK_ERROR_FIELDS,
+    ...UNATTRIBUTED_FAILURE_FIELDS,
+    errnoCode: Schema.NullOr(Schema.String),
+    reason: Schema.String,
+  },
+) {
+  public override get message() {
+    return `could not write to standard error (${this.reason}), so task stopped the run`;
+  }
+
+  public override get [Runtime.errorReported]() {
+    return false;
+  }
+}
+
+export const standardErrorWriteFailedDeferred = Deferred.makeUnsafe<StandardErrorWriteFailed>();
+
+export const standardErrorClosedDeferred = Deferred.makeUnsafe<void>();
+
+export const standardErrorLinesDeferred =
+  Deferred.makeUnsafe<Queue.Queue<typeof StandardErrorLine.Type, Cause.Done>>();
+
+export const standardErrorLinesToTheMainThreadDeferred =
+  Deferred.makeUnsafe<(logLevel: LogLevel.LogLevel, text: string) => Effect.Effect<void>>();
+
+export const printLine = (logLevel: LogLevel.LogLevel, text: string) =>
+  isInsideTaskWorkerThread()
+    ? Deferred.await(standardErrorLinesToTheMainThreadDeferred).pipe(
+        Effect.flatMap((sendLine) => sendLine(logLevel, text)),
+      )
+    : Deferred.await(standardErrorLinesDeferred).pipe(
+        Effect.flatMap((lines) => Queue.offer(lines, { logLevel, text: `${text}\n` })),
+        Effect.asVoid,
+      );
+
+export const printTaskLines = (logLevel: LogLevel.LogLevel, taskName: string, text: string) =>
+  printLine(logLevel, prefixLines(taskName, text));