@orz/ui-code 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright 2026 the orzui team
+Copyright 2026 the todou team
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -1,3 +1,217 @@
-# Temporary Holding Version
+# @orz/ui-code
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read-only code and diff blocks, syntax-highlighted by [pierre](https://www.npmjs.com/package/@pierre/diffs)
+on shiki and themed by `@orz/ui`, plus a word differ that segments CJK as well as English. The
+package contributes two renderers to `@orz/ui-content`'s registry: `codeContent` for code and
+`patchContent` for unified diffs.
+
+## Install
+
+```bash
+pnpm add @orz/ui-code @orz/ui @orz/ui-content @pierre/diffs lucide-react react react-dom
+```
+
+`@orz/ui-content` is a peer dependency so that the app and every content package share one registry.
+
+`@pierre/diffs` is a peer dependency. pierre's highlighter is a module singleton, and its engine is
+fixed by whichever surface creates it first. An app that renders pierre surfaces of its own has to
+share that one copy with these blocks: a second copy would bring its own singleton, its own shiki
+and its own wasm, and two highlighters that disagree about the engine.
+
+## CSS
+
+```css
+@import "tailwindcss";
+@import "@orz/ui/styles.css";
+@import "@orz/ui-code/styles.css";
+```
+
+Import it after `@orz/ui/styles.css`. It pins every `diffs-container` to the app theme's
+`color-scheme` and paints pierre's background and foreground from `--background` and
+`--foreground`, so a block matches the page under every theme, including themes with no syntax
+counterpart. It also colours a patch's `+`/`−` counts from the theme's `--diff-addition` and
+`--diff-deletion`. Like `@orz/ui`'s stylesheet, it registers `@source "./dist"` on its own.
+
+## Theme
+
+Blocks follow `@orz/ui`'s `ThemeProvider`. A palette's `syntax` (or its variant's) names the shiki
+theme for its token colors, and a palette without one uses that slot of pierre's own light/dark
+pair. Under `system` each slot comes from its own palette, so Solarized highlights as
+solarized-light by day and solarized-dark at night. A pinned mode or a one-palette theme fills both
+slots from the side on screen. Outside a provider, blocks use pierre's pair.
+
+## Entry points
+
+| Import | Contents |
+|---|---|
+| `@orz/ui-code` | `CodeBlock`, `CodeDiffBlock`, `CodeWorkerProvider`, `useCodeWorkerFactory`, `fenceFilename`, `codeContent`, `patchContent`, `PatchView`, `useSyntaxTheme`, `PIERRE_THEME`, `PIERRE_THEME_TYPE`, `PIERRE_HIGHLIGHTER`, `LazyMultiFileDiff`, `type SyntaxTheme` |
+| `@orz/ui-code/word-diff` | `wordDiff`, `coalescedWordDiff`, `wordBag`, `bagWith`, types |
+| `@orz/ui-code/styles.css` | the `diffs-container` rules |
+
+pierre is only reached through `lazy()`, so a bundler splits it and shiki into their own chunks,
+fetched when the first block renders.
+
+### `@orz/ui-code`
+
+`CodeBlock` takes a filename and infers the language from its extension. `fenceFilename` turns a
+markdown fence's language tag into such a filename, falling back to plain text for a tag pierre
+does not know:
+
+```tsx
+import { CodeBlock, CodeDiffBlock, fenceFilename } from "@orz/ui-code";
+
+<CodeBlock filename={fenceFilename(lang)} contents={code} />
+<CodeBlock filename="main.ts" contents={file} lineNumbers />
+<CodeDiffBlock filename="main.ts" before={previous} after={current} />
+```
+
+`CodeBlock` takes `plain` to skip highlighting, and a `className` that caps a long file's height:
+the code view virtualizes against its own box.
+
+### Highlighting off the main thread
+
+pierre tokenizes a whole file even when it draws a screenful: 1 MiB of log held the tab for 9.3 s
+on the main thread, 0.2 s in pierre's worker. `CodeWorkerProvider` lends that worker to every
+`CodeBlock` below it that sets `offThread`, which `codeContent` does for files. The lines show as
+plain text at once and their colours follow. The worker script has to come from the app's bundler,
+so the app starts it:
+
+```tsx
+import { CodeWorkerProvider } from "@orz/ui-code";
+import PierreWorker from "@pierre/diffs/worker/worker.js?worker"; // Vite
+
+<CodeWorkerProvider workerFactory={() => new PierreWorker()}>{app}</CodeWorkerProvider>
+```
+
+Without a provider those blocks tokenize on the main thread, as every other block does. The pool
+is a page-wide singleton of two workers, created from the first factory and terminated when the
+last block using it unmounts. `offThread` only pays off with a height cap in `className`:
+uncapped, laying out every line of 1 MiB still held the main thread for 2.2 s.
+
+`CodeDiffBlock` is a unified line diff of one block; with identical sides it renders a `CodeBlock`.
+
+### `codeContent`
+
+The renderer this package contributes to `@orz/ui-content`'s registry. It
+accepts every inline source, whatever its `lang`, and every file `isTextFile` calls text, in either
+placement:
+
+- An inline source, such as a markdown fence, is a `CodeBlock` named `fenceFilename(lang)`.
+- A file is loaded through `useSourceText` and drawn as a `CodeBlock` under its own name, with
+  line numbers and without its final newline, tokenized off the main thread when a
+  `CodeWorkerProvider` is mounted, and capped to the viewer's pane or a card's collapsed body. While it loads, it is the registry's fallback: a
+  download link, or the bare name when there is no `url`. A failed load shows that fallback, the
+  error and a Retry button.
+
+It takes everything a narrower renderer would, so it goes after them in the list:
+
+```tsx
+import { codeContent } from "@orz/ui-code";
+import { ContentRenderers } from "@orz/ui-content";
+import { markdownContent } from "@orz/ui-markdown";
+import { mermaidContent } from "@orz/ui-mermaid";
+
+const RENDERERS = [mermaidContent, markdownContent(), codeContent];
+
+<ContentRenderers renderers={RENDERERS}>{app}</ContentRenderers>;
+```
+
+It highlights at most `TEXT_PREVIEW_MAX_BYTES` (1 MiB, from `@orz/ui-content`), so a path that
+reaches it with a large file cannot freeze the tab:
+
+- A file whose `size` is over `TEXT_PREVIEW_HARD_MAX_BYTES` (10 MiB) is not loaded: it draws the
+  registry's fallback and "This file is too large to preview."
+- Text over 1 MiB, declared or found once loaded, is drawn plain: still a virtualized code view
+  with line numbers for a file, but with no highlighting, which is what costs. A file's plain view
+  is capped at the viewer's pane height, or at a card's collapsed height in a document. The viewer
+  and `attachmentCard` ask before they draw a file that large.
+
+### `patchContent`
+
+Draws a unified diff as one diff per file, each commit's subject, author, date and hash in a row
+above its message and files, with a file list (with `+`/`−` counts, jumping to a file) and a *raw*
+toggle back to the text as written. It accepts a source tagged `diff` or `patch` (a fenced block)
+and a file `isPatchFile` calls a patch, in either placement, so it goes before `codeContent`:
+
+```tsx
+const RENDERERS = [attachmentCard(), markdownContent(), patchContent, codeContent];
+```
+
+- `format-patch` mail, `show` / `log -p` output and a plain `diff -u` all read. The mail headers
+  and the `--stat` are left to *raw*; a `diff` command line or an `Index:` banner above a plain diff
+  names no commit.
+- Parsing is strict: a hunk whose line counts do not add up, or text with no file in it, shows the
+  text instead, rather than a patch with a change silently missing. A fence that is not a patch,
+  such as a bare `+`/`-` snippet, stays highlighted text; a file that is not one says so above it.
+- The file list and *raw* go into the title bar a surrounding surface lends (`useContentTitleBar`;
+  `attachmentCard` lends its card's). With none, the patch draws a framed bar of its own, which is
+  what a fence gets, so a fence inside a markdown card never takes over the card's bar.
+- The diffs scroll inside a height-capped box, which is what lets pierre virtualize them: 70vh in a
+  document, the viewer's 75vh pane less its bar (maximized too, for now). Inside a card, whose
+  collapsed body hides its overflow, they do not scroll and the file list does not jump; the card
+  expands instead. That assumes the card's `collapsedClassName` caps it below one screen: past it,
+  the patch is cut at one screen.
+- A file diff over `LARGE_DIFF_LINES` (2,000) changed lines is drawn as its header row with a
+  *Load diff* button, unless it is the patch's only file: not for speed (a 40,000-line file drew in
+  0.1 s) but so a generated file does not bury the files around it.
+- A file is loaded and capped as `codeContent` caps it, except that a patch up to 10 MiB is never
+  asked about: its view is virtualized per file, and a 20 MiB one held the tab for 0.6 s at most.
+
+`PatchView` is the same view on its own, for a surface outside the registry:
+
+```tsx
+<PatchView filename="fix.patch" text={text} lineNumbers invalidNote titleBar={bar} />
+```
+
+### `@orz/ui-code/word-diff`
+
+Importing it pulls in neither React nor pierre.
+
+```ts
+import { coalescedWordDiff, wordDiff } from "@orz/ui-code/word-diff";
+
+const { ins, del } = coalescedWordDiff(oldText, newText);
+// ins: [start, end) ranges in newText
+// del: { at, from, to }, a caret in newText and the deleted range in oldText
+```
+
+`wordDiff` is the bare word-level diff, for measuring how much changed. `coalescedWordDiff` folds
+anchors lighter than the changes around them into those changes, which is what a reader should see
+for a heavily rewritten line.
+
+## Your own pierre surfaces
+
+To render a pierre surface of your own that matches these blocks, build its options from the same
+pieces. Naming the same `preferredHighlighter` is what keeps it on the shared singleton:
+
+```tsx
+import {
+  LazyMultiFileDiff,
+  PIERRE_HIGHLIGHTER,
+  PIERRE_THEME_TYPE,
+  useSyntaxTheme,
+} from "@orz/ui-code";
+
+const theme = useSyntaxTheme();
+const options = useMemo(
+  () => ({
+    theme,
+    themeType: PIERRE_THEME_TYPE,
+    preferredHighlighter: PIERRE_HIGHLIGHTER,
+  }),
+  [theme],
+);
+
+<Suspense>
+  <LazyMultiFileDiff oldFile={oldFile} newFile={newFile} options={options} />
+</Suspense>;
+```
+
+## Failures
+
+- While pierre's chunk loads and until it renders its first line, the block shows its text as a
+  plain `<pre>`.
+- When highlighting fails, the block falls back to the same plain text and logs one `console.warn`
+  naming the file.
+- A highlight that fails in the background leaves the plain text up, with no warning: pierre 1.6
+  only logs those itself.

package/dist/capped-code-block.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether `text` takes more than `max` bytes as UTF-8, counted without encoding it, and stopping
+ * as soon as it is over.
+ */
+export declare function exceedsBytes(text: string, max: number): boolean;
+/**
+ * Highlights `contents` when it is within the cap, and draws it as plain text otherwise: pierre
+ * over a multi-megabyte text would freeze the tab (T-31), where plain text costs next to nothing.
+ * Plain text is still a virtualized code view, so it needs `capClassName` to bound its height:
+ * laying out every line of a large file is a cost of its own. With `offThread`, highlighted text
+ * tokenizes in the worker a `CodeWorkerProvider` lends, inside that same cap.
+ */
+export declare function CappedCodeBlock({ filename, contents, lineNumbers, capClassName, offThread, }: {
+    filename: string;
+    contents: string;
+    lineNumbers?: boolean;
+    /** The box a text over the cap is drawn in; a height cap with its own overflow. */
+    capClassName?: string;
+    offThread?: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=capped-code-block.d.ts.map

package/dist/capped-code-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capped-code-block.d.ts","sourceRoot":"","sources":["../src/capped-code-block.tsx"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAiB/D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,SAAiB,GAClB,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,+BAeA"}

package/dist/capped-code-block.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TEXT_PREVIEW_MAX_BYTES } from "@orz/ui-content";
+import { useMemo } from "react";
+import { CodeBlock } from "./code-block.js";
+/**
+ * Whether `text` takes more than `max` bytes as UTF-8, counted without encoding it, and stopping
+ * as soon as it is over.
+ */
+export function exceedsBytes(text, max) {
+    // Every UTF-16 unit is at least one byte and at most three.
+    if (text.length > max)
+        return true;
+    if (text.length * 3 <= max)
+        return false;
+    let bytes = 0;
+    for (let i = 0; i < text.length; i++) {
+        const unit = text.charCodeAt(i);
+        // A surrogate is half of a four-byte character.
+        bytes +=
+            unit < 0x80
+                ? 1
+                : unit < 0x800 || (unit >= 0xd800 && unit < 0xe000)
+                    ? 2
+                    : 3;
+        if (bytes > max)
+            return true;
+    }
+    return false;
+}
+/**
+ * Highlights `contents` when it is within the cap, and draws it as plain text otherwise: pierre
+ * over a multi-megabyte text would freeze the tab (T-31), where plain text costs next to nothing.
+ * Plain text is still a virtualized code view, so it needs `capClassName` to bound its height:
+ * laying out every line of a large file is a cost of its own. With `offThread`, highlighted text
+ * tokenizes in the worker a `CodeWorkerProvider` lends, inside that same cap.
+ */
+export function CappedCodeBlock({ filename, contents, lineNumbers, capClassName, offThread = false, }) {
+    const tooLarge = useMemo(() => exceedsBytes(contents, TEXT_PREVIEW_MAX_BYTES), [contents]);
+    return (_jsx(CodeBlock, { filename: filename, contents: contents, lineNumbers: lineNumbers, plain: tooLarge, offThread: offThread, className: tooLarge || offThread ? capClassName : undefined }));
+}
+//# sourceMappingURL=capped-code-block.js.map

package/dist/capped-code-block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capped-code-block.js","sourceRoot":"","sources":["../src/capped-code-block.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAkB,CAAC;AAE7C;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,GAAW;IACpD,4DAA4D;IAC5D,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG;QAAE,OAAO,IAAI,CAAC;IACnC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG;QAAE,OAAO,KAAK,CAAC;IACzC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,gDAAgD;QAChD,KAAK;YACH,IAAI,GAAG,IAAI;gBACT,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,IAAI,GAAG,KAAK,IAAI,CAAC,IAAI,IAAI,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC;oBACjD,CAAC,CAAC,CAAC;oBACH,CAAC,CAAC,CAAC,CAAC;QACV,IAAI,KAAK,GAAG,GAAG;YAAE,OAAO,IAAI,CAAC;IAC/B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,EAC9B,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,SAAS,GAAG,KAAK,GAQlB;IACC,MAAM,QAAQ,GAAG,OAAO,CACtB,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,sBAAsB,CAAC,EACpD,CAAC,QAAQ,CAAC,CACX,CAAC;IACF,OAAO,CACL,KAAC,SAAS,IACR,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,GAC3D,CACH,CAAC;AACJ,CAAC"}

package/dist/code-block.d.ts

@@ -0,0 +1,147 @@
+import type { CodeViewItem, ParsedPatch } from "@pierre/diffs";
+import type { CodeViewHandle, MultiFileDiffProps } from "@pierre/diffs/react";
+import { type ComponentType, type ReactNode, type Ref } from "react";
+export declare const LazyMultiFileDiff: import("react").LazyExoticComponent<ComponentType<MultiFileDiffProps<undefined, undefined>>>;
+/**
+ * A unified diff split into commits and their files, or null when the text is
+ * not one. Strict on purpose: pierre's lenient mode skips a hunk whose counts
+ * do not add up and carries on, so the reader would be shown a patch with a
+ * change silently missing. Text before the first file — a commit message — is
+ * no reason to refuse; a patch with no file in it is.
+ */
+export declare function parsePatch(text: string): Promise<ParsedPatch[] | null>;
+export declare const PIERRE_THEME: {
+    readonly dark: "pierre-dark";
+    readonly light: "pierre-light";
+};
+/**
+ * "system" makes pierre inject no color-scheme pin of its own; the actual
+ * scheme is forced from the outer tree by the `diffs-container` rules in
+ * this package's styles.css, which follow the app theme (T-36). Options objects that
+ * captured this value at module scope stay correct for the same reason.
+ */
+export declare const PIERRE_THEME_TYPE: "system";
+export type SyntaxTheme = {
+    light: string;
+    dark: string;
+};
+/**
+ * Syntax token colors for the active theme (T-144). Under "system" each slot
+ * takes its own palette's shiki theme, because the light/dark choice is then
+ * made by CSS light-dark() inside the shadow root rather than by a React
+ * render. A pinned mode or a one-palette theme fills both slots from the side
+ * on screen: the slot the browser will not paint is irrelevant. A palette
+ * with no shiki theme keeps that slot of pierre's own pair.
+ */
+export declare function useSyntaxTheme(): SyntaxTheme;
+/** The shape every code surface falls back to: the code, unhighlighted. */
+export declare function PlainCodeFallback({ contents }: {
+    contents: string;
+}): import("react").JSX.Element;
+/**
+ * pierre defaults to "shiki-js", which transpiles the TextMate grammars'
+ * Oniguruma patterns into native RegExp through oniguruma-to-es. That
+ * transpiler is a recursive-descent pass over patterns, and the TypeScript
+ * grammar's giant lookaheads overflow SpiderMonkey's much shallower stack:
+ * Firefox rendered `too much recursion` in place of every `ts` fence
+ * (T-177). The wasm build is real Oniguruma and never runs that pass.
+ *
+ * pierre's highlighter is a module singleton whose engine is fixed by
+ * whichever surface creates it first, so every options object in the app has
+ * to name the same one — snippets, files, and the revision diff alike.
+ */
+export declare const PIERRE_HIGHLIGHTER: "shiki-wasm";
+/** px; the header rows `PatchFiles` callers draw must be exactly this tall. */
+export declare const PATCH_HEADER_HEIGHT = 36;
+/**
+ * A synthetic filename whose extension carries the fence's language.
+ * Passing the tag as `lang` instead would reject on unknown languages;
+ * filename inference degrades to plain text.
+ */
+export declare function fenceFilename(tag: string | undefined): string;
+/**
+ * Read-only code rendering through pierre CodeView: syntax highlighting
+ * from the filename, dark/light theme in step with the revision diffs.
+ * Until pierre renders its first line a plain `<pre>` shows the same text, so
+ * content stays readable through both chunk loading and highlighter startup.
+ *
+ * pierre's virtualization scaffold declares `contain: inline-size`, so this
+ * block contributes 0px to an ancestor's intrinsic width: in a content-sized
+ * column (horizontal flex item, table cell, `max-content`) the code wraps at
+ * the width of the prose beside it — 30 lines came out 5416px tall in a 109px
+ * column, and a fence with no prose left the column 0px wide (T-287). Any such
+ * column has to be made to fill its row.
+ */
+export declare function CodeBlock({ filename, contents, lineNumbers, plain, offThread, className, }: {
+    filename: string;
+    contents: string;
+    /** Line numbers suit whole files; snippets read better without. */
+    lineNumbers?: boolean;
+    /**
+     * No highlighting. Tokenizing is what costs: virtualized lines spare the
+     * DOM, but pierre tokenizes the whole file regardless, 11 s for 1 MiB of
+     * log where plain text took 0.16 s.
+     */
+    plain?: boolean;
+    /**
+     * Tokenize in pierre's worker pool, when a `CodeWorkerProvider` lends one.
+     * Only pays off with `className` capping the height: uncapped, laying out
+     * every line of 1 MiB still held the main thread for 2.2 s.
+     */
+    offThread?: boolean;
+    /** Caps the height for a long file: CodeView virtualizes against its box. */
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * One code block shown as the line-level diff between two versions of it:
+ * red for the lines the baseline had, green for the ones that replaced them
+ * (T-343).
+ *
+ * Nothing is injected into the code. pierre is handed both bodies as plain
+ * strings and does its own diffing, highlighting and theming, so T-31's
+ * constraint — a mark reaching inside a fence deletes the code it wraps — is
+ * never engaged.
+ */
+export declare function CodeDiffBlock({ filename, before, after, }: {
+    filename: string;
+    before: string;
+    after: string;
+}): import("react").JSX.Element;
+/** The CodeView item id of a patch's `index`-th file, counted across commits. */
+export declare function patchFileId(index: number): string;
+/** The CodeView item id of a commit's message, counted across the patch. */
+export declare function patchCommitId(index: number): string;
+/**
+ * A parsed patch in one virtualized CodeView: per commit, its message, then
+ * one diff per file.
+ *
+ * `className` must cap the height. CodeView virtualizes against its own box,
+ * so an uncapped one grows to the whole patch and lays every line out: a
+ * 1 MB, 116-file patch froze the tab for 15 s in one task that way, against
+ * under 0.3 s capped.
+ *
+ * A highlighter failure takes the whole patch back to its plain text rather
+ * than one file: the grammar that failed is likely shared by its neighbours.
+ */
+export declare function PatchFiles({ patches, messages, text, className, viewRef, collapsedFiles, renderHeader, }: {
+    patches: ParsedPatch[];
+    /**
+     * Each patch's commit message, index for index with `patches`, drawn as an
+     * item of its own above its files: an empty one is only its header row, and
+     * null gets no item at all.
+     */
+    messages: (string | null)[];
+    /** The patch as written, for the plain-text fallback. */
+    text: string;
+    className: string;
+    /** For scrolling to an item by `patchFileId`. */
+    viewRef?: Ref<CodeViewHandle<undefined, undefined>>;
+    /** Files, by position across the patch, drawn as their header row only. */
+    collapsedFiles?: ReadonlySet<number>;
+    /**
+     * Every item's header row, `PATCH_HEADER_HEIGHT` tall: pierre reserves that
+     * height for it without measuring.
+     */
+    renderHeader: (item: CodeViewItem<undefined>) => ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=code-block.d.ts.map

package/dist/code-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block.d.ts","sourceRoot":"","sources":["../src/code-block.tsx"],"names":[],"mappings":"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"}