effective-progress 0.4.2 → 0.4.3

package/README.md

@@ -15,7 +15,7 @@
 
 - multiple nested tree-like progress bars
 - spinner support for “we have no idea how long this takes” work
-- clean log rendering alongside progress output, so you can keep using `Console.log` / `Effect.logInfo` without wrecking the UI
+- keep using `Console.log` / `Effect.logInfo` while raw console calls are buffered and replayed through your existing `Console` / logger between frame renders
 - familiar `.all` and `.forEach` APIs — swap `Effect` for `Progress`, get progress bars basically for free
 - flicker-free rendering (in theory) by drawing everything in a single terminal frame
 
@@ -88,11 +88,11 @@ Effect.runPromise(program);
 
 ## Configuration
 
-### Log retention
+### Console replay
 
-- `maxLogLines` on `RendererConfig` controls in-memory log retention.
-- Omitted or set to `0` means no log history is kept in memory.
-- `maxLogLines > 0` keeps only the latest `N` log lines in memory.
+- `Progress.task`, `Progress.all`, and `Progress.forEach` buffer `Console.log`/`Console.dir` calls and replay them through the outer `Console`.
+- Calls are replayed between progress frame renders to avoid tearing the TTY frame.
+- Formatting is controlled by the API consumer's logger/console implementation.
 
 ### Configuring renderer and progress bars
 
@@ -111,7 +111,6 @@ import * as Progress from "effective-progress";
 const configured = program.pipe(
   Effect.provideService(Progress.RendererConfig, {
     width: 80,
-    maxLogLines: 12,
     nonTtyUpdateStep: 2,
   }),
   Effect.provideService(Progress.ProgressBarConfig, {
@@ -180,13 +179,13 @@ yield *
 
 ## Manual task control
 
-For manual usage, `task` captures logs implicitly and provides the current `Task` context:
+For manual usage, `task` still provides the current `Task` context, while logs continue through your outer `Console`:
 
 ```ts
 const program = Progress.task(
   Effect.gen(function* () {
     const currentTask = yield* Progress.Task;
-    yield* Console.log("This log is rendered through progress output", { taskId: currentTask });
+    yield* Console.log("This log is handled by the outer Console", { taskId: currentTask });
     yield* Effect.sleep("1 second");
   }),
   { description: "Manual task" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -19,6 +19,9 @@
   ],
   "type": "module",
   "module": "index.ts",
+  "engines": {
+    "node": ">=20.12.0"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -30,18 +33,18 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "chalk": "^5.6.2",
-    "effect": "^3.19.17",
     "es-toolkit": "^1.44.0",
     "type-fest": "^5.4.4"
   },
   "devDependencies": {
     "@effect/language-service": "^0.73.1",
     "@types/bun": "latest",
+    "effect": "^3.19.17",
     "oxfmt": "^0.32.0",
-    "oxlint": "^1.47.0"
+    "oxlint": "^1.47.0",
+    "typescript": "^5"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "effect": "^3.19.17"
   }
 }

package/src/console.ts

@@ -1,85 +1,177 @@
-import { Console, Effect } from "effect";
-import { formatWithOptions } from "node:util";
+import { Console, Effect, Ref } from "effect";
 
-export const makeProgressConsole = (
-  progressLog: (...args: ReadonlyArray<unknown>) => Effect.Effect<void, never, never>,
+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 = (...args: ReadonlyArray<unknown>) => progressLog(...args);
-  const unsafeLog = (...args: ReadonlyArray<unknown>) => {
-    Effect.runFork(progressLog(...args));
+  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 }));
   };
 
-  const delegate = (effect: Effect.Effect<void, never, never>) => effect;
-
   return Console.Console.of({
     [Console.TypeId]: Console.TypeId,
-    assert(condition, ...args) {
-      return condition ? Effect.void : log("Assertion failed:", ...args);
-    },
+    assert: (condition, ...args) => log("assert", condition, ...args),
     clear: Effect.void,
     count: (_label) => Effect.void,
     countReset: (_label) => Effect.void,
-    debug: (...args) => log(...args),
-    dir: (item, options) => log(formatWithOptions(options ?? {}, "%O", item)),
-    dirxml: (...args) => log(...args),
-    error: (...args) => log(...args),
-    group: (...args) => log(...args),
-    groupEnd: Effect.void,
-    info: (...args) => log(...args),
-    log: (...args) => log(...args),
-    table: (tabularData, properties) => log(tabularData, properties),
+    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(...args),
-    trace: (...args) => delegate(outerConsole.trace(...args)),
-    warn: (...args) => log(...args),
+    timeLog: (_label, ...args) => log("info", ...args),
+    trace: (...args) => log("trace", ...args),
+    warn: (...args) => log("warn", ...args),
     unsafe: {
       assert(condition, ...args) {
-        if (!condition) unsafeLog("Assertion failed:", ...args);
+        unsafeLog("assert", condition, ...args);
       },
       clear() {},
       count(_label) {},
       countReset(_label) {},
       debug(...args) {
-        unsafeLog(...args);
+        unsafeLog("debug", ...args);
       },
       dir(item, options) {
-        unsafeLog(formatWithOptions(options ?? {}, "%O", item));
+        unsafeLog("dir", item, options);
       },
       dirxml(...args) {
-        unsafeLog(...args);
+        unsafeLog("dirxml", ...args);
       },
       error(...args) {
-        unsafeLog(...args);
+        unsafeLog("error", ...args);
       },
       group(...args) {
-        unsafeLog(...args);
+        unsafeLog("group", ...args);
       },
       groupCollapsed(...args) {
-        unsafeLog(...args);
+        unsafeLog("groupCollapsed", ...args);
+      },
+      groupEnd() {
+        unsafeLog("groupEnd");
       },
-      groupEnd() {},
       info(...args) {
-        unsafeLog(...args);
+        unsafeLog("info", ...args);
       },
       log(...args) {
-        unsafeLog(...args);
+        unsafeLog("log", ...args);
       },
       table(tabularData, properties) {
-        unsafeLog(tabularData, properties);
+        unsafeLog("table", tabularData, properties);
       },
       time(_label) {},
       timeEnd(_label) {},
       timeLog(_label, ...args) {
-        unsafeLog(...args);
+        unsafeLog("info", ...args);
       },
       trace(...args) {
-        outerConsole.unsafe.trace(...args);
+        unsafeLog("trace", ...args);
       },
       warn(...args) {
-        unsafeLog(...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,
+  };
+};

package/src/renderer.ts

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { styleText } from "node:util";
 import { Clock, Context, Effect, Layer, Ref } from "effect";
 import { fitRenderedText, visibleWidth } from "./renderer/ansi";
 import { computeTreeInfo, renderTreePrefix } from "./renderer/tree";
@@ -81,8 +81,13 @@ const formatEta = (snapshot: TaskSnapshot, now: number): string => {
 const reserveTimeWidth = (formattedDuration: string): string =>
   formattedDuration.padStart(RESERVED_SECONDS_WIDTH, " ");
 
-const styleIfTTY = (isTTY: boolean, style: (text: string) => string, text: string): string =>
-  isTTY ? style(text) : text;
+type StyleFormat = Parameters<typeof styleText>[0];
+
+const applyStyle = (format: StyleFormat, text: string): string =>
+  styleText(format, text, { validateStream: false });
+
+const styleIfTTY = (isTTY: boolean, format: StyleFormat, text: string): string =>
+  isTTY ? applyStyle(format, text) : text;
 
 interface ColumnBaseOptions {
   readonly id?: string;
@@ -220,19 +225,19 @@ export class BarColumn implements ProgressColumn {
     const fill = config.fillChar.repeat(filled);
     const empty = config.emptyChar.repeat(Math.max(0, innerWidth - filled));
 
-    const fillStyle =
+    const fillStyle: StyleFormat =
       context.task.status === "failed"
-        ? chalk.red
+        ? "red"
         : context.task.status === "done"
-          ? chalk.green
-          : chalk.blue;
-    const emptyStyle = context.task.status === "failed" ? chalk.red : chalk.white.dim;
+          ? "green"
+          : "blue";
+    const emptyStyle: StyleFormat = context.task.status === "failed" ? "red" : ["white", "dim"];
 
     return [
-      styleIfTTY(context.isTTY, chalk.white.dim, config.leftBracket),
+      styleIfTTY(context.isTTY, ["white", "dim"], config.leftBracket),
       styleIfTTY(context.isTTY, fillStyle, fill),
       styleIfTTY(context.isTTY, emptyStyle, empty),
-      styleIfTTY(context.isTTY, chalk.white.dim, config.rightBracket),
+      styleIfTTY(context.isTTY, ["white", "dim"], config.rightBracket),
     ].join("");
   }
 
@@ -299,7 +304,7 @@ export class AmountColumn implements ProgressColumn {
     if (task.units._tag === "DeterminateTaskUnits") {
       return styleIfTTY(
         context.isTTY,
-        task.status === "failed" ? chalk.red : chalk.whiteBright,
+        task.status === "failed" ? "red" : "whiteBright",
         formatDeterminateUnits(task.units.completed, task.units.total),
       );
     }
@@ -308,14 +313,14 @@ export class AmountColumn implements ProgressColumn {
       const frames = task.config.spinnerFrames;
       const frameIndex = (task.units.spinnerFrame + context.tick) % frames.length;
       const frame = frames[frameIndex] ?? frames[0] ?? "";
-      return styleIfTTY(context.isTTY, chalk.yellow, frame);
+      return styleIfTTY(context.isTTY, "yellow", frame);
     }
 
     if (task.status === "done") {
-      return styleIfTTY(context.isTTY, chalk.green, this.doneSymbol);
+      return styleIfTTY(context.isTTY, "green", this.doneSymbol);
     }
 
-    return styleIfTTY(context.isTTY, chalk.red, this.failedSymbol);
+    return styleIfTTY(context.isTTY, "red", this.failedSymbol);
   }
 }
 
@@ -353,7 +358,7 @@ export class ElapsedColumn implements ProgressColumn {
   render(context: ProgressColumnContext): string {
     const raw = formatElapsed(context.task, context.now);
     const elapsed = this.padSeconds ? reserveTimeWidth(raw) : raw;
-    return styleIfTTY(context.isTTY, chalk.gray, elapsed);
+    return styleIfTTY(context.isTTY, "gray", elapsed);
   }
 }
 
@@ -421,7 +426,7 @@ export class EtaColumn implements ProgressColumn {
   }
 
   render(context: ProgressColumnContext): string {
-    return styleIfTTY(context.isTTY, chalk.gray, this.resolveEtaText(context, true));
+    return styleIfTTY(context.isTTY, "gray", this.resolveEtaText(context, true));
   }
 
   variants(context: ProgressColumnContext): ReadonlyArray<ProgressColumnVariant> {
@@ -438,17 +443,17 @@ export class EtaColumn implements ProgressColumn {
     if (compact === full) {
       return [
         {
-          render: () => styleIfTTY(context.isTTY, chalk.gray, full),
+          render: () => styleIfTTY(context.isTTY, "gray", full),
         },
       ];
     }
 
     return [
       {
-        render: () => styleIfTTY(context.isTTY, chalk.gray, full),
+        render: () => styleIfTTY(context.isTTY, "gray", full),
       },
       {
-        render: () => styleIfTTY(context.isTTY, chalk.gray, compact),
+        render: () => styleIfTTY(context.isTTY, "gray", compact),
       },
     ];
   }
@@ -1002,31 +1007,20 @@ const renderTaskFrame = (
 };
 
 export interface FrameRendererService {
-  readonly run: (
+  readonly run: <LogEntry>(
     storeRef: Ref.Ref<TaskStore>,
-    logsRef: Ref.Ref<ReadonlyArray<string>>,
-    pendingLogsRef: Ref.Ref<ReadonlyArray<string>>,
+    pendingLogsRef: Ref.Ref<ReadonlyArray<LogEntry>>,
+    replayLogs: (logs: ReadonlyArray<LogEntry>) => Effect.Effect<void, never, never>,
     dirtyRef: Ref.Ref<boolean>,
     terminal: ProgressTerminalService,
     isTTY: boolean,
     rendererConfig: RendererConfigShape,
-    maxRetainedLogLines: number,
   ) => Effect.Effect<void>;
 }
 
 const makeDefaultFrameRenderer = (): FrameRendererService => ({
-  run: (
-    storeRef,
-    logsRef,
-    pendingLogsRef,
-    dirtyRef,
-    terminal,
-    isTTY,
-    rendererConfig,
-    maxRetainedLogLines,
-  ) =>
+  run: (storeRef, pendingLogsRef, replayLogs, dirtyRef, terminal, isTTY, rendererConfig) =>
     Effect.gen(function* () {
-      const retainLogHistory = maxRetainedLogLines > 0;
       const compiledColumns = normalizeColumns(rendererConfig.columns);
       let previousLineCount = 0;
       let nonTTYTaskSignatureById = new Map<number, string>();
@@ -1152,33 +1146,27 @@ const makeDefaultFrameRenderer = (): FrameRendererService => ({
               for (let i = 1; i < previousLineCount; i++) {
                 frame += MOVE_UP_ONE + CLEAR_LINE;
               }
-            }
-
-            if (retainLogHistory) {
-              const historyLogs = yield* Ref.get(logsRef);
-              const lines = yield* clipTTYFrameLines([...historyLogs, ...renderedFrame.lines]);
-              if (lines.length > 0) {
-                frame += lines.join("\n");
-              }
-              previousLineCount = lines.length;
-            } else {
-              if (drainedLogs.length > 0) {
-                frame += `${drainedLogs.join("\n")}\n`;
-              }
-              if (renderedFrame.lines.length > 0) {
-                frame += renderedFrame.lines.join("\n");
-              }
-              previousLineCount = renderedFrame.lines.length;
+              previousLineCount = 0;
             }
 
             if (frame) {
               yield* terminal.writeStderr(frame);
             }
+
+            if (drainedLogs.length > 0) {
+              yield* replayLogs(drainedLogs);
+            }
+
+            const lines = yield* clipTTYFrameLines(renderedFrame.lines);
+            if (lines.length > 0) {
+              yield* terminal.writeStderr(lines.join("\n"));
+            }
+            previousLineCount = lines.length;
             return;
           }
 
           if (drainedLogs.length > 0) {
-            yield* terminal.writeStderr(`${drainedLogs.join("\n")}\n`);
+            yield* replayLogs(drainedLogs);
           }
 
           const orderedForNonTTY = orderedTasks.map((task) => ({
@@ -1208,7 +1196,7 @@ const makeDefaultFrameRenderer = (): FrameRendererService => ({
             if (dirty || hasActiveSpinners || hasPendingLogs) {
               yield* renderFrame("tick");
             }
-          } else if (dirty || hasActiveSpinners) {
+          } else if (dirty || hasActiveSpinners || hasPendingLogs) {
             yield* renderFrame("tick");
           }
 
@@ -1219,6 +1207,10 @@ const makeDefaultFrameRenderer = (): FrameRendererService => ({
         Effect.ensuring(
           Effect.gen(function* () {
             if (!rendererActive) {
+              const drainedLogs = yield* Ref.getAndSet(pendingLogsRef, []);
+              if (drainedLogs.length > 0) {
+                yield* replayLogs(drainedLogs);
+              }
               return;
             }
 

package/src/runtime.ts

@@ -1,9 +1,8 @@
 import { Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
 import { dual } from "effect/Function";
 import { mergeWith } from "es-toolkit/object";
-import { formatWithOptions } from "node:util";
 import type { PartialDeep } from "type-fest";
-import { makeProgressConsole } from "./console";
+import { type BufferedConsoleCall, makeConsoleBridge } from "./console";
 import { Columns, FrameRenderer } from "./renderer";
 import { ProgressTerminal } from "./terminal";
 import type {
@@ -157,35 +156,40 @@ const makeProgressService = Effect.gen(function* () {
 
   const terminal = yield* ProgressTerminal;
   const frameRenderer = yield* FrameRenderer;
+  const outerConsole = yield* Effect.console;
   const isTTY = yield* terminal.isTTY;
-  const maxRetainedLogLines = Math.max(0, Math.floor(rendererConfig.maxLogLines ?? 0));
 
   const nextTaskIdRef = yield* Ref.make(0);
   const storeRef = yield* Ref.make<TaskStore>({
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
   });
-  const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
-  const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
+  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,
+  );
+
   yield* Effect.forkIn(
     frameRenderer.run(
       storeRef,
-      logsRef,
       pendingLogsRef,
+      replayLogs,
       dirtyRef,
       terminal,
       isTTY,
       rendererConfig,
-      maxRetainedLogLines,
     ),
     scope,
   );
-
-  const markDirty = Ref.set(dirtyRef, true);
+  // Let the renderer fiber start so queued logs are reliably flushed on scope teardown.
+  yield* Effect.sleep("0 millis");
 
   const addTask = (options: AddTaskOptions) =>
     Effect.gen(function* () {
@@ -377,36 +381,6 @@ const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
-  const appendLog = (args: ReadonlyArray<unknown>) =>
-    Effect.gen(function* () {
-      if (args.length === 0) {
-        return;
-      }
-
-      const message = formatWithOptions(
-        {
-          colors: isTTY,
-          depth: 6,
-        },
-        ...args,
-      );
-
-      yield* Ref.update(pendingLogsRef, (logs) => [...logs, message]);
-      if (maxRetainedLogLines > 0) {
-        yield* Ref.update(logsRef, (logs) => {
-          const next = [...logs, message];
-          if (next.length <= maxRetainedLogLines) {
-            return next;
-          }
-          return next.slice(next.length - maxRetainedLogLines);
-        });
-      }
-
-      yield* markDirty;
-    });
-
-  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
-
   const getTask = (taskId: TaskId) =>
     Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
 
@@ -416,7 +390,6 @@ const makeProgressService = Effect.gen(function* () {
     2,
     <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
       Effect.gen(function* () {
-        const outerConsole = yield* Effect.console;
         const inheritedParentId = yield* FiberRef.get(currentParentRef);
         const resolvedParentId =
           options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
@@ -428,10 +401,7 @@ const makeProgressService = Effect.gen(function* () {
         });
 
         return yield* Effect.locally(
-          Effect.withConsole(
-            Effect.provideService(effect, Task, taskId),
-            makeProgressConsole(log, outerConsole),
-          ),
+          Effect.withConsole(Effect.provideService(effect, Task, taskId), progressConsole),
           currentParentRef,
           Option.some(taskId),
         );

package/src/types.ts

@@ -5,7 +5,6 @@ import type { ProgressColumn } from "./renderer";
 export const RendererConfigSchema = Schema.Struct({
   disableUserInput: Schema.Boolean,
   renderIntervalMillis: Schema.Number,
-  maxLogLines: Schema.optional(Schema.Number),
   nonTtyUpdateStep: Schema.Number,
   width: Schema.Union(Schema.Number, Schema.Literal("fullwidth")),
   columnGap: Schema.Number,
@@ -14,7 +13,6 @@ export const RendererConfigSchema = Schema.Struct({
 export type RendererConfigShape = {
   readonly disableUserInput: boolean;
   readonly renderIntervalMillis: number;
-  readonly maxLogLines?: number;
   readonly nonTtyUpdateStep: number;
   readonly width: number | "fullwidth";
   readonly columnGap: number;
@@ -46,7 +44,6 @@ export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarC
 export const defaultRendererConfig: RendererConfigShape = {
   disableUserInput: true,
   renderIntervalMillis: 100, // 10 FPS
-  maxLogLines: 0,
   nonTtyUpdateStep: 5,
   width: 120,
   columnGap: 1,