@termaxjs/web-react 0.1.1

package/dist/pool/rendererPool.js

@@ -0,0 +1,1281 @@
+function detectMonoFontFamily(...args) {
+    return args[0] || "JetBrains Mono, Menlo, Monaco, monospace";
+}
+function scheduleOnce(fn) {
+    const raf = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame(fn) : setTimeout(fn, 16);
+    return raf;
+}
+function cancelFrame(raf) {
+    if (typeof cancelAnimationFrame !== "undefined")
+        cancelAnimationFrame(raf);
+    else
+        clearTimeout(raf);
+}
+let activeConfig = {
+    getPreferences: () => ({}),
+    getTheme: () => ({}),
+    openFile: () => { },
+    openUrl: async (url) => {
+        if (typeof window !== "undefined")
+            window.open(url, "_blank");
+    },
+};
+export function initRendererPool(config) {
+    activeConfig = {
+        ...activeConfig,
+        ...config,
+    };
+}
+export function setRendererPoolPreferencesGetter(fn) {
+    activeConfig.getPreferences = fn;
+}
+const usePreferencesStore = {
+    getState: () => activeConfig.getPreferences ? activeConfig.getPreferences() : {},
+};
+export function setRendererPoolOpenFileHandler(fn) {
+    activeConfig.openFile = fn;
+}
+const openFileTab = (...args) => {
+    if (activeConfig.openFile)
+        activeConfig.openFile(...args);
+};
+export function setRendererPoolThemeGetter(fn) {
+    activeConfig.getTheme = fn;
+}
+function buildTerminalTheme(...args) {
+    if (activeConfig.getTheme)
+        return activeConfig.getTheme();
+    return args[0] || {};
+}
+export function setRendererPoolOpenUrlHandler(fn) {
+    activeConfig.openUrl = fn;
+}
+const openUrl = (url) => {
+    if (activeConfig.openUrl)
+        return activeConfig.openUrl(url);
+    return Promise.resolve();
+};
+import { AsciinemaAddon, CopyModeAddon, FitAddon, ImageAddon, LigaturesAddon, Osc133Addon, PathLinkProvider, SearchAddon, SerializeAddon, WebglAddon, WebLinksAddon, } from "@termaxjs/web-addons";
+import { shouldCursorBlink, Terminal, terminalDeleteSequence, terminalLineNavigationSequence, terminalScrollAction, terminalWordNavigationSequence, } from "@termaxjs/web-ui";
+export const POOL_MAX_SIZE = 5;
+const FIT_DEBOUNCE_MS = 8;
+const PTY_RESIZE_DEBOUNCE_MS = 16;
+const SNAPSHOT_SCROLLBACK_CAP = 5_000;
+const slots = [];
+let recyclerEl = null;
+let adapter = null;
+let windowActive = typeof document === "undefined" || (!document.hidden && document.hasFocus());
+let windowActivityBound = false;
+let cursorBlinkEnabled = false;
+function bindWindowActivityListeners() {
+    if (windowActivityBound || typeof window === "undefined")
+        return;
+    windowActivityBound = true;
+    const sync = () => setWindowActive(!document.hidden && document.hasFocus());
+    window.addEventListener("focus", sync);
+    window.addEventListener("blur", sync);
+    document.addEventListener("visibilitychange", sync);
+}
+function setWindowActive(active) {
+    if (windowActive === active)
+        return;
+    windowActive = active;
+    for (const slot of slots) {
+        if (slot.currentLeafId === null)
+            continue;
+        applyCursorBlinkOnSlot(slot, adapter?.isLeafFocused(slot.currentLeafId) ?? false);
+    }
+}
+export function configureRendererPool(a) {
+    adapter = a;
+    bindWindowActivityListeners();
+}
+export function forEachSlot(fn) {
+    for (const s of slots)
+        fn(s);
+}
+export function poolSize() {
+    return slots.length;
+}
+export function poolSlotStats() {
+    return slots.map((s) => ({
+        id: s.id,
+        leafId: s.currentLeafId,
+        cols: s.term.cols,
+        rows: s.term.rows,
+        bufferLines: s.term.buffer.active.length,
+        webgl: !!s.webglAddon,
+        canvases: s.webglCanvases.length,
+    }));
+}
+// Bracketed paste via xterm, so an app that enabled it (Claude Code) treats a
+// dropped path as a real paste while a plain shell gets the literal text.
+export function pasteIntoLeaf(leafId, text) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return false;
+    slot.term.paste(text);
+    return true;
+}
+export function toggleCopyModeForLeaf(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return false;
+    slot.copyModeAddon.toggle();
+    return true;
+}
+const termKeyHandlers = new WeakMap();
+export function registerCustomKeyHandler(term, handler) {
+    let list = termKeyHandlers.get(term);
+    if (!list) {
+        list = [];
+        termKeyHandlers.set(term, list);
+    }
+    list.push(handler);
+    return () => {
+        const l = termKeyHandlers.get(term);
+        if (l) {
+            const idx = l.indexOf(handler);
+            if (idx !== -1)
+                l.splice(idx, 1);
+        }
+    };
+}
+function getRecycler() {
+    if (recyclerEl?.isConnected)
+        return recyclerEl;
+    const el = document.createElement("div");
+    el.setAttribute("data-termax-recycler", "");
+    el.style.cssText =
+        "position:fixed;left:-99999px;top:-99999px;width:1024px;height:768px;overflow:hidden;pointer-events:none;contain:strict;";
+    document.body.appendChild(el);
+    recyclerEl = el;
+    return el;
+}
+const MCR_BG_ACTIVE = 4.5;
+const MCR_BG_INACTIVE = 1;
+function bgActive(prefs) {
+    return prefs.backgroundKind === "image" && !!prefs.backgroundImageId;
+}
+function termOptions() {
+    const prefs = usePreferencesStore.getState();
+    const theme = buildTerminalTheme();
+    if (prefs.terminalCursorAnimation) {
+        theme.cursor = "transparent";
+        theme.cursorAccent = "transparent";
+    }
+    const cursorStyle = prefs.terminalCursorStyle ?? "bar";
+    const cursorInactiveStyle = cursorStyle === "block" ? "outline" : cursorStyle;
+    return {
+        fontFamily: prefs.terminalFontFamily || detectMonoFontFamily(),
+        letterSpacing: prefs.terminalLetterSpacing,
+        fontSize: Math.max(4, Math.round(prefs.terminalFontSize * prefs.zoomLevel)),
+        theme,
+        cursorBlink: false,
+        cursorStyle,
+        cursorInactiveStyle,
+        scrollback: prefs.terminalScrollback,
+        smoothScrollDuration: prefs.terminalSmoothScrolling ? 150 : 0,
+        allowProposedApi: true,
+        minimumContrastRatio: bgActive(prefs) ? MCR_BG_ACTIVE : MCR_BG_INACTIVE,
+        wordSeparator: " ()[]{}'\"`",
+    };
+}
+function applyHostPadding(slot) {
+    const prefs = usePreferencesStore.getState();
+    const padTop = prefs.terminalPaddingTop ?? prefs.terminalPadding ?? 0;
+    const padRight = prefs.terminalPaddingRight ?? prefs.terminalPadding ?? 0;
+    const padBottom = prefs.terminalPaddingBottom ?? prefs.terminalPadding ?? 0;
+    const padLeft = prefs.terminalPaddingLeft ?? prefs.terminalPadding ?? 0;
+    slot.host.style.paddingTop = `${padTop}px`;
+    slot.host.style.paddingRight = `${padRight}px`;
+    slot.host.style.paddingBottom = `${padBottom}px`;
+    slot.host.style.paddingLeft = `${padLeft}px`;
+    slot.host.style.boxSizing = "border-box";
+    slot.host.style.backgroundColor = "inherit";
+}
+export function applyBackgroundActive(active) {
+    const value = active ? MCR_BG_ACTIVE : MCR_BG_INACTIVE;
+    for (const slot of slots) {
+        if (slot.term.options.minimumContrastRatio === value)
+            continue;
+        slot.term.options.minimumContrastRatio = value;
+    }
+}
+function createSlot() {
+    const prefs = usePreferencesStore.getState();
+    const term = new Terminal(termOptions());
+    const initialStyle = prefs.terminalCursorStyle ?? "bar";
+    if (term.vt?.cursor) {
+        term.vt.cursor.shape = initialStyle;
+    }
+    const fitAddon = new FitAddon();
+    const searchAddon = new SearchAddon();
+    const serializeAddon = new SerializeAddon();
+    const imageAddon = new ImageAddon();
+    const copyModeAddon = new CopyModeAddon();
+    const osc133Addon = new Osc133Addon();
+    const asciinemaAddon = new AsciinemaAddon();
+    term.loadAddon(fitAddon);
+    term.loadAddon(searchAddon);
+    term.loadAddon(serializeAddon);
+    term.loadAddon(imageAddon);
+    term.loadAddon(copyModeAddon);
+    term.loadAddon(osc133Addon);
+    term.loadAddon(asciinemaAddon);
+    let linkHoverTooltip = null;
+    const showTooltip = (e, _text) => {
+        if (!linkHoverTooltip) {
+            linkHoverTooltip = document.createElement("div");
+            linkHoverTooltip.style.position = "fixed";
+            linkHoverTooltip.style.zIndex = "999999";
+            linkHoverTooltip.style.background = "hsl(var(--card, #18181b))";
+            linkHoverTooltip.style.color = "hsl(var(--foreground, #fafafa))";
+            linkHoverTooltip.style.padding = "4px 8px";
+            linkHoverTooltip.style.borderRadius = "6px";
+            linkHoverTooltip.style.fontSize = "11px";
+            linkHoverTooltip.style.fontWeight = "500";
+            linkHoverTooltip.style.fontFamily = "var(--font-sans)";
+            linkHoverTooltip.style.boxShadow = "0 4px 16px rgba(0,0,0,0.35)";
+            linkHoverTooltip.style.border =
+                "1px solid hsl(var(--border, #27272a) / 0.8)";
+            linkHoverTooltip.style.pointerEvents = "none";
+            linkHoverTooltip.style.whiteSpace = "nowrap";
+            linkHoverTooltip.style.backdropFilter = "blur(8px)";
+            document.body.appendChild(linkHoverTooltip);
+        }
+        const cmdKey = navigator.userAgent.includes("Mac") ? "Cmd" : "Ctrl";
+        linkHoverTooltip.innerHTML = `<span style="opacity: 0.85">${cmdKey} + click to follow link</span>`;
+        const x = Math.max(10, Math.min(e.clientX + 8, window.innerWidth - 220));
+        const y = e.clientY + 24 > window.innerHeight - 40
+            ? e.clientY - 28
+            : e.clientY + 18;
+        linkHoverTooltip.style.left = `${x}px`;
+        linkHoverTooltip.style.top = `${y}px`;
+        linkHoverTooltip.style.display = "block";
+    };
+    const hideTooltip = () => {
+        if (linkHoverTooltip)
+            linkHoverTooltip.style.display = "none";
+    };
+    term.loadAddon(new WebLinksAddon((_e, uri) => openUrl(uri).catch(console.error), {
+        hover: (e, text) => showTooltip(e, text),
+        leave: () => hideTooltip(),
+    }));
+    term.registerLinkProvider(new PathLinkProvider(term, {
+        hover: (e, text) => showTooltip(e, text),
+        leave: () => hideTooltip(),
+    }, (path, line) => openFileTab(path, true, line)));
+    const host = document.createElement("div");
+    host.style.cssText =
+        "width:100%;height:100%;position:relative;box-sizing:border-box;";
+    host.setAttribute("data-termax-slot", String(slots.length));
+    const cursorNode = document.createElement("div");
+    cursorNode.className = "termax-custom-cursor";
+    cursorNode.style.position = "absolute";
+    cursorNode.style.top = "0";
+    cursorNode.style.left = "0";
+    cursorNode.style.pointerEvents = "none";
+    cursorNode.style.zIndex = "10";
+    cursorNode.style.borderRadius = "1px";
+    cursorNode.style.opacity = "0";
+    cursorNode.style.transitionProperty = "transform, opacity, width, height";
+    cursorNode.style.transitionDuration = "80ms";
+    cursorNode.style.transitionTimingFunction = "cubic-bezier(0.2, 0.9, 0.4, 1)";
+    cursorNode.style.background = "var(--terminal-cursor, var(--tx-text, #fff))";
+    getRecycler().appendChild(host);
+    term.open(host);
+    host.appendChild(cursorNode);
+    const slot = {
+        id: slots.length,
+        term,
+        fitAddon,
+        searchAddon,
+        serializeAddon,
+        imageAddon,
+        copyModeAddon,
+        osc133Addon,
+        asciinemaAddon,
+        host,
+        cursorNode,
+        webglAddon: null,
+        ligaturesAddon: null,
+        webglCanvases: [],
+        currentLeafId: null,
+        oscDisposers: [],
+        observer: null,
+        fitTimer: null,
+        ptyTimer: null,
+        webglReapTimer: null,
+        slotReapTimer: null,
+        unhideRaf: null,
+        lastCols: term.cols,
+        lastRows: term.rows,
+        lastW: 0,
+        lastH: 0,
+        lastUsedAt: 0,
+    };
+    let cursorIdleTimer = null;
+    let cursorBlinkInterval = null;
+    let cursorRaf = null;
+    const stopAnimatedCursorBlink = () => {
+        if (cursorIdleTimer) {
+            clearTimeout(cursorIdleTimer);
+            cursorIdleTimer = null;
+        }
+        if (cursorBlinkInterval) {
+            clearInterval(cursorBlinkInterval);
+            cursorBlinkInterval = null;
+        }
+    };
+    const updateCursor = () => {
+        const prefs = usePreferencesStore.getState();
+        if (!prefs.terminalCursorAnimation || !slot.lastCols || !slot.lastRows) {
+            stopAnimatedCursorBlink();
+            cursorNode.style.opacity = "0";
+            return;
+        }
+        // Only show custom cursor if window is active and this slot is focused
+        const isFocused = slot.currentLeafId !== null &&
+            (adapter ? adapter.isLeafFocused(slot.currentLeafId) : true);
+        if (!windowActive || !isFocused) {
+            stopAnimatedCursorBlink();
+            cursorNode.style.opacity = "0";
+            return;
+        }
+        stopAnimatedCursorBlink();
+        cursorNode.style.opacity = "1";
+        const padTop = prefs.terminalPaddingTop ?? prefs.terminalPadding ?? 0;
+        const padRight = prefs.terminalPaddingRight ?? prefs.terminalPadding ?? 0;
+        const padBottom = prefs.terminalPaddingBottom ?? prefs.terminalPadding ?? 0;
+        const padLeft = prefs.terminalPaddingLeft ?? prefs.terminalPadding ?? 0;
+        const rendererCharW = slot.term.renderer?.charWidth || 9;
+        const rendererCharH = slot.term.renderer?.charHeight || 18;
+        const cw = slot.lastW > 0
+            ? (slot.lastW - padLeft - padRight) / slot.lastCols
+            : rendererCharW;
+        const ch = slot.lastH > 0
+            ? (slot.lastH - padTop - padBottom) / slot.lastRows
+            : rendererCharH;
+        const cx = padLeft + term.buffer.active.cursorX * cw;
+        const cy = padTop + term.buffer.active.cursorY * ch;
+        const style = prefs.terminalCursorStyle ?? "bar";
+        if (style === "underline") {
+            cursorNode.style.transform = `translate(${cx}px, ${cy + ch - 2}px)`;
+            cursorNode.style.width = `${cw}px`;
+            cursorNode.style.height = "2px";
+            cursorNode.style.mixBlendMode = "normal";
+        }
+        else if (style === "bar") {
+            cursorNode.style.transform = `translate(${cx}px, ${cy}px)`;
+            cursorNode.style.width = "2px";
+            cursorNode.style.height = `${ch}px`;
+            cursorNode.style.mixBlendMode = "normal";
+        }
+        else {
+            cursorNode.style.transform = `translate(${cx}px, ${cy}px)`;
+            cursorNode.style.width = `${cw}px`;
+            cursorNode.style.height = `${ch}px`;
+            cursorNode.style.mixBlendMode = "difference";
+        }
+        if (prefs.terminalCursorBlink) {
+            cursorIdleTimer = setTimeout(() => {
+                let visible = true;
+                cursorBlinkInterval = setInterval(() => {
+                    visible = !visible;
+                    cursorNode.style.opacity = visible ? "1" : "0";
+                }, 530);
+            }, 500);
+        }
+    };
+    const scheduleCursorUpdate = () => {
+        if (cursorRaf !== null)
+            return;
+        cursorRaf = scheduleOnce(() => {
+            cursorRaf = null;
+            updateCursor();
+        });
+    };
+    slot.updateCursor = updateCursor;
+    term.onCursorMove(scheduleCursorUpdate);
+    term.onRender(scheduleCursorUpdate);
+    term.onWriteParsed(scheduleCursorUpdate);
+    term.onData(updateCursor);
+    term.onKey(updateCursor);
+    host.addEventListener("focusin", updateCursor);
+    host.addEventListener("focusout", updateCursor);
+    term.attachCustomKeyEventHandler((event) => {
+        // During IME composition the browser is assembling a multi-keystroke
+        // character (Chinese pinyin → hanzi, Korean jamo → syllable, etc.).
+        // Raw keydown events — including the Enter that commits a candidate —
+        // must NOT be forwarded to the PTY; xterm will receive the final
+        // composed string through its own compositionend handler instead.
+        // keyCode 229 ("Process") is what Chromium reports for every key
+        // pressed inside an active IME session when isComposing is not yet set.
+        if (event.isComposing || event.keyCode === 229)
+            return false;
+        const extraHandlers = termKeyHandlers.get(term);
+        if (extraHandlers) {
+            for (const h of extraHandlers) {
+                const res = h(event);
+                if (res !== undefined)
+                    return res;
+            }
+        }
+        if (slot.copyModeAddon.isActive) {
+            return slot.copyModeAddon.handleKey(event);
+        }
+        const leafId = slot.currentLeafId;
+        if (leafId === null)
+            return false;
+        const bridge = adapter?.resolveLeaf(leafId);
+        if (!bridge)
+            return true;
+        const lineNavigation = terminalLineNavigationSequence(event, {
+            isMac: IS_MAC,
+        });
+        if (lineNavigation) {
+            event.preventDefault();
+            if (event.type === "keydown")
+                bridge.writeToPty(lineNavigation);
+            return false;
+        }
+        const wordNavigation = terminalWordNavigationSequence(event, {
+            isMac: IS_MAC,
+        });
+        if (wordNavigation) {
+            event.preventDefault();
+            if (event.type === "keydown")
+                bridge.writeToPty(wordNavigation);
+            return false;
+        }
+        const deleteSeq = terminalDeleteSequence(event, { isMac: IS_MAC });
+        if (deleteSeq) {
+            event.preventDefault();
+            if (event.type === "keydown")
+                bridge.writeToPty(deleteSeq);
+            return false;
+        }
+        if (isShiftEnter(event)) {
+            event.preventDefault();
+            if (event.type === "keydown")
+                bridge.writeToPty("\x1b\r");
+            return false;
+        }
+        if (isTerminalCopy(event)) {
+            if (event.type === "keydown" && slot.term.hasSelection()) {
+                const sel = slot.term.getSelection();
+                if (sel)
+                    void navigator.clipboard.writeText(sel).catch(() => { });
+            }
+            event.preventDefault();
+            return false;
+        }
+        if (isTerminalPaste(event)) {
+            if (event.type === "keydown") {
+                void navigator.clipboard
+                    .readText()
+                    .then((text) => {
+                    if (text)
+                        slot.term.paste(text);
+                })
+                    .catch(() => { });
+            }
+            event.preventDefault();
+            return false;
+        }
+        const scrollAction = terminalScrollAction(event, { isMac: IS_MAC });
+        if (scrollAction) {
+            event.preventDefault();
+            if (event.type === "keydown") {
+                if (scrollAction === "top")
+                    slot.term.scrollToTop();
+                else
+                    slot.term.scrollToBottom();
+            }
+            return false;
+        }
+        // Default: allow event through
+        return true;
+    });
+    term.onData((data) => {
+        const leafId = slot.currentLeafId;
+        if (leafId === null)
+            return;
+        adapter?.resolveLeaf(leafId)?.writeToPty(data);
+    });
+    slots.push(slot);
+    return slot;
+}
+function isAltScreen(s) {
+    try {
+        return s.term.buffer.active.type === "alternate";
+    }
+    catch {
+        return false;
+    }
+}
+function pickSlotFor(leafId) {
+    const free = slots.find((s) => s.currentLeafId === null);
+    if (free)
+        return { slot: free, previousLeafId: null };
+    if (slots.length < POOL_MAX_SIZE)
+        return { slot: createSlot(), previousLeafId: null };
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const s of slots) {
+        if (s.currentLeafId === leafId)
+            return { slot: s, previousLeafId: null };
+        const focused = s.currentLeafId !== null &&
+            (adapter?.isLeafFocused(s.currentLeafId) ?? false);
+        const blocks = s.currentLeafId !== null &&
+            (adapter?.isLeafBlocks(s.currentLeafId) ?? false);
+        const score = (isAltScreen(s) ? 100 : 0) +
+            (blocks ? 50 : 0) +
+            (focused ? 10 : 0) +
+            s.lastUsedAt / 1e12;
+        if (score < bestScore) {
+            bestScore = score;
+            best = s;
+        }
+    }
+    const chosen = best;
+    return { slot: chosen, previousLeafId: chosen.currentLeafId };
+}
+export function acquireSlot(params) {
+    const existing = slots.find((s) => s.currentLeafId === params.leafId);
+    if (existing) {
+        rewireSlot(existing, params);
+        return existing;
+    }
+    const pick = pickSlotFor(params.leafId);
+    if (pick.previousLeafId !== null) {
+        adapter?.evictLeaf(pick.previousLeafId);
+    }
+    if (pick.slot.currentLeafId !== null &&
+        pick.slot.currentLeafId !== params.leafId) {
+        detachSlotFromLeaf(pick.slot);
+    }
+    bindSlot(pick.slot, params);
+    return pick.slot;
+}
+function bindSlot(slot, p) {
+    const stale = !slot.webglAddon || performance.now() - slot.lastUsedAt > SLOT_STALE_MS;
+    slot.currentLeafId = p.leafId;
+    slot.lastUsedAt = performance.now();
+    cancelPendingUnhide(slot);
+    cancelWebglReap(slot);
+    cancelSlotReap(slot);
+    slot.host.style.visibility = "hidden";
+    if (slot.host.parentNode !== p.container) {
+        p.container.appendChild(slot.host);
+    }
+    applyHostPadding(slot);
+    setupResizeObserver(slot, p);
+    slot.fitAddon.fit();
+    slot.lastCols = slot.term.cols;
+    slot.lastRows = slot.term.rows;
+    slot.lastW = p.container.clientWidth;
+    slot.lastH = p.container.clientHeight;
+    slot.term.options.disableStdin = p.shellExited;
+    slot.term.clear();
+    slot.term.reset();
+    if (p.snapshot) {
+        try {
+            slot.term.write(p.snapshot);
+        }
+        catch (e) {
+            console.warn("[termax] snapshot replay failed:", e);
+        }
+    }
+    if (p.altScreen) {
+        p.drainRing(() => { });
+    }
+    else {
+        p.drainRing((bytes) => slot.term.write(bytes));
+    }
+    try {
+        slot.term.write("\x1b[?25h");
+    }
+    catch (e) {
+        console.warn("[rendererPool]", e);
+    }
+    for (const d of slot.oscDisposers) {
+        try {
+            d();
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    const d1 = slot.term.onTitleChange((title) => p.onTitle?.(title));
+    const d2 = slot.term.onBell(() => p.onBell?.());
+    slot.oscDisposers = [
+        ...p.registerOsc(slot.term),
+        () => d1.dispose(),
+        () => d2.dispose(),
+    ];
+    if (slot.lastCols !== p.cols || slot.lastRows !== p.rows) {
+        if (slot.lastCols > 0 && slot.lastRows > 0) {
+            adapter?.resolveLeaf(p.leafId)?.resizePty(slot.lastCols, slot.lastRows);
+        }
+    }
+    if (p.searchQuery) {
+        try {
+            slot.searchAddon.findNext(p.searchQuery);
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    applyCursorBlinkOnSlot(slot, adapter?.isLeafFocused(p.leafId) ?? false);
+    const containerReady = p.container.clientWidth > 0 && p.container.clientHeight > 0;
+    if (p.altScreen && !p.shellExited) {
+        if (slot.term.cols > 0 && slot.term.rows > 0 && containerReady) {
+            adapter?.resolveLeaf(p.leafId)?.kickPty(slot.term.cols, slot.term.rows);
+        }
+    }
+    scheduleUnhide(slot, stale, p.altScreen && !p.shellExited && !containerReady);
+    p.onSearchReady(slot.searchAddon);
+}
+function scheduleUnhide(slot, stale, needsDeferredKick = false) {
+    slot.unhideRaf = scheduleOnce(() => {
+        slot.unhideRaf = null;
+        slot.host.style.visibility = "";
+        try {
+            slot.fitAddon.fit();
+            slot.term.scrollToBottom();
+            slot.updateCursor?.();
+        }
+        catch { }
+        if (stale) {
+            if (!slot.webglAddon)
+                attachWebgl(slot);
+            try {
+                slot.term.refresh(0, slot.term.rows - 1);
+            }
+            catch (e) {
+                console.warn("[rendererPool]", e);
+            }
+        }
+        const leafId = slot.currentLeafId;
+        if (needsDeferredKick &&
+            leafId !== null &&
+            slot.term.cols > 0 &&
+            slot.term.rows > 0) {
+            adapter?.resolveLeaf(leafId)?.kickPty(slot.term.cols, slot.term.rows);
+        }
+        if (leafId !== null && adapter?.isLeafFocused(leafId)) {
+            slot.term.focus();
+        }
+    });
+}
+function cancelPendingUnhide(slot) {
+    if (slot.unhideRaf !== null) {
+        cancelFrame(slot.unhideRaf);
+        slot.unhideRaf = null;
+    }
+}
+function rewireSlot(slot, p) {
+    slot.lastUsedAt = performance.now();
+    if (slot.host.parentNode !== p.container) {
+        p.container.appendChild(slot.host);
+    }
+    applyHostPadding(slot);
+    setupResizeObserver(slot, p);
+    slot.fitAddon.fit();
+    if (p.container.clientWidth > 0 && p.container.clientHeight > 0) {
+        slot.lastW = p.container.clientWidth;
+        slot.lastH = p.container.clientHeight;
+    }
+    if (slot.term.cols > 0 &&
+        slot.term.rows > 0 &&
+        (slot.term.cols !== p.cols || slot.term.rows !== p.rows)) {
+        adapter?.resolveLeaf(p.leafId)?.resizePty(slot.term.cols, slot.term.rows);
+    }
+    slot.lastCols = slot.term.cols;
+    slot.lastRows = slot.term.rows;
+    slot.updateCursor?.();
+    p.onSearchReady(slot.searchAddon);
+}
+function setupResizeObserver(slot, p) {
+    slot.observer?.disconnect();
+    if (slot.fitTimer)
+        clearTimeout(slot.fitTimer);
+    if (slot.ptyTimer)
+        clearTimeout(slot.ptyTimer);
+    slot.fitTimer = null;
+    slot.ptyTimer = null;
+    const container = p.container;
+    const flushPty = () => {
+        slot.ptyTimer = null;
+        if (slot.currentLeafId !== p.leafId)
+            return;
+        if (slot.term.cols === slot.lastCols && slot.term.rows === slot.lastRows)
+            return;
+        if (slot.term.cols <= 0 || slot.term.rows <= 0)
+            return;
+        slot.lastCols = slot.term.cols;
+        slot.lastRows = slot.term.rows;
+        adapter?.resolveLeaf(p.leafId)?.resizePty(slot.lastCols, slot.lastRows);
+    };
+    slot.observer = new ResizeObserver(() => {
+        if (slot.fitTimer)
+            clearTimeout(slot.fitTimer);
+        slot.fitTimer = setTimeout(() => {
+            slot.fitTimer = null;
+            if (slot.currentLeafId !== p.leafId)
+                return;
+            const w = container.clientWidth;
+            const h = container.clientHeight;
+            if (w <= 0 || h <= 0)
+                return;
+            if (w === slot.lastW && h === slot.lastH)
+                return;
+            slot.lastW = w;
+            slot.lastH = h;
+            slot.fitAddon.fit();
+            slot.term.scrollToBottom();
+            slot.updateCursor?.();
+            if (slot.ptyTimer)
+                clearTimeout(slot.ptyTimer);
+            slot.ptyTimer = setTimeout(flushPty, PTY_RESIZE_DEBOUNCE_MS);
+        }, FIT_DEBOUNCE_MS);
+    });
+    slot.observer.observe(container);
+}
+export function releaseSlot(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return null;
+    const out = serializeSlot(slot);
+    detachSlotFromLeaf(slot);
+    return out;
+}
+function serializeSlot(slot) {
+    let snapshot = null;
+    try {
+        const cap = Math.min(SNAPSHOT_SCROLLBACK_CAP, usePreferencesStore.getState().terminalScrollback);
+        snapshot = slot.serializeAddon.serialize({ scrollback: cap });
+    }
+    catch (e) {
+        console.warn("[termax] serialize failed:", e);
+    }
+    return {
+        snapshot,
+        cols: slot.term.cols,
+        rows: slot.term.rows,
+        altScreen: isAltScreen(slot),
+    };
+}
+function detachSlotFromLeaf(slot) {
+    for (const d of slot.oscDisposers) {
+        try {
+            d();
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    slot.oscDisposers = [];
+    slot.observer?.disconnect();
+    slot.observer = null;
+    if (slot.fitTimer)
+        clearTimeout(slot.fitTimer);
+    if (slot.ptyTimer)
+        clearTimeout(slot.ptyTimer);
+    slot.fitTimer = null;
+    slot.ptyTimer = null;
+    cancelPendingUnhide(slot);
+    slot.host.style.visibility = "";
+    if (slot.host.parentNode !== getRecycler()) {
+        getRecycler().appendChild(slot.host);
+    }
+    slot.currentLeafId = null;
+    slot.lastUsedAt = performance.now();
+    scheduleWebglReap(slot);
+    scheduleSlotReap(slot);
+}
+function scheduleWebglReap(slot) {
+    cancelWebglReap(slot);
+    if (!slot.webglAddon)
+        return;
+    slot.webglReapTimer = setTimeout(() => {
+        slot.webglReapTimer = null;
+        if (slot.currentLeafId === null)
+            disposeSlotWebgl(slot);
+    }, WEBGL_REAP_GRACE_MS);
+}
+function cancelWebglReap(slot) {
+    if (slot.webglReapTimer !== null) {
+        clearTimeout(slot.webglReapTimer);
+        slot.webglReapTimer = null;
+    }
+}
+function scheduleSlotReap(slot) {
+    cancelSlotReap(slot);
+    slot.slotReapTimer = setTimeout(() => {
+        slot.slotReapTimer = null;
+        reapIdleSlot(slot);
+    }, SLOT_REAP_GRACE_MS);
+}
+function cancelSlotReap(slot) {
+    if (slot.slotReapTimer !== null) {
+        clearTimeout(slot.slotReapTimer);
+        slot.slotReapTimer = null;
+    }
+}
+function reapIdleSlot(slot) {
+    if (slot.currentLeafId !== null)
+        return;
+    const idle = slots.filter((s) => s.currentLeafId === null);
+    if (idle.length <= IDLE_SLOTS_KEEP_WARM)
+        return;
+    idle.sort((a, b) => a.lastUsedAt - b.lastUsedAt);
+    const surplus = idle.slice(0, idle.length - IDLE_SLOTS_KEEP_WARM);
+    if (surplus.includes(slot))
+        disposeSlot(slot);
+}
+function disposeSlot(slot) {
+    cancelSlotReap(slot);
+    cancelWebglReap(slot);
+    cancelPendingUnhide(slot);
+    if (slot.fitTimer)
+        clearTimeout(slot.fitTimer);
+    if (slot.ptyTimer)
+        clearTimeout(slot.ptyTimer);
+    slot.fitTimer = null;
+    slot.ptyTimer = null;
+    slot.observer?.disconnect();
+    slot.observer = null;
+    for (const d of slot.oscDisposers) {
+        try {
+            d();
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    slot.oscDisposers = [];
+    disposeSlotWebgl(slot);
+    try {
+        slot.term.dispose();
+    }
+    catch (e) {
+        console.warn("[termax] slot dispose failed:", e);
+    }
+    slot.host.remove();
+    const i = slots.indexOf(slot);
+    if (i >= 0)
+        slots.splice(i, 1);
+}
+const WEBGL_RECOVERY_DELAY_MS = 250;
+// Below this a re-shown slot is fresh enough to trust; above it, repaint on
+// unhide to defeat silent GPU/context staleness.
+const SLOT_STALE_MS = 10_000;
+const WEBGL_REAP_GRACE_MS = 30_000;
+const SLOT_REAP_GRACE_MS = 45_000;
+const IDLE_SLOTS_KEEP_WARM = 1;
+function attachWebgl(slot) {
+    if (slot.webglAddon || !slot.term.element)
+        return;
+    if (!usePreferencesStore.getState().terminalWebglEnabled)
+        return;
+    const elem = slot.term.element;
+    const before = new Set(elem.querySelectorAll("canvas"));
+    try {
+        const webgl = new WebglAddon();
+        webgl.onContextLoss(() => {
+            const cur = slot.webglAddon;
+            if (cur === webgl) {
+                slot.webglAddon = null;
+                slot.webglCanvases = [];
+            }
+            try {
+                webgl.dispose();
+            }
+            catch (e) {
+                console.warn("[rendererPool]", e);
+            }
+            // Recovery: WebKit may transiently lose contexts on sleep/wake or GPU
+            // reset; without re-attach the slot would silently fall back to DOM
+            // forever. Defer past WebKit's reset window before retrying.
+            setTimeout(() => {
+                if (slot.webglAddon || slot.currentLeafId === null)
+                    return;
+                if (!usePreferencesStore.getState().terminalWebglEnabled)
+                    return;
+                attachWebgl(slot);
+                if (slot.webglAddon) {
+                    try {
+                        slot.term.refresh(0, slot.term.rows - 1);
+                    }
+                    catch (e) {
+                        console.warn("[rendererPool]", e);
+                    }
+                }
+            }, WEBGL_RECOVERY_DELAY_MS);
+        });
+        slot.term.loadAddon(webgl);
+        const after = elem.querySelectorAll("canvas");
+        const added = [];
+        for (const c of after)
+            if (!before.has(c))
+                added.push(c);
+        slot.webglAddon = webgl;
+        slot.webglCanvases = added;
+    }
+    catch (e) {
+        console.warn("[termax-webgl] unavailable:", e);
+    }
+}
+function disposeSlotWebgl(slot) {
+    if (!slot.webglAddon)
+        return;
+    const addon = slot.webglAddon;
+    for (const canvas of slot.webglCanvases)
+        releaseCanvasContext(canvas);
+    slot.webglCanvases = [];
+    try {
+        addon.dispose();
+    }
+    catch (e) {
+        console.warn("[termax-webgl] dispose failed:", e);
+    }
+    try {
+        const r = addon._renderer;
+        if (r) {
+            r._canvas = null;
+            r._gl = null;
+            r._charAtlas = null;
+            r._atlas = null;
+        }
+        addon._renderer = null;
+        addon._renderService = null;
+    }
+    catch (e) {
+        console.warn("[rendererPool]", e);
+    }
+    slot.webglAddon = null;
+}
+function releaseCanvasContext(canvas) {
+    let gl = null;
+    try {
+        gl = canvas.getContext("webgl2");
+    }
+    catch (e) {
+        console.warn("[rendererPool]", e);
+    }
+    if (!gl) {
+        try {
+            gl = canvas.getContext("webgl");
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    if (gl) {
+        try {
+            const ext = gl.getExtension("WEBGL_lose_context");
+            if (ext && !gl.isContextLost())
+                ext.loseContext();
+        }
+        catch (e) {
+            console.warn("[rendererPool]", e);
+        }
+    }
+    try {
+        canvas.width = 0;
+        canvas.height = 0;
+    }
+    catch (e) {
+        console.warn("[rendererPool]", e);
+    }
+}
+export function applyWebglPreference(enabled) {
+    for (const slot of slots) {
+        if (enabled) {
+            if (slot.currentLeafId !== null && !slot.webglAddon) {
+                attachWebgl(slot);
+                if (slot.webglAddon) {
+                    try {
+                        slot.term.refresh(0, slot.term.rows - 1);
+                    }
+                    catch (e) {
+                        console.warn("[rendererPool]", e);
+                    }
+                }
+            }
+        }
+        else if (slot.webglAddon) {
+            cancelWebglReap(slot);
+            disposeSlotWebgl(slot);
+        }
+    }
+}
+export function applyFontSize(size) {
+    for (const slot of slots) {
+        if (slot.term.options.fontSize === size)
+            continue;
+        slot.term.options.fontSize = size;
+        slot.fitAddon.fit();
+        if (slot.currentLeafId !== null) {
+            slot.lastCols = slot.term.cols;
+            slot.lastRows = slot.term.rows;
+            const bridge = adapter?.resolveLeaf(slot.currentLeafId);
+            bridge?.resizePty(slot.term.cols, slot.term.rows);
+        }
+    }
+}
+export function applyLetterSpacing(spacing) {
+    for (const slot of slots) {
+        if (slot.term.options.letterSpacing === spacing)
+            continue;
+        slot.term.options.letterSpacing = spacing;
+        slot.fitAddon.fit();
+    }
+}
+export function applyFontFamily(family) {
+    const resolved = family || detectMonoFontFamily();
+    for (const slot of slots) {
+        if (slot.term.options.fontFamily === resolved)
+            continue;
+        slot.term.options.fontFamily = resolved;
+        slot.fitAddon.fit();
+        if (slot.currentLeafId !== null) {
+            slot.lastCols = slot.term.cols;
+            slot.lastRows = slot.term.rows;
+            const bridge = adapter?.resolveLeaf(slot.currentLeafId);
+            bridge?.resizePty(slot.term.cols, slot.term.rows);
+        }
+    }
+}
+export function applyScrollback(value) {
+    for (const slot of slots) {
+        if (slot.term.options.scrollback === value)
+            continue;
+        slot.term.options.scrollback = value;
+    }
+}
+function applyLigaturesOnSlot(slot, enabled) {
+    if (enabled && !slot.ligaturesAddon) {
+        slot.ligaturesAddon = new LigaturesAddon();
+        slot.term.loadAddon(slot.ligaturesAddon);
+    }
+    else if (!enabled && slot.ligaturesAddon) {
+        slot.ligaturesAddon.dispose();
+        slot.ligaturesAddon = null;
+    }
+}
+export function restoreWindowActivity() {
+    const theme = buildTerminalTheme();
+    const prefs = usePreferencesStore.getState();
+    if (prefs.terminalCursorAnimation) {
+        theme.cursor = "transparent";
+        theme.cursorAccent = "transparent";
+    }
+    for (const slot of slots) {
+        slot.term.updateTheme(theme);
+    }
+}
+export function applyTheme() {
+    const theme = buildTerminalTheme();
+    const prefs = usePreferencesStore.getState();
+    const rawCursor = theme.cursor;
+    if (prefs.terminalCursorAnimation) {
+        theme.cursor = "transparent";
+        theme.cursorAccent = "transparent";
+    }
+    for (const slot of slots) {
+        slot.term.updateTheme(theme);
+        if (rawCursor && rawCursor !== "transparent") {
+            slot.cursorNode.style.background = rawCursor;
+        }
+        else {
+            slot.cursorNode.style.background =
+                "var(--terminal-cursor, var(--tx-text, #fff))";
+        }
+        applyHostPadding(slot);
+        slot.updateCursor?.();
+        try {
+            slot.term.refresh(0, slot.term.rows - 1);
+        }
+        catch { }
+    }
+}
+export function applyCursorAnimation(_enabled) {
+    applyTheme();
+    for (const slot of slots) {
+        slot.updateCursor?.();
+    }
+}
+export function applyThemeToLeaf(leafId, theme) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (slot && theme) {
+        const prefs = usePreferencesStore.getState();
+        const clonedTheme = { ...theme };
+        const rawCursor = clonedTheme.cursor;
+        if (prefs.terminalCursorAnimation) {
+            clonedTheme.cursor = "transparent";
+            clonedTheme.cursorAccent = "transparent";
+        }
+        slot.term.updateTheme(clonedTheme);
+        if (rawCursor && rawCursor !== "transparent") {
+            slot.cursorNode.style.background = rawCursor;
+        }
+        else {
+            slot.cursorNode.style.background =
+                "var(--terminal-cursor, var(--tx-text, #fff))";
+        }
+        slot.updateCursor?.();
+        try {
+            slot.term.refresh(0, slot.term.rows - 1);
+        }
+        catch { }
+    }
+}
+export function focusSlot(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return;
+    slot.term.focus();
+    slot.updateCursor?.();
+}
+export function setSlotFocused(leafId, focused) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return;
+    applyCursorBlinkOnSlot(slot, focused);
+    if (focused) {
+        slot.term.focus();
+    }
+    slot.updateCursor?.();
+}
+export function applyTerminalPadding() {
+    for (const slot of slots) {
+        applyHostPadding(slot);
+        try {
+            slot.fitAddon.fit();
+            if (slot.currentLeafId !== null) {
+                slot.lastCols = slot.term.cols;
+                slot.lastRows = slot.term.rows;
+                const bridge = adapter?.resolveLeaf(slot.currentLeafId);
+                bridge?.resizePty(slot.term.cols, slot.term.rows);
+            }
+            slot.updateCursor?.();
+            slot.term.refresh(0, slot.term.rows - 1);
+        }
+        catch { }
+    }
+}
+export function applyLigatures(enabled) {
+    for (const slot of slots) {
+        applyLigaturesOnSlot(slot, enabled);
+    }
+}
+export function applyCursorBlink(enabled) {
+    cursorBlinkEnabled = enabled;
+    for (const slot of slots) {
+        if (slot.currentLeafId === null)
+            continue;
+        applyCursorBlinkOnSlot(slot, adapter?.isLeafFocused(slot.currentLeafId) ?? false);
+    }
+}
+function applyCursorBlinkOnSlot(slot, focused) {
+    const desired = shouldCursorBlink(cursorBlinkEnabled, windowActive, focused);
+    if (slot.term.options.cursorBlink === desired)
+        return;
+    slot.term.options.cursorBlink = desired;
+    if (typeof slot.term.setCursorBlink === "function") {
+        slot.term.setCursorBlink(desired);
+    }
+}
+export function applyCursorStyle(style) {
+    for (const slot of slots) {
+        slot.term.options.cursorStyle = style;
+        slot.term.options.cursorInactiveStyle =
+            style === "block" ? "outline" : style;
+        if (typeof slot.term.setCursorStyle === "function") {
+            slot.term.setCursorStyle(style);
+        }
+        else {
+            if (slot.term.vt?.cursor) {
+                slot.term.vt.cursor.shape = style;
+            }
+            if (slot.term.renderer?.options) {
+                slot.term.renderer.options.cursorStyle = style;
+            }
+        }
+        slot.updateCursor?.();
+        try {
+            slot.term.refresh(0, slot.term.rows - 1);
+        }
+        catch { }
+    }
+}
+export function getSlotForLeaf(leafId) {
+    return slots.find((s) => s.currentLeafId === leafId) ?? null;
+}
+export function isLeafAltScreen(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    return slot ? isAltScreen(slot) : false;
+}
+export function parkLeafSlot(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (slot)
+        disposeSlotWebgl(slot);
+}
+export function refreshLeafSlot(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (!slot)
+        return;
+    if (usePreferencesStore.getState().terminalWebglEnabled && !slot.webglAddon) {
+        attachWebgl(slot);
+    }
+    try {
+        slot.fitAddon.fit();
+        slot.term.scrollToBottom();
+        slot.lastCols = slot.term.cols;
+        slot.lastRows = slot.term.rows;
+        adapter?.resolveLeaf(leafId)?.resizePty(slot.lastCols, slot.lastRows);
+        slot.term.refresh(0, slot.term.rows - 1);
+    }
+    catch (e) {
+        console.warn("[rendererPool]", e);
+    }
+}
+export function disposeLeafSlot(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    if (slot)
+        disposeSlot(slot);
+}
+const IS_MAC = typeof navigator !== "undefined" &&
+    /Mac|iPhone|iPad/.test(navigator.userAgent);
+function isTerminalCopy(e) {
+    return (!IS_MAC &&
+        e.ctrlKey &&
+        e.shiftKey &&
+        !e.altKey &&
+        !e.metaKey &&
+        (e.code === "KeyC" || e.key === "c" || e.key === "C"));
+}
+function isTerminalPaste(e) {
+    return (!IS_MAC &&
+        e.ctrlKey &&
+        e.shiftKey &&
+        !e.altKey &&
+        !e.metaKey &&
+        (e.code === "KeyV" || e.key === "v" || e.key === "V"));
+}
+function isShiftEnter(e) {
+    return (e.key === "Enter" && e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey);
+}
+export function getAsciinemaForLeaf(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    return slot?.asciinemaAddon ?? null;
+}
+export function getOsc133ForLeaf(leafId) {
+    const slot = slots.find((s) => s.currentLeafId === leafId);
+    return slot?.osc133Addon ?? null;
+}
+//# sourceMappingURL=rendererPool.js.map