@simon_he/vue-tui 1.1.1 → 1.1.2

package/dist/experimental.cjs

@@ -17,6 +17,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0
 // src/experimental.ts
 var experimental_exports = {};
 __export(experimental_exports, {
+  T3DViewport: () => T3DViewport,
   TCandlestickChart: () => TCandlestickChart,
   TContributionGraph: () => TContributionGraph,
   TLineChart: () => TLineChart,
@@ -31,6 +32,7 @@ __export(experimental_exports, {
   TLogVirtualSearchResults: () => TLogVirtualSearchResults,
   TPieChart: () => TPieChart,
   TTranscriptView: () => TTranscriptView,
+  TVideo: () => TVideo,
   TVirtualList: () => TVirtualList,
   captureTLogViewSessionState: () => captureTLogViewSessionState,
   createAppendOnlyLogStore: () => createAppendOnlyLogStore,
@@ -780,6 +782,14 @@ function hasInlineAsciiControl(text) {
   }
   return !1;
 }
+function hasTextBlockAsciiControl(text) {
+  for (let i = 0; i < text.length; i++) {
+    let code = text.charCodeAt(i);
+    if (code === 9 || code <= 31 && code !== 10 || code === 127)
+      return !0;
+  }
+  return !1;
+}
 function forEachGrapheme(text, cb) {
   if (!text)
     return;
@@ -842,6 +852,25 @@ function sanitizeInlineText(text) {
   }
   return out.join("");
 }
+function sanitizeTextBlock(text) {
+  if (!text)
+    return "";
+  if (!UNSAFE_FORMAT_CONTROL_RE.test(text) && !hasTextBlockAsciiControl(text))
+    return text;
+  let out = [];
+  out.length = 0;
+  for (let ch of text) {
+    let cp = ch.codePointAt(0);
+    if (cp !== 13) {
+      if (cp === 9) {
+        out.push(" ");
+        continue;
+      }
+      cp <= 31 && cp !== 10 || cp === 127 || isUnsafeFormatControl(cp) || out.push(ch);
+    }
+  }
+  return out.join("");
+}
 function textCellWidth(text, provider = currentTextWidthProvider()) {
   if (!text)
     return 0;
@@ -1393,8 +1422,8 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now = Date.now(), de
 }
 
 // src/vue/utils/row-scroll.ts
-function exposedRowsForDelta(y0, h15, delta) {
-  let startY = Math.floor(y0), height = Math.max(0, Math.floor(h15)), lines = Math.trunc(delta), rows = [];
+function exposedRowsForDelta(y0, h19, delta) {
+  let startY = Math.floor(y0), height = Math.max(0, Math.floor(h19)), lines = Math.trunc(delta), rows = [];
   if (height <= 0 || lines === 0 || Math.abs(lines) >= height)
     return rows;
   if (lines > 0)
@@ -1406,17 +1435,17 @@ function exposedRowsForDelta(y0, h15, delta) {
   return rows;
 }
 function prepareUnsafeFullRowScroll(options) {
-  let r = options.rect, x = Math.floor(r.x), y = Math.floor(r.y), w = Math.floor(r.w), h15 = Math.floor(r.h), rows = Math.floor(options.terminalSize.rows), cols = Math.floor(options.terminalSize.cols), delta = Math.trunc(options.delta);
-  if (delta === 0 || h15 <= 0 || cols <= 0 || rows <= 0)
+  let r = options.rect, x = Math.floor(r.x), y = Math.floor(r.y), w = Math.floor(r.w), h19 = Math.floor(r.h), rows = Math.floor(options.terminalSize.rows), cols = Math.floor(options.terminalSize.cols), delta = Math.trunc(options.delta);
+  if (delta === 0 || h19 <= 0 || cols <= 0 || rows <= 0)
     return null;
-  let ownsFullRows = x === 0 && w >= cols, withinTerminalRows = y >= 0 && y + h15 <= rows;
-  if (!((options.strategy ?? "auto") === "auto" && options.rowScrollMode === "unsafe-full-row" && options.rendererCapabilities.scrollOperations && ownsFullRows && withinTerminalRows && !options.isClipped && Math.abs(delta) < h15 && !options.hasPendingDirtyRows))
+  let ownsFullRows = x === 0 && w >= cols, withinTerminalRows = y >= 0 && y + h19 <= rows;
+  if (!((options.strategy ?? "auto") === "auto" && options.rowScrollMode === "unsafe-full-row" && options.rendererCapabilities.scrollOperations && ownsFullRows && withinTerminalRows && !options.isClipped && Math.abs(delta) < h19 && !options.hasPendingDirtyRows))
     return null;
-  let exposedRows = exposedRowsForDelta(y, h15, delta);
+  let exposedRows = exposedRowsForDelta(y, h19, delta);
   return exposedRows.length ? {
     exposedRows,
     apply: () => {
-      options.render.unsafeScrollPlaneRows(options.plane, y, y + h15, delta);
+      options.render.unsafeScrollPlaneRows(options.plane, y, y + h19, delta);
     }
   } : null;
 }
@@ -1824,115 +1853,2872 @@ var virtualListInstanceSeq = 0, TVirtualList = (0, import_vue9.defineComponent)(
         },
         keydown: onKeydown
       }
-    }));
-    (0, import_vue9.watchEffect)(() => {
-      if (!props.autoFocus || !visible.value)
+    }));
+    (0, import_vue9.watchEffect)(() => {
+      if (!props.autoFocus || !visible.value)
+        return;
+      let manager = events.value, nodeId = eventNode.id.value;
+      !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
+    }), (0, import_vue9.watch)(
+      () => visible.value,
+      (nextVisible) => {
+        nextVisible || cancelWheelScrollFrame();
+      }
+    ), (0, import_vue9.onBeforeUnmount)(() => {
+      alive = !1, pendingWheelTop = null, resetWheelScrollState(wheelState), wheelMailbox.dispose(), terminalGraphicsActivity.dispose();
+    });
+    function viewportRows() {
+      let r = normalizedRect(), rows = [];
+      for (let y = r.y; y < r.y + r.h; y++)
+        rows.push(y);
+      return rows;
+    }
+    function unionDirtyRows(nextRows) {
+      if (!dirtyRowsHint?.length)
+        return nextRows.slice().sort((a, b) => a - b);
+      let rows = new Set(dirtyRowsHint);
+      for (let y of nextRows)
+        rows.add(y);
+      return Array.from(rows).sort((a, b) => a - b);
+    }
+    function markRowsDirty(nextRows) {
+      return hasPaintableViewport() ? (dirtyRowsHint = unionDirtyRows(nextRows), renderNodeId && render.markDirtyRows(renderNodeId, dirtyRowsHint) ? !0 : (dirtyRowsHint = void 0, !1)) : !1;
+    }
+    function markViewportDirty() {
+      return markRowsDirty(viewportRows());
+    }
+    function applyScrollTop(nextTop, options) {
+      let controlled = isScrollControlled(), r = normalizedRect(), full = normalizedFullRect();
+      if (r.h <= 0 || full.h <= 0)
+        return { changed: !1, dirty: !1, top: scrollTop.value, controlled };
+      let clampedTop = clampScrollTop(nextTop), delta = clampedTop - scrollTop.value;
+      if (!delta)
+        return { changed: !1, dirty: !1, top: scrollTop.value, controlled };
+      if (controlled)
+        return terminalGraphicsActivity.markScroll(), (options?.emitUpdate ?? !0) && emit("update:scrollTop", clampedTop), options?.emitScroll && emit("scroll", clampedTop), { changed: !0, dirty: !1, top: clampedTop, controlled };
+      terminalGraphicsActivity.markScroll(), scrollTop.value = clampedTop, options?.emitUpdate && emit("update:scrollTop", clampedTop);
+      let canUseTerminalRowScroll = rendererCapabilities.value.scrollOperations && rendererCapabilities.value.domRows !== !0, scrollPlan = prepareUnsafeFullRowScroll({
+        render,
+        plane: plane.value,
+        rect: r,
+        terminalSize: terminal.size(),
+        delta,
+        rowScrollMode: props.rowScrollMode,
+        rendererCapabilities: {
+          scrollOperations: canUseTerminalRowScroll
+        },
+        isClipped: isClipped(),
+        hasPendingDirtyRows: !!dirtyRowsHint?.length,
+        strategy: options?.strategy ?? "viewport-repaint"
+      }), dirty = !1;
+      return scrollPlan && markRowsDirty(scrollPlan.exposedRows) ? (scrollPlan.apply(), dirty = !0) : dirty = markViewportDirty(), options?.emitScroll && emit("scroll", clampedTop), options?.priority && dirty && invalidateSelf(options.priority, options.reason ?? "scroll"), { changed: !0, dirty, top: clampedTop, controlled };
+    }
+    let renderNode = useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? normalizedRect() : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        absRect.value,
+        fullRect.value,
+        itemCount.value,
+        props.itemVersion,
+        props.getItem,
+        props.renderItem,
+        active.value,
+        focused.value,
+        props.style,
+        props.activeStyle,
+        defaultStyle.value
+      ],
+      paint: (dirtyRows) => {
+        if (dirtyRowsHint = void 0, !visible.value)
+          return;
+        let r = normalizedRect(), full = normalizedFullRect();
+        if (r.w <= 0 || r.h <= 0)
+          return;
+        let base = props.style ?? defaultStyle.value, activeStyle = props.activeStyle ?? defaultActiveStyle(base), top = visibleWindow.value.top, { x: clipX, y: clipY } = clipOffsets(), paintRow = (y) => {
+          if (y < r.y || y >= r.y + r.h)
+            return;
+          let idx = top + clipY + (y - r.y), fullLine = formatInlineCellLine(
+            idx >= 0 && idx < itemCount.value ? itemText(idx) : "",
+            full.w
+          ), line = padEndByCells(sliceByCellsRange(fullLine, clipX, clipX + r.w), r.w), style = idx >= 0 && idx < itemCount.value && idx === active.value ? activeStyle : base;
+          terminal.write(line, { x: r.x, y, style });
+        }, rows = dirtyRows;
+        if (rows?.length) {
+          for (let y of rows)
+            paintRow(y);
+          return;
+        }
+        for (let y = r.y; y < r.y + r.h; y++)
+          paintRow(y);
+      }
+    }));
+    return (0, import_vue9.watchEffect)(() => {
+      renderNodeId = renderNode.id.value;
+    }), () => (0, import_vue9.h)("span", rootProps);
+  }
+});
+
+// src/vue/components/T3DViewport.ts
+var import_vue14 = require("vue");
+
+// src/vue/components/TVideo.ts
+var import_vue13 = require("vue");
+
+// src/core/ansi/sgr.ts
+var ESC = "\x1B";
+function ansi16ToColorName(code) {
+  switch (code) {
+    case 30:
+      return "black";
+    case 31:
+      return "red";
+    case 32:
+      return "green";
+    case 33:
+      return "yellow";
+    case 34:
+      return "blue";
+    case 35:
+      return "magenta";
+    case 36:
+      return "cyan";
+    case 37:
+      return "white";
+    case 90:
+      return "blackBright";
+    case 91:
+      return "redBright";
+    case 92:
+      return "greenBright";
+    case 93:
+      return "yellowBright";
+    case 94:
+      return "blueBright";
+    case 95:
+      return "magentaBright";
+    case 96:
+      return "cyanBright";
+    case 97:
+      return "whiteBright";
+    default:
+      return;
+  }
+}
+function ansi16BgToColorName(code) {
+  let fgCode = code >= 40 && code <= 47 || code >= 100 && code <= 107 ? code - 10 : null;
+  if (fgCode != null)
+    return ansi16ToColorName(fgCode);
+}
+var ANSI16_RGB = {
+  black: { r: 0, g: 0, b: 0 },
+  red: { r: 201, g: 27, b: 0 },
+  green: { r: 0, g: 194, b: 0 },
+  yellow: { r: 199, g: 196, b: 0 },
+  blue: { r: 2, g: 37, b: 199 },
+  magenta: { r: 201, g: 48, b: 199 },
+  cyan: { r: 0, g: 197, b: 199 },
+  white: { r: 199, g: 199, b: 199 },
+  blackBright: { r: 104, g: 104, b: 104 },
+  redBright: { r: 255, g: 110, b: 103 },
+  greenBright: { r: 95, g: 250, b: 104 },
+  yellowBright: { r: 255, g: 252, b: 103 },
+  blueBright: { r: 104, g: 113, b: 255 },
+  magentaBright: { r: 255, g: 118, b: 255 },
+  cyanBright: { r: 95, g: 253, b: 255 },
+  whiteBright: { r: 255, g: 255, b: 255 }
+};
+function nearestAnsi16(r, g, b) {
+  let best = "white", bestDist = Number.POSITIVE_INFINITY;
+  for (let [name, rgb] of Object.entries(ANSI16_RGB)) {
+    let dr = r - rgb.r, dg = g - rgb.g, db = b - rgb.b, d = dr * dr + dg * dg + db * db;
+    d < bestDist && (bestDist = d, best = name);
+  }
+  return best;
+}
+function ansi256ToRgb(index) {
+  let n = Math.max(0, Math.min(255, Math.trunc(index)));
+  if (n < 16) {
+    let name = [
+      "black",
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "white",
+      "blackBright",
+      "redBright",
+      "greenBright",
+      "yellowBright",
+      "blueBright",
+      "magentaBright",
+      "cyanBright",
+      "whiteBright"
+    ][n] ?? "white";
+    return ANSI16_RGB[name];
+  }
+  if (n >= 232) {
+    let c = 8 + (n - 232) * 10;
+    return { r: c, g: c, b: c };
+  }
+  let i = n - 16, rr = Math.floor(i / 36), gg = Math.floor(i % 36 / 6), bb = i % 6, toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
+  return { r: toComponent(rr), g: toComponent(gg), b: toComponent(bb) };
+}
+function applyAnsiSgrStyle(current, codes) {
+  let next = { ...current };
+  for (let i = 0; i < codes.length; i++) {
+    let code = codes[i];
+    if (code === 0) {
+      next = {};
+      continue;
+    }
+    if (code === 1)
+      next = { ...next, bold: !0 };
+    else if (code === 2)
+      next = { ...next, dim: !0 };
+    else if (code === 3)
+      next = { ...next, italic: !0 };
+    else if (code === 4)
+      next = { ...next, underline: !0 };
+    else if (code === 7)
+      next = { ...next, inverse: !0 };
+    else if (code === 22)
+      next = { ...next, bold: !1, dim: !1 };
+    else if (code === 23)
+      next = { ...next, italic: !1 };
+    else if (code === 24)
+      next = { ...next, underline: !1 };
+    else if (code === 27)
+      next = { ...next, inverse: !1 };
+    else if (code === 39)
+      next = { ...next, fg: void 0 };
+    else if (code === 49)
+      next = { ...next, bg: void 0 };
+    else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+      let fg = ansi16ToColorName(code);
+      next = { ...next, fg: fg ?? next.fg };
+    } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+      let bg = ansi16BgToColorName(code);
+      next = { ...next, bg: bg ?? next.bg };
+    } else if (code === 38 || code === 48) {
+      let mode = codes[i + 1];
+      if (mode === 5) {
+        let idx = codes[i + 2];
+        if (idx != null) {
+          let { r, g, b } = ansi256ToRgb(idx), name = nearestAnsi16(r, g, b);
+          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
+        }
+        i += 2;
+      } else if (mode === 2) {
+        let r = codes[i + 2], g = codes[i + 3], b = codes[i + 4];
+        if (r != null && g != null && b != null) {
+          let name = nearestAnsi16(r, g, b);
+          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
+        }
+        i += 4;
+      }
+    }
+  }
+  return next;
+}
+function parseAnsiSgr(input, baseStyle = {}) {
+  let segments = [], style = { ...baseStyle }, lastIndex = 0;
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] !== ESC || input[i + 1] !== "[")
+      continue;
+    let j = i + 2;
+    for (; j < input.length; ) {
+      let c = input.charCodeAt(j);
+      if (c >= 48 && c <= 57 || c === 59) {
+        j++;
+        continue;
+      }
+      break;
+    }
+    if (j >= input.length || input[j] !== "m")
+      continue;
+    i > lastIndex && segments.push({ text: input.slice(lastIndex, i), style });
+    let codes = input.slice(i + 2, j).split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+    style = applyAnsiSgrStyle(style, codes.length ? codes : [0]), lastIndex = j + 1, i = j;
+  }
+  return lastIndex < input.length && segments.push({ text: input.slice(lastIndex), style }), segments;
+}
+
+// src/core/terminal/create-terminal.ts
+var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals"), TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
+function getRootTerminal(terminal) {
+  return terminal[TERMINAL_ROOT] ?? terminal;
+}
+
+// src/renderer/terminal-graphics.ts
+var ESC2 = "\x1B", BEL = "\x07", ST = `${ESC2}\\`, ESC_RE = "\\u001B", BEL_RE = "\\u0007", CSI_RE = new RegExp(`${ESC_RE}\\[[0-?]*[ -/]*[@-~]`, "g"), OSC_RE = new RegExp(`${ESC_RE}\\][\\s\\S]*?(?:${BEL_RE}|${ESC_RE}\\\\)`, "g"), DCS_RE = new RegExp(`${ESC_RE}P[\\s\\S]*?${ESC_RE}\\\\`, "g"), APC_RE = new RegExp(`${ESC_RE}_[\\s\\S]*?${ESC_RE}\\\\`, "g"), C1_CSI_RE = new RegExp("\\u009B[0-?]*[ -/]*[@-~]", "g"), C1_OSC_RE = new RegExp(`\\u009D[\\s\\S]*?(?:${BEL_RE}|\\u009C)`, "g"), C1_DCS_RE = new RegExp("\\u0090[\\s\\S]*?\\u009C", "g"), C1_APC_RE = new RegExp("\\u009F[\\s\\S]*?\\u009C", "g"), MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS = 16 * 1024 * 1024, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS = 16384, MAX_TERMINAL_GRAPHIC_CELLS = 1e4, TERMINAL_GRAPHICS_REGISTRY = Symbol.for("@simon_he/vue-tui:v1:terminal-graphics"), terminalGraphicsGlobal = globalThis, terminalGraphicsRegistry = terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] ?? {
+  outputs: /* @__PURE__ */ new WeakMap(),
+  outputVersions: /* @__PURE__ */ new WeakMap(),
+  outputListeners: /* @__PURE__ */ new WeakMap()
+};
+terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] = terminalGraphicsRegistry;
+var terminalGraphicsOutputs = terminalGraphicsRegistry.outputs, terminalGraphicsOutputVersions = terminalGraphicsRegistry.outputVersions, terminalGraphicsOutputListeners = terminalGraphicsRegistry.outputListeners;
+function getTerminalGraphicsOutput(terminal) {
+  return terminalGraphicsOutputs.get(getRootTerminal(terminal)) ?? null;
+}
+function getTerminalGraphicsOutputVersion(terminal) {
+  return terminalGraphicsOutputVersions.get(getRootTerminal(terminal)) ?? 0;
+}
+function subscribeTerminalGraphicsOutput(terminal, listener) {
+  let rootTerminal = getRootTerminal(terminal), listeners = terminalGraphicsOutputListeners.get(rootTerminal);
+  return listeners || (listeners = /* @__PURE__ */ new Set(), terminalGraphicsOutputListeners.set(rootTerminal, listeners)), listeners.add(listener), () => {
+    listeners.delete(listener), listeners.size === 0 && terminalGraphicsOutputListeners.delete(rootTerminal);
+  };
+}
+function isTerminalGraphicsProtocol(value) {
+  return value === "kitty" || value === "iterm2" || value === "sixel";
+}
+function stableTerminalGraphicNumericId(input, options = {}) {
+  let min = Math.floor(options.min ?? 1), max = Math.floor(options.max ?? 2147483647), span = Math.max(1, max - min + 1), hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1)
+    hash ^= input.charCodeAt(index), hash = Math.imul(hash, 16777619);
+  return min + (hash >>> 0) % span;
+}
+function positiveGraphicInt(value, max) {
+  let n = Math.trunc(Number(value));
+  return !Number.isFinite(n) || n <= 0 ? null : Math.min(max, n);
+}
+function normalizeTerminalGraphicSize(width, height) {
+  let w = positiveGraphicInt(width, MAX_TERMINAL_GRAPHIC_CELLS), h19 = positiveGraphicInt(height, MAX_TERMINAL_GRAPHIC_CELLS);
+  return w == null || h19 == null || w * h19 > MAX_TERMINAL_GRAPHIC_CELLS ? null : { width: w, height: h19 };
+}
+function canDrawTerminalGraphicRect(rect, size) {
+  let x = Math.floor(rect.x), y = Math.floor(rect.y), graphicSize = normalizeTerminalGraphicSize(rect.w, rect.h), cols = Math.max(0, Math.floor(size.cols)), rows = Math.max(0, Math.floor(size.rows));
+  return graphicSize != null && cols > 0 && rows > 0 && Number.isFinite(x) && Number.isFinite(y) && x >= 0 && y >= 0 && x < cols && y < rows;
+}
+function withoutNestedEscapes(body) {
+  return !body.includes(ESC2) && !body.includes(BEL);
+}
+function isBase64ish(value) {
+  return /^[A-Za-z0-9+/=]*$/.test(value);
+}
+function parseKittyControls(raw) {
+  let out = /* @__PURE__ */ new Map();
+  if (!/^[A-Za-z0-9_,=+.\-:]*$/.test(raw))
+    return null;
+  for (let part of raw.split(",")) {
+    if (!part)
+      continue;
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return null;
+    let key = part.slice(0, eq), value = part.slice(eq + 1);
+    if (!/^[A-Za-z]$/.test(key) || !/^[A-Za-z0-9+.\-:]*$/.test(value))
+      return null;
+    out.set(key, value);
+  }
+  return out;
+}
+function parseKittyPackets(sequence) {
+  let packets = [], index = 0;
+  for (; index < sequence.length; ) {
+    if (!sequence.startsWith(`${ESC2}_G`, index))
+      return null;
+    let end = sequence.indexOf(ST, index + 3);
+    if (end < 0)
+      return null;
+    let body = sequence.slice(index + 3, end);
+    if (!withoutNestedEscapes(body))
+      return null;
+    let semicolon = body.indexOf(";"), rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body, payload = semicolon >= 0 ? body.slice(semicolon + 1) : "", controls = parseKittyControls(rawControls);
+    if (!controls || payload && !isBase64ish(payload))
+      return null;
+    packets.push({ controls, payload }), index = end + ST.length;
+  }
+  return packets.length ? packets : null;
+}
+var KITTY_DRAW_FIRST_CONTROL_KEYS = /* @__PURE__ */ new Set([
+  "a",
+  "f",
+  "q",
+  "C",
+  "i",
+  "I",
+  "p",
+  "c",
+  "r",
+  "x",
+  "y",
+  "w",
+  "h",
+  "z",
+  "m",
+  "t"
+]), KITTY_DRAW_CONTINUATION_CONTROL_KEYS = /* @__PURE__ */ new Set(["a", "q", "m"]), KITTY_CLEAR_CONTROL_KEYS = /* @__PURE__ */ new Set(["a", "d", "i", "I", "p", "q"]);
+function kittyControlsUseOnly(controls, allowed) {
+  for (let key of controls.keys())
+    if (!allowed.has(key))
+      return !1;
+  return !0;
+}
+var KITTY_UINT32_MAX = 4294967295, KITTY_INT32_MIN = -2147483648, KITTY_INT32_MAX = 2147483647;
+function kittyControlIsUint32(controls, key, min = 0) {
+  let value = controls.get(key);
+  if (value == null)
+    return !0;
+  if (!/^\d+$/.test(value))
+    return !1;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX;
+}
+function kittyControlIsInt32(controls, key) {
+  let value = controls.get(key);
+  if (value == null)
+    return !0;
+  if (!/^-?\d+$/.test(value))
+    return !1;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX;
+}
+function kittyControlPositiveInt(controls, key, fallback) {
+  let value = controls.get(key);
+  if (value == null)
+    return fallback;
+  if (!/^\d+$/.test(value))
+    return null;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= 1 ? n : null;
+}
+function kittyControlIsTerminalGraphicCellsBounded(controls) {
+  let columns = kittyControlPositiveInt(controls, "c", 1), rows = kittyControlPositiveInt(controls, "r", 1);
+  return columns != null && rows != null && columns * rows <= MAX_TERMINAL_GRAPHIC_CELLS;
+}
+function validateKittySharedSafeControls(controls) {
+  let q = controls.get("q");
+  if (q != null && !/^[0-2]$/.test(q))
+    return !1;
+  let cursorMove = controls.get("C");
+  if (cursorMove != null && !/^[01]$/.test(cursorMove))
+    return !1;
+  for (let key of ["i", "I", "p"])
+    if (!kittyControlIsUint32(controls, key))
+      return !1;
+  for (let key of ["c", "r"])
+    if (!kittyControlIsUint32(controls, key, 1))
+      return !1;
+  if (!kittyControlIsTerminalGraphicCellsBounded(controls))
+    return !1;
+  for (let key of ["x", "y"])
+    if (!kittyControlIsUint32(controls, key))
+      return !1;
+  for (let key of ["w", "h"])
+    if (!kittyControlIsUint32(controls, key, 1))
+      return !1;
+  if (!kittyControlIsInt32(controls, "z"))
+    return !1;
+  let transmissionMedium = controls.get("t");
+  return !(transmissionMedium != null && transmissionMedium !== "d");
+}
+function validateKittySequence(sequence, op = "draw") {
+  let packets = parseKittyPackets(sequence);
+  if (!packets)
+    return !1;
+  if (op === "clear") {
+    if (packets.length !== 1)
+      return !1;
+    let packet = packets[0];
+    if (!kittyControlsUseOnly(packet.controls, KITTY_CLEAR_CONTROL_KEYS) || !validateKittySharedSafeControls(packet.controls) || packet.payload || packet.controls.get("a") !== "d")
+      return !1;
+    let d = packet.controls.get("d");
+    return d == null || /^[aAcCiI]$/.test(d);
+  }
+  let first = packets[0];
+  if (!kittyControlsUseOnly(first.controls, KITTY_DRAW_FIRST_CONTROL_KEYS) || !validateKittySharedSafeControls(first.controls))
+    return !1;
+  if (first.controls.get("a") === "p")
+    return !(packets.length !== 1 || first.payload || !first.controls.has("i") && !first.controls.has("I"));
+  if (first.controls.get("a") !== "T" || !first.payload)
+    return !1;
+  let f = first.controls.get("f");
+  if (f != null && f !== "24" && f !== "32" && f !== "100")
+    return !1;
+  let firstMore = first.controls.get("m");
+  if (firstMore != null && firstMore !== "0" && firstMore !== "1" || packets.length > 1 && firstMore !== "1")
+    return !1;
+  for (let i = 1; i < packets.length; i++) {
+    let packet = packets[i];
+    if (!kittyControlsUseOnly(packet.controls, KITTY_DRAW_CONTINUATION_CONTROL_KEYS) || !validateKittySharedSafeControls(packet.controls))
+      return !1;
+    let action = packet.controls.get("a");
+    if (action != null && action !== "T")
+      return !1;
+    let m = packet.controls.get("m");
+    if (m !== "0" && m !== "1" || !packet.payload && !(i === packets.length - 1 && m === "0"))
+      return !1;
+  }
+  return !(packets.length > 1 && packets[packets.length - 1].controls.get("m") === "1");
+}
+function validateIterm2Dimension(value) {
+  return /^auto$/i.test(value) || /^(?:[1-9]\d{0,4})(?:px|%)?$/.test(value);
+}
+function validateIterm2Params(params) {
+  let seen = /* @__PURE__ */ new Set(), inline = !1;
+  for (let part of params.split(";").filter(Boolean)) {
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return !1;
+    let key = part.slice(0, eq), value = part.slice(eq + 1);
+    if (seen.has(key))
+      return !1;
+    switch (seen.add(key), key) {
+      case "inline":
+        if (value !== "1")
+          return !1;
+        inline = !0;
+        break;
+      case "width":
+      case "height":
+        if (!validateIterm2Dimension(value))
+          return !1;
+        break;
+      case "preserveAspectRatio":
+      case "doNotMoveCursor":
+        if (!/^[01]$/.test(value))
+          return !1;
+        break;
+      default:
+        return !1;
+    }
+  }
+  return inline;
+}
+function validateIterm2Sequence(sequence, op = "draw") {
+  if (op === "clear")
+    return !1;
+  let index = 0;
+  for (; index < sequence.length; ) {
+    let prefix = `${ESC2}]1337;File=`;
+    if (!sequence.startsWith(prefix, index))
+      return !1;
+    let belEnd = sequence.indexOf(BEL, index + prefix.length), stEnd = sequence.indexOf(ST, index + prefix.length), end = belEnd >= 0 && stEnd >= 0 ? Math.min(belEnd, stEnd) : belEnd >= 0 ? belEnd : stEnd;
+    if (end < 0)
+      return !1;
+    let body = sequence.slice(index + `${ESC2}]1337;`.length, end);
+    if (!body.startsWith("File=") || !withoutNestedEscapes(body))
+      return !1;
+    let colon = body.indexOf(":");
+    if (colon < 0)
+      return !1;
+    let params = body.slice(5, colon), payload = body.slice(colon + 1);
+    if (!/^[A-Za-z0-9_=;,.%+\-:]*$/.test(params) || !payload || !isBase64ish(payload) || !validateIterm2Params(params))
+      return !1;
+    index = end + (end === stEnd ? ST.length : BEL.length);
+  }
+  return sequence.length > 0;
+}
+function validateSixelSequence(sequence, op = "draw") {
+  if (op === "clear")
+    return !1;
+  let index = 0;
+  for (; index < sequence.length; ) {
+    if (!sequence.startsWith(`${ESC2}P`, index))
+      return !1;
+    let end = sequence.indexOf(ST, index + 2);
+    if (end < 0)
+      return !1;
+    let body = sequence.slice(index + 2, end);
+    if (!withoutNestedEscapes(body))
+      return !1;
+    for (let i = 0; i < body.length; i++) {
+      let code = body.charCodeAt(i);
+      if (code < 32 || code > 126)
+        return !1;
+    }
+    let q = body.indexOf("q");
+    if (q < 0 || q > 32)
+      return !1;
+    let introducer = body.slice(0, q);
+    if (!/^[0-9;?]*$/.test(introducer) || !body.slice(q + 1).length)
+      return !1;
+    index = end + ST.length;
+  }
+  return sequence.length > 0;
+}
+function stripTerminalControlChars(value) {
+  let out = "";
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 128 && code <= 159 || (out += value[index]);
+  }
+  return out;
+}
+function sanitizeTerminalFallbackText(text) {
+  return stripTerminalControlChars(
+    String(text ?? "").replace(OSC_RE, "").replace(CSI_RE, "").replace(DCS_RE, "").replace(APC_RE, "").replace(C1_OSC_RE, "").replace(C1_CSI_RE, "").replace(C1_DCS_RE, "").replace(C1_APC_RE, "")
+  ).slice(0, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS);
+}
+function isSafeTerminalGraphicsSequence(sequence, protocol, op = "draw") {
+  return !isTerminalGraphicsProtocol(protocol) || !sequence || sequence.length > MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS ? !1 : protocol === "kitty" ? validateKittySequence(sequence, op) : protocol === "iterm2" ? validateIterm2Sequence(sequence, op) : validateSixelSequence(sequence, op);
+}
+function uint32Control(key, value, min = 0) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX ? `${key}=${n}` : "";
+}
+function int32Control(key, value) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX ? `${key}=${n}` : "";
+}
+function sanitizeBase64(value) {
+  let data = String(value ?? "").replace(/\s+/g, "");
+  return isBase64ish(data) ? data : "";
+}
+function kittyGraphicCellControls(columns, rows) {
+  if (columns == null && rows == null)
+    return [];
+  let size = normalizeTerminalGraphicSize(columns ?? 1, rows ?? 1);
+  return size ? [columns == null ? "" : `c=${size.width}`, rows == null ? "" : `r=${size.height}`] : [];
+}
+function kittyGraphicSourceControls(sourceX, sourceY, sourceWidth, sourceHeight) {
+  return [
+    uint32Control("x", sourceX),
+    uint32Control("y", sourceY),
+    uint32Control("w", sourceWidth, 1),
+    uint32Control("h", sourceHeight, 1)
+  ];
+}
+function chunkBase64(value, chunkSize) {
+  let normalizedSize = Math.max(4, Math.floor(chunkSize / 4) * 4), chunks = [];
+  for (let index = 0; index < value.length; index += normalizedSize)
+    chunks.push(value.slice(index, index + normalizedSize));
+  return chunks.length ? chunks : [""];
+}
+function createKittyPlacementSequence(options) {
+  let imageId = uint32Control("i", options.imageId), imageNumber = uint32Control("I", options.imageNumber);
+  if (!imageId && !imageNumber)
+    return "";
+  let controls = [
+    "a=p",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    imageId,
+    imageNumber,
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return `${ESC2}_G${controls.join(",")}${ST}`;
+}
+function createKittyGraphicsSequence(base64Png, options = {}) {
+  let data = sanitizeBase64(base64Png);
+  if (!data)
+    return "";
+  let chunks = chunkBase64(data, options.chunkSize ?? 4096), baseControls = [
+    "a=T",
+    "f=100",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    uint32Control("i", options.imageId),
+    uint32Control("I", options.imageNumber),
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return chunks.map((chunk, index) => {
+    let last = index === chunks.length - 1, controls = index === 0 ? [...baseControls, chunks.length > 1 ? `m=${last ? 0 : 1}` : ""] : [options.quiet === !1 ? "" : "q=2", `m=${last ? 0 : 1}`].filter(Boolean);
+    return `${ESC2}_G${controls.filter(Boolean).join(",")};${chunk}${ST}`;
+  }).join("");
+}
+function createKittyDeleteGraphicsSequence(options = {}) {
+  let controls = ["a=d"];
+  if (options.allVisible)
+    controls.push(`d=${options.freeImageData ? "A" : "a"}`);
+  else if (options.imageId != null) {
+    let imageId = uint32Control("i", options.imageId), placementId = uint32Control("p", options.placementId);
+    if (!imageId || options.placementId != null && !placementId)
+      return "";
+    controls.push(`d=${options.freeImageData ? "I" : "i"}`), controls.push(imageId), controls.push(placementId);
+  } else if (options.currentCell)
+    controls.push(`d=${options.freeImageData ? "C" : "c"}`);
+  else
+    return "";
+  return options.quiet !== !1 && controls.push("q=2"), `${ESC2}_G${controls.filter(Boolean).join(",")}${ST}`;
+}
+function createIterm2InlineImageSequence(base64Data, options = {}) {
+  let data = sanitizeBase64(base64Data);
+  if (!data)
+    return "";
+  let params = [
+    "inline=1",
+    options.width != null ? `width=${formatItermDimension(options.width)}` : "",
+    options.height != null ? `height=${formatItermDimension(options.height)}` : "",
+    `preserveAspectRatio=${options.preserveAspectRatio === !1 ? 0 : 1}`,
+    options.doNotMoveCursor === !1 ? "" : "doNotMoveCursor=1"
+  ].filter(Boolean);
+  return `${ESC2}]1337;File=${params.join(";")}:${data}${BEL}`;
+}
+function formatItermDimension(value) {
+  if (typeof value == "number") {
+    let n = Math.floor(value);
+    return Number.isFinite(n) ? String(Math.min(99999, Math.max(1, n))) : "auto";
+  }
+  let raw = String(value ?? "").trim();
+  return validateIterm2Dimension(raw) ? raw : "auto";
+}
+
+// src/vue/components/TAgentTerminalGraphic.ts
+var import_vue10 = require("vue");
+var NO_GRAPHICS_CAPABILITIES = Object.freeze({
+  supported: !1,
+  kitty: !1,
+  iterm2: !1,
+  sixel: !1,
+  preferredProtocol: null,
+  protocol: "unicode",
+  candidates: [],
+  stdoutIsTTY: !1,
+  insideTmux: !1,
+  insideScreen: !1,
+  insideZellij: !1,
+  multiplexer: null,
+  passthrough: !1,
+  forced: !1,
+  reason: "no-terminal-graphics-output"
+});
+function splitTextOutput(value) {
+  let lines = sanitizeTextBlock(sanitizeTerminalFallbackText(value).replace(/\r\n?/g, `
+`)).split(`
+`);
+  return lines.length ? lines : [""];
+}
+function hasVisibleOutput(value) {
+  return value.some((line) => line.trim().length > 0);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function positiveInt(value) {
+  let n = Math.floor(Number(value));
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function finiteInt(value) {
+  let n = Math.floor(Number(value));
+  return Number.isFinite(n) ? n : void 0;
+}
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function rectArea(rect) {
+  return Math.max(0, rect.w) * Math.max(0, rect.h);
+}
+function sameRect(a, b) {
+  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function subtractRect(rect, cover) {
+  let hit = intersectRect(rect, cover);
+  if (!hit)
+    return [rect];
+  let out = [], rectRight = rect.x + rect.w, rectBottom = rect.y + rect.h, hitRight = hit.x + hit.w, hitBottom = hit.y + hit.h;
+  return hit.y > rect.y && out.push({ x: rect.x, y: rect.y, w: rect.w, h: hit.y - rect.y }), hitBottom < rectBottom && out.push({ x: rect.x, y: hitBottom, w: rect.w, h: rectBottom - hitBottom }), hit.x > rect.x && out.push({ x: rect.x, y: hit.y, w: hit.x - rect.x, h: hit.h }), hitRight < rectRight && out.push({ x: hitRight, y: hit.y, w: rectRight - hitRight, h: hit.h }), out.filter((part) => part.w > 0 && part.h > 0);
+}
+function largestUncoveredRect(rect, covers) {
+  let parts = [rect];
+  for (let cover of covers)
+    if (parts = parts.flatMap((part) => subtractRect(part, cover)), !parts.length)
+      return null;
+  return parts.sort((a, b) => rectArea(b) - rectArea(a) || a.y - b.y || a.x - b.x), parts[0] ?? null;
+}
+function parseKittyClearControls(sequence) {
+  let prefix = "\x1B_G", terminator = "\x1B\\";
+  if (!sequence.startsWith(prefix) || !sequence.endsWith(terminator))
+    return null;
+  let body = sequence.slice(prefix.length, -terminator.length);
+  if (body.includes(terminator) || body.includes("\x1B") || body.includes("\x07"))
+    return null;
+  let semicolon = body.indexOf(";"), rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body, controls = /* @__PURE__ */ new Map();
+  for (let part of rawControls.split(",")) {
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return null;
+    controls.set(part.slice(0, eq), part.slice(eq + 1));
+  }
+  return controls;
+}
+function kittyClearTargetsComponent(sequence, imageId, placementId) {
+  let controls = parseKittyClearControls(sequence);
+  if (!controls)
+    return !1;
+  let mode = controls.get("d");
+  return mode !== "i" && mode !== "I" ? !1 : controls.get("i") === String(imageId) && controls.get("p") === String(placementId);
+}
+function isSafeComponentClearSequence(sequence, protocol, imageId, placementId) {
+  return isSafeTerminalGraphicsSequence(sequence, protocol, "clear") ? protocol !== "kitty" || kittyClearTargetsComponent(sequence, imageId, placementId) : !1;
+}
+var textEncoder = null;
+function stringByteLength(value) {
+  if (typeof TextEncoder < "u")
+    return textEncoder ?? (textEncoder = new TextEncoder()), textEncoder.encode(value).length;
+  let bytes = 0;
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    code <= 127 ? bytes += 1 : code <= 2047 ? bytes += 2 : code >= 55296 && code <= 56319 && index + 1 < value.length ? (bytes += 4, index++) : bytes += 3;
+  }
+  return bytes;
+}
+function smallHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++)
+    hash ^= input.charCodeAt(i), hash = Math.imul(hash, 16777619);
+  return (hash >>> 0).toString(36);
+}
+var tAgentTerminalGraphicProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, default: void 0 },
+  zIndex: { type: Number, default: 0 },
+  content: { type: String, required: !0 },
+  kind: {
+    type: String,
+    default: "image"
+  },
+  fallback: { type: String, default: void 0 },
+  style: { type: Object, default: void 0 },
+  loadingStyle: { type: Object, default: void 0 },
+  errorStyle: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 },
+  final: { type: Boolean, default: !0 },
+  streaming: { type: Boolean, default: !1 },
+  renderer: {
+    type: Function,
+    default: void 0
+  },
+  loadingText: {
+    type: String,
+    default: "Rendering terminal graphic..."
+  },
+  deferRenderUntilVisible: { type: Boolean, default: !0 },
+  suspendRawWhileScrolling: { type: Boolean, default: !0 },
+  suspendRenderWhileScrolling: { type: Boolean, default: !0 },
+  scrolling: { type: Boolean, default: !1 },
+  scrollVersion: { type: Number, default: 0 },
+  placementMoveWithoutClear: { type: Boolean, default: !1 },
+  preserveRawWhileRendering: { type: Boolean, default: !1 },
+  suspended: { type: Boolean, default: !1 },
+  retainRawWhileCovered: { type: Boolean, default: !1 },
+  ignoreRawCoverage: { type: Boolean, default: !1 },
+  ignoreSamePlaneRawCoverage: { type: Boolean, default: !1 },
+  cacheKey: { type: String, default: void 0 },
+  placementKey: { type: String, default: void 0 },
+  trace: {
+    type: Function,
+    default: void 0
+  }
+};
+function terminalDrawKey(current, rect, clearSequence, resizeSequence) {
+  return [
+    current.protocol,
+    rect.x,
+    rect.y,
+    rect.w,
+    rect.h,
+    current.sequenceHash,
+    clearSequence === current.clearSequence ? current.clearSequenceHash ?? "" : smallHash(clearSequence ?? ""),
+    resizeSequence === current.resizeSequence ? current.resizeSequenceHash ?? "" : smallHash(resizeSequence ?? "")
+  ].join(":");
+}
+var TAgentTerminalGraphic = (0, import_vue10.defineComponent)({
+  name: "TAgentTerminalGraphic",
+  props: tAgentTerminalGraphicProps,
+  setup(props) {
+    let instance = (0, import_vue10.getCurrentInstance)(), { terminal, defaultStyle, scheduler, widthProvider, render } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), graphicsActivity = (0, import_vue10.inject)(TerminalGraphicsActivityKey, null), status = (0, import_vue10.shallowRef)("idle"), error = (0, import_vue10.shallowRef)(""), graphic = (0, import_vue10.shallowRef)(null), documentVersion = (0, import_vue10.shallowRef)(0), builtOnce = !1, renderVersion = 0, renderAbort = null, alive = !0, lastRenderedContent = "", lastRenderRawVisible = !1, lastRenderProtocol = null, lastRenderGraphicsOutputVersion = 0, rawIdSeed = props.placementKey ? `placement:${props.placementKey}` : props.cacheKey ? `cache:${props.cacheKey}` : `instance:${instance?.uid ?? "unknown"}`, rawId = `TAgentTerminalGraphic:${smallHash(rawIdSeed)}`, frameTaskId = `${rawId}:render`, lastDrawnGraphic = (0, import_vue10.shallowRef)(null), rawClearPendingRepaint = (0, import_vue10.shallowRef)(null), rawDrawRejectedKey = (0, import_vue10.shallowRef)(null), reservedTerminalGraphicSize = (0, import_vue10.shallowRef)(null), terminalSizeVersion = (0, import_vue10.shallowRef)(0), renderNodeId = (0, import_vue10.shallowRef)(null), lastRawSkipScrollKey = "", lastDeferTraceKey = "", isParentScrolling = (0, import_vue10.computed)(
+      () => props.scrolling || !!graphicsActivity?.scrolling.value
+    ), graphicsActivityVersion = (0, import_vue10.computed)(
+      () => (graphicsActivity?.version.value ?? 0) + Math.floor(Number(props.scrollVersion ?? 0))
+    ), graphicsOutput = () => getTerminalGraphicsOutput(terminal), graphicsOutputVersion = (0, import_vue10.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+    }), unsubscribeTerminalResize = terminal.on("resize", () => {
+      terminalSizeVersion.value++;
+    }), fallbackText = () => props.fallback ?? (props.kind === "math" ? props.content : ""), contentIdentity = (0, import_vue10.computed)(() => `${props.content.length}:${smallHash(props.content)}`), stableGraphicKey = (0, import_vue10.computed)(
+      () => [
+        rawIdSeed,
+        props.cacheKey ?? "",
+        props.kind,
+        contentIdentity.value,
+        props.w,
+        props.h ?? "",
+        props.final ? "final" : "draft"
+      ].join("")
+    ), imageId = (0, import_vue10.computed)(
+      () => stableTerminalGraphicNumericId(`image:${stableGraphicKey.value}`)
+    ), placementId = (0, import_vue10.computed)(
+      () => stableTerminalGraphicNumericId(`placement:${stableGraphicKey.value}`)
+    );
+    function rememberTerminalGraphicSize(current) {
+      if (current.type !== "terminal")
+        return;
+      let rows = positiveInt(current.rows);
+      rows && (reservedTerminalGraphicSize.value = {
+        key: stableGraphicKey.value,
+        rows
+      });
+    }
+    function bump() {
+      documentVersion.value++;
+    }
+    function currentCapabilities() {
+      return graphicsOutput()?.capabilities ?? NO_GRAPHICS_CAPABILITIES;
+    }
+    function trace(type, extra = {}) {
+      let capabilities = currentCapabilities();
+      try {
+        props.trace?.({
+          type,
+          id: rawId,
+          kind: props.kind,
+          protocol: capabilities.protocol,
+          contentHash: smallHash(props.content),
+          ...extra
+        });
+      } catch {
+      }
+      let protocol = isTerminalGraphicsProtocol(capabilities.protocol) ? capabilities.protocol : void 0, key = props.cacheKey ?? smallHash(props.content);
+      type === "render-start" ? recordTerminalGraphicTrace({ type: "renderer-start", id: rawId, key, protocol }) : type === "render-end" ? recordTerminalGraphicTrace({
+        type: extra.reason ? "renderer-error" : "renderer-end",
+        id: rawId,
+        key,
+        protocol,
+        durationMs: extra.durationMs,
+        bytes: extra.sequenceBytes,
+        error: extra.reason
+      }) : type === "defer" ? recordTerminalGraphicTrace({
+        type: extra.reason === "scrolling" ? "skip-scrolling" : "skip-hidden",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }) : type === "raw-draw" || (type === "render-abort" ? recordTerminalGraphicTrace({
+        type: "renderer-abort",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }) : type === "raw-clear" ? recordTerminalGraphicTrace({ type: "clear", id: rawId, key, protocol }) : type === "raw-skip-scroll" && recordTerminalGraphicTrace({
+        type: "skip-scrolling",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }));
+    }
+    function traceDeferOnce(reason) {
+      let key = [reason, graphicsActivityVersion.value, stableGraphicKey.value].join(":");
+      lastDeferTraceKey !== key && (lastDeferTraceKey = key, trace("defer", { reason }));
+    }
+    function abortCurrentRender(reason) {
+      renderAbort && (renderAbort.abort(), renderAbort = null, trace("render-abort", { reason }));
+    }
+    function normalizeResult(result) {
+      if (result == null)
+        return {
+          type: "text",
+          text: fallbackText()
+        };
+      if (typeof result == "string")
+        return {
+          type: "text",
+          text: result
+        };
+      if (typeof result != "object")
+        return {
+          type: "text",
+          text: fallbackText()
+        };
+      if ("type" in result && result.type === "text")
+        return {
+          type: "text",
+          text: result.text
+        };
+      let maybeRaw = result;
+      if (!(maybeRaw.type === "sequence" || "sequence" in result || "protocol" in result) && "text" in result)
+        return {
+          type: "text",
+          text: result.text
+        };
+      let sequence = typeof maybeRaw.sequence == "string" ? maybeRaw.sequence : "", protocol = isTerminalGraphicsProtocol(maybeRaw.protocol) ? maybeRaw.protocol : null, fallback = typeof maybeRaw.fallback == "string" ? sanitizeTerminalFallbackText(maybeRaw.fallback) : fallbackText(), fallbackFromProps = typeof maybeRaw.fallback != "string";
+      if (!sequence || !protocol || !isSafeTerminalGraphicsSequence(sequence, protocol, "draw"))
+        return {
+          type: "text",
+          text: fallback
+        };
+      let rawClear = typeof maybeRaw.clearSequence == "string" ? maybeRaw.clearSequence : void 0, clearSequence = rawClear && isSafeComponentClearSequence(rawClear, protocol, imageId.value, placementId.value) ? rawClear : void 0, rawResize = typeof maybeRaw.resizeSequence == "string" ? maybeRaw.resizeSequence : void 0, resizeSequence = rawResize && isSafeTerminalGraphicsSequence(rawResize, protocol, "draw") ? rawResize : void 0, declaredRows = positiveInt(maybeRaw.rows), declaredCols = positiveInt(maybeRaw.cols), sourceWidth = positiveInt(maybeRaw.sourceWidth), sourceHeight = positiveInt(maybeRaw.sourceHeight), zIndex = finiteInt(maybeRaw.zIndex), declaredSize = declaredRows == null ? null : normalizeTerminalGraphicSize(declaredCols ?? props.w, declaredRows);
+      return {
+        type: "terminal",
+        protocol,
+        sequence,
+        sequenceHash: smallHash(sequence),
+        sequenceBytes: stringByteLength(sequence),
+        fallback,
+        fallbackFromProps,
+        clearSequence,
+        clearSequenceHash: clearSequence ? smallHash(clearSequence) : void 0,
+        resizeSequence,
+        resizeSequenceHash: resizeSequence ? smallHash(resizeSequence) : void 0,
+        cols: declaredRows == null ? declaredCols : declaredSize?.width,
+        rows: declaredSize?.height,
+        sourceWidth,
+        sourceHeight,
+        zIndex
+      };
+    }
+    function defaultClearSequence(protocol) {
+      return protocol === "kitty" ? createKittyDeleteGraphicsSequence({
+        imageId: imageId.value,
+        placementId: placementId.value
+      }) : "";
+    }
+    function resolveClearSequence(current) {
+      if (current.clearSequence)
+        return current.clearSequence;
+      let candidate = defaultClearSequence(current.protocol);
+      if (candidate)
+        return isSafeComponentClearSequence(
+          candidate,
+          current.protocol,
+          imageId.value,
+          placementId.value
+        ) ? candidate : void 0;
+    }
+    function resolveResizeSequence(current, rect, full) {
+      if (current.protocol !== "kitty")
+        return current.resizeSequence;
+      let sourceWidth = positiveInt(current.sourceWidth), sourceHeight = positiveInt(current.sourceHeight);
+      if (!sourceWidth || !sourceHeight || full.w <= 0 || full.h <= 0)
+        return current.resizeSequence;
+      let offsetX = Math.max(0, rect.x - full.x), offsetY = Math.max(0, rect.y - full.y), visibleW = Math.max(0, Math.min(rect.w, full.w - offsetX)), visibleH = Math.max(0, Math.min(rect.h, full.h - offsetY)), x0 = clampNumber(Math.floor(offsetX * sourceWidth / full.w), 0, sourceWidth - 1), y0 = clampNumber(Math.floor(offsetY * sourceHeight / full.h), 0, sourceHeight - 1), x1 = Math.max(
+        x0 + 1,
+        clampNumber(Math.ceil((offsetX + visibleW) * sourceWidth / full.w), 1, sourceWidth)
+      ), y1 = Math.max(
+        y0 + 1,
+        clampNumber(Math.ceil((offsetY + visibleH) * sourceHeight / full.h), 1, sourceHeight)
+      );
+      return createKittyPlacementSequence({
+        imageId: imageId.value,
+        placementId: placementId.value,
+        columns: rect.w,
+        rows: rect.h,
+        sourceX: x0,
+        sourceY: y0,
+        sourceWidth: x1 - x0,
+        sourceHeight: y1 - y0,
+        zIndex: current.zIndex
+      });
+    }
+    function queueClearLastGraphic(options = {}) {
+      let previous = lastDrawnGraphic.value;
+      if (!previous)
+        return !1;
+      let output = graphicsOutput(), accepted = !1;
+      if (output?.clear && !previous.retainOnClear)
+        try {
+          accepted = !!output.clear(previous.id);
+        } catch {
+          accepted = !1;
+        }
+      if (!accepted && output && previous.clearSequence)
+        try {
+          accepted = output.queue({
+            id: previous.id,
+            x: previous.x,
+            y: previous.y,
+            w: previous.w,
+            h: previous.h,
+            protocol: previous.protocol,
+            sequence: previous.clearSequence,
+            deferFlush: !0,
+            retainOnClear: previous.retainOnClear,
+            op: "clear"
+          });
+        } catch {
+          accepted = !1;
+        }
+      return accepted && ((options.markPendingRepaint ?? !0) && (rawClearPendingRepaint.value = previous), lastDrawnGraphic.value = null, trace("raw-clear", {
+        x: previous.x,
+        y: previous.y,
+        w: previous.w,
+        h: previous.h
+      })), accepted;
+    }
+    function queueDrawGraphic(output, current, rect, full = rect, options = {}) {
+      let clearSequence = resolveClearSequence(current), resizeSequence = resolveResizeSequence(current, rect, full), drawKey = terminalDrawKey(current, rect, clearSequence, resizeSequence), activePrevious = lastDrawnGraphic.value, retainedPrevious = rawClearPendingRepaint.value, previous = activePrevious ?? retainedPrevious, previousIsRetained = activePrevious == null && retainedPrevious != null, previousStillActive = previous ? typeof output.isActive == "function" ? output.isActive(previous.id) : !0 : !1, preservePreviousForAtomicReplace = props.preserveRawWhileRendering && activePrevious != null && !previousIsRetained && previousStillActive;
+      if (!previousIsRetained && !options.force && previous?.drawKey === drawKey && previousStillActive)
+        return !1;
+      let canReusePlacementSequence = previousStillActive && previous?.protocol === current.protocol && previous.sequenceHash === current.sequenceHash && current.protocol === "kitty" && !!resizeSequence, scrollVersion = Math.floor(Number(props.scrollVersion ?? 0)), canMoveWithoutClear = canReusePlacementSequence && !!options.placementMoveWithoutClear;
+      if (!previousIsRetained && previousStillActive && !resizeSequence && previous?.protocol === current.protocol && previous.sequenceHash === current.sequenceHash && previous.x === rect.x && previous.y === rect.y && rect.w <= previous.w && rect.h <= previous.h && (options.force || !sameRect(rect, full)))
+        return lastDrawnGraphic.value = {
+          ...previous,
+          w: rect.w,
+          h: rect.h,
+          clearSequence,
+          resizeSequence,
+          drawKey,
+          activityVersion: graphicsActivityVersion.value,
+          scrollVersion
+        }, lastRawSkipScrollKey = "", !1;
+      if (previousStillActive && !previousIsRetained && !canReusePlacementSequence && !preservePreviousForAtomicReplace) {
+        if (!queueClearLastGraphic({ markPendingRepaint: !1 }))
+          return !1;
+      } else
+        previous && (previousStillActive || (lastDrawnGraphic.value = null, rawClearPendingRepaint.value = null));
+      let accepted = !1;
+      try {
+        accepted = output.queue({
+          id: rawId,
+          x: rect.x,
+          y: rect.y,
+          w: rect.w,
+          h: rect.h,
+          protocol: current.protocol,
+          sequence: canReusePlacementSequence && resizeSequence ? resizeSequence : current.sequence,
+          resizeSequence,
+          clearSequence,
+          retainOnClear: !!(props.cacheKey && resizeSequence),
+          resizeRedraw: canReusePlacementSequence,
+          placementMoveWithoutClear: canMoveWithoutClear,
+          allowTextOverlay: options.allowTextOverlay,
+          forceDraw: options.force,
+          deferFlush: options.deferFlush ?? !0,
+          fallbackText: current.fallback
+        });
+      } catch {
+        accepted = !1;
+      }
+      return accepted ? (rawDrawRejectedKey.value = null, rawClearPendingRepaint.value = null, lastDrawnGraphic.value = {
+        id: rawId,
+        x: rect.x,
+        y: rect.y,
+        w: rect.w,
+        h: rect.h,
+        protocol: current.protocol,
+        sequenceHash: current.sequenceHash,
+        clearSequence,
+        resizeSequence,
+        retainOnClear: !!(props.cacheKey && resizeSequence),
+        allowTextOverlay: !!options.allowTextOverlay,
+        drawKey,
+        activityVersion: graphicsActivityVersion.value,
+        scrollVersion
+      }, lastRawSkipScrollKey = "", !0) : (preservePreviousForAtomicReplace ? (lastDrawnGraphic.value = activePrevious, queueClearLastGraphic({ markPendingRepaint: !1 })) : lastDrawnGraphic.value = null, rawDrawRejectedKey.value !== drawKey && (rawDrawRejectedKey.value = drawKey, scheduler.invalidate({ priority: "low", reason: "data" })), !1);
+    }
+    function hasRetainedActiveRawGraphic() {
+      let output = graphicsOutput();
+      return !!(status.value === "loading" && !graphic.value && output && typeof output.isActive == "function" && output.isActive(rawId));
+    }
+    let showingInitialLoadingText = (0, import_vue10.computed)(
+      () => status.value === "loading" && !graphic.value && !hasRetainedActiveRawGraphic()
+    ), fullRect = (0, import_vue10.computed)(() => {
+      let current = graphic.value, reserved = reservedTerminalGraphicSize.value, reservedRows = current?.type === "terminal" ? void 0 : status.value === "idle" && reserved?.key === stableGraphicKey.value ? reserved.rows : void 0, textLines = current?.type === "text" ? splitTextOutput(current.text) : splitTextOutput(fallbackText()), height = props.h ?? (current?.type === "terminal" ? current.rows : void 0) ?? reservedRows ?? Math.max(1, textLines.length);
+      return translateRect(
+        { x: props.x, y: props.y, w: props.w, h: height },
+        layout.originX,
+        layout.originY
+      );
+    }), absRect = (0, import_vue10.computed)(() => {
+      terminalSizeVersion.value;
+      let translated = fullRect.value, size = terminal.size(), terminalClip = {
+        x: 0,
+        y: 0,
+        w: Math.max(0, Math.floor(size.cols)),
+        h: Math.max(0, Math.floor(size.rows))
+      }, clip = layout.clipRect ? intersectRect(layout.clipRect, terminalClip) : terminalClip;
+      return clip ? intersectRect(translated, clip) ?? { x: 0, y: 0, w: 0, h: 0 } : { x: 0, y: 0, w: 0, h: 0 };
+    }), renderRect = (0, import_vue10.computed)(() => absRect.value);
+    function rawRectFitsTerminalViewport(rect) {
+      return canDrawTerminalGraphicRect(rect, terminal.size());
+    }
+    function rawCoveredByHigherRenderNode(rect = fullRect.value) {
+      if (props.retainRawWhileCovered)
+        return !1;
+      let id = renderNodeId.value;
+      return !props.ignoreRawCoverage && id != null && render.isRectCoveredByHigherNode(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      });
+    }
+    function retainedRawCoveredByHigherRenderNode(rect) {
+      if (!props.retainRawWhileCovered)
+        return !1;
+      let id = renderNodeId.value;
+      return !!(id != null && render.isRectCoveredByHigherNode(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      }));
+    }
+    function rawUncoveredRenderRect(rect) {
+      if (props.retainRawWhileCovered)
+        return rect;
+      let id = renderNodeId.value;
+      if (id == null)
+        return rect;
+      let covers = render.higherNodeCoverageRects(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      });
+      return covers.length ? props.ignoreRawCoverage ? largestUncoveredRect(rect, covers) : null : rect;
+    }
+    let rawCanRender = (0, import_vue10.computed)(() => {
+      graphicsOutputVersion.value, terminalSizeVersion.value;
+      let current = graphic.value, output = graphicsOutput(), rect = absRect.value;
+      return current?.type === "terminal" && rawRectFitsTerminalViewport(rect) && !!output?.capabilities.supported && output?.capabilities.preferredProtocol === current.protocol;
+    }), rawOutputCanRenderValue = (0, import_vue10.computed)(() => (graphicsOutputVersion.value, terminalSizeVersion.value, rawOutputCanRender())), rawSuppressedByScroll = (0, import_vue10.computed)(
+      () => props.suspended || props.suspendRawWhileScrolling && isParentScrolling.value
+    ), rawCanQueue = (0, import_vue10.computed)(() => rawCanRender.value && !rawSuppressedByScroll.value);
+    function traceRawSkipScrollOnce(reason) {
+      let r = absRect.value, key = [
+        reason,
+        graphicsActivityVersion.value,
+        stableGraphicKey.value,
+        r.x,
+        r.y,
+        r.w,
+        r.h
+      ].join(":");
+      lastRawSkipScrollKey !== key && (lastRawSkipScrollKey = key, trace("raw-skip-scroll", { reason }));
+    }
+    function hasPaintableRect() {
+      let r = absRect.value;
+      return visible.value && r.w > 0 && r.h > 0;
+    }
+    function rawOutputCanRender() {
+      let output = graphicsOutput(), rect = absRect.value;
+      return rawRectFitsTerminalViewport(rect) && !!output?.capabilities.supported;
+    }
+    function renderDeferReason() {
+      return props.suspended ? "suspended" : props.deferRenderUntilVisible && !hasPaintableRect() ? "not-visible" : props.suspendRenderWhileScrolling && isParentScrolling.value ? "scrolling" : null;
+    }
+    function shouldDeferRender() {
+      return renderDeferReason() != null;
+    }
+    function shouldRerenderForGraphicsOutputChange() {
+      if (!props.renderer || !props.content.trim() || shouldDeferRender() || rawSuppressedByScroll.value)
+        return !1;
+      let protocol = currentCapabilities().protocol;
+      return lastRenderProtocol != null && (lastRenderProtocol !== protocol || lastRenderGraphicsOutputVersion !== graphicsOutputVersion.value);
+    }
+    function shouldRetryTemporaryRawFallback(rawCovered = rawCoveredByHigherRenderNode()) {
+      return !!props.renderer && props.content.trim().length > 0 && graphic.value?.type === "text" && status.value !== "loading" && !lastRenderRawVisible && rawOutputCanRenderValue.value && !rawSuppressedByScroll.value && !rawCovered;
+    }
+    function setDeferredFallback(content) {
+      graphic.value = { type: "text", text: content.trim() ? fallbackText() : "" }, lastRenderedContent = content, status.value = "idle", error.value = "", bump();
+    }
+    function resolveRendererContext(signal) {
+      let capabilities = currentCapabilities(), visibleNow = hasPaintableRect(), rawVisible = rawOutputCanRenderValue.value && !rawSuppressedByScroll.value && !rawCoveredByHigherRenderNode();
+      return {
+        kind: props.kind,
+        width: props.w,
+        height: props.h,
+        final: props.final,
+        streaming: props.streaming,
+        protocol: capabilities.protocol,
+        capabilities,
+        signal,
+        imageId: imageId.value,
+        placementId: placementId.value,
+        visible: visibleNow,
+        rawVisible,
+        scrolling: isParentScrolling.value,
+        cacheKey: props.cacheKey,
+        viewport: {
+          visible: visibleNow,
+          rawVisible,
+          scrolling: isParentScrolling.value,
+          rect: absRect.value,
+          fullRect: fullRect.value
+        }
+      };
+    }
+    async function renderNow(version) {
+      let protocol = currentCapabilities().protocol;
+      recordTerminalGraphicTrace({
+        type: "request",
+        id: rawId,
+        key: props.cacheKey ?? smallHash(props.content),
+        protocol: isTerminalGraphicsProtocol(protocol) ? protocol : void 0
+      });
+      let content = props.content;
+      if (!content.trim()) {
+        if (abortCurrentRender("superseded"), !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: "" }, lastRenderedContent = content, status.value = "ready", error.value = "", bump();
+        return;
+      }
+      let renderer = props.renderer;
+      if (!renderer) {
+        if (abortCurrentRender("superseded"), !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: fallbackText() }, lastRenderedContent = content, status.value = "ready", error.value = "", bump();
+        return;
+      }
+      let deferred = renderDeferReason();
+      if (deferred) {
+        if (abortCurrentRender(deferred), !alive || version !== renderVersion)
+          return;
+        setDeferredFallback(content), traceDeferOnce(deferred);
+        return;
+      }
+      abortCurrentRender("superseded"), lastDeferTraceKey = "";
+      let abort = new AbortController();
+      renderAbort = abort;
+      let startedAt = nowTerminalGraphicTraceTime();
+      status.value = "loading", error.value = "", trace("render-start"), bump();
+      try {
+        let contextGraphicsOutputVersion = graphicsOutputVersion.value, context = resolveRendererContext(abort.signal);
+        lastRenderRawVisible = context.rawVisible, lastRenderProtocol = context.protocol, lastRenderGraphicsOutputVersion = contextGraphicsOutputVersion;
+        let result = await renderer(content, context);
+        if (abort.signal.aborted || !alive || version !== renderVersion)
+          return;
+        let normalized = normalizeResult(result);
+        rememberTerminalGraphicSize(normalized), graphic.value = normalized, lastRenderedContent = content, status.value = "ready", error.value = "", trace("render-end", {
+          durationMs: nowTerminalGraphicTraceTime() - startedAt,
+          sequenceChars: normalized.type === "terminal" ? normalized.sequence.length : 0,
+          sequenceBytes: normalized.type === "terminal" ? normalized.sequenceBytes : 0
+        }), bump(), normalized.type === "terminal" && scheduler.invalidate({ priority: "low", reason: "data" });
+      } catch (err) {
+        if (abort.signal.aborted || !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: fallbackText() }, lastRenderedContent = content, status.value = "ready", error.value = errorMessage(err), trace("render-end", {
+          durationMs: nowTerminalGraphicTraceTime() - startedAt,
+          reason: error.value
+        }), bump();
+      } finally {
+        renderAbort === abort && (renderAbort = null);
+      }
+    }
+    function scheduleRender(options = {}) {
+      let version = ++renderVersion;
+      if ((options.clearLastGraphic ?? !props.preserveRawWhileRendering) && queueClearLastGraphic(), !builtOnce || !props.streaming) {
+        builtOnce = !0, renderNow(version);
+        return;
+      }
+      scheduler.queueFrameTask({
+        id: frameTaskId,
+        reason: "stream",
+        priority: "low",
+        sync: !1,
+        run: () => {
+          alive && version === renderVersion && renderNow(version);
+        }
+      }) === !1 && renderNow(version);
+    }
+    (0, import_vue10.watch)(
+      [
+        () => props.content,
+        () => props.kind,
+        () => props.renderer,
+        () => props.w,
+        () => props.h,
+        () => props.streaming,
+        () => props.final,
+        () => props.deferRenderUntilVisible,
+        () => props.suspendRawWhileScrolling,
+        () => props.suspendRenderWhileScrolling,
+        () => props.scrolling,
+        () => props.preserveRawWhileRendering,
+        () => props.suspended,
+        () => props.retainRawWhileCovered,
+        () => props.ignoreRawCoverage,
+        () => props.ignoreSamePlaneRawCoverage,
+        () => props.cacheKey,
+        () => props.placementKey
+      ],
+      () => {
+        scheduleRender();
+      },
+      { immediate: !0 }
+    ), (0, import_vue10.watch)(
+      () => props.fallback,
+      () => {
+        let current = graphic.value;
+        if (current?.type === "terminal") {
+          if (current.fallbackFromProps) {
+            graphic.value = { ...current, fallback: fallbackText() }, bump(), scheduler.invalidate({ priority: "low", reason: "data" });
+            return;
+          }
+          scheduleRender({ clearLastGraphic: !1 });
+          return;
+        }
+        scheduleRender();
+      }
+    ), (0, import_vue10.watch)(
+      () => [graphicsOutputVersion.value, rawOutputCanRenderValue.value],
+      () => {
+        !props.renderer || !props.content.trim() || graphic.value?.type !== "terminal" && (!rawOutputCanRenderValue.value || shouldDeferRender() || scheduleRender({ clearLastGraphic: !1 }));
+      }
+    ), (0, import_vue10.watch)(
+      () => [props.x, props.y, props.w, props.h, props.scrollVersion],
+      () => {
+        if (graphic.value?.type === "terminal") {
+          scheduler.invalidate({ priority: "low", reason: "data" });
+          return;
+        }
+        props.kind !== "image" || status.value !== "loading" || !props.renderer || scheduleRender({ clearLastGraphic: !1 });
+      },
+      { flush: "sync" }
+    ), (0, import_vue10.onBeforeUnmount)(() => {
+      alive = !1, renderVersion++, unsubscribeTerminalResize(), unsubscribeGraphicsOutput(), abortCurrentRender("unmount"), scheduler.cancelFrameTask?.(frameTaskId), queueClearLastGraphic();
+    });
+    function resolveDisplayLines(rawPlaceholderAllowed) {
+      if (showingInitialLoadingText.value)
+        return splitTextOutput(props.loadingText);
+      let current = graphic.value;
+      if (!current)
+        return splitTextOutput(fallbackText());
+      if (current.type === "terminal" && rawPlaceholderAllowed) {
+        let clearSequence = resolveClearSequence(current), drawKey = terminalDrawKey(
+          current,
+          absRect.value,
+          clearSequence,
+          resolveResizeSequence(current, absRect.value, fullRect.value)
+        );
+        if (rawDrawRejectedKey.value !== drawKey)
+          return (0, import_vue10.markRaw)([""]);
+      }
+      let text = current.type === "terminal" ? current.fallback : current.text, lines = splitTextOutput(text);
+      return text.trim().length > 0 && !hasVisibleOutput(lines) ? splitTextOutput(fallbackText()) : lines;
+    }
+    let displayLines = (0, import_vue10.computed)(() => resolveDisplayLines(rawCanQueue.value)), currentStyle = (0, import_vue10.computed)(() => error.value ? props.errorStyle ?? props.style ?? defaultStyle.value : showingInitialLoadingText.value ? props.loadingStyle ?? props.style ?? defaultStyle.value : props.style ?? defaultStyle.value), renderNode = useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? renderRect.value : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        renderRect.value,
+        fullRect.value,
+        displayLines.value,
+        currentStyle.value,
+        props.clear,
+        status.value,
+        error.value,
+        documentVersion.value,
+        rawOutputCanRenderValue.value,
+        rawCanRender.value,
+        rawCanQueue.value,
+        rawClearPendingRepaint.value,
+        rawDrawRejectedKey.value,
+        rawSuppressedByScroll.value,
+        props.placementMoveWithoutClear,
+        props.retainRawWhileCovered,
+        isParentScrolling.value,
+        graphicsActivityVersion.value,
+        graphicsOutputVersion.value
+      ],
+      paint: (dirtyRows) => {
+        withTextWidthProvider(widthProvider, () => {
+          if (!visible.value) {
+            queueClearLastGraphic();
+            return;
+          }
+          let r = absRect.value, full = fullRect.value;
+          if (r.w <= 0 || r.h <= 0) {
+            queueClearLastGraphic();
+            return;
+          }
+          let style = currentStyle.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), current = graphic.value, output = graphicsOutput(), retainedActiveRawGraphic = hasRetainedActiveRawGraphic(), rawRectForPaint = rawUncoveredRenderRect(r), rawCoverageClipped = rawRectForPaint != null && props.ignoreRawCoverage && !sameRect(rawRectForPaint, r), rawCoveredForPaint = rawRectForPaint == null && rawCoveredByHigherRenderNode(r), rawCanQueueForPaint = current?.type === "terminal" && rawCanQueue.value && rawRectForPaint != null, preserveActiveRawGraphic = !1, forceActiveRawRedraw = !1, allowTextOverlay = !1;
+          if (rawCanQueueForPaint && output) {
+            let previous = lastDrawnGraphic.value;
+            if ((previous ? typeof output.isActive == "function" ? output.isActive(previous.id) : !0 : !1) && previous) {
+              let clearSequence = resolveClearSequence(current), resizeSequence = resolveResizeSequence(current, rawRectForPaint, full);
+              preserveActiveRawGraphic = rawClearPendingRepaint.value == null && previous.drawKey === terminalDrawKey(current, rawRectForPaint, clearSequence, resizeSequence), allowTextOverlay = retainedRawCoveredByHigherRenderNode(r), forceActiveRawRedraw = preserveActiveRawGraphic && (previous.activityVersion !== graphicsActivityVersion.value || previous.allowTextOverlay !== allowTextOverlay);
+            }
+          }
+          let preserveActiveRawGraphicForPaint = preserveActiveRawGraphic, out = rawCanQueueForPaint ? displayLines.value : resolveDisplayLines(!1), clearingRawGraphic = rawClearPendingRepaint.value != null || lastDrawnGraphic.value != null && !preserveActiveRawGraphicForPaint, clearOwnedRegion = preserveActiveRawGraphicForPaint || retainedActiveRawGraphic ? !1 : props.clear || clearingRawGraphic || !!rawCanQueueForPaint, blank = clearOwnedRegion ? spaces(r.w) : "", paintRow = (y) => {
+            if (y < r.y || y >= r.y + r.h)
+              return;
+            let rowIndex = y - fullY;
+            if (rowIndex < 0 || rowIndex >= out.length) {
+              clearOwnedRegion && terminal.write(blank, { x: r.x, y, style });
+              return;
+            }
+            let src = out[rowIndex] ?? "", clipped = dx > 0 ? sliceByCellsRange(src, dx, dx + r.w) : sliceByCells(src, r.w), value = clearOwnedRegion ? padEndByCells(clipped, r.w) : clipped;
+            (value || clearOwnedRegion) && terminal.write(value, { x: r.x, y, style });
+          }, paintRows = () => {
+            if (dirtyRows?.length)
+              for (let y of dirtyRows)
+                paintRow(y);
+            else
+              for (let y = r.y; y < r.y + r.h; y++)
+                paintRow(y);
+          };
+          if (paintRows(), current?.type === "terminal" && output?.capabilities.supported && output.capabilities.preferredProtocol === current.protocol && rawCanQueueForPaint) {
+            let drawKey = terminalDrawKey(
+              current,
+              rawRectForPaint,
+              resolveClearSequence(current),
+              resolveResizeSequence(current, rawRectForPaint, full)
+            );
+            queueDrawGraphic(output, current, rawRectForPaint, full, {
+              force: forceActiveRawRedraw,
+              deferFlush: preserveActiveRawGraphicForPaint,
+              placementMoveWithoutClear: props.placementMoveWithoutClear || rawCoverageClipped,
+              allowTextOverlay
+            }) ? trace("raw-draw", {
+              sequenceChars: current.sequence.length,
+              sequenceBytes: current.sequenceBytes,
+              x: rawRectForPaint.x,
+              y: rawRectForPaint.y,
+              w: rawRectForPaint.w,
+              h: rawRectForPaint.h
+            }) : rawDrawRejectedKey.value === drawKey && (out = resolveDisplayLines(!1), paintRows());
+          } else
+            current?.type === "terminal" && rawSuppressedByScroll.value && traceRawSkipScrollOnce(isParentScrolling.value ? "scrolling" : "suspended"), queueClearLastGraphic({ markPendingRepaint: !1 }), !shouldDeferRender() && shouldRetryTemporaryRawFallback(rawCoveredForPaint) && scheduleRender({ clearLastGraphic: !1 });
+          clearingRawGraphic && (rawClearPendingRepaint.value = null);
+        });
+      }
+    }));
+    return (0, import_vue10.watch)(
+      renderNode.id,
+      (id) => {
+        renderNodeId.value = id;
+      },
+      { immediate: !0 }
+    ), (0, import_vue10.watch)(
+      [
+        visible,
+        rawOutputCanRenderValue,
+        rawCanRender,
+        rawCanQueue,
+        rawSuppressedByScroll,
+        isParentScrolling,
+        graphicsActivityVersion,
+        graphicsOutputVersion,
+        () => renderRect.value.x,
+        () => renderRect.value.y,
+        () => renderRect.value.w,
+        () => renderRect.value.h,
+        () => fullRect.value.x,
+        () => fullRect.value.y,
+        () => fullRect.value.w,
+        () => fullRect.value.h
+      ],
+      () => {
+        if (!alive)
+          return;
+        let deferred = renderDeferReason();
+        deferred && (abortCurrentRender(deferred), (status.value === "loading" || !graphic.value || lastRenderedContent !== props.content) && setDeferredFallback(props.content), traceDeferOnce(deferred)), (!visible.value || !rawCanQueue.value) && queueClearLastGraphic();
+        let shouldRetryTemporaryFallback = shouldRetryTemporaryRawFallback(), shouldRerenderForOutputChange = shouldRerenderForGraphicsOutputChange();
+        if (!shouldDeferRender() && (!graphic.value || status.value === "idle" || shouldRetryTemporaryFallback || shouldRerenderForOutputChange)) {
+          scheduleRender();
+          return;
+        }
+        scheduler.invalidate({ priority: "low", reason: "data" });
+      },
+      { flush: "post" }
+    ), () => (0, import_vue10.h)("span", rootProps);
+  }
+});
+
+// src/vue/components/TText.ts
+var import_vue11 = require("vue");
+function fitText(text, max) {
+  return max <= 0 ? "" : (text = sanitizeInlineText(text), sliceByCells(text, max));
+}
+function splitLines(text) {
+  return sanitizeTextBlock(text).split(`
+`);
+}
+function computeDefaultWidth(text) {
+  let lines = splitLines(text), max = 0;
+  for (let line of lines)
+    max = Math.max(max, textCellWidth(line));
+  return max;
+}
+var TText = (0, import_vue11.defineComponent)({
+  name: "TText",
+  props: {
+    x: { type: Number, required: !0 },
+    y: { type: Number, required: !0 },
+    zIndex: { type: Number, default: 0 },
+    value: { type: String, required: !0 },
+    w: { type: Number, default: void 0 },
+    h: { type: Number, default: void 0 },
+    style: { type: Object, default: void 0 },
+    clear: { type: Boolean, default: !0 },
+    wrap: { type: Boolean, default: !1 },
+    /**
+     * Optional key that participates in render-node dependency tracking.
+     * Useful for forcing a repaint when the rendered output might change
+     * even if `value`, `style`, and geometry are unchanged (e.g. external
+     * terminal writes or higher-level virtualized row reuse).
+     */
+    depsKey: { type: null, default: void 0 }
+  },
+  setup(props) {
+    let { terminal, defaultStyle } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), defaultWidth = (0, import_vue11.computed)(() => computeDefaultWidth(props.value)), lines = (0, import_vue11.computed)(() => {
+      let w = props.w ?? defaultWidth.value;
+      if (w <= 0)
+        return [""];
+      if (!props.wrap)
+        return splitLines(props.value).map((l) => fitText(l, w));
+      let safe = sanitizeTextBlock(props.value);
+      return wrapByCells(safe, w).map((l) => fitText(l, w));
+    }), absRect = (0, import_vue11.computed)(() => {
+      let width = props.w ?? defaultWidth.value, height = props.h ?? (props.wrap, lines.value.length || 1), raw = { x: props.x, y: props.y, w: width, h: height }, translated = translateRect(raw, layout.originX, layout.originY);
+      return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
+    }), fullRect = (0, import_vue11.computed)(() => {
+      let width = props.w ?? defaultWidth.value, height = props.h ?? (props.wrap, lines.value.length || 1);
+      return translateRect(
+        { x: props.x, y: props.y, w: width, h: height },
+        layout.originX,
+        layout.originY
+      );
+    });
+    return useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? absRect.value : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        absRect.value,
+        fullRect.value,
+        props.value,
+        props.w,
+        props.h,
+        props.wrap,
+        props.style,
+        defaultStyle.value,
+        props.depsKey
+      ],
+      paint: (dirtyRows) => {
+        if (!visible.value)
+          return;
+        let r = absRect.value;
+        if (r.w <= 0 || r.h <= 0)
+          return;
+        let full = fullRect.value, style = props.style ?? defaultStyle.value, blank = props.clear ? spaces(r.w) : "", out = lines.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), paintRow = (y) => {
+          let relY = y - r.y;
+          if (relY < 0 || relY >= r.h)
+            return;
+          let i = y - fullY;
+          if (i < 0 || i >= out.length) {
+            props.clear && terminal.write(blank, { x: r.x, y, style });
+            return;
+          }
+          let src = out[i] ?? "", clipped = dx > 0 ? sliceByCellsRange(src, dx, dx + r.w) : sliceByCells(src, r.w);
+          terminal.write(padEndByCells(clipped, r.w), { x: r.x, y, style });
+        };
+        if (!dirtyRows) {
+          for (let i = 0; i < r.h; i++)
+            paintRow(r.y + i);
+          return;
+        }
+        for (let y of dirtyRows)
+          paintRow(y);
+      }
+    })), () => (0, import_vue11.h)("span", rootProps);
+  }
+});
+
+// src/vue/components/TView.ts
+var import_vue12 = require("vue");
+var EMPTY_RECT = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), TView = (0, import_vue12.defineComponent)({
+  name: "TView",
+  props: {
+    x: { type: Number, required: !0 },
+    y: { type: Number, required: !0 },
+    w: { type: Number, required: !0 },
+    h: { type: Number, required: !0 },
+    zIndex: { type: Number, default: 0 },
+    scrollX: { type: Number, default: 0 },
+    scrollY: { type: Number, default: 0 },
+    focusable: { type: Boolean, default: !1 },
+    selectable: { type: Boolean, default: void 0 },
+    selectionScrollBy: {
+      type: Function,
+      default: void 0
+    },
+    autoFocus: { type: Boolean, default: !1 }
+  },
+  emits: [
+    "clickCapture",
+    "click",
+    "dblclickCapture",
+    "dblclick",
+    "pointerdownCapture",
+    "pointerdown",
+    "pointerupCapture",
+    "pointerup",
+    "pointermoveCapture",
+    "pointermove",
+    "pointerenterCapture",
+    "pointerenter",
+    "pointerleaveCapture",
+    "pointerleave",
+    "wheelCapture",
+    "wheel",
+    "keydownCapture",
+    "keydown",
+    "keyupCapture",
+    "keyup",
+    "focusCapture",
+    "focus",
+    "blurCapture",
+    "blur"
+  ],
+  setup(props, { emit, slots }) {
+    let parent = useLayout(), { render, events } = useTerminal(), parentStack = useRenderStack(), { visible, rootProps } = useVisibility({ provide: !0 }), parentEventZ = (0, import_vue12.inject)(EventZIndexContextKey, (0, import_vue12.computed)(() => 0)), eventZ = (0, import_vue12.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), rawRect = (0, import_vue12.computed)(
+      () => translateRect(
+        { x: props.x, y: props.y, w: props.w, h: props.h },
+        parent.originX,
+        parent.originY
+      )
+    ), rect = (0, import_vue12.computed)(() => {
+      let translated = rawRect.value;
+      return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT : translated;
+    }), { id } = useTerminalNode(() => ({
+      rect: rect.value,
+      zIndex: eventZ.value,
+      visible: visible.value,
+      focusable: props.focusable,
+      selectable: props.selectable,
+      selectionScrollBy: props.selectionScrollBy,
+      handlers: {
+        clickCapture: (e) => emit("clickCapture", e),
+        click: (e) => emit("click", e),
+        dblclickCapture: (e) => emit("dblclickCapture", e),
+        dblclick: (e) => emit("dblclick", e),
+        pointerdownCapture: (e) => emit("pointerdownCapture", e),
+        pointerdown: (e) => emit("pointerdown", e),
+        pointerupCapture: (e) => emit("pointerupCapture", e),
+        pointerup: (e) => emit("pointerup", e),
+        pointermoveCapture: (e) => emit("pointermoveCapture", e),
+        pointermove: (e) => emit("pointermove", e),
+        pointerenterCapture: (e) => emit("pointerenterCapture", e),
+        pointerenter: (e) => emit("pointerenter", e),
+        pointerleaveCapture: (e) => emit("pointerleaveCapture", e),
+        pointerleave: (e) => emit("pointerleave", e),
+        wheelCapture: (e) => emit("wheelCapture", e),
+        wheel: (e) => emit("wheel", e),
+        keydownCapture: (e) => emit("keydownCapture", e),
+        keydown: (e) => emit("keydown", e),
+        keyupCapture: (e) => emit("keyupCapture", e),
+        keyup: (e) => emit("keyup", e),
+        focusCapture: (e) => emit("focusCapture", e),
+        focus: (e) => emit("focus", e),
+        blurCapture: (e) => emit("blurCapture", e),
+        blur: (e) => emit("blur", e)
+      }
+    }));
+    (0, import_vue12.watchEffect)(() => {
+      if (!props.autoFocus || !visible.value)
+        return;
+      let manager = events.value, nodeId = id.value;
+      !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
+    });
+    let childLayout = (0, import_vue12.shallowReactive)({
+      originX: 0,
+      originY: 0,
+      clipRect: null
+    }), childStack = (0, import_vue12.computed)(() => render.createStack(parentStack.value, props.zIndex));
+    return (0, import_vue12.watchEffect)(() => {
+      let translated = rawRect.value;
+      childLayout.originX = translated.x - Math.floor(props.scrollX), childLayout.originY = translated.y - Math.floor(props.scrollY), childLayout.clipRect = rect.value;
+    }), (0, import_vue12.provide)(LayoutContextKey, childLayout), (0, import_vue12.provide)(RenderStackKey, childStack), (0, import_vue12.provide)(EventZIndexContextKey, eventZ), () => (0, import_vue12.h)("div", rootProps, slots.default?.());
+  }
+});
+
+// src/vue/components/TVideo.ts
+var DEFAULT_MAX_FPS = 12, DEFAULT_MAX_PIXEL_WIDTH = 640, DEFAULT_MAX_PIXEL_HEIGHT = 360, MAX_PIXEL_DIMENSION = 4096, MAX_FRAME_BYTES = 8 * 1024 * 1024, MAX_GRAY8_FPS = 10, MAX_GRAY8_WIDTH = 512, MAX_GRAY8_HEIGHT = 256, ASCII_RAMP = " .:-=+*#%@", CONTROL_REFRESH_MS = 250, PLAYBACK_RATES = [1, 2, 3];
+function positiveInt2(value, fallback, max) {
+  let parsed = Math.floor(Number(value));
+  return !Number.isFinite(parsed) || parsed <= 0 ? Math.min(max, fallback) : Math.min(max, parsed);
+}
+function positiveNumber(value, fallback, max) {
+  let parsed = Number(value);
+  return !Number.isFinite(parsed) || parsed <= 0 ? fallback : Math.min(max, parsed);
+}
+function playbackRate(value) {
+  return value === 2 || value === 3 ? value : 1;
+}
+function optionalDuration(value) {
+  let parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function formatPlaybackTime(valueMs, hourDigits = 0) {
+  if (valueMs == null)
+    return "--:--";
+  let seconds = Math.max(0, Math.floor(valueMs / 1e3)), hours = Math.floor(seconds / 3600), minutes = Math.floor(seconds % 3600 / 60), remainder = seconds % 60;
+  return hours > 0 || hourDigits > 0 ? `${String(hours).padStart(Math.max(1, hourDigits), "0")}:${String(minutes).padStart(2, "0")}:${String(remainder).padStart(2, "0")}` : `${String(minutes).padStart(2, "0")}:${String(remainder).padStart(2, "0")}`;
+}
+function readUint32(bytes, offset) {
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+}
+function normalizeFrame(frame) {
+  if (frame.format === "gray8") {
+    let pixelWidth2 = Math.floor(Number(frame.pixelWidth)), pixelHeight2 = Math.floor(Number(frame.pixelHeight)), pixels = frame.pixels;
+    if (!Number.isFinite(pixelWidth2) || !Number.isFinite(pixelHeight2) || pixelWidth2 <= 0 || pixelHeight2 <= 0 || pixelWidth2 > MAX_GRAY8_WIDTH || pixelHeight2 > MAX_GRAY8_HEIGHT || !(pixels instanceof Uint8Array) || pixels.length !== pixelWidth2 * pixelHeight2 || pixels.length > MAX_FRAME_BYTES)
+      throw new Error("TVideo gray8 frame must match its bounded pixel dimensions");
+    return {
+      format: "gray8",
+      pixels,
+      timestampMs: Math.max(0, Number(frame.timestampMs) || 0),
+      pixelWidth: pixelWidth2,
+      pixelHeight: pixelHeight2,
+      fingerprint: frame.fingerprint,
+      durationMs: optionalDuration(frame.durationMs)
+    };
+  }
+  let png = frame.png;
+  if (!(png instanceof Uint8Array) || png.length < 24 || png.length > MAX_FRAME_BYTES)
+    throw new Error("TVideo frame must contain a bounded PNG Uint8Array");
+  if (png[0] !== 137 || png[1] !== 80 || png[2] !== 78 || png[3] !== 71 || png[4] !== 13 || png[5] !== 10 || png[6] !== 26 || png[7] !== 10)
+    throw new Error("TVideo frame source emitted invalid PNG data");
+  let pixelWidth = readUint32(png, 16), pixelHeight = readUint32(png, 20);
+  if (pixelWidth <= 0 || pixelHeight <= 0 || pixelWidth > MAX_PIXEL_DIMENSION || pixelHeight > MAX_PIXEL_DIMENSION)
+    throw new Error(`TVideo frame has an unsupported size: ${pixelWidth}x${pixelHeight}`);
+  return {
+    format: "png",
+    png,
+    timestampMs: Math.max(0, Number(frame.timestampMs) || 0),
+    pixelWidth,
+    pixelHeight,
+    fingerprint: frame.fingerprint,
+    durationMs: optionalDuration(frame.durationMs)
+  };
+}
+function frameBytes(frame) {
+  return frame.format === "gray8" ? frame.pixels : frame.png;
+}
+function gray8ToAscii(frame, cellWidth) {
+  let lines = [], width = Math.max(1, Math.floor(cellWidth));
+  for (let y = 0; y < frame.pixelHeight; y++) {
+    let line = "", rowStart = y * frame.pixelWidth;
+    for (let x = 0; x < frame.pixelWidth; x++) {
+      let value = frame.pixels[rowStart + x], glyph = ASCII_RAMP[Math.min(ASCII_RAMP.length - 1, value * ASCII_RAMP.length >> 8)];
+      line += `${glyph}${glyph}`;
+    }
+    lines.push(line.slice(0, width));
+  }
+  return lines.join(`
+`);
+}
+function sameBytes(left, right) {
+  if (left.length !== right.length)
+    return !1;
+  for (let index = 0; index < left.length; index++)
+    if (left[index] !== right[index])
+      return !1;
+  return !0;
+}
+function bytesToBase64(bytes) {
+  let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", chunks = [], chunk = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    let a = bytes[index], hasB = index + 1 < bytes.length, hasC = index + 2 < bytes.length, b = hasB ? bytes[index + 1] : 0, c = hasC ? bytes[index + 2] : 0;
+    chunk += alphabet[a >> 2] + alphabet[(a & 3) << 4 | b >> 4] + (hasB ? alphabet[(b & 15) << 2 | c >> 6] : "=") + (hasC ? alphabet[c & 63] : "="), chunk.length >= 16384 && (chunks.push(chunk), chunk = "");
+  }
+  return chunk && chunks.push(chunk), chunks.join("");
+}
+function resolveKittyPlacement(frame, context) {
+  let rect = context.viewport.rect, full = context.viewport.fullRect, columns = Math.max(1, Math.floor(rect.w)), rows = Math.max(1, Math.floor(rect.h));
+  if (full.w <= 0 || full.h <= 0)
+    return { columns, rows };
+  let offsetX = Math.max(0, rect.x - full.x), offsetY = Math.max(0, rect.y - full.y), visibleW = Math.max(0, Math.min(rect.w, full.w - offsetX)), visibleH = Math.max(0, Math.min(rect.h, full.h - offsetY));
+  if (offsetX <= 0 && offsetY <= 0 && visibleW >= full.w && visibleH >= full.h)
+    return { columns, rows };
+  let sourceX = Math.max(
+    0,
+    Math.min(frame.pixelWidth - 1, Math.floor(offsetX * frame.pixelWidth / full.w))
+  ), sourceY = Math.max(
+    0,
+    Math.min(frame.pixelHeight - 1, Math.floor(offsetY * frame.pixelHeight / full.h))
+  ), sourceRight = Math.max(
+    sourceX + 1,
+    Math.min(frame.pixelWidth, Math.ceil((offsetX + visibleW) * frame.pixelWidth / full.w))
+  ), sourceBottom = Math.max(
+    sourceY + 1,
+    Math.min(frame.pixelHeight, Math.ceil((offsetY + visibleH) * frame.pixelHeight / full.h))
+  );
+  return {
+    columns,
+    rows,
+    sourceX,
+    sourceY,
+    sourceWidth: sourceRight - sourceX,
+    sourceHeight: sourceBottom - sourceY
+  };
+}
+function createFrameRenderer(frame, cellWidth) {
+  if (frame.format === "gray8") {
+    let text = gray8ToAscii(frame, cellWidth);
+    return () => ({ type: "text", text });
+  }
+  let base64;
+  return (_content, context) => {
+    if (!context.visible || !context.rawVisible)
+      return null;
+    if (base64 ?? (base64 = bytesToBase64(frame.png)), context.protocol === "kitty") {
+      let placement = resolveKittyPlacement(frame, context);
+      return {
+        type: "sequence",
+        protocol: "kitty",
+        sequence: createKittyGraphicsSequence(base64, {
+          imageId: context.imageId,
+          placementId: context.placementId,
+          ...placement
+        }),
+        resizeSequence: createKittyPlacementSequence({
+          imageId: context.imageId,
+          placementId: context.placementId,
+          ...placement
+        }),
+        clearSequence: createKittyDeleteGraphicsSequence({
+          imageId: context.imageId,
+          placementId: context.placementId,
+          freeImageData: !0
+        }),
+        cols: context.width,
+        rows: context.height,
+        sourceWidth: frame.pixelWidth,
+        sourceHeight: frame.pixelHeight
+      };
+    }
+    return context.protocol === "iterm2" ? {
+      type: "sequence",
+      protocol: "iterm2",
+      sequence: createIterm2InlineImageSequence(base64, {
+        width: context.width,
+        height: context.height,
+        preserveAspectRatio: !0,
+        doNotMoveCursor: !0
+      }),
+      cols: context.width,
+      rows: context.height,
+      sourceWidth: frame.pixelWidth,
+      sourceHeight: frame.pixelHeight
+    } : null;
+  };
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var tVideoProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, required: !0 },
+  zIndex: { type: Number, default: 0 },
+  src: { type: String, required: !0 },
+  frameSource: {
+    type: Function,
+    required: !0
+  },
+  paused: { type: Boolean, default: void 0 },
+  playbackRate: { type: Number, default: void 0 },
+  controls: { type: Boolean, default: !1 },
+  controlsLayout: {
+    type: String,
+    default: "compact"
+  },
+  durationMs: { type: Number, default: void 0 },
+  loop: { type: Boolean, default: !1 },
+  maxFps: { type: Number, default: DEFAULT_MAX_FPS },
+  pixelWidth: { type: Number, default: void 0 },
+  pixelHeight: { type: Number, default: void 0 },
+  fallback: { type: String, default: "[video]" },
+  style: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 }
+}, TVideo = (0, import_vue13.defineComponent)({
+  name: "TVideo",
+  props: tVideoProps,
+  emits: {
+    frame: (_event) => !0,
+    ended: () => !0,
+    error: (_error) => !0,
+    seek: (_event) => !0,
+    "update:paused": (_paused) => !0,
+    "update:playbackRate": (_rate) => !0
+  },
+  setup(props, { emit }) {
+    let instance = (0, import_vue13.getCurrentInstance)(), { terminal, scheduler } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility({ provide: !0 }), graphicsActivity = (0, import_vue13.inject)(TerminalGraphicsActivityKey, null), frameRenderer = (0, import_vue13.shallowRef)(), playbackError = (0, import_vue13.shallowRef)(""), internalPaused = (0, import_vue13.shallowRef)(props.paused ?? !1), internalPlaybackRate = (0, import_vue13.shallowRef)(playbackRate(props.playbackRate)), discoveredDurationMs = (0, import_vue13.shallowRef)(), displayedTimestampMs = (0, import_vue13.shallowRef)(0), seekPreviewMs = (0, import_vue13.shallowRef)(), seeking = (0, import_vue13.shallowRef)(!1), terminalSizeVersion = (0, import_vue13.shallowRef)(0), graphicsOutputVersion = (0, import_vue13.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), placementKey = `TVideo:${instance?.uid ?? "unknown"}`, mailboxId = `${placementKey}:frame`, alive = !0, generation = 0, activeAbort = null, lastSourceBytes = null, lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint, lastTimestampMs = 0, droppedFrames = 0, pendingEndedGeneration = null, suppressNextVideoClick = !1, controlPointerCapture = null, unsubscribeTerminalResize = terminal.on("resize", () => {
+      terminalSizeVersion.value++;
+    }), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+    }), showControls = (0, import_vue13.computed)(
+      () => props.controls && Math.floor(props.w) >= 14 && Math.floor(props.h) >= 2
+    ), resolvedControlsLayout = (0, import_vue13.computed)(
+      () => props.controlsLayout === "cinema" && Math.floor(props.h) >= 3 ? "cinema" : "compact"
+    ), controlRows = (0, import_vue13.computed)(
+      () => showControls.value ? resolvedControlsLayout.value === "cinema" ? 2 : 1 : 0
+    ), videoHeight = (0, import_vue13.computed)(() => Math.max(1, Math.floor(props.h) - controlRows.value)), resolvedMaxFps = (0, import_vue13.computed)(() => positiveNumber(props.maxFps, DEFAULT_MAX_FPS, 60)), resolvedPixelSize = (0, import_vue13.computed)(() => {
+      let desiredWidth = Math.max(2, Math.floor(props.w) * 8), desiredHeight = Math.max(2, videoHeight.value * 16);
+      if (props.pixelWidth == null && props.pixelHeight == null) {
+        let scale = Math.min(
+          1,
+          DEFAULT_MAX_PIXEL_WIDTH / desiredWidth,
+          DEFAULT_MAX_PIXEL_HEIGHT / desiredHeight
+        );
+        return {
+          width: Math.max(2, Math.floor(desiredWidth * scale)),
+          height: Math.max(2, Math.floor(desiredHeight * scale))
+        };
+      }
+      if (props.pixelWidth != null && props.pixelHeight == null) {
+        let width = positiveInt2(props.pixelWidth, desiredWidth, MAX_PIXEL_DIMENSION), inferredHeight = width * desiredHeight / desiredWidth, scale = Math.min(1, MAX_PIXEL_DIMENSION / inferredHeight);
+        return {
+          width: Math.max(2, Math.floor(width * scale)),
+          height: Math.max(2, Math.floor(inferredHeight * scale))
+        };
+      }
+      if (props.pixelWidth == null && props.pixelHeight != null) {
+        let height = positiveInt2(props.pixelHeight, desiredHeight, MAX_PIXEL_DIMENSION), inferredWidth = height * desiredWidth / desiredHeight, scale = Math.min(1, MAX_PIXEL_DIMENSION / inferredWidth);
+        return {
+          width: Math.max(2, Math.floor(inferredWidth * scale)),
+          height: Math.max(2, Math.floor(height * scale))
+        };
+      }
+      return {
+        width: positiveInt2(props.pixelWidth, desiredWidth, MAX_PIXEL_DIMENSION),
+        height: positiveInt2(props.pixelHeight, desiredHeight, MAX_PIXEL_DIMENSION)
+      };
+    }), resolvedPixelWidth = (0, import_vue13.computed)(() => resolvedPixelSize.value.width), resolvedPixelHeight = (0, import_vue13.computed)(() => resolvedPixelSize.value.height), paintable = (0, import_vue13.computed)(() => {
+      if (terminalSizeVersion.value, !visible.value)
+        return !1;
+      let size = terminal.size(), terminalRect = {
+        x: 0,
+        y: 0,
+        w: Math.max(0, Math.floor(size.cols)),
+        h: Math.max(0, Math.floor(size.rows))
+      }, clip = layout.clipRect ? intersectRect(layout.clipRect, terminalRect) : terminalRect;
+      if (!clip)
+        return !1;
+      let rect = translateRect(
+        { x: props.x, y: props.y, w: props.w, h: videoHeight.value },
+        layout.originX,
+        layout.originY
+      ), visibleRect = intersectRect(rect, clip);
+      return !!(visibleRect && visibleRect.w > 0 && visibleRect.h > 0);
+    }), graphicsProtocol = (0, import_vue13.computed)(() => (graphicsOutputVersion.value, getTerminalGraphicsOutput(terminal)?.capabilities.preferredProtocol ?? null)), preferredFormat = (0, import_vue13.computed)(
+      () => graphicsProtocol.value === "kitty" || graphicsProtocol.value === "iterm2" ? "png" : "gray8"
+    ), resolvedDecodeFps = (0, import_vue13.computed)(
+      () => preferredFormat.value === "gray8" ? Math.min(MAX_GRAY8_FPS, resolvedMaxFps.value) : resolvedMaxFps.value
+    ), resolvedDecodeWidth = (0, import_vue13.computed)(
+      () => preferredFormat.value === "gray8" ? positiveInt2(Math.ceil(props.w / 2), 1, MAX_GRAY8_WIDTH) : resolvedPixelWidth.value
+    ), resolvedDecodeHeight = (0, import_vue13.computed)(
+      () => preferredFormat.value === "gray8" ? positiveInt2(videoHeight.value, 1, MAX_GRAY8_HEIGHT) : resolvedPixelHeight.value
+    ), resolvedDurationMs = (0, import_vue13.computed)(
+      () => optionalDuration(props.durationMs) ?? discoveredDurationMs.value
+    ), effectivePaused = (0, import_vue13.computed)(() => props.paused ?? internalPaused.value), effectivePlaybackRate = (0, import_vue13.computed)(
+      () => props.playbackRate == null ? internalPlaybackRate.value : playbackRate(props.playbackRate)
+    ), controlTimestampMs = (0, import_vue13.computed)(() => seekPreviewMs.value ?? displayedTimestampMs.value), timeHourDigits = (0, import_vue13.computed)(() => {
+      let duration = resolvedDurationMs.value;
+      return !duration || duration < 36e5 ? 0 : String(Math.floor(duration / 36e5)).length;
+    }), currentTimeText = (0, import_vue13.computed)(
+      () => formatPlaybackTime(controlTimestampMs.value, timeHourDigits.value)
+    ), durationTimeText = (0, import_vue13.computed)(
+      () => formatPlaybackTime(resolvedDurationMs.value, timeHourDigits.value)
+    ), controlLayout = (0, import_vue13.computed)(() => {
+      let width = Math.max(1, Math.floor(props.w)), progressY = videoHeight.value, current = currentTimeText.value, duration = durationTimeText.value, timeWidth = Math.max(textCellWidth(current), textCellWidth(duration)), ratesWidth = 8;
+      if (resolvedControlsLayout.value === "cinema") {
+        let ratesX2 = Math.max(3, width - ratesWidth), timeText = `${current} / ${duration}`;
+        return {
+          width,
+          kind: "cinema",
+          progressX: 0,
+          progressY,
+          progressWidth: width,
+          actionY: progressY + 1,
+          ratesX: ratesX2,
+          showAllRates: !0,
+          showTimes: 3 + textCellWidth(timeText) < ratesX2,
+          current,
+          duration,
+          timeText,
+          timeWidth,
+          currentX: 3,
+          totalX: 0
+        };
+      }
+      let ratesX = width - ratesWidth, progressX = timeWidth + 4, totalX = ratesX - timeWidth - 1, progressWidth = totalX - progressX - 1;
+      if (progressWidth >= 4)
+        return {
+          width,
+          kind: "compact",
+          progressX,
+          progressY,
+          progressWidth,
+          actionY: progressY,
+          ratesX,
+          showAllRates: !0,
+          showTimes: !0,
+          current,
+          duration,
+          timeText: "",
+          timeWidth,
+          currentX: 3,
+          totalX
+        };
+      let compactRatesX = Math.max(4, width - 2);
+      return {
+        width,
+        kind: "compact",
+        progressX: 3,
+        progressY,
+        progressWidth: Math.max(1, compactRatesX - 4),
+        actionY: progressY,
+        ratesX: compactRatesX,
+        showAllRates: !1,
+        showTimes: !1,
+        current,
+        duration,
+        timeText: "",
+        timeWidth,
+        currentX: 0,
+        totalX: 0
+      };
+    }), rateStyles = (0, import_vue13.computed)(
+      () => PLAYBACK_RATES.map(
+        (rate) => rate === effectivePlaybackRate.value ? { ...props.style, inverse: !0 } : props.style
+      )
+    ), remainingProgressStyle = (0, import_vue13.computed)(() => ({ ...props.style, dim: !0 })), progressThumbStyle = (0, import_vue13.computed)(() => ({ ...props.style, inverse: !0 })), progressSegments = (0, import_vue13.computed)(() => {
+      let { progressWidth } = controlLayout.value, duration = resolvedDurationMs.value;
+      if (!duration)
+        return { playedWidth: 0, thumbWidth: 0, remainingWidth: progressWidth };
+      let ratio = Math.max(0, Math.min(1, controlTimestampMs.value / duration)), marker = Math.round(ratio * Math.max(0, progressWidth - 1));
+      return {
+        playedWidth: marker,
+        thumbWidth: 1,
+        remainingWidth: progressWidth - marker - 1
+      };
+    }), controlFill = (0, import_vue13.computed)(() => " ".repeat(controlLayout.value.width)), progressGlyphs = (0, import_vue13.computed)(() => ({
+      played: "\u2501".repeat(progressSegments.value.playedWidth),
+      remaining: "\u2500".repeat(progressSegments.value.remainingWidth)
+    })), playbackEnabled = (0, import_vue13.computed)(
+      () => alive && !effectivePaused.value && !graphicsActivity?.scrolling.value && props.src.trim().length > 0 && paintable.value
+    ), shouldPlay = (0, import_vue13.computed)(() => playbackEnabled.value && !seeking.value), visibleFallback = (0, import_vue13.computed)(
+      () => playbackError.value ? `${props.fallback}: ${playbackError.value}` : props.fallback
+    );
+    function timelineTimestamp(timestampMs) {
+      let duration = resolvedDurationMs.value;
+      return duration ? props.loop ? Math.max(0, timestampMs) % duration : Math.max(0, Math.min(duration, timestampMs)) : Math.max(0, timestampMs);
+    }
+    function seekTimestamp(timestampMs) {
+      let duration = resolvedDurationMs.value;
+      if (!duration)
+        return Math.max(0, timestampMs);
+      let end = props.loop ? Math.max(0, duration - 1) : duration;
+      return Math.max(0, Math.min(end, timestampMs));
+    }
+    function updateTimestamp(timestampMs, force = !1) {
+      let next = timelineTimestamp(timestampMs);
+      if (lastTimestampMs = next, !showControls.value)
+        return;
+      let threshold = CONTROL_REFRESH_MS * effectivePlaybackRate.value;
+      (force || next < displayedTimestampMs.value || Math.abs(next - displayedTimestampMs.value) >= threshold) && (displayedTimestampMs.value = next);
+    }
+    function commitFrame(frame, dropped) {
+      if (!alive)
+        return;
+      droppedFrames += dropped, frameRenderer.value = (0, import_vue13.markRaw)(createFrameRenderer(frame, props.w)), updateTimestamp(frame.timestampMs);
+      let durationMs = resolvedDurationMs.value;
+      emit("frame", {
+        timestampMs: frame.timestampMs,
+        pixelWidth: frame.pixelWidth,
+        pixelHeight: frame.pixelHeight,
+        droppedFrames,
+        ...durationMs ? { durationMs } : {},
+        playbackRate: effectivePlaybackRate.value
+      });
+    }
+    let mailbox = createFrameMailbox({
+      scheduler,
+      id: mailboxId,
+      reason: "stream",
+      priority: "low",
+      apply(frame, _context, meta) {
+        commitFrame(frame, meta.dropped), pendingEndedGeneration === generation && (pendingEndedGeneration = null, emit("ended"));
+      }
+    });
+    function stopPlayback() {
+      generation++, pendingEndedGeneration = null;
+      let discardedPendingFrame = mailbox.hasPending();
+      mailbox.cancel(), discardedPendingFrame && (lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint = void 0), activeAbort?.abort(), activeAbort = null;
+    }
+    function resetQueuedFrameIdentity() {
+      lastSourceBytes = null, lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint = void 0;
+    }
+    function setPaused(paused) {
+      effectivePaused.value !== paused && (props.paused == null && (internalPaused.value = paused), emit("update:paused", paused));
+    }
+    function setPlaybackRate(rate) {
+      let next = playbackRate(rate);
+      effectivePlaybackRate.value !== next && (props.playbackRate == null && (internalPlaybackRate.value = next), emit("update:playbackRate", next));
+    }
+    function applySeek(timestampMs, restart) {
+      let parsed = Number(timestampMs);
+      if (!Number.isFinite(parsed))
+        return;
+      stopPlayback(), resetQueuedFrameIdentity();
+      let next = seekTimestamp(parsed);
+      updateTimestamp(next, !0), seekPreviewMs.value = void 0;
+      let durationMs = resolvedDurationMs.value;
+      emit("seek", {
+        timestampMs: next,
+        ...durationMs ? { durationMs } : {}
+      }), restart && startPlayback(effectivePaused.value);
+    }
+    function controlCell(event) {
+      return {
+        x: Math.floor(event.cellX - layout.originX - props.x),
+        y: Math.floor(event.cellY - layout.originY - props.y)
+      };
+    }
+    function previewSeekAt(cellX) {
+      let duration = resolvedDurationMs.value;
+      if (!duration)
+        return;
+      let { progressX, progressWidth } = controlLayout.value, offset = Math.max(0, Math.min(progressWidth - 1, cellX - progressX));
+      seekPreviewMs.value = progressWidth <= 1 ? 0 : offset / Math.max(1, progressWidth - 1) * duration;
+    }
+    function captureControlPointer(event) {
+      let native = event.nativeEvent, pointerId = native?.pointerId, target = native?.target;
+      pointerId == null || !target?.setPointerCapture || (target.setPointerCapture(pointerId), controlPointerCapture = { pointerId, target });
+    }
+    function releaseControlPointer() {
+      controlPointerCapture && (controlPointerCapture.target.releasePointerCapture?.(controlPointerCapture.pointerId), controlPointerCapture = null);
+    }
+    function rateAt(cellX) {
+      let { ratesX, showAllRates } = controlLayout.value, offset = cellX - ratesX;
+      if (!showAllRates) {
+        if (offset < 0 || offset >= 2)
+          return;
+        let index = PLAYBACK_RATES.indexOf(effectivePlaybackRate.value);
+        return PLAYBACK_RATES[(index + 1) % PLAYBACK_RATES.length];
+      }
+      if (!(offset < 0 || offset % 3 >= 2))
+        return PLAYBACK_RATES[Math.floor(offset / 3)];
+    }
+    function onInteractivePointerDown(event) {
+      if (event.button != null && event.button !== 0)
+        return;
+      let { x: cellX, y: cellY } = controlCell(event);
+      if (cellY < videoHeight.value) {
+        suppressNextVideoClick = !1;
+        return;
+      }
+      if (!showControls.value)
+        return;
+      let { actionY, progressY, progressX, progressWidth } = controlLayout.value, rate = rateAt(cellX);
+      if (cellY === actionY && cellX <= 1) {
+        event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, setPaused(!effectivePaused.value);
+        return;
+      }
+      if (cellY === actionY && rate) {
+        event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, setPlaybackRate(rate);
+        return;
+      }
+      cellY !== progressY || !resolvedDurationMs.value || cellX < progressX || cellX >= progressX + progressWidth || (event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, seeking.value = !0, stopPlayback(), previewSeekAt(cellX), captureControlPointer(event));
+    }
+    function onInteractivePointerMove(event) {
+      if (seeking.value) {
+        if (event.buttons === 0) {
+          onInteractivePointerUp(event);
+          return;
+        }
+        event.preventDefault(), event.stopPropagation(), previewSeekAt(controlCell(event).x);
+      }
+    }
+    function onInteractivePointerUp(event) {
+      if (!seeking.value)
+        return;
+      event.preventDefault(), event.stopPropagation(), previewSeekAt(controlCell(event).x);
+      let timestampMs = seekPreviewMs.value ?? lastTimestampMs;
+      applySeek(timestampMs, !1), seeking.value = !1, releaseControlPointer(), startPlayback(effectivePaused.value);
+    }
+    function onVideoClick(event) {
+      if (!(event.button != null && event.button !== 0)) {
+        if (suppressNextVideoClick) {
+          suppressNextVideoClick = !1, event.preventDefault(), event.stopPropagation();
+          return;
+        }
+        controlCell(event).y >= videoHeight.value || (event.preventDefault(), event.stopPropagation(), setPaused(!effectivePaused.value));
+      }
+    }
+    function finishControlSeek() {
+      if (!seeking.value)
+        return;
+      let timestampMs = seekPreviewMs.value ?? lastTimestampMs;
+      applySeek(timestampMs, !1), seeking.value = !1, releaseControlPointer(), startPlayback(effectivePaused.value);
+    }
+    function onControlKeydown(event) {
+      if (event.key === "Enter" || event.key === " " || event.key === "Spacebar") {
+        event.preventDefault(), event.stopPropagation(), setPaused(!effectivePaused.value);
+        return;
+      }
+      if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+        event.preventDefault(), event.stopPropagation();
+        let index = PLAYBACK_RATES.indexOf(effectivePlaybackRate.value), offset = event.key === "ArrowUp" ? 1 : -1;
+        setPlaybackRate(PLAYBACK_RATES[Math.max(0, Math.min(2, index + offset))]);
+        return;
+      }
+      if (!event.repeat && (event.key === "Home" || event.key === "End") && resolvedDurationMs.value) {
+        event.preventDefault(), event.stopPropagation(), applySeek(event.key === "Home" ? 0 : resolvedDurationMs.value, !0);
+        return;
+      }
+      (event.key === "1" || event.key === "2" || event.key === "3") && (event.preventDefault(), event.stopPropagation(), setPlaybackRate(Number(event.key)));
+    }
+    function queueFrame(frame, expectedFormat) {
+      let normalized = normalizeFrame(frame);
+      if (normalized.format !== expectedFormat)
+        throw new Error(`TVideo frame source did not provide requested ${expectedFormat} frames`);
+      normalized.durationMs != null && normalized.durationMs !== discoveredDurationMs.value && (discoveredDurationMs.value = normalized.durationMs), normalized = { ...normalized, timestampMs: timelineTimestamp(normalized.timestampMs) };
+      let sourceBytes = frameBytes(normalized), reusesSourceBuffer = sourceBytes === lastSourceBytes;
+      lastSourceBytes = sourceBytes;
+      let stableFrame = reusesSourceBuffer ? normalized.format === "gray8" ? { ...normalized, pixels: new Uint8Array(normalized.pixels) } : { ...normalized, png: new Uint8Array(normalized.png) } : normalized, bytes = frameBytes(stableFrame), sameFingerprint = normalized.format === lastQueuedFormat && normalized.fingerprint != null && lastQueuedFingerprint != null && normalized.fingerprint === lastQueuedFingerprint, canCompareBytes = normalized.fingerprint == null && lastQueuedFingerprint == null && !reusesSourceBuffer;
+      if (sameFingerprint || canCompareBytes && normalized.format === lastQueuedFormat && lastQueuedBytes && sameBytes(lastQueuedBytes, sourceBytes)) {
+        lastQueuedBytes = bytes, lastQueuedFormat = normalized.format, lastQueuedFingerprint = normalized.fingerprint, updateTimestamp(normalized.timestampMs), mailbox.hasPending() && mailbox.replacePending(stableFrame);
+        return;
+      }
+      lastQueuedBytes = bytes, lastQueuedFormat = normalized.format, lastQueuedFingerprint = normalized.fingerprint, mailbox.queue(stableFrame) || (commitFrame(stableFrame, 0), scheduler.invalidate({ priority: "low", reason: "stream" }));
+    }
+    function startPlayback(oneFrame = !1) {
+      if (stopPlayback(), !shouldPlay.value && !(oneFrame && alive && props.src.trim().length > 0 && paintable.value && !graphicsActivity?.scrolling.value))
+        return;
+      let currentGeneration = generation, abort = new AbortController();
+      activeAbort = abort, playbackError.value = "";
+      let source = props.frameSource, format = preferredFormat.value, context = {
+        src: props.src,
+        signal: abort.signal,
+        maxFps: resolvedDecodeFps.value,
+        pixelWidth: resolvedDecodeWidth.value,
+        pixelHeight: resolvedDecodeHeight.value,
+        startAtMs: lastTimestampMs,
+        preferredFormat: format,
+        playbackRate: effectivePlaybackRate.value,
+        loop: props.loop
+      };
+      (async () => {
+        try {
+          let frames = await source(context);
+          for await (let frame of frames)
+            if (!alive || abort.signal.aborted || currentGeneration !== generation || (queueFrame(frame, format), oneFrame))
+              return;
+          if (!alive || abort.signal.aborted || currentGeneration !== generation)
+            return;
+          mailbox.hasPending() ? pendingEndedGeneration = currentGeneration : emit("ended");
+        } catch (error) {
+          if (!alive || abort.signal.aborted || currentGeneration !== generation)
+            return;
+          playbackError.value = errorMessage2(error), emit("error", error), scheduler.invalidate({ priority: "low", reason: "data" });
+        } finally {
+          activeAbort === abort && (activeAbort = null);
+        }
+      })();
+    }
+    return (0, import_vue13.watch)(
+      () => props.paused,
+      (paused) => {
+        paused != null && (internalPaused.value = paused);
+      }
+    ), (0, import_vue13.watch)(
+      () => props.playbackRate,
+      (rate) => {
+        rate != null && (internalPlaybackRate.value = playbackRate(rate));
+      }
+    ), (0, import_vue13.watch)(
+      [
+        () => props.src,
+        () => props.frameSource,
+        playbackEnabled,
+        resolvedDecodeFps,
+        resolvedDecodeWidth,
+        resolvedDecodeHeight,
+        preferredFormat,
+        effectivePlaybackRate,
+        () => props.loop
+      ],
+      (next, previous) => {
+        let sourceChanged = !previous || next[0] !== previous[0] || next[1] !== previous[1], formatChanged = !previous || next[6] !== previous[6];
+        (sourceChanged || formatChanged) && (resetQueuedFrameIdentity(), sourceChanged && (lastTimestampMs = 0, displayedTimestampMs.value = 0, discoveredDurationMs.value = void 0, seekPreviewMs.value = void 0, seeking.value = !1, suppressNextVideoClick = !1, releaseControlPointer(), droppedFrames = 0), playbackError.value = "", frameRenderer.value = void 0), startPlayback();
+      },
+      { immediate: !0, flush: "post" }
+    ), (0, import_vue13.onBeforeUnmount)(() => {
+      alive = !1, stopPlayback(), releaseControlPointer(), mailbox.dispose(), unsubscribeTerminalResize(), unsubscribeGraphicsOutput();
+    }), () => {
+      let children = [
+        (0, import_vue13.h)(TAgentTerminalGraphic, {
+          x: props.x,
+          y: props.y,
+          w: props.w,
+          h: videoHeight.value,
+          zIndex: props.zIndex,
+          content: props.src.trim() ? props.src : "video",
+          fallback: visibleFallback.value,
+          style: props.style,
+          clear: props.clear,
+          final: !1,
+          streaming: !0,
+          renderer: frameRenderer.value,
+          placementKey,
+          preserveRawWhileRendering: !0,
+          ignoreSamePlaneRawCoverage: !0,
+          suspended: !paintable.value
+        })
+      ];
+      return props.controls && children.push(
+        (0, import_vue13.h)(
+          TView,
+          {
+            x: props.x,
+            y: props.y,
+            w: Math.max(0, Math.floor(props.w)),
+            h: Math.max(0, Math.floor(props.h)),
+            zIndex: props.zIndex,
+            focusable: !0,
+            selectable: !1,
+            onClick: onVideoClick,
+            onPointerdown: onInteractivePointerDown,
+            onPointermove: onInteractivePointerMove,
+            onPointerup: onInteractivePointerUp,
+            onKeydown: onControlKeydown,
+            onBlur: finishControlSeek
+          },
+          () => {
+            if (!showControls.value)
+              return [];
+            let layout2 = controlLayout.value, segments = progressSegments.value, controls = Array.from(
+              { length: controlRows.value },
+              (_, index) => (0, import_vue13.h)(TText, {
+                x: 0,
+                y: videoHeight.value + index,
+                w: layout2.width,
+                value: controlFill.value,
+                style: props.style
+              })
+            );
+            return controls.push(
+              (0, import_vue13.h)(TText, {
+                x: 0,
+                y: layout2.actionY,
+                w: 2,
+                value: effectivePaused.value ? "> " : "||",
+                style: props.style
+              })
+            ), layout2.showTimes && (layout2.kind === "cinema" ? controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.currentX,
+                y: layout2.actionY,
+                w: textCellWidth(layout2.timeText),
+                value: layout2.timeText,
+                style: props.style
+              })
+            ) : controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.currentX,
+                y: layout2.actionY,
+                w: layout2.timeWidth,
+                value: layout2.current,
+                style: props.style
+              }),
+              (0, import_vue13.h)(TText, {
+                x: layout2.totalX,
+                y: layout2.actionY,
+                w: layout2.timeWidth,
+                value: layout2.duration,
+                style: props.style
+              })
+            )), segments.playedWidth > 0 && controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.progressX,
+                y: layout2.progressY,
+                w: segments.playedWidth,
+                value: progressGlyphs.value.played,
+                style: props.style
+              })
+            ), segments.thumbWidth > 0 && controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.progressX + segments.playedWidth,
+                y: layout2.progressY,
+                w: 1,
+                value: "\u254B",
+                style: progressThumbStyle.value
+              })
+            ), segments.remainingWidth > 0 && controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.progressX + segments.playedWidth + segments.thumbWidth,
+                y: layout2.progressY,
+                w: segments.remainingWidth,
+                value: progressGlyphs.value.remaining,
+                style: remainingProgressStyle.value
+              })
+            ), layout2.showAllRates ? controls.push(
+              ...PLAYBACK_RATES.map(
+                (rate, index) => (0, import_vue13.h)(TText, {
+                  x: layout2.ratesX + index * 3,
+                  y: layout2.actionY,
+                  w: 2,
+                  value: `${rate}x`,
+                  style: rateStyles.value[index]
+                })
+              )
+            ) : controls.push(
+              (0, import_vue13.h)(TText, {
+                x: layout2.ratesX,
+                y: layout2.actionY,
+                w: 2,
+                value: `${effectivePlaybackRate.value}x`,
+                style: rateStyles.value[PLAYBACK_RATES.indexOf(effectivePlaybackRate.value)]
+              })
+            ), controls;
+          }
+        )
+      ), (0, import_vue13.h)("span", rootProps, children);
+    };
+  }
+});
+
+// src/vue/components/T3DViewport.ts
+var DEFAULT_MAX_FPS2 = 24, DEFAULT_AUTO_ROTATE_SPEED = 0.35, DEFAULT_POINTER_SENSITIVITY = 0.055, VELOCITY_DAMPING_PER_SECOND = 5.5, ZOOM_DAMPING_PER_SECOND = 7, MAX_ZOOM_VELOCITY = 3, DEFAULT_MIN_ZOOM = 0.65, DEFAULT_MAX_ZOOM = 1.65, DEFAULT_ZOOM_SENSITIVITY = 0.1, MAX_PITCH = Math.PI * 0.42, t3DViewportProps = {
+  /** Horizontal position in terminal cells. */
+  x: { type: Number, required: !0 },
+  /** Vertical position in terminal cells. */
+  y: { type: Number, required: !0 },
+  /** Width in terminal cells. */
+  w: { type: Number, required: !0 },
+  /** Height in terminal cells. */
+  h: { type: Number, required: !0 },
+  /** Paint and pointer hit-test stacking order. */
+  zIndex: { type: Number, default: 0 },
+  /** Pull renderer captured at mount; remount the component to replace it. */
+  renderer: { type: Object, required: !0 },
+  /** Stops frame pulling while true. */
+  paused: { type: Boolean, default: !1 },
+  /** Maximum requested frames per second. */
+  maxFps: { type: Number, default: DEFAULT_MAX_FPS2 },
+  /** Requested source width in pixels; TVideo may adapt it for ASCII output. */
+  pixelWidth: { type: Number, default: void 0 },
+  /** Requested source height in pixels; TVideo may adapt it for ASCII output. */
+  pixelHeight: { type: Number, default: void 0 },
+  /** Text displayed before a frame is available or after rendering fails. */
+  fallback: { type: String, default: "[3D viewport]" },
+  /** Terminal style applied to fallback and ASCII output. */
+  style: { type: Object, default: void 0 },
+  /** Clears cells underneath each video frame. */
+  clear: { type: Boolean, default: !0 },
+  /** Enables pointer orbit, wheel zoom, and hover motion tracking. */
+  interactive: { type: Boolean, default: !0 },
+  /** Initial yaw angle in radians, also restored by resetMotion(). */
+  initialYaw: { type: Number, default: 0 },
+  /** Initial pitch angle in radians, also restored by resetMotion(). */
+  initialPitch: { type: Number, default: 0 },
+  /** Enables continuous yaw rotation when not dragging. */
+  autoRotate: { type: Boolean, default: !0 },
+  /** Automatic yaw rotation speed in radians per second. */
+  autoRotateSpeed: { type: Number, default: DEFAULT_AUTO_ROTATE_SPEED },
+  /** Drag sensitivity in radians per terminal cell. */
+  pointerSensitivity: { type: Number, default: DEFAULT_POINTER_SENSITIVITY },
+  /** Initial camera zoom, also restored by resetMotion(). */
+  initialZoom: { type: Number, default: 1 },
+  /** Minimum camera zoom accepted from wheel and trackpad gestures. */
+  minZoom: { type: Number, default: DEFAULT_MIN_ZOOM },
+  /** Maximum camera zoom accepted from wheel and trackpad gestures. */
+  maxZoom: { type: Number, default: DEFAULT_MAX_ZOOM },
+  /** Zoom impulse per normalized wheel or trackpad unit. */
+  zoomSensitivity: { type: Number, default: DEFAULT_ZOOM_SENSITIVITY }
+};
+function finite(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function clampPitch(value) {
+  return Math.max(-MAX_PITCH, Math.min(MAX_PITCH, value));
+}
+function zoomBounds(minZoom, maxZoom) {
+  let first = Math.max(0.01, finite(minZoom, DEFAULT_MIN_ZOOM)), second = Math.max(0.01, finite(maxZoom, DEFAULT_MAX_ZOOM));
+  return first <= second ? { min: first, max: second } : { min: second, max: first };
+}
+function clampZoom(value, minZoom, maxZoom) {
+  let { min, max } = zoomBounds(minZoom, maxZoom);
+  return Math.max(min, Math.min(max, finite(value, 1)));
+}
+function normalizedWheelDelta(event) {
+  let deltaY = Number(event.deltaY ?? 0);
+  return !Number.isFinite(deltaY) || deltaY === 0 ? 0 : event.deltaMode === 1 ? deltaY : event.deltaMode === 2 ? Math.max(-3, Math.min(3, deltaY * 3)) : event.deltaMode === 0 ? deltaY / 100 : Number.isInteger(deltaY) && Math.abs(deltaY) <= 3 ? deltaY : deltaY / 100;
+}
+function nowMs() {
+  return typeof performance < "u" ? performance.now() : Date.now();
+}
+function abortError() {
+  let error = new Error("T3D viewport render aborted");
+  return error.name = "AbortError", error;
+}
+function warnDev(message) {
+  globalThis.process?.env?.NODE_ENV !== "production" && console.warn(message);
+}
+function waitFor(ms, signal) {
+  return signal.aborted || ms <= 0 ? Promise.resolve() : new Promise((resolve) => {
+    let timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer), signal.removeEventListener("abort", done), resolve();
+    }
+    signal.addEventListener("abort", done, { once: !0 });
+  });
+}
+var T3DViewport = (0, import_vue14.defineComponent)({
+  name: "T3DViewport",
+  props: t3DViewportProps,
+  emits: {
+    /** A frame was committed by TVideo. */
+    frame: (_event) => !0,
+    /** Rendering or frame processing failed. */
+    error: (_error) => !0,
+    /** Hovered renderer object changed, or cleared to null. */
+    objecthover: (_hit) => !0,
+    /** Click-locked renderer object changed, or cleared to null. */
+    objectselect: (_hit) => !0
+  },
+  setup(props, { emit, expose }) {
+    let layout = useLayout(), renderer = props.renderer, alive = !0, yaw = finite(props.initialYaw, 0), pitch = clampPitch(finite(props.initialPitch, 0)), yawVelocity = 0, pitchVelocity = 0, pointerX = 0, pointerY = 0, pointerSpeed = 0, hovering = !1, zoom = clampZoom(props.initialZoom, props.minZoom, props.maxZoom), zoomVelocity = 0, hoveredObject = null, selectedObject = null, actualPixelWidth = Math.max(1, Math.floor(props.pixelWidth ?? props.w)), actualPixelHeight = Math.max(1, Math.floor(props.pixelHeight ?? props.h)), pointer = null, drag = null, renderTail = Promise.resolve();
+    function motionSnapshot() {
+      return {
+        yaw,
+        pitch,
+        yawVelocity,
+        pitchVelocity,
+        pointerX,
+        pointerY,
+        pointerSpeed,
+        hovering,
+        zoom,
+        zoomVelocity,
+        hoveredObjectId: hoveredObject?.objectId ?? null,
+        selectedObjectId: selectedObject?.objectId ?? null
+      };
+    }
+    async function renderFrame(context) {
+      let previous = renderTail, release = () => {
+      };
+      renderTail = new Promise((resolve) => {
+        release = resolve;
+      }), await previous;
+      try {
+        if (!alive || context.signal.aborted)
+          throw abortError();
+        return await renderer.render(context);
+      } finally {
+        release();
+      }
+    }
+    function sameHit(left, right) {
+      return left?.objectId === right?.objectId;
+    }
+    function setHoveredObject(hit) {
+      sameHit(hoveredObject, hit) || (hoveredObject = hit, emit("objecthover", hit));
+    }
+    function setSelectedObject(hit) {
+      sameHit(selectedObject, hit) || (selectedObject = hit, emit("objectselect", hit));
+    }
+    function resetMotion() {
+      yaw = finite(props.initialYaw, 0), pitch = clampPitch(finite(props.initialPitch, 0)), yawVelocity = 0, pitchVelocity = 0, pointerX = 0, pointerY = 0, pointerSpeed = 0, zoom = clampZoom(props.initialZoom, props.minZoom, props.maxZoom), zoomVelocity = 0, setHoveredObject(null), setSelectedObject(null), pointer = null, drag = null;
+    }
+    expose({ resetMotion });
+    function localCell(event) {
+      return {
+        x: Math.floor(event.cellX - layout.originX - props.x),
+        y: Math.floor(event.cellY - layout.originY - props.y)
+      };
+    }
+    function eventTime(event) {
+      return Number.isFinite(event.timeStamp) ? event.timeStamp : nowMs();
+    }
+    function updatePointerPosition(point) {
+      let width = Math.max(1, Math.floor(props.w)), height = Math.max(1, Math.floor(props.h));
+      pointerX = Math.max(-1, Math.min(1, (point.x + 0.5) / width * 2 - 1)), pointerY = Math.max(-1, Math.min(1, (point.y + 0.5) / height * 2 - 1));
+    }
+    function hitTest() {
+      if (!renderer.hitTest)
+        return null;
+      try {
+        return renderer.hitTest({
+          pointerX,
+          pointerY,
+          pixelWidth: actualPixelWidth,
+          pixelHeight: actualPixelHeight,
+          cellWidth: Math.max(1, Math.floor(props.w)),
+          cellHeight: Math.max(1, Math.floor(props.h)),
+          motion: motionSnapshot()
+        });
+      } catch (error) {
+        return emit("error", error), null;
+      }
+    }
+    function updateHoveredObject() {
+      renderer.hitTest && setHoveredObject(hitTest());
+    }
+    function onPointerEnter(event) {
+      if (!props.interactive)
+        return;
+      let point = localCell(event);
+      hovering = !0, updatePointerPosition(point), pointer = { ...point, timeMs: eventTime(event) }, updateHoveredObject();
+    }
+    function onPointerDown(event) {
+      if (!props.interactive || event.button != null && event.button !== 0)
+        return;
+      event.preventDefault(), event.stopPropagation();
+      let point = localCell(event), timeMs = eventTime(event);
+      hovering = !0, updatePointerPosition(point), yawVelocity = 0, pitchVelocity = 0, pointerSpeed = 0, pointer = { ...point, timeMs }, drag = { ...point, timeMs, moved: !1 }, updateHoveredObject();
+    }
+    function onPointerMove(event) {
+      if (!props.interactive)
+        return;
+      hovering = !0;
+      let point = localCell(event);
+      updatePointerPosition(point);
+      let timeMs = eventTime(event), previous = drag ?? pointer;
+      if (pointer = { ...point, timeMs }, !previous)
+        return;
+      let dtMs = Math.max(1, timeMs - previous.timeMs), dx = point.x - previous.x, dy = point.y - previous.y, sensitivity = finite(props.pointerSensitivity, DEFAULT_POINTER_SENSITIVITY), deltaYaw = dx * sensitivity, deltaPitch = dy * sensitivity;
+      if (pointerSpeed = Math.hypot(dx, dy) * 1e3 / dtMs, !drag) {
+        if (renderer.hitTest) {
+          yawVelocity = 0, pitchVelocity = 0, updateHoveredObject();
+          return;
+        }
+        yawVelocity = deltaYaw * 650 / dtMs, pitchVelocity = deltaPitch * 450 / dtMs;
         return;
-      let manager = events.value, nodeId = eventNode.id.value;
-      !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
-    }), (0, import_vue9.watch)(
-      () => visible.value,
-      (nextVisible) => {
-        nextVisible || cancelWheelScrollFrame();
       }
-    ), (0, import_vue9.onBeforeUnmount)(() => {
-      alive = !1, pendingWheelTop = null, resetWheelScrollState(wheelState), wheelMailbox.dispose(), terminalGraphicsActivity.dispose();
-    });
-    function viewportRows() {
-      let r = normalizedRect(), rows = [];
-      for (let y = r.y; y < r.y + r.h; y++)
-        rows.push(y);
-      return rows;
+      if (event.buttons === 0) {
+        drag = null;
+        return;
+      }
+      event.preventDefault(), event.stopPropagation(), yaw += deltaYaw, pitch = clampPitch(pitch + deltaPitch), yawVelocity = deltaYaw * 1e3 / dtMs, pitchVelocity = deltaPitch * 1e3 / dtMs, setHoveredObject(null), drag = { ...point, timeMs, moved: drag.moved || dx !== 0 || dy !== 0 };
     }
-    function unionDirtyRows(nextRows) {
-      if (!dirtyRowsHint?.length)
-        return nextRows.slice().sort((a, b) => a - b);
-      let rows = new Set(dirtyRowsHint);
-      for (let y of nextRows)
-        rows.add(y);
-      return Array.from(rows).sort((a, b) => a - b);
+    function onPointerUp(event) {
+      if (!drag)
+        return;
+      event.preventDefault(), event.stopPropagation();
+      let moved = drag.moved;
+      if (drag = null, !moved && renderer.hitTest) {
+        let hit = hitTest();
+        setHoveredObject(hit), setSelectedObject(hit);
+      } else
+        updateHoveredObject();
     }
-    function markRowsDirty(nextRows) {
-      return hasPaintableViewport() ? (dirtyRowsHint = unionDirtyRows(nextRows), renderNodeId && render.markDirtyRows(renderNodeId, dirtyRowsHint) ? !0 : (dirtyRowsHint = void 0, !1)) : !1;
+    function onPointerLeave(event) {
+      drag && (event.preventDefault(), event.stopPropagation(), drag = null), hovering = !1, pointer = null, setHoveredObject(null);
     }
-    function markViewportDirty() {
-      return markRowsDirty(viewportRows());
+    function onWheel(event) {
+      if (!props.interactive)
+        return;
+      let delta = normalizedWheelDelta(event), sensitivity = Math.max(0, finite(props.zoomSensitivity, DEFAULT_ZOOM_SENSITIVITY));
+      delta === 0 || sensitivity === 0 || (event.preventDefault(), event.stopPropagation(), zoomVelocity = Math.max(
+        -MAX_ZOOM_VELOCITY,
+        Math.min(MAX_ZOOM_VELOCITY, zoomVelocity - delta * sensitivity * 6)
+      ));
     }
-    function applyScrollTop(nextTop, options) {
-      let controlled = isScrollControlled(), r = normalizedRect(), full = normalizedFullRect();
-      if (r.h <= 0 || full.h <= 0)
-        return { changed: !1, dirty: !1, top: scrollTop.value, controlled };
-      let clampedTop = clampScrollTop(nextTop), delta = clampedTop - scrollTop.value;
-      if (!delta)
-        return { changed: !1, dirty: !1, top: scrollTop.value, controlled };
-      if (controlled)
-        return terminalGraphicsActivity.markScroll(), (options?.emitUpdate ?? !0) && emit("update:scrollTop", clampedTop), options?.emitScroll && emit("scroll", clampedTop), { changed: !0, dirty: !1, top: clampedTop, controlled };
-      terminalGraphicsActivity.markScroll(), scrollTop.value = clampedTop, options?.emitUpdate && emit("update:scrollTop", clampedTop);
-      let canUseTerminalRowScroll = rendererCapabilities.value.scrollOperations && rendererCapabilities.value.domRows !== !0, scrollPlan = prepareUnsafeFullRowScroll({
-        render,
-        plane: plane.value,
-        rect: r,
-        terminalSize: terminal.size(),
-        delta,
-        rowScrollMode: props.rowScrollMode,
-        rendererCapabilities: {
-          scrollOperations: canUseTerminalRowScroll
-        },
-        isClipped: isClipped(),
-        hasPendingDirtyRows: !!dirtyRowsHint?.length,
-        strategy: options?.strategy ?? "viewport-repaint"
-      }), dirty = !1;
-      return scrollPlan && markRowsDirty(scrollPlan.exposedRows) ? (scrollPlan.apply(), dirty = !0) : dirty = markViewportDirty(), options?.emitScroll && emit("scroll", clampedTop), options?.priority && dirty && invalidateSelf(options.priority, options.reason ?? "scroll"), { changed: !0, dirty, top: clampedTop, controlled };
+    function advanceZoom(deltaMs) {
+      if (deltaMs <= 0 || zoomVelocity === 0)
+        return;
+      let dt = Math.min(deltaMs, 100) / 1e3, next = zoom + zoomVelocity * dt;
+      if (zoom = clampZoom(next, props.minZoom, props.maxZoom), zoom !== next) {
+        zoomVelocity = 0;
+        return;
+      }
+      zoomVelocity *= Math.exp(-ZOOM_DAMPING_PER_SECOND * dt), Math.abs(zoomVelocity) < 1e-3 && (zoomVelocity = 0);
     }
-    let renderNode = useRenderNode(() => ({
-      zIndex: props.zIndex,
-      rect: visible.value ? normalizedRect() : { x: 0, y: 0, w: 0, h: 0 },
-      deps: [
-        visible.value,
-        absRect.value,
-        fullRect.value,
-        itemCount.value,
-        props.itemVersion,
-        props.getItem,
-        props.renderItem,
-        active.value,
-        focused.value,
-        props.style,
-        props.activeStyle,
-        defaultStyle.value
-      ],
-      paint: (dirtyRows) => {
-        if (dirtyRowsHint = void 0, !visible.value)
-          return;
-        let r = normalizedRect(), full = normalizedFullRect();
-        if (r.w <= 0 || r.h <= 0)
-          return;
-        let base = props.style ?? defaultStyle.value, activeStyle = props.activeStyle ?? defaultActiveStyle(base), top = visibleWindow.value.top, { x: clipX, y: clipY } = clipOffsets(), paintRow = (y) => {
-          if (y < r.y || y >= r.y + r.h)
-            return;
-          let idx = top + clipY + (y - r.y), fullLine = formatInlineCellLine(
-            idx >= 0 && idx < itemCount.value ? itemText(idx) : "",
-            full.w
-          ), line = padEndByCells(sliceByCellsRange(fullLine, clipX, clipX + r.w), r.w), style = idx >= 0 && idx < itemCount.value && idx === active.value ? activeStyle : base;
-          terminal.write(line, { x: r.x, y, style });
-        }, rows = dirtyRows;
-        if (rows?.length) {
-          for (let y of rows)
-            paintRow(y);
+    function advanceMotion(deltaMs) {
+      if (deltaMs <= 0 || (advanceZoom(deltaMs), drag))
+        return;
+      let dt = Math.min(deltaMs, 100) / 1e3;
+      if (hovering && !renderer.hitTest) {
+        let targetPitch = clampPitch(-pointerY * 0.36);
+        pitchVelocity += (targetPitch - pitch) * 4.5 * dt;
+      } else
+        hovering || (pointerX *= Math.exp(-7 * dt), pointerY *= Math.exp(-7 * dt));
+      yaw += yawVelocity * dt, pitch = clampPitch(pitch + pitchVelocity * dt);
+      let inspectingObject = !!(renderer.hitTest && (hoveredObject || selectedObject));
+      if (props.autoRotate && !inspectingObject) {
+        let baseSpeed = finite(props.autoRotateSpeed, DEFAULT_AUTO_ROTATE_SPEED), steering = hovering ? 0.85 + pointerX * 1.75 : 1;
+        yaw += baseSpeed * steering * dt;
+      }
+      let decay = Math.exp(-VELOCITY_DAMPING_PER_SECOND * dt);
+      yawVelocity *= decay, pitchVelocity *= decay, pointerSpeed *= decay;
+    }
+    let frameSource = async function* (videoContext) {
+      let startedAt = nowMs(), previousAt = startedAt, frame = 0, frameIntervalMs = 1e3 / Math.max(1, finite(videoContext.maxFps, DEFAULT_MAX_FPS2));
+      for (; alive && !videoContext.signal.aborted; ) {
+        let pulledAt = nowMs(), deltaMs = frame === 0 ? 0 : Math.max(0, pulledAt - previousAt);
+        advanceMotion(deltaMs), actualPixelWidth = videoContext.pixelWidth, actualPixelHeight = videoContext.pixelHeight;
+        let result = await renderFrame({
+          timeMs: Math.max(0, pulledAt - startedAt),
+          deltaMs,
+          frame,
+          pixelWidth: videoContext.pixelWidth,
+          pixelHeight: videoContext.pixelHeight,
+          format: videoContext.preferredFormat,
+          signal: videoContext.signal,
+          motion: motionSnapshot()
+        });
+        if (!alive || videoContext.signal.aborted)
           return;
-        }
-        for (let y = r.y; y < r.y + r.h; y++)
-          paintRow(y);
+        yield result, frame++, previousAt = pulledAt, await waitFor(frameIntervalMs - (nowMs() - pulledAt), videoContext.signal);
       }
-    }));
-    return (0, import_vue9.watchEffect)(() => {
-      renderNodeId = renderNode.id.value;
-    }), () => (0, import_vue9.h)("span", rootProps);
+    };
+    return (0, import_vue14.watch)(
+      () => props.renderer,
+      (next) => {
+        next !== renderer && warnDev("[vue-tui] T3DViewport renderer is init-only. Remount T3DViewport to replace it.");
+      }
+    ), (0, import_vue14.watch)(
+      () => props.interactive,
+      (interactive) => {
+        interactive || (hovering = !1, pointer = null, drag = null, setHoveredObject(null), setSelectedObject(null));
+      }
+    ), (0, import_vue14.onBeforeUnmount)(() => {
+      alive = !1, pointer = null, drag = null;
+    }), (0, import_vue14.onUnmounted)(() => renderer.dispose?.()), () => (0, import_vue14.h)("span", [
+      (0, import_vue14.h)(TVideo, {
+        x: props.x,
+        y: props.y,
+        w: props.w,
+        h: props.h,
+        zIndex: props.zIndex,
+        src: "t3d://viewport",
+        frameSource,
+        paused: props.paused,
+        maxFps: props.maxFps,
+        pixelWidth: props.pixelWidth,
+        pixelHeight: props.pixelHeight,
+        fallback: props.fallback,
+        style: props.style,
+        clear: props.clear,
+        onFrame: (event) => emit("frame", event),
+        onError: (error) => emit("error", error)
+      }),
+      props.interactive ? (0, import_vue14.h)(TView, {
+        x: props.x,
+        y: props.y,
+        w: Math.max(0, Math.floor(props.w)),
+        h: Math.max(0, Math.floor(props.h)),
+        zIndex: props.zIndex + 1,
+        selectable: !1,
+        onPointerenter: onPointerEnter,
+        onPointermove: onPointerMove,
+        onPointerleave: onPointerLeave,
+        onPointerdown: onPointerDown,
+        onPointerup: onPointerUp,
+        onWheel
+      }) : null
+    ]);
   }
 });
 
 // src/vue/components/TCharts.ts
-var import_vue10 = require("vue");
+var import_vue15 = require("vue");
 
 // src/vue/components/simple-utils.ts
 function mergeStyle(...styles) {
@@ -2271,7 +5057,7 @@ function chooseTooltipPlacement(cells, width, height, anchorX, anchorY, textWidt
 }
 function useChartVisibleRect(props, size) {
   let layout = useLayout();
-  return (0, import_vue10.computed)(() => {
+  return (0, import_vue15.computed)(() => {
     let full = translateRect(
       {
         x: Math.floor(props.x),
@@ -2353,7 +5139,7 @@ function createSurface(width, height, clearStyle, cells) {
   return { width, height, clearStyle, rows };
 }
 function useChartRender(props, surface, options) {
-  let { terminal } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue10.inject)(EventZIndexContextKey, (0, import_vue10.computed)(() => 0)), eventZ = (0, import_vue10.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue10.computed)(
+  let { terminal } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue15.inject)(EventZIndexContextKey, (0, import_vue15.computed)(() => 0)), eventZ = (0, import_vue15.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue15.computed)(
     () => translateRect(
       {
         x: Math.floor(props.x),
@@ -2364,10 +5150,10 @@ function useChartRender(props, surface, options) {
       layout.originX,
       layout.originY
     )
-  ), absRect = (0, import_vue10.computed)(() => {
+  ), absRect = (0, import_vue15.computed)(() => {
     let translated = fullRect.value;
     return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
-  }), dirtyRowsHint = (0, import_vue10.computed)(() => {
+  }), dirtyRowsHint = (0, import_vue15.computed)(() => {
     if (!visible.value)
       return [];
     let r = absRect.value;
@@ -2414,7 +5200,7 @@ function useChartRender(props, surface, options) {
       for (let y of dirtyRows)
         paintRow(y);
     }
-  })), () => (0, import_vue10.h)("span", rootProps);
+  })), () => (0, import_vue15.h)("span", rootProps);
 }
 function positiveHeatmapStyle(value, max, styles) {
   if (!styles.length)
@@ -2424,7 +5210,7 @@ function positiveHeatmapStyle(value, max, styles) {
   let ratio = Math.max(0, Math.min(1, value / max)), index = Math.max(0, Math.min(styles.length - 1, Math.ceil(ratio * styles.length) - 1));
   return styles[index] ?? {};
 }
-var TContributionGraph = (0, import_vue10.defineComponent)({
+var TContributionGraph = (0, import_vue15.defineComponent)({
   name: "TContributionGraph",
   props: {
     /** Left position in terminal cells. */
@@ -2471,7 +5257,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
     style: { type: Object, default: void 0 }
   },
   setup(props) {
-    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue10.computed)(() => mergeStyle(defaultStyle.value, props.style)), hoverPointer = (0, import_vue10.ref)(null), graphLayout = (0, import_vue10.computed)(() => {
+    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue15.computed)(() => mergeStyle(defaultStyle.value, props.style)), hoverPointer = (0, import_vue15.ref)(null), graphLayout = (0, import_vue15.computed)(() => {
       let rowCount = cellCount(props.rows, 7);
       if (rowCount <= 0)
         return {
@@ -2506,7 +5292,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
       let label = props.labels?.[index] ?? `#${index + 1}`;
       return { x: cellX, y: localY, index, value, label };
     }
-    let surface = (0, import_vue10.computed)(() => {
+    let surface = (0, import_vue15.computed)(() => {
       let current = graphLayout.value;
       if (current.rowCount <= 0)
         return createSurface(0, 0, baseStyle.value, []);
@@ -2556,7 +5342,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
       })
     });
   }
-}), TLineChart = (0, import_vue10.defineComponent)({
+}), TLineChart = (0, import_vue15.defineComponent)({
   name: "TLineChart",
   props: {
     /** Left position in terminal cells. */
@@ -2606,7 +5392,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
     tooltipStyle: { type: Object, default: () => ({ fg: "whiteBright" }) }
   },
   setup(props) {
-    let { defaultStyle } = useTerminal(), clearStyle = (0, import_vue10.computed)(() => mergeStyle(defaultStyle.value, props.style)), lineStyle = (0, import_vue10.computed)(() => mergeStyle(clearStyle.value, props.lineStyle)), axisStyle = (0, import_vue10.computed)(() => mergeStyle(clearStyle.value, props.axisStyle)), labelStyle = (0, import_vue10.computed)(() => mergeStyle(clearStyle.value, props.labelStyle)), hoverPointer = (0, import_vue10.ref)(null), lineLayout = (0, import_vue10.computed)(() => {
+    let { defaultStyle } = useTerminal(), clearStyle = (0, import_vue15.computed)(() => mergeStyle(defaultStyle.value, props.style)), lineStyle = (0, import_vue15.computed)(() => mergeStyle(clearStyle.value, props.lineStyle)), axisStyle = (0, import_vue15.computed)(() => mergeStyle(clearStyle.value, props.axisStyle)), labelStyle = (0, import_vue15.computed)(() => mergeStyle(clearStyle.value, props.labelStyle)), hoverPointer = (0, import_vue15.ref)(null), lineLayout = (0, import_vue15.computed)(() => {
       let width = cellCount(props.w, 0), height = cellCount(props.h, 0), runs = finiteLineRuns(props.values), sourceLength = props.values.length, { min, max } = domainFromValues(props.values, props.min, props.max), layout = resolveAxisLayout(width, height, min, max, props.showAxes);
       return { width, height, layout, runs, sourceLength, min, max };
     }), visibleRect = useChartVisibleRect(props, lineLayout);
@@ -2628,7 +5414,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
       ), y = layout.plotY + valueToY(value, min, max, layout.plotH), label = props.labels?.[point.originalIndex] ?? `#${point.originalIndex + 1}`;
       return { x, y, index: point.originalIndex, label, value };
     }
-    let baseCells = (0, import_vue10.computed)(() => {
+    let baseCells = (0, import_vue15.computed)(() => {
       let { width, height, layout, runs, sourceLength, min, max } = lineLayout.value, cells = [];
       if (layout.plotW > 0 && layout.plotH > 0 && runs.length > 0) {
         let occupiedLineCells = /* @__PURE__ */ new Set();
@@ -2677,7 +5463,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
         props.startLabel || (sourceLength > 0 ? "1" : ""),
         props.endLabel || (sourceLength > 0 ? String(sourceLength) : "")
       ), cells;
-    }), surface = (0, import_vue10.computed)(() => {
+    }), surface = (0, import_vue15.computed)(() => {
       let { width, height, layout } = lineLayout.value, cells = baseCells.value.slice(), pointer = hoverPointer.value, hovered = pointer ? hitLine(pointer.x, pointer.y) : null;
       hovered && cells.push({
         x: hovered.x,
@@ -2723,7 +5509,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
       })
     });
   }
-}), TCandlestickChart = (0, import_vue10.defineComponent)({
+}), TCandlestickChart = (0, import_vue15.defineComponent)({
   name: "TCandlestickChart",
   props: {
     /** Left position in terminal cells. */
@@ -2772,7 +5558,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
     tooltipStyle: { type: Object, default: () => ({ fg: "whiteBright" }) }
   },
   setup(props) {
-    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue10.computed)(() => mergeStyle(defaultStyle.value, props.style)), axisStyle = (0, import_vue10.computed)(() => mergeStyle(baseStyle.value, props.axisStyle)), labelStyle = (0, import_vue10.computed)(() => mergeStyle(baseStyle.value, props.labelStyle)), hoverPointer = (0, import_vue10.ref)(null), candleLayout = (0, import_vue10.computed)(() => {
+    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue15.computed)(() => mergeStyle(defaultStyle.value, props.style)), axisStyle = (0, import_vue15.computed)(() => mergeStyle(baseStyle.value, props.axisStyle)), labelStyle = (0, import_vue15.computed)(() => mergeStyle(baseStyle.value, props.labelStyle)), hoverPointer = (0, import_vue15.ref)(null), candleLayout = (0, import_vue15.computed)(() => {
       let width = cellCount(props.w, 0), height = cellCount(props.h, 0), min = 0, max = 0, layout = resolveAxisLayout(width, height, min, max, props.showAxes), startIndex = props.candles.length, visibleCandles = [];
       for (let capacity = Math.min(props.candles.length, width); capacity >= 0 && (startIndex = Math.max(0, props.candles.length - capacity), visibleCandles = props.candles.slice(startIndex), { min, max } = domainFromValues(
         candlestickDomainValues(visibleCandles),
@@ -2806,7 +5592,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
         close
       };
     }
-    let surface = (0, import_vue10.computed)(() => {
+    let surface = (0, import_vue15.computed)(() => {
       let current = candleLayout.value, { width, height, layout, visibleCandles, candleOffsetX, min, max } = current, cells = [], upStyle = mergeStyle(baseStyle.value, props.upStyle), downStyle = mergeStyle(baseStyle.value, props.downStyle), upWickStyle = mergeStyle(baseStyle.value, props.upStyle, props.wickStyle), downWickStyle = mergeStyle(baseStyle.value, props.downStyle, props.wickStyle), pointer = hoverPointer.value, hovered = pointer ? hitCandle(pointer.x, pointer.y) : null;
       for (let x = 0; x < visibleCandles.length; x++) {
         let candle = visibleCandles[x], values = normalizeCandlestick(candle);
@@ -2872,7 +5658,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
       })
     });
   }
-}), TPieChart = (0, import_vue10.defineComponent)({
+}), TPieChart = (0, import_vue15.defineComponent)({
   name: "TPieChart",
   props: {
     /** Left position in terminal cells. */
@@ -2902,7 +5688,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
     legendStyle: { type: Object, default: () => ({ fg: "whiteBright" }) }
   },
   setup(props) {
-    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue10.computed)(() => mergeStyle(defaultStyle.value, props.style)), legendStyle = (0, import_vue10.computed)(() => mergeStyle(baseStyle.value, props.legendStyle)), surface = (0, import_vue10.computed)(() => {
+    let { defaultStyle } = useTerminal(), baseStyle = (0, import_vue15.computed)(() => mergeStyle(defaultStyle.value, props.style)), legendStyle = (0, import_vue15.computed)(() => mergeStyle(baseStyle.value, props.legendStyle)), surface = (0, import_vue15.computed)(() => {
       let width = cellCount(props.w, 0), height = cellCount(props.h, 0), values = props.values.map((value) => {
         let n = Number(value);
         return Number.isFinite(n) ? Math.max(0, n) : 0;
@@ -2971,7 +5757,7 @@ var TContributionGraph = (0, import_vue10.defineComponent)({
 });
 
 // src/vue/components/TTranscriptView.ts
-var import_vue13 = require("vue");
+var import_vue17 = require("vue");
 
 // src/observability/frame-perf.ts
 var EMPTY_METRIC_STATS = Object.freeze({ avg: 0, max: 0, min: 0 });
@@ -3118,147 +5904,39 @@ function layoutTranscriptRow(options) {
       rowIndex: options.rowIndex,
       payload: { row: options.row, rowKey: options.rowKey },
       hoverStyle: options.hoverStyle,
-      focusStyle: options.focusStyle
-    };
-    for (let i = 0; i < segments.length; i++)
-      appendTextSegment(segments[i], i, i === 0 ? foldRegion : toolRegion);
-  } else
-    for (let i = 0; i < segments.length; i++)
-      appendTextSegment(segments[i], i);
-  if ("actions" in options.row)
-    for (let action of options.row.actions ?? [])
-      appendAction(action);
-  return pushCurrentIfNeeded(), visualRows.length ? visualRows : [createVisualRow(0, 0)];
-}
-
-// src/vue/transcript/plain-text.ts
-function plainTextForTranscriptRow(row) {
-  if (row.selectableText != null)
-    return row.selectableText;
-  if (row.kind === "message")
-    return row.segments.map((segment) => segment.text).join("");
-  if (row.kind === "action")
-    return row.label;
-  if (row.kind === "approval") {
-    let description = row.description?.map((segment) => segment.text).join("") ?? "";
-    return description ? `${row.title}
-${description}` : row.title;
-  }
-  let summary = row.summary?.map((segment) => segment.text).join("") ?? "", body = row.collapsed ? "" : row.body?.map((segment) => segment.text).join("") ?? "";
-  return [row.title, summary, body].filter(Boolean).join(`
-`);
-}
-
-// src/vue/components/TView.ts
-var import_vue11 = require("vue");
-var EMPTY_RECT = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), TView = (0, import_vue11.defineComponent)({
-  name: "TView",
-  props: {
-    x: { type: Number, required: !0 },
-    y: { type: Number, required: !0 },
-    w: { type: Number, required: !0 },
-    h: { type: Number, required: !0 },
-    zIndex: { type: Number, default: 0 },
-    scrollX: { type: Number, default: 0 },
-    scrollY: { type: Number, default: 0 },
-    focusable: { type: Boolean, default: !1 },
-    selectable: { type: Boolean, default: void 0 },
-    selectionScrollBy: {
-      type: Function,
-      default: void 0
-    },
-    autoFocus: { type: Boolean, default: !1 }
-  },
-  emits: [
-    "clickCapture",
-    "click",
-    "dblclickCapture",
-    "dblclick",
-    "pointerdownCapture",
-    "pointerdown",
-    "pointerupCapture",
-    "pointerup",
-    "pointermoveCapture",
-    "pointermove",
-    "pointerenterCapture",
-    "pointerenter",
-    "pointerleaveCapture",
-    "pointerleave",
-    "wheelCapture",
-    "wheel",
-    "keydownCapture",
-    "keydown",
-    "keyupCapture",
-    "keyup",
-    "focusCapture",
-    "focus",
-    "blurCapture",
-    "blur"
-  ],
-  setup(props, { emit, slots }) {
-    let parent = useLayout(), { render, events } = useTerminal(), parentStack = useRenderStack(), { visible, rootProps } = useVisibility({ provide: !0 }), parentEventZ = (0, import_vue11.inject)(EventZIndexContextKey, (0, import_vue11.computed)(() => 0)), eventZ = (0, import_vue11.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), rawRect = (0, import_vue11.computed)(
-      () => translateRect(
-        { x: props.x, y: props.y, w: props.w, h: props.h },
-        parent.originX,
-        parent.originY
-      )
-    ), rect = (0, import_vue11.computed)(() => {
-      let translated = rawRect.value;
-      return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT : translated;
-    }), { id } = useTerminalNode(() => ({
-      rect: rect.value,
-      zIndex: eventZ.value,
-      visible: visible.value,
-      focusable: props.focusable,
-      selectable: props.selectable,
-      selectionScrollBy: props.selectionScrollBy,
-      handlers: {
-        clickCapture: (e) => emit("clickCapture", e),
-        click: (e) => emit("click", e),
-        dblclickCapture: (e) => emit("dblclickCapture", e),
-        dblclick: (e) => emit("dblclick", e),
-        pointerdownCapture: (e) => emit("pointerdownCapture", e),
-        pointerdown: (e) => emit("pointerdown", e),
-        pointerupCapture: (e) => emit("pointerupCapture", e),
-        pointerup: (e) => emit("pointerup", e),
-        pointermoveCapture: (e) => emit("pointermoveCapture", e),
-        pointermove: (e) => emit("pointermove", e),
-        pointerenterCapture: (e) => emit("pointerenterCapture", e),
-        pointerenter: (e) => emit("pointerenter", e),
-        pointerleaveCapture: (e) => emit("pointerleaveCapture", e),
-        pointerleave: (e) => emit("pointerleave", e),
-        wheelCapture: (e) => emit("wheelCapture", e),
-        wheel: (e) => emit("wheel", e),
-        keydownCapture: (e) => emit("keydownCapture", e),
-        keydown: (e) => emit("keydown", e),
-        keyupCapture: (e) => emit("keyupCapture", e),
-        keyup: (e) => emit("keyup", e),
-        focusCapture: (e) => emit("focusCapture", e),
-        focus: (e) => emit("focus", e),
-        blurCapture: (e) => emit("blurCapture", e),
-        blur: (e) => emit("blur", e)
-      }
-    }));
-    (0, import_vue11.watchEffect)(() => {
-      if (!props.autoFocus || !visible.value)
-        return;
-      let manager = events.value, nodeId = id.value;
-      !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
-    });
-    let childLayout = (0, import_vue11.shallowReactive)({
-      originX: 0,
-      originY: 0,
-      clipRect: null
-    }), childStack = (0, import_vue11.computed)(() => render.createStack(parentStack.value, props.zIndex));
-    return (0, import_vue11.watchEffect)(() => {
-      let translated = rawRect.value;
-      childLayout.originX = translated.x - Math.floor(props.scrollX), childLayout.originY = translated.y - Math.floor(props.scrollY), childLayout.clipRect = rect.value;
-    }), (0, import_vue11.provide)(LayoutContextKey, childLayout), (0, import_vue11.provide)(RenderStackKey, childStack), (0, import_vue11.provide)(EventZIndexContextKey, eventZ), () => (0, import_vue11.h)("div", rootProps, slots.default?.());
+      focusStyle: options.focusStyle
+    };
+    for (let i = 0; i < segments.length; i++)
+      appendTextSegment(segments[i], i, i === 0 ? foldRegion : toolRegion);
+  } else
+    for (let i = 0; i < segments.length; i++)
+      appendTextSegment(segments[i], i);
+  if ("actions" in options.row)
+    for (let action of options.row.actions ?? [])
+      appendAction(action);
+  return pushCurrentIfNeeded(), visualRows.length ? visualRows : [createVisualRow(0, 0)];
+}
+
+// src/vue/transcript/plain-text.ts
+function plainTextForTranscriptRow(row) {
+  if (row.selectableText != null)
+    return row.selectableText;
+  if (row.kind === "message")
+    return row.segments.map((segment) => segment.text).join("");
+  if (row.kind === "action")
+    return row.label;
+  if (row.kind === "approval") {
+    let description = row.description?.map((segment) => segment.text).join("") ?? "";
+    return description ? `${row.title}
+${description}` : row.title;
   }
-});
+  let summary = row.summary?.map((segment) => segment.text).join("") ?? "", body = row.collapsed ? "" : row.body?.map((segment) => segment.text).join("") ?? "";
+  return [row.title, summary, body].filter(Boolean).join(`
+`);
+}
 
 // src/vue/components/TVirtualRows.ts
-var import_vue12 = require("vue");
+var import_vue16 = require("vue");
 function clamp3(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
@@ -3276,7 +5954,7 @@ function getWheelScrollInput2(e) {
   let deltaY = Number(e.deltaY ?? 0), deltaMode = typeof e.deltaMode == "number" ? e.deltaMode : void 0;
   return Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && deltaMode == null ? { deltaY: deltaY / 100, mode: "line" } : deltaMode === 1 ? { deltaY, mode: "line" } : deltaMode === 0 ? { deltaY, mode: "pixel" } : { deltaY, mode: "auto" };
 }
-var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), TVirtualRows = (0, import_vue12.defineComponent)({
+var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), TVirtualRows = (0, import_vue16.defineComponent)({
   name: "TVirtualRows",
   props: {
     x: { type: Number, required: !0 },
@@ -3340,27 +6018,27 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
     "itemClick"
   ],
   setup(props, { emit, expose }) {
-    let { terminal, scheduler, render, rendererCapabilities, defaultStyle, events, selection } = useTerminal(), instance = (0, import_vue12.getCurrentInstance)(), layout = useLayout(), { visible, rootProps } = useVisibility(), plane = (0, import_vue12.inject)(RenderPlaneContextKey, (0, import_vue12.ref)("default")), parentEventZ = (0, import_vue12.inject)(EventZIndexContextKey, (0, import_vue12.computed)(() => 0)), eventZ = (0, import_vue12.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), parentStack = useRenderStack(), childLayout = (0, import_vue12.shallowReactive)({
+    let { terminal, scheduler, render, rendererCapabilities, defaultStyle, events, selection } = useTerminal(), instance = (0, import_vue16.getCurrentInstance)(), layout = useLayout(), { visible, rootProps } = useVisibility(), plane = (0, import_vue16.inject)(RenderPlaneContextKey, (0, import_vue16.ref)("default")), parentEventZ = (0, import_vue16.inject)(EventZIndexContextKey, (0, import_vue16.computed)(() => 0)), eventZ = (0, import_vue16.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), parentStack = useRenderStack(), childLayout = (0, import_vue16.shallowReactive)({
       originX: 0,
       originY: 0,
       clipRect: null
-    }), childStack = (0, import_vue12.computed)(() => render.createStack(parentStack.value, props.zIndex));
-    (0, import_vue12.provide)(LayoutContextKey, childLayout), (0, import_vue12.provide)(RenderStackKey, childStack), (0, import_vue12.provide)(EventZIndexContextKey, eventZ);
-    let virtualRowsInstanceId = ++virtualRowsInstanceSeq, parentTerminalGraphicsActivity = (0, import_vue12.inject)(TerminalGraphicsActivityKey, null), terminalGraphicsActivity = createTerminalGraphicsActivity({
+    }), childStack = (0, import_vue16.computed)(() => render.createStack(parentStack.value, props.zIndex));
+    (0, import_vue16.provide)(LayoutContextKey, childLayout), (0, import_vue16.provide)(RenderStackKey, childStack), (0, import_vue16.provide)(EventZIndexContextKey, eventZ);
+    let virtualRowsInstanceId = ++virtualRowsInstanceSeq, parentTerminalGraphicsActivity = (0, import_vue16.inject)(TerminalGraphicsActivityKey, null), terminalGraphicsActivity = createTerminalGraphicsActivity({
       scrollIdleMs: props.terminalGraphicScrollIdleMs,
       traceId: `TVirtualRows:${virtualRowsInstanceId}:terminal-graphics`
     });
-    (0, import_vue12.provide)(
+    (0, import_vue16.provide)(
       TerminalGraphicsActivityKey,
       createCombinedTerminalGraphicsActivity(
         parentTerminalGraphicsActivity,
         terminalGraphicsActivity
       )
-    ), (0, import_vue12.watch)(
+    ), (0, import_vue16.watch)(
       () => props.terminalGraphicScrollIdleMs,
       (value) => terminalGraphicsActivity.setScrollIdleMs(value)
     );
-    let frameTaskId = `TVirtualRows:${virtualRowsInstanceId}`, innerScrollTop = (0, import_vue12.ref)(0), controlledScrollTop = (0, import_vue12.ref)(0), focused = (0, import_vue12.ref)(!1), wheelState = createWheelScrollState(), initializedScrollTop = !1, dirtyRowsHint, renderNodeId = null, pendingWheelTop = null, pendingSelectionScrollFocusRemap = !1, alive = !0, itemCount = (0, import_vue12.computed)(() => Math.max(0, normalizeInt(props.itemCount))), fullRect = (0, import_vue12.computed)(
+    let frameTaskId = `TVirtualRows:${virtualRowsInstanceId}`, innerScrollTop = (0, import_vue16.ref)(0), controlledScrollTop = (0, import_vue16.ref)(0), focused = (0, import_vue16.ref)(!1), wheelState = createWheelScrollState(), initializedScrollTop = !1, dirtyRowsHint, renderNodeId = null, pendingWheelTop = null, pendingSelectionScrollFocusRemap = !1, alive = !0, itemCount = (0, import_vue16.computed)(() => Math.max(0, normalizeInt(props.itemCount))), fullRect = (0, import_vue16.computed)(
       () => translateRect(
         {
           x: normalizeInt(props.x),
@@ -3371,7 +6049,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
         layout.originX,
         layout.originY
       )
-    ), absRect = (0, import_vue12.computed)(() => {
+    ), absRect = (0, import_vue16.computed)(() => {
       let translated = fullRect.value;
       return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? EMPTY_RECT2 : translated;
     });
@@ -3437,10 +6115,10 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
         rows.push(y);
       return rows;
     }
-    function exposedRowsForDelta2(y0, h15, delta) {
+    function exposedRowsForDelta2(y0, h19, delta) {
       let rows = [];
       if (delta > 0)
-        for (let i = h15 - delta; i < h15; i++)
+        for (let i = h19 - delta; i < h19; i++)
           rows.push(y0 + i);
       else
         for (let i = 0; i < -delta; i++)
@@ -3465,11 +6143,11 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
       scheduler.invalidate({ priority, plane: plane.value, reason: "scroll" });
     }
     function markScrollDamage(prevTop, nextTop, strategy = "auto") {
-      let r = normalizedRect(), h15 = r.h, delta = nextTop - prevTop;
-      if (h15 <= 0 || !delta)
+      let r = normalizedRect(), h19 = r.h, delta = nextTop - prevTop;
+      if (h19 <= 0 || !delta)
         return;
-      let size = terminal.size(), ownsFullRows = Math.floor(r.x) === 0 && Math.floor(r.w) >= size.cols, withinTerminalRows = r.y >= 0 && r.y + h15 <= size.rows;
-      strategy === "auto" && props.rowScrollMode === "unsafe-full-row" && rendererCapabilities.value.scrollOperations && ownsFullRows && withinTerminalRows && !isClipped() && Math.abs(delta) < h15 && !dirtyRowsHint?.length ? (render.unsafeScrollPlaneRows(plane.value, r.y, r.y + h15, delta), markRowsDirty(exposedRowsForDelta2(r.y, h15, delta))) : markViewportDirty();
+      let size = terminal.size(), ownsFullRows = Math.floor(r.x) === 0 && Math.floor(r.w) >= size.cols, withinTerminalRows = r.y >= 0 && r.y + h19 <= size.rows;
+      strategy === "auto" && props.rowScrollMode === "unsafe-full-row" && rendererCapabilities.value.scrollOperations && ownsFullRows && withinTerminalRows && !isClipped() && Math.abs(delta) < h19 && !dirtyRowsHint?.length ? (render.unsafeScrollPlaneRows(plane.value, r.y, r.y + h19, delta), markRowsDirty(exposedRowsForDelta2(r.y, h19, delta))) : markViewportDirty();
     }
     function applyScrollTop(nextTop, options) {
       if (normalizedRect().h <= 0)
@@ -3614,7 +6292,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
       getText: textForSelectionRange,
       getVisibleSpans: visibleSpansForSelectionRange
     }, unregisterSelectionTextProvider = selection.registerTextProvider(selectionTextProvider);
-    (0, import_vue12.onBeforeUnmount)(unregisterSelectionTextProvider);
+    (0, import_vue16.onBeforeUnmount)(unregisterSelectionTextProvider);
     let eventNode = useTerminalNode(() => ({
       rect: normalizedRect(),
       zIndex: eventZ.value,
@@ -3666,15 +6344,15 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
         }
       }
     }));
-    (0, import_vue12.watchEffect)(() => {
+    (0, import_vue16.watchEffect)(() => {
       if (!props.autoFocus || !visible.value)
         return;
       let manager = events.value, nodeId = eventNode.id.value;
       !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
-    }), (0, import_vue12.watchEffect)(() => {
+    }), (0, import_vue16.watchEffect)(() => {
       let full = normalizedFullRect();
       childLayout.originX = full.x, childLayout.originY = full.y, childLayout.clipRect = normalizedRect();
-    }), (0, import_vue12.watch)(
+    }), (0, import_vue16.watch)(
       () => props.scrollTop,
       () => {
         if (!isScrollControlled())
@@ -3693,7 +6371,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
         controlledScrollTop.value = nextTop, terminalGraphicsActivity.markScroll(), markScrollDamage(prevTop, nextTop), selection.refresh(pendingSelectionScrollFocusRemap ? { remapFocus: !0 } : void 0), pendingSelectionScrollFocusRemap = !1, invalidateSelf("high"), desiredTop !== nextTop && (emit("update:scrollTop", nextTop), emitScroll(nextTop));
       },
       { immediate: !0 }
-    ), (0, import_vue12.watch)(
+    ), (0, import_vue16.watch)(
       [
         () => itemCount.value,
         () => props.itemVersion,
@@ -3719,12 +6397,12 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
         markViewportDirty(), invalidateSelf("normal");
       },
       { immediate: !0 }
-    ), (0, import_vue12.watch)(
+    ), (0, import_vue16.watch)(
       () => visible.value,
       (nextVisible) => {
         nextVisible || cancelWheelScrollFrame();
       }
-    ), (0, import_vue12.onBeforeUnmount)(() => {
+    ), (0, import_vue16.onBeforeUnmount)(() => {
       alive = !1, pendingWheelTop = null, resetWheelScrollState(wheelState), wheelMailbox.dispose(), terminalGraphicsActivity.dispose();
     });
     let renderNode = useRenderNode(() => ({
@@ -3777,7 +6455,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
           paintRow(y);
       }
     }));
-    return (0, import_vue12.watchEffect)(() => {
+    return (0, import_vue16.watchEffect)(() => {
       renderNodeId = renderNode.id.value;
     }), () => {
       let children = [];
@@ -3798,7 +6476,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
           );
         }
       }
-      return (0, import_vue12.h)("div", rootProps, children);
+      return (0, import_vue16.h)("div", rootProps, children);
     };
   }
 });
@@ -3874,7 +6552,7 @@ function reindexVisualRows(rows, rowIndex) {
 function sameCachedLayout(entry, next, matchRowIndex = !0) {
   return !!entry && (next.usesSourceRowVersion || entry.version === next.version) && entry.rowVersion === next.rowVersion && entry.usesSourceRowVersion === next.usesSourceRowVersion && (next.usesSourceRowVersion || entry.row === next.row) && (!matchRowIndex || entry.rowIndex === next.rowIndex) && entry.rowKey === next.rowKey && entry.width === next.width && entry.wrap === next.wrap && entry.baseStyle === next.baseStyle && entry.hoverStyle === next.hoverStyle && entry.focusStyle === next.focusStyle && entry.hoverRegionId === next.hoverRegionId && entry.focusedRegionId === next.focusedRegionId;
 }
-var TTranscriptView = (0, import_vue13.defineComponent)({
+var TTranscriptView = (0, import_vue17.defineComponent)({
   name: "TTranscriptView",
   props: {
     x: { type: Number, required: !0 },
@@ -3915,7 +6593,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
     "hoverRegion"
   ],
   setup(props, { emit, expose }) {
-    let { defaultStyle, observability } = useTerminal(), instance = (0, import_vue13.getCurrentInstance)(), rowsRef = (0, import_vue13.ref)(null), innerScrollTop = (0, import_vue13.ref)(normalizeInt2(props.defaultScrollTop)), hoveredRegion = (0, import_vue13.ref)(null), focusedRegion = (0, import_vue13.ref)(null), rowLayoutCache = /* @__PURE__ */ new Map(), keyedRowLayoutCache = /* @__PURE__ */ new Map(), previousWrappedLayout = null, previousWrappedDeps = null, canUseWrappedChangedRangeRepaint = !1, warnedLargeFlattenedRows = !1;
+    let { defaultStyle, observability } = useTerminal(), instance = (0, import_vue17.getCurrentInstance)(), rowsRef = (0, import_vue17.ref)(null), innerScrollTop = (0, import_vue17.ref)(normalizeInt2(props.defaultScrollTop)), hoveredRegion = (0, import_vue17.ref)(null), focusedRegion = (0, import_vue17.ref)(null), rowLayoutCache = /* @__PURE__ */ new Map(), keyedRowLayoutCache = /* @__PURE__ */ new Map(), previousWrappedLayout = null, previousWrappedDeps = null, canUseWrappedChangedRangeRepaint = !1, warnedLargeFlattenedRows = !1;
     function isScrollControlled() {
       return Object.prototype.hasOwnProperty.call(instance?.vnode.props ?? {}, "scrollTop");
     }
@@ -4023,7 +6701,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
       };
       return previousWrappedLayout = state, { state, cacheHit, cacheMiss };
     }
-    let layoutState = (0, import_vue13.computed)(() => {
+    let layoutState = (0, import_vue17.computed)(() => {
       props.version, canUseWrappedChangedRangeRepaint = !1;
       let perfEnabled = observability.framePerf.enabled.value, perfStartedAt = perfEnabled ? framePerfNow() : 0, width = Math.max(1, Math.floor(props.w)), count = Math.max(0, normalizeInt2(props.source.rowCount()));
       if (!count)
@@ -4113,7 +6791,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
       });
       let state = { visualRows, rowStarts, rowEnds, regions, fixedRows, rowCount: count };
       return fixedRows ? (previousWrappedLayout = null, previousWrappedDeps = null) : (previousWrappedLayout = state, previousWrappedDeps = wrappedDeps), state;
-    }), maxScrollTop = (0, import_vue13.computed)(
+    }), maxScrollTop = (0, import_vue17.computed)(
       () => Math.max(0, layoutState.value.visualRows.length - Math.max(0, normalizeInt2(props.h)))
     );
     function setScrollTop(top) {
@@ -4255,12 +6933,12 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
       focusPreviousRegion,
       activateFocusedRegion,
       getHoveredRegion: () => hoveredRegion.value
-    }), (0, import_vue13.watch)(
+    }), (0, import_vue17.watch)(
       () => props.defaultScrollTop,
       (top) => {
         isScrollControlled() || (innerScrollTop.value = clamp4(normalizeInt2(top), 0, maxScrollTop.value));
       }
-    ), (0, import_vue13.watch)(
+    ), (0, import_vue17.watch)(
       () => layoutState.value.visualRows.length,
       (next, prev) => {
         if (!props.autoStickToBottom)
@@ -4271,7 +6949,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
         let nextTop = Math.max(0, next - viewportRows);
         rowsRef.value?.scrollTo(nextTop), setScrollTop(nextTop);
       }
-    ), (0, import_vue13.watch)(
+    ), (0, import_vue17.watch)(
       () => [layoutState.value.regions, currentScrollTop(), props.h],
       () => reconcileActiveRegions()
     );
@@ -4299,7 +6977,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
       let nodes = [];
       for (let region of visualRow.hitRegions)
         nodes.push(
-          (0, import_vue13.h)(TView, {
+          (0, import_vue17.h)(TView, {
             key: `${region.id}:${ctx.index}:${region.x0}`,
             x: region.x0,
             y: ctx.row,
@@ -4354,7 +7032,7 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
       let visualRow = ctx.item;
       return visualRow ? visualRow.selectionSegments.length ? textForSelectionSegments(visualRow.selectionSegments, ctx.x0, ctx.x1) : sliceByCellsRange(selectionTextForVisualRow(visualRow), ctx.x0, ctx.x1) : "";
     }
-    return () => (0, import_vue13.h)(TVirtualRows, {
+    return () => (0, import_vue17.h)(TVirtualRows, {
       ref: rowsRef,
       x: props.x,
       y: props.y,
@@ -4395,187 +7073,6 @@ var TTranscriptView = (0, import_vue13.defineComponent)({
   }
 });
 
-// src/core/ansi/sgr.ts
-var ESC = "\x1B";
-function ansi16ToColorName(code) {
-  switch (code) {
-    case 30:
-      return "black";
-    case 31:
-      return "red";
-    case 32:
-      return "green";
-    case 33:
-      return "yellow";
-    case 34:
-      return "blue";
-    case 35:
-      return "magenta";
-    case 36:
-      return "cyan";
-    case 37:
-      return "white";
-    case 90:
-      return "blackBright";
-    case 91:
-      return "redBright";
-    case 92:
-      return "greenBright";
-    case 93:
-      return "yellowBright";
-    case 94:
-      return "blueBright";
-    case 95:
-      return "magentaBright";
-    case 96:
-      return "cyanBright";
-    case 97:
-      return "whiteBright";
-    default:
-      return;
-  }
-}
-function ansi16BgToColorName(code) {
-  let fgCode = code >= 40 && code <= 47 || code >= 100 && code <= 107 ? code - 10 : null;
-  if (fgCode != null)
-    return ansi16ToColorName(fgCode);
-}
-var ANSI16_RGB = {
-  black: { r: 0, g: 0, b: 0 },
-  red: { r: 201, g: 27, b: 0 },
-  green: { r: 0, g: 194, b: 0 },
-  yellow: { r: 199, g: 196, b: 0 },
-  blue: { r: 2, g: 37, b: 199 },
-  magenta: { r: 201, g: 48, b: 199 },
-  cyan: { r: 0, g: 197, b: 199 },
-  white: { r: 199, g: 199, b: 199 },
-  blackBright: { r: 104, g: 104, b: 104 },
-  redBright: { r: 255, g: 110, b: 103 },
-  greenBright: { r: 95, g: 250, b: 104 },
-  yellowBright: { r: 255, g: 252, b: 103 },
-  blueBright: { r: 104, g: 113, b: 255 },
-  magentaBright: { r: 255, g: 118, b: 255 },
-  cyanBright: { r: 95, g: 253, b: 255 },
-  whiteBright: { r: 255, g: 255, b: 255 }
-};
-function nearestAnsi16(r, g, b) {
-  let best = "white", bestDist = Number.POSITIVE_INFINITY;
-  for (let [name, rgb] of Object.entries(ANSI16_RGB)) {
-    let dr = r - rgb.r, dg = g - rgb.g, db = b - rgb.b, d = dr * dr + dg * dg + db * db;
-    d < bestDist && (bestDist = d, best = name);
-  }
-  return best;
-}
-function ansi256ToRgb(index) {
-  let n = Math.max(0, Math.min(255, Math.trunc(index)));
-  if (n < 16) {
-    let name = [
-      "black",
-      "red",
-      "green",
-      "yellow",
-      "blue",
-      "magenta",
-      "cyan",
-      "white",
-      "blackBright",
-      "redBright",
-      "greenBright",
-      "yellowBright",
-      "blueBright",
-      "magentaBright",
-      "cyanBright",
-      "whiteBright"
-    ][n] ?? "white";
-    return ANSI16_RGB[name];
-  }
-  if (n >= 232) {
-    let c = 8 + (n - 232) * 10;
-    return { r: c, g: c, b: c };
-  }
-  let i = n - 16, rr = Math.floor(i / 36), gg = Math.floor(i % 36 / 6), bb = i % 6, toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
-  return { r: toComponent(rr), g: toComponent(gg), b: toComponent(bb) };
-}
-function applyAnsiSgrStyle(current, codes) {
-  let next = { ...current };
-  for (let i = 0; i < codes.length; i++) {
-    let code = codes[i];
-    if (code === 0) {
-      next = {};
-      continue;
-    }
-    if (code === 1)
-      next = { ...next, bold: !0 };
-    else if (code === 2)
-      next = { ...next, dim: !0 };
-    else if (code === 3)
-      next = { ...next, italic: !0 };
-    else if (code === 4)
-      next = { ...next, underline: !0 };
-    else if (code === 7)
-      next = { ...next, inverse: !0 };
-    else if (code === 22)
-      next = { ...next, bold: !1, dim: !1 };
-    else if (code === 23)
-      next = { ...next, italic: !1 };
-    else if (code === 24)
-      next = { ...next, underline: !1 };
-    else if (code === 27)
-      next = { ...next, inverse: !1 };
-    else if (code === 39)
-      next = { ...next, fg: void 0 };
-    else if (code === 49)
-      next = { ...next, bg: void 0 };
-    else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
-      let fg = ansi16ToColorName(code);
-      next = { ...next, fg: fg ?? next.fg };
-    } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
-      let bg = ansi16BgToColorName(code);
-      next = { ...next, bg: bg ?? next.bg };
-    } else if (code === 38 || code === 48) {
-      let mode = codes[i + 1];
-      if (mode === 5) {
-        let idx = codes[i + 2];
-        if (idx != null) {
-          let { r, g, b } = ansi256ToRgb(idx), name = nearestAnsi16(r, g, b);
-          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
-        }
-        i += 2;
-      } else if (mode === 2) {
-        let r = codes[i + 2], g = codes[i + 3], b = codes[i + 4];
-        if (r != null && g != null && b != null) {
-          let name = nearestAnsi16(r, g, b);
-          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
-        }
-        i += 4;
-      }
-    }
-  }
-  return next;
-}
-function parseAnsiSgr(input, baseStyle = {}) {
-  let segments = [], style = { ...baseStyle }, lastIndex = 0;
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] !== ESC || input[i + 1] !== "[")
-      continue;
-    let j = i + 2;
-    for (; j < input.length; ) {
-      let c = input.charCodeAt(j);
-      if (c >= 48 && c <= 57 || c === 59) {
-        j++;
-        continue;
-      }
-      break;
-    }
-    if (j >= input.length || input[j] !== "m")
-      continue;
-    i > lastIndex && segments.push({ text: input.slice(lastIndex, i), style });
-    let codes = input.slice(i + 2, j).split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
-    style = applyAnsiSgrStyle(style, codes.length ? codes : [0]), lastIndex = j + 1, i = j;
-  }
-  return lastIndex < input.length && segments.push({ text: input.slice(lastIndex), style }), segments;
-}
-
 // src/utils/url-safety.ts
 var ENCODED_ASCII_CONTROL_RE = /%(?:0[0-9a-f]|1[0-9a-f]|7f)/i;
 function hasControlCodePoint(value) {
@@ -4660,7 +7157,7 @@ function sanitizeDomHref(value, options = {}) {
 }
 
 // src/vue/components/TLogView.ts
-var import_vue14 = require("vue");
+var import_vue18 = require("vue");
 
 // src/vue/theme.ts
 var tuiDefaultTheme = Object.freeze({
@@ -5142,7 +7639,7 @@ function countAsciiAnsiTextCells(text) {
   }
   return cells;
 }
-var TLogView = (0, import_vue14.defineComponent)({
+var TLogView = (0, import_vue18.defineComponent)({
   name: "TLogView",
   props: {
     x: { type: Number, required: !0 },
@@ -5251,19 +7748,19 @@ var TLogView = (0, import_vue14.defineComponent)({
     "keydown"
   ],
   setup(props, { emit, expose }) {
-    let { terminal, scheduler, render, rendererCapabilities, defaultStyle, events, selection } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), plane = (0, import_vue14.inject)(RenderPlaneContextKey, (0, import_vue14.ref)("default")), parentEventZ = (0, import_vue14.inject)(EventZIndexContextKey, (0, import_vue14.computed)(() => 0)), eventZ = (0, import_vue14.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), theme = (0, import_vue14.inject)(TuiThemeContextKey, (0, import_vue14.ref)(tuiDefaultTheme)), effectiveAnsiLinkStyle = (0, import_vue14.computed)(() => props.linkStyle ?? DEFAULT_LINK_STYLE), effectiveLinkStyle = (0, import_vue14.computed)(() => ({
+    let { terminal, scheduler, render, rendererCapabilities, defaultStyle, events, selection } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), plane = (0, import_vue18.inject)(RenderPlaneContextKey, (0, import_vue18.ref)("default")), parentEventZ = (0, import_vue18.inject)(EventZIndexContextKey, (0, import_vue18.computed)(() => 0)), eventZ = (0, import_vue18.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), theme = (0, import_vue18.inject)(TuiThemeContextKey, (0, import_vue18.ref)(tuiDefaultTheme)), effectiveAnsiLinkStyle = (0, import_vue18.computed)(() => props.linkStyle ?? DEFAULT_LINK_STYLE), effectiveLinkStyle = (0, import_vue18.computed)(() => ({
       ...theme.value.components.TLink?.style ?? {},
       ...props.linkStyle ?? {}
-    })), focused = (0, import_vue14.ref)(!1), innerScrollTop = (0, import_vue14.ref)(0), stickToBottom = (0, import_vue14.ref)(!0), frameTaskId = `TLogView:${nextTLogViewTaskId++}`, dirtyRowsHint, renderNodeId = null, alive = !0, pendingWheelTop = null, pendingSelectionScrollFocusRemap = !1, initializedScrollTop = !1, lastLineCount = 0, lastFirstLineIndex = 0, lastPaintedBottom = null, cacheClock = 0, renderLineCache = /* @__PURE__ */ new Map(), wrapLineCache = /* @__PURE__ */ new Map(), ansiLineCache = /* @__PURE__ */ new Map(), ansiTextCache = /* @__PURE__ */ new Map(), ansiWrapCache = /* @__PURE__ */ new Map(), ansiRowCache = /* @__PURE__ */ new Map(), linkifyLineCache = /* @__PURE__ */ new Map(), linkifyWrapCache = /* @__PURE__ */ new Map(), searchLineCache = /* @__PURE__ */ new Map(), visibleLinksByRow = /* @__PURE__ */ new Map(), focusedVisibleLinkIndex = (0, import_vue14.ref)(-1), focusedLinkTarget = null, searchGeneration = 0, searchCursor = 0, searchStatus = "idle", searchError = null, compiledSearch = {
+    })), focused = (0, import_vue18.ref)(!1), innerScrollTop = (0, import_vue18.ref)(0), stickToBottom = (0, import_vue18.ref)(!0), frameTaskId = `TLogView:${nextTLogViewTaskId++}`, dirtyRowsHint, renderNodeId = null, alive = !0, pendingWheelTop = null, pendingSelectionScrollFocusRemap = !1, initializedScrollTop = !1, lastLineCount = 0, lastFirstLineIndex = 0, lastPaintedBottom = null, cacheClock = 0, renderLineCache = /* @__PURE__ */ new Map(), wrapLineCache = /* @__PURE__ */ new Map(), ansiLineCache = /* @__PURE__ */ new Map(), ansiTextCache = /* @__PURE__ */ new Map(), ansiWrapCache = /* @__PURE__ */ new Map(), ansiRowCache = /* @__PURE__ */ new Map(), linkifyLineCache = /* @__PURE__ */ new Map(), linkifyWrapCache = /* @__PURE__ */ new Map(), searchLineCache = /* @__PURE__ */ new Map(), visibleLinksByRow = /* @__PURE__ */ new Map(), focusedVisibleLinkIndex = (0, import_vue18.ref)(-1), focusedLinkTarget = null, searchGeneration = 0, searchCursor = 0, searchStatus = "idle", searchError = null, compiledSearch = {
       key: '["text","",""]',
       query: "",
       mode: "text",
       error: null,
       findLineMatches: () => []
-    }, currentMatchIndex = -1, searchMatches = [], searchMarkersGeneration = 0, searchMarkersCacheGeneration = -1, searchMarkersCache = [], lastSearchMarkersPayloadKey = "", matchesByLine = /* @__PURE__ */ new Map(), wheelState = createWheelScrollState(), visualIndexWidth = 0, visualIndexLineCount = 0, visualIndexCapacity = 0, visualCounts = [], visualKeys = [], visualTree = [0], visualIndexStatus = "exact", visualMeasureGeneration = 0, visualMeasureCursor = 0, measuredLineCount = 0, measuredVisualRows = 0, lastVisualIndexPayloadKey = "", fullRect = (0, import_vue14.computed)(() => {
+    }, currentMatchIndex = -1, searchMatches = [], searchMarkersGeneration = 0, searchMarkersCacheGeneration = -1, searchMarkersCache = [], lastSearchMarkersPayloadKey = "", matchesByLine = /* @__PURE__ */ new Map(), wheelState = createWheelScrollState(), visualIndexWidth = 0, visualIndexLineCount = 0, visualIndexCapacity = 0, visualCounts = [], visualKeys = [], visualTree = [0], visualIndexStatus = "exact", visualMeasureGeneration = 0, visualMeasureCursor = 0, measuredLineCount = 0, measuredVisualRows = 0, lastVisualIndexPayloadKey = "", fullRect = (0, import_vue18.computed)(() => {
       let raw = { x: props.x, y: props.y, w: props.w, h: props.h };
       return translateRect(raw, layout.originX, layout.originY);
-    }), absRect = (0, import_vue14.computed)(() => {
+    }), absRect = (0, import_vue18.computed)(() => {
       let translated = fullRect.value;
       return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
     });
@@ -5327,7 +7824,7 @@ var TLogView = (0, import_vue14.defineComponent)({
         options.protocols ?? []
       ]);
     }
-    let linkifyOptionsKey = (0, import_vue14.computed)(() => linkifyOptionsCacheKey());
+    let linkifyOptionsKey = (0, import_vue18.computed)(() => linkifyOptionsCacheKey());
     function linkStyleCacheKey() {
       return linksEnabled() ? styleCacheKey(effectiveAnsiLinkStyle.value) : "";
     }
@@ -6500,10 +8997,10 @@ var TLogView = (0, import_vue14.defineComponent)({
     function shiftVisibleLinksForScrollRegion(y0, y1, delta) {
       if (!visibleLinksByRow.size || delta === 0)
         return;
-      let h15 = y1 - y0;
-      if (h15 <= 0)
+      let h19 = y1 - y0;
+      if (h19 <= 0)
         return;
-      if (Math.abs(delta) >= h15) {
+      if (Math.abs(delta) >= h19) {
         for (let y = y0; y < y1; y++)
           visibleLinksByRow.delete(y);
         return;
@@ -6597,8 +9094,8 @@ var TLogView = (0, import_vue14.defineComponent)({
       return props.wrap || delta <= 0 || delta >= r.h || prevCount <= 0 || nextCount <= prevCount || lastPaintedBottom?.index !== prevCount - 1 || lineKey(prevCount - 1) === lastPaintedBottom.lineKey ? null : r.y + r.h - delta - 1;
     }
     function applyScrollTop(nextTop, strategy = "auto", options) {
-      let r = normalizedRect(), full = normalizedFullRect(), h15 = r.h;
-      if (h15 <= 0 || full.h <= 0)
+      let r = normalizedRect(), full = normalizedFullRect(), h19 = r.h;
+      if (h19 <= 0 || full.h <= 0)
         return !1;
       options?.stickToBottom === !0 && props.wrap && ensureBottomMeasured();
       let prevTop = rawScrollTop(), clampedTop = normalizeScrollTop(nextTop), delta = clampedTop - prevTop;
@@ -6622,7 +9119,7 @@ var TLogView = (0, import_vue14.defineComponent)({
       if (scrollPlan) {
         let rows = options?.extraDirtyRows?.length ? [...scrollPlan.exposedRows, ...options.extraDirtyRows] : scrollPlan.exposedRows;
         if (markRowsDirty(rows))
-          return scrollPlan.apply(), shiftVisibleLinksForScrollRegion(r.y, r.y + h15, delta), options?.emitScroll && emitScroll(clampedTop), !0;
+          return scrollPlan.apply(), shiftVisibleLinksForScrollRegion(r.y, r.y + h19, delta), options?.emitScroll && emitScroll(clampedTop), !0;
       }
       return markViewportDirty(), options?.emitScroll && emitScroll(clampedTop), !0;
     }
@@ -6851,8 +9348,8 @@ var TLogView = (0, import_vue14.defineComponent)({
         return;
       let lineIndex = clamp5(normalizeScrollNumber(index), 0, count - 1), target = lineIndex, visualCount = 1;
       props.wrap && (ensureVisualIndex(), measureVisualLine(lineIndex), target = visualStartForLine(lineIndex), visualCount = visualCounts[lineIndex] ?? 1);
-      let h15 = viewportHeight();
-      options?.align === "center" ? target -= Math.floor((h15 - visualCount) / 2) : options?.align === "end" && (target += visualCount - h15), scrollToVisualRow(target);
+      let h19 = viewportHeight();
+      options?.align === "center" ? target -= Math.floor((h19 - visualCount) / 2) : options?.align === "end" && (target += visualCount - h19), scrollToVisualRow(target);
     }
     function repaintInvalidatedViewport() {
       let nextTop = stickToBottom.value ? bottomScrollTop() : currentScrollTop(), changed = applyScrollTop(nextTop, "viewport-repaint", {
@@ -7066,7 +9563,7 @@ var TLogView = (0, import_vue14.defineComponent)({
       getText: textForSelectionRange,
       getVisibleSpans: visibleSpansForSelectionRange
     }, unregisterSelectionTextProvider = selection.registerTextProvider(selectionTextProvider);
-    (0, import_vue14.onBeforeUnmount)(unregisterSelectionTextProvider);
+    (0, import_vue18.onBeforeUnmount)(unregisterSelectionTextProvider);
     let eventNode = useTerminalNode(() => ({
       rect: normalizedRect(),
       zIndex: eventZ.value,
@@ -7102,12 +9599,12 @@ var TLogView = (0, import_vue14.defineComponent)({
         keydown: onKeydown
       }
     }));
-    (0, import_vue14.watchEffect)(() => {
+    (0, import_vue18.watchEffect)(() => {
       if (!props.autoFocus || !visible.value)
         return;
       let manager = events.value, nodeId = eventNode.id.value;
       !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
-    }), (0, import_vue14.watch)(
+    }), (0, import_vue18.watch)(
       [
         () => visible.value,
         () => absRect.value.x,
@@ -7127,24 +9624,24 @@ var TLogView = (0, import_vue14.defineComponent)({
         let nextPendingTop = normalizeScrollTop(pendingWheelTop);
         nextPendingTop === currentScrollTop() ? cancelWheelScrollFrame() : nextPendingTop !== pendingWheelTop && replacePendingWheelTop(nextPendingTop);
       }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       () => props.version,
       () => {
         resetWheelScrollState(wheelState), requestDataFrame(), requestSearchScan();
       }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       () => [props.ansi, props.links, props.linkify],
       () => {
         visualLinksEnabled() || clearLinkFocus();
       }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       () => props.scrollTop,
       () => {
         cancelWheelScrollFrame(), syncStickFromCurrentScrollTop();
         let remap = pendingSelectionScrollFocusRemap;
         pendingSelectionScrollFocusRemap = !1, selection.refresh(remap ? { remapFocus: !0 } : void 0), markViewportDirty(), invalidateSelf("high", "scroll");
       }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       [
         () => props.source,
         () => props.wrap,
@@ -7167,7 +9664,7 @@ var TLogView = (0, import_vue14.defineComponent)({
         emitVisualIndex(!0);
       },
       { immediate: !0 }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       [
         () => props.searchQuery,
         () => props.searchOptions?.mode,
@@ -7184,12 +9681,12 @@ var TLogView = (0, import_vue14.defineComponent)({
         requestSearchScan();
       },
       { immediate: !0 }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       [() => props.highlightMatches, () => props.matchStyle, () => props.currentMatchStyle],
       () => {
         markViewportDirty(), invalidateSelf("normal", "data");
       }
-    ), (0, import_vue14.watch)(
+    ), (0, import_vue18.watch)(
       [
         () => props.source,
         () => props.wrap,
@@ -7215,7 +9712,7 @@ var TLogView = (0, import_vue14.defineComponent)({
         changed && selection.refresh(), changed || markViewportDirty(), invalidateSelf("normal", "data");
       },
       { immediate: !0 }
-    ), (0, import_vue14.onBeforeUnmount)(() => {
+    ), (0, import_vue18.onBeforeUnmount)(() => {
       alive = !1, searchGeneration++, visualMeasureGeneration++, cancelWheelScrollFrame(), wheelMailbox.dispose(), dataHighMailbox.dispose(), dataNormalMailbox.dispose();
     });
     let renderNode = useRenderNode(() => ({
@@ -7400,14 +9897,14 @@ var TLogView = (0, import_vue14.defineComponent)({
         syncFocusedVisibleLinkFromViewport(), trimRenderCache(), trimWrapCache(), trimAnsiLineCache(), trimAnsiWrapCache(), trimAnsiRowCache(), trimLinkifyLineCache(), trimLinkifyWrapCache();
       }
     }));
-    return (0, import_vue14.watchEffect)(() => {
+    return (0, import_vue18.watchEffect)(() => {
       renderNodeId = renderNode.id.value;
-    }), lastLineCount = lineCount(), lastFirstLineIndex = firstLineIndex(), () => (0, import_vue14.h)("span", rootProps);
+    }), lastLineCount = lineCount(), lastFirstLineIndex = firstLineIndex(), () => (0, import_vue18.h)("span", rootProps);
   }
 });
 
 // src/vue/components/TLogScrollbar.ts
-var import_vue15 = require("vue");
+var import_vue19 = require("vue");
 var EMPTY_RECT3 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), SCROLLBAR_WIDTH = 1, TRACK_CHAR = "\u2502", EXACT_THUMB_CHAR = "\u2588", MEASURING_THUMB_CHAR = "\u2592", ESTIMATED_THUMB_CHAR = "\u2591", MARKER_CHAR = "\u2022", ESTIMATED_MARKER_CHAR = "\xB7", CURRENT_MARKER_CHAR = "\u25C6", UP_ARROW_CHAR = "\u25B2", DOWN_ARROW_CHAR = "\u25BC";
 function clamp6(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -7469,7 +9966,7 @@ function collectMarkersByRow(markers, metrics2, height, showArrows) {
 function mergeStyle3(base, overlay) {
   return overlay ? { ...base, ...overlay } : base;
 }
-var TLogScrollbar = (0, import_vue15.defineComponent)({
+var TLogScrollbar = (0, import_vue19.defineComponent)({
   name: "TLogScrollbar",
   props: {
     x: { type: Number, required: !0 },
@@ -7501,7 +9998,7 @@ var TLogScrollbar = (0, import_vue15.defineComponent)({
   },
   emits: ["scrollTo", "scrollBy", "markerClick"],
   setup(props, { emit }) {
-    let { terminal, defaultStyle } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue15.inject)(EventZIndexContextKey, (0, import_vue15.computed)(() => 0)), eventZ = (0, import_vue15.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue15.computed)(
+    let { terminal, defaultStyle } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue19.inject)(EventZIndexContextKey, (0, import_vue19.computed)(() => 0)), eventZ = (0, import_vue19.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue19.computed)(
       () => translateRect(
         {
           x: normalizeInt3(props.x),
@@ -7512,7 +10009,7 @@ var TLogScrollbar = (0, import_vue15.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue15.computed)(() => {
+    ), rect = (0, import_vue19.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT3 : translated;
     });
@@ -7615,12 +10112,12 @@ var TLogScrollbar = (0, import_vue15.defineComponent)({
         for (let y of dirtyRows)
           paintRow(y);
       }
-    })), () => (0, import_vue15.h)("span", rootProps);
+    })), () => (0, import_vue19.h)("span", rootProps);
   }
 });
 
 // src/vue/components/TLogMinimap.ts
-var import_vue16 = require("vue");
+var import_vue20 = require("vue");
 var EMPTY_RECT4 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), CURRENT_MARKER_CHAR2 = "\u25C6", MARKER_CHAR2 = "\u2022", ESTIMATED_MARKER_CHAR2 = "\xB7", VIEWPORT_CHAR = "\u2588", DENSITY_HIGH_CHAR = "\u2593", DENSITY_MEDIUM_CHAR = "\u2592", DENSITY_LOW_CHAR = "\u2591";
 function clamp7(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -7709,7 +10206,7 @@ function collectDensityByRow(density, metrics2, height) {
 function densityChar(value) {
   return value >= 0.66 ? DENSITY_HIGH_CHAR : value >= 0.33 ? DENSITY_MEDIUM_CHAR : value > 0 ? DENSITY_LOW_CHAR : " ";
 }
-var TLogMinimap = (0, import_vue16.defineComponent)({
+var TLogMinimap = (0, import_vue20.defineComponent)({
   name: "TLogMinimap",
   props: {
     x: { type: Number, required: !0 },
@@ -7741,7 +10238,7 @@ var TLogMinimap = (0, import_vue16.defineComponent)({
   },
   emits: ["scrollTo", "markerClick"],
   setup(props, { emit }) {
-    let { terminal, defaultStyle } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue16.inject)(EventZIndexContextKey, (0, import_vue16.computed)(() => 0)), eventZ = (0, import_vue16.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue16.computed)(
+    let { terminal, defaultStyle } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue20.inject)(EventZIndexContextKey, (0, import_vue20.computed)(() => 0)), eventZ = (0, import_vue20.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), fullRect = (0, import_vue20.computed)(
       () => translateRect(
         {
           x: normalizeInt4(props.x),
@@ -7752,7 +10249,7 @@ var TLogMinimap = (0, import_vue16.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue16.computed)(() => {
+    ), rect = (0, import_vue20.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT4 : translated;
     });
@@ -7847,12 +10344,12 @@ var TLogMinimap = (0, import_vue16.defineComponent)({
         for (let y of dirtyRows)
           paintRow(y);
       }
-    })), () => (0, import_vue16.h)("span", rootProps);
+    })), () => (0, import_vue20.h)("span", rootProps);
   }
 });
 
 // src/vue/components/TLogSearchBar.ts
-var import_vue17 = require("vue");
+var import_vue21 = require("vue");
 var EMPTY_RECT5 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), PREVIOUS_CHAR = "\u25C0", NEXT_CHAR = "\u25B6";
 function clamp8(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -7882,7 +10379,7 @@ function cellToStringIndex(text, cell) {
 function errorLabel(error) {
   return error?.kind === "invalid-regex" ? "Invalid regex" : "Search error";
 }
-var TLogSearchBar = (0, import_vue17.defineComponent)({
+var TLogSearchBar = (0, import_vue21.defineComponent)({
   name: "TLogSearchBar",
   props: {
     x: { type: Number, required: !0 },
@@ -7933,7 +10430,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
     "keydown"
   ],
   setup(props, { emit }) {
-    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue17.inject)(EventZIndexContextKey, (0, import_vue17.computed)(() => 0)), eventZ = (0, import_vue17.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue17.ref)(!1), cursor = (0, import_vue17.ref)(0), scrollCellOffset = (0, import_vue17.ref)(0), pendingUpdate = (0, import_vue17.ref)(null), fullRect = (0, import_vue17.computed)(
+    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue21.inject)(EventZIndexContextKey, (0, import_vue21.computed)(() => 0)), eventZ = (0, import_vue21.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue21.ref)(!1), cursor = (0, import_vue21.ref)(0), scrollCellOffset = (0, import_vue21.ref)(0), pendingUpdate = (0, import_vue21.ref)(null), fullRect = (0, import_vue21.computed)(
       () => translateRect(
         {
           x: normalizeInt5(props.x),
@@ -7944,7 +10441,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue17.computed)(() => {
+    ), rect = (0, import_vue21.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT5 : translated;
     });
@@ -7964,7 +10461,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
       let totalCells = textCellWidth(query), maxScroll = Math.max(0, totalCells - inputWidth), cursorCell = stringIndexToCell2(query, cursor.value), nextScroll = clamp8(scrollCellOffset.value, 0, maxScroll);
       cursorCell < nextScroll && (nextScroll = cursorCell), cursorCell >= nextScroll + inputWidth && (nextScroll = cursorCell - inputWidth + 1), scrollCellOffset.value = clamp8(nextScroll, 0, maxScroll);
     }
-    let statusText = (0, import_vue17.computed)(() => props.state.status === "error" ? errorLabel(props.state.error) : props.state.status === "scanning" ? !props.showCount || props.state.matchCount <= 0 ? "Scanning\u2026" : `Scanning\u2026 ${props.state.matchCount}` : !props.showCount || !props.state.query ? "" : `${props.state.matchCount > 0 && props.state.currentMatchIndex >= 0 ? props.state.currentMatchIndex + 1 : 0}/${props.state.matchCount}`), rowLayout = (0, import_vue17.computed)(() => {
+    let statusText = (0, import_vue21.computed)(() => props.state.status === "error" ? errorLabel(props.state.error) : props.state.status === "scanning" ? !props.showCount || props.state.matchCount <= 0 ? "Scanning\u2026" : `Scanning\u2026 ${props.state.matchCount}` : !props.showCount || !props.state.query ? "" : `${props.state.matchCount > 0 && props.state.currentMatchIndex >= 0 ? props.state.currentMatchIndex + 1 : 0}/${props.state.matchCount}`), rowLayout = (0, import_vue21.computed)(() => {
       let width = Math.max(0, normalizeInt5(props.w)), base = props.style ?? defaultStyle.value, toggleBase = mergeStyle5(base, props.toggleStyle), active = mergeStyle5(toggleBase, props.activeStyle), disabled = mergeStyle5(toggleBase, props.disabledStyle), error = mergeStyle5(base, props.errorStyle), navigationEnabled = props.state.matchCount > 0 && props.state.status !== "error" && props.state.query.length > 0, prefixPieces = [], suffixSpecs = [], hits = [], prefixWidth = 0, pushPrefix = (text, style, action) => {
         if (!text)
           return;
@@ -8130,7 +10627,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
         );
       }
     }
-    (0, import_vue17.watch)(
+    (0, import_vue21.watch)(
       () => [
         props.state.query,
         props.state.mode,
@@ -8228,7 +10725,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
           clipped && terminal.write(clipped, { x: Math.max(drawX, r.x), y: r.y, style: piece.style });
         }
       }
-    })), () => (0, import_vue17.h)(
+    })), () => (0, import_vue21.h)(
       "div",
       {
         ...rootProps,
@@ -8240,7 +10737,7 @@ var TLogSearchBar = (0, import_vue17.defineComponent)({
 });
 
 // src/vue/components/TLogSearchResults.ts
-var import_vue18 = require("vue");
+var import_vue22 = require("vue");
 var EMPTY_RECT6 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 });
 function clamp9(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -8258,7 +10755,7 @@ function normalizeActiveIndex(value, count) {
   let n = Math.floor(Number(value));
   return !Number.isFinite(n) || n < 0 ? -1 : clamp9(n, 0, count - 1);
 }
-var TLogSearchResults = (0, import_vue18.defineComponent)({
+var TLogSearchResults = (0, import_vue22.defineComponent)({
   name: "TLogSearchResults",
   props: {
     x: { type: Number, required: !0 },
@@ -8289,7 +10786,7 @@ var TLogSearchResults = (0, import_vue18.defineComponent)({
   },
   emits: ["select", "activeChange", "keydown", "focus", "blur"],
   setup(props, { emit }) {
-    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue18.inject)(EventZIndexContextKey, (0, import_vue18.computed)(() => 0)), eventZ = (0, import_vue18.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue18.ref)(!1), internalActiveIndex = (0, import_vue18.ref)(-1), fullRect = (0, import_vue18.computed)(
+    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue22.inject)(EventZIndexContextKey, (0, import_vue22.computed)(() => 0)), eventZ = (0, import_vue22.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue22.ref)(!1), internalActiveIndex = (0, import_vue22.ref)(-1), fullRect = (0, import_vue22.computed)(
       () => translateRect(
         {
           x: normalizeInt6(props.x),
@@ -8300,16 +10797,16 @@ var TLogSearchResults = (0, import_vue18.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue18.computed)(() => {
+    ), rect = (0, import_vue22.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT6 : translated;
-    }), lineNumberDigits = (0, import_vue18.computed)(
+    }), lineNumberDigits = (0, import_vue22.computed)(
       () => props.showLineNumbers ? props.results.reduce(
         (max, result) => Math.max(max, String(result.absoluteLineIndex).length),
         1
       ) : 0
     );
-    (0, import_vue18.watch)(
+    (0, import_vue22.watch)(
       [() => props.activeIndex, () => props.results.length],
       () => {
         internalActiveIndex.value = normalizeActiveIndex(props.activeIndex, props.results.length);
@@ -8440,12 +10937,12 @@ var TLogSearchResults = (0, import_vue18.defineComponent)({
           }), result.text || segments.push({ text: "", style: rowStyle }), writeSegments(y, rowStyle, segments);
         }
       }
-    })), () => (0, import_vue18.h)("span", rootProps);
+    })), () => (0, import_vue22.h)("span", rootProps);
   }
 });
 
 // src/vue/components/TLogSearchPager.ts
-var import_vue19 = require("vue");
+var import_vue23 = require("vue");
 var EMPTY_RECT7 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), PREVIOUS_CHAR2 = "\u25C0", NEXT_CHAR2 = "\u25B6";
 function clamp10(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -8463,7 +10960,7 @@ function formatCount(matchCount) {
 function errorLabel2(error) {
   return error?.kind === "invalid-regex" ? "Invalid regex" : "Search error";
 }
-var TLogSearchPager = (0, import_vue19.defineComponent)({
+var TLogSearchPager = (0, import_vue23.defineComponent)({
   name: "TLogSearchPager",
   props: {
     x: { type: Number, required: !0 },
@@ -8488,7 +10985,7 @@ var TLogSearchPager = (0, import_vue19.defineComponent)({
   },
   emits: ["previousPage", "nextPage", "pageChange"],
   setup(props, { emit }) {
-    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue19.inject)(EventZIndexContextKey, (0, import_vue19.computed)(() => 0)), eventZ = (0, import_vue19.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue19.ref)(!1), fullRect = (0, import_vue19.computed)(
+    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue23.inject)(EventZIndexContextKey, (0, import_vue23.computed)(() => 0)), eventZ = (0, import_vue23.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue23.ref)(!1), fullRect = (0, import_vue23.computed)(
       () => translateRect(
         {
           x: normalizeInt7(props.x),
@@ -8499,10 +10996,10 @@ var TLogSearchPager = (0, import_vue19.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue19.computed)(() => {
+    ), rect = (0, import_vue23.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT7 : translated;
-    }), viewState = (0, import_vue19.computed)(() => props.state), segments = (0, import_vue19.computed)(() => {
+    }), viewState = (0, import_vue23.computed)(() => props.state), segments = (0, import_vue23.computed)(() => {
       let base = props.style ?? defaultStyle.value, active = mergeStyle7(base, props.activeStyle), disabled = mergeStyle7(base, props.disabledStyle), error = mergeStyle7(base, props.errorStyle), state = viewState.value;
       if (!state || state.status === "idle")
         return [{ text: "No search", style: base }];
@@ -8623,7 +11120,7 @@ var TLogSearchPager = (0, import_vue19.defineComponent)({
             break;
         }
       }
-    })), () => (0, import_vue19.h)(
+    })), () => (0, import_vue23.h)(
       "div",
       {
         ...rootProps,
@@ -8635,7 +11132,7 @@ var TLogSearchPager = (0, import_vue19.defineComponent)({
 });
 
 // src/vue/components/TLogLinksPanel.ts
-var import_vue20 = require("vue");
+var import_vue24 = require("vue");
 var EMPTY_RECT8 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), EMPTY_LABEL = "No visible links";
 function clamp11(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -8653,7 +11150,7 @@ function normalizeActiveIndex2(value, count) {
   let n = Math.floor(Number(value));
   return !Number.isFinite(n) || n < 0 ? -1 : clamp11(n, 0, count - 1);
 }
-var TLogLinksPanel = (0, import_vue20.defineComponent)({
+var TLogLinksPanel = (0, import_vue24.defineComponent)({
   name: "TLogLinksPanel",
   props: {
     x: { type: Number, required: !0 },
@@ -8689,7 +11186,7 @@ var TLogLinksPanel = (0, import_vue20.defineComponent)({
   },
   emits: ["select", "activate", "activeChange", "focus", "blur", "keydown"],
   setup(props, { emit }) {
-    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue20.inject)(EventZIndexContextKey, (0, import_vue20.computed)(() => 0)), eventZ = (0, import_vue20.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue20.ref)(!1), internalActiveIndex = (0, import_vue20.ref)(-1), fullRect = (0, import_vue20.computed)(
+    let { terminal, scheduler, defaultStyle, events } = useTerminal(), parent = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue24.inject)(EventZIndexContextKey, (0, import_vue24.computed)(() => 0)), eventZ = (0, import_vue24.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), focused = (0, import_vue24.ref)(!1), internalActiveIndex = (0, import_vue24.ref)(-1), fullRect = (0, import_vue24.computed)(
       () => translateRect(
         {
           x: normalizeInt8(props.x),
@@ -8700,13 +11197,13 @@ var TLogLinksPanel = (0, import_vue20.defineComponent)({
         parent.originX,
         parent.originY
       )
-    ), rect = (0, import_vue20.computed)(() => {
+    ), rect = (0, import_vue24.computed)(() => {
       let translated = fullRect.value;
       return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT8 : translated;
-    }), lineNumberDigits = (0, import_vue20.computed)(
+    }), lineNumberDigits = (0, import_vue24.computed)(
       () => props.showLineNumbers ? props.links.reduce((max, link) => Math.max(max, String(link.absoluteLineIndex).length), 1) : 0
     );
-    (0, import_vue20.watch)(
+    (0, import_vue24.watch)(
       [() => props.activeIndex, () => props.links.length],
       () => {
         internalActiveIndex.value = normalizeActiveIndex2(props.activeIndex, props.links.length);
@@ -8846,12 +11343,12 @@ var TLogLinksPanel = (0, import_vue20.defineComponent)({
           }), item.text && segments.push({ text: item.text, style: rowStyle }), props.showHref && item.href && (item.text && segments.push({ text: " ", style: rowStyle }), segments.push({ text: item.href, style: hrefRowStyle })), segments.length || segments.push({ text: "", style: rowStyle }), writeSegments(y, rowStyle, segments);
         }
       }
-    })), () => (0, import_vue20.h)("span", rootProps);
+    })), () => (0, import_vue24.h)("span", rootProps);
   }
 });
 
 // src/vue/components/TLogVirtualSearchResults.ts
-var import_vue21 = require("vue");
+var import_vue25 = require("vue");
 function sliceByCells2(text, start, end) {
   let cells = 0, out = "";
   for (let ch of text) {
@@ -8867,7 +11364,7 @@ function formatItem(item, width, showLineNumbers) {
   let currentPrefix = item.current ? "*" : " ", linePrefix = showLineNumbers ? `${String(item.absoluteLineIndex).padStart(5, " ")} ` : "", before = sliceByCells2(item.text, 0, item.matchStartCell), match = sliceByCells2(item.text, item.matchStartCell, item.matchEndCell), after = sliceByCells2(item.text, item.matchEndCell, Number.MAX_SAFE_INTEGER);
   return `${currentPrefix}${linePrefix}${before}[${match}]${after}`.slice(0, Math.max(0, width));
 }
-var TLogVirtualSearchResults = (0, import_vue21.defineComponent)({
+var TLogVirtualSearchResults = (0, import_vue25.defineComponent)({
   name: "TLogVirtualSearchResults",
   props: {
     x: { type: Number, required: !0 },
@@ -8892,7 +11389,7 @@ var TLogVirtualSearchResults = (0, import_vue21.defineComponent)({
   },
   emits: ["update:modelValue", "activeChange", "select", "focus", "blur", "keydown", "scroll"],
   setup(props, { emit }) {
-    let model = (0, import_vue21.computed)({
+    let model = (0, import_vue25.computed)({
       get: () => props.modelValue,
       set: (value) => {
         emit("update:modelValue", value), emit("activeChange", {
@@ -8901,7 +11398,7 @@ var TLogVirtualSearchResults = (0, import_vue21.defineComponent)({
         });
       }
     });
-    return () => (0, import_vue21.h)(TVirtualList, {
+    return () => (0, import_vue25.h)(TVirtualList, {
       x: props.x,
       y: props.y,
       w: props.w,
@@ -8939,14 +11436,14 @@ var TLogVirtualSearchResults = (0, import_vue21.defineComponent)({
 });
 
 // src/vue/components/TLogVirtualLinksPanel.ts
-var import_vue22 = require("vue");
+var import_vue26 = require("vue");
 function formatItem2(item, width, showLineNumbers) {
   if (!item)
     return "";
   let currentPrefix = item.current ? "*" : " ", linePrefix = showLineNumbers ? `${String(item.absoluteLineIndex).padStart(5, " ")} ` : "";
   return `${currentPrefix}${linePrefix}${item.text} -> ${item.href}`.slice(0, Math.max(0, width));
 }
-var TLogVirtualLinksPanel = (0, import_vue22.defineComponent)({
+var TLogVirtualLinksPanel = (0, import_vue26.defineComponent)({
   name: "TLogVirtualLinksPanel",
   props: {
     x: { type: Number, required: !0 },
@@ -8978,7 +11475,7 @@ var TLogVirtualLinksPanel = (0, import_vue22.defineComponent)({
     "scroll"
   ],
   setup(props, { emit }) {
-    let model = (0, import_vue22.computed)({
+    let model = (0, import_vue26.computed)({
       get: () => props.modelValue,
       set: (value) => {
         emit("update:modelValue", value), emit("activeChange", {
@@ -8987,7 +11484,7 @@ var TLogVirtualLinksPanel = (0, import_vue22.defineComponent)({
         });
       }
     });
-    return () => (0, import_vue22.h)(TVirtualList, {
+    return () => (0, import_vue26.h)(TVirtualList, {
       x: props.x,
       y: props.y,
       w: props.w,
@@ -9025,7 +11522,7 @@ var TLogVirtualLinksPanel = (0, import_vue22.defineComponent)({
 });
 
 // src/vue/log/append-only-log-store.ts
-var import_vue23 = require("vue");
+var import_vue27 = require("vue");
 function normalizeMaxLines(value) {
   if (value == null)
     return null;
@@ -9033,7 +11530,7 @@ function normalizeMaxLines(value) {
   return Number.isFinite(n) ? Math.max(1, n) : null;
 }
 function createAppendOnlyLogStore(options) {
-  let lines = [], version = (0, import_vue23.ref)(0), maxLines = normalizeMaxLines(options?.maxLines), head = 0, firstLineIndex = 0, tail = "", tailVersion = 0, nextLineId = 0;
+  let lines = [], version = (0, import_vue27.ref)(0), maxLines = normalizeMaxLines(options?.maxLines), head = 0, firstLineIndex = 0, tail = "", tailVersion = 0, nextLineId = 0;
   function bump() {
     version.value++;
   }
@@ -9107,7 +11604,7 @@ function createAppendOnlyLogStore(options) {
 }
 
 // src/vue/log/use-tlog-link-controller.ts
-var import_vue24 = require("vue");
+var import_vue28 = require("vue");
 
 // src/vue/log/tlog-plugins.ts
 function escapeRegExp(value) {
@@ -9414,7 +11911,7 @@ function actionKey(value) {
   ]);
 }
 function useTLogLinkController(logView, options = {}) {
-  let visibleLinks = (0, import_vue24.ref)([]), activeIndex = (0, import_vue24.ref)(-1), suppressedActivateKey = null;
+  let visibleLinks = (0, import_vue28.ref)([]), activeIndex = (0, import_vue28.ref)(-1), suppressedActivateKey = null;
   function emitAction(action) {
     options.onAction?.(action), dispatchTLogPluginLinkAction(options.plugins, action);
   }
@@ -9479,7 +11976,7 @@ function useTLogLinkController(logView, options = {}) {
     }
     emitAction(action), refresh();
   }
-  return (0, import_vue24.watch)(
+  return (0, import_vue28.watch)(
     () => logView.value,
     () => {
       refresh();
@@ -9501,10 +11998,10 @@ function useTLogLinkController(logView, options = {}) {
 }
 
 // src/vue/log/use-tlog-search-controller.ts
-var import_vue26 = require("vue");
+var import_vue30 = require("vue");
 
 // src/vue/log/use-tlog-search-results-page.ts
-var import_vue25 = require("vue"), DEFAULT_PAGE_SIZE = 20;
+var import_vue29 = require("vue"), DEFAULT_PAGE_SIZE = 20;
 function clamp12(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
@@ -9536,7 +12033,7 @@ function createEmptyState(pageSize, status = "idle", error = null) {
   };
 }
 function useTLogSearchResultsPage(logView, options = {}) {
-  let pageSize = normalizePageSize(options.pageSize), includePreview = options.includePreview === !0, currentPage = (0, import_vue25.ref)(0), state = (0, import_vue25.ref)(createEmptyState(pageSize));
+  let pageSize = normalizePageSize(options.pageSize), includePreview = options.includePreview === !0, currentPage = (0, import_vue29.ref)(0), state = (0, import_vue29.ref)(createEmptyState(pageSize));
   function clear(status = "idle", error = null) {
     currentPage.value = 0, state.value = createEmptyState(pageSize, status, error);
   }
@@ -9596,7 +12093,7 @@ function useTLogSearchResultsPage(logView, options = {}) {
     let normalizedMatchIndex = normalizeInt9(matchIndex, -1);
     return handle.selectSearchMatch(normalizedMatchIndex) ? (currentPage.value = Math.floor(normalizedMatchIndex / pageSize), refresh(), !0) : (refresh(), !1);
   }
-  return (0, import_vue25.watch)(
+  return (0, import_vue29.watch)(
     () => logView.value,
     () => {
       currentPage.value = 0, refresh();
@@ -9633,7 +12130,7 @@ function sameSavedSearch(a, b) {
   return a.query === b.query && a.mode === b.mode && !!a.caseSensitive == !!b.caseSensitive && !!a.wholeWord == !!b.wholeWord && (a.regexFlags ?? "") === (b.regexFlags ?? "");
 }
 function useTLogSearchController(logView, options = {}) {
-  let query = (0, import_vue26.ref)(options.initialQuery ?? ""), mode = (0, import_vue26.ref)(options.initialMode === "regex" ? "regex" : "text"), caseSensitive = (0, import_vue26.ref)(options.initialCaseSensitive === !0), wholeWord = (0, import_vue26.ref)(options.initialWholeWord === !0), regexFlags = (0, import_vue26.ref)(options.initialRegexFlags ?? ""), searchState = (0, import_vue26.ref)(normalizeSearchState(query.value)), markers = (0, import_vue26.ref)([]), metrics2 = (0, import_vue26.ref)(null), searchHistory = (0, import_vue26.ref)([]), savedSearches = (0, import_vue26.ref)(options.initialSavedSearches ?? []), historyLimit = normalizeHistoryLimit(options.maxHistory), resultsPage = useTLogSearchResultsPage(logView, options), nextSavedSearchId = 0;
+  let query = (0, import_vue30.ref)(options.initialQuery ?? ""), mode = (0, import_vue30.ref)(options.initialMode === "regex" ? "regex" : "text"), caseSensitive = (0, import_vue30.ref)(options.initialCaseSensitive === !0), wholeWord = (0, import_vue30.ref)(options.initialWholeWord === !0), regexFlags = (0, import_vue30.ref)(options.initialRegexFlags ?? ""), searchState = (0, import_vue30.ref)(normalizeSearchState(query.value)), markers = (0, import_vue30.ref)([]), metrics2 = (0, import_vue30.ref)(null), searchHistory = (0, import_vue30.ref)([]), savedSearches = (0, import_vue30.ref)(options.initialSavedSearches ?? []), historyLimit = normalizeHistoryLimit(options.maxHistory), resultsPage = useTLogSearchResultsPage(logView, options), nextSavedSearchId = 0;
   function nextSavedSearchIdValue() {
     let id = "";
     do
@@ -9641,7 +12138,7 @@ function useTLogSearchController(logView, options = {}) {
     while (savedSearches.value.some((entry) => entry.id === id));
     return id;
   }
-  let searchBarState = (0, import_vue26.computed)(() => ({
+  let searchBarState = (0, import_vue30.computed)(() => ({
     query: query.value,
     mode: mode.value,
     caseSensitive: caseSensitive.value,
@@ -9746,7 +12243,7 @@ function useTLogSearchController(logView, options = {}) {
       regexFlags: entry.regexFlags || void 0
     }));
   }
-  return (0, import_vue26.watch)(
+  return (0, import_vue30.watch)(
     () => logView.value,
     () => {
       refresh();
@@ -9783,13 +12280,13 @@ function useTLogSearchController(logView, options = {}) {
 }
 
 // src/vue/log/use-tlog-virtual-search-results.ts
-var import_vue27 = require("vue");
+var import_vue31 = require("vue");
 function normalizeInt10(value, fallback = 0) {
   let n = Math.floor(Number(value));
   return Number.isFinite(n) ? n : fallback;
 }
 function useTLogVirtualSearchResults(logView, options = {}) {
-  let state = (0, import_vue27.ref)({
+  let state = (0, import_vue31.ref)({
     itemCount: 0,
     itemVersion: 0,
     activeIndex: -1,
@@ -9848,7 +12345,7 @@ function useTLogVirtualSearchResults(logView, options = {}) {
     let selected = handle.selectSearchMatch(normalizeInt10(matchIndex, -1));
     return refresh(), selected;
   }
-  return (0, import_vue27.watch)(() => logView.value, refresh, { immediate: !0 }), {
+  return (0, import_vue31.watch)(() => logView.value, refresh, { immediate: !0 }), {
     state,
     refresh,
     getItem,
@@ -9857,7 +12354,7 @@ function useTLogVirtualSearchResults(logView, options = {}) {
 }
 
 // src/vue/log/use-tlog-retained-index.ts
-var import_vue28 = require("vue");
+var import_vue32 = require("vue");
 var DEFAULT_BUDGET_MS = 4, DEFAULT_MAX_ITEMS = 1e4;
 function clamp13(n, min, max) {
   return Math.max(min, Math.min(max, n));
@@ -9874,7 +12371,7 @@ function sanitizeIndexedExternalHref(value, options = {}) {
   return sanitizeTerminalHref(value, options);
 }
 function useTLogRetainedIndex(logView, source, version, options = {}) {
-  let status = (0, import_vue28.ref)("idle"), links = (0, import_vue28.ref)([]), diagnostics = (0, import_vue28.ref)([]), density = (0, import_vue28.ref)([]), plugins = (0, import_vue28.computed)(() => {
+  let status = (0, import_vue32.ref)("idle"), links = (0, import_vue32.ref)([]), diagnostics = (0, import_vue32.ref)([]), density = (0, import_vue32.ref)([]), plugins = (0, import_vue32.computed)(() => {
     let builtins = [];
     return options.links && builtins.push(createTLogOsc8LinkPlugin()), options.urls && builtins.push(createTLogUrlPlugin({ allowFileUrls: options.allowFileUrls })), options.levels && builtins.push(createTLogLevelPlugin({ bucketCount: options.bucketCount })), [...builtins, ...options.plugins ?? []];
   }), generation = 0, cursor = 0, rafHandle = null, indexedLines = [];
@@ -10004,7 +12501,7 @@ function useTLogRetainedIndex(logView, source, version, options = {}) {
   function refresh() {
     cancel(), indexedLines = [], links.value = [], diagnostics.value = [], density.value = [], cursor = 0, status.value = "indexing", schedule();
   }
-  return (0, import_vue28.watch)([() => source.value, () => version.value, () => logView.value], refresh, {
+  return (0, import_vue32.watch)([() => source.value, () => version.value, () => logView.value], refresh, {
     immediate: !0
   }), {
     status,
@@ -10017,7 +12514,7 @@ function useTLogRetainedIndex(logView, source, version, options = {}) {
 }
 
 // src/vue/log/tlog-session.ts
-var import_vue29 = require("vue");
+var import_vue33 = require("vue");
 function clamp14(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
@@ -10035,7 +12532,7 @@ function deserializeTLogViewSessionState(value) {
   }
 }
 function createTLogViewSessionStore(options = {}) {
-  let storageKey = options.storageKey ?? "@simon_he/vue-tui:tlog-session", storage = options.storage ?? globalThis.localStorage ?? null, state = (0, import_vue29.ref)(null);
+  let storageKey = options.storageKey ?? "@simon_he/vue-tui:tlog-session", storage = options.storage ?? globalThis.localStorage ?? null, state = (0, import_vue33.ref)(null);
   function load() {
     let next = deserializeTLogViewSessionState(storage?.getItem(storageKey));
     return state.value = next, next;