@jun133/kitty 0.0.10 → 0.0.12

package/dist/chunk-4HIVDFN5.mjs

@@ -0,0 +1,823 @@
+// src/shell/tui/theme.ts
+var TUI_COLORS = {
+  background: "#080808",
+  panel: "#191919",
+  panelStrong: "#222222",
+  border: "#303030",
+  muted: "#8d8d8d",
+  text: "#e5e7eb",
+  user: "#d6a84f",
+  assistant: "#e5e7eb",
+  reasoning: "#a8a8a8",
+  thought: "#c99a3f",
+  system: "#cbd5e1",
+  success: "#34d399",
+  warning: "#d6a84f",
+  error: "#f87171"
+};
+
+// src/shell/tui/transcriptLayout.ts
+import stringWidth2 from "string-width";
+
+// src/shell/tui/markdown.ts
+import { marked } from "marked";
+
+// src/shell/tui/markdownInline.ts
+import { Lexer } from "marked";
+var MARKED_OPTIONS = { gfm: true };
+function renderInlineSpans(source) {
+  const tokens = typeof source === "string" ? Lexer.lexInline(source, MARKED_OPTIONS) : source;
+  return compactSpans(tokens.flatMap((token) => renderInlineToken(token, {})));
+}
+function renderInlineText(source) {
+  return renderInlineSpans(source).map((span) => span.text).join("");
+}
+function textSpan(text, marks = {}) {
+  return text ? [{ text, ...marks }] : [];
+}
+function renderInlineToken(token, marks) {
+  switch (token.type) {
+    case "text":
+    case "escape":
+      return textSpan(token.text, marks);
+    case "codespan":
+      return textSpan(token.text, { ...marks, code: true });
+    case "strong":
+      return renderInlineSpansWithMarks(token.tokens, { ...marks, bold: true });
+    case "em":
+      return renderInlineSpansWithMarks(token.tokens, { ...marks, italic: true });
+    case "del":
+      return renderInlineSpansWithMarks(token.tokens, { ...marks, strike: true });
+    case "link":
+      return renderLinkToken(token, marks);
+    case "image":
+      return textSpan(token.text, marks);
+    case "br":
+      return textSpan("\n", marks);
+    case "html":
+      return renderHtmlInline(token.text, marks);
+    default:
+      return renderGenericToken(token, marks);
+  }
+}
+function renderInlineSpansWithMarks(tokens, marks) {
+  return compactSpans(tokens.flatMap((token) => renderInlineToken(token, marks)));
+}
+function renderLinkToken(token, marks) {
+  const linked = renderInlineSpansWithMarks(token.tokens, { ...marks, href: token.href });
+  const visible = linked.map((span) => span.text).join("");
+  if (!token.href || token.href === visible) {
+    return linked;
+  }
+  return compactSpans([
+    ...linked,
+    ...textSpan(` (${token.href})`, { ...marks, href: token.href })
+  ]);
+}
+function renderHtmlInline(text, marks) {
+  if (/^<br\s*\/?>$/i.test(text.trim())) {
+    return textSpan("\n", marks);
+  }
+  return textSpan(decodeHtmlEntities(text), marks);
+}
+function renderGenericToken(token, marks) {
+  if ("tokens" in token && Array.isArray(token.tokens)) {
+    return renderInlineSpansWithMarks(token.tokens, marks);
+  }
+  if ("text" in token && typeof token.text === "string") {
+    return textSpan(token.text, marks);
+  }
+  if ("raw" in token && typeof token.raw === "string") {
+    return textSpan(token.raw, marks);
+  }
+  return [];
+}
+function compactSpans(spans) {
+  const compacted = [];
+  for (const span of spans) {
+    if (!span.text) {
+      continue;
+    }
+    const last = compacted[compacted.length - 1];
+    if (last && sameMarks(last, span)) {
+      compacted[compacted.length - 1] = { ...last, text: `${last.text}${span.text}` };
+      continue;
+    }
+    compacted.push(span);
+  }
+  return compacted;
+}
+function sameMarks(left, right) {
+  return left.bold === right.bold && left.italic === right.italic && left.code === right.code && left.strike === right.strike && left.href === right.href;
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+
+// src/shell/tui/markdownTable.ts
+import stringWidth from "string-width";
+function renderMarkdownTableLines(header, rows) {
+  const headerTexts = header.map(readCellText);
+  const rowTexts = rows.map((row) => row.map(readCellText));
+  const widths = headerTexts.map((cell, index) => Math.max(
+    stringWidth(cell),
+    ...rowTexts.map((row) => stringWidth(row[index] ?? ""))
+  ));
+  return [
+    tableLine(joinTableRow(headerTexts, widths)),
+    tableLine(widths.map((width) => "\u2500".repeat(Math.max(3, width))).join("\u2500\u253C\u2500")),
+    ...rowTexts.map((row) => tableLine(joinTableRow(row, widths)))
+  ];
+}
+function readCellText(cell) {
+  return cell.tokens ? renderInlineText(cell.tokens) : renderInlineText(cell.text);
+}
+function tableLine(text) {
+  return {
+    kind: "table",
+    text,
+    spans: [{ text }]
+  };
+}
+function joinTableRow(cells, widths) {
+  return cells.map((cell, index) => padDisplayEnd(cell, widths[index] ?? stringWidth(cell))).join(" \u2502 ");
+}
+function padDisplayEnd(text, width) {
+  return `${text}${" ".repeat(Math.max(0, width - stringWidth(text)))}`;
+}
+
+// src/shell/tui/markdown.ts
+var MARKED_OPTIONS2 = { gfm: true };
+function renderMarkdownLines(markdown) {
+  try {
+    const tokens = marked.lexer(markdown, MARKED_OPTIONS2);
+    const lines = [];
+    for (const token of tokens) {
+      appendToken(lines, token);
+    }
+    return trimOuterBlankLines(lines);
+  } catch {
+    return markdown.split(/\r?\n/).map((text) => line("text", text, textSpan(text)));
+  }
+}
+function appendToken(lines, token) {
+  switch (token.type) {
+    case "heading":
+      appendInlineLine(lines, "heading", token.tokens);
+      pushBlank(lines);
+      return;
+    case "paragraph":
+      appendInlineLine(lines, "text", token.tokens);
+      pushBlank(lines);
+      return;
+    case "list":
+      appendList(lines, token);
+      pushBlank(lines);
+      return;
+    case "code":
+      appendCode(lines, token);
+      pushBlank(lines);
+      return;
+    case "blockquote":
+      appendBlockquote(lines, token);
+      pushBlank(lines);
+      return;
+    case "hr":
+      push(lines, line("rule", "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500", textSpan("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")));
+      pushBlank(lines);
+      return;
+    case "space":
+      pushBlank(lines);
+      return;
+    case "table":
+      lines.push(...renderMarkdownTableLines(
+        token.header,
+        token.rows
+      ));
+      pushBlank(lines);
+      return;
+    default:
+      appendUnknownToken(lines, token);
+  }
+}
+function appendInlineLine(lines, kind, tokens) {
+  const spans = renderInlineSpans(tokens);
+  const text = spans.map((span) => span.text).join("").trimEnd();
+  push(lines, line(kind, text, trimEndSpans(spans)));
+}
+function appendList(lines, token) {
+  const start = typeof token.start === "number" ? token.start : Number.parseInt(String(token.start || 1), 10);
+  const orderedStart = Number.isFinite(start) ? start : 1;
+  token.items.forEach((item, index) => {
+    const marker = token.ordered ? `${orderedStart + index}.` : "\u2022";
+    const markerSpans = textSpan(`${marker} `, { bold: true });
+    const bodySpans = readListItemSpans(item);
+    const rows = splitSpansOnNewline([...markerSpans, ...bodySpans]);
+    rows.forEach((spans, rowIndex) => {
+      const prefix = rowIndex === 0 ? "" : "  ";
+      const lineSpans = prefix ? [...textSpan(prefix), ...spans] : spans;
+      push(lines, line("list", spansText(lineSpans), lineSpans));
+    });
+  });
+}
+function readListItemSpans(item) {
+  const paragraph = item.tokens.find((token) => token.type === "paragraph");
+  if (paragraph) {
+    return renderInlineSpans(paragraph.tokens);
+  }
+  return renderInlineSpans(item.text);
+}
+function appendCode(lines, token) {
+  const language = normalizeLanguage(token.lang);
+  if (language) {
+    const text = ` ${language} `;
+    push(lines, line("code", text, textSpan(text, { code: true }), language));
+  }
+  for (const codeLine of token.text.split(/\r?\n/)) {
+    push(lines, line("code", codeLine, textSpan(codeLine, { code: true }), language));
+  }
+}
+function appendBlockquote(lines, token) {
+  const nested = token.tokens.length > 0 ? renderNestedLines(token.tokens) : renderMarkdownLines(token.text);
+  for (const nestedLine of nested) {
+    const prefix = nestedLine.text ? "\u2502 " : "\u2502";
+    const spans = nestedLine.text ? [...textSpan("\u2502 ", { italic: true }), ...nestedLine.spans] : textSpan("\u2502", { italic: true });
+    push(lines, line("quote", `${prefix}${nestedLine.text}`, spans));
+  }
+}
+function renderNestedLines(tokens) {
+  const lines = [];
+  for (const token of tokens) {
+    appendToken(lines, token);
+  }
+  return trimOuterBlankLines(lines);
+}
+function appendUnknownToken(lines, token) {
+  if ("tokens" in token && Array.isArray(token.tokens)) {
+    appendInlineLine(lines, "text", token.tokens);
+    pushBlank(lines);
+    return;
+  }
+  const text = "text" in token && typeof token.text === "string" ? renderInlineText(token.text) : "raw" in token && typeof token.raw === "string" ? token.raw : "";
+  if (text.trim()) {
+    push(lines, line("text", text, textSpan(text)));
+    pushBlank(lines);
+  }
+}
+function splitSpansOnNewline(spans) {
+  const rows = [[]];
+  for (const span of spans) {
+    const parts = span.text.split("\n");
+    parts.forEach((part, index) => {
+      if (index > 0) {
+        rows.push([]);
+      }
+      if (part) {
+        rows[rows.length - 1].push({ ...span, text: part });
+      }
+    });
+  }
+  return rows.length > 0 ? rows : [[]];
+}
+function trimEndSpans(spans) {
+  const next = spans.slice();
+  while (next.length > 0) {
+    const last = next[next.length - 1];
+    const trimmed = last.text.trimEnd();
+    if (trimmed.length === last.text.length) {
+      break;
+    }
+    if (trimmed) {
+      next[next.length - 1] = { ...last, text: trimmed };
+      break;
+    }
+    next.pop();
+  }
+  return next;
+}
+function normalizeLanguage(language) {
+  const [name] = (language ?? "").trim().split(/\s+/);
+  return name || void 0;
+}
+function line(kind, text, spans, language) {
+  return {
+    kind,
+    text,
+    spans,
+    language
+  };
+}
+function push(lines, next) {
+  lines.push(next);
+}
+function pushBlank(lines) {
+  push(lines, line("text", "", []));
+}
+function trimOuterBlankLines(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start]?.text === "") {
+    start += 1;
+  }
+  while (end > start && lines[end - 1]?.text === "") {
+    end -= 1;
+  }
+  return lines.slice(start, end);
+}
+function spansText(spans) {
+  return spans.map((span) => span.text).join("");
+}
+
+// src/shell/tui/transcriptLayout.ts
+var TRANSCRIPT_OUTER_PADDING_X = 3;
+var MIN_BODY_WIDTH = 8;
+var REASONING_PREFIX = "Thinking: ";
+function renderTranscriptLineViews(entries, viewportWidth, theme) {
+  return entries.flatMap((entry) => renderTranscriptEntryLineViews(entry, viewportWidth, theme));
+}
+function measureTranscriptRows(entries, viewportWidth, theme) {
+  return renderTranscriptLineViews(entries, viewportWidth, theme).length;
+}
+function renderTranscriptEntryLineViews(entry, viewportWidth, theme) {
+  const frame = readRoleFrame(entry.role, viewportWidth);
+  const style = readRoleStyle(entry.role, theme);
+  const sourceRows = readEntryDisplayRows(entry);
+  const contentRows = wrapEntryRows(entry, sourceRows, frame.bodyWidth);
+  const rows = contentRows.length > 0 ? contentRows : [{ markdownKind: void 0, language: void 0, prefix: "", text: "", spans: [] }];
+  const entryId = entry.id;
+  return [
+    {
+      id: `${entryId}-spacer`,
+      entryId,
+      role: entry.role,
+      kind: "spacer",
+      text: "",
+      spans: [],
+      prefix: "",
+      markdownKind: void 0,
+      language: void 0,
+      isFirstContentLine: false,
+      frame,
+      style
+    },
+    ...rows.map((row, index) => ({
+      id: `${entryId}-line-${index + 1}`,
+      entryId,
+      role: entry.role,
+      kind: "content",
+      text: row.text,
+      spans: row.spans,
+      prefix: row.prefix,
+      markdownKind: row.markdownKind,
+      language: row.language,
+      isFirstContentLine: index === 0,
+      frame,
+      style: applyMarkdownStyle(style, row.markdownKind, theme)
+    }))
+  ];
+}
+function readRoleFrame(role, viewportWidth) {
+  const frameWidth = Math.max(1, viewportWidth - TRANSCRIPT_OUTER_PADDING_X * 2);
+  const base = readRoleFrameBase(role);
+  const bodyWidth = Math.max(
+    MIN_BODY_WIDTH,
+    frameWidth - base.marginLeft - base.paddingLeft - base.paddingRight - stringWidth2(base.gutter) - base.gap
+  );
+  return {
+    ...base,
+    bodyWidth
+  };
+}
+function readRoleFrameBase(role) {
+  switch (role) {
+    case "user":
+      return {
+        gap: 2,
+        gutter: "\u2503",
+        marginLeft: 1,
+        paddingLeft: 1,
+        paddingRight: 1
+      };
+    case "reasoning":
+      return {
+        gap: 2,
+        gutter: "\u2503",
+        marginLeft: 1,
+        paddingLeft: 1,
+        paddingRight: 1
+      };
+    case "system":
+      return {
+        gap: 2,
+        gutter: "\u2502",
+        marginLeft: 2,
+        paddingLeft: 1,
+        paddingRight: 1
+      };
+    case "assistant":
+      return {
+        gap: 2,
+        gutter: " ",
+        marginLeft: 2,
+        paddingLeft: 1,
+        paddingRight: 1
+      };
+  }
+}
+function readRoleStyle(role, theme) {
+  switch (role) {
+    case "user":
+      return {
+        accent: theme.user,
+        background: theme.panelStrong,
+        text: theme.text,
+        bold: true,
+        dim: false,
+        italicPrefix: false
+      };
+    case "reasoning":
+      return {
+        accent: theme.border,
+        background: void 0,
+        text: theme.reasoning,
+        bold: false,
+        dim: true,
+        italicPrefix: true
+      };
+    case "system":
+      return {
+        accent: theme.border,
+        background: theme.panel,
+        text: theme.system,
+        bold: false,
+        dim: false,
+        italicPrefix: false
+      };
+    case "assistant":
+      return {
+        accent: theme.background,
+        background: void 0,
+        text: theme.assistant,
+        bold: false,
+        dim: false,
+        italicPrefix: false
+      };
+  }
+}
+function readEntryDisplayRows(entry) {
+  if (entry.role === "assistant" || entry.role === "reasoning") {
+    const markdownRows = renderMarkdownLines(entry.text);
+    return markdownRows.length > 0 ? markdownRows.map((row) => ({
+      markdownKind: row.kind,
+      text: row.text,
+      spans: row.spans,
+      language: row.language
+    })) : [{ markdownKind: void 0, text: "", spans: [], language: void 0 }];
+  }
+  return entry.text.split(/\r?\n/).map((text) => ({
+    markdownKind: void 0,
+    text,
+    spans: [{ text }],
+    language: void 0
+  }));
+}
+function wrapEntryRows(entry, sourceRows, bodyWidth) {
+  if (entry.role !== "reasoning") {
+    return sourceRows.flatMap((line2) => wrapSourceRow(line2, bodyWidth, ""));
+  }
+  const rows = [];
+  const firstBodyWidth = Math.max(1, bodyWidth - stringWidth2(REASONING_PREFIX));
+  sourceRows.forEach((line2, sourceIndex) => {
+    const width = sourceIndex === 0 ? firstBodyWidth : bodyWidth;
+    const prefix = sourceIndex === 0 ? REASONING_PREFIX : "";
+    rows.push(...wrapSourceRow(line2, width, prefix));
+  });
+  return rows;
+}
+function wrapSourceRow(source, width, firstPrefix) {
+  const spanRows = wrapMarkdownSpans(source.spans.length > 0 ? source.spans : [{ text: source.text }], width);
+  return spanRows.map((spans, index) => ({
+    markdownKind: source.markdownKind,
+    language: source.language,
+    prefix: index === 0 ? firstPrefix : "",
+    text: transcriptSpansText(spans),
+    spans
+  }));
+}
+function wrapMarkdownSpans(spans, width) {
+  const rows = [[]];
+  let cursorWidth = 0;
+  for (const span of spans) {
+    const parts = span.text.split(/\r?\n/);
+    parts.forEach((part, partIndex) => {
+      if (partIndex > 0) {
+        rows.push([]);
+        cursorWidth = 0;
+      }
+      cursorWidth = appendWrappedSpan(rows, cursorWidth, span, part, width);
+    });
+  }
+  return rows.length > 0 ? rows : [[]];
+}
+function appendWrappedSpan(rows, cursorWidth, span, text, width) {
+  if (!text) {
+    return cursorWidth;
+  }
+  let nextCursor = cursorWidth;
+  for (const segment of splitWrapSegments(text)) {
+    const segmentWidth = stringWidth2(segment);
+    const isBlank = segment.trim() === "";
+    if (!isBlank && nextCursor > 0 && nextCursor + segmentWidth > width) {
+      rows.push([]);
+      nextCursor = 0;
+    }
+    const chunks = splitSegmentByWidth(segment, Math.max(1, width), nextCursor);
+    for (const chunk of chunks) {
+      if (chunk.newRow) {
+        rows.push([]);
+        nextCursor = 0;
+      }
+      pushTranscriptSpan(rows[rows.length - 1], toTranscriptSpan(span, chunk.text));
+      nextCursor += stringWidth2(chunk.text);
+    }
+  }
+  return nextCursor;
+}
+function splitWrapSegments(text) {
+  return text.match(/\s+|\S+/gu) ?? [];
+}
+function splitSegmentByWidth(segment, width, cursorWidth) {
+  const rows = [];
+  let current = "";
+  let currentWidth = cursorWidth;
+  for (const char of Array.from(segment)) {
+    const charWidth = stringWidth2(char);
+    if (current && currentWidth + charWidth > width) {
+      rows.push({ text: current, newRow: rows.length > 0 || cursorWidth > 0 });
+      current = "";
+      currentWidth = 0;
+    }
+    if (!current && currentWidth > 0 && currentWidth + charWidth > width) {
+      rows.push({ text: "", newRow: true });
+      currentWidth = 0;
+    }
+    current += char;
+    currentWidth += charWidth;
+  }
+  if (current) {
+    rows.push({ text: current, newRow: rows.length > 0 && rows[rows.length - 1]?.text !== "" });
+  }
+  return rows;
+}
+function toTranscriptSpan(span, text) {
+  return {
+    text,
+    bold: span.bold ?? false,
+    italic: span.italic ?? false,
+    code: span.code ?? false,
+    dim: false,
+    strike: span.strike ?? false,
+    href: span.href
+  };
+}
+function pushTranscriptSpan(row, span) {
+  if (!span.text) {
+    return;
+  }
+  const last = row[row.length - 1];
+  if (last && sameTranscriptSpanStyle(last, span)) {
+    row[row.length - 1] = { ...last, text: `${last.text}${span.text}` };
+    return;
+  }
+  row.push(span);
+}
+function sameTranscriptSpanStyle(left, right) {
+  return left.bold === right.bold && left.italic === right.italic && left.code === right.code && left.dim === right.dim && left.strike === right.strike && left.href === right.href;
+}
+function transcriptSpansText(spans) {
+  return spans.map((span) => span.text).join("");
+}
+function applyMarkdownStyle(base, kind, theme) {
+  switch (kind) {
+    case "heading":
+      return {
+        ...base,
+        text: theme.user,
+        bold: true
+      };
+    case "code":
+      return {
+        ...base,
+        background: theme.panel,
+        text: theme.system
+      };
+    case "quote":
+      return {
+        ...base,
+        text: theme.reasoning,
+        dim: true
+      };
+    case "rule":
+    case "table":
+      return {
+        ...base,
+        text: theme.muted
+      };
+    case "list":
+    case "text":
+    case void 0:
+      return base;
+  }
+}
+
+// src/shell/tui/store.ts
+var DEFAULT_DOCK = {
+  work: {
+    active: false,
+    label: "\u7A7A\u95F2",
+    detail: "\u6CA1\u6709\u540E\u53F0\u4EFB\u52A1\u6216\u5B50\u4EE3\u7406\u6B63\u5728\u6267\u884C"
+  },
+  background: "\u7A7A\u95F2",
+  subagent: "\u7A7A\u95F2",
+  context: "0 chars (0%)"
+};
+function createInitialTuiState(session) {
+  return {
+    transcript: session ? session.messages.flatMap(toTranscriptEntry) : [],
+    dock: {
+      ...DEFAULT_DOCK,
+      context: formatContextBudget(session)
+    },
+    scroll: {
+      offset: 0,
+      stickToBottom: true,
+      newContentPending: false
+    },
+    composer: {
+      promptLabel: "> ",
+      visibleRows: 1
+    }
+  };
+}
+function appendTranscriptEntry(state, entry, viewport, options = {}) {
+  const next = {
+    ...state,
+    transcript: [...state.transcript, { ...entry, id: createEntryId(state.transcript.length) }]
+  };
+  return applyContentChange(next, viewport, options);
+}
+function appendTranscriptText(state, role, text, viewport, options = {}) {
+  const last = state.transcript[state.transcript.length - 1];
+  if (last && last.role === role && (role === "assistant" || role === "reasoning")) {
+    const transcript = state.transcript.slice(0, -1);
+    const next = {
+      ...state,
+      transcript: [...transcript, { ...last, text: `${last.text}${text}` }]
+    };
+    return applyContentChange(next, viewport, options);
+  }
+  return appendTranscriptEntry(state, { role, text }, viewport, options);
+}
+function updateRuntimeDock(state, dock) {
+  return {
+    ...state,
+    dock: {
+      ...state.dock,
+      ...dock,
+      work: {
+        ...state.dock.work,
+        ...dock.work
+      }
+    }
+  };
+}
+function updateComposerState(state, composer) {
+  return {
+    ...state,
+    composer: {
+      ...state.composer,
+      ...composer
+    }
+  };
+}
+function scrollTuiTranscript(state, viewport, delta, options = {}) {
+  const maxOffset = getMaxScrollOffset(state, viewport, options);
+  const offset = clamp(state.scroll.offset + delta, 0, maxOffset);
+  return {
+    ...state,
+    scroll: {
+      offset,
+      stickToBottom: offset >= maxOffset,
+      newContentPending: offset >= maxOffset ? false : state.scroll.newContentPending
+    }
+  };
+}
+function scrollTuiTranscriptToTop(state) {
+  return {
+    ...state,
+    scroll: {
+      offset: 0,
+      stickToBottom: false,
+      newContentPending: state.scroll.newContentPending
+    }
+  };
+}
+function scrollTuiTranscriptToBottom(state, viewport, options = {}) {
+  return {
+    ...state,
+    scroll: {
+      offset: getMaxScrollOffset(state, viewport, options),
+      stickToBottom: true,
+      newContentPending: false
+    }
+  };
+}
+function applyViewportResize(state, viewport, options = {}) {
+  if (state.scroll.stickToBottom) {
+    return scrollTuiTranscriptToBottom(state, viewport, options);
+  }
+  return {
+    ...state,
+    scroll: {
+      ...state.scroll,
+      offset: clamp(state.scroll.offset, 0, getMaxScrollOffset(state, viewport, options))
+    }
+  };
+}
+function getMaxScrollOffset(state, viewport, options = {}) {
+  const rows = options.projection ? options.projection.measureRows(state.transcript, viewport.width) : measureTranscriptRows2(state.transcript, viewport.width);
+  return Math.max(0, rows - viewport.height);
+}
+function measureTranscriptRows2(entries, width) {
+  return measureTranscriptRows(entries, width, TUI_COLORS);
+}
+function renderTranscriptLineViews2(entries, width) {
+  return renderTranscriptLineViews(entries, width, TUI_COLORS);
+}
+function formatContextBudget(session) {
+  const budget = session?.contextBudget;
+  if (!budget) {
+    return "0 chars (0%)";
+  }
+  const percent = Math.round(budget.usageRatio * 100);
+  return `${budget.estimatedChars}/${budget.limitChars} chars (${percent}%)`;
+}
+function applyContentChange(state, viewport, options) {
+  if (state.scroll.stickToBottom) {
+    return scrollTuiTranscriptToBottom(state, viewport, options);
+  }
+  return {
+    ...state,
+    scroll: {
+      ...state.scroll,
+      newContentPending: true
+    }
+  };
+}
+function toTranscriptEntry(message, index) {
+  if (message.source === "internal" || !message.content?.trim()) {
+    return [];
+  }
+  if (message.role === "user") {
+    return [{ id: createEntryId(index), role: "user", text: message.content }];
+  }
+  if (message.role === "assistant") {
+    return [{ id: createEntryId(index), role: "assistant", text: message.content }];
+  }
+  return [];
+}
+function parseSubmittedInputEcho(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length === 0 || !lines[0]?.startsWith("> ")) {
+    return void 0;
+  }
+  const parsed = lines.map((line2, index) => {
+    const prefix = index === 0 ? "> " : "\u2026 ";
+    return line2.startsWith(prefix) ? line2.slice(prefix.length) : line2;
+  }).join("\n");
+  return parsed.trim() ? parsed : void 0;
+}
+function createEntryId(index) {
+  return `entry-${index + 1}`;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+export {
+  TUI_COLORS,
+  TRANSCRIPT_OUTER_PADDING_X,
+  renderTranscriptEntryLineViews,
+  createInitialTuiState,
+  appendTranscriptEntry,
+  appendTranscriptText,
+  updateRuntimeDock,
+  updateComposerState,
+  scrollTuiTranscript,
+  scrollTuiTranscriptToTop,
+  scrollTuiTranscriptToBottom,
+  applyViewportResize,
+  renderTranscriptLineViews2 as renderTranscriptLineViews,
+  formatContextBudget,
+  parseSubmittedInputEcho
+};