@weiping/wingline 0.0.0-stage → 0.1.1

package/dist/tui/app.js

@@ -0,0 +1,259 @@
+import { WinglineError, attention, auditedWriteCommands, cachedOrca, listTasks, ps, readTimeline, readTimelineAfter, } from '@weiping/wingline-core';
+import { parseKeys } from './keys.js';
+import { reduce, initialTuiState } from './reduce.js';
+import { renderView } from './render.js';
+import { Screen } from './screen.js';
+export { initialTuiState, reduce, renderView };
+const TIMELINE_KEEP = 500;
+const LOADING = '加载中…';
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+const emptyAttention = (team) => ({
+    team, dispatcher: { state: 'never' }, frozen: [], signals: [], questions: [], stale: [], unavailable: [], warnings: [],
+});
+function summaryOf(result) {
+    const r = result;
+    if (r?.duplicate === true)
+        return '已完成（该请求此前已处理过）';
+    return typeof r?.outcome === 'string' ? `已完成（${r.outcome}）` : '已完成';
+}
+/** 一次写操作失败：只改状态行。结果不确定且带 retryRequest 时记下来，按 R 以同样的参数重试。 */
+function failure(action, err) {
+    if (err instanceof WinglineError) {
+        const hint = err.hint ? `（${err.hint}）` : '';
+        const retryRequest = err.detail?.retryRequest;
+        if (err.kind === 'uncertain' && typeof retryRequest === 'string') {
+            return { lastUncertain: { ...action, args: { ...action.args, retryRequest } }, status: `${err.message}${hint}；按 R 原样重试` };
+        }
+        return { status: `${action.label}失败：${err.message}${hint}` };
+    }
+    return { status: `${action.label}失败：${err instanceof Error ? err.message : String(err)}` };
+}
+/**
+ * 一次 wl tui 会话：进程内直接调用 core，不依赖控制台服务。读取失败只标“数据过期”；
+ * 其他异常先恢复终端（退出备用屏幕、显示光标、关闭 raw 模式）再 reject。
+ */
+class TuiSession {
+    deps;
+    team;
+    io;
+    o;
+    done;
+    screen;
+    cached;
+    cdeps;
+    read;
+    commands;
+    state = { ...initialTuiState(), status: LOADING };
+    data;
+    cursor = null;
+    /** 正在进行的读取与“进行中又被要求刷新”的标记：同一种读取不并发，被挤掉的请求在读完后补跑一次。 */
+    busy = { data: false, timeline: false };
+    rerun = { data: false, timeline: false };
+    finished = false;
+    timers = [];
+    constructor(deps, team, io, o, done) {
+        this.deps = deps;
+        this.team = team;
+        this.io = io;
+        this.o = o;
+        this.done = done;
+        this.screen = new Screen(io.stdout);
+        this.cached = cachedOrca(deps.orca);
+        this.cdeps = { ...deps, orca: this.cached };
+        this.read = { ps, attention, listTasks, readTimeline, readTimelineAfter, ...o.read };
+        this.commands = o.commands ?? auditedWriteCommands('tui:');
+        this.data = { team, posts: [], attention: emptyAttention(team), tasks: [], timeline: [], hushed: [] };
+    }
+    // —— 生命周期 ——
+    start() {
+        try {
+            process.on('exit', this.restore);
+            process.on('uncaughtException', this.onFatal);
+            for (const sig of SIGNALS)
+                process.on(sig, this.onStop);
+            this.io.stdin.setRawMode?.(true);
+            this.io.stdin.setEncoding?.('utf8');
+            this.io.stdin.resume?.();
+            this.screen.enter();
+            this.io.stdin.on('data', this.onData);
+            this.io.stdout.on('resize', this.onResize);
+            this.o.signal?.addEventListener('abort', this.onStop, { once: true });
+            this.draw();
+            this.startLoops();
+            if (this.o.signal?.aborted)
+                this.finish();
+        }
+        catch (err) {
+            this.finish(err);
+        }
+    }
+    startLoops() {
+        this.timers.push(setInterval(this.guard(() => this.refreshData()), this.o.dataMs ?? 5000), setInterval(this.guard(() => this.refreshTimeline()), this.o.timelineMs ?? 2000));
+        this.guard(() => this.refreshData())();
+        this.guard(() => this.refreshTimeline())();
+    }
+    restore = () => {
+        this.screen.restore();
+        try {
+            this.io.stdin.setRawMode?.(false);
+        }
+        catch {
+            // 终端已经没了
+        }
+        this.io.stdin.pause?.();
+    };
+    finish(err) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        this.timers.forEach(clearInterval);
+        this.io.stdin.off('data', this.onData);
+        this.io.stdout.off('resize', this.onResize);
+        process.off('exit', this.restore);
+        process.off('uncaughtException', this.onFatal);
+        for (const sig of SIGNALS)
+            process.off(sig, this.onStop);
+        this.o.signal?.removeEventListener('abort', this.onStop);
+        this.restore();
+        if (err === undefined)
+            this.done.resolve();
+        else
+            this.done.reject(err);
+    }
+    /** 回调里抛出的异常（同步或异步）一律走 finish：先恢复终端再 reject。 */
+    guard(fn) {
+        return (...a) => {
+            try {
+                const r = fn(...a);
+                if (r instanceof Promise)
+                    r.catch((e) => this.finish(e));
+            }
+            catch (err) {
+                this.finish(err);
+            }
+        };
+    }
+    onStop = () => this.finish();
+    onFatal = (err) => {
+        process.off('uncaughtException', this.onFatal);
+        this.restore();
+        throw err;
+    };
+    // —— 画面与输入 ——
+    draw() {
+        if (this.finished)
+            return;
+        const lines = renderView(this.state, this.data, this.screen.size());
+        this.o.onFrame?.(lines);
+        this.screen.render(lines);
+    }
+    onData = this.guard((chunk) => {
+        for (const k of parseKeys(String(chunk))) {
+            const r = reduce(this.state, k, this.data);
+            this.state = r.state;
+            if (r.effect)
+                this.run(r.effect);
+        }
+        this.draw();
+    });
+    onResize = this.guard(() => {
+        this.screen.invalidate();
+        this.draw();
+    });
+    run(effect) {
+        if (effect.kind === 'quit')
+            return this.finish();
+        if (effect.kind === 'refresh')
+            return void this.refreshAll().catch((e) => this.finish(e));
+        void this.execute(effect.action).catch((e) => this.finish(e));
+    }
+    // —— 读取 ——
+    refreshAll() {
+        return Promise.all([this.refreshData(), this.refreshTimeline()]);
+    }
+    markStale() {
+        this.state = { ...this.state, stale: true };
+        this.draw();
+    }
+    /** 读取失败只标过期；处理结果时抛出的异常是 bug，交给 guard 走 finish。 */
+    refreshData() {
+        return this.exclusive('data', () => this.loadData());
+    }
+    refreshTimeline() {
+        return this.exclusive('timeline', () => this.loadTimeline());
+    }
+    async exclusive(kind, load) {
+        if (this.busy[kind]) {
+            this.rerun[kind] = true;
+            return;
+        }
+        this.busy[kind] = true;
+        try {
+            await load();
+        }
+        finally {
+            this.busy[kind] = false;
+        }
+        if (this.rerun[kind]) {
+            this.rerun[kind] = false;
+            await this.exclusive(kind, load);
+        }
+    }
+    async loadData() {
+        const { team, cdeps, read } = this;
+        let loaded;
+        try {
+            const [posts, att, tasks] = await Promise.all([read.ps(cdeps, { team }), read.attention(cdeps, team), read.listTasks(cdeps, { team })]);
+            loaded = { posts, attention: att, tasks };
+        }
+        catch {
+            return this.markStale();
+        }
+        const now = this.deps.now().getTime();
+        const hushed = loaded.posts.map((p) => p.address).filter((a) => Date.parse(this.deps.registry.hushedUntil(a) ?? '') > now);
+        this.data = { ...this.data, ...loaded, hushed };
+        this.state = { ...this.state, stale: false, status: this.state.status === LOADING ? '' : this.state.status };
+        this.draw();
+    }
+    async loadTimeline() {
+        const { team, cdeps, read } = this;
+        let events;
+        try {
+            if (this.cursor === null) {
+                const first = await read.readTimeline(cdeps, { team, limit: 200 });
+                this.cursor = first.cursor;
+                events = first.events;
+            }
+            else {
+                const more = await read.readTimelineAfter(cdeps, team, this.cursor);
+                this.cursor = more.cursor;
+                events = [...this.data.timeline, ...more.events];
+            }
+        }
+        catch {
+            return this.markStale();
+        }
+        const wasAtEnd = this.state.view === 'timeline' && this.state.selected >= this.data.timeline.length - 1;
+        this.data = { ...this.data, timeline: events.slice(-TIMELINE_KEEP) };
+        if (wasAtEnd)
+            this.state = { ...this.state, selected: Math.max(0, this.data.timeline.length - 1) };
+        this.draw();
+    }
+    // —— 写操作 ——
+    async execute(action) {
+        try {
+            const result = await this.commands[action.command](this.cdeps, action.args);
+            this.state = { ...this.state, status: `${action.label}：${summaryOf(result)}`, lastUncertain: null };
+        }
+        catch (err) {
+            this.state = { ...this.state, ...failure(action, err) };
+        }
+        this.cached.invalidate();
+        this.draw();
+        await this.refreshAll();
+    }
+}
+/** 全屏终端视图。结束（q / Ctrl-C / 信号 / abort）时 resolve；出错时先恢复终端再 reject。 */
+export function runTui(deps, team, io, o = {}) {
+    return new Promise((resolve, reject) => new TuiSession(deps, team, io, o, { resolve, reject }).start());
+}

package/dist/tui/command.d.ts

@@ -0,0 +1,16 @@
+import { type CommandDeps } from '@weiping/wingline-core';
+import { runTui } from './app.js';
+import type { TuiIo } from './types.js';
+import { pickTeam } from './views/picker.js';
+export interface TuiCmdArgs {
+    team?: string;
+    io: TuiIo;
+    /** 以下几项只在测试里替换。 */
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    warn?: (message: string) => void;
+    run?: typeof runTui;
+    pick?: typeof pickTeam;
+}
+/** `wl tui [team]`：检查终端，选定团队，进入全屏视图。 */
+export declare function tuiCmd(deps: CommandDeps, a: TuiCmdArgs): Promise<Record<string, never>>;

package/dist/tui/command.js

@@ -0,0 +1,35 @@
+import { WinglineError } from '@weiping/wingline-core';
+import { runTui } from './app.js';
+import { pickTeam } from './views/picker.js';
+function chooseTeams(deps, name) {
+    if (name !== undefined) {
+        const t = deps.registry.getTeam(name);
+        if (!t)
+            throw new WinglineError('input', 'team_unknown', `团队 ${name} 未登记`, { hint: '先执行 wl up <team.yaml>' });
+        return [t];
+    }
+    const teams = deps.registry.listTeams();
+    if (teams.length === 0)
+        throw new WinglineError('input', 'team_unknown', '还没有登记任何团队', { hint: '先执行 wl up <team.yaml>' });
+    return teams;
+}
+/** `wl tui [team]`：检查终端，选定团队，进入全屏视图。 */
+export async function tuiCmd(deps, a) {
+    if (!a.io.stdout.isTTY || !a.io.stdin.isTTY) {
+        throw new WinglineError('input', 'tui_not_tty', 'wl tui 需要在交互式终端里运行', { hint: '直接在终端里运行 wl tui，输入输出都不要重定向' });
+    }
+    if (!(a.io.stdout.columns > 0)) {
+        throw new WinglineError('input', 'tui_unsupported_terminal', '终端没有报告窗口宽度，无法布局', { hint: '换一个终端模拟器，或改用 wl attention / wl log' });
+    }
+    const env = a.env ?? deps.env;
+    if ((a.platform ?? process.platform) === 'win32' && !env.WT_SESSION && !env.TERM_PROGRAM) {
+        ;
+        (a.warn ?? ((m) => process.stderr.write(`警告：${m}\n`)))('当前终端可能不支持 VT 序列，显示异常请改用 Windows Terminal');
+    }
+    const teams = chooseTeams(deps, a.team);
+    const name = teams.length === 1 ? teams[0].name : await (a.pick ?? pickTeam)(teams, a.io);
+    if (name === null)
+        return {};
+    await (a.run ?? runTui)(deps, name, a.io, {});
+    return {};
+}

package/dist/tui/input.d.ts

@@ -0,0 +1,14 @@
+import type { Key } from './keys.js';
+/** 底部单行输入框：可打印字符、退格、左右移动；Enter 提交，Esc 取消。光标画成 `|`，不用任何终端样式。 */
+export declare class LineInput {
+    private readonly prompt;
+    private chars;
+    private pos;
+    constructor(prompt: string);
+    get value(): string;
+    /** reduce 是纯函数：按键作用在副本上。 */
+    clone(): LineInput;
+    feed(k: Key): 'continue' | 'submit' | 'cancel';
+    /** 一行 cols 列：放不下时让光标附近的文字留在可见区里，被截的左侧以 … 开头。 */
+    view(cols: number): string;
+}

package/dist/tui/input.js

@@ -0,0 +1,67 @@
+import { cellWidth, fit } from './width.js';
+const PRINTABLE = /^[^\x00-\x1f\x7f-\x9f]+$/;
+/** 底部单行输入框：可打印字符、退格、左右移动；Enter 提交，Esc 取消。光标画成 `|`，不用任何终端样式。 */
+export class LineInput {
+    prompt;
+    chars = [];
+    pos = 0;
+    constructor(prompt) {
+        this.prompt = prompt;
+    }
+    get value() {
+        return this.chars.join('');
+    }
+    /** reduce 是纯函数：按键作用在副本上。 */
+    clone() {
+        const c = new LineInput(this.prompt);
+        c.chars = [...this.chars];
+        c.pos = this.pos;
+        return c;
+    }
+    feed(k) {
+        if (k.name === 'enter')
+            return 'submit';
+        if (k.name === 'escape')
+            return 'cancel';
+        if (k.name === 'left')
+            this.pos = Math.max(0, this.pos - 1);
+        else if (k.name === 'right')
+            this.pos = Math.min(this.chars.length, this.pos + 1);
+        else if (k.name === 'backspace' && this.pos > 0)
+            this.chars.splice(--this.pos, 1);
+        else if (k.name === 'char' && k.ch && PRINTABLE.test(k.ch))
+            this.chars.splice(this.pos++, 0, k.ch);
+        return 'continue';
+    }
+    /** 一行 cols 列：放不下时让光标附近的文字留在可见区里，被截的左侧以 … 开头。 */
+    view(cols) {
+        const before = this.prompt + this.chars.slice(0, this.pos).join('');
+        const after = this.chars.slice(this.pos).join('');
+        if (cellWidth(before) + 1 + cellWidth(after) <= cols)
+            return fit(`${before}|${after}`, cols);
+        const room = Math.max(0, cols - 1);
+        const afterShown = takeHead(after, Math.floor(room / 3));
+        const beforeShown = takeTail(before, room - cellWidth(afterShown) - 1);
+        return fit(`…${beforeShown}|${afterShown}`, cols);
+    }
+}
+/** 从头取尽量多的字符，宽度不超过 budget。 */
+function takeHead(s, budget) {
+    let out = '';
+    for (const ch of s) {
+        if (cellWidth(out + ch) > budget)
+            break;
+        out += ch;
+    }
+    return out;
+}
+/** 从尾取尽量多的字符，宽度不超过 budget。 */
+function takeTail(s, budget) {
+    let out = '';
+    for (const ch of [...s].reverse()) {
+        if (cellWidth(ch + out) > budget)
+            break;
+        out = ch + out;
+    }
+    return out;
+}

package/dist/tui/items.d.ts

@@ -0,0 +1,15 @@
+import { type TimelineEvent } from '@weiping/wingline-core';
+import type { MenuItem, TimelineFilterSpec, TuiData, TuiState, View } from './types.js';
+/** 视图里一行可选中的条目：显示文字、能做的写操作；没有写操作的给出对应的 wl 命令。 */
+export interface Row {
+    section?: string;
+    text: string;
+    actions: MenuItem[];
+    hint?: string;
+}
+/** 事件是否命中过滤条件（岗位按名字或完整地址匹配 actor / target）。 */
+export declare function matchesFilter(e: TimelineEvent, f: TimelineFilterSpec | null): boolean;
+export declare const eventLine: (e: TimelineEvent) => string;
+export declare function filterText(f: TimelineFilterSpec | null): string;
+/** 当前视图里可选中的行；选中下标和 Enter 都以它为准。 */
+export declare function rowsOf(view: View, s: Pick<TuiState, 'filter'>, data: TuiData): Row[];

package/dist/tui/items.js

@@ -0,0 +1,137 @@
+import { postAddress, STALE_REASON_LABEL } from '@weiping/wingline-core';
+import { renderTimelineEvent } from '../output.js';
+import { cleanEvent, oneLine } from './text.js';
+import { fit } from './width.js';
+const action = (command, args, label) => ({ command, args, label });
+const sendItem = (address) => ({
+    label: '发消息',
+    steps: [{ prompt: '消息: ' }],
+    build: ([message]) => action('send', { address, message: message }, `给 ${address} 发消息`),
+});
+const freezeItem = (address) => ({
+    label: '冻结',
+    steps: [{ prompt: '冻结理由: ' }],
+    build: ([reason]) => action('freezePostCmd', { address, reason: reason }, `冻结 ${address}`),
+});
+const unfreezeItem = (address) => ({
+    label: '解冻', steps: [], build: () => action('unfreezePostCmd', { address }, `解冻 ${address}`),
+});
+const hushItem = (address) => ({
+    label: '静音',
+    steps: [{ prompt: '静音分钟数（留空为默认）: ', optional: true }],
+    build: ([minutes]) => {
+        const text = (minutes ?? '').trim();
+        if (text === '')
+            return action('hushCmd', { address }, `静音 ${address}`);
+        const n = Number(text);
+        if (!Number.isFinite(n) || n <= 0)
+            return '分钟数应为正数';
+        return action('hushCmd', { address, forMs: n * 60_000 }, `静音 ${address} ${text} 分钟`);
+    },
+});
+const unhushItem = (address) => ({
+    label: '取消静音', steps: [], build: () => action('unhushCmd', { address }, `取消 ${address} 的静音`),
+});
+const replyItem = (team, messageId, asker) => ({
+    label: '回答',
+    steps: [{ prompt: '回答: ' }],
+    build: ([body]) => action('dispatcherReply', { team, messageId, body: body }, `回答 ${asker} 的提问`),
+});
+const resolveItem = (gateId) => ({
+    label: '处理',
+    steps: [{ prompt: '决定: ' }],
+    build: ([resolution]) => action('resolveGate', { gateId, resolution: resolution }, `处理 gate ${gateId}`),
+});
+const resolveReassignItem = (gateId, team) => ({
+    label: '处理并改派',
+    steps: [{ prompt: '决定: ' }, { prompt: '改派给岗位: ' }],
+    build: ([resolution, post]) => {
+        const target = post.includes('@') ? post : postAddress(post.trim(), team);
+        return action('resolveGate', { gateId, resolution: resolution, reassign: target }, `处理 gate ${gateId} 并改派给 ${target}`);
+    },
+});
+const recoverItem = (taskId) => ({
+    label: '恢复派发', steps: [], build: () => action('recoverTask', { id: taskId }, `恢复任务 ${taskId} 的派发`),
+});
+function postRows(data) {
+    const frozen = new Set(data.attention.frozen.map((f) => f.post));
+    const hushed = new Set(data.hushed);
+    return data.posts.map((p) => {
+        const task = data.tasks.find((t) => t.status === 'dispatched' && p.handle !== null && t.assigneeHandle === p.handle);
+        const flags = [
+            frozen.has(p.address) ? '[冻结]' : '',
+            hushed.has(p.address) ? '[静音]' : '',
+            ...data.attention.signals.filter((s) => s.post === p.address).map((s) => `[${s.signal} L${s.level}]`),
+        ].filter(Boolean);
+        return {
+            text: [fit(oneLine(p.address), 20), fit(oneLine(p.agent), 7), fit(p.status, 7), fit(task ? oneLine(task.title) : '—', 16), ...flags].join(' ').trimEnd(),
+            actions: [
+                sendItem(p.address),
+                frozen.has(p.address) ? unfreezeItem(p.address) : freezeItem(p.address),
+                hushed.has(p.address) ? unhushItem(p.address) : hushItem(p.address),
+            ],
+        };
+    });
+}
+function inboxRows(data) {
+    const a = data.attention;
+    const gates = a.stale.filter((s) => s.reason === 'blocked_waiting');
+    const rest = a.stale.filter((s) => s.reason !== 'blocked_waiting');
+    return [
+        ...a.questions.map((q) => ({
+            section: '待回答的提问',
+            text: `${oneLine(q.asker)}：${oneLine(q.body)}${q.options.length ? `  选项：${q.options.map(oneLine).join(' / ')}` : ''}`,
+            actions: [replyItem(a.team, q.messageId, oneLine(q.asker))],
+        })),
+        ...gates.map((s) => {
+            const gateId = s.gateId;
+            return {
+                section: '等待决策的 gate',
+                text: `${oneLine(s.title)}  归属 ${s.owner ? oneLine(s.owner) : '—'}`,
+                actions: gateId ? [resolveItem(gateId), resolveReassignItem(gateId, a.team)] : [],
+                hint: s.command,
+            };
+        }),
+        ...a.frozen.map((f) => ({ section: '冻结的岗位', text: `${oneLine(f.post)}  ${oneLine(f.reason)}`, actions: [unfreezeItem(f.post)] })),
+        ...rest.map((s) => ({
+            section: '卡住的任务',
+            text: `${oneLine(s.title)}  ${STALE_REASON_LABEL[s.reason]}  主人 ${s.owner ? oneLine(s.owner) : '—'}`,
+            actions: s.reason === 'dead_assignee' ? [recoverItem(s.taskId)] : [],
+            hint: s.command,
+        })),
+        ...a.signals.map((s) => ({
+            section: '巡查信号',
+            text: `${oneLine(s.post)}  ${s.signal} L${s.level}${s.summary ? `  ${oneLine(s.summary)}` : ''}`,
+            actions: [hushItem(s.post), sendItem(s.post)],
+            hint: s.command ?? undefined,
+        })),
+    ];
+}
+/** 事件是否命中过滤条件（岗位按名字或完整地址匹配 actor / target）。 */
+export function matchesFilter(e, f) {
+    if (!f)
+        return true;
+    if (f.source && e.source !== f.source)
+        return false;
+    if (f.post) {
+        const hit = [e.actor, e.target].some((x) => x !== null && (x === f.post || x.split('@')[0] === f.post));
+        if (!hit)
+            return false;
+    }
+    return !f.task || e.target === f.task || (e.target?.startsWith(`${f.task}#`) ?? false);
+}
+export const eventLine = (e) => oneLine(renderTimelineEvent(cleanEvent(e)));
+export function filterText(f) {
+    if (!f)
+        return '';
+    return Object.entries(f).map(([k, v]) => `${k}:${v}`).join(' ');
+}
+function timelineRows(data, filter) {
+    return data.timeline.filter((e) => matchesFilter(e, filter)).map((e) => ({ text: eventLine(e), actions: [] }));
+}
+/** 当前视图里可选中的行；选中下标和 Enter 都以它为准。 */
+export function rowsOf(view, s, data) {
+    if (view === 'overview')
+        return postRows(data);
+    return view === 'inbox' ? inboxRows(data) : timelineRows(data, s.filter);
+}

package/dist/tui/keys.d.ts

@@ -0,0 +1,6 @@
+export type Key = {
+    name: 'up' | 'down' | 'enter' | 'tab' | 'escape' | 'backspace' | 'left' | 'right' | 'ctrl-c' | 'char';
+    ch?: string;
+};
+/** 把一次 stdin 数据拆成按键。认不出的转义序列整条丢掉，不会当成输入打出来。 */
+export declare function parseKeys(chunk: string): Key[];

package/dist/tui/keys.js

@@ -0,0 +1,41 @@
+const ARROWS = {
+    '\x1b[A': 'up', '\x1b[B': 'down', '\x1b[C': 'right', '\x1b[D': 'left',
+    '\x1bOA': 'up', '\x1bOB': 'down', '\x1bOC': 'right', '\x1bOD': 'left',
+};
+/** CSI（ESC [ 参数 中间字节 终止字节）与 SS3（ESC O x）。 */
+const SEQUENCE = /^\x1b(?:\[[0-9;?]*[ -/]*[@-~]|O[@-~])/;
+/** 把一次 stdin 数据拆成按键。认不出的转义序列整条丢掉，不会当成输入打出来。 */
+export function parseKeys(chunk) {
+    const keys = [];
+    let i = 0;
+    while (i < chunk.length) {
+        const c = chunk[i];
+        if (c === '\x1b') {
+            if (i === chunk.length - 1) {
+                keys.push({ name: 'escape' });
+                break;
+            }
+            const seq = SEQUENCE.exec(chunk.slice(i));
+            const arrow = seq ? ARROWS[seq[0]] : undefined;
+            if (arrow)
+                keys.push({ name: arrow });
+            i += seq ? seq[0].length : 2;
+            continue;
+        }
+        i += 1;
+        if (c === '\r' || c === '\n')
+            keys.push({ name: 'enter' });
+        else if (c === '\t')
+            keys.push({ name: 'tab' });
+        else if (c === '\x7f' || c === '\b')
+            keys.push({ name: 'backspace' });
+        else if (c === '\x03')
+            keys.push({ name: 'ctrl-c' });
+        else if (c >= ' ') {
+            const ch = String.fromCodePoint(chunk.codePointAt(i - 1));
+            i += ch.length - 1;
+            keys.push({ name: 'char', ch });
+        }
+    }
+    return keys;
+}

package/dist/tui/reduce.d.ts

@@ -0,0 +1,10 @@
+import type { Key } from './keys.js';
+import type { Effect, TuiData, TuiState } from './types.js';
+export declare function initialTuiState(): TuiState;
+type Out = {
+    state: TuiState;
+    effect?: Effect;
+};
+/** 按键状态机（纯函数）：返回新状态，以及需要外部执行的动作（写操作 / 刷新 / 退出）。 */
+export declare function reduce(s: TuiState, k: Key, data: TuiData): Out;
+export {};