[Init] Initial commit - NetMesh terminal manager

components/terminal/runtime/terminalWriteAckDeferral.ts

@@ -0,0 +1,69 @@
+import type { Terminal as XTerm } from "@xterm/xterm";
+
+import { XTERM_WRITE_CALLBACK_BATCH_BYTES } from "./terminalFlowConstants";
+
+const DEFERRED_TERMINAL_WRITE_ACK_IDLE_FLUSH_MS = 16;
+
+/** Ingress bytes written to xterm but not yet reported to main-process IPC ACK. */
+const deferredIpcAckBytesByTerm = new WeakMap<XTerm, number>();
+const deferredIpcAckFlushTimersByTerm = new WeakMap<XTerm, ReturnType<typeof setTimeout>>();
+
+const cancelDeferredTerminalWriteAckFlush = (term: XTerm): void => {
+  const timer = deferredIpcAckFlushTimersByTerm.get(term);
+  if (timer === undefined) return;
+  clearTimeout(timer);
+  deferredIpcAckFlushTimersByTerm.delete(term);
+};
+
+export const getDeferredTerminalWriteAckBytes = (term: XTerm): number =>
+  deferredIpcAckBytesByTerm.get(term) ?? 0;
+
+export const accumulateDeferredTerminalWriteAck = (
+  term: XTerm,
+  bytes: number,
+): number => {
+  if (bytes <= 0) return getDeferredTerminalWriteAckBytes(term);
+  const next = getDeferredTerminalWriteAckBytes(term) + bytes;
+  deferredIpcAckBytesByTerm.set(term, next);
+  return next;
+};
+
+export const clearDeferredTerminalWriteAck = (term: XTerm): number => {
+  cancelDeferredTerminalWriteAckFlush(term);
+  const bytes = deferredIpcAckBytesByTerm.get(term) ?? 0;
+  deferredIpcAckBytesByTerm.delete(term);
+  return bytes;
+};
+
+export const scheduleDeferredTerminalWriteAckFlush = (
+  term: XTerm,
+  onFlush: (bytes: number) => void,
+  delayMs: number = DEFERRED_TERMINAL_WRITE_ACK_IDLE_FLUSH_MS,
+): void => {
+  if (getDeferredTerminalWriteAckBytes(term) <= 0) return;
+  if (deferredIpcAckFlushTimersByTerm.has(term)) return;
+
+  const timer = setTimeout(() => {
+    deferredIpcAckFlushTimersByTerm.delete(term);
+    const bytes = clearDeferredTerminalWriteAck(term);
+    if (bytes > 0) {
+      onFlush(bytes);
+    }
+  }, Math.max(0, delayMs));
+  deferredIpcAckFlushTimersByTerm.set(term, timer);
+};
+
+export const shouldDeferTerminalWriteCallback = (
+  displayBytes: number,
+  deferredIngressBytes: number,
+  ingressBytes: number,
+  fastPathMaxBytes: number,
+  batchBytes: number = XTERM_WRITE_CALLBACK_BATCH_BYTES,
+): boolean =>
+  displayBytes <= fastPathMaxBytes
+  && deferredIngressBytes + ingressBytes < batchBytes;
+
+export const resetDeferredTerminalWriteAck = (term: XTerm): void => {
+  cancelDeferredTerminalWriteAckFlush(term);
+  deferredIpcAckBytesByTerm.delete(term);
+};