@kud/ink-markdown 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erwann Mest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+<div align="center">
+
+![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?style=flat-square&logo=typescript&logoColor=white)
+![Node.js](https://img.shields.io/badge/Node.js-339933?style=flat-square&logo=node.js&logoColor=white)
+![Status](https://img.shields.io/badge/status-alpha-yellow?style=flat-square)
+![MIT](https://img.shields.io/badge/licence-MIT-22C55E?style=flat-square)
+
+**A high-performance Markdown / code / diff rendering engine for Ink 7.**
+
+<a href="https://kud.io/projects/ink-markdown">Website</a> · <a href="https://kud.io/projects/ink-markdown/docs">Documentation</a>
+
+</div>
+
+> **Alpha.** The rendering path works today: parse a document, lay it out for a width, and scroll a virtualised viewport over it. `MarkdownViewport`, `useMarkdownScroll` and the whole `core` surface are real and covered by tests. Still ahead: syntax highlighting for fenced code (M4), the `useMarkdownStream` hook, overridable per-block renderers, and performance instrumentation — each is called out where it appears below. The API may still move before 1.0.
+
+## Features
+
+Ink apps that display large, code-heavy, streaming documents (AI responses, code review, diffs, source files) hit a wall with naïve Markdown renderers: parse the whole document into a React tree, run Yoga layout over all of it, re-diff the entire output every frame. `ink-markdown` is designed to keep that cost bounded to the viewport instead:
+
+- **Viewport virtualisation** ✅ — only the visible slice is ever composed, so React/Yoga work scales with viewport size, not document size. `MarkdownViewport` mounts exactly one `<Text>` whatever the document length.
+- **Block-based incremental parsing** ✅ — Markdown is segmented into top-level blocks with stable IDs and source hashes, so an edit in one block leaves the others untouched (`updateMarkdownDocument`).
+- **Cached, width-aware layout** ✅ — wrapping, Unicode width and styling are computed once per `(block, width, theme)` and reused until one of those changes, so a terminal resize doesn't force a full relayout.
+- **Unified-diff rendering** ✅ — hunk headers, additions and deletions are styled from the theme rather than treated as flat text.
+- **Syntax highlighting for fenced code** ⏳ — planned for M4; code blocks currently render unhighlighted, clipped rather than wrapped.
+- **Streaming with a mutable tail** ⏳ — the immutable-completed-blocks design is in place, but the `useMarkdownStream` hook that drives it is not written yet.
+- **Overridable block renderers and perf instrumentation** ⏳ — designed in [`prd.md`](./prd.md), not yet built.
+
+★ **Where the performance claims come from** — a benchmark spike proved the bet before the package was built: parsing a 10,000-line document took ~6.9ms (against a 100ms target), the pre-composed-string render path stayed at a constant ~1.6µs per frame regardless of document size, virtualisation mounted 1 Ink node against 9,167 for a naïve full-tree baseline, and CPU per scroll frame measured ~7.7ms — under Ink's ~26ms repaint throttle, so scroll latency is throttle-bound rather than compute-bound. The shipped engine implements that architecture; the numbers above are the spike's, not a benchmark of the current code.
+
+## Install
+
+```sh
+npm install @kud/ink-markdown
+```
+
+`ink-markdown` targets **Ink 7.x** and **React 19.x** as peer dependencies, and requires **Node.js 20+**.
+
+## Usage
+
+`height` is a prop, not something the component measures for itself — the caller owns the viewport, so there is no measurement round-trip to get wrong.
+
+```tsx
+import {
+  createMarkdownDocument,
+  createMarkdownLayout,
+  MarkdownViewport,
+  useMarkdownScroll,
+} from "@kud/ink-markdown"
+
+const Reader = ({ source, width, height }) => {
+  const [offset, setOffset] = useState(0)
+
+  // Laying out once and passing `layout` skips the parse on every scroll frame.
+  const layout = useMemo(
+    () =>
+      createMarkdownLayout(createMarkdownDocument(source), source, { width }),
+    [source, width],
+  )
+
+  useMarkdownScroll({
+    totalLines: layout.totalLines,
+    height,
+    offset,
+    onChange: setOffset,
+  })
+
+  return (
+    <MarkdownViewport
+      layout={layout}
+      width={width}
+      height={height}
+      scrollOffset={offset}
+    />
+  )
+}
+```
+
+Pass `source` instead of `layout` and the viewport parses and lays out for you — fine for short, static documents, and one prop less to thread.
+
+`useMarkdownScroll` is optional — it binds `j`/`k`, arrows, space, `b`, `g` and `G`. The core owns scrolling _primitives_ (an offset in, lines out), not keybindings, so an app with its own bindings drives `scrollOffset` directly and ignores the hook.
+
+`createMarkdownLayout` also takes a `theme` and a `cache` — a `Map` you own and reuse across renders, so a resize re-lays out only the blocks whose width actually changed. `layout.reused` and `layout.computed` report how that went.
+
+Streaming (`useMarkdownStream`), overridable per-block renderers and performance instrumentation are designed but not yet built — see [`prd.md`](./prd.md) for the full specification and [`plan.md`](./plan.md) for the decisions and spike results behind it.
+
+## Development
+
+```sh
+git clone https://github.com/kud/ink-markdown.git
+cd ink-markdown
+npm install
+npm run build
+npm test
+```
+
+Other scripts: `npm run build:watch` (rebuild on change), `npm run typecheck`, `npm run test:watch`.
+
+📚 **Full documentation → [ink-markdown/docs](https://kud.io/projects/ink-markdown/docs)**

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+import * as react from 'react';
+
+type MarkdownBlockType = "paragraph" | "heading" | "code" | "diff" | "list" | "quote" | "thematic-break";
+type MarkdownBlock = {
+    id: string;
+    type: MarkdownBlockType;
+    sourceStart: number;
+    sourceEnd: number;
+    sourceHash: string;
+    /** Fence info string for `code` / `diff` blocks (e.g. "ts", "diff"). */
+    lang?: string;
+};
+type MarkdownDocument = {
+    version: number;
+    blocks: readonly MarkdownBlock[];
+    sourceLength: number;
+};
+declare const createMarkdownDocument: (source: string, version?: number) => MarkdownDocument;
+declare const updateMarkdownDocument: (previous: MarkdownDocument, source: string) => MarkdownDocument;
+
+declare const hash: (input: string) => string;
+
+declare const segment: (source: string) => MarkdownBlock[];
+
+type SpanStyle = {
+    color?: string;
+    backgroundColor?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    inverse?: boolean;
+};
+type TextSpan = {
+    text: string;
+    style?: SpanStyle;
+};
+type LayoutLine = {
+    id: string;
+    spans: readonly TextSpan[];
+    plainText: string;
+    displayWidth: number;
+};
+type BlockLayout = {
+    blockId: string;
+    width: number;
+    height: number;
+    lines: readonly LayoutLine[];
+};
+type MarkdownTheme = {
+    foreground?: string;
+    muted: string;
+    heading: string;
+    link: string;
+    inlineCode: string;
+    quote: string;
+    added: string;
+    removed: string;
+    context: string;
+};
+declare const defaultTheme: MarkdownTheme;
+/** Display width in terminal columns (Unicode-aware: wide chars count as 2). */
+declare const measureWidth: (text: string) => number;
+/** Slice a string to at most `max` display columns without splitting a code point. */
+declare const sliceByWidth: (text: string, max: number) => string;
+declare const parseInline: (text: string, theme: MarkdownTheme) => TextSpan[];
+declare const wrapSpans: (spans: readonly TextSpan[], max: number) => TextSpan[][];
+/** Truncate a run of spans to `max` display columns (for code / diff — clip, don't wrap). */
+declare const clipSpans: (spans: readonly TextSpan[], max: number) => TextSpan[];
+
+type LayoutOptions = {
+    width: number;
+    theme?: MarkdownTheme;
+    themeId?: string;
+    /** Optional cross-call cache (survives scroll/resize) keyed by block id + width + theme. */
+    cache?: Map<string, readonly LayoutLine[]>;
+};
+type MarkdownLayout = {
+    width: number;
+    themeId: string;
+    blocks: readonly BlockLayout[];
+    /** All lines in document order — O(1) viewport slicing. */
+    lines: readonly LayoutLine[];
+    /** Cumulative first-line index of each block (parallel to blocks). */
+    lineOffsets: readonly number[];
+    totalLines: number;
+    reused: number;
+    computed: number;
+};
+declare const createMarkdownLayout: (document: MarkdownDocument, source: string, options: LayoutOptions) => MarkdownLayout;
+/** Visible slice for a viewport — clamped so the last page never scrolls past the end. */
+declare const sliceLines: (layout: MarkdownLayout, offset: number, height: number) => readonly LayoutLine[];
+/** Index of the first block whose cumulative offset ≤ line — the log-n first-visible lookup. */
+declare const firstBlockAt: (layout: MarkdownLayout, line: number) => number;
+
+type MarkdownViewportProps = {
+    /** Raw Markdown source. Ignored when `layout` is provided. */
+    source?: string;
+    /** Pre-parsed document (reused with `source` to skip re-parsing). */
+    document?: MarkdownDocument;
+    /** Pre-computed layout — skips parse + layout entirely. */
+    layout?: MarkdownLayout;
+    width: number;
+    height: number;
+    /** First visible document line. Clamped so the last page never scrolls past the end. */
+    scrollOffset?: number;
+    theme?: MarkdownTheme;
+    /** Layout cache shared across renders (survives scroll/resize). */
+    cache?: Map<string, readonly LayoutLine[]>;
+};
+declare const MarkdownViewport: ({ source, document, layout: providedLayout, width, height, scrollOffset, theme, cache, }: MarkdownViewportProps) => react.JSX.Element;
+
+type MarkdownScrollOptions = {
+    totalLines: number;
+    height: number;
+    offset: number;
+    onChange: (offset: number) => void;
+    /** Disable the key handler (e.g. when another pane has focus). */
+    active?: boolean;
+};
+declare const useMarkdownScroll: ({ totalLines, height, offset, onChange, active, }: MarkdownScrollOptions) => void;
+
+/** Compose one layout line's styled spans into a single ANSI string. */
+declare const lineToAnsi: (line: LayoutLine) => string;
+/** Path-A composition: the visible span-lines → one ANSI string for a single <Text>. */
+declare const linesToAnsi: (lines: readonly LayoutLine[]) => string;
+
+export { type BlockLayout, type LayoutLine, type LayoutOptions, type MarkdownBlock, type MarkdownBlockType, type MarkdownDocument, type MarkdownLayout, type MarkdownScrollOptions, type MarkdownTheme, MarkdownViewport, type MarkdownViewportProps, type SpanStyle, type TextSpan, clipSpans, createMarkdownDocument, createMarkdownLayout, defaultTheme, firstBlockAt, hash, lineToAnsi, linesToAnsi, measureWidth, parseInline, segment, sliceByWidth, sliceLines, updateMarkdownDocument, useMarkdownScroll, wrapSpans };

package/dist/index.js

@@ -0,0 +1,467 @@
+// src/core/hash.ts
+var hash = (input) => {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+};
+
+// src/core/segment.ts
+var FENCE = /^```(\S*)\s*$/;
+var HEADING = /^#{1,6}\s+/;
+var THEMATIC_BREAK = /^(-{3,}|\*{3,}|_{3,})\s*$/;
+var QUOTE = /^>\s?/;
+var LIST = /^(\s*)([-*+]|\d+\.)\s+/;
+var segment = (source) => {
+  const lines = source.split("\n");
+  const lineStart = [];
+  let offset = 0;
+  for (const line of lines) {
+    lineStart.push(offset);
+    offset += line.length + 1;
+  }
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Map();
+  const push = (type, fromLine, toLine2, lang) => {
+    const lastLine = toLine2 - 1;
+    const sourceStart = lineStart[fromLine];
+    const sourceEnd = lineStart[lastLine] + lines[lastLine].length;
+    const text = lines.slice(fromLine, toLine2).join("\n");
+    const sourceHash = hash(text);
+    const count = seen.get(sourceHash) ?? 0;
+    seen.set(sourceHash, count + 1);
+    const id = count === 0 ? sourceHash : `${sourceHash}~${count}`;
+    blocks.push({
+      id,
+      type,
+      sourceStart,
+      sourceEnd,
+      sourceHash,
+      ...lang ? { lang } : {}
+    });
+  };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const fence = line.match(FENCE);
+    if (fence) {
+      let j2 = i + 1;
+      while (j2 < lines.length && !FENCE.test(lines[j2])) j2++;
+      const toLine2 = j2 < lines.length ? j2 + 1 : lines.length;
+      const lang = fence[1] || "";
+      push(lang === "diff" ? "diff" : "code", i, toLine2, lang || void 0);
+      i = toLine2;
+      continue;
+    }
+    if (HEADING.test(line)) {
+      push("heading", i, i + 1);
+      i++;
+      continue;
+    }
+    if (THEMATIC_BREAK.test(line)) {
+      push("thematic-break", i, i + 1);
+      i++;
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      let j2 = i;
+      while (j2 < lines.length && QUOTE.test(lines[j2])) j2++;
+      push("quote", i, j2);
+      i = j2;
+      continue;
+    }
+    if (LIST.test(line)) {
+      let j2 = i;
+      while (j2 < lines.length && lines[j2].trim() !== "" && !FENCE.test(lines[j2]))
+        j2++;
+      push("list", i, j2);
+      i = j2;
+      continue;
+    }
+    let j = i;
+    while (j < lines.length && lines[j].trim() !== "" && !FENCE.test(lines[j]) && !HEADING.test(lines[j]) && !THEMATIC_BREAK.test(lines[j]) && !QUOTE.test(lines[j]) && !LIST.test(lines[j]))
+      j++;
+    push("paragraph", i, j);
+    i = j;
+  }
+  return blocks;
+};
+
+// src/core/document.ts
+var createMarkdownDocument = (source, version = 1) => ({
+  version,
+  blocks: segment(source),
+  sourceLength: source.length
+});
+var updateMarkdownDocument = (previous, source) => createMarkdownDocument(source, previous.version + 1);
+
+// src/core/spans.ts
+import stringWidth from "string-width";
+var defaultTheme = {
+  muted: "gray",
+  heading: "cyan",
+  link: "blue",
+  inlineCode: "yellow",
+  quote: "gray",
+  added: "green",
+  removed: "red",
+  context: "gray"
+};
+var measureWidth = (text) => stringWidth(text);
+var sliceByWidth = (text, max) => {
+  let used = 0;
+  let out = "";
+  for (const ch of text) {
+    const cw = stringWidth(ch);
+    if (used + cw > max) break;
+    out += ch;
+    used += cw;
+  }
+  return out;
+};
+var sameStyle = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+var append = (line, text, style) => {
+  const last = line[line.length - 1];
+  if (last && sameStyle(last.style, style))
+    line[line.length - 1] = { text: last.text + text, style };
+  else line.push(style ? { text, style } : { text });
+};
+var INLINE = /(\*\*([^*]+)\*\*|`([^`]+)`|\*([^*]+)\*|_([^_]+)_|\[([^\]]+)\]\(([^)]+)\))/g;
+var parseInline = (text, theme) => {
+  const spans = [];
+  const re = new RegExp(INLINE);
+  let last = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    if (m.index > last) spans.push({ text: text.slice(last, m.index) });
+    if (m[2] !== void 0) spans.push({ text: m[2], style: { bold: true } });
+    else if (m[3] !== void 0)
+      spans.push({ text: m[3], style: { color: theme.inlineCode } });
+    else if (m[4] !== void 0)
+      spans.push({ text: m[4], style: { italic: true } });
+    else if (m[5] !== void 0)
+      spans.push({ text: m[5], style: { italic: true } });
+    else if (m[6] !== void 0)
+      spans.push({ text: m[6], style: { color: theme.link, underline: true } });
+    last = m.index + m[0].length;
+  }
+  if (last < text.length) spans.push({ text: text.slice(last) });
+  return spans.length > 0 ? spans : [{ text }];
+};
+var wrapSpans = (spans, max) => {
+  const width = Math.max(1, max);
+  const lines = [];
+  let line = [];
+  let used = 0;
+  const flush = () => {
+    lines.push(line);
+    line = [];
+    used = 0;
+  };
+  for (const span of spans) {
+    const tokens = span.text.match(/\s+|\S+/g) ?? [];
+    for (const token of tokens) {
+      const w = stringWidth(token);
+      if (/^\s+$/.test(token)) {
+        if (used > 0 && used + w <= width) {
+          append(line, token, span.style);
+          used += w;
+        }
+        continue;
+      }
+      if (used + w <= width) {
+        append(line, token, span.style);
+        used += w;
+        continue;
+      }
+      if (used > 0) flush();
+      if (w <= width) {
+        append(line, token, span.style);
+        used += w;
+      } else {
+        let rest = token;
+        while (stringWidth(rest) > width) {
+          const chunk = sliceByWidth(rest, width);
+          append(line, chunk, span.style);
+          flush();
+          rest = rest.slice(chunk.length);
+        }
+        if (rest) {
+          append(line, rest, span.style);
+          used = stringWidth(rest);
+        }
+      }
+    }
+  }
+  if (line.length > 0) lines.push(line);
+  return lines.length > 0 ? lines : [[]];
+};
+var clipSpans = (spans, max) => {
+  const out = [];
+  let used = 0;
+  for (const span of spans) {
+    if (used >= max) break;
+    const w = stringWidth(span.text);
+    if (used + w <= max) {
+      out.push(span);
+      used += w;
+    } else {
+      out.push({ text: sliceByWidth(span.text, max - used), style: span.style });
+      break;
+    }
+  }
+  return out;
+};
+
+// src/core/layout.ts
+var blockText = (block, source) => source.slice(block.sourceStart, block.sourceEnd);
+var toLine = (blockId, index, spans) => {
+  const plainText = spans.map((span) => span.text).join("");
+  return {
+    id: `${blockId}:${index}`,
+    spans,
+    plainText,
+    displayWidth: measureWidth(plainText)
+  };
+};
+var stripFences = (text) => {
+  const lines = text.split("\n");
+  if (lines[0]?.startsWith("```")) lines.shift();
+  if (lines.length > 0 && lines[lines.length - 1]?.startsWith("```"))
+    lines.pop();
+  return lines;
+};
+var diffStyle = (line, theme) => {
+  if (line.startsWith("@@")) return { color: theme.heading };
+  if (/^(\+\+\+|---|diff |index )/.test(line)) return { bold: true };
+  if (line.startsWith("+")) return { color: theme.added };
+  if (line.startsWith("-")) return { color: theme.removed };
+  return { color: theme.context };
+};
+var layoutBlock = (block, source, width, theme) => {
+  const text = blockText(block, source);
+  const rows = [];
+  switch (block.type) {
+    case "heading": {
+      const content = text.replace(/^#{1,6}\s+/, "");
+      rows.push(
+        ...wrapSpans(
+          [{ text: content, style: { color: theme.heading, bold: true } }],
+          width
+        )
+      );
+      break;
+    }
+    case "thematic-break": {
+      rows.push([
+        { text: "\u2500".repeat(Math.max(1, width)), style: { color: theme.muted } }
+      ]);
+      break;
+    }
+    case "quote": {
+      const content = text.replace(/^>\s?/gm, "").split("\n").join(" ");
+      const prefix = { text: "\u2502 ", style: { color: theme.quote } };
+      for (const wrapped of wrapSpans(parseInline(content, theme), width - 2))
+        rows.push([prefix, ...wrapped]);
+      break;
+    }
+    case "list": {
+      for (const raw of text.split("\n")) {
+        const item = raw.match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+        if (!item) continue;
+        wrapSpans(parseInline(item[3], theme), width - 2).forEach(
+          (wrapped, i) => {
+            const prefix = i === 0 ? { text: "\u2022 ", style: { color: theme.heading } } : { text: "  " };
+            rows.push([prefix, ...wrapped]);
+          }
+        );
+      }
+      break;
+    }
+    case "code": {
+      for (const codeLine of stripFences(text))
+        rows.push(clipSpans([{ text: codeLine }], width));
+      break;
+    }
+    case "diff": {
+      const body = block.lang === "diff" ? stripFences(text) : text.split("\n");
+      for (const diffLine of body)
+        rows.push(
+          clipSpans(
+            [{ text: diffLine, style: diffStyle(diffLine, theme) }],
+            width
+          )
+        );
+      break;
+    }
+    default: {
+      const content = text.split("\n").join(" ");
+      rows.push(...wrapSpans(parseInline(content, theme), width));
+    }
+  }
+  return rows.map((spans, index) => toLine(block.id, index, spans));
+};
+var createMarkdownLayout = (document, source, options) => {
+  const theme = options.theme ?? defaultTheme;
+  const themeId = options.themeId ?? (options.theme ? hash(JSON.stringify(theme)) : "default");
+  const width = options.width;
+  const cache = options.cache;
+  const blocks = [];
+  const lines = [];
+  const lineOffsets = [];
+  let reused = 0;
+  let computed = 0;
+  for (const block of document.blocks) {
+    const key = `${block.id}:${width}:${themeId}`;
+    let blockLines = cache?.get(key);
+    if (blockLines) {
+      reused++;
+    } else {
+      blockLines = layoutBlock(block, source, width, theme);
+      cache?.set(key, blockLines);
+      computed++;
+    }
+    lineOffsets.push(lines.length);
+    blocks.push({
+      blockId: block.id,
+      width,
+      height: blockLines.length,
+      lines: blockLines
+    });
+    for (const line of blockLines) lines.push(line);
+  }
+  return {
+    width,
+    themeId,
+    blocks,
+    lines,
+    lineOffsets,
+    totalLines: lines.length,
+    reused,
+    computed
+  };
+};
+var sliceLines = (layout, offset, height) => {
+  const start = Math.max(
+    0,
+    Math.min(offset, Math.max(0, layout.totalLines - height))
+  );
+  return layout.lines.slice(start, start + height);
+};
+var firstBlockAt = (layout, line) => {
+  const offsets = layout.lineOffsets;
+  let lo = 0;
+  let hi = offsets.length - 1;
+  let answer = 0;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (offsets[mid] <= line) {
+      answer = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return answer;
+};
+
+// src/ink/markdown-viewport.tsx
+import { useMemo } from "react";
+import { Box, Text } from "ink";
+
+// src/ink/ansi.ts
+import chalk from "chalk";
+var chain = (fn, key) => {
+  const next = fn[key];
+  return typeof next === "function" ? next : fn;
+};
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+var applyStyle = (text, style) => {
+  if (!style) return text;
+  let fn = chalk;
+  if (style.color) fn = chain(fn, style.color);
+  if (style.backgroundColor)
+    fn = chain(fn, `bg${capitalize(style.backgroundColor)}`);
+  if (style.bold) fn = chain(fn, "bold");
+  if (style.italic) fn = chain(fn, "italic");
+  if (style.underline) fn = chain(fn, "underline");
+  if (style.dim) fn = chain(fn, "dim");
+  if (style.inverse) fn = chain(fn, "inverse");
+  return fn(text);
+};
+var lineToAnsi = (line) => line.spans.map((span) => applyStyle(span.text, span.style)).join("");
+var linesToAnsi = (lines) => lines.map(lineToAnsi).join("\n");
+
+// src/ink/markdown-viewport.tsx
+import { jsx } from "react/jsx-runtime";
+var MarkdownViewport = ({
+  source,
+  document,
+  layout: providedLayout,
+  width,
+  height,
+  scrollOffset = 0,
+  theme,
+  cache
+}) => {
+  const layout = useMemo(() => {
+    if (providedLayout) return providedLayout;
+    const text = source ?? "";
+    const doc = document ?? createMarkdownDocument(text);
+    return createMarkdownLayout(doc, text, { width, theme, cache });
+  }, [providedLayout, document, source, width, theme, cache]);
+  const composed = linesToAnsi(sliceLines(layout, scrollOffset, height));
+  return /* @__PURE__ */ jsx(Box, { width, height, flexDirection: "column", children: /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: composed }) });
+};
+
+// src/ink/use-markdown-scroll.ts
+import { useInput } from "ink";
+var clamp = (value, max) => Math.max(0, Math.min(value, max));
+var useMarkdownScroll = ({
+  totalLines,
+  height,
+  offset,
+  onChange,
+  active = true
+}) => {
+  const max = Math.max(0, totalLines - height);
+  useInput(
+    (input, key) => {
+      if (key.downArrow || input === "j") onChange(clamp(offset + 1, max));
+      else if (key.upArrow || input === "k") onChange(clamp(offset - 1, max));
+      else if (key.pageDown || input === " ")
+        onChange(clamp(offset + height, max));
+      else if (key.pageUp || input === "b")
+        onChange(clamp(offset - height, max));
+      else if (input === "g") onChange(0);
+      else if (input === "G") onChange(max);
+    },
+    { isActive: active }
+  );
+};
+export {
+  MarkdownViewport,
+  clipSpans,
+  createMarkdownDocument,
+  createMarkdownLayout,
+  defaultTheme,
+  firstBlockAt,
+  hash,
+  lineToAnsi,
+  linesToAnsi,
+  measureWidth,
+  parseInline,
+  segment,
+  sliceByWidth,
+  sliceLines,
+  updateMarkdownDocument,
+  useMarkdownScroll,
+  wrapSpans
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/hash.ts","../src/core/segment.ts","../src/core/document.ts","../src/core/spans.ts","../src/core/layout.ts","../src/ink/markdown-viewport.tsx","../src/ink/ansi.ts","../src/ink/use-markdown-scroll.ts"],"sourcesContent":["// FNV-1a — cheap, stable content hash used for block identity and layout-cache keys.\nexport const hash = (input: string): string => {\n  let h = 0x811c9dc5\n  for (let i = 0; i < input.length; i++) {\n    h ^= input.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return (h >>> 0).toString(36)\n}\n","import { hash } from \"./hash.js\"\nimport type { MarkdownBlock, MarkdownBlockType } from \"./document.js\"\n\nconst FENCE = /^```(\\S*)\\s*$/\nconst HEADING = /^#{1,6}\\s+/\nconst THEMATIC_BREAK = /^(-{3,}|\\*{3,}|_{3,})\\s*$/\nconst QUOTE = /^>\\s?/\nconst LIST = /^(\\s*)([-*+]|\\d+\\.)\\s+/\n\n// Line-scan segmenter → renderer-independent top-level blocks with stable, content-based\n// identity. Minimal GFM-ish block set; inline parsing happens later in the layout stage.\n// An unterminated fence stays a single open block, which is what the streaming tail needs.\nexport const segment = (source: string): MarkdownBlock[] => {\n  const lines = source.split(\"\\n\")\n  const lineStart: number[] = []\n  let offset = 0\n  for (const line of lines) {\n    lineStart.push(offset)\n    offset += line.length + 1 // + newline\n  }\n\n  const blocks: MarkdownBlock[] = []\n  const seen = new Map<string, number>()\n\n  const push = (\n    type: MarkdownBlockType,\n    fromLine: number,\n    toLine: number,\n    lang?: string,\n  ) => {\n    const lastLine = toLine - 1\n    const sourceStart = lineStart[fromLine]\n    const sourceEnd = lineStart[lastLine] + lines[lastLine].length\n    const text = lines.slice(fromLine, toLine).join(\"\\n\")\n    const sourceHash = hash(text)\n    // Content hash is the identity; disambiguate genuinely-identical blocks by occurrence so\n    // React keys stay unique without reintroducing position sensitivity for unique content.\n    const count = seen.get(sourceHash) ?? 0\n    seen.set(sourceHash, count + 1)\n    const id = count === 0 ? sourceHash : `${sourceHash}~${count}`\n    blocks.push({\n      id,\n      type,\n      sourceStart,\n      sourceEnd,\n      sourceHash,\n      ...(lang ? { lang } : {}),\n    })\n  }\n\n  let i = 0\n  while (i < lines.length) {\n    const line = lines[i]\n\n    if (line.trim() === \"\") {\n      i++\n      continue\n    }\n\n    const fence = line.match(FENCE)\n    if (fence) {\n      let j = i + 1\n      while (j < lines.length && !FENCE.test(lines[j])) j++\n      const toLine = j < lines.length ? j + 1 : lines.length // include closing fence, or EOF\n      const lang = fence[1] || \"\"\n      push(lang === \"diff\" ? \"diff\" : \"code\", i, toLine, lang || undefined)\n      i = toLine\n      continue\n    }\n\n    if (HEADING.test(line)) {\n      push(\"heading\", i, i + 1)\n      i++\n      continue\n    }\n\n    if (THEMATIC_BREAK.test(line)) {\n      push(\"thematic-break\", i, i + 1)\n      i++\n      continue\n    }\n\n    if (QUOTE.test(line)) {\n      let j = i\n      while (j < lines.length && QUOTE.test(lines[j])) j++\n      push(\"quote\", i, j)\n      i = j\n      continue\n    }\n\n    if (LIST.test(line)) {\n      let j = i\n      while (\n        j < lines.length &&\n        lines[j].trim() !== \"\" &&\n        !FENCE.test(lines[j])\n      )\n        j++\n      push(\"list\", i, j)\n      i = j\n      continue\n    }\n\n    // Paragraph — consume consecutive non-blank, non-structural lines.\n    let j = i\n    while (\n      j < lines.length &&\n      lines[j].trim() !== \"\" &&\n      !FENCE.test(lines[j]) &&\n      !HEADING.test(lines[j]) &&\n      !THEMATIC_BREAK.test(lines[j]) &&\n      !QUOTE.test(lines[j]) &&\n      !LIST.test(lines[j])\n    )\n      j++\n    push(\"paragraph\", i, j)\n    i = j\n  }\n\n  return blocks\n}\n","import { segment } from \"./segment.js\"\n\nexport type MarkdownBlockType =\n  | \"paragraph\"\n  | \"heading\"\n  | \"code\"\n  | \"diff\"\n  | \"list\"\n  | \"quote\"\n  | \"thematic-break\"\n\nexport type MarkdownBlock = {\n  id: string\n  type: MarkdownBlockType\n  sourceStart: number\n  sourceEnd: number\n  sourceHash: string\n  /** Fence info string for `code` / `diff` blocks (e.g. \"ts\", \"diff\"). */\n  lang?: string\n}\n\nexport type MarkdownDocument = {\n  version: number\n  blocks: readonly MarkdownBlock[]\n  sourceLength: number\n}\n\nexport const createMarkdownDocument = (\n  source: string,\n  version = 1,\n): MarkdownDocument => ({\n  version,\n  blocks: segment(source),\n  sourceLength: source.length,\n})\n\n// Reparse after an edit. Block identity is content-based, so unchanged blocks keep their ids\n// automatically — cached layouts downstream stay valid — and this just restamps the version.\nexport const updateMarkdownDocument = (\n  previous: MarkdownDocument,\n  source: string,\n): MarkdownDocument => createMarkdownDocument(source, previous.version + 1)\n","import stringWidth from \"string-width\"\n\n// Semantic (renderer-independent) styling. No ANSI here — the Ink view maps these to\n// <Text> props, a future OpenTUI view maps them to its own styling, and a path-A composer\n// turns them into ANSI. Colours are resolved theme values (e.g. \"cyan\"), not tokens.\nexport type SpanStyle = {\n  color?: string\n  backgroundColor?: string\n  bold?: boolean\n  italic?: boolean\n  underline?: boolean\n  dim?: boolean\n  inverse?: boolean\n}\n\nexport type TextSpan = {\n  text: string\n  style?: SpanStyle\n}\n\nexport type LayoutLine = {\n  id: string\n  spans: readonly TextSpan[]\n  plainText: string\n  displayWidth: number\n}\n\nexport type BlockLayout = {\n  blockId: string\n  width: number\n  height: number\n  lines: readonly LayoutLine[]\n}\n\nexport type MarkdownTheme = {\n  foreground?: string\n  muted: string\n  heading: string\n  link: string\n  inlineCode: string\n  quote: string\n  added: string\n  removed: string\n  context: string\n}\n\nexport const defaultTheme: MarkdownTheme = {\n  muted: \"gray\",\n  heading: \"cyan\",\n  link: \"blue\",\n  inlineCode: \"yellow\",\n  quote: \"gray\",\n  added: \"green\",\n  removed: \"red\",\n  context: \"gray\",\n}\n\n/** Display width in terminal columns (Unicode-aware: wide chars count as 2). */\nexport const measureWidth = (text: string): number => stringWidth(text)\n\n/** Slice a string to at most `max` display columns without splitting a code point. */\nexport const sliceByWidth = (text: string, max: number): string => {\n  let used = 0\n  let out = \"\"\n  for (const ch of text) {\n    const cw = stringWidth(ch)\n    if (used + cw > max) break\n    out += ch\n    used += cw\n  }\n  return out\n}\n\nconst sameStyle = (a?: SpanStyle, b?: SpanStyle): boolean =>\n  JSON.stringify(a ?? null) === JSON.stringify(b ?? null)\n\n// Append text to a span list, merging into the previous span when the style matches so\n// runs of identical styling stay a single span (fewer nodes for the renderer).\nconst append = (line: TextSpan[], text: string, style?: SpanStyle): void => {\n  const last = line[line.length - 1]\n  if (last && sameStyle(last.style, style))\n    line[line.length - 1] = { text: last.text + text, style }\n  else line.push(style ? { text, style } : { text })\n}\n\nconst INLINE =\n  /(\\*\\*([^*]+)\\*\\*|`([^`]+)`|\\*([^*]+)\\*|_([^_]+)_|\\[([^\\]]+)\\]\\(([^)]+)\\))/g\n\n// Minimal inline parser → styled spans: bold, italic, inline code, links. Markdown-it can\n// replace this later for fuller GFM inline; this covers the common PR-comment cases.\nexport const parseInline = (text: string, theme: MarkdownTheme): TextSpan[] => {\n  const spans: TextSpan[] = []\n  const re = new RegExp(INLINE)\n  let last = 0\n  let m: RegExpExecArray | null\n  while ((m = re.exec(text)) !== null) {\n    if (m.index > last) spans.push({ text: text.slice(last, m.index) })\n    if (m[2] !== undefined) spans.push({ text: m[2], style: { bold: true } })\n    else if (m[3] !== undefined)\n      spans.push({ text: m[3], style: { color: theme.inlineCode } })\n    else if (m[4] !== undefined)\n      spans.push({ text: m[4], style: { italic: true } })\n    else if (m[5] !== undefined)\n      spans.push({ text: m[5], style: { italic: true } })\n    else if (m[6] !== undefined)\n      spans.push({ text: m[6], style: { color: theme.link, underline: true } })\n    last = m.index + m[0].length\n  }\n  if (last < text.length) spans.push({ text: text.slice(last) })\n  return spans.length > 0 ? spans : [{ text }]\n}\n\n// Word-wrap a run of styled spans to `max` display columns, splitting spans at column\n// boundaries and hard-breaking any single token longer than the line.\nexport const wrapSpans = (\n  spans: readonly TextSpan[],\n  max: number,\n): TextSpan[][] => {\n  const width = Math.max(1, max)\n  const lines: TextSpan[][] = []\n  let line: TextSpan[] = []\n  let used = 0\n  const flush = () => {\n    lines.push(line)\n    line = []\n    used = 0\n  }\n\n  for (const span of spans) {\n    const tokens = span.text.match(/\\s+|\\S+/g) ?? []\n    for (const token of tokens) {\n      const w = stringWidth(token)\n      if (/^\\s+$/.test(token)) {\n        // Keep inter-word whitespace, but drop it at a line start (no leading spaces on wraps).\n        if (used > 0 && used + w <= width) {\n          append(line, token, span.style)\n          used += w\n        }\n        continue\n      }\n      if (used + w <= width) {\n        append(line, token, span.style)\n        used += w\n        continue\n      }\n      if (used > 0) flush()\n      if (w <= width) {\n        append(line, token, span.style)\n        used += w\n      } else {\n        let rest = token\n        while (stringWidth(rest) > width) {\n          const chunk = sliceByWidth(rest, width)\n          append(line, chunk, span.style)\n          flush()\n          rest = rest.slice(chunk.length)\n        }\n        if (rest) {\n          append(line, rest, span.style)\n          used = stringWidth(rest)\n        }\n      }\n    }\n  }\n  if (line.length > 0) lines.push(line)\n  return lines.length > 0 ? lines : [[]]\n}\n\n/** Truncate a run of spans to `max` display columns (for code / diff — clip, don't wrap). */\nexport const clipSpans = (\n  spans: readonly TextSpan[],\n  max: number,\n): TextSpan[] => {\n  const out: TextSpan[] = []\n  let used = 0\n  for (const span of spans) {\n    if (used >= max) break\n    const w = stringWidth(span.text)\n    if (used + w <= max) {\n      out.push(span)\n      used += w\n    } else {\n      out.push({ text: sliceByWidth(span.text, max - used), style: span.style })\n      break\n    }\n  }\n  return out\n}\n","import { hash } from \"./hash.js\"\nimport type { MarkdownBlock, MarkdownDocument } from \"./document.js\"\nimport {\n  type BlockLayout,\n  type LayoutLine,\n  type MarkdownTheme,\n  type TextSpan,\n  clipSpans,\n  defaultTheme,\n  measureWidth,\n  parseInline,\n  wrapSpans,\n} from \"./spans.js\"\n\nconst blockText = (block: MarkdownBlock, source: string): string =>\n  source.slice(block.sourceStart, block.sourceEnd)\n\nconst toLine = (\n  blockId: string,\n  index: number,\n  spans: TextSpan[],\n): LayoutLine => {\n  const plainText = spans.map((span) => span.text).join(\"\")\n  return {\n    id: `${blockId}:${index}`,\n    spans,\n    plainText,\n    displayWidth: measureWidth(plainText),\n  }\n}\n\nconst stripFences = (text: string): string[] => {\n  const lines = text.split(\"\\n\")\n  if (lines[0]?.startsWith(\"```\")) lines.shift()\n  if (lines.length > 0 && lines[lines.length - 1]?.startsWith(\"```\"))\n    lines.pop()\n  return lines\n}\n\nconst diffStyle = (line: string, theme: MarkdownTheme) => {\n  if (line.startsWith(\"@@\")) return { color: theme.heading }\n  if (/^(\\+\\+\\+|---|diff |index )/.test(line)) return { bold: true }\n  if (line.startsWith(\"+\")) return { color: theme.added }\n  if (line.startsWith(\"-\")) return { color: theme.removed }\n  return { color: theme.context }\n}\n\n// One block → its visual terminal lines. Prose wraps; code/diff clip. Pure + deterministic\n// given (block text, width, theme) → safe to cache. Syntax highlighting arrives in M4;\n// code renders plain here.\nconst layoutBlock = (\n  block: MarkdownBlock,\n  source: string,\n  width: number,\n  theme: MarkdownTheme,\n): LayoutLine[] => {\n  const text = blockText(block, source)\n  const rows: TextSpan[][] = []\n\n  switch (block.type) {\n    case \"heading\": {\n      const content = text.replace(/^#{1,6}\\s+/, \"\")\n      rows.push(\n        ...wrapSpans(\n          [{ text: content, style: { color: theme.heading, bold: true } }],\n          width,\n        ),\n      )\n      break\n    }\n    case \"thematic-break\": {\n      rows.push([\n        { text: \"─\".repeat(Math.max(1, width)), style: { color: theme.muted } },\n      ])\n      break\n    }\n    case \"quote\": {\n      const content = text.replace(/^>\\s?/gm, \"\").split(\"\\n\").join(\" \")\n      const prefix: TextSpan = { text: \"│ \", style: { color: theme.quote } }\n      for (const wrapped of wrapSpans(parseInline(content, theme), width - 2))\n        rows.push([prefix, ...wrapped])\n      break\n    }\n    case \"list\": {\n      for (const raw of text.split(\"\\n\")) {\n        const item = raw.match(/^(\\s*)([-*+]|\\d+\\.)\\s+(.*)$/)\n        if (!item) continue\n        wrapSpans(parseInline(item[3], theme), width - 2).forEach(\n          (wrapped, i) => {\n            const prefix: TextSpan =\n              i === 0\n                ? { text: \"• \", style: { color: theme.heading } }\n                : { text: \"  \" }\n            rows.push([prefix, ...wrapped])\n          },\n        )\n      }\n      break\n    }\n    case \"code\": {\n      for (const codeLine of stripFences(text))\n        rows.push(clipSpans([{ text: codeLine }], width))\n      break\n    }\n    case \"diff\": {\n      const body = block.lang === \"diff\" ? stripFences(text) : text.split(\"\\n\")\n      for (const diffLine of body)\n        rows.push(\n          clipSpans(\n            [{ text: diffLine, style: diffStyle(diffLine, theme) }],\n            width,\n          ),\n        )\n      break\n    }\n    default: {\n      const content = text.split(\"\\n\").join(\" \")\n      rows.push(...wrapSpans(parseInline(content, theme), width))\n    }\n  }\n\n  return rows.map((spans, index) => toLine(block.id, index, spans))\n}\n\nexport type LayoutOptions = {\n  width: number\n  theme?: MarkdownTheme\n  themeId?: string\n  /** Optional cross-call cache (survives scroll/resize) keyed by block id + width + theme. */\n  cache?: Map<string, readonly LayoutLine[]>\n}\n\nexport type MarkdownLayout = {\n  width: number\n  themeId: string\n  blocks: readonly BlockLayout[]\n  /** All lines in document order — O(1) viewport slicing. */\n  lines: readonly LayoutLine[]\n  /** Cumulative first-line index of each block (parallel to blocks). */\n  lineOffsets: readonly number[]\n  totalLines: number\n  reused: number\n  computed: number\n}\n\n// Lay out every block for a given width, reusing cached block layouts where possible. Scroll\n// never recomputes; a width change invalidates only width-dependent entries via the key.\nexport const createMarkdownLayout = (\n  document: MarkdownDocument,\n  source: string,\n  options: LayoutOptions,\n): MarkdownLayout => {\n  const theme = options.theme ?? defaultTheme\n  const themeId =\n    options.themeId ?? (options.theme ? hash(JSON.stringify(theme)) : \"default\")\n  const width = options.width\n  const cache = options.cache\n  const blocks: BlockLayout[] = []\n  const lines: LayoutLine[] = []\n  const lineOffsets: number[] = []\n  let reused = 0\n  let computed = 0\n\n  for (const block of document.blocks) {\n    const key = `${block.id}:${width}:${themeId}`\n    let blockLines = cache?.get(key)\n    if (blockLines) {\n      reused++\n    } else {\n      blockLines = layoutBlock(block, source, width, theme)\n      cache?.set(key, blockLines)\n      computed++\n    }\n    lineOffsets.push(lines.length)\n    blocks.push({\n      blockId: block.id,\n      width,\n      height: blockLines.length,\n      lines: blockLines,\n    })\n    for (const line of blockLines) lines.push(line)\n  }\n\n  return {\n    width,\n    themeId,\n    blocks,\n    lines,\n    lineOffsets,\n    totalLines: lines.length,\n    reused,\n    computed,\n  }\n}\n\n/** Visible slice for a viewport — clamped so the last page never scrolls past the end. */\nexport const sliceLines = (\n  layout: MarkdownLayout,\n  offset: number,\n  height: number,\n): readonly LayoutLine[] => {\n  const start = Math.max(\n    0,\n    Math.min(offset, Math.max(0, layout.totalLines - height)),\n  )\n  return layout.lines.slice(start, start + height)\n}\n\n/** Index of the first block whose cumulative offset ≤ line — the log-n first-visible lookup. */\nexport const firstBlockAt = (layout: MarkdownLayout, line: number): number => {\n  const offsets = layout.lineOffsets\n  let lo = 0\n  let hi = offsets.length - 1\n  let answer = 0\n  while (lo <= hi) {\n    const mid = (lo + hi) >> 1\n    if (offsets[mid] <= line) {\n      answer = mid\n      lo = mid + 1\n    } else {\n      hi = mid - 1\n    }\n  }\n  return answer\n}\n","import { useMemo } from \"react\"\nimport { Box, Text } from \"ink\"\nimport {\n  createMarkdownDocument,\n  createMarkdownLayout,\n  sliceLines,\n  type LayoutLine,\n  type MarkdownDocument,\n  type MarkdownLayout,\n  type MarkdownTheme,\n} from \"../core/index.js\"\nimport { linesToAnsi } from \"./ansi.js\"\n\nexport type MarkdownViewportProps = {\n  /** Raw Markdown source. Ignored when `layout` is provided. */\n  source?: string\n  /** Pre-parsed document (reused with `source` to skip re-parsing). */\n  document?: MarkdownDocument\n  /** Pre-computed layout — skips parse + layout entirely. */\n  layout?: MarkdownLayout\n  width: number\n  height: number\n  /** First visible document line. Clamped so the last page never scrolls past the end. */\n  scrollOffset?: number\n  theme?: MarkdownTheme\n  /** Layout cache shared across renders (survives scroll/resize). */\n  cache?: Map<string, readonly LayoutLine[]>\n}\n\n// The viewport mounts exactly ONE <Text>, whatever the document size: the visible slice is\n// composed into a single pre-rendered ANSI string (render-path A). React/Yoga work stays\n// O(viewport), not O(document) — the whole performance thesis, made concrete.\nexport const MarkdownViewport = ({\n  source,\n  document,\n  layout: providedLayout,\n  width,\n  height,\n  scrollOffset = 0,\n  theme,\n  cache,\n}: MarkdownViewportProps) => {\n  const layout = useMemo(() => {\n    if (providedLayout) return providedLayout\n    const text = source ?? \"\"\n    const doc = document ?? createMarkdownDocument(text)\n    return createMarkdownLayout(doc, text, { width, theme, cache })\n  }, [providedLayout, document, source, width, theme, cache])\n\n  const composed = linesToAnsi(sliceLines(layout, scrollOffset, height))\n\n  return (\n    <Box width={width} height={height} flexDirection=\"column\">\n      <Text wrap=\"truncate\">{composed}</Text>\n    </Box>\n  )\n}\n","import chalk, { type ChalkInstance } from \"chalk\"\nimport type { LayoutLine, SpanStyle } from \"../core/index.js\"\n\n// Path-A composition lives here: semantic spans → one ANSI string. Chalk auto-detects the\n// terminal's colour support, so this degrades to plain text where colour is unavailable.\nconst chain = (fn: ChalkInstance, key: string): ChalkInstance => {\n  const next = (fn as unknown as Record<string, unknown>)[key]\n  return typeof next === \"function\" ? (next as ChalkInstance) : fn\n}\n\nconst capitalize = (value: string): string =>\n  value.charAt(0).toUpperCase() + value.slice(1)\n\nconst applyStyle = (text: string, style?: SpanStyle): string => {\n  if (!style) return text\n  let fn: ChalkInstance = chalk\n  if (style.color) fn = chain(fn, style.color)\n  if (style.backgroundColor)\n    fn = chain(fn, `bg${capitalize(style.backgroundColor)}`)\n  if (style.bold) fn = chain(fn, \"bold\")\n  if (style.italic) fn = chain(fn, \"italic\")\n  if (style.underline) fn = chain(fn, \"underline\")\n  if (style.dim) fn = chain(fn, \"dim\")\n  if (style.inverse) fn = chain(fn, \"inverse\")\n  return fn(text)\n}\n\n/** Compose one layout line's styled spans into a single ANSI string. */\nexport const lineToAnsi = (line: LayoutLine): string =>\n  line.spans.map((span) => applyStyle(span.text, span.style)).join(\"\")\n\n/** Path-A composition: the visible span-lines → one ANSI string for a single <Text>. */\nexport const linesToAnsi = (lines: readonly LayoutLine[]): string =>\n  lines.map(lineToAnsi).join(\"\\n\")\n","import { useInput } from \"ink\"\n\nexport type MarkdownScrollOptions = {\n  totalLines: number\n  height: number\n  offset: number\n  onChange: (offset: number) => void\n  /** Disable the key handler (e.g. when another pane has focus). */\n  active?: boolean\n}\n\nconst clamp = (value: number, max: number): number =>\n  Math.max(0, Math.min(value, max))\n\n// Optional keyboard controller — the core owns scrolling *primitives* (offset in/out), not\n// keybindings. Apps that want their own bindings ignore this and drive `scrollOffset` directly.\nexport const useMarkdownScroll = ({\n  totalLines,\n  height,\n  offset,\n  onChange,\n  active = true,\n}: MarkdownScrollOptions): void => {\n  const max = Math.max(0, totalLines - height)\n  useInput(\n    (input, key) => {\n      if (key.downArrow || input === \"j\") onChange(clamp(offset + 1, max))\n      else if (key.upArrow || input === \"k\") onChange(clamp(offset - 1, max))\n      else if (key.pageDown || input === \" \")\n        onChange(clamp(offset + height, max))\n      else if (key.pageUp || input === \"b\")\n        onChange(clamp(offset - height, max))\n      else if (input === \"g\") onChange(0)\n      else if (input === \"G\") onChange(max)\n    },\n    { isActive: active },\n  )\n}\n"],"mappings":"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","names":["toLine","j"]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@kud/ink-markdown",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "A high-performance Markdown / code / diff rendering engine for Ink 7.",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "homepage": "https://kud.io/projects/ink-markdown",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kud/ink-markdown.git"
+  },
+  "author": "Erwann Mest <m@kud.io>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "ink": "7.x",
+    "react": "19.x"
+  },
+  "dependencies": {
+    "chalk": "5.6.2",
+    "cli-highlight": "2.1.11",
+    "markdown-it": "14.3.0",
+    "slice-ansi": "9.0.0",
+    "string-width": "8.2.2",
+    "wrap-ansi": "10.0.0"
+  },
+  "devDependencies": {
+    "@types/markdown-it": "14.1.2",
+    "@types/node": "26.1.1",
+    "@types/react": "19.2.17",
+    "ink": "7.1.0",
+    "ink-testing-library": "4.0.0",
+    "react": "19.2.7",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.1.10"
+  }
+}