@code-yeongyu/senpi-codemode 2026.10.13 → 2026.10.16

package/CHANGELOG.md

@@ -12,6 +12,32 @@
 
 ### Removed
 
+## [2026.10.16] - 2026-10-16
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.10.15] - 2026-10-15
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- `display()` of a large object, such as a screenshot result that wraps a multi-MB Buffer, no longer writes megabytes into the session file or breaks the session render. The stored copy is trimmed inside the value instead of dropped: every top-level key is kept, Buffers become a `<Buffer N MB>` summary, long strings, arrays and keys keep a prefix with a visible marker, and the entry stays within the display budget, emoji included. Older sessions holding such entries render a short summary, and an object whose `buffer` holds image bytes now displays as the image with its metadata ([#3320](https://github.com/code-yeongyu/senpi/pull/3320)).
+
+### Removed
+
 ## [2026.10.13] - 2026-10-13
 
 ### Breaking Changes

package/README.md

@@ -456,7 +456,7 @@ so providers can interpret it independently.
 ## Detached cells
 
 `eval` accepts `on_timeout: "detach"|"error"`. The default is `"detach"` in
-interactive TUI, RPC, and app-server sessions; print and JSON one-shot runs
+interactive TUI and RPC sessions; print and JSON one-shot runs
 default to `"error"` so their result is never silently detached. A detached
 cell keeps only its own language kernel busy. New same-language cells are admitted
 into its FIFO queue; calls in other languages continue normally. Queued cells may

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.13",
+	"version": "2026.10.16",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -33,15 +33,15 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.13",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.16",
 		"quickjs-wasi": "3.6.2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.13"
+		"@code-yeongyu/senpi": "2026.10.16"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.13"
+		"@code-yeongyu/senpi": "2026.10.16"
 	},
 	"keywords": [
 		"senpi",

package/src/kernels/js/display-image.js

@@ -113,6 +113,38 @@ function isEncodableImage(value) {
 	return !isBinaryData(value) && (typeof value.arrayBuffer === "function" || typeof value.bytes === "function");
 }
 
+// { buffer: <bytes>, ...metadata } (e.g. an omowright screenshot): the bytes frame as an image when they
+// carry a known signature; the remaining own fields display as compact JSON text. Non-image bytes or a
+// non-plain wrapper stay on the JSON path. BMP's two-byte 'BM' signature is too weak for the wrapper path
+// (a plain-text buffer can start with 'BM'), so it is only trusted when the header length field is plausible.
+function wrappedBufferImageOps(value) {
+	if (Object.getPrototypeOf(value) !== Object.prototype || !("buffer" in value)) return undefined;
+	const bytes = bytesOf(value.buffer);
+	if (bytes === undefined) return undefined;
+	const mimeType = sniffImageMimeType(bytes);
+	if (mimeType === undefined) return undefined;
+	if (mimeType === "image/bmp" && !isPlausibleBmp(bytes)) return undefined;
+	const frameOp = frame(mimeType, Buffer.from(bytes).toString("base64"));
+	const meta = {};
+	for (const key of Object.keys(value)) {
+		if (key !== "buffer") meta[key] = value[key];
+	}
+	if (Object.keys(meta).length === 0) return [frameOp];
+	try {
+		return [{ kind: "text", text: JSON.stringify(meta) }, frameOp];
+	} catch {
+		return [frameOp];
+	}
+}
+
+function isPlausibleBmp(bytes) {
+	// A BMP header is at least 26 bytes (14 file + 12 info), and its little-endian file-size field must
+	// not exceed the bytes actually present: text after "BM" declares hundreds of MB and stays JSON.
+	if (bytes.length < 26) return false;
+	const declared = bytes[2] | (bytes[3] << 8) | (bytes[4] << 16) | (bytes[5] << 24);
+	return declared >= 26 && bytes.length >= declared;
+}
+
 function frame(mimeType, dataBase64) {
 	return { kind: "frame", mimeType, dataBase64 };
 }
@@ -141,7 +173,7 @@ export function resolveDisplayOps(value) {
 		return [frame(payload.mimeType ?? "application/octet-stream", payload.dataBase64)];
 	}
 	if (isEncodableImage(value)) return [{ kind: "encode", value }];
-	return undefined;
+	return wrappedBufferImageOps(value);
 }
 
 export async function encodeDisplayImage(value) {

package/src/tool/display-json-bounds.ts

@@ -0,0 +1,237 @@
+import {
+	bufferPlaceholder,
+	isRecord,
+	MAX_DISPLAY_JSON_BYTES,
+	serializedBufferByteLength,
+	serializedStringLength,
+} from "./display-json-size.ts";
+import {
+	JSON_TREE_MAX_DEPTH_EXPANDED,
+	JSON_TREE_MAX_LINES_EXPANDED,
+	JSON_TREE_SCALAR_LEN_EXPANDED,
+} from "./json-tree.ts";
+
+const STUB = "…";
+const STUB_COST = 3; // JSON.stringify("…")
+const MAX_KEY_CHARS = 64;
+
+function serializedLength(value: unknown): number {
+	return value === undefined ? 0 : JSON.stringify(value).length;
+}
+
+function elisionMarker(elided: number): string {
+	return `[…${elided}ch elided…]`;
+}
+
+/** keptLength moved back so the prefix never ends on the high half of a surrogate pair. */
+function characterBoundary(value: string, keptLength: number): number {
+	const last = value.charCodeAt(keptLength - 1);
+	return keptLength > 0 && last >= 0xd800 && last <= 0xdbff ? keptLength - 1 : keptLength;
+}
+
+/** The longest prefix of value whose serialized length with its elision marker fits limit, or undefined. */
+function trimmedString(value: string, maxChars: number, limit: number): string | undefined {
+	let keptLength = characterBoundary(value, Math.min(maxChars, value.length));
+	while (keptLength >= 0) {
+		const candidate = `${value.slice(0, keptLength)}${elisionMarker(value.length - keptLength)}`;
+		if (serializedStringLength(candidate) <= limit) return candidate;
+		if (keptLength === 0) return undefined;
+		keptLength = characterBoundary(value, Math.floor(keptLength / 2));
+	}
+	return undefined;
+}
+
+function boundString(value: string, limit: number): string {
+	if (value.length <= JSON_TREE_SCALAR_LEN_EXPANDED && serializedStringLength(value) <= limit) return value;
+	return trimmedString(value, JSON_TREE_SCALAR_LEN_EXPANDED, limit) ?? STUB;
+}
+
+/** Keys are display data too: long or escape-heavy keys keep a prefix and stay unique (#3261 review). */
+function fittedKey(key: string, maxChars: number): string {
+	return key.length <= maxChars && serializedStringLength(key) <= maxChars + 2
+		? key
+		: (trimmedString(key, maxChars, maxChars + 2) ?? STUB);
+}
+
+function boundKey(key: string, taken: Set<string>): string {
+	let unique = fittedKey(key, MAX_KEY_CHARS);
+	for (let suffix = 2; taken.has(unique); suffix += 1) {
+		// The suffix fits inside the key limit so every stored key stays within MAX_KEY_CHARS.
+		unique = `${fittedKey(key, MAX_KEY_CHARS - String(suffix).length - 1)}#${suffix}`;
+	}
+	taken.add(unique);
+	return unique;
+}
+
+/**
+ * Serialized length of what boundNode would keep given unlimited room, capped at cap + 1 so a
+ * multi-MB value is never walked past what the budget could use.
+ */
+function boundedNeed(value: unknown, depth: number, cap: number): number {
+	if (value === undefined) return 0;
+	if (value === null || typeof value === "boolean" || typeof value === "number") return serializedLength(value);
+	if (typeof value === "string") {
+		if (value.length > cap || value.length > JSON_TREE_SCALAR_LEN_EXPANDED) return cap + 1;
+		return Math.min(cap + 1, serializedStringLength(value));
+	}
+	const bufferBytes = serializedBufferByteLength(value);
+	if (bufferBytes !== undefined) return serializedLength(bufferPlaceholder(bufferBytes));
+	if (depth >= JSON_TREE_MAX_DEPTH_EXPANDED) return STUB_COST;
+	let total = 2;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			total += 1 + boundedNeed(item, depth + 1, cap - total);
+			if (total > cap) return cap + 1;
+		}
+		return total;
+	}
+	if (isRecord(value)) {
+		for (const key in value) {
+			total += 2 + serializedStringLength(key) + boundedNeed(value[key], depth + 1, cap - total);
+			if (total > cap) return cap + 1;
+		}
+		return total;
+	}
+	return Math.min(cap + 1, serializedStringLength(String(value)));
+}
+
+function boundArray(value: readonly unknown[], depth: number, limit: number): unknown {
+	const kept: unknown[] = [];
+	let used = 2;
+	for (const [index, item] of value.entries()) {
+		const marker = `… (${value.length - index} more items)`;
+		const markerCost = serializedLength(marker) + (index > 0 ? 1 : 0);
+		const isLast = index === value.length - 1;
+		const room =
+			limit - used - (index > 0 ? 1 : 0) - (isLast ? 0 : serializedLength(`… (${value.length} more items)`) + 1);
+		if (index >= JSON_TREE_MAX_LINES_EXPANDED || room < STUB_COST + 8) {
+			if (used + markerCost > limit) return kept.length === 0 ? STUB : kept;
+			kept.push(marker);
+			return kept;
+		}
+		const child = boundNode(item, depth + 1, room);
+		used += (index > 0 ? 1 : 0) + (child === undefined ? 4 : serializedLength(child));
+		kept.push(child);
+	}
+	return kept;
+}
+
+function boundRecord(value: Record<string, unknown>, depth: number, limit: number): unknown {
+	const taken = new Set<string>();
+	const keys = Object.keys(value);
+	const shown = keys.slice(0, JSON_TREE_MAX_LINES_EXPANDED).map((key) => ({ key, stored: boundKey(key, taken) }));
+	const overflowKey = boundKey("…", taken);
+	const stubCost = (entry: { stored: string }) => serializedStringLength(entry.stored) + 2 + STUB_COST;
+	const overflowCost = (count: number) =>
+		count === 0 ? 0 : serializedStringLength(overflowKey) + 2 + serializedLength(`${count} more keys`);
+	// Every shown key is guaranteed at least a stub value; keys that cannot all fit become a visible count.
+	let base = 2 + shown.reduce((sum, entry) => sum + stubCost(entry), 0) + overflowCost(keys.length - shown.length);
+	while (base > limit && shown.length > 0) {
+		const dropped = shown.pop();
+		if (dropped) base -= stubCost(dropped);
+		base += overflowCost(keys.length - shown.length) - overflowCost(keys.length - shown.length - 1);
+	}
+	if (base > limit) return STUB;
+	// Max-min fair share of the remaining room: small values are kept whole, large ones share what is left.
+	let pool = limit - base;
+	const needs = shown.map((entry) =>
+		Math.max(0, boundedNeed(value[entry.key], depth + 1, pool + STUB_COST) - STUB_COST),
+	);
+	const order = shown.map((_, index) => index).sort((left, right) => (needs[left] ?? 0) - (needs[right] ?? 0));
+	const results = new Map<number, unknown>();
+	for (const [position, index] of order.entries()) {
+		const entry = shown[index];
+		if (!entry) continue;
+		const share = Math.floor(pool / (order.length - position));
+		const grant = Math.min(needs[index] ?? 0, share);
+		const child = boundNode(value[entry.key], depth + 1, STUB_COST + grant);
+		pool -= Math.max(0, serializedLength(child) - STUB_COST);
+		results.set(index, child);
+	}
+	const kept: Record<string, unknown> = {};
+	for (const [index, entry] of shown.entries()) kept[entry.stored] = results.get(index);
+	if (keys.length > shown.length) kept[overflowKey] = `${keys.length - shown.length} more keys`;
+	return kept;
+}
+
+/**
+ * Serialized length of value when bounding would keep it unchanged (no cap, depth, key, or Buffer rule
+ * applies), or Infinity otherwise; stops counting past cap so large values are never walked in full.
+ */
+function unchangedLength(value: unknown, depth: number, cap: number): number {
+	if (value === undefined || value === null || typeof value === "boolean" || typeof value === "number") {
+		return value === undefined ? 4 : serializedLength(value);
+	}
+	if (typeof value === "string") {
+		return value.length > JSON_TREE_SCALAR_LEN_EXPANDED || value.length > cap
+			? Number.POSITIVE_INFINITY
+			: serializedStringLength(value);
+	}
+	if (depth >= JSON_TREE_MAX_DEPTH_EXPANDED || serializedBufferByteLength(value) !== undefined) {
+		return Number.POSITIVE_INFINITY;
+	}
+	let total = 2;
+	if (Array.isArray(value)) {
+		if (value.length > JSON_TREE_MAX_LINES_EXPANDED) return Number.POSITIVE_INFINITY;
+		for (const item of value) {
+			total += 1 + unchangedLength(item, depth + 1, cap - total);
+			if (total > cap) return Number.POSITIVE_INFINITY;
+		}
+		return total;
+	}
+	if (isRecord(value)) {
+		let count = 0;
+		for (const key in value) {
+			count += 1;
+			if (count > JSON_TREE_MAX_LINES_EXPANDED || key.length > MAX_KEY_CHARS) return Number.POSITIVE_INFINITY;
+			const keyLength = serializedStringLength(key);
+			if (keyLength > MAX_KEY_CHARS + 2) return Number.POSITIVE_INFINITY;
+			total += 2 + keyLength + unchangedLength(value[key], depth + 1, cap - total);
+			if (total > cap) return Number.POSITIVE_INFINITY;
+		}
+		return total;
+	}
+	return Number.POSITIVE_INFINITY;
+}
+
+/** The value bounded so its serialized length is at most max(limit, 3). */
+function boundNode(value: unknown, depth: number, limit: number): unknown {
+	if (value === undefined) return value;
+	// A value that already fits as it is stays exactly as it is.
+	if (unchangedLength(value, depth, limit) <= limit) return value;
+	if (value === null || typeof value === "boolean" || typeof value === "number") {
+		return serializedLength(value) <= limit ? value : STUB;
+	}
+	if (typeof value === "string") return boundString(value, limit);
+	const bufferBytes = serializedBufferByteLength(value);
+	if (bufferBytes !== undefined) {
+		const placeholder = bufferPlaceholder(bufferBytes);
+		return serializedLength(placeholder) <= limit ? placeholder : STUB;
+	}
+	if (depth >= JSON_TREE_MAX_DEPTH_EXPANDED || limit < STUB_COST + 2) return STUB;
+	if (Array.isArray(value)) return boundArray(value, depth, limit);
+	if (isRecord(value)) return boundRecord(value, depth, limit);
+	return boundString(String(value), limit);
+}
+
+/** Every top-level key with a stub value, or a bare stub when even that cannot fit. */
+function skeleton(value: unknown): unknown {
+	if (!isRecord(value)) return STUB;
+	const stubbed = boundRecord(
+		Object.fromEntries(Object.keys(value).map((key) => [key, STUB])),
+		0,
+		MAX_DISPLAY_JSON_BYTES,
+	);
+	return serializedLength(stubbed) <= MAX_DISPLAY_JSON_BYTES ? stubbed : STUB;
+}
+
+/**
+ * Bounds one display value for persistence in `details.jsonOutputs`. The value is trimmed inside, never
+ * replaced: every shown key keeps at least a stub, serialized Buffers become `<Buffer N>`, long strings,
+ * arrays and objects carry a visible `… elided` / `N more items` / `N more keys` marker, keys are
+ * trimmed like strings, and the real serialized length is checked last (#3261 review).
+ */
+export function sanitizeDisplayJson(value: unknown): unknown {
+	const sanitized = boundNode(value, 0, MAX_DISPLAY_JSON_BYTES);
+	return serializedLength(sanitized) <= MAX_DISPLAY_JSON_BYTES ? sanitized : skeleton(value);
+}

package/src/tool/display-json-size.ts

@@ -0,0 +1,86 @@
+// Display JSON size accounting shared by storage bounding and legacy rendering (#3261).
+
+/** Model-facing display text budget; the stored jsonOutputs entry follows the same order of budget. */
+export const MAX_DISPLAY_TEXT_BYTES = 8_000;
+/**
+ * Total serialized-size budget for one stored entry. Measured in characters (JS string length), so
+ * non-ASCII text can store up to ~3x this many UTF-8 bytes; the bound is what matters (#3261 review).
+ */
+export const MAX_DISPLAY_JSON_BYTES = MAX_DISPLAY_TEXT_BYTES;
+
+/**
+ * Byte length of a `{type:"Buffer",data:[...]}` serialization, or undefined when the shape is not one.
+ * Only a bounded prefix of the data array is validated, so a multi-MB legacy dump never gets walked (#3261).
+ */
+export function serializedBufferByteLength(value: unknown): number | undefined {
+	if (!isRecord(value) || value.type !== "Buffer" || !Array.isArray(value.data)) return undefined;
+	if (value.data.length === 0) return 0;
+	const prefixLength = Math.min(value.data.length, 1_024);
+	for (let index = 0; index < prefixLength; index += 1) {
+		const byte = value.data[index];
+		if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
+	}
+	return value.data.length;
+}
+
+export function formatByteLength(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${Number((bytes / 1024).toFixed(1))} KB`;
+	return `${Number((bytes / (1024 * 1024)).toFixed(1))} MB`;
+}
+
+export function bufferPlaceholder(bytes: number): string {
+	return `<Buffer ${formatByteLength(bytes)}>`;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Length of value's JSON string body after escaping; bounded at 6x plus quotes, never serialized here. */
+export function serializedStringLength(value: string): number {
+	let length = 2;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		// Control characters, quotes, backslashes and lone surrogates escape (up to \uXXXX); everything else
+		// costs its UTF-16 length, so a character above U+FFFF counts as the two units JSON.stringify writes.
+		const escaped =
+			codePoint < 0x20 || character === '"' || character === "\\" || (codePoint >= 0xd800 && codePoint <= 0xdfff);
+		length += escaped ? JSON.stringify(character).length : character.length;
+	}
+	return length;
+}
+
+/**
+ * Iterative early-exit size estimate for stored entries (legacy sessions carry multi-MB ones); never
+ * enumerates more of the value than the budget plus a key.
+ */
+export function displayJsonSizeExceeds(value: unknown, budget: number): boolean {
+	let size = 0;
+	const pending: unknown[] = [value];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node === null || node === undefined) continue;
+		if (typeof node === "boolean" || typeof node === "number") {
+			size += 8;
+		} else if (typeof node === "string") {
+			size += node.length;
+		} else if (Array.isArray(node)) {
+			size += 2;
+			for (const child of node) {
+				size += 1;
+				if (size > budget) return true;
+				pending.push(child);
+			}
+		} else if (isRecord(node)) {
+			size += 2;
+			for (const key in node) {
+				size += key.length + 1;
+				if (size > budget) return true;
+				pending.push(node[key]);
+			}
+		}
+		if (size > budget) return true;
+	}
+	return false;
+}

package/src/tool/image.ts

@@ -11,6 +11,8 @@ import {
 	TailBuffer,
 	truncateTail,
 } from "../output/streaming-output.ts";
+import { sanitizeDisplayJson } from "./display-json-bounds.ts";
+import { MAX_DISPLAY_TEXT_BYTES } from "./display-json-size.ts";
 import { type EvalImageContent, type EvalImageResizer, resizeEvalImage } from "./image-resize.ts";
 
 export {
@@ -22,8 +24,6 @@ export {
 } from "./image-resize.ts";
 export { marshalToolResult, toolResultIsError } from "./tool-result-marshal.ts";
 
-const MAX_DISPLAY_TEXT_BYTES = 8_000;
-
 // Per-cell display caps: display payloads are retained for the whole result lifetime, so an unbounded
 // burst pins base64 originals plus resized copies on the session heap (#1695).
 const MAX_DISPLAY_IMAGES_PER_CELL = 8;
@@ -149,7 +149,7 @@ export class EvalOutputCollector {
 				if (error instanceof SyntaxError) throw new DisplayPayloadError(message.mimeType, error);
 				throw error;
 			}
-			this.#jsonOutputs.push(value);
+			this.#jsonOutputs.push(sanitizeDisplayJson(value));
 			this.#sink.push(`display[${this.#jsonOutputs.length}]:\n${formatDisplayJson(value)}\n`);
 			return;
 		}

package/src/tool/render-detail.ts

@@ -1,5 +1,13 @@
 import { type AgentToolResult, sanitizeTerminalLabel, type Theme } from "@code-yeongyu/senpi";
 import {
+	bufferPlaceholder,
+	displayJsonSizeExceeds,
+	formatByteLength,
+	MAX_DISPLAY_JSON_BYTES,
+	serializedBufferByteLength,
+} from "./display-json-size.ts";
+import {
+	formatScalar,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
 	JSON_TREE_MAX_LINES_COLLAPSED,
@@ -44,12 +52,70 @@ export function renderJsonOutputs(values: readonly unknown[], environment: Rende
 			lines,
 			renderAllVisualLines(style(environment.theme, "dim", `display[${index + 1}]`), environment.width),
 		);
+		appendLines(lines, renderJsonEntryLines(value, environment, depth, lineCap, scalarLen));
+	}
+	return lines;
+}
+// The real legacy shape stores the screenshot as {buffer:{type:"Buffer",data},...metadata}; the buffer key
+// collapses to a placeholder and the remaining keys render as one scalar summary line each.
+function nestedSerializedBuffer(value: unknown): { readonly key: string } | undefined {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	for (const key of Object.keys(record)) {
+		if (serializedBufferByteLength(record[key]) !== undefined) return { key };
+	}
+	return undefined;
+}
+
+function renderJsonEntryLines(
+	value: unknown,
+	environment: RenderEnvironment,
+	depth: number,
+	lineCap: number,
+	scalarLen: number,
+): string[] {
+	const fallback = (text: string): string[] =>
+		renderAllVisualLines(style(environment.theme, "dim", text), environment.width);
+	try {
+		// Sessions from before the storage bound can hold byte-per-number Buffer dumps or oversized entries;
+		// those collapse to a bounded placeholder or summary instead of walking the whole value.
+		const bufferBytes = serializedBufferByteLength(value);
+		if (bufferBytes !== undefined) return fallback(bufferPlaceholder(bufferBytes));
+		const nested = nestedSerializedBuffer(value);
+		if (nested !== undefined) {
+			const record = value as Record<string, unknown>;
+			const lines = fallback(
+				`${nested.key}: ${bufferPlaceholder(serializedBufferByteLength(record[nested.key]) ?? 0)}`,
+			);
+			const keys = Object.keys(record).filter((key) => key !== nested.key);
+			const shownKeys = keys.slice(0, Math.max(0, lineCap - 1));
+			for (const key of shownKeys) {
+				appendLines(
+					lines,
+					renderAllVisualLines(
+						style(environment.theme, "dim", `  ${key}: ${formatScalar(record[key], scalarLen)}`),
+						environment.width,
+					),
+				);
+			}
+			if (keys.length > shownKeys.length)
+				appendLines(lines, fallback(`  … ${keys.length - shownKeys.length} more keys`));
+			return lines;
+		}
+		if (displayJsonSizeExceeds(value, MAX_DISPLAY_JSON_BYTES)) {
+			return fallback(
+				`… oversized display value elided (${formatScalar(value, scalarLen)}, ~${formatByteLength(MAX_DISPLAY_JSON_BYTES)}+ stored)`,
+			);
+		}
 		const tree = renderJsonTreeLines(value, environment.theme, depth, lineCap, scalarLen);
+		const lines: string[] = [];
 		for (const line of tree.lines) appendLines(lines, renderAllVisualLines(line, environment.width));
 		if (tree.truncated)
 			appendLines(lines, renderAllVisualLines(style(environment.theme, "dim", "…"), environment.width));
+		return lines;
+	} catch {
+		return fallback("[display value could not be rendered]");
 	}
-	return lines;
 }
 
 export function renderDetailedLines(