berry-agent 0.1.0-alpha.1

package/dist/channels/tui/history/history-viewer.js

@@ -0,0 +1,403 @@
+import { graphemeWidth, splitGraphemes } from '../../engine/index.js';
+import { ScrollView } from '../scroll/scroll-view.js';
+import { Editor } from '../editor/editor.js';
+import { prefixDisplayWidth } from '../editor/visual-lines.js';
+import { LiveTranscript, renderBlockStyledLines, shortIdOf } from '../backend/transcript.js';
+import { sessionColor } from '../theme.js';
+/** 当前匹配高亮样式（整段反色——视口内最强存在感；选区高亮同载体叠加） */
+const MATCH_STYLE = Object.freeze({ inverse: true });
+/** 提示行样式（dim——存在感弱于正文） */
+const HINT_STYLE = Object.freeze({ dim: true });
+/** 常态底行键面提示 */
+const HINT_TEXT = 'q/esc 返回 · ctrl+shift+f 搜索 · ↑↓/pgup/pgdn/home/end 滚动 · 拖选复制';
+/** 选区帽（64 KiB——07 件 8 细则码面缺省参数；计量面 = 选中明文 UTF-8 字节数，与 xterm 100,000 解码后上限同基准） */
+const SELECTION_CAP_BYTES = 64 * 1024;
+/** 超帽底行提示（spec 定文——常显至选区清除） */
+const SELECTION_CAP_NOTICE = '选区过大未复制';
+/** key 事件窄化（其他事件形归各分路——text/ime/paste） */
+function asKey(event) {
+    return event.kind === 'key' ? event : null;
+}
+/** 无修饰命名键判（让位判据与退出键消费的判据面） */
+function isPlainKey(e, key) {
+    return !e.ctrl && !e.alt && !e.shift && !e.meta && e.key === key;
+}
+/**
+ * 回看器内容件：ScrollView 子类（滚动/折叠/偏移算术继承）+ OverlayContent
+ * （副屏 root——render 直收全屏 region，量高不经布局路）。
+ */
+export class HistoryViewer extends ScrollView {
+    sessionId;
+    shortId;
+    /** 带样式行集（构造后静态——快照档 v1：回看期新事件不进副屏） */
+    styledLines;
+    onExit;
+    onInterrupt;
+    onQuit;
+    onCopy;
+    /* ---- 搜索态（开/跳/关三动作状态机） ---- */
+    searchOpen = false;
+    searchEditor;
+    matches = [];
+    matchIndex = -1;
+    /** 退出闭锁（同批多事件只退一次——q 与 Esc 竞发的防御位） */
+    exited = false;
+    /* ---- 选区态（press 锚定 → motion 扩展 → release 复制——线性选区状态机） ---- */
+    selAnchor = null;
+    selFocus = null;
+    /** 底行提示文案（超帽拒复制——常显至选区清除；null = 常态键面提示） */
+    selectionNotice = null;
+    constructor(options) {
+        super(); // 无 maxHeight——副屏 root 直收 region 全高
+        this.sessionId = options.sessionId;
+        this.shortId = shortIdOf(options.sessionId);
+        this.onExit = options.onExit;
+        this.onInterrupt = options.onInterrupt;
+        this.onQuit = options.onQuit;
+        this.onCopy = options.onCopy;
+        // 全量档行集：投影 → LiveTranscript（Infinity 帽恒不截）→ 带样式行（管线单源）
+        const transcript = new LiveTranscript({ blockCap: Number.POSITIVE_INFINITY });
+        transcript.loadProjection(options.messages);
+        const styled = [];
+        for (const block of transcript.snapshot) {
+            styled.push(...renderBlockStyledLines(block, options.columns));
+        }
+        this.styledLines = styled;
+        super.setLines(styled.map((line) => line.plain)); // 开屏贴尾（follow 初始 true）
+        this.searchEditor = new Editor({
+            maxVisibleLines: 1, // 单行档——搜索框
+            onChange: () => this.recomputeMatches(),
+        });
+        this.searchEditor.setFocused(false);
+    }
+    /** 量高：头行 + 视口全量 + 底铬（副屏 root 不经布局路——契约的诚实实现） */
+    measure(width) {
+        return 1 + super.measure(width) + (this.searchOpen ? this.searchEditor.measure(width) : 1);
+    }
+    /**
+     * 落位（副屏全屏 region 自底盘向上三段）：头行（档名 + 会话短 id 会话区分色
+     * + 搜索计数）→ 滚动视口（super.render——折叠/偏移/滚动条恒归 ScrollView）→
+     * 底铬（搜索在场 = 单行 Editor；否则键面提示行）。
+     */
+    render(buffer, region) {
+        if (region.height < 2)
+            return; // 防御位（极小终端——头行 + 视口都不够）
+        // 头行
+        const headPrefix = '↩ 历史回看 · ';
+        buffer.writeText(region.row, region.col, headPrefix);
+        // 会话短 id 起列 = 前缀显示宽（CJK 双宽——UTF-16 长度直减不可靠）
+        buffer.writeText(region.row, region.col + prefixDisplayWidth(headPrefix, headPrefix.length), this.shortId, {
+            fg: sessionColor(this.shortId),
+        });
+        if (this.searchOpen) {
+            // 搜索计数（当前/总数；无匹配如实 0）
+            const count = `${this.matchIndex + 1}/${this.matches.length}`;
+            buffer.writeText(region.row, region.col + region.width - 1 - count.length, count, HINT_STYLE);
+        }
+        // 滚动视口（头行与底铬之间）
+        const chromeBottom = this.searchOpen ? this.searchEditor.measure(region.width) : 1;
+        const viewHeight = region.height - 1 - chromeBottom;
+        if (viewHeight > 0) {
+            super.render(buffer, { row: region.row + 1, col: region.col, width: region.width, height: viewHeight });
+        }
+        // 底铬
+        if (this.searchOpen) {
+            this.searchEditor.setFocused(true);
+            this.searchEditor.render(buffer, {
+                row: region.row + region.height - chromeBottom,
+                col: region.col,
+                width: region.width,
+                height: chromeBottom,
+            });
+        }
+        else {
+            // 底行：超帽提示优先（常显至选区清除），否则常态键面提示
+            buffer.writeText(region.row + region.height - 1, region.col, this.selectionNotice ?? HINT_TEXT, HINT_STYLE);
+        }
+    }
+    /**
+     * 事件分发（副屏内容终局消费——未消费键不穿透，模态独占）。
+     * 序：Ctrl+C / Ctrl+D 副屏键面补丁 → 搜索开关键 → 搜索在场模态（让位判据：
+     * q/Esc 不退出）→ 常态退出键（q/Esc）→ 滚动键（ScrollView）。
+     */
+    handleEvent(event) {
+        if (event.kind === 'mouse')
+            return this.handleMouse(event); // mouse 路（终局消费——模态独占）
+        const k = asKey(event);
+        if (k !== null && k.phase !== 'release') {
+            // Ctrl+C = 打断在飞 run（press/repeat 相动作滤 kitty release——与滚动键/编辑键的相过滤同律）
+            if (k.ctrl && !k.alt && !k.shift && !k.meta && k.key === 'c') {
+                this.onInterrupt?.(this.sessionId);
+                return true;
+            }
+            // Ctrl+D = 退出（先收副屏再转退出柄；搜索框有文不退——主屏空框闸同律）
+            if (k.ctrl && !k.alt && !k.shift && !k.meta && k.key === 'd' && this.searchEditor.model.isEmpty()) {
+                this.exit();
+                this.onQuit?.();
+                return true;
+            }
+            // 搜索开键（条款锁能力不锁键位）：kitty 轨 ctrl+shift+f；legacy 轨 0x06
+            // 归一 ctrl+f（shift 不可辨）——搜索关态两形同判，开态 ctrl+f 让路编辑器
+            if (k.ctrl && !k.alt && !k.meta && k.key === 'f' && (k.shift || !this.searchOpen)) {
+                if (!this.searchOpen)
+                    this.openSearch();
+                return true; // 已开态的 ctrl+shift+f = no-op（层内终局）
+            }
+        }
+        if (this.searchOpen) {
+            // 让位判据（条款）：搜索框在场时 Esc 先关搜索、q 落框内——退出键不消费
+            if (k !== null && k.phase !== 'release' && !k.ctrl && !k.alt && !k.meta) {
+                if (isPlainKey(k, 'escape')) {
+                    this.closeSearch();
+                    return true;
+                }
+                if (isPlainKey(k, 'enter')) {
+                    this.jumpMatch(1); // 跳匹配：Enter 下一
+                    return true;
+                }
+                if (k.shift && k.key === 'enter') {
+                    this.jumpMatch(-1); // Shift+Enter 上一
+                    return true;
+                }
+            }
+            // 其余（文本/IME/粘贴/编辑键）入搜索框；未消费键层内终局（模态）
+            this.searchEditor.handleEvent(event);
+            return true;
+        }
+        // 常态退出键（搜索不在场——让位判据的另一面）：q（text 路为主——kitty
+        // disambiguate 轨纯键打字走 text 事件；key 路防御同判）与 Esc
+        if (k !== null && k.phase !== 'release') {
+            if (isPlainKey(k, 'escape') || isPlainKey(k, 'q')) {
+                this.exit();
+                return true;
+            }
+        }
+        if (event.kind === 'text' && event.text === 'q') {
+            this.exit();
+            return true;
+        }
+        // 滚动键（↑/↓/PgUp/PgDn/Home/End——ScrollView 自持；未消费键终局吞）
+        this.handleEventSuper(event);
+        return true;
+    }
+    /** super.handleEvent 直呼（子类覆写同名面后仍需触达基类滚动路的显式位） */
+    handleEventSuper(event) {
+        super.handleEvent(event);
+    }
+    /* ---------------- 鼠标选区（mu-2——07 件 8 细则） ---------------- */
+    /**
+     * mouse 事件路（副屏内容件终局消费——未消费 mouse 不穿透，模态独占）：
+     * 滚轮归 ScrollView（搜索在场也照常滚——禁的是拖选）；选区 = 左键 press
+     * 锚定 → motion 扩展 → release 复制（release 后选区高亮保留，下次 press
+     * 清除/重锚）。
+     */
+    handleMouse(event) {
+        if (event.button === 'wheel-up' || event.button === 'wheel-down') {
+            this.handleEventSuper(event); // 滚轮消费路（±3 视觉行——显式滚动路）
+            return true;
+        }
+        if (this.searchOpen)
+            return true; // 搜索框在场拖选禁用（输入模态优先）——吞
+        if (event.button !== 'left')
+            return true; // v1 选区只有左键——中/右零动作吞
+        if (event.phase === 'press') {
+            // 新选区起手：旧选区与超帽提示随清（「常显至选区清除」的清除位）
+            this.selectionNotice = null;
+            const hit = this.screenToLogical(event.row, event.col);
+            this.selAnchor = hit; // 视口外起手 = null（无锚——motion/release 零动作）
+            this.selFocus = hit; // 零宽起手（拖动才扩）
+            return true;
+        }
+        if (this.selAnchor === null)
+            return true; // 无锚——motion/release 零动作
+        if (event.phase === 'motion') {
+            const hit = this.screenToLogical(event.row, event.col);
+            if (hit !== null)
+                this.selFocus = hit; // 拖出视口（头行/底铬/滚动条列）保焦点不扩
+            return true;
+        }
+        // release：空选区零动作；超帽拒复制 + 底行提示；在帽行间拼 LF 经注入柄写出
+        const text = this.selectionText();
+        if (text.length === 0)
+            return true;
+        if (Buffer.byteLength(text, 'utf8') > SELECTION_CAP_BYTES) {
+            this.selectionNotice = SELECTION_CAP_NOTICE;
+            return true;
+        }
+        this.onCopy?.(text);
+        return true;
+    }
+    /**
+     * 屏幕坐标 → 选区定位点（逻辑行 + 行内 UTF-16 下标）：视口外命中（头行/
+     * 底铬/滚动条列/界外）返 null 零动作；列反查走字素宽累加（与折叠算术同源
+     * ——CJK 双宽对齐，命中字素含半格命中归该字素首）。
+     */
+    screenToLogical(row, col) {
+        const geo = this.viewportGeometry;
+        if (row < 1 || row >= 1 + geo.height)
+            return null; // 头行 / 底铬（拖选仅在搜索不在场——底铬恒提示行 1 行）
+        if (col < 0 || col >= geo.width)
+            return null; // 界外防御位
+        if (this.hitScrollbar(col))
+            return null; // 滚动条列（溢出让列时末列）零动作
+        const seg = this.segmentAt(row - 1);
+        if (seg === null)
+            return null;
+        const text = this.styledLines[seg.line]?.plain ?? '';
+        let index = seg.startCol;
+        let seen = 0;
+        for (const g of splitGraphemes(text.slice(seg.startCol, seg.startCol + seg.length))) {
+            if (seen + graphemeWidth(g) > col)
+                break; // 命中字素（含双宽字素半格）归该字素首
+            seen += graphemeWidth(g);
+            index += g.length;
+        }
+        return { line: seg.line, col: index };
+    }
+    /** 选区规范化（锚/焦点 → 升序两端点；无选区 null） */
+    selectionBounds() {
+        if (this.selAnchor === null || this.selFocus === null)
+            return null;
+        const flip = this.selFocus.line < this.selAnchor.line ||
+            (this.selFocus.line === this.selAnchor.line && this.selFocus.col < this.selAnchor.col);
+        return flip ? [this.selFocus, this.selAnchor] : [this.selAnchor, this.selFocus];
+    }
+    /** 选区明文（行间拼 LF——release 复制与帽计量的单源；空选区空串） */
+    selectionText() {
+        const bounds = this.selectionBounds();
+        if (bounds === null)
+            return '';
+        const [from, to] = bounds;
+        const parts = [];
+        for (let line = from.line; line <= to.line; line++) {
+            const plain = this.styledLines[line]?.plain ?? '';
+            const start = line === from.line ? from.col : 0;
+            const end = line === to.line ? to.col : plain.length;
+            parts.push(plain.slice(start, end));
+        }
+        return parts.join('\n');
+    }
+    /**
+     * 本逻辑行的选中区间（端点含头不含尾；end = Infinity 表行尾开放——跨行尾
+     * 段；无选区/异行 null）。writeSlice 高亮与 selectionText 共用此规范化。
+     */
+    selectionSpanFor(line) {
+        const bounds = this.selectionBounds();
+        if (bounds === null)
+            return null;
+        const [from, to] = bounds;
+        if (line < from.line || line > to.line)
+            return null;
+        return {
+            start: line === from.line ? from.col : 0,
+            end: line === to.line ? to.col : Number.POSITIVE_INFINITY,
+        };
+    }
+    /* ---------------- 搜索三动作 ---------------- */
+    /** 开：搜索框在场 + 按在框文本重算匹配并跳首匹配 */
+    openSearch() {
+        this.searchOpen = true;
+        this.recomputeMatches();
+    }
+    /** 关：框退场 + 高亮清（查询文本保留——重开续搜的增量检索延续） */
+    closeSearch() {
+        this.searchOpen = false;
+        this.matches = [];
+        this.matchIndex = -1;
+        this.searchEditor.setFocused(false);
+    }
+    /** 匹配重算（查询变更路）：全行不区分大小写子串扫描 + 跳首匹配 */
+    recomputeMatches() {
+        const query = this.searchEditor.getText();
+        const found = [];
+        if (query !== '') {
+            const q = query.toLowerCase();
+            for (let i = 0; i < this.styledLines.length; i++) {
+                const plain = this.styledLines[i].plain.toLowerCase();
+                let at = plain.indexOf(q);
+                while (at !== -1) {
+                    found.push({ line: i, start: at, end: at + q.length });
+                    at = plain.indexOf(q, at + 1);
+                }
+            }
+        }
+        this.matches = found;
+        this.matchIndex = found.length > 0 ? 0 : -1;
+        if (this.matchIndex >= 0)
+            this.scrollToLine(found[0].line, found[0].start);
+    }
+    /** 跳匹配（±1 循环——尾后回首、首前到尾） */
+    jumpMatch(delta) {
+        if (this.matches.length === 0)
+            return;
+        this.matchIndex = (this.matchIndex + delta + this.matches.length) % this.matches.length;
+        const m = this.matches[this.matchIndex];
+        this.scrollToLine(m.line, m.start);
+    }
+    /** 退出（闭锁——单次） */
+    exit() {
+        if (this.exited)
+            return;
+        this.exited = true;
+        this.onExit?.();
+    }
+    /* ---------------- 带样式切片写出（writeSlice 覆写接缝） ---------------- */
+    /**
+     * 视口切片带样式写出：样式段（管线单源产物）按切片边界分段落格 + 当前匹配
+     * 反色高亮叠加。列位经 prefixDisplayWidth 换算（UTF-16 切片下标 → 显示列
+     * ——CJK 双宽对齐与折叠算术同源）。
+     */
+    writeSlice(buffer, region, displayRow, seg) {
+        const styled = this.styledLines[seg.line];
+        if (styled === undefined)
+            return;
+        const start = seg.startCol;
+        const end = seg.startCol + seg.length;
+        // 当前匹配与本切片的交叠段（无匹配/异行 = 空区间）
+        const match = this.matchIndex >= 0 ? this.matches[this.matchIndex] : undefined;
+        const hlStart = match !== undefined && match.line === seg.line ? Math.max(match.start, start) : end;
+        const hlEnd = match !== undefined && match.line === seg.line ? Math.min(match.end, end) : start;
+        // 选区段（本切片所在逻辑行的选中区间——与当前匹配同 inverse 载体叠加）
+        const sel = this.selectionSpanFor(seg.line);
+        const selStart = sel !== null ? Math.max(sel.start, start) : end;
+        const selEnd = sel !== null ? Math.min(sel.end, end) : start;
+        // 分段边界：切片端点 ∪ 样式段端点 ∪ 高亮端点 ∪ 选区端点（升序去重）
+        const cuts = new Set([start, end]);
+        for (const run of styled.runs) {
+            if (run.start > start && run.start < end)
+                cuts.add(run.start);
+            if (run.end > start && run.end < end)
+                cuts.add(run.end);
+        }
+        if (hlStart > start && hlStart < end)
+            cuts.add(hlStart);
+        if (hlEnd > start && hlEnd < end)
+            cuts.add(hlEnd);
+        if (selStart > start && selStart < end)
+            cuts.add(selStart);
+        if (selEnd > start && selEnd < end)
+            cuts.add(selEnd);
+        const bounds = [...cuts].sort((a, b) => a - b);
+        const baseCols = prefixDisplayWidth(styled.plain, start);
+        for (let i = 0; i + 1 < bounds.length; i++) {
+            const from = bounds[i];
+            const to = bounds[i + 1];
+            // 段样式：覆写 from 起点的样式段（段间空隙 = 裸文本）
+            let style;
+            for (const run of styled.runs) {
+                if (run.start <= from && from < run.end) {
+                    style = run.style;
+                    break;
+                }
+            }
+            if (from >= hlStart && from < hlEnd) {
+                style = style === undefined ? MATCH_STYLE : { ...style, inverse: true };
+            }
+            if (from >= selStart && from < selEnd) {
+                // 选区高亮（与搜索匹配同 inverse 载体——叠加处同 inverse 幂等）
+                style = style === undefined ? MATCH_STYLE : { ...style, inverse: true };
+            }
+            buffer.writeText(region.row + displayRow, region.col + prefixDisplayWidth(styled.plain, from) - baseCols, styled.plain.slice(from, to), style);
+        }
+    }
+}

package/dist/channels/tui/index.js

@@ -0,0 +1,3 @@
+export { TuiBackend } from './backend/tui-backend.js';
+// 补全源族（批 12e host 装配消费——@ 文件段源与注入面类型；组件族余者仍件内）
+export { FileMentionSource } from './autocomplete/file-mentions.js';

package/dist/channels/tui/layout.js

@@ -0,0 +1,167 @@
+/** Flex 结构判据（isFlex 真值 = Column 吸收余量的信号位） */
+export function isFlexRenderable(r) {
+    return r.isFlex === true;
+}
+/** 区域取交（越界返回 null——布局夹取的公共件） */
+function intersect(a, b) {
+    const row1 = Math.max(a.row, b.row);
+    const col1 = Math.max(a.col, b.col);
+    const row2 = Math.min(a.row + a.height, b.row + b.height);
+    const col2 = Math.min(a.col + a.width, b.col + b.width);
+    if (row2 <= row1 || col2 <= col1)
+        return null;
+    return { row: row1, col: col1, width: col2 - col1, height: row2 - row1 };
+}
+/** Flex 包装件（isFlex 标记——Column 吸收余量的信号；协商最小占位 1） */
+export class Flex {
+    isFlex = true;
+    child;
+    constructor(props) {
+        this.child = props.child;
+    }
+    measure(_width) {
+        return 1; // 协商最小占位（真高度由 Column 分配余量决定）
+    }
+    render(buffer, region) {
+        if (region.height <= 0 || region.width <= 0)
+            return;
+        this.child.render(buffer, region);
+    }
+}
+/**
+ * 垂直堆叠组合子：固定子按 measure(width) 定高顺排；Flex 子均分余量
+ * （整除余数给最后一个 Flex 子）。子区域宽 = 全宽；底部溢出截断。
+ */
+export class Column {
+    children;
+    constructor(props) {
+        this.children = props.children;
+    }
+    measure(width) {
+        // 协商面：固定子按各自期望；Flex 子按最小占位 1 计
+        let total = 0;
+        for (const c of this.children) {
+            total += isFlexRenderable(c) ? 1 : Math.max(1, c.measure(width));
+        }
+        return Math.max(1, total);
+    }
+    render(buffer, region) {
+        if (region.width <= 0 || region.height <= 0)
+            return;
+        // 两遍：先算固定高合计与 Flex 子数，再逐子分配落位
+        const fixed = [];
+        let fixedSum = 0;
+        let flexCount = 0;
+        for (const c of this.children) {
+            if (isFlexRenderable(c)) {
+                fixed.push(-1);
+                flexCount++;
+            }
+            else {
+                const h = Math.max(1, c.measure(region.width));
+                fixed.push(h);
+                fixedSum += h;
+            }
+        }
+        const remaining = Math.max(0, region.height - fixedSum);
+        const flexH = flexCount > 0 ? Math.max(1, Math.floor(remaining / flexCount)) : 0;
+        let flexSeen = 0;
+        let row = region.row;
+        for (let idx = 0; idx < this.children.length; idx++) {
+            if (row >= region.row + region.height)
+                break; // 底部溢出截断
+            const child = this.children[idx];
+            let h;
+            if (fixed[idx] < 0) {
+                flexSeen++;
+                // 末 Flex 子收整除余数（份额 = 余量 - 前 N-1 份），仍受底部截断约束
+                const share = flexSeen === flexCount ? remaining - flexH * (flexCount - 1) : flexH;
+                h = Math.min(Math.max(0, share), region.row + region.height - row);
+            }
+            else {
+                h = Math.min(fixed[idx], region.row + region.height - row);
+            }
+            if (h > 0) {
+                child.render(buffer, { row, col: region.col, width: region.width, height: h });
+            }
+            row += h;
+        }
+    }
+}
+/** 水平分列组合子：按权重分宽（整除余数给末列）；高度 = 各子期望最大值 */
+export class Row {
+    children;
+    weights;
+    constructor(props) {
+        this.children = props.children;
+        this.weights = props.weights ?? props.children.map(() => 1);
+    }
+    /**
+     * 在总宽 width 下各子分得的列宽（含余数吸收——render 与 measure 共用
+     * 单源：两段协商「同一分配单源」条款的执法位）。
+     */
+    allocate(width) {
+        const totalW = this.weights.reduce((a, b) => a + b, 0);
+        const out = [];
+        let used = 0;
+        for (let i = 0; i < this.children.length; i++) {
+            // 末列收整除余数（宽 = 总宽 - 前已分），前列按权重整除
+            const w = i === this.children.length - 1 ? width - used : Math.floor((width * (this.weights[i] ?? 1)) / totalW);
+            out.push(Math.max(0, w));
+            used += Math.max(0, w);
+        }
+        return out;
+    }
+    measure(width) {
+        const widths = this.allocate(Math.max(1, width));
+        let max = 1;
+        for (let i = 0; i < this.children.length; i++) {
+            max = Math.max(max, this.children[i].measure(Math.max(1, widths[i])));
+        }
+        return max;
+    }
+    render(buffer, region) {
+        if (region.width <= 0 || region.height <= 0)
+            return;
+        const widths = this.allocate(region.width);
+        let col = region.col;
+        for (let i = 0; i < this.children.length; i++) {
+            if (col >= region.col + region.width)
+                break; // 右侧溢出截断
+            if (widths[i] > 0) {
+                this.children[i].render(buffer, { row: region.row, col, width: widths[i], height: region.height });
+            }
+            col += widths[i];
+        }
+    }
+}
+/** 内缩组合子：区域四向收缩后与原区域取交整夹，再整交子件 */
+export class Inset {
+    child;
+    top;
+    right;
+    bottom;
+    left;
+    constructor(props) {
+        this.child = props.child;
+        this.top = props.top ?? 0;
+        this.right = props.right ?? 0;
+        this.bottom = props.bottom ?? 0;
+        this.left = props.left ?? 0;
+    }
+    measure(width) {
+        return Math.max(1, this.child.measure(Math.max(1, width - this.left - this.right))) + this.top + this.bottom;
+    }
+    render(buffer, region) {
+        const inner = {
+            row: region.row + this.top,
+            col: region.col + this.left,
+            width: Math.max(0, region.width - this.left - this.right),
+            height: Math.max(0, region.height - this.top - this.bottom),
+        };
+        const clipped = intersect(inner, region);
+        if (!clipped)
+            return;
+        this.child.render(buffer, clipped);
+    }
+}

package/dist/channels/tui/markdown/blocks.js

@@ -0,0 +1,111 @@
+/**
+ * Markdown 块解析件（07 §4.1 引擎节件 6——批 10d-4）。
+ *
+ * 块模型 = 滚动帽单位（呈现面件 1：一个 Markdown 块一子行——blockCount
+ * 即帽额度计数）。v1 支持面（CommonMark 子集，边界注释在案）：
+ * 标题 #..######、段落（段内软换行折叠为空格——标准语义）、无序/有序
+ * 列表（嵌套缩进 2 空格一层）、围栏代码块（```/~~~）、引用（>，连续行
+ * 归块）、水平线（三连 - 或 * 或 _）。缩进四空格代码块、表格、脚注不
+ * 支撑（未列形按段落回退——坏输入不丢字）。
+ */
+import { parseInline } from './inline.js';
+/** 围栏开行（```/~~~ 可 repetitions——闭栏同字符等长以上） */
+const FENCE_RE = /^(`{3,}|~{3,})\s*(\S*)\s*$/;
+/** 标题行（# 1-6 个 + 空格） */
+const HEADING_RE = /^(#{1,6})\s+(.*)$/;
+/** 水平线（同字符 ≥3、容忍符间空格） */
+const HR_RE = /^(?:[-*_])(?:\s*[-*_]){2,}$/;
+/** 列表项（前导缩进 + 无序符或有序序号符 + 空格 + 内容） */
+const LIST_RE = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/;
+/**
+ * 块解析：全文 → 块序列。CRLF/CR 统一 LF；未闭围栏收至文末（防御——
+ * 流式半截文本换装前的定稿才进本件，但防御不依赖调用方）。
+ */
+export function parseMarkdown(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const blocks = [];
+    let paragraph = [];
+    const flushParagraph = () => {
+        if (paragraph.length > 0) {
+            // 段内软换行折叠为空格（Markdown 标准语义——渲染时按宽重折）
+            blocks.push({ type: 'paragraph', spans: parseInline(paragraph.join(' ')) });
+            paragraph = [];
+        }
+    };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trimEnd();
+        if (line.trim() === '') {
+            flushParagraph(); // 空行断段
+            i++;
+            continue;
+        }
+        // 围栏代码块：吃到闭栏（同字符等长以上）或文末
+        const fence = FENCE_RE.exec(line.trim());
+        if (fence !== null) {
+            flushParagraph();
+            const marker = fence[1];
+            const language = fence[2] !== '' ? fence[2] : undefined;
+            const closeChar = marker[0];
+            const code = [];
+            i++;
+            while (i < lines.length) {
+                const inner = lines[i];
+                if (inner.trimStart().startsWith(closeChar) && inner.trim().length >= marker.length)
+                    break;
+                code.push(inner);
+                i++;
+            }
+            i++; // 越过闭栏（文末防御——闭栏缺席时此步越界无害）
+            blocks.push({ type: 'code', lines: code, language });
+            continue;
+        }
+        // 标题
+        const heading = HEADING_RE.exec(line);
+        if (heading !== null) {
+            flushParagraph();
+            blocks.push({ type: 'heading', level: heading[1].length, spans: parseInline(heading[2]) });
+            i++;
+            continue;
+        }
+        // 水平线
+        if (HR_RE.test(line.trim())) {
+            flushParagraph();
+            blocks.push({ type: 'hr' });
+            i++;
+            continue;
+        }
+        // 引用（连续 > 行归一块）
+        if (line.startsWith('>')) {
+            flushParagraph();
+            const quoted = [];
+            while (i < lines.length && lines[i].startsWith('>')) {
+                // 剥 '> ' 或 '>' 前缀（无空格紧贴形同剥）
+                const body = lines[i].replace(/^>\s?/, '');
+                quoted.push(body.trim() === '' ? [] : parseInline(body));
+                i++;
+            }
+            blocks.push({ type: 'quote', lines: quoted });
+            continue;
+        }
+        // 列表项（每项一块——滚动帽子行单位）
+        const list = LIST_RE.exec(line);
+        if (list !== null) {
+            flushParagraph();
+            blocks.push({
+                type: 'list-item',
+                ordered: /\d/.test(list[2]),
+                marker: /\d/.test(list[2]) ? list[2] : '•',
+                indent: Math.floor(list[1].length / 2),
+                spans: parseInline(list[3]),
+            });
+            i++;
+            continue;
+        }
+        // 其余 → 段落累积（相邻块型出现时由各自 flush 断段）
+        paragraph.push(line.trim());
+        i++;
+    }
+    flushParagraph();
+    return blocks;
+}