pi-supernova 0.2.0 → 0.3.1

package/{render-measure.js → src/ui/render-measure.js}

@@ -4,8 +4,34 @@ import stringWidth from "string-width";
 const ELLIPSIS = "…";
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
+const widthCache = new Map();
+let cachedWidthChars = 0;
+const MAX_WIDTH_CACHE_CHARS = 512_000;
+
 export function measureWidth(text) {
-  return stringWidth(String(text ?? "").replace(/\t/g, "   "));
+  const raw = String(text ?? "");
+  const cached = widthCache.get(raw);
+  if (cached !== undefined) return cached;
+  const normalized = raw.replace(/\t/g, "   ");
+  // eslint-disable-next-line no-control-regex -- intentional ANSI SGR recognition
+  const plain = normalized.replace(/\x1b\[(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?m/g, "");
+  // ASCII and these single-column chrome glyphs need no Unicode segmentation.
+  // Any other character/control/escape sequence uses the full oracle.
+  const width = /^[\x20-\x7e\u2500-\u257f\u00b7\u00d7\u2026\u2713\u2717]*$/.test(plain)
+    ? plain.length
+    : stringWidth(normalized);
+  // Cache immutable text only, never host/theme/result objects. Bound both
+  // bookkeeping and retained text; unusually long lines bypass retention.
+  if (raw.length <= 4096) {
+    while (widthCache.size >= 4096 || cachedWidthChars + raw.length > MAX_WIDTH_CACHE_CHARS) {
+      const oldest = widthCache.keys().next().value;
+      widthCache.delete(oldest);
+      cachedWidthChars -= oldest.length;
+    }
+    widthCache.set(raw, width);
+    cachedWidthChars += raw.length;
+  }
+  return width;
 }
 
 function takePrefix(text, width) {

package/{render.js → src/ui/render.js}

@@ -11,10 +11,10 @@
  */
 
 import { stripVTControlCharacters } from "node:util";
-import { isString, isObject, isFunction } from "./decode.js";
+import { isString, isObject, isFunction } from "../shared/decode.js";
 import { measureWidth, hardTruncate, clampLine, fitPath, wrapLine } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
-import { formatValue } from "./format.js";
+import { formatValue } from "../output/format.js";
 
 export { measureWidth, hardTruncate, clampLine };
 
@@ -42,14 +42,10 @@ function formatDiffRows(diff, theme, maxShown = 6) {
 }
 
 function stripUnsafeControls(value) {
-	let clean = "";
-	for (const character of value) {
-		const codePoint = character.codePointAt(0);
-		const isC0 = codePoint <= 0x08 || codePoint === 0x0b || codePoint === 0x0c || (codePoint >= 0x0e && codePoint <= 0x1f);
-		const isDeleteOrC1 = codePoint >= 0x7f && codePoint <= 0x9f;
-		if (!isC0 && !isDeleteOrC1) clean += character;
-	}
-	return clean;
+	// Exactly the C0/DEL/C1 ranges previously filtered code point by code point.
+	// Native replacement avoids rebuilding every already-clean Unicode string.
+	// eslint-disable-next-line no-control-regex -- intentional terminal-control filtering
+	return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "");
 }
 
 function cleanBlockText(value) {
@@ -195,11 +191,20 @@ function parseDiffLine(rawLine) {
 	return null;
 }
 
+// Text diffs are immutable, even when hosts replace trace snapshots on each frame.
+// Cache only parsed data, not theme, paths or mutable result objects.
+const textDiffCache = new Map();
+let cachedDiffChars = 0;
+const MAX_CACHED_DIFF_CHARS = 1_000_000;
+
 function normalizeTraceDiff(item) {
 	const diff = item?.diff;
 	if (isObject(diff)) return diff;
 	if (!isString(diff) || !diff.trim()) return undefined;
+	const cached = textDiffCache.get(diff);
+	if (cached) return cached;
 	const lines = [];
+	let displayLineCount = 0;
 	let added = 0;
 	let removed = 0;
 	for (const rawLine of cleanBlockText(diff).split("\n")) {
@@ -207,10 +212,21 @@ function normalizeTraceDiff(item) {
 		if (!parsed) continue;
 		if (parsed.type === "add") added += 1;
 		else if (parsed.type === "remove") removed += 1;
-		lines.push(parsed);
+		displayLineCount++;
+		if (lines.length < 24) lines.push(parsed);
 	}
 	if (lines.length === 0) return undefined;
-	return { path: item?.args?.path || "", op: item?.name, added, removed, lines };
+	const parsed = { added, removed, lines, displayLineCount };
+	if (diff.length <= MAX_CACHED_DIFF_CHARS) {
+		while (textDiffCache.size >= 24 || cachedDiffChars + diff.length > MAX_CACHED_DIFF_CHARS) {
+			const oldest = textDiffCache.keys().next().value;
+			textDiffCache.delete(oldest);
+			cachedDiffChars -= oldest.length;
+		}
+		textDiffCache.set(diff, parsed);
+		cachedDiffChars += diff.length;
+	}
+	return parsed;
 }
 
 function operationsFromTrace(trace) {
@@ -305,8 +321,9 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	return prefix.trimEnd();
 }
 
-function operationsFor(payload, context) {
-	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
+function traceFor(payload, context) {
+	const trace = payload?.trace || context?.state?.trace;
+	return Array.isArray(trace) ? trace : [];
 }
 
 function resultLines(value, width) {
@@ -317,7 +334,7 @@ function resultLines(value, width) {
 function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError) {
 	for (const op of ops.slice(0, maxOps)) {
 		lines.push(formatOpRow(theme, op, width, isPartial, isError));
-		if (!op.diff || !isObject(op.diff)) continue;
+		if (maxDiffLines === 0 || !op.diff || !isObject(op.diff)) continue;
 		for (const row of formatDiffRows(op.diff, theme, maxDiffLines)) lines.push("  " + row);
 	}
 	if (ops.length > maxOps) lines.push(theme.fg("dim", `  … ${ops.length - maxOps} more calls`));
@@ -338,14 +355,19 @@ function appendTail(lines, theme, payload, expanded, isError, width) {
 	}
 }
 
-function buildBodyLines(theme, width, { payload, context, args, expanded, isPartial, isError }) {
-	const ops = operationsFor(payload, context, args);
+function buildBodyLines(theme, width, { payload, context, expanded, isPartial, isError }) {
+	const trace = traceFor(payload, context);
 	const maxOps = expanded ? 24 : 8;
-	const maxDiffLines = expanded ? 24 : 8;
+	const maxDiffLines = expanded ? 24 : isPartial ? 0 : 8;
+	// Select before parsing diffs: invisible history must not consume a frame.
+	// While running, show current activity rather than the first completed calls.
+	const visible = isPartial ? trace.slice(-maxOps) : trace.slice(0, maxOps);
+	const ops = operationsFromTrace(visible);
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
+	if (trace.length > maxOps) lines.push(theme.fg("dim", `  … ${trace.length - maxOps} ${isPartial ? "earlier" : "more"} calls`));
 	appendTail(lines, theme, payload, expanded, isError, width);
-	return { lines, opCount: ops.length };
+	return { lines, opCount: trace.length };
 }
 
 function describeCard(model, opCount) {
@@ -404,7 +426,7 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 		contextArg,
 	);
 
-	const payload = result?.details;
+	const payload = result?.details ?? (result?.isError ? { ok: false, error: result.content?.filter(block => block.type === "text").map(block => block.text).join("\n") } : undefined);
 	syncState(context, payload);
 
 	const isError = result?.isError || payload?.ok === false;