@simon_he/vue-tui 1.0.2 → 1.1.1

package/dist/{wheel-scroll-vBRaQ7p-.js → rect-Ng-3eKzF.js}

@@ -1,5 +1,5 @@
-import { charCellWidth, segmentedGraphemes } from "./hyperlink-Bn02UXJb.js";
-import { computed, inject, onBeforeUnmount, provide, ref, vShow, watchEffect } from "vue";
+import { charCellWidth, segmentedGraphemes } from "./width-GqllnV8C.js";
+import { computed, inject, onBeforeUnmount, provide, readonly, ref, vShow, watchEffect } from "vue";
 
 //#region src/vue/injection-key.ts
 const VUE_TUI_INJECTION_PROTOCOL = "v1";
@@ -7,6 +7,120 @@ function injectionKey(name) {
 	return Symbol.for(`@simon_he/vue-tui:${VUE_TUI_INJECTION_PROTOCOL}:${name}`);
 }
 
+//#endregion
+//#region src/renderer/terminal-graphics-trace.ts
+const metrics = {
+	requests: 0,
+	skippedHidden: 0,
+	skippedScrolling: 0,
+	cacheHits: 0,
+	cacheMisses: 0,
+	cacheStores: 0,
+	rendererRuns: 0,
+	rendererAborts: 0,
+	rendererErrors: 0,
+	queued: 0,
+	queueWaits: 0,
+	queueDeduped: 0,
+	cleared: 0,
+	bytesQueued: 0,
+	totalRendererMs: 0,
+	totalValidateMs: 0,
+	totalQueueWaitMs: 0,
+	maxQueueWaitMs: 0,
+	maxActiveRenders: 0,
+	maxWaitingRenders: 0,
+	maxCacheEntries: 0,
+	maxCacheBytes: 0,
+	scrollStarts: 0,
+	scrollMarks: 0,
+	scrollIdles: 0,
+	totalScrollMs: 0,
+	maxScrollMs: 0
+};
+const subscribers = new Set();
+function nowTerminalGraphicTraceTime() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function recordTerminalGraphicTrace(event) {
+	const normalized = {
+		...event,
+		timestamp: event.timestamp ?? nowTerminalGraphicTraceTime()
+	};
+	switch (normalized.type) {
+		case "request":
+			metrics.requests++;
+			break;
+		case "skip-hidden":
+			metrics.skippedHidden++;
+			break;
+		case "skip-scrolling":
+			metrics.skippedScrolling++;
+			break;
+		case "cache-hit":
+			metrics.cacheHits++;
+			break;
+		case "cache-miss":
+			metrics.cacheMisses++;
+			break;
+		case "cache-store":
+			metrics.cacheStores++;
+			break;
+		case "renderer-start":
+			metrics.rendererRuns++;
+			break;
+		case "renderer-end":
+			metrics.totalRendererMs += normalized.durationMs ?? 0;
+			break;
+		case "renderer-abort":
+			metrics.rendererAborts++;
+			break;
+		case "renderer-error":
+			metrics.rendererErrors++;
+			break;
+		case "validate-end":
+			metrics.totalValidateMs += normalized.durationMs ?? 0;
+			break;
+		case "queue":
+			metrics.queued++;
+			metrics.bytesQueued += normalized.bytes ?? 0;
+			break;
+		case "queue-wait": {
+			const durationMs = normalized.durationMs ?? 0;
+			metrics.queueWaits++;
+			metrics.totalQueueWaitMs += durationMs;
+			metrics.maxQueueWaitMs = Math.max(metrics.maxQueueWaitMs, durationMs);
+			break;
+		}
+		case "queue-dedupe":
+			metrics.queueDeduped++;
+			break;
+		case "clear":
+			metrics.cleared++;
+			break;
+		case "scroll-start":
+			metrics.scrollStarts++;
+			break;
+		case "scroll-mark":
+			metrics.scrollMarks++;
+			break;
+		case "scroll-idle": {
+			const durationMs = normalized.durationMs ?? 0;
+			metrics.scrollIdles++;
+			metrics.totalScrollMs += durationMs;
+			metrics.maxScrollMs = Math.max(metrics.maxScrollMs, durationMs);
+			break;
+		}
+	}
+	if (normalized.active != null && Number.isFinite(normalized.active)) metrics.maxActiveRenders = Math.max(metrics.maxActiveRenders, Math.max(0, normalized.active));
+	if (normalized.waiting != null && Number.isFinite(normalized.waiting)) metrics.maxWaitingRenders = Math.max(metrics.maxWaitingRenders, Math.max(0, normalized.waiting));
+	if (normalized.cacheEntries != null && Number.isFinite(normalized.cacheEntries)) metrics.maxCacheEntries = Math.max(metrics.maxCacheEntries, Math.max(0, normalized.cacheEntries));
+	if (normalized.cacheBytes != null && Number.isFinite(normalized.cacheBytes)) metrics.maxCacheBytes = Math.max(metrics.maxCacheBytes, Math.max(0, normalized.cacheBytes));
+	for (const subscriber of subscribers) try {
+		subscriber(normalized);
+	} catch {}
+}
+
 //#endregion
 //#region src/vue/context.ts
 const TerminalContextKey = injectionKey("TerminalContext");
@@ -17,7 +131,95 @@ const RenderPlaneContextKey = injectionKey("RenderPlane");
 const ImeAnchorContextKey = injectionKey("ImeAnchor");
 const TInputPluginsContextKey = injectionKey("TInputPlugins");
 const TPathPickerProviderContextKey = injectionKey("TPathPickerProvider");
+const TerminalGraphicsActivityKey = injectionKey("TerminalGraphicsActivity");
 const DialogContextKey = injectionKey("DialogContext");
+function createTerminalGraphicsActivity(options = {}) {
+	let scrollIdleMs = normalizeTerminalGraphicsScrollIdleMs(options.scrollIdleMs);
+	const traceId = options.traceId ?? "TerminalGraphicsActivity";
+	const scrolling = ref(false);
+	const version = ref(0);
+	let timer = null;
+	let scrollStartedAt = 0;
+	function bump() {
+		version.value++;
+	}
+	function clearTimer() {
+		if (!timer) return;
+		clearTimeout(timer);
+		timer = null;
+	}
+	function traceScroll(type, durationMs) {
+		if (options.trace !== true) return;
+		recordTerminalGraphicTrace({
+			type,
+			id: traceId,
+			key: traceId,
+			durationMs
+		});
+	}
+	function finishScroll() {
+		if (!scrolling.value) return;
+		const endedAt = nowTerminalGraphicTraceTime();
+		const durationMs = scrollStartedAt > 0 ? endedAt - scrollStartedAt : void 0;
+		scrolling.value = false;
+		scrollStartedAt = 0;
+		traceScroll("scroll-idle", durationMs);
+		bump();
+	}
+	function markScroll() {
+		const started = !scrolling.value;
+		if (started) {
+			scrolling.value = true;
+			scrollStartedAt = nowTerminalGraphicTraceTime();
+			traceScroll("scroll-start");
+			bump();
+		} else traceScroll("scroll-mark");
+		clearTimer();
+		timer = setTimeout(() => {
+			timer = null;
+			finishScroll();
+		}, scrollIdleMs);
+	}
+	function setScrollIdleMs(value) {
+		scrollIdleMs = normalizeTerminalGraphicsScrollIdleMs(value);
+		if (!scrolling.value) return;
+		clearTimer();
+		timer = setTimeout(() => {
+			timer = null;
+			finishScroll();
+		}, scrollIdleMs);
+	}
+	function dispose() {
+		clearTimer();
+		finishScroll();
+	}
+	return {
+		scrolling: readonly(scrolling),
+		version: readonly(version),
+		markScroll,
+		setScrollIdleMs,
+		dispose
+	};
+}
+function createCombinedTerminalGraphicsActivity(parent, own) {
+	if (!parent) return own;
+	return {
+		scrolling: computed(() => parent.scrolling.value || own.scrolling.value),
+		version: computed(() => parent.version.value + own.version.value),
+		markScroll: own.markScroll,
+		setScrollIdleMs: own.setScrollIdleMs,
+		dispose: own.dispose
+	};
+}
+function positiveFiniteInt(value, fallback) {
+	const n = Number(value);
+	if (!Number.isFinite(n)) return fallback;
+	const int = Math.floor(n);
+	return int > 0 ? int : fallback;
+}
+function normalizeTerminalGraphicsScrollIdleMs(value) {
+	return Math.max(16, positiveFiniteInt(value, 96));
+}
 
 //#endregion
 //#region src/vue/render/context.ts
@@ -374,8 +576,10 @@ function wrapByCells(text, width, provider = currentTextWidthProvider()) {
 	const useCache = canUseDefaultTextCache(provider);
 	const bucket = useCache ? getWrapBucket(width) : null;
 	if (text && hasAsciiFastPath(provider) && isAscii(text)) {
-		const cached$1 = bucket?.get(text);
-		if (cached$1) return cached$1;
+		if (bucket) {
+			const cached = bucket.get(text);
+			if (cached) return cached;
+		}
 		const out$1 = [];
 		for (const rawLine of text.replace(/\r/g, "").split("\n")) {
 			if (rawLine.length === 0) {
@@ -390,8 +594,10 @@ function wrapByCells(text, width, provider = currentTextWidthProvider()) {
 		}
 		return out$1;
 	}
-	const cached = bucket?.get(text);
-	if (cached) return cached;
+	if (bucket) {
+		const cached = bucket.get(text);
+		if (cached) return cached;
+	}
 	const out = [];
 	for (const rawLine of text.replace(/\r/g, "").split("\n")) {
 		if (rawLine.length === 0) {
@@ -512,47 +718,82 @@ function requestBatchedInvalidate(scheduler, plane, priority) {
 		});
 	});
 }
+function sameRenderRect(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function sameDeps(a, b) {
+	if (Object.is(a, b)) return true;
+	if (!Array.isArray(a) || !Array.isArray(b)) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+	return true;
+}
 function useRenderNode(getOptions) {
 	const { scheduler, render, widthProvider } = useTerminal();
 	const parentStack = useRenderStack();
 	const plane = inject(RenderPlaneContextKey, ref("default"));
 	const id = ref(null);
 	const lastPlane = ref(plane.value);
+	let lastStack = null;
+	let lastZIndex = 0;
+	let lastHasRect = false;
+	let lastRect = null;
+	let lastDeps;
+	let lastHasDeps = false;
 	const options = computed(() => withTextWidthProvider(widthProvider, getOptions));
 	const stop = watchEffect(() => {
 		const opt = options.value;
 		opt.deps;
 		const stack = opt.stack ?? parentStack.value;
 		const nextPlane = plane.value;
+		const hasRect = Object.prototype.hasOwnProperty.call(opt, "rect");
+		const nextRect = hasRect ? opt.rect ?? null : null;
+		const nextZIndex = opt.zIndex ?? 0;
+		const hasDeps = Object.prototype.hasOwnProperty.call(opt, "deps");
 		if (!stack) return;
 		if (!id.value) {
 			const node = render.register({
 				stack,
-				zIndex: opt.zIndex,
-				rect: opt.rect,
+				zIndex: nextZIndex,
+				rect: hasRect ? nextRect : void 0,
 				plane: nextPlane,
 				paint: opt.paint
 			});
 			id.value = node.id;
 			lastPlane.value = nextPlane;
+			lastStack = stack;
+			lastZIndex = nextZIndex;
+			lastHasRect = hasRect;
+			lastRect = nextRect;
+			lastHasDeps = hasDeps;
+			lastDeps = opt.deps;
 			requestBatchedInvalidate(scheduler, nextPlane, opt.priority ?? "normal");
 			return;
 		}
 		const prevPlane = lastPlane.value;
+		if (hasDeps && lastHasDeps && !opt.dirtyRowsHint?.length && lastStack === stack && lastZIndex === nextZIndex && prevPlane === nextPlane && lastHasRect === hasRect && (!hasRect || sameRenderRect(lastRect, nextRect)) && sameDeps(lastDeps, opt.deps)) return;
 		const updatePayload = {
 			stack,
-			zIndex: opt.zIndex ?? 0,
+			zIndex: nextZIndex,
 			dirtyRowsHint: opt.dirtyRowsHint,
 			plane: nextPlane,
 			paint: opt.paint
 		};
-		if (Object.prototype.hasOwnProperty.call(opt, "rect")) updatePayload.rect = opt.rect ?? null;
+		if (hasRect) updatePayload.rect = nextRect;
 		render.update(id.value, updatePayload);
 		lastPlane.value = nextPlane;
+		lastStack = stack;
+		lastZIndex = nextZIndex;
+		lastHasRect = hasRect;
+		lastRect = nextRect;
+		lastHasDeps = hasDeps;
+		lastDeps = opt.deps;
 		const priority = opt.priority ?? "normal";
 		requestBatchedInvalidate(scheduler, prevPlane, priority);
 		if (prevPlane !== nextPlane) requestBatchedInvalidate(scheduler, nextPlane, priority);
-	});
+	}, { flush: "sync" });
 	onBeforeUnmount(() => {
 		stop();
 		if (id.value) {
@@ -716,109 +957,4 @@ function normalizeCellRect(rect) {
 }
 
 //#endregion
-//#region src/vue/utils/wheel-scroll.ts
-const LINE_UNIT_THRESHOLD = 3;
-const PIXELS_PER_LINE = 16;
-const ACCEL_WINDOW_MS = 120;
-const MAX_ACCEL = 26;
-const EDGE_BOUNCE_MS = 120;
-function clamp(n, min, max) {
-	return Math.max(min, Math.min(max, n));
-}
-function isLineUnitDelta(deltaY, mode = "auto") {
-	if (mode === "line") return true;
-	if (mode === "pixel") return false;
-	const abs = Math.abs(deltaY);
-	return abs > 0 && abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY);
-}
-function normalizeDelta(deltaY, mode = "auto") {
-	if (mode === "line") return deltaY;
-	if (mode === "pixel") return deltaY / PIXELS_PER_LINE;
-	const abs = Math.abs(deltaY);
-	if (abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY)) return deltaY;
-	return deltaY / PIXELS_PER_LINE;
-}
-function accelFactor(now, lastAt, maxAccel = MAX_ACCEL) {
-	const dt = now - lastAt;
-	if (!Number.isFinite(dt) || dt <= 0 || dt > ACCEL_WINDOW_MS) return 1;
-	const t = 1 - dt / ACCEL_WINDOW_MS;
-	return 1 + t * (maxAccel - 1);
-}
-function createWheelScrollState() {
-	return {
-		accumulator: 0,
-		lastAt: 0,
-		lastEdgeDir: 0,
-		lastEdgeAt: 0
-	};
-}
-function resetWheelScrollState(state) {
-	state.accumulator = 0;
-	state.lastAt = 0;
-	state.lastEdgeDir = 0;
-	state.lastEdgeAt = 0;
-}
-function applyWheelScroll(state, deltaY, scrollTop, maxTop, now = Date.now(), deltaMode = "auto", options = {}) {
-	if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
-		if (maxTop <= 0) {
-			state.accumulator = 0;
-			state.lastEdgeDir = 0;
-			state.lastEdgeAt = 0;
-		}
-		return {
-			nextTop: scrollTop,
-			dir: 0,
-			lines: 0
-		};
-	}
-	const lineUnits = isLineUnitDelta(deltaY, deltaMode);
-	const normalizedDelta = normalizeDelta(deltaY, deltaMode);
-	const accel = options.disableAcceleration ? 1 : lineUnits ? 1 : state.lastAt ? accelFactor(now, state.lastAt) : 1;
-	state.lastAt = now;
-	state.accumulator += normalizedDelta * accel;
-	const lines = Math.trunc(state.accumulator);
-	if (lines === 0) return {
-		nextTop: scrollTop,
-		dir: 0,
-		lines: 0
-	};
-	state.accumulator -= lines;
-	const dir = lines > 0 ? 1 : -1;
-	const atTop = scrollTop <= 0;
-	const atBottom = scrollTop >= maxTop;
-	if (dir < 0 && atTop || dir > 0 && atBottom) {
-		state.lastEdgeDir = dir;
-		state.lastEdgeAt = now;
-		state.accumulator = 0;
-		return {
-			nextTop: scrollTop,
-			dir: 0,
-			lines: 0
-		};
-	}
-	if (state.lastEdgeDir !== 0 && now - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) return {
-		nextTop: scrollTop,
-		dir: 0,
-		lines: 0
-	};
-	const unclamped = scrollTop + lines;
-	const nextTop = clamp(unclamped, 0, maxTop);
-	if (nextTop === scrollTop) {
-		state.accumulator = 0;
-		return {
-			nextTop: scrollTop,
-			dir: 0,
-			lines: 0
-		};
-	}
-	if (nextTop !== unclamped) state.accumulator = 0;
-	state.lastEdgeDir = 0;
-	return {
-		nextTop,
-		dir: nextTop > scrollTop ? 1 : -1,
-		lines: nextTop - scrollTop
-	};
-}
-
-//#endregion
-export { DialogContextKey, EventZIndexContextKey, ImeAnchorContextKey, LayoutContextKey, RenderPlaneContextKey, RenderStackKey, TInputPluginsContextKey, TPathPickerProviderContextKey, TerminalContextKey, VisibilityContextKey, applyWheelScroll, clearTextCaches, createWheelScrollState, currentTextWidthProvider, forEachTextCellSegment, formatInlineCellLine, graphemeRangeAt, hasTextWidthAsciiFastPath, injectionKey, intersectRect, normalizeCellRect, padEndByCells as padEndByCells$1, repeatChar, resetWheelScrollState, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, textCellWidth as textCellWidth$1, translateRect, useLayout, useRenderNode, useRenderStack, useTerminal, useTerminalNode, useVisibility, withTextRenderPass, withTextWidthProvider, wrapByCells };
+export { DialogContextKey, EventZIndexContextKey, ImeAnchorContextKey, LayoutContextKey, RenderPlaneContextKey, RenderStackKey, TInputPluginsContextKey, TPathPickerProviderContextKey, TerminalContextKey, TerminalGraphicsActivityKey, VisibilityContextKey, clearTextCaches, createCombinedTerminalGraphicsActivity, createTerminalGraphicsActivity, currentTextWidthProvider, forEachTextCellSegment, formatInlineCellLine, graphemeRangeAt, hasTextWidthAsciiFastPath, injectionKey, intersectRect, normalizeCellRect, nowTerminalGraphicTraceTime, padEndByCells as padEndByCells$1, recordTerminalGraphicTrace, repeatChar, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, textCellWidth as textCellWidth$1, translateRect, useLayout, useRenderNode, useRenderStack, useTerminal, useTerminalNode, useVisibility, withTextRenderPass, withTextWidthProvider, wrapByCells };

package/dist/renderer/cli/stdout-metrics.d.ts

@@ -7,6 +7,10 @@ export interface StdoutRendererMetrics {
     writeMode: StdoutRendererWriteMode;
     fps: number;
     bytesPerSec: number;
+    terminalGraphicsDraws: number;
+    terminalGraphicsClears: number;
+    terminalGraphicsBytes: number;
+    terminalGraphicsActive: number;
 }
 export declare function getStdoutRendererMetrics(): StdoutRendererMetrics;
 export declare function recordStdoutFrame(info: Readonly<{
@@ -16,3 +20,9 @@ export declare function recordStdoutFrame(info: Readonly<{
     writeEmaMs: number;
     writeMode: StdoutRendererWriteMode;
 }>): void;
+export declare function recordStdoutTerminalGraphics(info: Readonly<{
+    draws?: number;
+    clears?: number;
+    bytes?: number;
+    active: number;
+}>): void;

package/dist/renderer/cli/stdout-renderer.d.ts

@@ -1,5 +1,6 @@
 import type { Terminal } from "../../core/types.js";
 import type { RendererCapabilities } from "../capabilities.js";
+import type { TerminalGraphicsCapabilities, TerminalGraphicsDetectionInput } from "../terminal-graphics.js";
 import type { ThemePalette } from "../../core/ansi-palette.js";
 export type CliOutput = Readonly<{
     write: (chunk: string) => unknown;
@@ -12,6 +13,7 @@ export type CliOutput = Readonly<{
 }>;
 export type StdoutRenderer = Readonly<{
     capabilities: RendererCapabilities;
+    graphicsCapabilities?: TerminalGraphicsCapabilities;
     render: () => void;
     dispose: () => void;
     /** Move terminal cursor to specified cell position for IME input */
@@ -83,6 +85,7 @@ export type StdoutRendererOptions = Readonly<{
     } | null;
     /** Use DEC 2026 synchronized output mode. */
     useSyncOutput?: boolean;
+    terminalGraphics?: false | TerminalGraphicsCapabilities | TerminalGraphicsDetectionInput;
     allowFileUrls?: boolean;
     profileFileWriter?: {
         appendFileSync?: (path: string, data: string) => void;

package/dist/renderer/terminal-graphic-render-queue.d.ts

@@ -0,0 +1,50 @@
+export type TerminalGraphicRenderQueueMetric = Readonly<{
+    type: "cache-hit";
+    key: string;
+}> | Readonly<{
+    type: "cache-store";
+    key: string;
+    bytes: number;
+}> | Readonly<{
+    type: "evict";
+    key: string;
+    bytes: number;
+}> | Readonly<{
+    type: "queue-wait";
+    key: string;
+    waitMs: number;
+}> | Readonly<{
+    type: "render-abort";
+    key: string;
+}>;
+export type TerminalGraphicRenderQueueOptions = Readonly<{
+    maxConcurrency?: number;
+    maxEntries?: number;
+    maxBytes?: number;
+    ttlMs?: number;
+    /**
+     * Share in-flight renders for equal cache keys.
+     *
+     * Keep this disabled when render work observes a caller AbortSignal. This is
+     * the safe default for viewport-bound graphics in virtual scrollers: an
+     * offscreen row may abort while another still-visible row with the same cache
+     * key is still valid. Duplicate queued renders are still cheap because each
+     * task re-checks the cache after acquiring a concurrency slot, so a render
+     * completed by an earlier row is reused instead of rendering again.
+     */
+    dedupeInflight?: boolean;
+    onMetric?: (metric: TerminalGraphicRenderQueueMetric) => void;
+}>;
+export type TerminalGraphicRenderQueue = Readonly<{
+    cached: <T>(key: string, signal: AbortSignal | undefined, render: () => Promise<T>, estimateBytes?: (value: T) => number, options?: Readonly<{
+        dedupeInflight?: boolean;
+    }>) => Promise<T>;
+    clear: () => void;
+    stats: () => Readonly<{
+        active: number;
+        waiting: number;
+        cacheEntries: number;
+        cacheBytes: number;
+    }>;
+}>;
+export declare function createTerminalGraphicRenderQueue(options?: TerminalGraphicRenderQueueOptions): TerminalGraphicRenderQueue;

package/dist/renderer/terminal-graphics-trace.d.ts

@@ -0,0 +1,53 @@
+import type { TerminalGraphicsProtocol } from "./terminal-graphics.js";
+export type TerminalGraphicTraceEventType = "request" | "skip-hidden" | "skip-scrolling" | "cache-hit" | "cache-miss" | "cache-store" | "renderer-start" | "renderer-end" | "renderer-abort" | "renderer-error" | "validate-end" | "queue" | "queue-depth" | "queue-wait" | "queue-dedupe" | "clear" | "scroll-start" | "scroll-mark" | "scroll-idle";
+export type TerminalGraphicTraceEvent = Readonly<{
+    type: TerminalGraphicTraceEventType;
+    id: string;
+    key?: string;
+    protocol?: TerminalGraphicsProtocol;
+    timestamp: number;
+    durationMs?: number;
+    bytes?: number;
+    reason?: string;
+    error?: string;
+    active?: number;
+    waiting?: number;
+    cacheEntries?: number;
+    cacheBytes?: number;
+}>;
+export type TerminalGraphicTraceMetrics = Readonly<{
+    requests: number;
+    skippedHidden: number;
+    skippedScrolling: number;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheStores: number;
+    rendererRuns: number;
+    rendererAborts: number;
+    rendererErrors: number;
+    queued: number;
+    queueWaits: number;
+    queueDeduped: number;
+    cleared: number;
+    bytesQueued: number;
+    totalRendererMs: number;
+    totalValidateMs: number;
+    totalQueueWaitMs: number;
+    maxQueueWaitMs: number;
+    maxActiveRenders: number;
+    maxWaitingRenders: number;
+    maxCacheEntries: number;
+    maxCacheBytes: number;
+    scrollStarts: number;
+    scrollMarks: number;
+    scrollIdles: number;
+    totalScrollMs: number;
+    maxScrollMs: number;
+}>;
+export declare function nowTerminalGraphicTraceTime(): number;
+export declare function recordTerminalGraphicTrace(event: Omit<TerminalGraphicTraceEvent, "timestamp"> & {
+    timestamp?: number;
+}): void;
+export declare function getTerminalGraphicTraceMetrics(): TerminalGraphicTraceMetrics;
+export declare function resetTerminalGraphicTraceMetrics(): void;
+export declare function subscribeTerminalGraphicTrace(listener: (event: TerminalGraphicTraceEvent) => void): () => void;