@ian-pascoe/pi-codemode 0.1.0 → 0.3.0

package/src/codemode-worker-protocol.ts

@@ -1,4 +1,5 @@
 import { Buffer } from "node:buffer";
+import { CODEMODE_CONSOLE_METHODS, type CodeModeConsoleEntry } from "./codemode-console-output.ts";
 
 /** Maximum UTF-8 bytes in one CodeMode worker protocol line, excluding its newline. */
 export const CODEMODE_WORKER_MESSAGE_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -76,6 +77,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly resultJson?: string;
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -83,6 +85,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly error: { readonly code: CodeModeWorkerCellErrorCode; readonly message: string };
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -132,19 +135,61 @@ function hasString(values: readonly string[], candidate: string): boolean {
 function hasExactKeys(value: CodeModeProtocolObject, expected: readonly string[]): boolean {
   const keys = objectKeys(value);
   if (keys.length !== expected.length) return false;
-  for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex += 1) {
-    const expectedKey = expected[expectedIndex];
-    if (expectedKey === undefined) return false;
-    let found = false;
-    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
-      if (keys[keyIndex] === expectedKey) {
-        found = true;
-        break;
+  return expected.every((expectedKey) => expectedKey !== undefined && keys.includes(expectedKey));
+}
+
+function hasDuplicateJsonObjectKeys(message: string): boolean {
+  const objectKeysByDepth: (string[] | undefined)[] = [];
+  for (let index = 0; index < message.length; index += 1) {
+    const character = message[index];
+    if (character === "{") {
+      objectKeysByDepth.push([]);
+      continue;
+    }
+    if (character === "[") {
+      objectKeysByDepth.push(undefined);
+      continue;
+    }
+    if (character === "}" || character === "]") {
+      objectKeysByDepth.pop();
+      continue;
+    }
+    if (character !== '"') continue;
+
+    let endIndex = index + 1;
+    for (; endIndex < message.length; endIndex += 1) {
+      if (message[endIndex] === "\\") {
+        endIndex += 1;
+        continue;
       }
+      if (message[endIndex] === '"') break;
     }
-    if (!found) return false;
+    if (endIndex >= message.length) return false;
+    let nextIndex = endIndex + 1;
+    while (
+      message[nextIndex] === " " ||
+      message[nextIndex] === "\n" ||
+      message[nextIndex] === "\r" ||
+      message[nextIndex] === "\t"
+    ) {
+      nextIndex += 1;
+    }
+    const keys = objectKeysByDepth[objectKeysByDepth.length - 1];
+    if (message[nextIndex] === ":" && keys !== undefined) {
+      try {
+        // SAFETY: This slice is one syntactically bounded JSON string token; the string refinement below rejects every other JSON value.
+        const key = jsonParse(message.slice(index, endIndex + 1)) as CodeModeProtocolValue;
+        if (isString(key)) {
+          if (hasString(keys, key)) return true;
+          keys.push(key);
+        }
+      } catch {
+        return false;
+      }
+    }
+    index = endIndex;
   }
-  return true;
+  return false;
 }
 
 function parseProtocolJson(
@@ -158,6 +203,9 @@ function parseProtocolJson(
   if (Buffer.byteLength(message, "utf8") > CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) {
     return { ok: false, message: `CodeMode worker ${subject} exceeds 8 MiB` };
   }
+  if (hasDuplicateJsonObjectKeys(message)) {
+    return { ok: false, message: `CodeMode worker ${subject} contains duplicate object keys` };
+  }
   try {
     // SAFETY: Successful JSON.parse output is exactly the recursive JSON representation modeled by CodeModeProtocolValue.
     return { ok: true, value: jsonParse(message) as CodeModeProtocolValue };
@@ -308,6 +356,30 @@ function parseWorkerError(
   return { code: value.code, message: value.message };
 }
 
+function parseConsoleOutput(
+  value: CodeModeProtocolSlot,
+): readonly CodeModeConsoleEntry[] | undefined {
+  if (!arrayIsArray(value) || value.length === 0) return undefined;
+  const entries: CodeModeConsoleEntry[] = [];
+  for (const candidate of value) {
+    if (
+      !isRecord(candidate) ||
+      !hasExactKeys(candidate, ["method", "text"]) ||
+      !isString(candidate.method) ||
+      !hasString(CODEMODE_CONSOLE_METHODS, candidate.method) ||
+      !isString(candidate.text)
+    ) {
+      return undefined;
+    }
+    entries.push({
+      // SAFETY: The literal-membership check above refines the protocol string to a supported Console method.
+      method: candidate.method as CodeModeConsoleEntry["method"],
+      text: candidate.text,
+    });
+  }
+  return entries;
+}
+
 function parseToolBatchResponse(
   decoded: CodeModeProtocolObject,
 ): CodeModeWorkerResponse | undefined {
@@ -401,43 +473,58 @@ export function parseCodeModeWorkerResponse(
   }
   if (
     decoded.type === "cell-result" &&
-    hasExactKeys(
-      decoded,
-      decoded.resultJson === undefined
-        ? ["cellId", "sessionId", "type", "version"]
-        : ["cellId", "resultJson", "sessionId", "type", "version"],
-    ) &&
     isNonEmptyString(decoded.cellId) &&
     (decoded.resultJson === undefined || isString(decoded.resultJson))
   ) {
+    const expectedKeys = ["cellId", "sessionId", "type", "version"];
+    if (decoded.resultJson !== undefined) expectedKeys.push("resultJson");
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (decoded.console !== undefined && consoleEntries === undefined) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const value = {
       version: CODEMODE_WORKER_PROTOCOL_VERSION,
       type: "cell-result",
       sessionId: decoded.sessionId,
       cellId: decoded.cellId,
     } as const;
-    return decoded.resultJson === undefined
-      ? { ok: true, value }
-      : { ok: true, value: { ...value, resultJson: decoded.resultJson } };
+    const resultValue =
+      decoded.resultJson === undefined ? value : { ...value, resultJson: decoded.resultJson };
+    return consoleEntries === undefined
+      ? { ok: true, value: resultValue }
+      : { ok: true, value: { ...resultValue, console: consoleEntries } };
   }
-  if (
-    decoded.type === "cell-error" &&
-    hasExactKeys(decoded, ["cellId", "error", "sessionId", "type", "version"]) &&
-    isNonEmptyString(decoded.cellId)
-  ) {
+  if (decoded.type === "cell-error" && isNonEmptyString(decoded.cellId)) {
+    const expectedKeys = ["cellId", "error", "sessionId", "type", "version"];
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const error = parseWorkerError(decoded.error);
-    if (error !== undefined && ["script", "serialization", "runtime"].includes(error.code)) {
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (
+      error !== undefined &&
+      ["script", "serialization", "runtime"].includes(error.code) &&
+      (decoded.console === undefined || consoleEntries !== undefined)
+    ) {
       // SAFETY: The literal-membership check above refines the protocol string to the closed worker error code union.
       const code = error.code as CodeModeWorkerCellErrorCode;
+      const value = {
+        version: CODEMODE_WORKER_PROTOCOL_VERSION,
+        type: "cell-error",
+        sessionId: decoded.sessionId,
+        cellId: decoded.cellId,
+        error: { code, message: error.message },
+      } as const;
       return {
         ok: true,
-        value: {
-          version: CODEMODE_WORKER_PROTOCOL_VERSION,
-          type: "cell-error",
-          sessionId: decoded.sessionId,
-          cellId: decoded.cellId,
-          error: { code, message: error.message },
-        },
+        value: consoleEntries === undefined ? value : { ...value, console: consoleEntries },
       };
     }
   }
@@ -456,7 +543,28 @@ export function serializeCodeModeWorkerRequest(
 
 /** Serializes one worker response, replacing oversized Cell output with a bounded error. */
 export function serializeCodeModeWorkerResponse(response: CodeModeWorkerResponse): string {
-  const message = jsonStringify(response);
+  let message: string;
+  if (response.type === "cell-result" && response.console?.length === 0) {
+    const responseBase = {
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+    } as const;
+    message = jsonStringify(
+      response.resultJson === undefined
+        ? responseBase
+        : { ...responseBase, resultJson: response.resultJson },
+    );
+  } else if (response.type === "cell-error" && response.console?.length === 0) {
+    message = jsonStringify({
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+      error: response.error,
+    });
+  } else message = jsonStringify(response);
   if (Buffer.byteLength(message, "utf8") <= CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) return message;
   if (
     response.type === "cell-result" ||

package/src/codemode-worker.ts

@@ -1,3 +1,4 @@
+import { CODEMODE_CONSOLE_METHODS, type CodeModeConsoleEntry } from "./codemode-console-output.ts";
 import {
   CODEMODE_WORKER_MESSAGE_LIMIT_BYTES,
   parseCodeModeWorkerRequest,
@@ -9,13 +10,27 @@ import {
 } from "./codemode-worker-protocol.ts";
 
 const CODEMODE_WORKER_READ_BUFFER_BYTES = 64 * 1024;
+const CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES = 512;
 
 type DenoByteReader = { read(buffer: Uint8Array): Promise<number | null> };
 type DenoByteWriter = { write(buffer: Uint8Array): Promise<number> };
+type DenoInspectOptions = {
+  readonly colors: false;
+  readonly getters: false;
+  readonly customInspect: false;
+};
 type CodeModeDenoNamespace = {
   readonly args: readonly string[];
   readonly stdin: DenoByteReader;
   readonly stdout: DenoByteWriter;
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Deno.inspect is the captured hostile-value formatter; coordinator tests cover getters, coercion hooks, custom inspectors, and Proxies.
+  readonly inspect: (value: unknown, options: DenoInspectOptions) => string;
+  readonly internal: symbol;
+  readonly [key: symbol]:
+    | {
+        readonly inspectArgs: (args: readonly unknown[], options: DenoInspectOptions) => string;
+      }
+    | undefined;
   readonly version: {
     readonly deno: string;
     readonly v8: string;
@@ -26,6 +41,11 @@ type CodeModeDenoNamespace = {
 declare const Deno: CodeModeDenoNamespace;
 
 const denoProcess = Deno;
+const denoInspect = denoProcess.inspect;
+const denoInternal = denoProcess[denoProcess.internal];
+if (denoInternal === undefined)
+  throw new Error("Pi CodeMode: Deno Console formatter is unavailable");
+const denoInspectArgs = denoInternal.inspectArgs;
 const arrayIsArray = Array.isArray;
 const arrayPrototype = Array.prototype;
 const blobConstructor = Blob;
@@ -43,6 +63,11 @@ const numberFrom = Number;
 const numberIsFinite = Number.isFinite;
 const numberIsSafeInteger = Number.isSafeInteger;
 const objectFreeze = Object.freeze;
+const SAFE_DENO_INSPECT_OPTIONS = objectFreeze({
+  colors: false,
+  getters: false,
+  customInspect: false,
+} as const);
 const objectPrototype = Object.prototype;
 const ownKeys = Reflect.ownKeys;
 const queueRuntimeMicrotask = queueMicrotask.bind(globalThis);
@@ -159,6 +184,9 @@ type ActiveWorkerCell = {
   readonly sessionId: string;
   readonly cellId: string;
   readonly pendingCalls: PendingGuestToolCall[];
+  readonly consoleEntries: CodeModeConsoleEntry[];
+  consoleBytes: number;
+  consoleOverflow: boolean;
   batchSequence: number;
   callSequence: number;
   batchScheduled: boolean;
@@ -206,6 +234,113 @@ function isReservedNotebookBindingName(name: string): boolean {
   return false;
 }
 
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Cell Console calls accept arbitrary guest values; captured Deno.inspect disables getters and custom inspection, while coordinator hostile-value tests cover coercion hooks and Proxies.
+function inspectGuestConsoleValue(value: unknown): string {
+  try {
+    return denoInspect(value, SAFE_DENO_INSPECT_OPTIONS);
+  } catch {
+    return "[Uninspectable value]";
+  }
+}
+
+function formatGuestConsoleArguments(args: readonly unknown[]): string | undefined {
+  if (args.length === 0) return "";
+  const first = args[0];
+  const maximumTextLength =
+    CODEMODE_WORKER_MESSAGE_LIMIT_BYTES - CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES;
+  if (isGuestString(first) && first.length >= maximumTextLength) return undefined;
+  if (args.length === 1 && isGuestString(first)) return first;
+  if (isGuestString(first) && !first.includes("%")) {
+    let text = first;
+    for (let index = 1; index < args.length; index += 1) {
+      const value = args[index];
+      const rendered = isGuestString(value) ? value : inspectGuestConsoleValue(value);
+      if (text.length + rendered.length + 1 >= maximumTextLength) return undefined;
+      text += ` ${rendered}`;
+    }
+    return text;
+  }
+  if (!isGuestString(first)) {
+    let text = "";
+    for (let index = 0; index < args.length; index += 1) {
+      const value = args[index];
+      const rendered = isGuestString(value) ? value : inspectGuestConsoleValue(value);
+      const separatorLength = index === 0 ? 0 : 1;
+      if (text.length + rendered.length + separatorLength >= maximumTextLength) return undefined;
+      if (separatorLength > 0) text += " ";
+      text += rendered;
+    }
+    return text;
+  }
+
+  const safeArgs: unknown[] = [first];
+  for (let index = 1; index < args.length; index += 1) safeArgs[index] = args[index];
+  let format = "";
+  let argumentIndex = 1;
+  for (let index = 0; index < first.length; index += 1) {
+    const character = first[index];
+    if (character !== "%" || index + 1 >= first.length) {
+      format += character;
+      continue;
+    }
+    const token = first[index + 1];
+    if (token === "%") {
+      format += "%%";
+      index += 1;
+      continue;
+    }
+    if (
+      token !== "s" &&
+      token !== "d" &&
+      token !== "i" &&
+      token !== "f" &&
+      token !== "j" &&
+      token !== "o" &&
+      token !== "O" &&
+      token !== "c"
+    ) {
+      format += `%${token}`;
+      index += 1;
+      continue;
+    }
+    const value = safeArgs[argumentIndex];
+    if (value !== undefined || argumentIndex < safeArgs.length) {
+      if (isGuestReference(value)) {
+        const inspected = inspectGuestConsoleValue(value);
+        if (inspected.length >= maximumTextLength) return undefined;
+        safeArgs[argumentIndex] = inspected;
+        format += token === "c" ? "%c" : "%s";
+      } else {
+        format += `%${token}`;
+      }
+      argumentIndex += 1;
+    } else {
+      format += `%${token}`;
+    }
+    index += 1;
+  }
+  safeArgs[0] = format;
+  for (let index = argumentIndex; index < safeArgs.length; index += 1) {
+    const value = safeArgs[index];
+    if (isGuestReference(value)) {
+      const inspected = inspectGuestConsoleValue(value);
+      if (inspected.length >= maximumTextLength) return undefined;
+      safeArgs[index] = inspected;
+    }
+  }
+  let minimumFormattedBytes = 0;
+  for (const value of safeArgs) {
+    if (isGuestString(value)) minimumFormattedBytes += value.length;
+    if (
+      minimumFormattedBytes + CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+      CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+    ) {
+      return undefined;
+    }
+  }
+  return denoInspectArgs(safeArgs, SAFE_DENO_INSPECT_OPTIONS);
+}
+
 function assertNotebookBindingNameAvailable(name: string): void {
   if (isReservedNotebookBindingName(name)) {
     throw new typeErrorConstructor(`CodeMode Notebook Binding '${name}' is reserved`);
@@ -398,6 +533,35 @@ function utf8ByteLength(value: string): number {
   return encodeUtf8(value).byteLength;
 }
 
+function utf8JsonStringByteLength(value: string): number {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0x22 || codeUnit === 0x5c) bytes += 2;
+    else if (codeUnit <= 0x1f) {
+      bytes +=
+        codeUnit === 0x08 ||
+        codeUnit === 0x09 ||
+        codeUnit === 0x0a ||
+        codeUnit === 0x0c ||
+        codeUnit === 0x0d
+          ? 2
+          : 6;
+    } else if (codeUnit <= 0x7f) bytes += 1;
+    else if (codeUnit <= 0x7ff) bytes += 2;
+    else if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const lowSurrogate = value.charCodeAt(index + 1);
+      if (lowSurrogate >= 0xdc00 && lowSurrogate <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 6;
+    } else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) bytes += 6;
+    else bytes += 3;
+    if (bytes >= CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) return bytes;
+  }
+  return bytes;
+}
+
 // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: This is arbitrary guest ingress; descriptor-only traversal avoids invoking accessors, coercion, and guest-mutated methods. Coordinator hostile JSON tests cover the boundary.
 function serializeGuestJson(value: unknown, allowUndefined: boolean): string | undefined {
   const seen: object[] = [];
@@ -715,6 +879,50 @@ defineProperty(globalThis, "tools", {
   value: tools,
   writable: false,
 });
+const guestConsole = createObject(null);
+for (const method of CODEMODE_CONSOLE_METHODS) {
+  defineProperty(guestConsole, method, {
+    configurable: false,
+    enumerable: true,
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Cell Console calls accept arbitrary guest values; formatGuestConsoleArguments safely inspects them before capture.
+    value: (...args: unknown[]): undefined => {
+      const cell = activeCell;
+      if (cell !== undefined && !cell.consoleOverflow) {
+        const text = formatGuestConsoleArguments(args);
+        if (text === undefined) {
+          cell.consoleEntries.length = 0;
+          cell.consoleOverflow = true;
+          return undefined;
+        }
+        const entryBytes = 19 + utf8JsonStringByteLength(method) + utf8JsonStringByteLength(text);
+        const nextConsoleBytes =
+          cell.consoleBytes + (cell.consoleEntries.length === 0 ? 0 : 1) + entryBytes;
+        if (
+          nextConsoleBytes + CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+          CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+        ) {
+          cell.consoleEntries.length = 0;
+          cell.consoleOverflow = true;
+          return undefined;
+        }
+        cell.consoleEntries[cell.consoleEntries.length] = {
+          method,
+          text,
+        };
+        cell.consoleBytes = nextConsoleBytes;
+      }
+      return undefined;
+    },
+    writable: false,
+  });
+}
+objectFreeze(guestConsole);
+defineProperty(globalThis, "console", {
+  configurable: false,
+  enumerable: false,
+  value: guestConsole,
+  writable: false,
+});
 
 function disableGuestGlobal(name: string, value?: Readonly<typeof safeDenoIdentity>): void {
   const descriptor = getOwnPropertyDescriptor(globalThis, name);
@@ -770,7 +978,6 @@ const safeDenoIdentity = objectFreeze({
 disableGuestGlobal("Deno", safeDenoIdentity);
 for (const unsafeGlobal of [
   "process",
-  "console",
   "alert",
   "confirm",
   "prompt",
@@ -889,42 +1096,97 @@ function scheduleCellFinish(cell: ActiveWorkerCell): void {
       return;
     }
     activeCell = undefined;
+    const consoleEntries = cell.consoleEntries.length === 0 ? undefined : [...cell.consoleEntries];
     let response: CodeModeWorkerResponse;
-    if (cell.mainFailed) {
-      const error = describeGuestError(cell.mainError);
-      const serializationFailure =
-        isGuestReference(cell.mainError) &&
-        (hasSerializationErrorInstance(cell.mainError) ||
-          internalToolErrorCode(cell.mainError) === "serialization");
+    if (cell.consoleOverflow) {
       response = {
         version: 1,
         type: "cell-error",
         sessionId: cell.sessionId,
         cellId: cell.cellId,
-        error: {
-          code: serializationFailure ? "serialization" : "script",
-          message: renderGuestError(error),
-        },
+        error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
       };
-    } else {
-      try {
-        const resultJson = serializeGuestJson(cell.mainResult, true);
+    } else if (cell.mainFailed) {
+      const error = describeGuestError(cell.mainError);
+      const serializationFailure =
+        isGuestReference(cell.mainError) &&
+        (hasSerializationErrorInstance(cell.mainError) ||
+          internalToolErrorCode(cell.mainError) === "serialization");
+      const message = renderGuestError(error);
+      if (
+        consoleEntries !== undefined &&
+        cell.consoleBytes +
+          utf8JsonStringByteLength(message) +
+          CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+          CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+      ) {
+        response = {
+          version: 1,
+          type: "cell-error",
+          sessionId: cell.sessionId,
+          cellId: cell.cellId,
+          error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
+        };
+      } else {
         const responseBase = {
           version: 1,
-          type: "cell-result",
+          type: "cell-error",
           sessionId: cell.sessionId,
           cellId: cell.cellId,
+          error: {
+            code: serializationFailure ? "serialization" : "script",
+            message,
+          },
         } as const;
-        response = resultJson === undefined ? responseBase : { ...responseBase, resultJson };
+        response =
+          consoleEntries === undefined
+            ? responseBase
+            : { ...responseBase, console: consoleEntries };
+      }
+    } else {
+      try {
+        const resultJson = serializeGuestJson(cell.mainResult, true);
+        if (
+          consoleEntries !== undefined &&
+          cell.consoleBytes +
+            (resultJson === undefined ? 0 : utf8JsonStringByteLength(resultJson)) +
+            CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+            CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+        ) {
+          response = {
+            version: 1,
+            type: "cell-error",
+            sessionId: cell.sessionId,
+            cellId: cell.cellId,
+            error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
+          };
+        } else {
+          const responseBase = {
+            version: 1,
+            type: "cell-result",
+            sessionId: cell.sessionId,
+            cellId: cell.cellId,
+          } as const;
+          const resultResponse =
+            resultJson === undefined ? responseBase : { ...responseBase, resultJson };
+          response =
+            consoleEntries === undefined
+              ? resultResponse
+              : { ...resultResponse, console: consoleEntries };
+        }
       } catch (cause) {
         const error = describeGuestError(cause);
-        response = {
+        const responseBase = {
           version: 1,
           type: "cell-error",
           sessionId: cell.sessionId,
           cellId: cell.cellId,
           error: { code: "serialization", message: renderGuestError(error) },
-        };
+        } as const;
+        response =
+          consoleEntries === undefined
+            ? responseBase
+            : { ...responseBase, console: consoleEntries };
       }
     }
     void enqueueWorkerResponse(response);
@@ -939,6 +1201,9 @@ function startWorkerCell(
     sessionId: request.sessionId,
     cellId: request.cellId,
     pendingCalls: [],
+    consoleEntries: [],
+    consoleBytes: 2,
+    consoleOverflow: false,
     batchSequence: 0,
     callSequence: 0,
     batchScheduled: false,