mocode-ai 1.6.4 → 1.6.5

package/dist/ui/batch.js

@@ -82,6 +82,12 @@ export function reset() {
  *  opts.groupChildIndex:本批作为组子批时在父 entries 中的序号(插入锚点用)。 */
 export function beginBatch(label, opts) {
     const id = `b${++_idCounter}`;
+    const parentId = opts?.parentId && batches.has(opts.parentId) ? opts.parentId : undefined;
+    const parent = parentId ? batches.get(parentId) : undefined;
+    // 缩进未显式给定时按父层级自动推导:组容器批的子批 = 两层 entry 缩进;
+    // 普通子 agent 批下再嵌套 = 父批缩进 + 两层(树状逐层加深)。
+    const indent = opts?.indent ??
+        (parent ? (parent.groupParent ? SUB_BATCH_INDENT : (parent.indent ?? '') + SUB_BATCH_INDENT) : undefined);
     batches.set(id, {
         id,
         summaryAbsIdx: -1,
@@ -90,8 +96,8 @@ export function beginBatch(label, opts) {
         renderedCount: 0,
         startedAt: Date.now(),
         label,
-        indent: opts?.indent,
-        parentId: opts?.parentId && batches.has(opts.parentId) ? opts.parentId : undefined,
+        indent,
+        parentId,
         groupParent: opts?.groupParent ?? false,
         groupChildIndex: opts?.groupChildIndex,
         running: opts?.running ?? false,
@@ -123,7 +129,8 @@ export function recordCall(id, name, callSummary, callId) {
     // 已完成的累计探索后又追加工具：恢复进行中，待新结果返回再完成。
     b.finishedAt = undefined;
     b.entries.push({ name, callSummary, resultSummary: '', diffBlock: null });
-    if (callId && b.groupParent)
+    // 对所有批登记:普通批内的 sub-agent 调用(子 agent 嵌套派生)同样要靠它定位锚点。
+    if (callId)
         groupChildIndexByCall.set(callId, b.entries.length - 1);
     // 新增 entry = 本批重新「在飞」→ 扫光心跳起(此前收口时可能已停)。
     syncSweepTimer();
@@ -149,8 +156,8 @@ export function recordResult(id, name, resultSummary, diffBlock, fullOutput, fai
     const b = batches.get(id);
     if (!b || b.entries.length === 0)
         return;
-    // 组容器批:优先按 callId 定位 entry,防止多个同名 sub-agent 结果互相填错位置。
-    if (callId && b.groupParent) {
+    // 优先按 callId 定位 entry,防止多个同名工具(并行调用 / 嵌套 sub-agent)结果互相填错。
+    if (callId) {
         const idx = groupChildIndexByCall.get(callId);
         if (idx != null && idx < b.entries.length && !isEntryDone(b.entries[idx])) {
             const e = b.entries[idx];
@@ -544,16 +551,16 @@ export function endBatch(id, layout) {
         absLineToBatchId.set(b.summaryAbsIdx, b.id);
         return;
     }
-    // 子批尚未落盘(组容器折叠期间被隐藏 / 折叠后才新建)。绝不能 contentWrite 到 buffer 末尾:
-    // 那会在正文区留下一条游离的子 agent 摘要行,父批再展开时就变成「多出来的第三条」。
+    // 子批尚未落盘(父批折叠期间被隐藏 / 折叠后才新建)。绝不能 contentWrite 到 buffer 末尾:
+    // 那会在正文区留下一条游离的子批摘要行,父批再展开时就变成「多出来的第三条」。
     if (b.parentId) {
         const parent = batches.get(b.parentId);
-        if (parent?.groupParent) {
+        if (parent) {
             // 父批折叠中:不渲染,等 expand() 统一恢复(那时会用最新状态重建摘要行)。
             if (!expandedBatches.has(parent.id) || parent.summaryAbsIdx < 0)
                 return;
-            // 父批已展开:插到自己的 └─ sub-agent 行下方。
-            const anchor = findParentEntryAbsLine(parent.id, b.groupChildIndex ?? 0) ?? parent.summaryAbsIdx;
+            // 父批已展开:插到对应的内部 sub-agent entry 行下方。
+            const anchor = childBatchAnchor(parent, b.groupChildIndex);
             layout.contentInsertAfter(anchor, [sanitizeRow(buildSummaryLine(b))]);
             b.summaryAbsIdx = anchor + 1;
             absLineToBatchId.set(b.summaryAbsIdx, b.id);
@@ -584,29 +591,15 @@ export function showLiveBatch(id, layout) {
         // 让「子 agent 的工具明细」始终跟在自己的父调用行下——并行派发时才不串行。
         const parent = b.parentId ? batches.get(b.parentId) : undefined;
         if (parent && parent.summaryAbsIdx >= 0 && layout.contentInsertAfter) {
-            // 组容器父批处于折叠态时,子批摘要行先不渲染;等父批展开时由 expand 统一恢复,
-            // 避免子批摘要残留在父批明细区、再次展开后出现重复行。
-            if (parent.groupParent && !expandedBatches.has(parent.id)) {
+            // 父批(组容器批或普通子 agent 批)折叠时,子批摘要行先不渲染;
+            // 等父批展开时由 expand 统一恢复,避免摘要残留/重复行。
+            if (!expandedBatches.has(parent.id)) {
                 b.summaryAbsIdx = -1;
                 return;
             }
-            let anchor;
-            if (parent.groupParent && b.groupChildIndex != null && expandedBatches.has(parent.id)) {
-                // 组容器已展开:子 agent 工具批插到第 groupChildIndex 个 └─ sub-agent 行下方。
-                // 不能用固定偏移 summaryAbsIdx+1+childIndex——前面兄弟子批的内容会把它后面的
-                // entry 行整体下移,固定偏移会错位;用 absLineToEntry 登记的真实绝对索引。
-                let entryAbs = parent.summaryAbsIdx + 1 + b.groupChildIndex;
-                for (const [idx, target] of absLineToEntry) {
-                    if (target.batchId === parent.id && target.entryIndex === b.groupChildIndex) {
-                        entryAbs = idx;
-                        break;
-                    }
-                }
-                anchor = entryAbs;
-            }
-            else {
-                anchor = parent.summaryAbsIdx + (expandedBatches.has(parent.id) ? parent.renderedCount : 0);
-            }
+            // 父批已展开:插到本批对应的内部 sub-agent entry 行下方(按真实登记位置,
+            // 不用固定偏移——兄弟内容会把后续行整体下移);找不到 entry 时退化到父批块末。
+            const anchor = childBatchAnchor(parent, b.groupChildIndex);
             layout.contentInsertAfter(anchor, [sanitizeRow(summary)], false);
             b.summaryAbsIdx = anchor + 1;
             absLineToBatchId.set(b.summaryAbsIdx, b.id); // 运行态同样开放点击(endBatch 幂等重登)
@@ -687,43 +680,17 @@ export function refreshBatchExpanded(id, layout) {
     const newEntries = b.entries.slice(b.renderedCount);
     const lines = buildExpandedLines(b, b.indent ?? '', b.renderedCount);
     // 实时追加:不锚定视口,让新明细行自然出现在屏底。
-    // 组容器批的 entry 与子批摘要行交错,新 entry 必须插在当前块末尾,
-    // 不能简单用 summaryAbsIdx+renderedCount(否则 entry 会插到前一个子批摘要行之前)。
-    // 块末还必须计入已渲染 entry 的二层展开明细行(toggleEntry 把明细插在 entry 行下方,
-    // 会把后续 entry 行整体下移;运行态可交互后这条路径高频,漏算会插错位)。
+    // 锚点必须是本批已渲染块的真实最末行——不能简单用 summaryAbsIdx+renderedCount:
+    // ①toggleEntry 展开的二层明细行会把后续行下移;
+    // ②挂在内部 sub-agent entry 下的嵌套子批(摘要 + 其展开内容)也在本批块内。
+    // 组容器批与普通子 agent 批走同一计算。
     let anchor = b.summaryAbsIdx + b.renderedCount;
     for (const j of b.expandedEntries) {
         if (j < b.renderedCount) {
             anchor += buildEntryDetailLines(b.entries[j], entryDetailIndent(b.indent ?? '')).length;
         }
     }
-    if (b.groupParent) {
-        let maxIdx = anchor;
-        for (const [idx, target] of absLineToEntry) {
-            if (target.batchId !== b.id)
-                continue;
-            // entry 行自身(含其二层明细)的块末位置
-            const end = b.expandedEntries.has(target.entryIndex)
-                ? idx + buildEntryDetailLines(b.entries[target.entryIndex], entryDetailIndent(b.indent ?? '')).length
-                : idx;
-            if (end > maxIdx)
-                maxIdx = end;
-        }
-        for (const child of batches.values()) {
-            if (child.parentId === b.id && child.summaryAbsIdx >= 0) {
-                let childEnd = child.summaryAbsIdx;
-                if (expandedBatches.has(child.id)) {
-                    childEnd += child.renderedCount;
-                    for (const j of child.expandedEntries) {
-                        childEnd += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.indent ?? '')).length;
-                    }
-                }
-                if (childEnd > maxIdx)
-                    maxIdx = childEnd;
-            }
-        }
-        anchor = maxIdx;
-    }
+    anchor = blockEndAbsIdx(b, anchor);
     layout.contentInsertAfter(anchor, lines, false);
     // 登记新增明细行的点击命中(按实际插入位置)
     for (let i = 0; i < newEntries.length; i++) {
@@ -761,15 +728,15 @@ function expand(b, layout, live = false) {
         absLineToEntry.set(b.summaryAbsIdx + 1 + i, { batchId: b.id, entryIndex: i });
         b.entries[i].renderedDigest = entryLineDigest(b.entries[i]); // 记指纹,供运行态结果回填原位刷新
     }
-    // 组容器批展开时:把之前被折叠隐藏的子批摘要行重新插回对应 entry 下方,
+    // 展开时:把之前被折叠隐藏的子批摘要行重新插回对应的内部 sub-agent entry 下方,
     // 否则子批摘要行会留在父批摘要行之后、造成明细重复/错位。
-    if (b.groupParent) {
+    // 组容器批与普通子 agent 批同一路径(嵌套孙批保持折叠,逐层展开)。
+    {
         const children = [...batches.values()]
             .filter((x) => x.parentId === b.id)
-            .sort((a, b) => (a.groupChildIndex ?? 0) - (b.groupChildIndex ?? 0));
+            .sort((x, y) => (x.groupChildIndex ?? 0) - (y.groupChildIndex ?? 0));
         for (const child of children) {
-            const entryAbs = findParentEntryAbsLine(b.id, child.groupChildIndex ?? 0);
-            const anchor = entryAbs ?? b.summaryAbsIdx + b.renderedCount;
+            const anchor = childBatchAnchor(b, child.groupChildIndex);
             const summary = buildSummaryLine(child, true);
             layout.contentInsertAfter(anchor, [sanitizeRow(summary)], !live);
             child.summaryAbsIdx = anchor + 1;
@@ -784,6 +751,75 @@ function findParentEntryAbsLine(parentId, entryIndex) {
     }
     return null;
 }
+/** 子批挂到父批(组容器批或普通子 agent 批)时的插入锚点:
+ *  优先取该子批对应的内部 sub-agent entry 真实行;未登记则退化到父批已渲染块末。 */
+function childBatchAnchor(parent, childIndex) {
+    if (childIndex != null) {
+        const entryAbs = findParentEntryAbsLine(parent.id, childIndex);
+        if (entryAbs != null)
+            return entryAbs;
+    }
+    let end = parent.summaryAbsIdx + parent.renderedCount;
+    for (const j of parent.expandedEntries) {
+        end += buildEntryDetailLines(parent.entries[j], entryDetailIndent(parent.indent ?? '')).length;
+    }
+    return blockEndAbsIdx(parent, end);
+}
+/** 批已渲染块的真实最末绝对行:把直接挂在本批下的子批(摘要行;若子批展开,
+ *  还含其明细行与再嵌套子批)全部计入,递归得到整棵树的块末。 */
+function blockEndAbsIdx(b, initial) {
+    let maxIdx = initial;
+    for (const child of batches.values()) {
+        if (child.parentId !== b.id || child.summaryAbsIdx < 0)
+            continue;
+        let childEnd = child.summaryAbsIdx;
+        if (expandedBatches.has(child.id)) {
+            childEnd += child.renderedCount;
+            for (const j of child.expandedEntries) {
+                childEnd += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.indent ?? '')).length;
+            }
+            childEnd = blockEndAbsIdx(child, childEnd);
+        }
+        if (childEnd > maxIdx)
+            maxIdx = childEnd;
+    }
+    return maxIdx;
+    return maxIdx;
+}
+/** 折叠父批的所有直接子批(递归):返回这些子批在 buffer 中占据的总行数。
+ *  未落盘子批(父批折叠期间新建)在 buffer 无对应行,只清状态不计数,避免多删相邻正文。 */
+function foldChildren(parentId) {
+    let count = 0;
+    for (const child of batches.values()) {
+        if (child.parentId !== parentId)
+            continue;
+        if (child.summaryAbsIdx < 0) {
+            child.renderedCount = 0;
+            child.expandedEntries.clear();
+            expandedBatches.delete(child.id);
+            foldChildren(child.id);
+            continue;
+        }
+        count += 1; // 子批摘要行本身
+        if (expandedBatches.has(child.id)) {
+            count += child.renderedCount;
+            for (const j of child.expandedEntries) {
+                count += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.indent ?? '')).length;
+            }
+            count += foldChildren(child.id);
+            child.expandedEntries.clear();
+            expandedBatches.delete(child.id);
+        }
+        child.renderedCount = 0;
+        absLineToBatchId.delete(child.summaryAbsIdx);
+        child.summaryAbsIdx = -1;
+        for (const [idx, target] of absLineToEntry) {
+            if (target.batchId === child.id)
+                absLineToEntry.delete(idx);
+        }
+    }
+    return count;
+}
 /** mutation 独占 batch 收尾后立即展示其调用概要和 diff。 */
 export function expandSingleEntryFully(id, layout) {
     const b = batches.get(id);
@@ -815,38 +851,9 @@ function collapse(b, layout) {
     for (const i of b.expandedEntries) {
         lineCount += buildEntryDetailLines(b.entries[i], entryDetailIndent(b.indent ?? '')).length;
     }
-    // 组容器批折叠时:一并移除嵌套子批的摘要行(及其已展开详情),
-    // 否则父批再次展开后子批摘要仍残留在明细区,出现重复行。
-    if (b.groupParent) {
-        const children = [...batches.values()].filter((x) => x.parentId === b.id);
-        for (const child of children) {
-            // 未落盘的子批(父批折叠期间新建)在 buffer 里没有对应行,计进 lineCount 会多删相邻正文。
-            if (child.summaryAbsIdx < 0) {
-                child.renderedCount = 0;
-                child.expandedEntries.clear();
-                expandedBatches.delete(child.id);
-                continue;
-            }
-            lineCount += 1; // 子批摘要行本身
-            if (expandedBatches.has(child.id)) {
-                // 子批自身展开时,它的第一层明细行(renderedCount)也在父批块内,必须一并计入,
-                // 否则删少了会留下孤儿明细行。
-                lineCount += child.renderedCount;
-                for (const j of child.expandedEntries) {
-                    lineCount += buildEntryDetailLines(child.entries[j], entryDetailIndent(child.indent ?? '')).length;
-                }
-                child.expandedEntries.clear();
-                expandedBatches.delete(child.id);
-            }
-            child.renderedCount = 0;
-            absLineToBatchId.delete(child.summaryAbsIdx);
-            child.summaryAbsIdx = -1;
-            for (const [idx, target] of absLineToEntry) {
-                if (target.batchId === child.id)
-                    absLineToEntry.delete(idx);
-            }
-        }
-    }
+    // 折叠时:递归移除挂在本批下的整棵子批树(子批摘要行 + 已展开明细),
+    // 否则父批再次展开后子批摘要/明细仍残留,出现重复行。组容器批与普通子 agent 批同一路径。
+    lineCount += foldChildren(b.id);
     layout.contentDeleteFrom(b.summaryAbsIdx + 1, lineCount);
     expandedBatches.delete(b.id);
     b.renderedCount = 0;
@@ -867,11 +874,10 @@ export function toggleEntry(batchId, entryIndex, layout) {
     const b = batches.get(batchId);
     if (!b || !expandedBatches.has(batchId))
         return;
-    // 组容器批的 entry 对应一个子 Agent 批；点击 entry 行应展开/折叠该 entry
-    // 自身的详情（即子 agent 返回的完整文本输出）。子 agent 的工具调用列表由点击
-    // 子批自己的摘要行（● 子 Agent 完成 ...）来控制。
-    if (b.groupParent) {
-        // 如果该 sub-agent entry 没有可展开的详情，fallback 到 toggle 子批工具列表。
+    // sub-agent entry(组容器批的顶层调用,或子 agent 内部嵌套派生)对应一个子批:
+    // 点击 entry 行优先展开/折叠该 entry 自身详情(子 agent 返回的完整文本输出);
+    // 只有没有自身详情时,才 fallback 到 toggle 对应子批的工具列表。
+    if (b.entries[entryIndex]?.name === 'sub-agent') {
         const details = buildEntryDetailLines(b.entries[entryIndex], entryDetailIndent(b.indent ?? ''));
         if (details.length === 0) {
             const child = [...batches.values()].find((x) => x.parentId === batchId && x.groupChildIndex === entryIndex);

package/dist/ui/fuzzy-picker.js

@@ -0,0 +1,227 @@
+/**
+ * 通用模糊选择器（#模型命令交互）。
+ *
+ * 把 history-picker 的「输入即过滤 + ↑↓ + Enter」骨架抽成泛型组件：候选是任意对象，
+ * 由调用方提供 searchable 文本与渲染行。不绑定「历史/模型」语义，任何「从一大堆项里
+ * 挑一个」的场景都能用。
+ *
+ * 交互契约：
+ *  - 可打印字符      追加到过滤词，实时模糊过滤（fuzzy.ts）
+ *  - ↑/↓            移动高亮（循环；只在可选项间移动）
+ *  - Enter          确认当前高亮项
+ *  - Esc / Ctrl+C   取消，返回 null
+ *  - Backspace 等    常规行编辑；Ctrl+U 清行
+ */
+import { stdin } from 'node:process';
+import { ui } from './theme.js';
+import { displayWidth, truncateDisplay } from './render.js';
+import * as layout from './layout.js';
+import { fuzzyMatch } from './fuzzy.js';
+/** 纯函数：按 query 过滤+排序，禁用项沉底并保留（用于呈现，不参与选择）。导出供单测。 */
+export function filterItems(query, items) {
+    const q = query.trim();
+    const enabled = [];
+    const disabled = [];
+    for (const item of items) {
+        if (!q) {
+            (item.disabled ? disabled : enabled).push({ item, score: 0 });
+            continue;
+        }
+        const m = fuzzyMatch(q, item.searchText);
+        if (!m)
+            continue;
+        (item.disabled ? disabled : enabled).push({ item, score: m.score });
+    }
+    if (q)
+        enabled.sort((a, b) => b.score - a.score);
+    return [...enabled, ...disabled];
+}
+export async function promptFuzzyPicker(opts) {
+    if (!layout.isActive())
+        return null;
+    const maxVisible = opts.maxVisible ?? 10;
+    const emitter = stdin;
+    let query = opts.initialQuery ?? '';
+    let cursor = query.length;
+    let matches = [];
+    let selected = 0; // 在 matches 中的下标（可能落在禁用项，移动时跳过）
+    let menuTop = 0;
+    let resolved = false;
+    let resolve;
+    /** 可选项（非禁用）下标集合。 */
+    function enabledIndices() {
+        const out = [];
+        matches.forEach((r, i) => {
+            if (!r.item.disabled)
+                out.push(i);
+        });
+        return out;
+    }
+    function clampSelected() {
+        const en = enabledIndices();
+        if (en.length === 0) {
+            selected = matches.length ? 0 : 0;
+            return;
+        }
+        if (!en.includes(selected))
+            selected = en[0];
+    }
+    function recompute() {
+        matches = filterItems(query, opts.items);
+        clampSelected();
+    }
+    function menuLines() {
+        const cols = layout.getGeo().cols;
+        const lines = [`${ui.bold}${truncateDisplay(opts.title, cols)}${ui.reset}`];
+        if (opts.hint)
+            lines.push(`${ui.dim}${truncateDisplay(opts.hint, cols)}${ui.reset}`);
+        const en = enabledIndices();
+        if (en.length === 0) {
+            lines.push(`${ui.dim}${query.trim() ? '无匹配，按 Esc 返回' : '（空列表）'}${ui.reset}`);
+            return lines;
+        }
+        // 开窗：以 selected 为中心。
+        const visibleCount = Math.min(maxVisible, en.length);
+        const selPos = en.indexOf(selected);
+        let page = Math.floor(selPos / visibleCount);
+        const winEn = en.slice(page * visibleCount, page * visibleCount + visibleCount);
+        menuTop = winEn[0];
+        const hasMore = page * visibleCount + visibleCount < en.length;
+        const hasAbove = page > 0;
+        winEn.forEach((idx, i) => {
+            const r = matches[idx];
+            const isSel = idx === selected;
+            const color = isSel ? `${ui.accent}${ui.bold}` : '';
+            const marker = isSel ? `${ui.accent}${ui.bold}▸${ui.reset}` : ' ';
+            let scrollHint = '';
+            if (i === 0 && hasAbove)
+                scrollHint = ' ▲';
+            if (i === winEn.length - 1 && hasMore)
+                scrollHint = ' ▼';
+            const detail = r.item.detail ? `  ${ui.dim}${r.item.detail}${ui.reset}` : '';
+            const budget = cols - 4 - scrollHint.length - (r.item.detail ? displayWidth(r.item.detail) + 2 : 0);
+            const body = truncateDisplay(r.item.label, Math.max(1, budget));
+            lines.push(`${marker} ${color}${body}${ui.reset}${detail}${ui.dim}${scrollHint}${ui.reset}`);
+        });
+        return lines;
+    }
+    function redraw() {
+        layout.paintInput({
+            prompt: '❯ ',
+            lines: [query],
+            cursorLine: 0,
+            cursorCol: displayWidth(query.slice(0, cursor)),
+            menu: { lines: menuLines() },
+        });
+    }
+    function finish(v) {
+        if (resolved)
+            return;
+        resolved = true;
+        layout.setMouseEnabled(true); // 恢复输入框态鼠标(框选/右键粘贴)
+        try {
+            stdin.setRawMode(false);
+        }
+        catch {
+            /* 忽略 */
+        }
+        emitter.removeListener('keypress', onKey);
+        stdin.pause();
+        // 擦菜单区。
+        layout.paintInput({ prompt: '❯ ', lines: [''], cursorLine: 0, cursorCol: 0, menu: null });
+        resolve(v);
+    }
+    function move(delta) {
+        const en = enabledIndices();
+        if (en.length === 0)
+            return;
+        const pos = en.indexOf(selected);
+        const nextPos = (pos + delta + en.length) % en.length;
+        selected = en[nextPos];
+        redraw();
+    }
+    function onKey(_str, key) {
+        if (key.name === 'escape')
+            return finish(null);
+        if (key.ctrl && key.name === 'c')
+            return finish(null);
+        if (key.name === 'return' || key.name === 'enter') {
+            const r = matches[selected];
+            if (r && !r.item.disabled)
+                finish(r.item.value);
+            return;
+        }
+        switch (key.name) {
+            case 'up':
+                move(-1);
+                return;
+            case 'down':
+                move(1);
+                return;
+            case 'left':
+                if (cursor > 0) {
+                    cursor--;
+                    redraw();
+                }
+                return;
+            case 'right':
+                if (cursor < query.length) {
+                    cursor++;
+                    redraw();
+                }
+                return;
+            case 'home':
+                cursor = 0;
+                redraw();
+                return;
+            case 'end':
+                cursor = query.length;
+                redraw();
+                return;
+            case 'backspace':
+                if (cursor > 0) {
+                    query = query.slice(0, cursor - 1) + query.slice(cursor);
+                    cursor--;
+                    recompute();
+                    redraw();
+                }
+                return;
+            case 'delete':
+                if (cursor < query.length) {
+                    query = query.slice(0, cursor) + query.slice(cursor + 1);
+                    recompute();
+                    redraw();
+                }
+                return;
+        }
+        if (key.ctrl && key.name === 'u') {
+            query = '';
+            cursor = 0;
+            recompute();
+            redraw();
+            return;
+        }
+        const s = key.sequence ?? '';
+        if (s && s >= ' ' && !key.ctrl && !key.meta) {
+            query = query.slice(0, cursor) + s + query.slice(cursor);
+            cursor += s.length;
+            recompute();
+            redraw();
+        }
+    }
+    recompute();
+    return new Promise((res) => {
+        resolve = res;
+        layout.setMouseEnabled(false);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            res(null);
+            return;
+        }
+        stdin.resume();
+        emitter.on('keypress', onKey);
+        redraw();
+    });
+}