effective-progress 0.4.3 → 0.5.0

package/src/ink-renderer/service.tsx

@@ -0,0 +1,121 @@
+import { Writable } from "node:stream";
+import { Clock, Context, Effect, Layer, Ref } from "effect";
+import { render, type Instance } from "ink";
+import type { ProgressTerminalService } from "../terminal";
+import type { TaskSnapshot, TaskStore } from "../types";
+import { ProgressApp } from "./app";
+import { toTaskRows } from "./model";
+
+const RENDER_INTERVAL_MILLIS = 100;
+
+export interface InkRendererService {
+  readonly run: (
+    storeRef: Ref.Ref<TaskStore>,
+    dirtyRef: Ref.Ref<boolean>,
+    terminal: ProgressTerminalService,
+    isTTY: boolean,
+  ) => Effect.Effect<void>;
+}
+
+const hasRunningSpinners = (tasks: ReadonlyArray<TaskSnapshot>): boolean =>
+  tasks.some(
+    (task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits",
+  );
+
+const createInkWritable = (terminal: ProgressTerminalService): Writable =>
+  new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
+        Effect.runSync(terminal.writeStderr(text));
+        callback();
+      } catch (error) {
+        callback(error as Error);
+      }
+    },
+  });
+
+const makeDefaultInkRenderer = (): InkRendererService => ({
+  run: (storeRef, dirtyRef, terminal, isTTY) =>
+    Effect.gen(function* () {
+      const output = createInkWritable(terminal);
+      let instance: Instance | undefined;
+      let tick = 0;
+      let rendererActive = false;
+
+      const renderStore = (
+        store: TaskStore,
+        now: number,
+        terminalColumns: number | undefined,
+      ) =>
+        Effect.sync(() => {
+          const app = (
+            <ProgressApp
+              rows={toTaskRows(store)}
+              now={now}
+              tick={tick}
+              isTTY={isTTY}
+              terminalColumns={terminalColumns}
+            />
+          );
+          if (instance === undefined) {
+            instance = render(app, {
+              stdout: output as unknown as NodeJS.WriteStream,
+              stderr: output as unknown as NodeJS.WriteStream,
+              patchConsole: true,
+              exitOnCtrlC: false,
+              debug: false,
+            });
+            return;
+          }
+
+          instance.rerender(app);
+        });
+
+      const renderLoop = Effect.gen(function* () {
+        rendererActive = true;
+
+        while (true) {
+          const dirty = yield* Ref.getAndSet(dirtyRef, false);
+          const store = yield* Ref.get(storeRef);
+          const tasks = Array.from(store.tasks.values()).filter(
+            (task) => !(task.transient && task.status !== "running"),
+          );
+          const shouldRender = dirty || hasRunningSpinners(tasks);
+
+          if (shouldRender) {
+            const now = yield* Clock.currentTimeMillis;
+            const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
+            yield* renderStore(store, now, terminalColumns);
+          }
+
+          tick += 1;
+          yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
+        }
+      }).pipe(
+        Effect.ensuring(
+          Effect.gen(function* () {
+            if (rendererActive) {
+              const store = yield* Ref.get(storeRef);
+              const now = yield* Clock.currentTimeMillis;
+              const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
+              yield* renderStore(store, now, terminalColumns);
+            }
+
+            yield* Effect.sync(() => {
+              instance?.unmount();
+            });
+          }),
+        ),
+      );
+
+      return yield* renderLoop;
+    }),
+});
+
+export class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")<
+  InkRenderer,
+  InkRendererService
+>() {
+  static readonly Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
+}

package/src/ink-renderer/task-row.tsx

@@ -0,0 +1,53 @@
+import { Box } from "ink";
+import { DEFAULT_BAR_WIDTH, type SharedColumnWidths } from "./layout";
+import type { TaskRowModel } from "./types";
+import {
+  AmountColumn,
+  BarColumn,
+  DescriptionColumn,
+  ElapsedColumn,
+  EtaColumn,
+} from "./columns";
+
+export interface TaskRowProps {
+  readonly row: TaskRowModel;
+  readonly now: number;
+  readonly tick: number;
+  readonly isTTY: boolean;
+  readonly widths: SharedColumnWidths;
+}
+
+export const TaskRow = ({ row, now, tick, isTTY, widths }: TaskRowProps) => {
+  const props = {
+    task: row.task,
+    tree: row.tree,
+    now,
+    tick,
+    isTTY,
+    showTree: widths.showTree,
+  } as const;
+
+  return (
+    <Box flexDirection="row" minWidth={widths.row}>
+      <Box width={widths.description} flexShrink={1} marginRight={1}>
+        <DescriptionColumn {...props} />
+      </Box>
+      {widths.bar > 0 ? (
+        <Box width={widths.bar} flexShrink={0} marginRight={1}>
+          <BarColumn {...props} width={Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))} />
+        </Box>
+      ) : null}
+      <Box width={widths.amount} flexShrink={0} marginRight={1}>
+        <AmountColumn {...props} />
+      </Box>
+      <Box width={widths.elapsed} flexShrink={0} marginRight={1}>
+        <ElapsedColumn {...props} />
+      </Box>
+      {widths.eta > 0 ? (
+        <Box width={widths.eta} flexShrink={0}>
+          <EtaColumn {...props} />
+        </Box>
+      ) : null}
+    </Box>
+  );
+};

package/src/{renderer → ink-renderer}/tree.ts

@@ -1,10 +1,4 @@
-import type { TaskSnapshot } from "../types";
-import type { TaskTreeInfo } from "./types";
-
-export interface OrderedTreeTask {
-  readonly snapshot: TaskSnapshot;
-  readonly depth: number;
-}
+import type { OrderedTask, TaskTreeInfo } from "./types";
 
 const treeAncestorPrefix = (tree: TaskTreeInfo): string =>
   tree.ancestorHasNextSibling
@@ -22,8 +16,8 @@ export const renderTreePrefix = (tree: TaskTreeInfo): string => {
 };
 
 export const computeTreeInfo = (
-  ordered: ReadonlyArray<OrderedTreeTask>,
-): ReadonlyArray<OrderedTreeTask & { readonly tree: TaskTreeInfo }> => {
+  ordered: ReadonlyArray<OrderedTask>,
+): ReadonlyArray<OrderedTask & { readonly tree: TaskTreeInfo }> => {
   const hasNextSiblingByIndex: Array<boolean> = Array.from({ length: ordered.length }, () => false);
 
   for (let i = 0; i < ordered.length; i++) {

package/src/ink-renderer/types.ts

@@ -0,0 +1,18 @@
+import type { TaskSnapshot } from "../types";
+
+export interface TaskTreeInfo {
+  readonly depth: number;
+  readonly hasNextSibling: boolean;
+  readonly hasChildren: boolean;
+  readonly ancestorHasNextSibling: ReadonlyArray<boolean>;
+}
+
+export interface OrderedTask {
+  readonly snapshot: TaskSnapshot;
+  readonly depth: number;
+}
+
+export interface TaskRowModel {
+  readonly task: TaskSnapshot;
+  readonly tree: TaskTreeInfo;
+}

package/src/runtime.ts

@@ -1,47 +1,22 @@
 import { Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
 import { dual } from "effect/Function";
-import { mergeWith } from "es-toolkit/object";
-import type { PartialDeep } from "type-fest";
-import { type BufferedConsoleCall, makeConsoleBridge } from "./console";
-import { Columns, FrameRenderer } from "./renderer";
+import { InkRenderer } from "./ink-renderer";
 import { ProgressTerminal } from "./terminal";
 import type {
   AddTaskOptions,
   ProgressService,
   RenderRow,
-  RendererConfigShape,
   TaskStore,
   UpdateTaskOptions,
 } from "./types";
 import {
-  decodeProgressBarConfigSync,
-  decodeRendererConfigSync,
-  defaultProgressBarConfig,
-  defaultRendererConfig,
   DeterminateTaskUnits,
   IndeterminateTaskUnits,
-  ProgressBarConfig,
-  RendererConfig,
   Task,
   TaskId,
   TaskSnapshot,
 } from "./types";
 
-const mergeConfig = <T extends Record<PropertyKey, any>>(
-  base: T,
-  override: PartialDeep<T> | undefined,
-): T =>
-  mergeWith(
-    structuredClone(base),
-    (override ?? {}) as Record<PropertyKey, any>,
-    (_targetValue, sourceValue) => {
-      if (Array.isArray(sourceValue)) {
-        return sourceValue;
-      }
-      return undefined;
-    },
-  ) as T;
-
 const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): TaskSnapshot => {
   const currentUnits = snapshot.units;
   const units = (() => {
@@ -81,7 +56,6 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     status: snapshot.status,
     transient: options.transient ?? snapshot.transient,
     units,
-    config: snapshot.config,
     startedAt: snapshot.startedAt,
     completedAt: snapshot.completedAt,
   });
@@ -95,7 +69,6 @@ const withTransient = (snapshot: TaskSnapshot, transient: boolean): TaskSnapshot
     status: snapshot.status,
     transient,
     units: snapshot.units,
-    config: snapshot.config,
     startedAt: snapshot.startedAt,
     completedAt: snapshot.completedAt,
   });
@@ -129,33 +102,9 @@ const removeFromRenderOrder = (
   return next;
 };
 
-const withDefaultColumns = (rendererConfig: RendererConfigShape): RendererConfigShape => ({
-  ...rendererConfig,
-  columns: rendererConfig.columns.length > 0 ? rendererConfig.columns : Columns.defaults(),
-});
-
 const makeProgressService = Effect.gen(function* () {
-  const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
-  const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
-
-  const rendererConfig = withDefaultColumns(
-    decodeRendererConfigSync(
-      mergeConfig(
-        defaultRendererConfig,
-        Option.isSome(rendererConfigOption) ? rendererConfigOption.value : undefined,
-      ),
-    ),
-  );
-
-  const progressBarConfig = decodeProgressBarConfigSync(
-    mergeConfig(
-      defaultProgressBarConfig,
-      Option.isSome(progressBarConfigOption) ? progressBarConfigOption.value : undefined,
-    ),
-  );
-
   const terminal = yield* ProgressTerminal;
-  const frameRenderer = yield* FrameRenderer;
+  const inkRenderer = yield* InkRenderer;
   const outerConsole = yield* Effect.console;
   const isTTY = yield* terminal.isTTY;
 
@@ -164,30 +113,15 @@ const makeProgressService = Effect.gen(function* () {
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
   });
-  const pendingLogsRef = yield* Ref.make<ReadonlyArray<BufferedConsoleCall>>([]);
   const dirtyRef = yield* Ref.make(true);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
   const scope = yield* Effect.scope;
 
   const markDirty = Ref.set(dirtyRef, true);
-  const { replayLogs, progressConsole, log } = makeConsoleBridge(
-    outerConsole,
-    pendingLogsRef,
-    markDirty,
-  );
+  const log = (...args: ReadonlyArray<unknown>) =>
+    args.length === 0 ? Effect.void : outerConsole.log(...args);
 
-  yield* Effect.forkIn(
-    frameRenderer.run(
-      storeRef,
-      pendingLogsRef,
-      replayLogs,
-      dirtyRef,
-      terminal,
-      isTTY,
-      rendererConfig,
-    ),
-    scope,
-  );
+  yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
   // Let the renderer fiber start so queued logs are reliably flushed on scope teardown.
   yield* Effect.sleep("0 millis");
 
@@ -206,10 +140,6 @@ const makeProgressService = Effect.gen(function* () {
       const parentSnapshot = Option.isSome(resolvedParentId)
         ? store.tasks.get(resolvedParentId.value)
         : undefined;
-      const inheritedProgressBarConfig = parentSnapshot?.config ?? progressBarConfig;
-      const resolvedProgressBarConfig = decodeProgressBarConfigSync(
-        mergeConfig(inheritedProgressBarConfig, options.progressbar),
-      );
 
       const now = yield* Clock.currentTimeMillis;
       const parentIdValue = Option.getOrNull(resolvedParentId);
@@ -220,7 +150,6 @@ const makeProgressService = Effect.gen(function* () {
         status: "running",
         transient: parentSnapshot?.transient ?? options.transient ?? false,
         units,
-        config: resolvedProgressBarConfig,
         startedAt: now,
         completedAt: null,
       });
@@ -296,7 +225,6 @@ const makeProgressService = Effect.gen(function* () {
           status: snapshot.status,
           transient: snapshot.transient,
           units,
-          config: snapshot.config,
           startedAt: snapshot.startedAt,
           completedAt: snapshot.completedAt,
         }),
@@ -336,7 +264,6 @@ const makeProgressService = Effect.gen(function* () {
                     total: snapshot.units.total,
                   })
                 : snapshot.units,
-            config: snapshot.config,
             startedAt: snapshot.startedAt,
             completedAt: now,
           }),
@@ -371,7 +298,6 @@ const makeProgressService = Effect.gen(function* () {
             status: "failed",
             transient: snapshot.transient,
             units: snapshot.units,
-            config: snapshot.config,
             startedAt: snapshot.startedAt,
             completedAt: now,
           }),
@@ -401,7 +327,7 @@ const makeProgressService = Effect.gen(function* () {
         });
 
         return yield* Effect.locally(
-          Effect.withConsole(Effect.provideService(effect, Task, taskId), progressConsole),
+          Effect.provideService(effect, Task, taskId),
           currentParentRef,
           Option.some(taskId),
         );
@@ -454,11 +380,11 @@ export class Progress extends Context.Tag("stromseng.dev/effective-progress/Prog
   static readonly Default = Layer.unwrapEffect(
     Effect.gen(function* () {
       const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
-      const frameRendererOption = yield* Effect.serviceOption(FrameRenderer);
+      const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
       let layer: Layer.Layer<Progress, never, any> = Layer.scoped(Progress, makeProgressService);
 
-      if (Option.isNone(frameRendererOption)) {
-        layer = layer.pipe(Layer.provide(FrameRenderer.Default));
+      if (Option.isNone(inkRendererOption)) {
+        layer = layer.pipe(Layer.provide(InkRenderer.Default));
       }
       if (Option.isNone(terminalOption)) {
         layer = layer.pipe(Layer.provide(ProgressTerminal.Default));

package/src/types.ts

@@ -1,72 +1,4 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
-import type { PartialDeep } from "type-fest";
-import type { ProgressColumn } from "./renderer";
-
-export const RendererConfigSchema = Schema.Struct({
-  disableUserInput: Schema.Boolean,
-  renderIntervalMillis: Schema.Number,
-  nonTtyUpdateStep: Schema.Number,
-  width: Schema.Union(Schema.Number, Schema.Literal("fullwidth")),
-  columnGap: Schema.Number,
-  columns: Schema.Array(Schema.Unknown),
-});
-export type RendererConfigShape = {
-  readonly disableUserInput: boolean;
-  readonly renderIntervalMillis: number;
-  readonly nonTtyUpdateStep: number;
-  readonly width: number | "fullwidth";
-  readonly columnGap: number;
-  readonly columns: ReadonlyArray<ProgressColumn | string>;
-};
-const decodeRendererConfigSchemaSync = Schema.decodeUnknownSync(RendererConfigSchema);
-export const decodeRendererConfigSync = (input: unknown): RendererConfigShape => {
-  if (typeof input === "object" && input !== null && "determinateTaskLayout" in input) {
-    throw new Error("determinateTaskLayout has been removed. Use columns instead.");
-  }
-  if (typeof input === "object" && input !== null && "maxTaskWidth" in input) {
-    throw new Error("maxTaskWidth has been removed. Use width on RendererConfig instead.");
-  }
-
-  return decodeRendererConfigSchemaSync(input) as RendererConfigShape;
-};
-
-export const ProgressBarConfigSchema = Schema.Struct({
-  spinnerFrames: Schema.NonEmptyArray(Schema.String),
-  barWidth: Schema.Number,
-  fillChar: Schema.String,
-  emptyChar: Schema.String,
-  leftBracket: Schema.String,
-  rightBracket: Schema.String,
-});
-export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
-export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
-
-export const defaultRendererConfig: RendererConfigShape = {
-  disableUserInput: true,
-  renderIntervalMillis: 100, // 10 FPS
-  nonTtyUpdateStep: 5,
-  width: 120,
-  columnGap: 1,
-  columns: [],
-};
-
-export const defaultProgressBarConfig: ProgressBarConfigShape = {
-  spinnerFrames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-  barWidth: 40,
-  fillChar: "━",
-  emptyChar: "─",
-  leftBracket: "",
-  rightBracket: "",
-};
-
-export class RendererConfig extends Context.Tag("stromseng.dev/effective-progress/RendererConfig")<
-  RendererConfig,
-  PartialDeep<RendererConfigShape>
->() {}
-
-export class ProgressBarConfig extends Context.Tag(
-  "stromseng.dev/effective-progress/ProgressBarConfig",
-)<ProgressBarConfig, PartialDeep<ProgressBarConfigShape>>() {}
 
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 
@@ -82,7 +14,6 @@ export interface AddTaskOptions {
   readonly total?: number;
   readonly transient?: boolean;
   readonly parentId?: TaskId;
-  readonly progressbar?: PartialDeep<ProgressBarConfigShape>;
 }
 
 export interface UpdateTaskOptions {
@@ -120,7 +51,6 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   status: TaskStatusSchema,
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
-  config: ProgressBarConfigSchema,
   startedAt: Schema.Number,
   completedAt: Schema.NullOr(Schema.Number),
 }) {}

package/src/console.ts

@@ -1,177 +0,0 @@
-import { Console, Effect, Ref } from "effect";
-
-export type BufferedConsoleMethod =
-  | "assert"
-  | "debug"
-  | "dir"
-  | "dirxml"
-  | "error"
-  | "group"
-  | "groupCollapsed"
-  | "groupEnd"
-  | "info"
-  | "log"
-  | "table"
-  | "trace"
-  | "warn";
-
-export interface BufferedConsoleCall {
-  readonly method: BufferedConsoleMethod;
-  readonly args: ReadonlyArray<unknown>;
-  readonly unsafe: boolean;
-}
-
-export interface ConsoleBridge {
-  readonly progressConsole: Console.Console;
-  readonly appendLog: (call: BufferedConsoleCall) => Effect.Effect<void, never, never>;
-  readonly replayLogs: (
-    logs: ReadonlyArray<BufferedConsoleCall>,
-  ) => Effect.Effect<void, never, never>;
-  readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void, never, never>;
-}
-
-const replayBufferedConsoleCall = (
-  outerConsole: Console.Console,
-  call: BufferedConsoleCall,
-): Effect.Effect<void, never, never> => {
-  type DirOptions = Parameters<Console.Console["dir"]>[1];
-  type GroupOptions = Parameters<Console.Console["group"]>[0];
-
-  switch (call.method) {
-    case "assert": {
-      const [condition, ...rest] = call.args;
-      return outerConsole.assert(condition as boolean, ...rest);
-    }
-    case "debug":
-      return outerConsole.debug(...call.args);
-    case "dir":
-      return outerConsole.dir(call.args[0], call.args[1] as DirOptions);
-    case "dirxml":
-      return outerConsole.dirxml(...call.args);
-    case "error":
-      return outerConsole.error(...call.args);
-    case "group":
-      return outerConsole.group(call.args[0] as GroupOptions);
-    case "groupCollapsed":
-      return outerConsole.group(call.args[0] as GroupOptions);
-    case "groupEnd":
-      return outerConsole.groupEnd;
-    case "info":
-      return outerConsole.info(...call.args);
-    case "log":
-      return outerConsole.log(...call.args);
-    case "table":
-      return outerConsole.table(call.args[0], call.args[1] as ReadonlyArray<string> | undefined);
-    case "trace":
-      return outerConsole.trace(...call.args);
-    case "warn":
-      return outerConsole.warn(...call.args);
-  }
-};
-
-export const makeProgressConsole = (
-  appendLog: (call: BufferedConsoleCall) => Effect.Effect<void, never, never>,
-): Console.Console => {
-  const log = (method: BufferedConsoleMethod, ...args: ReadonlyArray<unknown>) =>
-    appendLog({ method, args, unsafe: false });
-  const unsafeLog = (method: BufferedConsoleMethod, ...args: ReadonlyArray<unknown>) => {
-    Effect.runSync(appendLog({ method, args, unsafe: true }));
-  };
-
-  return Console.Console.of({
-    [Console.TypeId]: Console.TypeId,
-    assert: (condition, ...args) => log("assert", condition, ...args),
-    clear: Effect.void,
-    count: (_label) => Effect.void,
-    countReset: (_label) => Effect.void,
-    debug: (...args) => log("debug", ...args),
-    dir: (item, options) => log("dir", item, options),
-    dirxml: (...args) => log("dirxml", ...args),
-    error: (...args) => log("error", ...args),
-    group: (...args) => log("group", ...args),
-    groupEnd: log("groupEnd"),
-    info: (...args) => log("info", ...args),
-    log: (...args) => log("log", ...args),
-    table: (tabularData, properties) => log("table", tabularData, properties),
-    time: (_label) => Effect.void,
-    timeEnd: (_label) => Effect.void,
-    timeLog: (_label, ...args) => log("info", ...args),
-    trace: (...args) => log("trace", ...args),
-    warn: (...args) => log("warn", ...args),
-    unsafe: {
-      assert(condition, ...args) {
-        unsafeLog("assert", condition, ...args);
-      },
-      clear() {},
-      count(_label) {},
-      countReset(_label) {},
-      debug(...args) {
-        unsafeLog("debug", ...args);
-      },
-      dir(item, options) {
-        unsafeLog("dir", item, options);
-      },
-      dirxml(...args) {
-        unsafeLog("dirxml", ...args);
-      },
-      error(...args) {
-        unsafeLog("error", ...args);
-      },
-      group(...args) {
-        unsafeLog("group", ...args);
-      },
-      groupCollapsed(...args) {
-        unsafeLog("groupCollapsed", ...args);
-      },
-      groupEnd() {
-        unsafeLog("groupEnd");
-      },
-      info(...args) {
-        unsafeLog("info", ...args);
-      },
-      log(...args) {
-        unsafeLog("log", ...args);
-      },
-      table(tabularData, properties) {
-        unsafeLog("table", tabularData, properties);
-      },
-      time(_label) {},
-      timeEnd(_label) {},
-      timeLog(_label, ...args) {
-        unsafeLog("info", ...args);
-      },
-      trace(...args) {
-        unsafeLog("trace", ...args);
-      },
-      warn(...args) {
-        unsafeLog("warn", ...args);
-      },
-    },
-  });
-};
-
-export const makeConsoleBridge = (
-  outerConsole: Console.Console,
-  pendingLogsRef: Ref.Ref<ReadonlyArray<BufferedConsoleCall>>,
-  markDirty: Effect.Effect<void, never, never>,
-): ConsoleBridge => {
-  const appendLog = (call: BufferedConsoleCall) =>
-    call.args.length === 0
-      ? Effect.void
-      : Ref.update(pendingLogsRef, (logs) => [...logs, call]).pipe(Effect.zipRight(markDirty));
-
-  const replayLogs = (logs: ReadonlyArray<BufferedConsoleCall>) =>
-    Effect.forEach(logs, (call) => replayBufferedConsoleCall(outerConsole, call), {
-      discard: true,
-    });
-
-  const log = (...args: ReadonlyArray<unknown>) =>
-    args.length === 0 ? Effect.void : appendLog({ method: "log", args, unsafe: false });
-
-  return {
-    progressConsole: makeProgressConsole(appendLog),
-    appendLog,
-    replayLogs,
-    log,
-  };
-};