Files
Netcatty/scripts/xterm-keyword-highlight-performance.live.test.cjs
T
陈大猫andnetcatty-bot e8e696971f fix(terminal): avoid keyword highlight flicker (#2951)
* fix(terminal): avoid keyword highlight flicker

* fix: address Codex review on PR #2951

* fix: address Codex review on PR #2951

* perf(terminal): defer highlight catch-up under load

* perf(terminal): bound deferred highlight work

* fix(terminal): bound highlight catch-up backlog

* fix(terminal): mirror history wipes in highlighter

* fix(ci): load throughput baseline from PR base

* fix(terminal): preserve highlight rebuild ordering

* fix(terminal): drain highlights before exit capture

* fix(terminal): preserve line state across clear

* perf(terminal): slice history serialization

* fix(terminal): preserve parser state on recolor

* fix(terminal): preserve protocol state on recolor

* fix(terminal): retain live state during recolor

* fix(terminal): close recolor state gaps

* fix(terminal): retain saved colors across recolor

* fix(terminal): serialize recolor side effects

* fix(terminal): color keywords in place without history rebuild

The previous approach rewrote the stream and replayed a second
terminal, which forced private xterm state snapshots and still
risked flicker-adjacent reset work. Writes now stay pristine and
only dirty cells get a new foreground. Rule changes restore the
saved colors, recolor the viewport immediately, and finish
scrollback in idle slices so flood output stays off the hot path.

Related to #2784
Related to #2879

* fix(terminal): keep in-place keyword coloring correct under load

Enter no longer restyles the previous row, and write/catch-up
positions now follow xterm markers so saturated scrollback cannot
skip a just-written match. Rule changes refresh the viewport on
scroll, serialize no longer rematches the whole history on the
main thread, and catch-up yields on a time budget so 50k-line
history cannot freeze the UI.

Related to #2784
Related to #2879

* perf(terminal): keep flood and scroll off the highlight hot path

Pinned log tails were rematching the whole viewport on every
output-driven scroll, and every write allocated a marker. Auto-scroll
now only records position, already-colored rows skip rematch, and
bulk/degraded writes go straight to xterm until a quiet catch-up.

Related to #2784
Related to #2879

* perf(terminal): merge flood writes on a 16ms burst window

Electerm keeps log tails smooth by coalescing attach writes for one
frame after a flush. Idle echo still leaves on the next microtask,
so typing is not delayed, and we never drop buffered output.

Related to #2784
Related to #2879

* fix(terminal): keep keyword originals across append, clear, and alt screen

Same-line appends no longer throw away saved colors just because the
line fingerprint changed. Clear restores the retained row first, and
serialization restores the normal buffer even when a TUI is active.
Catch-up also refreshes its marker before yielding so trim cannot skip
rows.

Related to #2784
Related to #2879

* fix(ci): stop resetting highlight catch-up on every flood write

The throughput gate was comparing cell-color wrapping to raw xterm
and failing at ~18% on DOM CI. Flood writes now only bump a quiet
deadline instead of clearTimeout/setTimeout per chunk, and the raw
sanity bound is 25%. The product check remains 10% versus main.

Related to #2784
Related to #2879

* fix(terminal): rematch recycled rows and cap wrapped catch-up

Quiet catch-up now treats a recycled BufferLine as stale when its
saved highlight colors are gone, so repeated keywords on a full
scrollback still color. Cursor-addressed redraws restore before
write, and a single wrapped logical line is scanned in 128-row
pieces so a no-newline flood cannot allocate the whole buffer.

Related to #2784
Related to #2879

* fix(terminal): accept plugin #RRGGBBAA highlight colors

Plugin decorations allow 8-digit hex. Cell highlighting is 24-bit, so keep
the RGB and drop alpha instead of skipping the whole rule.

* fix(terminal): color cells for partial grapheme matches

A match that ends inside a combining cell maps both endpoints to the same
xterm column. Color that cell instead of building an empty range.

* fix(terminal): rematch flood rows after empty-line stamps

A hot-path \r\n write stamped the following empty cursor row as current.
The next flood chunk reused that BufferLine with ERROR text, and quiet
catch-up skipped it. Fingerprint the stamped content so filled or
recycled identical rows are recolored.

* perf(terminal): avoid flood-path registerMarker after trim

Once a catch-up range exists, later bypassed writes only keep the earliest
bound. A disposed marker collapses to 0 without allocating a new one on
every saturated-scrollback chunk.

* fix(terminal): recolor the row retained by clear

xterm clear keeps the cursor row after we restore originals. Recolor that
surviving line so enabled rules still apply until the next write.

* perf(terminal): stamp no-match rows without cell snapshots

Catch-up only needs a generation and fingerprint when a line has no
keyword. Allocate typed-array originals when a cell is actually colored.

* perf(terminal): treat pinned-bottom recycle as output scroll

Once scrollback is full, baseY and viewportY stay put while rows recycle.
That was treated as a user scroll, so every flood write rematched the
visible area. Keep pinned-to-bottom updates off the rematch path.

* perf(terminal): keep quiet catch-up to a single viewport paint

Catch-up already refreshes visible slices. A trailing recolorVisible()
caused a second settle paint and tripped the atomic-repaint gate.

---------

Co-authored-by: netcatty-bot <308658023+netcatty-bot@users.noreply.github.com>
2026-08-13 21:26:16 +08:00

175 lines
6.8 KiB
JavaScript

"use strict";
/* global process, __dirname, console */
if (!process.versions.electron) {
const test = require("node:test");
test("inline keyword highlighting stays responsive", {
skip: "run with Electron so the real WebGL renderer is available",
}, () => {});
} else {
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const electron = require("electron");
const esbuild = require("esbuild");
const tempDirBridge = require("../electron/bridges/tempDirBridge.cjs");
const appRoot = path.resolve(__dirname, "..");
const showWindow = process.env.NETCATTY_TERMINAL_PERF_SHOW_WINDOW === "1";
const userData = fs.mkdtempSync(`${tempDirBridge.getTempFilePath("xterm-keyword-highlight-perf")}-`);
electron.app.setPath("userData", userData);
electron.app.on("window-all-closed", () => {});
let window = null;
const cleanup = (exitCode) => {
if (window && !window.isDestroyed()) window.destroy();
try {
fs.rmSync(userData, { recursive: true, force: true });
} catch (error) {
console.warn("Unable to remove xterm performance test data:", error);
} finally {
electron.app.exit(exitCode);
}
};
void electron.app.whenReady().then(async () => {
window = new electron.BrowserWindow({
show: showWindow,
width: 1000,
height: 640,
paintWhenInitiallyHidden: true,
webPreferences: {
backgroundThrottling: false,
contextIsolation: false,
nodeIntegration: true,
sandbox: false,
},
});
await window.loadURL(
"data:text/html;charset=utf-8," + encodeURIComponent(
"<!doctype html><style>html,body,#terminal{width:920px;height:560px;margin:0}</style><div id=terminal></div>",
),
);
const xtermPath = require.resolve("@xterm/xterm", { paths: [appRoot] });
const webglPath = require.resolve("@xterm/addon-webgl", { paths: [appRoot] });
const serializePath = require.resolve("@xterm/addon-serialize", { paths: [appRoot] });
const highlighterPath = path.join(appRoot, "components/terminal/keywordHighlight.ts");
const pressurePath = path.join(appRoot, "components/terminal/runtime/terminalOutputPressure.ts");
const highlighterBundle = esbuild.buildSync({
stdin: {
contents: [
`export * from ${JSON.stringify(highlighterPath)};`,
`export { noteTerminalOutputPressureData } from ${JSON.stringify(pressurePath)};`,
].join("\n"),
loader: "ts",
resolveDir: appRoot,
},
bundle: true,
format: "cjs",
platform: "browser",
target: "chrome142",
write: false,
}).outputFiles[0].text;
const result = await window.webContents.executeJavaScript(`(async () => {
const { Terminal } = require(${JSON.stringify(xtermPath)});
const { WebglAddon } = require(${JSON.stringify(webglPath)});
const { SerializeAddon } = require(${JSON.stringify(serializePath)});
const highlighterModule = { exports: {} };
((module, exports) => { ${highlighterBundle} })(highlighterModule, highlighterModule.exports);
const { KeywordHighlighter, noteTerminalOutputPressureData } = highlighterModule.exports;
const term = new Terminal({
allowProposedApi: true,
cols: 120,
cursorBlink: false,
rows: 40,
scrollback: 10000,
});
term.open(document.getElementById("terminal"));
let renderer = "dom";
try {
term.loadAddon(new WebglAddon());
renderer = "webgl";
} catch {}
const serializer = new SerializeAddon();
term.loadAddon(serializer);
const highlighter = new KeywordHighlighter(term);
const redRules = [{
id: "error",
label: "Error",
patterns: ["ERROR", "failed", "10\\\\.2\\\\.\\\\d+\\\\.\\\\d+"],
color: "#F87171",
enabled: true,
}];
const blueRules = redRules.map(rule => ({ ...rule, color: "#60A5FA" }));
highlighter.setRules(redRules, true);
const write = data => new Promise(resolve => term.write(data, resolve));
const waitPaint = () => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
let history = "";
for (let line = 0; line < 10000; line += 1) {
history += "2026-08-13 worker=" + (line % 32) + " ERROR failed from 10.2." + (line % 255) + "." + ((line * 7) % 255) + "\\r\\n";
}
const initialStart = performance.now();
noteTerminalOutputPressureData(term, history);
await write(history);
await waitPaint();
const initialWriteMs = performance.now() - initialStart;
await new Promise(resolve => setTimeout(resolve, 650));
await highlighter.whenSettled();
const rebuildsBeforeEnter = highlighter.rebuildCount;
const enterStart = performance.now();
const prompt = "\\r\\nplain prompt # ";
noteTerminalOutputPressureData(term, prompt);
await write(prompt);
await waitPaint();
const enterWriteMs = performance.now() - enterStart;
await new Promise(resolve => setTimeout(resolve, 650));
await highlighter.whenSettled();
const enterRebuildCount = highlighter.rebuildCount;
const rebuildStart = performance.now();
highlighter.setRules(blueRules, true);
await highlighter.whenSettled();
await waitPaint();
const rebuildMs = performance.now() - rebuildStart;
const serialized = serializer.serialize({ scrollback: 10000 });
const pristine = highlighter.serializeAddon.serialize({ scrollback: 10000 });
const state = {
renderer,
rawChars: history.length,
initialWriteMs,
rebuildsBeforeEnter,
enterWriteMs,
enterRebuildCount,
rebuildMs,
rebuildCount: highlighter.rebuildCount,
blueMatchCount: (serialized.match(/38;2;96;165;250m/g) || []).length,
pristineHasNetcattyColor: /38;2;(248;113;113|96;165;250)m/.test(pristine),
};
highlighter.dispose();
term.dispose();
return state;
})()`);
if (process.env.NETCATTY_TERMINAL_PERF_REQUIRE_WEBGL === "1") {
assert.equal(result.renderer, "webgl", JSON.stringify(result));
}
assert.equal(result.enterRebuildCount, result.rebuildsBeforeEnter, JSON.stringify(result));
assert.equal(result.rebuildCount, result.rebuildsBeforeEnter + 1, JSON.stringify(result));
assert.ok(result.blueMatchCount >= 10000, JSON.stringify(result));
assert.equal(result.pristineHasNetcattyColor, false, JSON.stringify(result));
assert.ok(result.enterWriteMs < 150, `Enter write regressed: ${JSON.stringify(result)}`);
assert.ok(result.rebuildMs < 1000, `10k-line rule rebuild regressed: ${JSON.stringify(result)}`);
process.stdout.write(`XTERM_KEYWORD_HIGHLIGHT_PERFORMANCE_OK ${JSON.stringify(result)}\n`);
cleanup(0);
}).catch((error) => {
console.error(error);
cleanup(1);
});
}