@xingular/harness 0.1.6 → 1.0.0

package/dist/sdk/terminal/tui/pages/permissionsPage.js

@@ -0,0 +1,124 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'overview', title: 'Overview' },
+    { id: 'tools', title: 'Tools' }
+];
+const FULL = 'full';
+const NOTE = 'Applies to future approvals only. Hard denials and disabled tools still apply.';
+const FULL_WARNING = 'Automatically approve eligible future requests in every Pi terminal session sharing this local Harness state. Hard denials and disabled tools still apply; human-only requests stay manual unless the host explicitly opts them in. Requests already waiting are not approved.';
+export class PermissionsPage {
+    options;
+    state;
+    section = 'overview';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['tool', 'tools'], empty: 'No tools to show',
+            onActivate: row => { void this.toggle(row.id); },
+            onToggle: row => { void this.toggle(row.id); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() { void this.reload(); }
+    dispose() { this.disposed = true; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    hint() { return this.list.query ? 'Enter toggle · Esc clear' : 'Space or Enter toggle · type to search'; }
+    async reload() {
+        try {
+            this.state = await this.options.permissions();
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        this.list.setRows(this.rows());
+    }
+    rows() {
+        const state = this.state;
+        if (!state)
+            return [];
+        if (this.section === 'overview') {
+            return [{ id: FULL, label: 'Full Permission', group: 'Mode', detail: state.full ? 'ON' : 'OFF', tone: state.full ? 'warning' : 'muted', searchText: 'full permission approve everything' }];
+        }
+        const granted = new Set(state.globalTools);
+        const active = this.options.activeTools();
+        const inactive = [...granted].filter(tool => !active.includes(tool));
+        const byName = (left, right) => left.localeCompare(right);
+        const tool = (name, group) => ({
+            id: 'tool:' + name, label: name, group,
+            detail: granted.has(name) ? '● allowed everywhere' : '○ asks each time',
+            tone: granted.has(name) ? 'success' : 'muted'
+        });
+        return [
+            ...[...active].sort(byName).map(name => tool(name, 'Tools in this session')),
+            ...inactive.sort(byName).map(name => tool(name, 'Granted, not active here'))
+        ];
+    }
+    async toggle(id) {
+        if (this.busy || !this.state)
+            return;
+        this.busy = true;
+        try {
+            if (id === FULL) {
+                const desired = !this.state.full;
+                const latest = await this.options.permissions();
+                if (latest.full !== desired && (!desired || await this.options.confirm('Enable Full Permission?', FULL_WARNING)))
+                    await this.options.setFullPermission(desired);
+            }
+            else {
+                const tool = id.slice('tool:'.length);
+                if (!tool)
+                    return;
+                const desired = !this.state.globalTools.includes(tool);
+                const latest = await this.options.permissions();
+                if (latest.globalTools.includes(tool) !== desired)
+                    await this.options.setGlobalTool(tool, desired);
+            }
+        }
+        catch (error) {
+            this.options.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                this.section = this.section === 'overview' ? 'tools' : 'overview';
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.state)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? `Could not read permissions: ${this.error}` : 'Reading permissions…')];
+        const note = this.section === 'overview' && rows >= 8 ? wrapTextWithAnsi(NOTE, width).slice(0, 2) : [];
+        const lines = this.list.render(width, Math.max(1, rows - (note.length ? note.length + 1 : 0)));
+        if (note.length)
+            lines.push('', ...note.map(line => theme.fg('dim', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/pluginsPage.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The Plugins page: what this session loads, switched on or off, with trust for plugin code.
+ * Enter opens what can be done with a row; nothing changes without a choice made here. A plugin
+ * with settings has a Settings row that opens them as a subpage; Esc goes back to the list.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type MenuCall, type MenuUi } from "../../pluginMenu.js";
+import type { TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface PluginsPageOptions {
+    theme: () => Theme;
+    call: MenuCall;
+    ui: MenuUi & {
+        input(title: string, placeholder?: string): Promise<string | undefined>;
+    };
+    changed(): void;
+}
+export declare class PluginsPage implements TerminalPage {
+    private readonly options;
+    private plugins;
+    private section;
+    private projectId;
+    private error;
+    private restart;
+    private busy;
+    private disposed;
+    private readonly list;
+    /** The plugin whose settings are open, or null on the list. */
+    private settingsFor;
+    private saved;
+    private readonly settingsList;
+    constructor(options: PluginsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private settingsPlugin;
+    private reload;
+    private fill;
+    /** The menu rows, with a Settings row after the last row of each plugin that has settings. */
+    private rows;
+    private menu;
+    private key;
+    private toRow;
+    private open;
+    private back;
+    /** Flips a switch, or asks for a number inside the setting's range, and saves it. */
+    private change;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+    private renderSettings;
+}

package/dist/sdk/terminal/tui/pages/pluginsPage.js

@@ -0,0 +1,243 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { BACK, applyPluginAction, menuRows, rowActions } from "../../pluginMenu.js";
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'plugins', title: 'Plugins' },
+    { id: 'trust', title: 'Trust' }
+];
+const SETTINGS_ROW = 'settings:';
+const isSwitch = (setting) => setting.min === 0 && setting.max === 1;
+const settingValueText = (setting) => isSwitch(setting)
+    ? setting.value === 1 ? 'on' : 'off'
+    : `${setting.value.toLocaleString('en-US')}${setting.value === setting.default ? ' · default' : ''}`;
+const settingsOf = (plugin) => plugin.settings ?? [];
+export class PluginsPage {
+    options;
+    plugins;
+    section = 'plugins';
+    projectId = null;
+    error;
+    restart = false;
+    busy = false;
+    disposed = false;
+    list;
+    /** The plugin whose settings are open, or null on the list. */
+    settingsFor = null;
+    saved = false;
+    settingsList;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['item', 'items'], empty: 'There is nothing to switch or trust here yet.',
+            onActivate: row => { void this.open(row.id); }
+        });
+        this.settingsList = new FilterList({
+            theme: options.theme, search: 'always', noun: ['setting', 'settings'], empty: 'This plugin has no settings.',
+            onActivate: row => { void this.change(row.id); },
+            onCancel: () => this.back()
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) {
+        this.list.focused = value;
+        this.settingsList.focused = value;
+    }
+    activate() { void this.reload(); }
+    dispose() { this.disposed = true; }
+    tabs() {
+        const plugin = this.settingsPlugin();
+        return plugin ? [{ id: 'settings', title: `Plugins › ${safeText(plugin.title)}` }] : SECTIONS;
+    }
+    activeTab() { return this.settingsPlugin() ? 'settings' : this.section; }
+    hint() {
+        if (this.settingsPlugin())
+            return this.settingsList.query ? 'Enter change · Esc clear' : 'Enter change · Esc back';
+        return this.list.query ? 'Enter actions · Esc clear' : 'Enter actions · type to search';
+    }
+    settingsPlugin() {
+        return this.settingsFor ? this.plugins?.find(plugin => plugin.id === this.settingsFor) : undefined;
+    }
+    async reload() {
+        try {
+            const { call } = this.options;
+            this.projectId = (await call('plugins.session').catch(() => ({ projectId: null }))).projectId;
+            this.plugins = await call('plugins.list');
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        if (this.settingsFor && !this.settingsPlugin())
+            this.settingsFor = null;
+        this.list.setRows(this.rows());
+        const plugin = this.settingsPlugin();
+        if (plugin)
+            this.settingsList.setRows(settingsOf(plugin).map(setting => ({
+                id: setting.key, label: safeText(setting.label), detail: settingValueText(setting),
+                tone: isSwitch(setting) ? (setting.value === 1 ? 'success' : 'dim') : 'muted',
+                searchText: `${setting.label} ${setting.description}`
+            })));
+    }
+    /** The menu rows, with a Settings row after the last row of each plugin that has settings. */
+    rows() {
+        const menu = this.menu();
+        const out = [];
+        const placed = new Set();
+        const settingsRow = (plugin) => {
+            const count = settingsOf(plugin).length;
+            placed.add(plugin.id);
+            return { id: `${SETTINGS_ROW}${plugin.id}`, group: safeText(plugin.title), label: 'Settings', detail: `${count} ${count === 1 ? 'setting' : 'settings'} ›`, tone: 'muted', searchText: `${plugin.title} settings ${settingsOf(plugin).map(setting => setting.label).join(' ')}` };
+        };
+        menu.forEach((row, index) => {
+            out.push(this.toRow(row));
+            const last = menu[index + 1]?.plugin.id !== row.plugin.id;
+            if (this.section === 'plugins' && last && settingsOf(row.plugin).length)
+                out.push(settingsRow(row.plugin));
+        });
+        if (this.section === 'plugins') {
+            for (const plugin of this.plugins ?? [])
+                if (settingsOf(plugin).length && !placed.has(plugin.id))
+                    out.push(settingsRow(plugin));
+        }
+        return out;
+    }
+    menu() {
+        const rows = menuRows(this.plugins ?? [], this.projectId);
+        return this.section === 'trust'
+            ? rows.filter(row => row.whole && Boolean(row.plugin.code))
+            : rows.filter(row => rowActions(row, this.projectId).some(action => action.startsWith('Switch ')));
+    }
+    key(row) { return `${row.whole ? 'plugin' : 'item'}:${row.id}`; }
+    toRow(row) {
+        const kind = row.whole ? row.note : row.note.replace(/ in .*$/, '');
+        return {
+            id: this.key(row), group: safeText(row.plugin.title), label: row.whole ? 'Whole plugin' : safeText(row.name),
+            detail: `${row.on ? 'on' : 'off'}${kind ? ` · ${kind}` : ''}`, tone: row.on ? 'success' : 'dim',
+            searchText: `${row.name} ${row.plugin.title} ${row.note}`
+        };
+    }
+    async open(id) {
+        if (id.startsWith(SETTINGS_ROW)) {
+            this.settingsFor = id.slice(SETTINGS_ROW.length);
+            this.saved = false;
+            this.fill();
+            this.options.changed();
+            return;
+        }
+        const row = this.menu().find(candidate => this.key(candidate) === id);
+        if (!row || this.busy)
+            return;
+        this.busy = true;
+        try {
+            const action = await this.options.ui.select(`${row.plugin.title}: ${row.plugin.description || 'No description.'}`, rowActions(row, this.projectId));
+            if (action && action !== BACK && await applyPluginAction(this.options.ui, this.options.call, row, action))
+                this.restart = true;
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    back() {
+        this.settingsFor = null;
+        this.saved = false;
+        this.fill();
+    }
+    /** Flips a switch, or asks for a number inside the setting's range, and saves it. */
+    async change(key) {
+        const plugin = this.settingsPlugin();
+        const setting = plugin && settingsOf(plugin).find(candidate => candidate.key === key);
+        if (!plugin || !setting || this.busy)
+            return;
+        this.busy = true;
+        try {
+            let value;
+            if (isSwitch(setting))
+                value = setting.value === 1 ? 0 : 1;
+            else {
+                const answer = await this.options.ui.input(`${setting.label} (${setting.min.toLocaleString('en-US')}–${setting.max.toLocaleString('en-US')})`, String(setting.value));
+                if (answer === undefined || !answer.trim())
+                    return;
+                const typed = answer.trim().replace(/[,_]/g, '');
+                value = Number(typed);
+                if (!/^-?\d+$/.test(typed) || value < setting.min || value > setting.max) {
+                    this.options.ui.notify(`${setting.label} must be a whole number from ${setting.min.toLocaleString('en-US')} to ${setting.max.toLocaleString('en-US')}.`, 'error');
+                    return;
+                }
+            }
+            const fresh = await this.options.call('plugins.configure', { pluginId: plugin.id, settings: { [setting.key]: value } });
+            if (Array.isArray(fresh))
+                this.plugins = fresh;
+            else
+                await this.reload();
+            this.saved = true;
+            this.fill();
+        }
+        catch (error) {
+            this.options.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+            if (!this.disposed)
+                this.options.changed();
+        }
+    }
+    handleMouse(event) {
+        return this.settingsPlugin() ? this.settingsList.handleMouse(event) : this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (this.settingsPlugin()) {
+            if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab'))
+                return true;
+            return this.settingsList.handleInput(data);
+        }
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                this.section = this.section === 'plugins' ? 'trust' : 'plugins';
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.plugins)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? `Could not read plugins: ${this.error}` : 'Reading plugins…')];
+        const plugin = this.settingsPlugin();
+        if (plugin)
+            return this.renderSettings(plugin, width, rows);
+        const selectedId = this.list.selected?.id;
+        const selected = selectedId?.startsWith(SETTINGS_ROW)
+            ? this.plugins.find(candidate => `${SETTINGS_ROW}${candidate.id}` === selectedId)
+            : this.menu().find(candidate => this.key(candidate) === selectedId)?.plugin;
+        const detail = selected && rows >= 8 ? wrapTextWithAnsi(safeText(selected.description || 'No description.'), width).slice(0, 2) : [];
+        const note = this.restart ? ['Saved. Changes apply when this session restarts.'] : [];
+        const extra = detail.length + note.length;
+        const lines = this.list.render(width, Math.max(2, rows - (extra ? extra + 1 : 0)));
+        if (extra)
+            lines.push('', ...detail.map(line => theme.fg('muted', line)), ...note.map(line => theme.fg('warning', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+    renderSettings(plugin, width, rows) {
+        const theme = this.options.theme();
+        const setting = settingsOf(plugin).find(candidate => candidate.key === this.settingsList.selected?.id);
+        const range = setting && !isSwitch(setting) ? [`From ${setting.min.toLocaleString('en-US')} to ${setting.max.toLocaleString('en-US')} · default ${setting.default.toLocaleString('en-US')}`] : [];
+        const detail = setting && rows >= 8 ? [...wrapTextWithAnsi(safeText(setting.description), width).slice(0, 3), ...range] : [];
+        const note = this.saved ? ['Saved.'] : [];
+        const extra = detail.length + note.length;
+        const lines = this.settingsList.render(width, Math.max(2, rows - (extra ? extra + 1 : 0)));
+        if (extra)
+            lines.push('', ...detail.map(line => theme.fg('muted', line)), ...note.map(line => theme.fg('success', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/settingsPage.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The Settings page. It lists existing host settings and asks the host to change one; the values
+ * and actions belong to the host. Categories are page-local tabs (Tab / Shift+Tab).
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface TerminalSettingItem {
+    id: string;
+    tab: string;
+    group: string;
+    label: string;
+    value: string;
+    description?: string;
+}
+export interface SettingsPageOptions {
+    theme: () => Theme;
+    items(): TerminalSettingItem[];
+    /** Changes the setting; the page reads the items again afterwards. */
+    apply(id: string): Promise<void>;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class SettingsPage implements TerminalPage {
+    private readonly options;
+    private items;
+    private category;
+    private readonly list;
+    constructor(options: SettingsPageOptions);
+    set focused(value: boolean);
+    get focused(): boolean;
+    private categories;
+    private rowsFor;
+    private reload;
+    /** Searching looks through every category; otherwise the page shows the current one. */
+    private fill;
+    tabs(): ({
+        readonly id: "appearance";
+        readonly title: "Appearance";
+    } | {
+        readonly id: "model";
+        readonly title: "Model";
+    } | {
+        readonly id: "interaction";
+        readonly title: "Interaction";
+    } | {
+        readonly id: "context";
+        readonly title: "Context";
+    })[];
+    activeTab(): string;
+    hint(): string;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

package/dist/sdk/terminal/tui/pages/settingsPage.js

@@ -0,0 +1,88 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const CATEGORIES = [
+    { id: 'appearance', title: 'Appearance' }, { id: 'model', title: 'Model' },
+    { id: 'interaction', title: 'Interaction' }, { id: 'context', title: 'Context' }
+];
+const tabOf = (item) => item.tab.toLowerCase();
+export class SettingsPage {
+    options;
+    items = [];
+    category = '';
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['setting', 'settings'], empty: 'No settings',
+            searchContext: () => 'every category',
+            onActivate: row => {
+                void options.apply(row.id).then(() => this.reload(), error => options.notify(error instanceof Error ? error.message : String(error), 'error'));
+            }
+        });
+        this.reload();
+    }
+    set focused(value) { this.list.focused = value; }
+    get focused() { return this.list.focused; }
+    categories() {
+        return CATEGORIES.filter(category => this.items.some(item => tabOf(item) === category.id));
+    }
+    rowsFor(items) {
+        return items.map(item => ({
+            id: item.id, label: safeText(item.label), detail: safeText(item.value), group: safeText(item.group), data: item,
+            searchText: `${item.label} ${item.id} ${item.value} ${item.description ?? ''} ${item.group} ${item.tab}`
+        }));
+    }
+    reload() {
+        const selected = this.list.selected?.id;
+        this.items = this.options.items().filter(item => CATEGORIES.some(category => category.id === tabOf(item)));
+        if (!this.categories().some(category => category.id === this.category))
+            this.category = this.categories()[0]?.id ?? '';
+        this.fill();
+        if (selected)
+            this.list.select(selected);
+        this.options.changed();
+    }
+    /** Searching looks through every category; otherwise the page shows the current one. */
+    fill() {
+        this.list.setRows(this.rowsFor(this.list.query ? this.items : this.items.filter(item => tabOf(item) === this.category)));
+    }
+    tabs() { return this.categories(); }
+    activeTab() { return this.category; }
+    hint() { return this.list.query ? 'Enter change · Esc clear' : 'Enter change · type to search'; }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            const categories = this.categories();
+            if (!this.list.query && categories.length > 1) {
+                const at = Math.max(0, categories.findIndex(category => category.id === this.category));
+                this.category = categories[(at + (matchesKey(data, 'shift+tab') ? -1 : 1) + categories.length) % categories.length].id;
+                this.fill();
+            }
+            return true;
+        }
+        const before = this.list.query;
+        const used = this.list.handleInput(data);
+        if (this.list.query !== before)
+            this.fill();
+        return used;
+    }
+    render(width, rows) {
+        if (width < 1 || rows < 1)
+            return [];
+        const theme = this.options.theme();
+        const description = this.list.selected?.data?.description;
+        const descriptionRows = Math.min(3, Math.max(0, rows - 7));
+        const reserved = descriptionRows ? descriptionRows + 1 : 0;
+        const lines = this.list.render(width, Math.max(2, rows - 1 - reserved));
+        if (descriptionRows) {
+            lines.push('');
+            const wrapped = description ? wrapTextWithAnsi(safeText(description), Math.max(1, width)) : [];
+            for (let index = 0; index < descriptionRows; index++)
+                lines.push(theme.fg('muted', wrapped[index] ?? ''));
+        }
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/trajectoryPage.d.ts

@@ -0,0 +1,58 @@
+/** Saved run evidence for the current conversation: runs, their events, and the selected event's payload. */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import type { RunEvent } from "../../../sessions/contracts.js";
+import type { TerminalTrajectoryRun, TerminalTrajectorySnapshot } from "../../trajectory.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import { type TerminalMouseInput } from "../mouse.js";
+export interface TrajectoryPageOptions {
+    theme: () => Theme;
+    runs(): Promise<TerminalTrajectoryRun[]>;
+    read(runId: string, afterSequence?: number): Promise<TerminalTrajectorySnapshot>;
+    copy(text: string): Promise<void>;
+    /** Opens on this run when it is in the list; otherwise the newest. */
+    initialRunId?: string;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class TrajectoryPage implements TerminalPage {
+    private readonly options;
+    private runs;
+    private section;
+    private readonly runList;
+    private runIndex;
+    private run;
+    private events;
+    private selected;
+    private detailOffset;
+    private eventRowsStart;
+    private eventRowsFirst;
+    private eventRowsCount;
+    private loading;
+    private loaded;
+    private disposed;
+    private timer;
+    private error;
+    constructor(options: TrajectoryPageOptions);
+    get selectedRunId(): string | undefined;
+    get selectedEvent(): RunEvent | undefined;
+    get focused(): boolean;
+    set focused(value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    activate(): void;
+    deactivate(): void;
+    dispose(): void;
+    private load;
+    private open;
+    private refresh;
+    /** `[` is the older run, `]` the newer one. */
+    private runRows;
+    private selectRun;
+    private changeRun;
+    hint(): string;
+    handleMouse(event: TerminalMouseInput): TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}