@celestia-island/hikari 0.55.148 → 0.55.149

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.148",
+  "version": "0.55.149",
   "private": false,
   "type": "module",
   "description": "Hikari Vue 3 component library — production-grade UI components based on shittim-chest design system",

package/src/components/HkDiffViewer.scss

@@ -0,0 +1,204 @@
+// HkDiffViewer — grouped, collapsible unified-diff rendering.
+// Sibling of the markdown code-block chrome: same subtle surface, same
+// mono stack, same hidden native scrollbars (overlay rails are attached
+// by the consumer's scroll container).
+
+@use "./hikari-vars" as vars;
+
+.hk-diff-viewer {
+  border: 1px solid var(--hi-color-border, #646464);
+  border-radius: var(--radius-sm);
+  background: var(--hi-color-bg-subtle, #21262d);
+  overflow: hidden; // clip hunk/gap bands to the rounded corners
+}
+
+.hk-diff-viewer__body {
+  overflow-x: auto;
+  font-size: var(--text-xs);
+  line-height: 1.55;
+  scrollbar-width: none;
+
+  &::-webkit-scrollbar {
+    display: none;
+  }
+}
+
+// One diff row: old number | new number | sign | content. The row is at
+// least the container width (so tints span edge to edge) and grows with
+// the longest content (so the container can scroll horizontally).
+.hk-diff-viewer__line {
+  display: grid;
+  grid-template-columns: 4.2ch 4.2ch 2ch 1fr;
+  width: 100%;
+  min-width: max-content;
+  font-family: var(--font-mono, vars.$hikari-font-family-mono);
+  white-space: pre;
+  color: var(--hi-color-text-primary, #1e1e1e);
+
+  &[data-kind="add"] {
+    background: rgb(var(--color-success) / 12%);
+
+    .hk-diff-viewer__sign {
+      color: rgb(var(--color-success));
+    }
+  }
+
+  &[data-kind="del"] {
+    background: rgb(var(--color-error) / 12%);
+
+    .hk-diff-viewer__sign {
+      color: rgb(var(--color-error));
+    }
+  }
+}
+
+.hk-diff-viewer__no {
+  padding: 0 0.8ch;
+  text-align: end;
+  color: var(--hi-color-text-tertiary, #8b949e);
+  opacity: 0.75;
+  user-select: none;
+}
+
+.hk-diff-viewer__sign {
+  user-select: none;
+  text-align: center;
+  font-weight: 600;
+}
+
+.hk-diff-viewer__code {
+  padding-inline-end: 1ch;
+  min-width: 0;
+}
+
+// ── hunk groups ────────────────────────────────────────────────────────────
+.hk-diff-viewer__hunk + .hk-diff-viewer__hunk,
+.hk-diff-viewer__hunk-body {
+  border-top: 1px solid var(--hi-color-border, #646464);
+}
+
+.hk-diff-viewer__hunk-head {
+  display: flex;
+  align-items: center;
+  gap: 0.5em;
+  width: 100%;
+  padding: 0.3em 0.8em;
+  border: 0;
+  background: var(--hi-color-bg-subtle, #21262d);
+  color: var(--hi-color-text-secondary, #666666);
+  font: inherit;
+  text-align: start;
+  cursor: pointer;
+  user-select: none;
+
+  &:hover {
+    color: var(--hi-color-text-primary, #1e1e1e);
+  }
+
+  &:focus-visible {
+    outline: 2px solid var(--hi-color-primary, #7aa2f7);
+    outline-offset: -2px;
+  }
+}
+
+.hk-diff-viewer__hunk-range {
+  font-weight: 600;
+  letter-spacing: 0.01em;
+}
+
+.hk-diff-viewer__hunk-section {
+  color: var(--hi-color-text-tertiary, #8b949e);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  min-width: 0;
+  flex: 1;
+}
+
+.hk-diff-viewer__hunk-stats {
+  display: inline-flex;
+  gap: 0.6em;
+  margin-inline-start: auto;
+  font-style: normal;
+
+  em {
+    font-style: normal;
+    font-weight: 600;
+  }
+
+  em[data-kind="add"] {
+    color: rgb(var(--color-success));
+  }
+
+  em[data-kind="del"] {
+    color: rgb(var(--color-error));
+  }
+}
+
+// ── collapsed unchanged regions ────────────────────────────────────────────
+.hk-diff-viewer__gap {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5em;
+  width: 100%;
+  padding: 0.35em 0.8em;
+  border: 0;
+  border-top: 1px dashed var(--hi-color-border, #646464);
+  background: rgb(var(--color-primary) / 5%);
+  color: var(--hi-color-text-tertiary, #8b949e);
+  font: inherit;
+  cursor: pointer;
+  user-select: none;
+
+  &:hover:not(:disabled) {
+    background: rgb(var(--color-primary) / 10%);
+    color: var(--hi-color-text-primary, #1e1e1e);
+  }
+
+  &:focus-visible {
+    outline: 2px solid var(--hi-color-primary, #7aa2f7);
+    outline-offset: -2px;
+  }
+
+  &:disabled {
+    cursor: progress;
+  }
+
+  &[data-state="failed"] {
+    background: rgb(var(--color-error) / 8%);
+    color: rgb(var(--color-error));
+  }
+
+  // Without a loadContext fetcher the row is a passive divider.
+  &[data-state="static"] {
+    cursor: default;
+
+    &:hover {
+      background: rgb(var(--color-primary) / 5%);
+      color: var(--hi-color-text-tertiary, #8b949e);
+    }
+  }
+}
+
+.hk-diff-viewer__gap-label {
+  font-size: 0.95em;
+}
+
+// A gap directly after the last hunk still gets its dashed separator.
+.hk-diff-viewer__hunk + .hk-diff-viewer__gap,
+.hk-diff-viewer__gap + .hk-diff-viewer__hunk .hk-diff-viewer__hunk-head {
+  border-top: 1px dashed var(--hi-color-border, #646464);
+}
+
+// ── raw fallback (unparseable input) ───────────────────────────────────────
+.hk-diff-viewer__raw {
+  margin: 0;
+  padding: 0.6em 0.8em;
+  font-family: var(--font-mono, vars.$hikari-font-family-mono);
+  font-size: var(--text-xs);
+  line-height: 1.55;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: var(--hi-color-text-primary, #1e1e1e);
+}

package/src/components/HkDiffViewer.test.tsx

@@ -0,0 +1,240 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
+
+import HkDiffViewer from "./HkDiffViewer";
+
+/**
+ * HkDiffViewer — the rendered half: hunk grouping, collapsed unchanged
+ * regions and the async expander contract (loadContext round-trips,
+ * anchor policy, failure/retry, reset on diff change).
+ */
+
+const apps: App[] = [];
+afterEach(() => {
+  for (const app of apps.splice(0)) app.unmount();
+  document.body.innerHTML = "";
+});
+
+function mount(props: Record<string, unknown>) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const Root = defineComponent({
+    setup() {
+      return () => h(HkDiffViewer, props as never);
+    },
+  });
+  const app = createApp(Root);
+  app.mount(container);
+  apps.push(app);
+  return container;
+}
+
+/** Diff with a 9-line leading gap, one mixed hunk, and a 5-line trailing gap. */
+const DIFF = [
+  "--- a/a.toml",
+  "+++ b/a.toml",
+  "@@ -10,4 +10,5 @@",
+  " ctx-a",
+  "-old",
+  "+new-1",
+  "+new-2",
+  " ctx-b",
+  " ctx-c",
+  "",
+].join("\n");
+
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+describe("HkDiffViewer", () => {
+  it("groups the diff into hunk cards with per-hunk stats and both-side numbers", async () => {
+    const root = mount({ diff: DIFF, totalLines: 19 });
+    await nextTick();
+    const head = root.querySelector(".hk-diff-viewer__hunk-head")!;
+    expect(head.textContent).toContain("@@ -10,4 +10,5 @@");
+    expect(head.querySelector('[data-kind="add"]')!.textContent).toBe("+2");
+    expect(head.querySelector('[data-kind="del"]')!.textContent).toBe("−1");
+    const lines = [...root.querySelectorAll(".hk-diff-viewer__line")];
+    // 6 hunk lines (3 context + 1 del + 2 add); gap rows are not .line
+    expect(lines).toHaveLength(6);
+    const kinds = lines.map((l) => l.getAttribute("data-kind"));
+    expect(kinds).toEqual(["context", "del", "add", "add", "context", "context"]);
+    const delLine = lines[1];
+    expect(delLine.querySelectorAll(".hk-diff-viewer__no")[0].textContent).toBe("11");
+    expect(delLine.querySelectorAll(".hk-diff-viewer__no")[1].textContent).toBe("");
+  });
+
+  it("renders unchanged regions as static dividers without a loadContext fetcher", async () => {
+    const root = mount({ diff: DIFF, totalLines: 19 });
+    await nextTick();
+    const gaps = [...root.querySelectorAll(".hk-diff-viewer__gap")];
+    expect(gaps).toHaveLength(2); // leading 9 + trailing 5
+    expect(gaps[0].tagName).toBe("DIV"); // not a button — nothing to fetch with
+    expect(gaps[0].textContent).toContain("9");
+    expect(gaps[1].textContent).toContain("5");
+  });
+
+  it("expands an unchanged region asynchronously via loadContext", async () => {
+    const seen: Array<[number, number]> = [];
+    const loadContext = vi.fn(async (start: number, count: number) => {
+      seen.push([start, count]);
+      return Array.from({ length: count }, (_, i) => `line-${start + i}`);
+    });
+    const root = mount({ diff: DIFF, totalLines: 19, loadContext, contextChunk: 4 });
+    await nextTick();
+
+    // Trailing gap [15..19] (5 lines, anchor start): first click fetches 15..18.
+    const trailing = root.querySelectorAll(".hk-diff-viewer__gap")[1] as HTMLButtonElement;
+    expect(trailing.tagName).toBe("BUTTON");
+    trailing.click();
+    await tick();
+    await nextTick();
+    expect(seen).toEqual([[15, 4]]);
+    let text = root.textContent!;
+    expect(text).toContain("line-15");
+    expect(text).toContain("line-18");
+    // One line remains hidden → the expander stays, now counting 1.
+    const after = root.querySelectorAll(".hk-diff-viewer__gap")[1] as HTMLButtonElement;
+    expect(after.textContent).toContain("1");
+
+    // Second click completes the region; the divider disappears entirely.
+    after.click();
+    await tick();
+    await nextTick();
+    expect(seen[1]).toEqual([19, 1]);
+    expect(root.querySelectorAll(".hk-diff-viewer__gap")).toHaveLength(1); // only the leading gap
+    text = root.textContent!;
+    expect(text).toContain("line-19");
+    // Revealed context lines carry both-side numbers (shift = 0 here).
+    const revealed = [...root.querySelectorAll(".hk-diff-viewer__line[data-kind='context']")];
+    expect(revealed.length).toBeGreaterThan(4);
+  });
+
+  it("expands the LEADING gap bottom-up (lines nearest the hunk first)", async () => {
+    const seen: Array<[number, number]> = [];
+    const loadContext = vi.fn(async (start: number, count: number) => {
+      seen.push([start, count]);
+      return Array.from({ length: count }, (_, i) => `L${start + i}`);
+    });
+    const root = mount({ diff: DIFF, totalLines: 19, loadContext, contextChunk: 4 });
+    await nextTick();
+    const leading = root.querySelectorAll(".hk-diff-viewer__gap")[0] as HTMLButtonElement;
+    leading.click();
+    await tick();
+    await nextTick();
+    expect(seen).toEqual([[6, 4]]); // bottom 4 of the 9-line leading gap
+    const text = root.textContent!;
+    expect(text).toContain("L6");
+    expect(text).toContain("L9");
+    expect(text).not.toContain("L5");
+  });
+
+  it("marks a failed fetch inline and retries on the next click", async () => {
+    let calls = 0;
+    const loadContext = vi.fn(async () => {
+      calls += 1;
+      if (calls === 1) return null; // transport failure
+      return ["recovered"];
+    });
+    const root = mount({
+      diff: DIFF,
+      totalLines: 19,
+      loadContext,
+      contextChunk: 1, // trailing gap is 5 lines; irrelevant — leading used
+    });
+    await nextTick();
+    const gap = root.querySelectorAll(".hk-diff-viewer__gap")[1] as HTMLButtonElement;
+    gap.click();
+    await tick();
+    await nextTick();
+    expect(root.querySelector(".hk-diff-viewer__gap[data-state='failed']")).toBeTruthy();
+    expect(loadContext).toHaveBeenCalledTimes(1);
+
+    (root.querySelector(".hk-diff-viewer__gap[data-state='failed']") as HTMLButtonElement).click();
+    await tick();
+    await nextTick();
+    expect(loadContext).toHaveBeenCalledTimes(2);
+    expect(root.querySelector(".hk-diff-viewer__gap[data-state='failed']")).toBeNull();
+    expect(root.textContent).toContain("recovered");
+  });
+
+  it("bottom-aligns a SHORT response in the leading gap (R1)", async () => {
+    // A clipping host answers fewer lines than requested: for the
+    // bottom-anchored leading gap the arrived lines are the ones NEAREST
+    // the hunk — storing them top-aligned would permanently hide those.
+    const seen: Array<[number, number]> = [];
+    const loadContext = vi.fn(async (start: number, count: number) => {
+      seen.push([start, count]);
+      // Clips to 2 lines regardless of the requested window.
+      return ["L8", "L9"].slice(0, Math.min(2, count));
+    });
+    const root = mount({ diff: DIFF, totalLines: 19, loadContext, contextChunk: 4 });
+    await nextTick();
+    const leading = root.querySelectorAll(".hk-diff-viewer__gap")[0] as HTMLButtonElement;
+    leading.click();
+    await tick();
+    await nextTick();
+    expect(seen).toEqual([[6, 4]]); // bottom 4 of the 9-line gap requested…
+    const text = root.textContent!;
+    expect(text).toContain("L8"); // …but the 2 that arrived render…
+    expect(text).toContain("L9"); //   …nearest the hunk (bottom-aligned)
+    expect(text).not.toContain("L6");
+    // 7 lines remain hidden; the expander persists with the new count.
+    const after = root.querySelectorAll(".hk-diff-viewer__gap")[0] as HTMLButtonElement;
+    expect(after.textContent).toContain("7");
+  });
+
+  it("collapses and re-expands a hunk via its header", async () => {
+    const root = mount({ diff: DIFF, totalLines: 19 });
+    await nextTick();
+    const head = root.querySelector(".hk-diff-viewer__hunk-head") as HTMLButtonElement;
+    expect(root.querySelectorAll(".hk-diff-viewer__line")).toHaveLength(6);
+    head.click();
+    await nextTick();
+    expect(root.querySelectorAll(".hk-diff-viewer__line")).toHaveLength(0);
+    head.click();
+    await nextTick();
+    expect(root.querySelectorAll(".hk-diff-viewer__line")).toHaveLength(6);
+  });
+
+  it("resets gap state when the diff prop changes", async () => {
+    const loadContext = vi.fn(async (start: number, count: number) =>
+      Array.from({ length: count }, (_, i) => `line-${start + i}`),
+    );
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const diffRef = ref(DIFF);
+    const Root = defineComponent({
+      setup() {
+        return () =>
+          h(HkDiffViewer, {
+            diff: diffRef.value,
+            totalLines: 19,
+            loadContext,
+            contextChunk: 100,
+          } as never);
+      },
+    });
+    const app = createApp(Root);
+    app.mount(container);
+    apps.push(app);
+    await nextTick();
+
+    (container.querySelector(".hk-diff-viewer__gap") as HTMLButtonElement).click();
+    await tick();
+    await nextTick();
+    expect(container.textContent).toContain("line-1");
+
+    // A different diff must drop the fetched lines and recompute gaps.
+    diffRef.value = "@@ -3,2 +3,2 @@\n-a\n+b\n";
+    await nextTick();
+    expect(container.textContent).not.toContain("line-1");
+    expect(container.textContent).toContain("15"); // trailing gap of the new diff
+  });
+
+  it("degrades unparseable input to a raw <pre>", async () => {
+    const root = mount({ diff: "not a diff\nat all" });
+    await nextTick();
+    expect(root.querySelector(".hk-diff-viewer__raw")!.textContent).toContain("not a diff");
+    expect(root.querySelector(".hk-diff-viewer__hunk")).toBeNull();
+  });
+});

package/src/components/HkDiffViewer.tsx

@@ -0,0 +1,276 @@
+import { computed, defineComponent, ref, watch } from "vue";
+import { AlertTriangle, ChevronDown, ChevronRight, UnfoldVertical } from "lucide-vue-next";
+import HkSpinner from "./HkSpinner";
+import { useI18n } from "../i18n/context";
+import { highlight } from "../composables/useHighlight";
+import { computeGaps, parseUnifiedDiff, type DiffLine, type UnchangedGap } from "./diffParse";
+import "./HkDiffViewer.scss";
+
+/**
+ * HkDiffViewer — unified-diff rendering as grouped, collapsible hunks.
+ *
+ * Born from the shittim-chest node-insight modal (2026-10-12 user
+ * direction): the previous renderer was a flat <pre> with tinted lines —
+ * no grouping, no way to see the unchanged neighbourhood of a change.
+ * This component parses the diff into hunks (the groups), renders every
+ * hunk as a collapsible card, and collapses the UNCHANGED regions
+ * between hunks into expander rows.
+ *
+ * Unchanged content is not part of a diff, so expansion is asynchronous:
+ * pass `loadContext(start, count)` (1-based, new-side numbering) and the
+ * component fetches the hidden lines on demand — over whatever transport
+ * the host app rides (chest: a WS RPC that the server relays into the
+ * container). Without `loadContext` the expander rows render as static
+ * dividers. Failures render inline and the next click retries.
+ *
+ * Line highlighting reuses the lazy highlight.js infrastructure
+ * (useHighlight): grammars load on demand and rows re-color once the
+ * grammar lands, exactly like the markdown code blocks.
+ */
+
+interface GapState {
+  /** Lines already revealed. */
+  revealed: number;
+  loading: boolean;
+  failed: boolean;
+  /** Fetched context lines, keyed by new-side line number. */
+  lines: Map<number, string>;
+}
+
+export default defineComponent({
+  name: "HkDiffViewer",
+  props: {
+    /** Unified-diff text (file headers allowed; they are skipped). */
+    diff: { type: String, required: true },
+    /** highlight.js language id for line highlighting (e.g. "rust"). */
+    language: { type: String, default: "" },
+    /**
+     * Current (new-side) total line count. Enables the trailing collapsed
+     * region after the last hunk; omit when unknown.
+     */
+    totalLines: { type: Number, default: null },
+    /** Lines revealed per expand click. */
+    contextChunk: { type: Number, default: 40 },
+    /**
+     * Async fetcher for unchanged lines: `(start, count) => lines | null`,
+     * 1-based new-side numbering. Null/throw = failure (inline + retry).
+     */
+    loadContext: { type: Function, default: null },
+  },
+  setup(props) {
+    const { t } = useI18n();
+
+    const parsed = computed(() => parseUnifiedDiff(props.diff));
+    const gaps = computed(() => computeGaps(parsed.value, props.totalLines ?? null));
+    const collapsedHunks = ref<Set<number>>(new Set());
+    /** Gap states keyed by the gap's new-side start line (stable identity). */
+    const gapStates = ref<Map<number, GapState>>(new Map());
+
+    // A fresh diff invalidates every cached context line and fold state.
+    watch(
+      () => [props.diff, props.totalLines],
+      () => {
+        collapsedHunks.value = new Set();
+        gapStates.value = new Map();
+      },
+    );
+
+    function gapState(gap: UnchangedGap): GapState {
+      let st = gapStates.value.get(gap.start);
+      if (!st) {
+        st = { revealed: 0, loading: false, failed: false, lines: new Map() };
+        gapStates.value.set(gap.start, st);
+      }
+      return st;
+    }
+
+    function toggleHunk(idx: number) {
+      const next = new Set(collapsedHunks.value);
+      if (next.has(idx)) next.delete(idx);
+      else next.add(idx);
+      collapsedHunks.value = next;
+    }
+
+    async function expandGap(gap: UnchangedGap) {
+      const load = props.loadContext as
+        | ((start: number, count: number) => Promise<string[] | null>)
+        | null;
+      if (!load) return;
+      const st = gapState(gap);
+      if (st.loading) return;
+      const remaining = gap.count - st.revealed;
+      if (remaining <= 0) return;
+      const take = Math.min(Math.max(1, props.contextChunk), remaining);
+      // Anchor policy: the leading gap reveals bottom-up (lines nearest
+      // the first hunk first); every later gap reveals top-down.
+      const fetchStart =
+        gap.anchor === "end" ? gap.start + remaining - take : gap.start + st.revealed;
+      st.loading = true;
+      st.failed = false;
+      try {
+        const lines = await load(fetchStart, take);
+        // The diff may have changed mid-flight; this gap state is then
+        // already discarded and writing into it is harmless.
+        if (!lines) {
+          st.failed = true;
+          return;
+        }
+        // A host may answer a SHORT window (clipped at EOF). For
+        // anchor="end" the render window is bottom-anchored, so the
+        // arrived lines must bottom-align too — treating them as the
+        // lines nearest the hunk (R1 finding: top-aligning them here
+        // permanently hides the lines closest to the first hunk).
+        const firstLine =
+          gap.anchor === "end" ? fetchStart + (take - lines.length) : fetchStart;
+        lines.forEach((text, i) => st.lines.set(firstLine + i, text));
+        st.revealed += lines.length;
+        if (lines.length === 0) st.revealed = gap.count; // nothing there — done
+      } catch {
+        st.failed = true;
+      } finally {
+        st.loading = false;
+      }
+    }
+
+    function renderLine(line: DiffLine, key: string) {
+      const sign = line.kind === "add" ? "+" : line.kind === "del" ? "−" : "";
+      const html = props.language ? highlight(line.text, props.language) : null;
+      return (
+        <div class="hk-diff-viewer__line" data-kind={line.kind} key={key}>
+          <span class="hk-diff-viewer__no">{line.oldNo ?? ""}</span>
+          <span class="hk-diff-viewer__no">{line.newNo ?? ""}</span>
+          <span class="hk-diff-viewer__sign">{sign}</span>
+          {html !== null ? (
+            <span class="hk-diff-viewer__code" v-html={html} />
+          ) : (
+            <span class="hk-diff-viewer__code">{line.text}</span>
+          )}
+        </div>
+      );
+    }
+
+    function renderContextLine(newNo: number, text: string, gap: UnchangedGap, key: string) {
+      return renderLine(
+        { kind: "context", oldNo: newNo - gap.shift, newNo, text },
+        key,
+      );
+    }
+
+    function renderGap(gap: UnchangedGap) {
+      const st = gapState(gap);
+      const remaining = gap.count - st.revealed;
+      const rows = [];
+
+      // Revealed context lines, in file order.
+      const revealedRows = [];
+      const first =
+        gap.anchor === "end" ? gap.start + gap.count - st.revealed : gap.start;
+      for (let no = first; no < first + st.revealed; no++) {
+        const text = st.lines.get(no);
+        if (text !== undefined) {
+          revealedRows.push(renderContextLine(no, text, gap, `g${gap.start}:${no}`));
+        }
+      }
+
+      const interactive = !!props.loadContext && remaining > 0;
+      const label = st.failed
+        ? t("hikari::diff.loadFailed", "Load failed, click to retry")
+        : t("hikari::diff.unchangedLines", "{count} unchanged lines").replace(
+            "{count}",
+            String(remaining),
+          );
+      const divider = interactive ? (
+        <button
+          type="button"
+          key={`gap-${gap.start}`}
+          class="hk-diff-viewer__gap"
+          data-state={st.loading ? "loading" : st.failed ? "failed" : "idle"}
+          disabled={st.loading}
+          onClick={() => void expandGap(gap)}
+        >
+          {st.loading ? (
+            <HkSpinner size="xs" />
+          ) : st.failed ? (
+            <AlertTriangle size={13} />
+          ) : (
+            <UnfoldVertical size={13} />
+          )}
+          <span class="hk-diff-viewer__gap-label">{label}</span>
+        </button>
+      ) : remaining > 0 ? (
+        <div class="hk-diff-viewer__gap" data-state="static" key={`gap-${gap.start}`}>
+          <UnfoldVertical size={13} />
+          <span class="hk-diff-viewer__gap-label">{label}</span>
+        </div>
+      ) : null;
+
+      // anchor=end: the remaining (button) part sits above the revealed
+      // lines; anchor=start: revealed lines first.
+      if (gap.anchor === "end") rows.push(divider, ...revealedRows);
+      else rows.push(...revealedRows, divider);
+      return rows;
+    }
+
+    function renderHunk(idx: number) {
+      const hunk = parsed.value.hunks[idx];
+      const collapsed = collapsedHunks.value.has(idx);
+      const adds = hunk.lines.filter((l) => l.kind === "add").length;
+      const dels = hunk.lines.filter((l) => l.kind === "del").length;
+      // The section heading after the second @@ (e.g. the enclosing fn).
+      const section = hunk.header.replace(/^@@\s+.*?@@\s*/, "");
+      return (
+        <div class="hk-diff-viewer__hunk" key={`h${idx}`}>
+          <button
+            type="button"
+            class="hk-diff-viewer__hunk-head"
+            aria-expanded={!collapsed}
+            onClick={() => toggleHunk(idx)}
+          >
+            {collapsed ? <ChevronRight size={13} /> : <ChevronDown size={13} />}
+            <span class="hk-diff-viewer__hunk-range">{hunk.header.match(/^@@\s+.*?@@/)?.[0] ?? "@@"}</span>
+            {section && <span class="hk-diff-viewer__hunk-section">{section}</span>}
+            <span class="hk-diff-viewer__hunk-stats">
+              {adds > 0 && <em data-kind="add">+{adds}</em>}
+              {dels > 0 && <em data-kind="del">−{dels}</em>}
+            </span>
+          </button>
+          {!collapsed && (
+            <div class="hk-diff-viewer__hunk-body">
+              {hunk.lines.map((line, li) => renderLine(line, `h${idx}:${li}`))}
+            </div>
+          )}
+        </div>
+      );
+    }
+
+    return () => {
+      const { hunks } = parsed.value;
+      if (hunks.length === 0) {
+        // Unparseable input: degrade to the honest raw text rather than
+        // rendering nothing.
+        return (
+          <div class="hk-diff-viewer">
+            <pre class="hk-diff-viewer__raw">{props.diff}</pre>
+          </div>
+        );
+      }
+      // Interleave: gaps are tagged with the hunk they precede
+      // (beforeHunk === hunks.length marks the trailing gap).
+      const gapsByHunk = new Map<number, UnchangedGap>();
+      for (const gap of gaps.value) gapsByHunk.set(gap.beforeHunk, gap);
+      const blocks = [];
+      for (let i = 0; i < hunks.length; i++) {
+        const gap = gapsByHunk.get(i);
+        if (gap) blocks.push(renderGap(gap));
+        blocks.push(renderHunk(i));
+      }
+      const trailing = gapsByHunk.get(hunks.length);
+      if (trailing) blocks.push(renderGap(trailing));
+      return (
+        <div class="hk-diff-viewer">
+          <div class="hk-diff-viewer__body">{blocks}</div>
+        </div>
+      );
+    };
+  },
+});

package/src/components/diffParse.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from "vitest";
+
+import { computeGaps, parseUnifiedDiff } from "./diffParse";
+
+/**
+ * diffParse — the pure half of HkDiffViewer. The pins that matter:
+ * line numbering on both sides (the renderer's fetched context lines
+ * must slot into exactly these numbers), zero-count hunk starts, and
+ * gap computation (leading / inter-hunk / trailing, with the old-side
+ * shift that lets context lines show both numbers).
+ */
+
+const SAMPLE = [
+  "--- a/config/app.toml",
+  "+++ b/config/app.toml",
+  "@@ -10,4 +10,5 @@ fn main() {",
+  " context-a",
+  "-old-line",
+  "+new-line-a",
+  "+new-line-b",
+  " context-b",
+  " context-b2",
+  "@@ -30,3 +31,3 @@",
+  " context-c",
+  "-gone",
+  "+here",
+  " context-d",
+  "",
+].join("\n");
+
+describe("parseUnifiedDiff", () => {
+  it("parses hunks with both-side line numbers", () => {
+    const { hunks, endCovered } = parseUnifiedDiff(SAMPLE);
+    expect(hunks).toHaveLength(2);
+
+    const [h0, h1] = hunks;
+    expect(h0.header).toBe("@@ -10,4 +10,5 @@ fn main() {");
+    expect(h0.lines.map((l) => [l.kind, l.oldNo, l.newNo, l.text])).toEqual([
+      ["context", 10, 10, "context-a"],
+      ["del", 11, null, "old-line"],
+      ["add", null, 11, "new-line-a"],
+      ["add", null, 12, "new-line-b"],
+      ["context", 12, 13, "context-b"],
+      ["context", 13, 14, "context-b2"],
+    ]);
+    expect(h1.oldStart).toBe(30);
+    expect(h1.newStart).toBe(31);
+    expect(endCovered).toBe(33);
+  });
+
+  it("treats an omitted count as 1 and a zero count as an empty range", () => {
+    const { hunks } = parseUnifiedDiff("@@ -0,0 +1 @@\n+only\n");
+    expect(hunks[0].oldStart).toBe(0);
+    expect(hunks[0].oldCount).toBe(0);
+    expect(hunks[0].lines).toEqual([{ kind: "add", oldNo: null, newNo: 1, text: "only" }]);
+
+    const del = parseUnifiedDiff("@@ -5 +4,0 @@\n-gone\n");
+    expect(del.hunks[0].lines).toEqual([{ kind: "del", oldNo: 5, newNo: null, text: "gone" }]);
+    // A deletion positions after new line 4 (the zero-count anchor rule),
+    // so the covered new-side range is 1..4 — NOT 1..3 (R2: the raw-start
+    // formula baked an off-by-one into this pin once).
+    expect(del.endCovered).toBe(4);
+  });
+
+  it("computes gaps for a pure insertion hunk like git -U0 (R2)", () => {
+    // `@@ -4,0 +5,2 @@` = insertion AFTER old line 4: the leading gap is
+    // new 1..4 with shift 0, and the trailing side resumes at old 5.
+    const parsed = parseUnifiedDiff("@@ -4,0 +5,2 @@\n+a\n+b\n");
+    expect(computeGaps(parsed, 8)).toEqual([
+      { start: 1, count: 4, shift: 0, anchor: "end", beforeHunk: 0 },
+      { start: 7, count: 2, shift: 2, anchor: "start", beforeHunk: 1 },
+    ]);
+  });
+
+  it("computes gaps for a pure deletion hunk like git -U0 (R2)", () => {
+    // `@@ -5,2 +4,0 @@` = old 5..6 deleted, positioned after new line 4:
+    // the unchanged new line 5 must expand ABOVE as part of no gap and
+    // resume numbering at old 7 after the hunk (shift −2).
+    const parsed = parseUnifiedDiff("@@ -5,2 +4,0 @@\n-gone-a\n-gone-b\n");
+    expect(parsed.endCovered).toBe(4);
+    expect(computeGaps(parsed, 6)).toEqual([
+      { start: 1, count: 4, shift: 0, anchor: "end", beforeHunk: 0 },
+      { start: 5, count: 2, shift: -2, anchor: "start", beforeHunk: 1 },
+    ]);
+  });
+
+  it("skips file headers and \\-markers, and tolerates stripped blank context lines", () => {
+    const diff = [
+      "--- a/x",
+      "+++ b/x",
+      "@@ -1,4 +1,4 @@",
+      " a",
+      "", // a context line whose trailing space got stripped
+      "-b",
+      "+c",
+      "\",
+      " d",
+    ].join("\n");
+    const { hunks } = parseUnifiedDiff(diff);
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0].lines.map((l) => l.kind)).toEqual(["context", "context", "del", "add", "context"]);
+  });
+
+  it("returns no hunks for empty or non-diff input", () => {
+    expect(parseUnifiedDiff("").hunks).toEqual([]);
+    expect(parseUnifiedDiff("hello\nworld").hunks).toEqual([]);
+    expect(parseUnifiedDiff("").endCovered).toBe(0);
+  });
+
+  it("never invents line 0 for a whole-file deletion (R1)", () => {
+    const parsed = parseUnifiedDiff("@@ -1,3 +0,0 @@\n-a\n-b\n-c\n");
+    expect(parsed.endCovered).toBe(0);
+    expect(computeGaps(parsed, 0)).toEqual([]);
+    expect(computeGaps(parsed, null)).toEqual([]);
+  });
+
+  it("lands a stray context line on line 1 inside a zero-count old range (R1)", () => {
+    // Malformed body (a context line where the old side is empty): the
+    // defensive +1 on zero-count ranges is the only thing keeping this
+    // line on the 1-based contract. Pins the behavior Mutation A broke.
+    const { hunks } = parseUnifiedDiff("@@ -0,0 +1,2 @@\n ctx\n+a\n");
+    expect(hunks[0].lines).toEqual([
+      { kind: "context", oldNo: 1, newNo: 1, text: "ctx" },
+      { kind: "add", oldNo: null, newNo: 2, text: "a" },
+    ]);
+  });
+
+  it("tolerates CRLF line endings without leaking \\r into text", () => {
+    const { hunks } = parseUnifiedDiff("@@ -1,2 +1,2 @@\r\n-old\r\n+new\r\n ctx\r\n");
+    expect(hunks[0].lines).toEqual([
+      { kind: "del", oldNo: 1, newNo: null, text: "old" },
+      { kind: "add", oldNo: null, newNo: 1, text: "new" },
+      { kind: "context", oldNo: 2, newNo: 2, text: "ctx" },
+    ]);
+  });
+});
+
+describe("computeGaps", () => {
+  it("computes leading, inter-hunk and trailing gaps with old-side shifts", () => {
+    const parsed = parseUnifiedDiff(SAMPLE);
+    const gaps = computeGaps(parsed, 60);
+    expect(gaps).toEqual([
+      // Lines 1–9 precede the first hunk (newStart 10, oldStart 10 → shift 0).
+      { start: 1, count: 9, shift: 0, anchor: "end", beforeHunk: 0 },
+      // Hunk 0 covers new 10–14, hunk 1 starts at 31 → gap 15–30.
+      // Old-side shift at hunk 1: newStart 31 − oldStart 30 = 1.
+      { start: 15, count: 16, shift: 1, anchor: "start", beforeHunk: 1 },
+      // Trailing: 34–60, shift from hunk 1's end: (31+3)−(30+3) = 1.
+      { start: 34, count: 27, shift: 1, anchor: "start", beforeHunk: 2 },
+    ]);
+  });
+
+  it("omits the trailing gap when the total line count is unknown", () => {
+    const parsed = parseUnifiedDiff(SAMPLE);
+    const gaps = computeGaps(parsed, null);
+    expect(gaps).toHaveLength(2);
+    expect(gaps.every((g) => g.beforeHunk < 2)).toBe(true);
+  });
+
+  it("produces no gaps for a whole-file addition", () => {
+    const parsed = parseUnifiedDiff("@@ -0,0 +1,3 @@\n+a\n+b\n+c\n");
+    expect(computeGaps(parsed, 3)).toEqual([]);
+  });
+});

package/src/components/diffParse.ts

@@ -0,0 +1,180 @@
+/**
+ * Unified-diff parsing for HkDiffViewer — pure functions, no Vue.
+ *
+ * Input is classic unified-diff text (`--- a/<path>` / `+++ b/<path>`
+ * headers followed by `@@ -oldStart[,oldCount] +newStart[,newCount @@`
+ * hunks). Only the hunk bodies are modeled; file headers are skipped
+ * (the consumer already knows the path and renders it itself).
+ *
+ * Line numbering follows the unified format contract: 1-based, and a
+ * `,count` of zero pins the start to the line BEFORE the range (so a
+ * pure-addition hunk reads `@@ -0,0 +1,31 @@`).
+ */
+
+export type DiffLineKind = "context" | "add" | "del";
+
+export interface DiffLine {
+  kind: DiffLineKind;
+  /** 1-based old-side line number (null for additions). */
+  oldNo: number | null;
+  /** 1-based new-side line number (null for deletions). */
+  newNo: number | null;
+  /** Line content without the +/-/space prefix. */
+  text: string;
+}
+
+export interface DiffHunk {
+  /** The raw `@@ … @@` line including any trailing section heading. */
+  header: string;
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  lines: DiffLine[];
+}
+
+export interface ParsedDiff {
+  hunks: DiffHunk[];
+  /**
+   * Highest new-side line number covered by the last hunk (0 when the
+   * diff carries no hunks). The collapsed region after the last hunk
+   * spans `endCovered + 1 … totalLines`.
+   */
+  endCovered: number;
+}
+
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+/**
+ * Parse unified-diff text into hunks. Malformed hunks degrade gracefully:
+ * a line that is neither prefix-tagged nor a new hunk header terminates
+ * the current hunk instead of corrupting line numbering.
+ */
+export function parseUnifiedDiff(diff: string): ParsedDiff {
+  const hunks: DiffHunk[] = [];
+  let cur: DiffHunk | null = null;
+  let oldNo = 0;
+  let newNo = 0;
+
+  // A trailing newline is the last line's terminator, not an extra line.
+  const text = diff.endsWith("\n") ? diff.slice(0, -1) : diff;
+  for (const rawLine of text.split("\n")) {
+    // Tolerate CRLF streams: a stray \r must not leak into line text.
+    const raw = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    const h = HUNK_RE.exec(raw);
+    if (h) {
+      cur = {
+        header: raw,
+        oldStart: Number(h[1]),
+        oldCount: h[2] === undefined ? 1 : Number(h[2]),
+        newStart: Number(h[3]),
+        newCount: h[4] === undefined ? 1 : Number(h[4]),
+        lines: [],
+      };
+      hunks.push(cur);
+      // A zero-count range starts one line earlier (the range is empty);
+      // the +1 below lands the first tagged line on the declared start.
+      oldNo = cur.oldStart + (cur.oldCount === 0 ? 1 : 0);
+      newNo = cur.newStart + (cur.newCount === 0 ? 1 : 0);
+      continue;
+    }
+    if (!cur) continue; // file headers (---/+++), index lines, …
+    const tag = raw[0];
+    if (tag === "\\") continue; // ""
+    const text = raw.slice(1);
+    if (tag === "+") {
+      cur.lines.push({ kind: "add", oldNo: null, newNo, text });
+      newNo += 1;
+    } else if (tag === "-") {
+      cur.lines.push({ kind: "del", oldNo, newNo: null, text });
+      oldNo += 1;
+    } else if (tag === " " || raw === "") {
+      // A truly empty line is a context line whose trailing space was
+      // stripped by an overeager serializer — accept it as context.
+      cur.lines.push({ kind: "context", oldNo, newNo, text: raw === "" ? "" : text });
+      oldNo += 1;
+      newNo += 1;
+    } else {
+      // Unknown line: end the hunk rather than corrupt numbering.
+      cur = null;
+    }
+  }
+
+  const last = hunks[hunks.length - 1];
+  // Same zero-count anchor rule as computeGaps (R2): a deletion hunk
+  // `@@ -5,2 +4,0 @@` positions after new line 4, so it covers 1..4 —
+  // and a whole-file deletion still floors at 0 (nothing covered).
+  const endCovered = last
+    ? Math.max(last.newStart + (last.newCount === 0 ? 1 : 0) + last.newCount - 1, 0)
+    : 0;
+  return { hunks, endCovered };
+}
+
+/** One collapsed stretch of unchanged lines, addressed on the new side. */
+export interface UnchangedGap {
+  /** 1-based new-side line number of the first hidden line. */
+  start: number;
+  /** Number of hidden lines. */
+  count: number;
+  /**
+   * Shift from new-side to old-side numbering at this point in the file
+   * (oldNo = newNo − shift), so fetched context lines render with both
+   * line numbers.
+   */
+  shift: number;
+  /** Expansion anchor: "end" for the leading gap (reveal near the first
+   *  hunk first), "start" for every later gap. */
+  anchor: "start" | "end";
+  /** Index of the hunk that follows this gap (`hunks.length` = trailing). */
+  beforeHunk: number;
+}
+
+/**
+ * Compute the collapsed unchanged regions around `hunks`, each tagged
+ * with the hunk it precedes so the renderer can interleave hunks and
+ * gaps without index arithmetic. `totalLines` is the current file's line
+ * count; pass undefined/null when unknown — the trailing region is then
+ * omitted (it cannot be sized).
+ */
+export function computeGaps(parsed: ParsedDiff, totalLines?: number | null): UnchangedGap[] {
+  const gaps: UnchangedGap[] = [];
+  let prevEnd = 0; // highest new-side line covered so far
+  parsed.hunks.forEach((hunk, i) => {
+    // Zero-count ranges anchor one line into the existing side — the SAME
+    // adjustment the parser applies to line numbering (R2 finding: a
+    // `@@ -4,0 +5,2 @@` insertion sits after old line 4, so the leading
+    // gap is new 1..4 with shift 0, not 1..4-with-shift-1; using the raw
+    // starts rendered an "old 0" and mislabelled expanded context).
+    const oldAnchor = hunk.oldStart + (hunk.oldCount === 0 ? 1 : 0);
+    const newAnchor = hunk.newStart + (hunk.newCount === 0 ? 1 : 0);
+    const gapStart = prevEnd + 1;
+    const gapEnd = newAnchor - 1;
+    if (gapEnd >= gapStart) {
+      gaps.push({
+        start: gapStart,
+        count: gapEnd - gapStart + 1,
+        shift: newAnchor - oldAnchor,
+        anchor: i === 0 && prevEnd === 0 ? "end" : "start",
+        beforeHunk: i,
+      });
+    }
+    prevEnd = newAnchor + hunk.newCount - 1;
+  });
+  // A whole-file deletion ends at new-side 0 under the anchor rule; clamp
+  // before sizing anything so the trailing region can never invent
+  // line 0 (R1 finding: loadContext(0, …) is off the 1-based contract).
+  const covered = Math.max(prevEnd, 0);
+  if (totalLines != null && totalLines > covered) {
+    const last = parsed.hunks[parsed.hunks.length - 1];
+    const lastOldAnchor = last.oldStart + (last.oldCount === 0 ? 1 : 0);
+    const lastNewAnchor = last.newStart + (last.newCount === 0 ? 1 : 0);
+    gaps.push({
+      start: covered + 1,
+      count: totalLines - covered,
+      shift: last ? lastNewAnchor + last.newCount - (lastOldAnchor + last.oldCount) : 0,
+      anchor: "start",
+      beforeHunk: parsed.hunks.length,
+    });
+  }
+  return gaps;
+}

package/src/i18n/locales/ar/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "تأكيد",
   "hikari::userPicker.selectedCount": "تم اختيار {count}",
   "hikari::tokenField.editValue": "تحرير القيمة",
-  "hikari::tokenField.clear": "مسح"
+  "hikari::tokenField.clear": "مسح",
+  "hikari::diff.unchangedLines": "{count} أسطر غير معدّلة",
+  "hikari::diff.loadFailed": "فشل التحميل، انقر لإعادة المحاولة"
 }

package/src/i18n/locales/de/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Bestätigen",
   "hikari::userPicker.selectedCount": "{count} ausgewählt",
   "hikari::tokenField.editValue": "Wert bearbeiten",
-  "hikari::tokenField.clear": "Leeren"
+  "hikari::tokenField.clear": "Leeren",
+  "hikari::diff.unchangedLines": "{count} unveränderte Zeilen",
+  "hikari::diff.loadFailed": "Laden fehlgeschlagen, zum Wiederholen klicken"
 }

package/src/i18n/locales/en/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Confirm",
   "hikari::userPicker.selectedCount": "{count} selected",
   "hikari::tokenField.editValue": "Edit value",
-  "hikari::tokenField.clear": "Clear"
+  "hikari::tokenField.clear": "Clear",
+  "hikari::diff.unchangedLines": "{count} unchanged lines",
+  "hikari::diff.loadFailed": "Load failed, click to retry"
 }

package/src/i18n/locales/es/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Confirmar",
   "hikari::userPicker.selectedCount": "{count} seleccionados",
   "hikari::tokenField.editValue": "Editar el valor",
-  "hikari::tokenField.clear": "Borrar"
+  "hikari::tokenField.clear": "Borrar",
+  "hikari::diff.unchangedLines": "{count} líneas sin cambios",
+  "hikari::diff.loadFailed": "Error al cargar, haz clic para reintentar"
 }

package/src/i18n/locales/fr/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Confirmer",
   "hikari::userPicker.selectedCount": "{count} sélectionnés",
   "hikari::tokenField.editValue": "Modifier la valeur",
-  "hikari::tokenField.clear": "Effacer"
+  "hikari::tokenField.clear": "Effacer",
+  "hikari::diff.unchangedLines": "{count} lignes inchangées",
+  "hikari::diff.loadFailed": "Échec du chargement, cliquez pour réessayer"
 }

package/src/i18n/locales/ja/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "確認",
   "hikari::userPicker.selectedCount": "{count} 件選択中",
   "hikari::tokenField.editValue": "値を編集",
-  "hikari::tokenField.clear": "クリア"
+  "hikari::tokenField.clear": "クリア",
+  "hikari::diff.unchangedLines": "未変更の {count} 行",
+  "hikari::diff.loadFailed": "読み込みに失敗しました。クリックで再試行"
 }

package/src/i18n/locales/ko/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "확인",
   "hikari::userPicker.selectedCount": "{count}명 선택됨",
   "hikari::tokenField.editValue": "값 편집",
-  "hikari::tokenField.clear": "지우기"
+  "hikari::tokenField.clear": "지우기",
+  "hikari::diff.unchangedLines": "변경되지 않은 {count}줄",
+  "hikari::diff.loadFailed": "불러오기 실패, 클릭하여 재시도"
 }

package/src/i18n/locales/pt/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Confirmar",
   "hikari::userPicker.selectedCount": "{count} selecionados",
   "hikari::tokenField.editValue": "Editar o valor",
-  "hikari::tokenField.clear": "Limpar"
+  "hikari::tokenField.clear": "Limpar",
+  "hikari::diff.unchangedLines": "{count} linhas inalteradas",
+  "hikari::diff.loadFailed": "Falha ao carregar, clique para tentar novamente"
 }

package/src/i18n/locales/ru/components.json

@@ -274,5 +274,7 @@
   "hikari::userPicker.confirm": "Подтвердить",
   "hikari::userPicker.selectedCount": "Выбрано: {count}",
   "hikari::tokenField.editValue": "Изменить значение",
-  "hikari::tokenField.clear": "Очистить"
+  "hikari::tokenField.clear": "Очистить",
+  "hikari::diff.unchangedLines": "{count} строк без изменений",
+  "hikari::diff.loadFailed": "Не удалось загрузить, нажмите для повтора"
 }

package/src/i18n/locales/zh-Hans/components.json

@@ -278,5 +278,7 @@
   "hikari::userPicker.confirm": "确认",
   "hikari::userPicker.selectedCount": "已选 {count} 人",
   "hikari::tokenField.editValue": "编辑数值",
-  "hikari::tokenField.clear": "清除"
+  "hikari::tokenField.clear": "清除",
+  "hikari::diff.unchangedLines": "{count} 行未修改",
+  "hikari::diff.loadFailed": "加载失败，点击重试"
 }

package/src/i18n/locales/zh-Hant/components.json

@@ -278,5 +278,7 @@
   "hikari::userPicker.confirm": "確認",
   "hikari::userPicker.selectedCount": "已選 {count} 人",
   "hikari::tokenField.editValue": "編輯數值",
-  "hikari::tokenField.clear": "清除"
+  "hikari::tokenField.clear": "清除",
+  "hikari::diff.unchangedLines": "{count} 行未修改",
+  "hikari::diff.loadFailed": "載入失敗，點擊重試"
 }

package/src/index.ts

@@ -694,6 +694,9 @@ export { default as HkCopyBadge } from "./components/HkCopyBadge";
 export { default as HkConfirmDialog } from "./components/HkConfirmDialog";
 export { default as HkCrossfade } from "./components/HkCrossfade";
 export { default as HkDivider } from "./components/HkDivider";
+export { default as HkDiffViewer } from "./components/HkDiffViewer";
+export { parseUnifiedDiff, computeGaps } from "./components/diffParse";
+export type { DiffLine, DiffHunk, ParsedDiff, UnchangedGap } from "./components/diffParse";
 export { default as HkDockBar } from "./components/HkDockBar";
 export { default as HkDrawer } from "./components/HkDrawer";
 export { default as HkEmptyState } from "./components/HkEmptyState";