@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/keepers/terminal/pty.js

@@ -1,330 +1 @@
-// Persistent PTY sessions (tmux-like): each session keeps a headless xterm screen and a bounded ring of rendered output;
-// clients `attach` (snapshot) and `poll(after)` (delta, or a snapshot reset when they fell behind). Control is explicit
-// (controller / takeover / detach), at most 8 sessions, exited sessions stay listed until closed. Spec §4.1.
-//
-// This is the one implementation: keeper-terminal serves it as `pty.*` (main.ts); the daemon's `terminal.*` reaches it through
-// tools/terminalRouter.ts.
-//
-// Keeper-side module: node builtins, kit siblings and the bundled @xterm packages only (the import guard enforces it).
-// Sessions are independent: there is no queue across sessions (a slow operation on one never delays another).
-import { execFile } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import xtermHeadless from '@xterm/headless';
-import xtermSerialize from '@xterm/addon-serialize';
-import { KeeperMethodError } from '../kit/protocol.js';
-import { PTY_HISTORY_BYTES, PTY_INPUT_BYTES, PTY_LABEL_CHARS, PTY_MAX_POLL_BYTES, PTY_RESULT_BYTES, PTY_SCROLLBACK, PTY_SESSION_LIMIT, PTY_UNAVAILABLE_ERROR, PtyErrorCode, } from './protocol.js';
-// CommonJS packages: their default export is `module.exports` both under Node and once esbuild bundles them.
-const { Terminal } = xtermHeadless;
-const { SerializeAddon } = xtermSerialize;
-const darwinShellName = (pid) => new Promise((resolve) => {
-    execFile('ps', ['-o', 'ucomm=', '-p', String(pid)], { timeout: 1000 }, (error, stdout) => resolve(error ? null : stdout.trim() || null));
-});
-const defaultShellProcessName = (pid) => (process.platform === 'darwin' ? darwinShellName(pid) : Promise.resolve(null));
-// Parameter checks (today's tools/validation.ts rules; kept here so the keeper bundle depends on no daemon module).
-const bad = (message) => { throw new KeeperMethodError(PtyErrorCode.badRequest, message); };
-function keys(params, allowed) {
-    if (Object.keys(params).some((key) => !allowed.includes(key)))
-        bad('Unexpected tool parameter');
-}
-function identifier(params, name) {
-    const value = params[name];
-    if (typeof value !== 'string' || !value.length || value.includes('\0') || value.length > 128 || !/^[A-Za-z0-9_.:-]+$/.test(value))
-        bad(`Invalid ${name}`);
-    return value;
-}
-function integer(params, name, min, max, fallback) {
-    const value = params[name] === undefined ? fallback : params[name];
-    if (!Number.isSafeInteger(value) || value < min || value > max)
-        bad(`Invalid ${name}`);
-    return value;
-}
-/** The basename of a foreground process name, without the leading '-' a login shell may carry. */
-export const processBasename = (name) => path.basename(name.trim()).replace(/^-/, '');
-export const CREATE_KEYS = ['id', 'clientId', 'name', 'cwd', 'cols', 'rows'];
-export const PTY_OPERATIONS = new Set(['attach', 'poll', 'write', 'resize', 'takeover', 'detach', 'close']);
-export class PtySessions {
-    options;
-    sessions = new Map();
-    ptyModule;
-    error;
-    now;
-    constructor(options = {}) {
-        this.options = options;
-        this.now = options.now ?? Date.now;
-        try {
-            this.ptyModule = (options.loadPty ?? (() => createRequire(import.meta.url)('node-pty')))();
-        }
-        catch {
-            this.error = PTY_UNAVAILABLE_ERROR;
-        }
-    }
-    get available() { return !!this.ptyModule; }
-    descriptor(s) {
-        return { id: s.id, name: s.name, cwd: s.cwd, cols: s.cols, rows: s.rows, exited: s.exited, exitCode: s.exitCode, controllerId: s.controllerId };
-    }
-    control(s, clientId) {
-        if (s.controllerId !== clientId)
-            throw new KeeperMethodError(PtyErrorCode.notController, 'Terminal is controlled by another client; take control explicitly');
-    }
-    resize(s, p) {
-        const cols = integer(p, 'cols', 20, 300, s.cols);
-        const rows = integer(p, 'rows', 5, 100, s.rows);
-        if (cols !== s.cols || rows !== s.rows) {
-            if (!s.exited)
-                s.pty.resize(cols, rows);
-            s.terminal.resize(cols, rows);
-            s.cols = cols;
-            s.rows = rows;
-        }
-    }
-    snapshot(s) {
-        // Scroll position belongs to the viewer, never the keeper. Serialization includes normal and
-        // alternate buffers, SGR attributes, cursor and modes; it starts from a clean emulator.
-        for (let scrollback = PTY_SCROLLBACK;; scrollback = Math.floor(scrollback / 2)) {
-            const snapshot = '\x1bc' + s.serializer.serialize({ scrollback });
-            if (Buffer.byteLength(JSON.stringify({ snapshot })) < PTY_RESULT_BYTES - 8192)
-                return snapshot;
-            if (!scrollback)
-                throw new KeeperMethodError(PtyErrorCode.snapshotTooLarge, 'Terminal screen exceeds snapshot limit; resize to a smaller viewport');
-        }
-    }
-    output(s, data) {
-        if (!data || s.closed)
-            return;
-        const bytes = Buffer.byteLength(data);
-        s.pendingBytes += bytes;
-        if (s.pendingBytes > 256 * 1024)
-            s.pty.pause();
-        // Written to xterm at once, not chained behind the previous write's callback: xterm parses writes and runs their
-        // callbacks strictly in order, so sequence numbers stay per event and `rendered` (the newest write's promise) still
-        // means "everything received so far is rendered". Chaining cost one timer tick per event, and node-pty on macOS
-        // delivers line-by-line output as one ~10-byte event per line (~9 KB/s rendered, a paused shell behind it).
-        s.rendered = new Promise((resolve) => {
-            s.terminal.write(data, () => {
-                // Each PTY event is a sequence boundary. A single large event can exceed the history budget;
-                // dropping it is safe because poll then returns a fully rendered snapshot.
-                s.seq += 1;
-                s.ring.push({ seq: s.seq, data, bytes });
-                s.ringBytes += bytes;
-                const limit = this.options.historyBytes ?? PTY_HISTORY_BYTES;
-                while (s.ringBytes > limit && s.ring.length)
-                    s.ringBytes -= s.ring.shift().bytes;
-                s.pendingBytes -= bytes;
-                if (s.pendingBytes < 64 * 1024 && !s.exited)
-                    s.pty.resume();
-                resolve();
-            });
-        });
-    }
-    unavailable() { throw new KeeperMethodError(PtyErrorCode.unavailable, this.error ?? 'Terminal unavailable'); }
-    list(p) {
-        keys(p, []);
-        return { sessions: [...this.sessions.values()].map((s) => this.descriptor(s)) };
-    }
-    /**
-     * Creates session `id`, or returns the existing one (idempotent). `allowedKeys` is the caller's parameter set; `launch`
-     * supplies cwd, shell and env and runs only when a session is really started (after the duplicate and limit checks,
-     * which are re-checked afterwards because `launch` may be asynchronous).
-     */
-    async create(p, allowedKeys, launch) {
-        if (!this.ptyModule)
-            this.unavailable();
-        const id = identifier(p, 'id');
-        const clientId = identifier(p, 'clientId');
-        keys(p, allowedKeys);
-        const cols = integer(p, 'cols', 20, 300, 100);
-        const rows = integer(p, 'rows', 5, 100, 30);
-        if (p.name !== undefined && (typeof p.name !== 'string' || !p.name.length || p.name.length > 128 || /[\x00-\x1f]/.test(p.name)))
-            bad('Invalid terminal name');
-        const existing = () => { const old = this.sessions.get(id); return old && this.descriptor(old); };
-        const limit = () => { if (this.sessions.size >= PTY_SESSION_LIMIT)
-            throw new KeeperMethodError(PtyErrorCode.limit, 'Terminal session limit exceeded'); };
-        let old = existing();
-        if (old)
-            return old;
-        limit();
-        const { cwd, shell, env } = await launch();
-        old = existing();
-        if (old)
-            return old; // a concurrent create of the same id won
-        limit();
-        const terminal = new Terminal({ cols, rows, scrollback: PTY_SCROLLBACK, allowProposedApi: true });
-        const serializer = new SerializeAddon();
-        // Headless and browser xterm share the addon contract, but their declaration packages differ.
-        terminal.loadAddon(serializer);
-        let pty;
-        try {
-            pty = this.ptyModule.spawn(shell, ['-l'], { name: 'xterm-256color', cwd, cols, rows, env: { ...env, TERM: 'xterm-256color', COLORTERM: 'truecolor' } });
-        }
-        catch (error) {
-            terminal.dispose();
-            throw error;
-        }
-        const created = this.now();
-        const shellName = processBasename(shell);
-        const session = {
-            id, name: p.name ?? 'Terminal', cwd, cols, rows, exited: false, exitCode: null, controllerId: clientId,
-            pty, closed: false, terminal, serializer, seq: 0, ring: [], ringBytes: 0, pendingBytes: 0, rendered: Promise.resolve(),
-            shellName, exitedAt: 0, shellNames: new Set([shellName]), observed: { label: shellName, state: 'idle', since: created },
-        };
-        pty.onData((data) => this.output(session, data));
-        pty.onExit((event) => { session.exited = true; session.exitCode = event.exitCode; session.exitedAt = this.now(); });
-        // Answering terminal queries (DA/DSR, etc.) is keeper-owned and does not require a web client.
-        terminal.onData((data) => { if (!session.exited)
-            pty.write(data); });
-        this.sessions.set(id, session);
-        const learn = setTimeout(() => { void this.learnShellName(session); }, this.options.shellNameDelayMs ?? 250);
-        learn.unref();
-        return this.descriptor(session);
-    }
-    /** attach / poll / write / resize / takeover / detach / close on an existing session. */
-    async operate(op, p) {
-        if (!this.ptyModule)
-            this.unavailable();
-        const id = identifier(p, 'id');
-        const clientId = identifier(p, 'clientId');
-        const s = this.sessions.get(id);
-        if (!s)
-            throw new KeeperMethodError(PtyErrorCode.notFound, 'Terminal session not found; keeper restart loses live PTYs');
-        switch (op) {
-            case 'attach': {
-                keys(p, ['id', 'clientId', 'cols', 'rows']);
-                // Validate dimensions even for a viewer, but only the controller's dimensions affect PTY.
-                integer(p, 'cols', 20, 300, s.cols);
-                integer(p, 'rows', 5, 100, s.rows);
-                await s.rendered;
-                if (s.controllerId === null)
-                    s.controllerId = clientId;
-                if (s.controllerId === clientId)
-                    this.resize(s, p);
-                return { session: this.descriptor(s), seq: s.seq, snapshot: this.snapshot(s), control: s.controllerId === clientId };
-            }
-            case 'poll': {
-                keys(p, ['id', 'clientId', 'after']);
-                const after = integer(p, 'after', 0, Number.MAX_SAFE_INTEGER);
-                await s.rendered;
-                const common = { exited: s.exited, exitCode: s.exitCode, control: s.controllerId === clientId };
-                if (after > s.seq || after < (s.ring[0]?.seq ?? s.seq + 1) - 1)
-                    return { ...common, seq: s.seq, data: '', reset: true, snapshot: this.snapshot(s) };
-                let data = '';
-                let bytes = 0;
-                let seq = after;
-                for (const output of s.ring) {
-                    if (output.seq <= after)
-                        continue;
-                    if (bytes + output.bytes > PTY_MAX_POLL_BYTES) {
-                        if (!bytes)
-                            return { ...common, seq: s.seq, data: '', reset: true, snapshot: this.snapshot(s) };
-                        break;
-                    }
-                    data += output.data;
-                    bytes += output.bytes;
-                    seq = output.seq;
-                }
-                return { ...common, seq, data, reset: false };
-            }
-            case 'takeover':
-                keys(p, ['id', 'clientId']);
-                s.controllerId = clientId;
-                return { ok: true };
-            case 'detach':
-                keys(p, ['id', 'clientId']);
-                if (s.controllerId === clientId)
-                    s.controllerId = null;
-                return { ok: true };
-            case 'write':
-                keys(p, ['id', 'clientId', 'data']);
-                this.control(s, clientId);
-                if (s.exited)
-                    throw new KeeperMethodError(PtyErrorCode.exited, 'Terminal has exited');
-                if (typeof p.data !== 'string' || Buffer.byteLength(p.data) > PTY_INPUT_BYTES)
-                    bad('Invalid terminal input');
-                s.pty.write(p.data);
-                return { ok: true };
-            case 'resize':
-                keys(p, ['id', 'clientId', 'cols', 'rows']);
-                this.control(s, clientId);
-                integer(p, 'cols', 20, 300);
-                integer(p, 'rows', 5, 100);
-                await s.rendered;
-                this.resize(s, p);
-                return { ok: true };
-            case 'close':
-                keys(p, ['id', 'clientId']);
-                this.control(s, clientId);
-                this.sessions.delete(id);
-                s.closed = true;
-                if (!s.exited)
-                    s.pty.kill();
-                await s.rendered;
-                s.terminal.dispose();
-                return { ok: true };
-            default: return bad('Unsupported terminal tool');
-        }
-    }
-    /** The tty's foreground process basename, '' when it cannot be read (node-pty falls back to the shell path itself). */
-    foreground(s) {
-        try {
-            return processBasename(String(s.pty.process ?? ''));
-        }
-        catch {
-            return '';
-        }
-    }
-    /**
-     * Learns once per session, in the background shortly after spawn, what the tty calls the shell itself (macOS `p_comm`).
-     * Until it resolves (or when it fails) the configured basename is the only shell name: activity never waits on a subprocess.
-     */
-    async learnShellName(s) {
-        if (s.closed || s.exited)
-            return;
-        try {
-            const name = await (this.options.shellProcessName ?? defaultShellProcessName)(s.pty.pid);
-            if (name)
-                s.shellNames.add(processBasename(name));
-        }
-        catch { /* keep the configured basename */ }
-    }
-    /**
-     * A live sample for `keeper.activity` (spec §3.5/§4.1): `ptyOpen` live sessions, `ptyActive` live sessions whose foreground
-     * process is not their shell, `ptyExited` exited sessions still listed. One item per session, labelled with the foreground
-     * process basename (never its arguments), `sinceEpochMs` = when this label/state was first observed.
-     */
-    activity() {
-        const now = this.now();
-        let open = 0;
-        let active = 0;
-        let exited = 0;
-        const items = [];
-        for (const s of this.sessions.values()) {
-            if (s.exited) {
-                exited += 1;
-                items.push({ type: 'pty', id: s.id, label: s.shellName.slice(0, PTY_LABEL_CHARS), state: 'exited', sinceEpochMs: s.exitedAt });
-                continue;
-            }
-            open += 1;
-            const fg = this.foreground(s);
-            const busy = fg !== '' && !s.shellNames.has(fg);
-            const label = (busy ? fg : s.shellName).slice(0, PTY_LABEL_CHARS);
-            const state = busy ? 'active' : 'idle';
-            if (s.observed.label !== label || s.observed.state !== state)
-                s.observed = { label, state, since: now };
-            if (busy)
-                active += 1;
-            items.push({ type: 'pty', id: s.id, label, state, sinceEpochMs: s.observed.since });
-        }
-        return { metrics: { ptyOpen: open, ptyActive: active, ptyExited: exited }, items };
-    }
-    /** Kills every session (the keeper is stopping). */
-    async dispose() {
-        for (const session of this.sessions.values()) {
-            session.closed = true;
-            if (!session.exited)
-                session.pty.kill();
-            await session.rendered;
-            session.terminal.dispose();
-        }
-        this.sessions.clear();
-    }
-}
+export {};

package/dist/workstation/keepers/terminal/screen.js

@@ -0,0 +1,246 @@
+import xtermHeadless from '@xterm/headless';
+import { TERMINAL_GRID_LIMITS, TERMINAL_RGB_COLOR_BASE, TERMINAL_STYLE_FLAGS, } from './gridProtocol.js';
+const { Terminal } = xtermHeadless;
+const mouseEncodings = { 1005: 'utf8', 1006: 'sgr', 1015: 'urxvt', 1016: 'sgr-pixels' };
+/** Keeper-owned emulator and its single shared, native xterm viewport. */
+export class TerminalScreen {
+    terminal;
+    settled = Promise.resolve();
+    resizeBarrier;
+    pending = new Set();
+    closed = false;
+    normalRestoreTop;
+    alternateScroll = false;
+    mouseEncoding = 'default';
+    constructor(cols, rows) {
+        this.terminal = new Terminal({ cols, rows, scrollback: TERMINAL_GRID_LIMITS.scrollbackLines, allowProposedApi: true });
+        // Observe only the input modes absent from xterm's public API. Native parsing
+        // still owns all escape processing; these handlers fall through to xterm.
+        for (const final of ['h', 'l'])
+            this.terminal.parser.registerCsiHandler({ prefix: '?', final }, params => {
+                for (const param of params) {
+                    if (param === 1007)
+                        this.alternateScroll = final === 'h';
+                    const encoding = typeof param === 'number' ? mouseEncodings[param] : undefined;
+                    if (encoding)
+                        this.mouseEncoding = final === 'h' ? encoding : 'default';
+                }
+                return false;
+            });
+        this.terminal.parser.registerEscHandler({ final: 'c' }, () => {
+            this.alternateScroll = false;
+            this.mouseEncoding = 'default';
+            return false;
+        });
+        this.terminal.buffer.onBufferChange(buffer => {
+            // xterm's isUserScrolling flag is shared by both buffers. Alternate-buffer
+            // scrolling must not change whether normal-buffer output follows the cursor.
+            const top = buffer.type === 'normal' ? this.normalRestoreTop ?? buffer.viewportY : buffer.viewportY;
+            if (buffer.type === 'normal')
+                this.normalRestoreTop = undefined;
+            this.terminal.scrollToBottom();
+            this.terminal.scrollToLine(top);
+        });
+    }
+    write(data) {
+        if (this.closed)
+            return Promise.reject(new Error('Terminal screen is disposed'));
+        const barrier = this.resizeBarrier;
+        const operation = new Promise((resolve, reject) => {
+            this.pending.add(reject);
+            const write = () => {
+                if (this.closed)
+                    return;
+                try {
+                    this.terminal.write(data, () => { this.pending.delete(reject); resolve(); });
+                }
+                catch (error) {
+                    this.pending.delete(reject);
+                    reject(error);
+                }
+            };
+            // Batch ordinary PTY writes directly into xterm; do not add a timer per chunk.
+            if (barrier)
+                void barrier.then(write, error => { this.pending.delete(reject); reject(error); });
+            else
+                write();
+        });
+        this.settled = operation;
+        return operation;
+    }
+    resize(cols, rows) {
+        if (this.closed)
+            return Promise.reject(new Error('Terminal screen is disposed'));
+        const previous = this.settled;
+        const operation = previous.then(() => {
+            if (this.closed)
+                throw new Error('Terminal screen is disposed');
+            const normal = this.terminal.buffer.normal;
+            const anchor = this.anchor(normal);
+            const live = (this.normalRestoreTop ?? normal.viewportY) === normal.baseY;
+            this.terminal.resize(cols, rows);
+            // The native resize reflows both buffers. Restore a content anchor, never
+            // the old numerical line index, which now refers to different content.
+            const top = live ? normal.baseY : anchor ? this.anchorLine(anchor, normal) : 0;
+            if (this.terminal.buffer.active.type === 'normal') {
+                this.terminal.scrollToBottom();
+                this.terminal.scrollToLine(top);
+            }
+            else {
+                this.normalRestoreTop = Math.min(top, normal.baseY);
+            }
+            anchor?.marker.dispose();
+        });
+        this.resizeBarrier = operation;
+        this.settled = operation;
+        void operation.then(() => { if (this.resizeBarrier === operation)
+            this.resizeBarrier = undefined; }, () => {
+            if (this.resizeBarrier === operation)
+                this.resizeBarrier = undefined;
+        });
+        return operation;
+    }
+    scroll(lines) {
+        this.assertOpen();
+        this.terminal.scrollLines(lines);
+    }
+    /** Only settled state may be published; callers await write/resize before capture. */
+    capture() {
+        this.assertOpen();
+        if (this.pending.size || this.resizeBarrier)
+            throw new Error('Terminal screen has pending writes or resize');
+        const terminal = this.terminal;
+        const buffer = terminal.buffer.active;
+        const core = terminal._core;
+        const styles = [];
+        const styleIndices = new Map();
+        const changedRows = Array.from({ length: terminal.rows }, (_, index) => {
+            const line = buffer.getLine(buffer.viewportY + index);
+            const runs = [];
+            for (let x = 0; x < terminal.cols; x++) {
+                const cell = line.getCell(x);
+                const style = cellStyle(cell);
+                const key = `${style.fg},${style.bg},${style.flags}`;
+                let styleIndex = styleIndices.get(key);
+                if (styleIndex === undefined) {
+                    styleIndex = styles.length;
+                    styles.push(style);
+                    styleIndices.set(key, styleIndex);
+                }
+                let run = runs[runs.length - 1];
+                if (!run || run.style !== styleIndex) {
+                    run = { style: styleIndex, cells: [] };
+                    runs.push(run);
+                }
+                // A width-zero continuation still occupies one grid column. Never drop it.
+                run.cells.push({ text: cell.getChars(), width: cell.getWidth() });
+            }
+            return { index, runs, wrapped: line.isWrapped };
+        });
+        const y = buffer.baseY + buffer.cursorY - buffer.viewportY;
+        return {
+            cols: terminal.cols, rows: terminal.rows, buffer: buffer.type,
+            viewport: { top: buffer.viewportY, totalLines: buffer.length, live: buffer.viewportY === buffer.baseY },
+            cursor: {
+                x: Math.min(buffer.cursorX, terminal.cols - 1), y,
+                visible: !core.coreService.isCursorHidden && y >= 0 && y < terminal.rows,
+                shape: core.coreService.decPrivateModes.cursorStyle ?? terminal.options.cursorStyle ?? 'block',
+                blink: core.coreService.decPrivateModes.cursorBlink ?? terminal.options.cursorBlink ?? false,
+            },
+            modes: this.state().modes,
+            styles, changedRows,
+        };
+    }
+    /** Cheap parsed state for input routing; never extracts viewport cells. */
+    state() {
+        this.assertOpen();
+        if (this.pending.size || this.resizeBarrier)
+            throw new Error('Terminal screen has pending writes or resize');
+        const terminal = this.terminal;
+        const modes = terminal.modes;
+        return {
+            buffer: terminal.buffer.active.type,
+            modes: {
+                applicationCursor: modes.applicationCursorKeysMode, applicationKeypad: modes.applicationKeypadMode,
+                bracketedPaste: modes.bracketedPasteMode, alternateScroll: this.alternateScroll, focusReporting: modes.sendFocusMode,
+                mouseTracking: modes.mouseTrackingMode,
+                mouseEncoding: this.mouseEncoding,
+            },
+        };
+    }
+    onTitleChange(listener) { return this.terminal.onTitleChange(listener); }
+    onCwdChange(listener) {
+        return this.terminal.parser.registerOscHandler(7, uri => { listener(uri); return true; });
+    }
+    onReply(listener) { return this.terminal.onData(listener); }
+    dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const reject of this.pending)
+            reject(new Error('Terminal screen is disposed'));
+        this.pending.clear();
+        this.terminal.dispose();
+    }
+    assertOpen() { if (this.closed)
+        throw new Error('Terminal screen is disposed'); }
+    anchor(buffer) {
+        const top = this.normalRestoreTop ?? buffer.viewportY;
+        if (top === buffer.baseY)
+            return undefined;
+        let end = top + 1;
+        while (buffer.getLine(end)?.isWrapped)
+            end++;
+        let cellsFromEnd = this.trimmedLength(buffer, end - 1);
+        for (let line = top; line < end - 1; line++)
+            cellsFromEnd += this.wrappedLength(buffer, line);
+        // Anchor AFTER the logical line. Its beginning can be evicted during reflow
+        // while the segment being read survives. A marker at that beginning would
+        // incorrectly lose the surviving segment. The end marker follows native
+        // insert/delete/trim events, then we walk backwards over the reflowed cells.
+        // Public registerMarker cannot target inactive normal history.
+        const marker = this.terminal.buffer.active.type === 'normal'
+            ? this.terminal.registerMarker(end - buffer.baseY - buffer.cursorY)
+            : this.terminal._core.buffers.normal.addMarker(end);
+        return marker ? { marker, cellsFromEnd } : undefined;
+    }
+    anchorLine(anchor, buffer) {
+        if (anchor.marker.isDisposed)
+            return 0;
+        let line = Math.min(anchor.marker.line, buffer.length) - 1;
+        if (line < 0)
+            return 0;
+        let remaining = anchor.cellsFromEnd - this.trimmedLength(buffer, line);
+        while (remaining > 0 && line > 0 && buffer.getLine(line)?.isWrapped) {
+            line--;
+            remaining -= this.wrappedLength(buffer, line);
+        }
+        return line;
+    }
+    trimmedLength(buffer, line) {
+        const row = buffer.getLine(line);
+        for (let x = this.terminal.cols - 1; x >= 0; x--) {
+            const cell = row.getCell(x);
+            if (cell.getChars())
+                return x + cell.getWidth();
+        }
+        return 0;
+    }
+    wrappedLength(buffer, line) {
+        const last = buffer.getLine(line).getCell(this.terminal.cols - 1);
+        // xterm leaves one empty padding cell when a wide glyph wraps at the edge.
+        return this.terminal.cols - (last.getChars() === '' && last.getWidth() === 1
+            && buffer.getLine(line + 1)?.getCell(0)?.getWidth() === 2 ? 1 : 0);
+    }
+}
+function cellStyle(cell) {
+    const flags = TERMINAL_STYLE_FLAGS;
+    return {
+        fg: cell.isFgDefault() ? -1 : cell.getFgColor() + (cell.isFgRGB() ? TERMINAL_RGB_COLOR_BASE : 0),
+        bg: cell.isBgDefault() ? -1 : cell.getBgColor() + (cell.isBgRGB() ? TERMINAL_RGB_COLOR_BASE : 0),
+        flags: (cell.isBold() ? flags.bold : 0) | (cell.isDim() ? flags.dim : 0)
+            | (cell.isItalic() ? flags.italic : 0) | (cell.isUnderline() ? flags.underline : 0)
+            | (cell.isBlink() ? flags.blink : 0) | (cell.isInverse() ? flags.inverse : 0)
+            | (cell.isInvisible() ? flags.invisible : 0) | (cell.isStrikethrough() ? flags.strike : 0),
+    };
+}