@riebeckite/plugin-diff 0.0.14 → 0.0.16

package/README.md

@@ -28,6 +28,9 @@ export default defineConfig({
 ```
 
 `diff(options?)` accepts the same `GitHistoryReaderOptions` as the API.
+The revision panel renders the initial comparison during the build and computes
+other selected comparisons in the browser. It embeds each available revision
+once rather than every pairwise diff, keeping generated pages compact.
 
 ## Programmatic API
 
@@ -61,7 +64,7 @@ const compare = await api.compareRevisions({
 
 | Option | Type | Default | Description |
 | ------ | ---- | ------- | ----------- |
-| `cwd` | `string` | `process.cwd()` | Working directory for Git commands |
+| `cwd` | `string` | `config.content.directory`, else `process.cwd()` | Content root used to locate the Git work tree |
 
 When `cwd` is not inside a Git repository, API calls resolve to empty results
 (`[]` / `null`) instead of throwing.
@@ -87,4 +90,4 @@ When `cwd` is not inside a Git repository, API calls resolve to empty results
 
 ## See also
 
-- [Plugin guide](../../../docs/en/reference/plugin-api.md)
+- [Plugin guide](../../../docs/en/docs/reference/plugin-api.md)

package/README_ja.md

@@ -28,7 +28,9 @@ const current = await api.getCurrentDiff("notes/hello.md");
 | `getCurrentDiff(filePath)` | 最新と一つ前のリビジョンの差分 |
 | `compareRevisions(input)` | 指定した二つのリビジョンの差分 |
 
-`cwd` は Git コマンドを実行するディレクトリで、既定値は `process.cwd()` です。Git リポジトリ外を指定しても例外は投げず、空の結果を返します。
+`cwd` は Git リポジトリを探すためのコンテンツルートで、既定値はビルド内の `config.content.directory`、それ以外では `process.cwd()` です。相対パスは `process.cwd()` 基準で解決されます。Git リポジトリ外を指定しても例外は投げず、空の結果を返します。
+
+リビジョンパネルは初期表示の差分だけをビルド時に描画し、利用者が選んだ比較はブラウザ上で計算します。各リビジョンは一度だけ埋め込むため、全組み合わせの差分を出力する場合より生成ページを小さく保てます。
 
 ## 公開 API
 
@@ -38,4 +40,4 @@ const current = await api.getCurrentDiff("notes/hello.md");
 
 ## 関連資料
 
-- [プラグインシステム](../../../docs/ja/reference/plugin-api.md)
+- [プラグインシステム](../../../docs/ja/docs/reference/plugin-api.md)

package/dist/client.js

@@ -3,6 +3,92 @@ function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 
+// src/diff/line_diff.ts
+function createLineDiff(fromMarkdown, toMarkdown) {
+  const fromLines = splitLines(fromMarkdown);
+  const toLines = splitLines(toMarkdown);
+  const table = buildLongestCommonSubsequenceTable(fromLines, toLines);
+  const lines = [];
+  let fromIndex = 0;
+  let toIndex = 0;
+  let oldLineNumber = 1;
+  let newLineNumber = 1;
+  while (fromIndex < fromLines.length && toIndex < toLines.length) {
+    if (fromLines[fromIndex] === toLines[toIndex]) {
+      lines.push({
+        type: "context",
+        content: fromLines[fromIndex],
+        oldLineNumber,
+        newLineNumber
+      });
+      fromIndex += 1;
+      toIndex += 1;
+      oldLineNumber += 1;
+      newLineNumber += 1;
+      continue;
+    }
+    if (table[fromIndex + 1][toIndex] >= table[fromIndex][toIndex + 1]) {
+      lines.push({
+        type: "removed",
+        content: fromLines[fromIndex],
+        oldLineNumber,
+        newLineNumber: null
+      });
+      fromIndex += 1;
+      oldLineNumber += 1;
+    } else {
+      lines.push({
+        type: "added",
+        content: toLines[toIndex],
+        oldLineNumber: null,
+        newLineNumber
+      });
+      toIndex += 1;
+      newLineNumber += 1;
+    }
+  }
+  while (fromIndex < fromLines.length) {
+    lines.push({
+      type: "removed",
+      content: fromLines[fromIndex],
+      oldLineNumber,
+      newLineNumber: null
+    });
+    fromIndex += 1;
+    oldLineNumber += 1;
+  }
+  while (toIndex < toLines.length) {
+    lines.push({
+      type: "added",
+      content: toLines[toIndex],
+      oldLineNumber: null,
+      newLineNumber
+    });
+    toIndex += 1;
+    newLineNumber += 1;
+  }
+  return lines;
+}
+function splitLines(markdown) {
+  if (!markdown) return [];
+  return markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+function buildLongestCommonSubsequenceTable(fromLines, toLines) {
+  const table = Array.from(
+    { length: fromLines.length + 1 },
+    () => Array.from({ length: toLines.length + 1 }, () => 0)
+  );
+  for (let fromIndex = fromLines.length - 1; fromIndex >= 0; fromIndex -= 1) {
+    for (let toIndex = toLines.length - 1; toIndex >= 0; toIndex -= 1) {
+      table[fromIndex][toIndex] = fromLines[fromIndex] === toLines[toIndex] ? table[fromIndex + 1][toIndex + 1] + 1 : Math.max(
+        table[fromIndex + 1][toIndex],
+        table[fromIndex][toIndex + 1]
+      );
+    }
+  }
+  return table;
+}
+
 // client/diff-viewer.ts
 function initDiffHistory() {
   for (const root of document.querySelectorAll(
@@ -13,7 +99,9 @@ function initDiffHistory() {
 }
 function initDiffHistoryRoot(root) {
   const payload = readPayload(root);
-  if (!payload || payload.diffs.length === 0) return;
+  if (!payload) return;
+  let revisions = revisionsMap(payload.revisions ?? []);
+  let revisionsRequest = null;
   const fromSelect = root.querySelector(
     "[data-rr-diff-from]"
   );
@@ -25,25 +113,86 @@ function initDiffHistoryRoot(root) {
   )) {
     button.addEventListener("click", () => {
       const toHash = button.dataset.rrDiffSelect;
-      const diff = payload.diffs.find((entry) => entry.to.hash === toHash);
-      if (!diff) return;
-      fromSelect.value = diff.from?.hash ?? "";
-      toSelect.value = diff.to.hash;
-      updateSelectedCommit(root, diff.to.hash);
-      renderPanel(panel, diff);
+      if (!toHash) return;
+      void updateDiff({
+        root,
+        panel,
+        getRevisions: () => revisions,
+        setRevisions: (loaded) => {
+          revisions = loaded;
+        },
+        load: () => {
+          revisionsRequest ??= loadRevisions(payload.path);
+          return revisionsRequest;
+        },
+        fromHash: fromSelect.value,
+        toHash,
+        fromSelect,
+        toSelect
+      });
     });
   }
   const updateFromSelects = () => {
-    const diff = payload.diffs.find(
-      (entry) => (entry.from?.hash ?? "") === fromSelect.value && entry.to.hash === toSelect.value
-    );
-    if (!diff) return;
-    updateSelectedCommit(root, diff.to.hash);
-    renderPanel(panel, diff);
+    void updateDiff({
+      root,
+      panel,
+      getRevisions: () => revisions,
+      setRevisions: (loaded) => {
+        revisions = loaded;
+      },
+      load: () => {
+        revisionsRequest ??= loadRevisions(payload.path);
+        return revisionsRequest;
+      },
+      fromHash: fromSelect.value,
+      toHash: toSelect.value,
+      fromSelect,
+      toSelect
+    });
   };
   fromSelect.addEventListener("change", updateFromSelects);
   toSelect.addEventListener("change", updateFromSelects);
 }
+async function updateDiff(input) {
+  const { root, panel, fromHash, toHash, fromSelect, toSelect } = input;
+  const token = `${fromHash}
+${toHash}`;
+  root.dataset.rrDiffPending = token;
+  const loaded = await input.load();
+  if (loaded) input.setRevisions(loaded);
+  if (root.dataset.rrDiffPending !== token) return;
+  const diff = createDiff(input.getRevisions(), fromHash, toHash);
+  if (!diff) return;
+  fromSelect.value = diff.from?.hash ?? "";
+  toSelect.value = diff.to.hash;
+  updateSelectedCommit(root, diff.to.hash);
+  renderPanel(panel, diff);
+}
+async function loadRevisions(path) {
+  if (!path) return null;
+  try {
+    const response = await fetch(path);
+    if (!response.ok) return null;
+    const payload = await response.json();
+    return revisionsMap(payload.revisions ?? []);
+  } catch {
+    return null;
+  }
+}
+function revisionsMap(revisions) {
+  return new Map(revisions.map((revision) => [revision.hash, revision]));
+}
+function createDiff(revisions, fromHash, toHash) {
+  const to = revisions.get(toHash);
+  if (!to) return null;
+  const from = fromHash ? revisions.get(fromHash) : null;
+  if (fromHash && !from) return null;
+  return {
+    from: from ?? null,
+    to,
+    lines: createLineDiff(from?.markdown ?? "", to.markdown)
+  };
+}
 function readPayload(root) {
   const script = root.querySelector(
     "[data-rr-diff-history-data]"
@@ -66,9 +215,7 @@ function updateSelectedCommit(root, hash) {
   }
 }
 function renderPanel(panel, diff) {
-  const fromLabel = diff.from?.shortHash ?? "Beginning";
   panel.innerHTML = `<div class="rr-diff-history__diff" data-rr-diff-rendered>
-    <div class="rr-diff-history__diff-head">${escapeHtml(fromLabel)} → ${escapeHtml(diff.to.shortHash)}</div>
     <div class="rr-diff-history__table-wrap">
       <table class="rr-diff-history__table">
         <tbody>${diff.lines.map(renderLine).join("")}</tbody>

package/dist/index.js

@@ -53,9 +53,7 @@ function renderDiffViewer({
   </div>`;
 }
 function renderDiffPanel(diff2) {
-  const fromLabel = diff2.from?.shortHash ?? "Beginning";
   return `<div class="rr-diff-history__diff" data-rr-diff-rendered>
-    <div class="rr-diff-history__diff-head">${escapeHtml(fromLabel)} → ${escapeHtml(diff2.to.shortHash)}</div>
     <div class="rr-diff-history__table-wrap">
       <table class="rr-diff-history__table">
         <tbody>${diff2.lines.map((line) => renderDiffLine({ line })).join("")}</tbody>
@@ -72,23 +70,26 @@ function renderRevisionSelect(kind, history, value) {
 
 // src/components/diff-history.tsx
 function renderDiffHistory(input) {
-  const selected = input.diffs[0] ?? null;
-  const payload = JSON.stringify(input).replace(/</g, "\\u003c");
+  const history = input.revisions;
+  const selected = input.selected;
+  const payloadPath = input.payloadPath;
   return `<section class="rr-diff-history" data-rr-diff-history>
-  <div class="rr-diff-history__header">
+  <details class="rr-diff-history__panel">
+  <summary class="rr-diff-history__header">
     <h2 class="rr-diff-history__title">History</h2>
-    <span class="rr-diff-history__count">${input.history.length} changes</span>
-  </div>
-  ${input.history.length === 0 || !selected ? renderEmptyState() : renderContent(input, selected)}
-  <script type="application/json" data-rr-diff-history-data>${payload}</script>
+    <span class="rr-diff-history__header-meta"><span class="rr-diff-history__count">${history.length} changes</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--open">Collapse</span><span class="rr-diff-history__toggle-label rr-diff-history__toggle-label--closed">Expand</span><span class="rr-diff-history__toggle" aria-hidden="true"><svg class="rr-diff-history__toggle-icon" viewBox="0 0 16 16" width="16" height="16" focusable="false"><path d="M5.2 3.4 10.8 8l-5.6 4.6" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.8"/></svg></span></span>
+  </summary>
+   ${history.length === 0 || !selected ? renderEmptyState() : renderContent(history, selected)}
+  </details>
+   ${payloadPath ? `<script type="application/json" data-rr-diff-history-data>${JSON.stringify({ path: payloadPath }).replace(/</g, "\\u003c")}</script>` : ""}
 </section>`;
 }
-function renderContent(input, selected) {
+function renderContent(history, selected) {
   return `<div class="rr-diff-history__layout">
     <ol class="rr-diff-history__list" aria-label="Commit history">
-      ${input.history.map((revision, index) => renderRevisionButton(revision, index === 0)).join("")}
+      ${history.map((revision, index) => renderRevisionButton(revision, index === 0)).join("")}
     </ol>
-    ${renderDiffViewer({ history: input.history, selected })}
+    ${renderDiffViewer({ history, selected })}
   </div>`;
 }
 function renderEmptyState() {
@@ -191,30 +192,131 @@ function buildLongestCommonSubsequenceTable(fromLines, toLines) {
 }
 
 // src/git/history_reader.ts
+import path2 from "node:path";
+
+// src/git/repo_paths.ts
+import path from "node:path";
+
+// src/git/run_git.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
+function isGitCommandFailure(result) {
+  return result.ok === false;
+}
+async function runGit(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-c", "core.quotePath=false", ...args],
+      {
+        ...cwd === void 0 ? {} : { cwd },
+        maxBuffer: 1024 * 1024 * 10
+      }
+    );
+    return { ok: true, stdout };
+  } catch (error) {
+    return {
+      ok: false,
+      spawnError: isSpawnFailure(readErrorCode(error)),
+      detail: describeGitFailure(error)
+    };
+  }
+}
+function readErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+function isSpawnFailure(code) {
+  return typeof code === "string" && !code.startsWith("ERR_");
+}
+function describeGitFailure(error) {
+  if (typeof error !== "object" || error === null) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  const stderr = "stderr" in error ? error.stderr : void 0;
+  if (typeof stderr === "string" && stderr.trim()) return stderr.trim();
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/git/repo_paths.ts
+async function resolveRepositoryPaths(contentRoot) {
+  const resolvedContentRoot = path.resolve(contentRoot);
+  const result = await runGit([
+    "-C",
+    resolvedContentRoot,
+    "rev-parse",
+    "--show-toplevel",
+    "--show-prefix"
+  ]);
+  if (isGitCommandFailure(result)) {
+    return result.spawnError ? { kind: "git-unavailable", detail: result.detail } : { kind: "content-outside-repository", detail: result.detail };
+  }
+  const [toplevel, prefix] = parseRevParseOutput(result.stdout);
+  if (!toplevel) {
+    return {
+      kind: "content-outside-repository",
+      detail: "git rev-parse reported no work tree root"
+    };
+  }
+  return {
+    kind: "resolved",
+    paths: {
+      repositoryRoot: toPosixPath(path.normalize(toplevel)),
+      contentRoot: toPosixPath(resolvedContentRoot),
+      contentPrefix: toPosixPath(prefix).replace(/\/+$/, "")
+    }
+  };
+}
+function toRepositoryPath(paths, contentRelativePath) {
+  const normalized = normalizeContentPath(contentRelativePath);
+  if (!paths.contentPrefix) return normalized;
+  if (!normalized) return paths.contentPrefix;
+  return `${paths.contentPrefix}/${normalized}`;
+}
+function normalizeContentPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isResolvedRepository(resolution) {
+  return resolution.kind === "resolved";
+}
+function parseRevParseOutput(stdout) {
+  const [toplevel = "", prefix = ""] = stdout.split(/\r?\n/);
+  return [toplevel.trim(), prefix.trim()];
+}
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/git/history_reader.ts
 var fieldSeparator = "";
 var recordSeparator = "";
 var GitMarkdownHistoryReader = class {
-  #cwd;
+  #contentRoot;
   #historyCache = /* @__PURE__ */ new Map();
   #markdownCache = /* @__PURE__ */ new Map();
+  /** Maps a content-relative path to `<revision hash>` → work tree path. */
   #revisionPathCache = /* @__PURE__ */ new Map();
-  #repositoryAvailable;
+  #repository;
   constructor(options = {}) {
-    this.#cwd = options.cwd ?? process.cwd();
+    this.#contentRoot = path2.resolve(options.cwd ?? process.cwd());
   }
+  /**
+   * Revision history for one file, newest first, following renames.
+   *
+   * @param filePath Content-relative path, e.g. `notes/hello.md`.
+   */
   getHistory(filePath) {
-    const normalizedPath = normalizeGitPath(filePath);
+    const normalizedPath = normalizeContentPath(filePath);
     const cached = this.#historyCache.get(normalizedPath);
     if (cached) return cached;
     const history = this.#readHistory(normalizedPath);
     this.#historyCache.set(normalizedPath, history);
     return history;
   }
+  /** Content of one revision of a file, or `null` when Git cannot read it. */
   getRevisionMarkdown(filePath, hash) {
-    const normalizedPath = normalizeGitPath(filePath);
+    const normalizedPath = normalizeContentPath(filePath);
     const cacheKey = `${hash}:${normalizedPath}`;
     const cached = this.#markdownCache.get(cacheKey);
     if (cached) return cached;
@@ -223,35 +325,44 @@ var GitMarkdownHistoryReader = class {
     return markdown;
   }
   async #readHistory(filePath) {
-    if (!await this.#isRepositoryAvailable()) return [];
+    const repository = await this.#resolvePaths();
+    if (!repository) return [];
     const format = ["%H", "%h", "%cI", "%s", "%an"].join(fieldSeparator);
-    const result = await runGit(this.#cwd, [
-      "log",
-      "--follow",
-      "--name-status",
-      `--format=${recordSeparator}${format}`,
-      "--",
-      filePath
-    ]);
+    const result = await runGit(
+      [
+        "log",
+        "--follow",
+        "--name-status",
+        `--format=${recordSeparator}${format}`,
+        "--",
+        toRepositoryPath(repository, filePath)
+      ],
+      repository.repositoryRoot
+    );
     if (!result.ok || !result.stdout.trim()) return [];
     const revisionPaths = /* @__PURE__ */ new Map();
-    const revisions = result.stdout.split(recordSeparator).map((record) => record.trim()).filter(Boolean).map((record) => parseRevisionRecord(record, revisionPaths, filePath)).filter((revision) => revision !== null);
+    const fallbackPath = toRepositoryPath(repository, filePath);
+    const revisions = result.stdout.split(recordSeparator).map((record) => record.trim()).filter(Boolean).map((record) => parseRevisionRecord(record, revisionPaths, fallbackPath)).filter((revision) => revision !== null);
     this.#revisionPathCache.set(filePath, revisionPaths);
     return revisions;
   }
   async #readRevisionMarkdown(filePath, hash) {
-    if (!await this.#isRepositoryAvailable()) return null;
+    const repository = await this.#resolvePaths();
+    if (!repository) return null;
     await this.getHistory(filePath);
-    const revisionPath = this.#revisionPathCache.get(filePath)?.get(hash) ?? filePath;
-    const result = await runGit(this.#cwd, ["show", `${hash}:${revisionPath}`]);
+    const revisionPath = this.#revisionPathCache.get(filePath)?.get(hash) ?? toRepositoryPath(repository, filePath);
+    const result = await runGit(
+      ["show", `${hash}:${revisionPath}`],
+      repository.repositoryRoot
+    );
     return result.ok ? result.stdout : null;
   }
-  #isRepositoryAvailable() {
-    this.#repositoryAvailable ??= runGit(this.#cwd, [
-      "rev-parse",
-      "--is-inside-work-tree"
-    ]).then((result) => result.ok && result.stdout.trim() === "true");
-    return this.#repositoryAvailable;
+  /** `null` when the content directory has no readable work tree. */
+  async #resolvePaths() {
+    this.#repository ??= resolveRepositoryPaths(this.#contentRoot);
+    const resolution = await this.#repository;
+    if (!isResolvedRepository(resolution)) return null;
+    return resolution.paths;
   }
 };
 function parseRevisionRecord(record, revisionPaths, fallbackPath) {
@@ -271,48 +382,54 @@ function getRevisionPath(nameStatusLines, fallbackPath) {
   const line = nameStatusLines.find((entry) => entry.trim().length > 0);
   if (!line) return fallbackPath;
   const [, ...paths] = line.split("	");
-  return paths.at(-1) ?? fallbackPath;
-}
-function normalizeGitPath(filePath) {
-  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-async function runGit(cwd, args) {
-  try {
-    const { stdout } = await execFileAsync("git", args, {
-      cwd,
-      maxBuffer: 1024 * 1024 * 10
-    });
-    return { ok: true, stdout };
-  } catch (error) {
-    const stdout = typeof error === "object" && error !== null && "stdout" in error && typeof error.stdout === "string" ? error.stdout : "";
-    return { ok: false, stdout };
-  }
+  return normalizeContentPath(paths.at(-1) ?? fallbackPath);
 }
 
 // index.ts
 function diff(options = {}) {
-  const api = createPostDiffApi(options);
   const ui = { enabled: true, maxRevisions: 20, ...options.ui };
+  let api;
   return definePlugin({
     name: "diff",
+    processedContentCache: {
+      version: "diff-v2",
+      dependencyMode: "unsafe"
+    },
     options,
     assets: ui.enabled === false ? [] : [createStyleAsset("diff")],
     clientEntries: ui.enabled === false ? [] : [createClientEntry("diff", "initDiffHistory")],
     onPostProcessed: async (context) => {
       if (ui.enabled === false) return;
+      api ??= createPostDiffApi({
+        ...options,
+        cwd: options.cwd ?? context.config?.content.directory
+      });
       const filePath = resolvePostFilePath(context);
       const history = (await api.getHistory(filePath)).slice(
         0,
         ui.maxRevisions
       );
-      const diffs = await buildRevisionDiffs(api, filePath, history);
+      const revisions = await getMarkdownRevisions(api, filePath, history);
+      const selected = await api.getCurrentDiff(filePath);
+      const payloadPath = revisions.length > 0 ? diffPayloadPath(context.slug) : void 0;
+      if (payloadPath) {
+        context.output.emit({
+          path: payloadPath,
+          content: JSON.stringify({ revisions }).replace(/</g, "\\u003c"),
+          dependencies: [{ type: "content", slug: context.slug }]
+        });
+      }
       context.content.html += renderDiffHistory({
-        history,
-        diffs
+        revisions,
+        selected,
+        payloadPath: payloadPath ? `/${payloadPath}` : void 0
       });
     }
   });
 }
+function diffPayloadPath(slug) {
+  return `_riebeckite/diff/${Buffer.from(slug).toString("base64url")}.json`;
+}
 function createPostDiffApi(options = {}) {
   const reader = new GitMarkdownHistoryReader(options);
   return {
@@ -354,32 +471,16 @@ function createPostDiffApi(options = {}) {
     }
   };
 }
-function getPreviousRevision(history, hash) {
-  const index = history.findIndex((revision) => revision.hash === hash);
-  return index >= 0 ? history[index + 1] ?? null : null;
-}
-async function buildRevisionDiffs(api, filePath, history) {
-  const comparisons = [];
-  for (let toIndex = 0; toIndex < history.length; toIndex += 1) {
-    const to = history[toIndex];
-    const previous = getPreviousRevision(history, to.hash);
-    comparisons.push({
-      filePath,
-      fromHash: previous?.hash ?? null,
-      toHash: to.hash
-    });
-    for (let fromIndex = toIndex + 2; fromIndex < history.length; fromIndex += 1) {
-      comparisons.push({
-        filePath,
-        fromHash: history[fromIndex].hash,
-        toHash: to.hash
-      });
-    }
-  }
-  const diffs = await Promise.all(
-    comparisons.map((comparison) => api.compareRevisions(comparison))
+async function getMarkdownRevisions(api, filePath, history) {
+  const revisions = await Promise.all(
+    history.map(async (revision) => ({
+      revision,
+      markdown: await api.getRevisionMarkdown(filePath, revision.hash)
+    }))
+  );
+  return revisions.flatMap(
+    ({ revision, markdown }) => markdown === null ? [] : [{ ...revision, markdown }]
   );
-  return diffs.filter((entry) => entry !== null);
 }
 function resolvePostFilePath(context) {
   const indexedPath = context.contentIndex.get(context.slug.toLowerCase());

package/dist/src/components/diff-history.d.ts

@@ -1,6 +1,7 @@
-import type { DiffRevision, PostDiff } from "../types.js";
+import type { MarkdownRevision, PostDiff } from "../types.js";
 export type DiffHistoryProps = {
-    history: DiffRevision[];
-    diffs: PostDiff[];
+    revisions: MarkdownRevision[];
+    selected: PostDiff | null;
+    payloadPath?: string;
 };
 export declare function renderDiffHistory(input: DiffHistoryProps): string;

package/dist/src/git/history_reader.d.ts

@@ -1,7 +1,20 @@
 import type { DiffRevision, GitHistoryReaderOptions } from "../types.js";
+/**
+ * Reads Markdown revisions out of a local Git repository.
+ *
+ * Callers speak content-relative paths — the same paths the content index
+ * reports. The reader resolves the owning work tree once and translates every
+ * path itself, so the process working directory never influences a result.
+ */
 export declare class GitMarkdownHistoryReader {
     #private;
     constructor(options?: GitHistoryReaderOptions);
+    /**
+     * Revision history for one file, newest first, following renames.
+     *
+     * @param filePath Content-relative path, e.g. `notes/hello.md`.
+     */
     getHistory(filePath: string): Promise<DiffRevision[]>;
+    /** Content of one revision of a file, or `null` when Git cannot read it. */
     getRevisionMarkdown(filePath: string, hash: string): Promise<string | null>;
 }

package/dist/src/git/repo_paths.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The paths that locate a content directory inside a Git work tree.
+ *
+ * Every field is a POSIX-separated path (`git` prints and accepts those on every
+ * platform, including Windows).
+ */
+export type GitRepositoryPaths = {
+    /** Work tree root reported by `git rev-parse --show-toplevel`. */
+    repositoryRoot: string;
+    /** Absolute path of the content directory. */
+    contentRoot: string;
+    /**
+     * Content directory relative to `repositoryRoot`, without a trailing slash.
+     * Empty when the content directory is the work tree root itself.
+     */
+    contentPrefix: string;
+};
+/**
+ * Why Git history cannot be read for a content directory.
+ *
+ * The reason is modelled explicitly so a plugin can report an actionable
+ * diagnostic instead of quietly rendering nothing.
+ */
+export type RepositoryPathsResolution = {
+    kind: "resolved";
+    paths: GitRepositoryPaths;
+}
+/** Git is not installed, or could not be started. */
+ | {
+    kind: "git-unavailable";
+    detail: string;
+}
+/** Git ran, but the content directory does not live in a work tree. */
+ | {
+    kind: "content-outside-repository";
+    detail: string;
+};
+/**
+ * Locates the Git work tree that owns `contentRoot`.
+ *
+ * Both the work tree root and the content prefix come from Git itself, so their
+ * casing and symlink resolution always agree with the paths `git log` prints —
+ * the reason content-relative paths can be translated without guessing.
+ *
+ * The work tree is resolved through `git -C <contentRoot>` rather than by
+ * running Git in `contentRoot`, so a missing directory surfaces as a Git
+ * failure instead of an indistinguishable spawn failure.
+ */
+export declare function resolveRepositoryPaths(contentRoot: string): Promise<RepositoryPathsResolution>;
+/**
+ * Translates a content-relative path into the work tree-relative path that
+ * `git log` pathspecs and `git show <rev>:<path>` expect.
+ */
+export declare function toRepositoryPath(paths: GitRepositoryPaths, contentRelativePath: string): string;
+/**
+ * Translates a work tree-relative path printed by `git` back into a
+ * content-relative path, or returns `null` when the path lies outside the
+ * content directory.
+ */
+export declare function toContentPath(paths: GitRepositoryPaths, repositoryRelativePath: string): string | null;
+/** Normalizes a path to the POSIX form used for content and work tree paths. */
+export declare function normalizeContentPath(value: string): string;
+/**
+ * True when the content directory has a usable work tree. Narrows the
+ * resolution so callers can read `paths`.
+ */
+export declare function isResolvedRepository(resolution: RepositoryPathsResolution): resolution is Extract<RepositoryPathsResolution, {
+    kind: "resolved";
+}>;
+/**
+ * True when history cannot be read and a reason is available. Narrows the
+ * resolution so callers can read `detail`.
+ */
+export declare function isRepositoryUnavailable(resolution: RepositoryPathsResolution): resolution is Exclude<RepositoryPathsResolution, {
+    kind: "resolved";
+}>;

package/dist/src/git/run_git.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Result of a `git` invocation.
+ *
+ * Failures are returned instead of thrown: a site whose Git history cannot be
+ * read must still build, so every caller decides what an unavailable repository
+ * means for its own output.
+ */
+export type GitCommandResult = {
+    ok: true;
+    stdout: string;
+}
+/**
+ * `spawnError` separates "Git could not be started" (missing or unexecutable
+ * binary) from "Git ran and rejected the command" (not a work tree, unknown
+ * revision, unreadable path). The distinction drives which diagnostic a
+ * plugin reports.
+ */
+ | {
+    ok: false;
+    spawnError: boolean;
+    detail: string;
+};
+/**
+ * Narrows a failed command so its failure fields can be read.
+ *
+ * Type predicates are used instead of `result.ok` checks throughout this
+ * package because the build type-checks without `strictNullChecks`, where
+ * discriminant narrowing of an inline condition does not apply.
+ */
+export declare function isGitCommandFailure(result: GitCommandResult): result is Extract<GitCommandResult, {
+    ok: false;
+}>;
+/**
+ * Runs `git` with `args`.
+ *
+ * `core.quotePath=false` keeps non-ASCII paths verbatim so the printed paths
+ * match the ones the content index reports; Git otherwise escapes them into
+ * octal sequences that no path lookup can resolve.
+ *
+ * @param cwd Directory Git runs in. Omit when the command carries its own
+ *   `-C <dir>` argument.
+ */
+export declare function runGit(args: readonly string[], cwd?: string): Promise<GitCommandResult>;

package/dist/src/types.d.ts

@@ -26,6 +26,12 @@ export type RevisionComparisonInput = {
     toHash: string;
 };
 export type GitHistoryReaderOptions = {
+    /**
+     * Content root: the directory holding the notes, used to locate the owning
+     * Git work tree. Defaults to `config.content.directory` when the plugin runs
+     * inside a build, otherwise `process.cwd()`. A relative value is resolved
+     * against `process.cwd()`.
+     */
     cwd?: string;
 };
 export type DiffPluginUiOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/plugin-diff",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,12 +21,12 @@
     "./style.css": "./style.css"
   },
   "dependencies": {
-    "@riebeckite/core": "0.0.14"
+    "@riebeckite/core": "0.0.16"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.14"
+    "@riebeckite/test": "0.0.16"
   },
   "publishConfig": {
     "access": "public"

package/style.css

@@ -12,6 +12,25 @@
   justify-content: space-between;
   gap: 1rem;
   margin-block-end: 1rem;
+  cursor: pointer;
+  user-select: none;
+}
+
+.rr-diff-history__panel {
+  interpolate-size: allow-keywords;
+}
+
+.rr-diff-history__header::marker {
+  content: "";
+}
+
+.rr-diff-history__header::-webkit-details-marker {
+  display: none;
+}
+
+.rr-diff-history__header:focus-visible {
+  outline: 2px solid var(--rb-color-accent, #f66620);
+  outline-offset: 2px;
 }
 
 .rr-diff-history__title {
@@ -21,6 +40,72 @@
   text-transform: uppercase;
 }
 
+.rr-diff-history__header-meta {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.rr-diff-history__toggle-label {
+  color: var(
+    --rb-color-muted,
+    color-mix(in srgb, currentColor 62%, transparent)
+  );
+  font-size: 0.75rem;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.rr-diff-history__toggle-label--open {
+  display: none;
+}
+
+.rr-diff-history__panel[open] .rr-diff-history__toggle-label--open {
+  display: inline;
+}
+
+.rr-diff-history__panel[open] .rr-diff-history__toggle-label--closed {
+  display: none;
+}
+
+.rr-diff-history__toggle {
+  display: inline-grid;
+  place-items: center;
+  width: 1.5rem;
+  height: 1.5rem;
+  color: var(
+    --rb-color-muted,
+    color-mix(in srgb, currentColor 62%, transparent)
+  );
+}
+
+.rr-diff-history__toggle-icon {
+  transform: rotate(180deg);
+  transition: transform 180ms ease;
+}
+
+.rr-diff-history__panel[open] .rr-diff-history__toggle-icon {
+  transform: rotate(90deg);
+}
+
+@supports selector(::details-content) {
+  .rr-diff-history__panel::details-content {
+    block-size: 0;
+    overflow: clip;
+    opacity: 0;
+    transition:
+      block-size 220ms ease,
+      content-visibility 220ms ease allow-discrete,
+      opacity 160ms ease;
+    transition-behavior: allow-discrete;
+  }
+
+  .rr-diff-history__panel[open]::details-content {
+    block-size: auto;
+    opacity: 1;
+  }
+}
+
 .rr-diff-history__count,
 .rr-diff-history__date,
 .rr-diff-history__meta {
@@ -136,27 +221,16 @@
     var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
 }
 
-.rr-diff-history__diff-head {
-  border-block-end: 1px solid
-    var(--rb-color-border, color-mix(in srgb, currentColor 18%, transparent));
-  padding: 0.625rem 0.75rem;
-  font-family: var(
-    --rb-font-mono,
-    ui-monospace,
-    SFMono-Regular,
-    Consolas,
-    monospace
-  );
-  font-size: 0.8125rem;
-}
-
 .rr-diff-history__table-wrap {
   overflow-x: auto;
 }
 
 .rr-diff-history__table {
+  display: table;
   width: 100%;
   min-width: 42rem;
+  margin-block: 0;
+  overflow-x: visible;
   border-collapse: collapse;
   font-family: var(
     --rb-font-mono,