@vite-hub/ui 0.0.3 → 0.1.0

package/dist/code-view-vDM-hph-.d.ts

@@ -0,0 +1,4091 @@
+import { BundledLanguage, BundledTheme, HighlighterGeneric } from "shiki";
+import "shiki/core";
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/node_modules/.pnpm/@types_unist@3.0.3/node_modules/@types/unist/index.d.ts
+//#region ../../node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
+// ## Interfaces
+/**
+ * Info associated with nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or specifications
+ * implementing unist.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'unist' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data$1 {}
+/**
+ * One place in a source file.
+ */
+interface Point {
+  /**
+   * Line in a source file (1-indexed integer).
+   */
+  line: number;
+  /**
+   * Column in a source file (1-indexed integer).
+   */
+  column: number;
+  /**
+   * Character in a source file (0-indexed integer).
+   */
+  offset?: number | undefined;
+}
+/**
+ * Position of a node in a source document.
+ *
+ * A position is a range between two points.
+ */
+interface Position$1 {
+  /**
+   * Place of the first character of the parsed source region.
+   */
+  start: Point;
+  /**
+   * Place of the first character after the parsed source region.
+   */
+  end: Point;
+}
+/**
+ * Abstract unist node.
+ *
+ * The syntactic unit in unist syntax trees are called nodes.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a `thematicBreak` (`***`), is neither literal
+ * nor parent, but still a node.
+ */
+interface Node$2 {
+  /**
+   * Node type.
+   */
+  type: string;
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data$1 | undefined;
+  /**
+   * Position of a node in a source document.
+   *
+   * Nodes that are generated (not in the original source document) must not
+   * have a position.
+   */
+  position?: Position$1 | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/node_modules/.pnpm/@types_hast@3.0.4/node_modules/@types/hast/index.d.ts
+//#region ../../node_modules/.pnpm/@types+hast@3.0.4/node_modules/@types/hast/index.d.ts
+// ## Interfaces
+/**
+ * Info associated with hast nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or hast.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'hast' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data extends Data$1 {}
+/**
+ * Info associated with an element.
+ */
+interface Properties {
+  [PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
+}
+// ## Content maps
+/**
+ * Union of registered hast nodes that can occur in {@link Element}.
+ *
+ * To register mote custom hast nodes, add them to {@link ElementContentMap}.
+ * They will be automatically added here.
+ */
+type ElementContent = ElementContentMap[keyof ElementContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Element}.
+ *
+ * For a union of all {@link Element} children, see {@link ElementContent}.
+ */
+interface ElementContentMap {
+  comment: Comment;
+  element: Element$1;
+  text: Text;
+}
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap}.
+ * They will be automatically added here.
+ */
+type RootContent = RootContentMap[keyof RootContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Root}.
+ *
+ * > 👉 **Note**: {@link Root} does not need to be an entire document.
+ * > it can also be a fragment.
+ *
+ * For a union of all {@link Root} children, see {@link RootContent}.
+ */
+interface RootContentMap {
+  comment: Comment;
+  doctype: Doctype;
+  element: Element$1;
+  text: Text;
+}
+// ## Abstract nodes
+/**
+ * Abstract hast node.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in HTML, a `Doctype` is neither literal nor parent, but
+ * still a node.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant (such as {@link ElementContentMap}).
+ *
+ * For a union of all registered hast nodes, see {@link Nodes}.
+ */
+interface Node$1 extends Node$2 {
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data | undefined;
+}
+/**
+ * Abstract hast node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast literals, see {@link Literals}.
+ */
+interface Literal extends Node$1 {
+  /**
+   * Plain-text value.
+   */
+  value: string;
+}
+/**
+ * Abstract hast node that contains other hast nodes (*children*).
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast parents, see {@link Parents}.
+ */
+interface Parent extends Node$1 {
+  /**
+   * List of children.
+   */
+  children: RootContent[];
+}
+// ## Concrete nodes
+/**
+ * HTML comment.
+ */
+interface Comment extends Literal {
+  /**
+   * Node type of HTML comments in hast.
+   */
+  type: "comment";
+  /**
+   * Data associated with the comment.
+   */
+  data?: CommentData | undefined;
+}
+/**
+ * Info associated with hast comments by the ecosystem.
+ */
+interface CommentData extends Data {}
+/**
+ * HTML document type.
+ */
+interface Doctype extends Node$2 {
+  /**
+   * Node type of HTML document types in hast.
+   */
+  type: "doctype";
+  /**
+   * Data associated with the doctype.
+   */
+  data?: DoctypeData | undefined;
+}
+/**
+ * Info associated with hast doctypes by the ecosystem.
+ */
+interface DoctypeData extends Data {}
+/**
+ * HTML element.
+ */
+interface Element$1 extends Parent {
+  /**
+   * Node type of elements.
+   */
+  type: "element";
+  /**
+   * Tag name (such as `'body'`) of the element.
+   */
+  tagName: string;
+  /**
+   * Info associated with the element.
+   */
+  properties: Properties;
+  /**
+   * Children of element.
+   */
+  children: ElementContent[];
+  /**
+   * When the `tagName` field is `'template'`, a `content` field can be
+   * present.
+   */
+  content?: Root | undefined;
+  /**
+   * Data associated with the element.
+   */
+  data?: ElementData | undefined;
+}
+/**
+ * Info associated with hast elements by the ecosystem.
+ */
+interface ElementData extends Data {}
+/**
+ * Document fragment or a whole document.
+ *
+ * Should be used as the root of a tree and must not be used as a child.
+ *
+ * Can also be used as the value for the content field on a `'template'` element.
+ */
+interface Root extends Parent {
+  /**
+   * Node type of hast root.
+   */
+  type: "root";
+  /**
+   * Children of root.
+   */
+  children: RootContent[];
+  /**
+   * Data associated with the hast root.
+   */
+  data?: RootData | undefined;
+}
+/**
+ * Info associated with hast root nodes by the ecosystem.
+ */
+interface RootData extends Data {}
+/**
+ * HTML character data (plain text).
+ */
+interface Text extends Literal {
+  /**
+   * Node type of HTML character data (plain text) in hast.
+   */
+  type: "text";
+  /**
+   * Data associated with the text.
+   */
+  data?: TextData | undefined;
+}
+/**
+ * Info associated with hast texts by the ecosystem.
+ */
+interface TextData extends Data {}
+//#endregion
+//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/types.d.ts
+interface ChangeObject<ValueT> {
+  /**
+   * The concatenated content of all the tokens represented by this change object - i.e. generally the text that is either added, deleted, or common, as a single string.
+   * In cases where tokens are considered common but are non-identical (e.g. because an option like `ignoreCase` or a custom `comparator` was used), the value from the *new* string will be provided here.
+   */
+  value: ValueT;
+  /**
+   * true if the value was inserted into the new string, otherwise false
+   */
+  added: boolean;
+  /**
+   * true if the value was removed from the old string, otherwise false
+   */
+  removed: boolean;
+  /**
+   * How many tokens (e.g. chars for `diffChars`, lines for `diffLines`) the value in the change object consists of
+   */
+  count: number;
+}
+interface CommonDiffOptions {
+  /**
+   * If `true`, the array of change objects returned will contain one change object per token (e.g. one per line if calling `diffLines`), instead of runs of consecutive tokens that are all added / all removed / all conserved being combined into a single change object.
+   */
+  oneChangePerToken?: boolean;
+}
+type DiffCallbackNonabortable<T> = (result: ChangeObject<T>[]) => void;
+interface DiffLinesOptions extends CommonDiffOptions {
+  /**
+   * `true` to remove all trailing CR (`\r`) characters before performing the diff.
+   * This helps to get a useful diff when diffing UNIX text files against Windows text files.
+   * @default false
+   */
+  stripTrailingCr?: boolean;
+  /**
+   * `true` to treat the newline character at the end of each line as its own token.
+   * This allows for changes to the newline structure to occur independently of the line content and to be treated as such.
+   * In general this is the more human friendly form of `diffLines`; the default behavior with this option turned off is better suited for patches and other computer friendly output.
+   *
+   * Note that while using `ignoreWhitespace` in combination with `newlineIsToken` is not an error, results may not be as expected.
+   * With `ignoreWhitespace: true` and `newlineIsToken: false`, changing a completely empty line to contain some spaces is treated as a non-change, but with `ignoreWhitespace: true` and `newlineIsToken: true`, it is treated as an insertion.
+   * This is because the content of a completely blank line is not a token at all in `newlineIsToken` mode.
+   *
+   * @default false
+   */
+  newlineIsToken?: boolean;
+  /**
+   * `true` to ignore a missing newline character at the end of the last line when comparing it to other lines.
+   * (By default, the line `'b\n'` in text `'a\nb\nc'` is not considered equal to the line `'b'` in text `'a\nb'`; this option makes them be considered equal.)
+   * Ignored if `ignoreWhitespace` or `newlineIsToken` are also true.
+   * @default false
+   */
+  ignoreNewlineAtEof?: boolean;
+  /**
+   * `true` to ignore leading and trailing whitespace characters when checking if two lines are equal.
+   * @default false
+   */
+  ignoreWhitespace?: boolean;
+}
+interface DiffLinesOptionsNonabortable extends DiffLinesOptions {
+  /**
+   * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
+   * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
+   */
+  callback?: DiffCallbackNonabortable<string>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/patch/create.d.ts
+interface HeaderOptions {
+  includeIndex: boolean;
+  includeUnderline: boolean;
+  includeFileHeaders: boolean;
+}
+type CreatePatchCallbackNonabortable = (patch: string) => void;
+interface CreatePatchOptionsNonabortable extends Pick<DiffLinesOptionsNonabortable, 'ignoreWhitespace' | 'stripTrailingCr'> {
+  context?: number;
+  callback?: CreatePatchCallbackNonabortable;
+  headerOptions?: HeaderOptions;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/types.d.ts
+//#region src/types.d.ts
+type CodeViewScrollBehavior = 'instant' | 'smooth' | 'smooth-auto';
+/**
+ * Represents a file's contents for generating diffs via `parseDiffFromFile` or
+ * for when rendering a file directly using the File components
+ */
+interface FileContents {
+  /** Filename used for display in headers and for inferring the language for
+   * syntax highlighting. */
+  name: string;
+  /** The raw text contents of the file. */
+  contents: string;
+  /** Explicitly set the syntax highlighting language instead of inferring from
+   * filename. Generally you should not be setting this. */
+  lang?: SupportedLanguages;
+  /** Optional header passed to the jsdiff library's `createTwoFilesPatch`. */
+  header?: string;
+  /** Identifies a file for worker pool highlight caching. */
+  cacheKey?: string;
+}
+interface FileDiffLoadedChangedFiles {
+  oldFile: FileContents;
+  newFile: FileContents;
+}
+interface FileDiffLoadedPureRenamedFile {
+  oldFile: null;
+  newFile: FileContents;
+}
+type FileDiffLoadedFiles = FileDiffLoadedChangedFiles | FileDiffLoadedPureRenamedFile;
+type DiffFileInput = {
+  oldFile: FileContents;
+  newFile: FileContents;
+} | {
+  oldFile: null;
+  newFile: FileContents;
+} | {
+  oldFile: FileContents;
+  newFile: null;
+};
+type MaybeDiffFileInput = DiffFileInput | {
+  oldFile?: undefined;
+  newFile?: undefined;
+};
+type FileDiffContentsLoader = (fileDiff: FileDiffMetadata) => Promise<FileDiffLoadedFiles>;
+type HighlighterTypes = 'shiki-js' | 'shiki-wasm';
+type HighlightedToken = [char: number, fg: string, text: string];
+type DiffsThemeNames = BundledTheme | (string & {});
+type ThemesType = Record<'dark' | 'light', DiffsThemeNames>;
+/**
+ * A Shiki highlighter instance configured with the library's supported
+ * languages and themes. Used internally to generate syntax-highlighted AST
+ * from file contents. By default diffs will ensure that only 1 highlighter is
+ * instantiated per thread and shared for all syntax highlighting.  This
+ * applies to the main thread and worker threads.
+ */
+type DiffsHighlighter = HighlighterGeneric<SupportedLanguages, DiffsThemeNames>;
+/**
+ * Describes the type of change for a file in a diff.
+ * - `change`: File content was modified, name unchanged.
+ * - `rename-pure`: File was renamed/moved without content changes (100% similarity).
+ * - `rename-changed`: File was renamed/moved and content was also modified.
+ * - `new`: A new file was added.
+ * - `deleted`: An existing file was removed.
+ */
+type ChangeTypes = 'change' | 'rename-pure' | 'rename-changed' | 'new' | 'deleted';
+/**
+ * Represents a parsed patch file, typically corresponding to a single commit.
+ * Returned by `parsePatchFiles` when parsing raw patch/diff strings.
+ */
+interface ParsedPatch {
+  /** Optional raw introductory text before the file diffs that may have been
+   * included in the patch (e.g., commit message, author, date). */
+  patchMetadata?: string;
+  /** Array of file changes contained in the patch. */
+  files: FileDiffMetadata[];
+}
+/**
+ * Represents a block of unchanged context lines within a hunk.  Basically a
+ * batch of lines in a hunk that are prefixed with a space ` `.  Consecutive
+ * lines prefixed with a ` ` are grouped together into a single ContextContent.
+ */
+interface ContextContent {
+  type: 'context';
+  /** Number of unchanged lines in this context block. */
+  lines: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.additionLines` where this context
+   * block starts.
+   */
+  additionLineIndex: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.deletionLines` where this context
+   * block starts.
+   */
+  deletionLineIndex: number;
+}
+/**
+ * Represents a block of changes (additions and/or deletions) within a hunk.
+ * Consecutive `+` and `-` lines are grouped together into a single
+ * ChangeContent.
+ */
+interface ChangeContent {
+  type: 'change';
+  /** Number of lines prefixed with `-` in this change block. */
+  deletions: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.deletionLines` where the deleted
+   * lines start.
+   */
+  deletionLineIndex: number;
+  /** Number of lines prefixed with `+` in this change block. */
+  additions: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.additionLines` where the added
+   * lines start.
+   */
+  additionLineIndex: number;
+}
+/**
+ * Represents a single hunk from a diff, corresponding to
+ * one `@@ ... @@` block.
+ */
+interface Hunk {
+  /**
+   * Number of unchanged lines between the previous hunk (or file start) and
+   * this hunk.
+   */
+  collapsedBefore: number;
+  /**
+   * Starting line number in the new file version, parsed from the `+X`
+   * in the hunk header.
+   */
+  additionStart: number;
+  /**
+   * Total line count in the new file version for this hunk, parsed from
+   * `+X,count` in the hunk header.  If this hunk was viewed in `diffStyle:
+   * split` this would correspond to the number of lines in the right
+   * `additions` column.  It includes both `context` lines and lines
+   * prefixed with `+`.
+   */
+  additionCount: number;
+  /** This corresponds to the number of lines prefixed with `+` in this hunk. */
+  additionLines: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.additionLines` where this hunk's
+   * content starts.
+   */
+  additionLineIndex: number;
+  /**
+   * Starting line number in the old file version, parsed from the `-X`
+   * in the hunk header.
+   */
+  deletionStart: number;
+  /**
+   * Total line count in the old file version for this hunk, parsed from
+   * `-X,count` in the hunk header.  If this hunk was viewed in `diffStyle:
+   * split` this would correspond to the number of lines in the left
+   * `deletions` column.  It includes both `context` lines and lines
+   * prefixed with `-`.
+   */
+  deletionCount: number;
+  /** This corresponds to the number of lines prefixed with `-` in this hunk. */
+  deletionLines: number;
+  /**
+   * Zero-based index into `FileDiffMetadata.deletionLines` where this hunk's
+   * content starts.
+   */
+  deletionLineIndex: number;
+  /**
+   * Array of content segments within this hunk, each representing either
+   * a context line group or a change group.
+   */
+  hunkContent: (ContextContent | ChangeContent)[];
+  /**
+   * Function/method name that appears after the `@@` markers if it existed in
+   * the diff.
+   */
+  hunkContext?: string;
+  /** Raw hunk header string (e.g., `@@ -1,5 +1,7 @@`). */
+  hunkSpecs?: string;
+  /**
+   * Starting line index for this hunk when rendered in split (side-by-side)
+   * view.
+   */
+  splitLineStart: number;
+  /** Total rendered line count for this hunk in split view. */
+  splitLineCount: number;
+  /** Starting line index for this hunk when rendered in unified view. */
+  unifiedLineStart: number;
+  /** Total rendered line count for this hunk in unified view. */
+  unifiedLineCount: number;
+  /**
+   * True if the old file version has no trailing newline at end of file.  This
+   * is parsed from the patch file directly at the end of the hunk.  If the
+   * final hunkContent is a `context` group, then both values will be true or
+   * false together.  If it's from a `change` content group, then it may differ
+   * depending on the patch.
+   */
+  noEOFCRDeletions: boolean;
+  /**
+   * True if the new file version has no trailing newline at end of file.  This
+   * is parsed from the patch file directly at the end of the hunk.  If the
+   * final hunkContent is a `context` group, then both values will be true or
+   * false together.  If it's from a `change` content group, then it may differ
+   * depending on the patch.
+   */
+  noEOFCRAdditions: boolean;
+}
+/**
+ * Metadata and content for a single file's diff.  Think of this as a JSON
+ * compatible representation of a diff for a single file.
+ *
+ * When a renderer uses `loadDiffFiles` to hydrate a partial diff, it upgrades
+ * this metadata object in place. Keep the same object identity stable when
+ * callers want that hydrated state to persist across later renders.
+ */
+interface FileDiffMetadata {
+  /** The file's name and path. */
+  name: string;
+  /** Previous file path, present only if file was renamed or moved. */
+  prevName?: string;
+  /**
+   * Explicitly override the syntax highlighting language instead of inferring
+   * from filename.  This will never be set by default, since all internal diff
+   * APIs will attempt to detect the language automatically.  If you'd like to
+   * specify a language override, you can do so via the method `setLanguageOverride`
+   */
+  lang?: SupportedLanguages;
+  /**
+   * Object ID for the new file content parsed from the `index` line in a
+   * patch file.
+   */
+  newObjectId?: string;
+  /**
+   * Object ID for the previous file content parsed from the `index` line in a
+   * patch file.
+   */
+  prevObjectId?: string;
+  /**
+   * Git file mode parsed from the diff (e.g., `100644` for regular files) when
+   * present in the patch metadata.
+   */
+  mode?: string;
+  /** Previous git file mode, present if the mode changed. */
+  prevMode?: string;
+  /** The type of change for this file. */
+  type: ChangeTypes;
+  /** Array of diff hunks containing line-level change information.  Each hunk
+   * corresponds to a `@@ -X,X +X,X @@` group in a diff. */
+  hunks: Hunk[];
+  /** Pre-computed line size for this diff if rendered in `split` diffStyle. */
+  splitLineCount: number;
+  /** Pre-computed line size for this diff if rendered in `unified` diffStyle. */
+  unifiedLineCount: number;
+  /**
+   * Whether the diff was parsed from a patch file (true) or generated from
+   * full file contents (false).
+   *
+   * When true, `deletionLines`/`additionLines` contain only the lines present
+   * in the patch and hunk expansion is unavailable.
+   *
+   * When false, they contain the complete file contents.
+   *
+   * A hydrating renderer mutates a partial metadata object to flip this to
+   * false after `loadDiffFiles` resolves. Passing a freshly parsed partial
+   * object later is treated as a new partial render model.
+   */
+  isPartial: boolean;
+  /**
+   * Array of lines from previous version of the file. If `isPartial` is false,
+   * it means that `deletionLines` can be considered the entire contents of the
+   * old version of the file.  Otherwise `deletionLines` will just be an array
+   * of all the content processed from the `context` and `deletion` lines of
+   * the patch.
+   */
+  deletionLines: string[];
+  /**
+   * Array of lines from new version of the file. If `isPartial` is false, it
+   * means that `additionLines` can be considered the entire contents of the
+   * new version of the file.  Otherwise `additionLines` will just be an array
+   * of all the content processed from the `context` and `addition` lines of
+   * the patch.
+   */
+  additionLines: string[];
+  /**
+   * Set while an attached editor's session-scoped hunk updates have reshaped
+   * `hunks` away from a plain recompute (regions stay frozen during an edit
+   * session). Consumed by the session-exit recompute, which restores
+   * recompute-shaped hunks and clears the flag. It lives on the metadata so
+   * it survives instance recycling and pooling.
+   *
+   * @internal
+   */
+  editSessionDirty?: boolean;
+  /**
+   * This unique key is only used for Worker Pools to avoid subsequent requests
+   * to highlight if we've already highlighted the diff.  Please note that if
+   * you modify the contents of the diff in any way, you will need to update
+   * the `cacheKey`.
+   *
+   * When `loadDiffFiles` hydrates a partial diff, Diffs uses loaded file cache
+   * keys when they are available so full-file highlights can be reused. If the
+   * loaded files are unkeyed and this partial key exists, Diffs appends a
+   * hydration segment as a fallback.
+   */
+  cacheKey?: string;
+}
+type MergeConflictMarkerRowType = 'marker-start' | 'marker-base' | 'marker-separator' | 'marker-end';
+interface MergeConflictMarkerRow {
+  type: MergeConflictMarkerRowType;
+  hunkIndex: number;
+  /** Index into `hunk.hunkContent` for the structural block this row belongs to. */
+  contentIndex: number;
+  conflictIndex: number;
+  lineText: string;
+  /** Unified rendered-row index where this virtual row should be injected. */
+  lineIndex: number;
+}
+type SupportedLanguages = BundledLanguage | 'text' | 'ansi' | (string & {});
+type ThemeTypes = 'system' | 'light' | 'dark';
+type PostRenderPhase = 'mount' | 'update' | 'unmount';
+/**
+ * The `'custom'` variant is deprecated and will be removed in a future version.
+ */
+type HunkSeparators = 'simple' | 'metadata' | 'line-info' | 'line-info-basic' | 'custom';
+type LineDiffTypes = 'word-alt' | 'word-line' | 'word' | 'char' | 'none';
+type DiffIndicators = 'classic' | 'bars' | 'none';
+interface BaseCodeOptions {
+  theme?: DiffsThemeNames | ThemesType;
+  disableLineNumbers?: boolean;
+  overflow?: 'scroll' | 'wrap';
+  themeType?: ThemeTypes;
+  collapsed?: boolean;
+  disableFileHeader?: boolean;
+  disableVirtualizationBuffers?: boolean;
+  stickyHeader?: boolean;
+  preferredHighlighter?: HighlighterTypes;
+  useCSSClasses?: boolean;
+  useTokenTransformer?: boolean;
+  tokenizeMaxLineLength?: number;
+  tokenizeMaxLength?: number;
+  unsafeCSS?: string;
+}
+interface BaseDiffOptions extends BaseCodeOptions {
+  diffStyle?: 'unified' | 'split';
+  diffIndicators?: DiffIndicators;
+  disableBackground?: boolean;
+  hunkSeparators?: HunkSeparators;
+  expandUnchanged?: boolean;
+  /**
+   * Fetches full file contents for partial changed/renamed diffs parsed from
+   * patches. Return both sides for changed diffs and `oldFile: null` for pure
+   * renames. Added/deleted diffs already include their available side and thus
+   * this function serves no purpose in those contexts
+   */
+  loadDiffFiles?: FileDiffContentsLoader;
+  collapsedContextThreshold?: number;
+  lineDiffType?: LineDiffTypes;
+  maxLineDiffLength?: number;
+  expansionLineCount?: number;
+  /**
+   * Options forwarded to the underlying diff algorithm when computing
+   * diffs from file contents (oldFile/newFile) or recomputing edited
+   * diffs. Does not change the hunks in supplied pre-parsed patches.
+   */
+  parseDiffOptions?: CreatePatchOptionsNonabortable;
+}
+type BaseDiffOptionsWithDefaults = Required<Omit<BaseDiffOptions, 'unsafeCSS' | 'preferredHighlighter' | 'parseDiffOptions' | 'loadDiffFiles'>>;
+type CustomPreProperties = Record<string, string | number | undefined>;
+interface PrePropertiesConfig extends Required<Pick<BaseDiffOptions, 'diffIndicators' | 'disableBackground' | 'disableLineNumbers' | 'overflow'>> {
+  type: 'diff' | 'file';
+  split: boolean;
+  totalLines: number;
+  customProperties?: CustomPreProperties;
+}
+type FileHeaderRenderMode = 'default' | 'custom';
+type RenderHeaderMetadataCallback = (fileDiff: FileDiffMetadata) => Element | string | number | null | undefined;
+type RenderHeaderPrefixCallback = (fileDiff: FileDiffMetadata) => Element | string | number | null | undefined;
+type RenderHeaderFilenameSuffixCallback = (fileDiff: FileDiffMetadata) => Element | string | number | null | undefined;
+type RenderFileMetadata = (file: FileContents) => Element | string | number | null | undefined;
+type AnnotationSide = 'deletions' | 'additions';
+type SelectionSide = 'deletions' | 'additions';
+interface SelectedLineRange {
+  start: number;
+  side?: SelectionSide;
+  end: number;
+  endSide?: SelectionSide;
+}
+type OptionalMetadata<LAnnotation> = LAnnotation extends undefined ? {
+  metadata?: undefined;
+} : {
+  metadata: LAnnotation;
+};
+/**
+ * Annotation rendered for a file line. Use `lineNumber: 0` to render a
+ * file-level annotation above the first rendered file line.
+ */
+type LineAnnotation<LAnnotation = undefined> = {
+  lineNumber: number;
+} & OptionalMetadata<LAnnotation>;
+/**
+ * Annotation rendered for one side of a diff line. Use `lineNumber: 0` to
+ * render a side-specific file-level annotation above the first hunk/separator.
+ */
+type DiffLineAnnotation<LAnnotation = undefined> = {
+  side: AnnotationSide;
+  lineNumber: number;
+} & OptionalMetadata<LAnnotation>;
+type CodeViewFileItem<LAnnotation = undefined> = {
+  id: string;
+  type: 'file';
+  file: FileContents;
+  annotations?: LineAnnotation<LAnnotation>[];
+  version?: number;
+  collapsed?: boolean;
+  /**
+   * Put this item into edit mode. Requires `EditProvider` in React or the
+   * CodeView `createEditor` option in vanilla; ignored while `collapsed` is
+   * true. Make sure you bump the version when also changing the value.
+   */
+  edit?: boolean;
+};
+type CodeViewDiffItem<LAnnotation = undefined> = {
+  id: string;
+  type: 'diff';
+  fileDiff: FileDiffMetadata;
+  annotations?: DiffLineAnnotation<LAnnotation>[];
+  version?: number;
+  collapsed?: boolean;
+  /**
+   * Put this item into edit mode. Requires `EditProvider` in React or the
+   * CodeView `createEditor` option in vanilla; ignored while `collapsed` is
+   * true. Make sure you bump the version when also changing the value.
+   */
+  edit?: boolean;
+};
+type CodeViewItem<LAnnotation> = CodeViewFileItem<LAnnotation> | CodeViewDiffItem<LAnnotation>;
+interface CodeViewPositionScrollTarget {
+  type: 'position';
+  position: number;
+  behavior?: CodeViewScrollBehavior;
+}
+interface CodeViewLineScrollTarget {
+  type: 'line';
+  id: string;
+  lineNumber: number;
+  side?: SelectionSide;
+  align?: 'start' | 'center' | 'end' | 'nearest';
+  offset?: number;
+  behavior?: CodeViewScrollBehavior;
+}
+interface CodeViewRangeScrollTarget {
+  type: 'range';
+  id: string;
+  range: SelectedLineRange;
+  align?: 'start' | 'center' | 'end' | 'nearest';
+  offset?: number;
+  behavior?: CodeViewScrollBehavior;
+}
+interface NumericScrollLineAnchor {
+  lineNumber: number;
+  top: number;
+  side?: SelectionSide;
+}
+interface CodeViewItemScrollTarget {
+  type: 'item';
+  id: string;
+  align?: 'start' | 'center' | 'end' | 'nearest';
+  offset?: number;
+  behavior?: CodeViewScrollBehavior;
+}
+type CodeViewScrollTarget = CodeViewPositionScrollTarget | CodeViewLineScrollTarget | CodeViewRangeScrollTarget | CodeViewItemScrollTarget;
+type MergeConflictResolution = 'current' | 'incoming' | 'both';
+interface MergeConflictRegion {
+  conflictIndex: number;
+  startLineIndex: number;
+  startLineNumber: number;
+  separatorLineIndex: number;
+  separatorLineNumber: number;
+  endLineIndex: number;
+  endLineNumber: number;
+  baseMarkerLineIndex?: number;
+  baseMarkerLineNumber?: number;
+}
+interface MergeConflictActionPayload {
+  resolution: MergeConflictResolution;
+  conflict: MergeConflictRegion;
+}
+type LineTypes = 'change-deletion' | 'change-addition' | 'context' | 'context-expanded';
+interface LineEventBaseProps {
+  type: 'line';
+  lineNumber: number;
+  lineElement: HTMLElement;
+  numberElement: HTMLElement;
+  numberColumn: boolean;
+}
+interface DiffLineEventBaseProps extends Omit<LineEventBaseProps, 'type'> {
+  type: 'diff-line';
+  annotationSide: AnnotationSide;
+  lineType: LineTypes;
+}
+interface TokenEventBase {
+  type: 'token';
+  lineNumber: number;
+  lineCharStart: number;
+  lineCharEnd: number;
+  tokenText: string;
+  tokenElement: HTMLElement;
+}
+interface DiffTokenEventBaseProps extends TokenEventBase {
+  side: AnnotationSide;
+}
+type CodeColumnType = 'unified' | 'additions' | 'deletions';
+interface HunkData {
+  slotName: string;
+  hunkIndex: number;
+  lines: number;
+  lineCountKnown: boolean;
+  type: CodeColumnType;
+  expandable?: {
+    chunked: boolean;
+    up: boolean;
+    down: boolean;
+  };
+}
+type ExpansionDirections = 'up' | 'down' | 'both';
+interface ThemedFileResult {
+  code: ElementContent[];
+  themeStyles: string;
+  baseThemeType: 'light' | 'dark' | undefined;
+}
+interface RenderDiffFilesResult {
+  deletionLines: ElementContent[];
+  additionLines: ElementContent[];
+}
+interface ThemedDiffResult {
+  code: RenderDiffFilesResult;
+  themeStyles: string;
+  baseThemeType: 'light' | 'dark' | undefined;
+}
+interface HunkExpansionRegion {
+  fromStart: number;
+  fromEnd: number;
+}
+interface RenderFileOptions {
+  theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;
+  useTokenTransformer: boolean;
+  tokenizeMaxLineLength: number;
+}
+interface RenderDiffOptions {
+  theme: DiffsThemeNames | Record<'dark' | 'light', DiffsThemeNames>;
+  useTokenTransformer: boolean;
+  tokenizeMaxLineLength: number;
+  lineDiffType: LineDiffTypes;
+  maxLineDiffLength: number;
+}
+interface RenderFileResult {
+  result: ThemedFileResult;
+  options: RenderFileOptions;
+}
+interface RenderDiffResult {
+  result: ThemedDiffResult;
+  options: RenderDiffOptions;
+}
+/**
+ * A window of rendered content. Two unit interpretations exist:
+ *
+ * - Renderer consumers (`iterateOverDiff` window predicates, windowed AST
+ *   requests, buffers, sticky specs) read `startingLine`/`totalLines` as
+ *   dense rendered-row indexes for the active diff style.
+ * - The editor reads them as zero-based document-line indexes of the new
+ *   file. `FileDiff.computeEditorRenderRange` converts the renderer range on
+ *   the editor-bound copy; the two coincide only while every line renders
+ *   (`expandUnchanged`).
+ */
+interface RenderRange {
+  startingLine: number;
+  totalLines: number;
+  bufferBefore: number;
+  bufferAfter: number;
+}
+interface RenderWindow {
+  top: number;
+  bottom: number;
+}
+interface VirtualWindowSpecs {
+  /** Absolute top edge of the active virtual window in scroll-space pixels. */
+  top: number;
+  /** Absolute bottom edge of the active virtual window in scroll-space pixels. */
+  bottom: number;
+}
+interface VirtualFileMetrics {
+  /** Number of rendered lines per hunk chunk when virtualization batches line rendering. */
+  hunkLineCount: number;
+  /** Estimated single-line row height used before a line is measured. */
+  lineHeight: number;
+  /** Height reserved for the file or diff header region. */
+  diffHeaderHeight: number;
+  /** Height reserved for each collapsed-context separator row. Only set this
+   * if you customized the size of hunk separators via unsafeCSS */
+  hunkSeparatorHeight?: number;
+  /** Vertical spacing used around hunks and file-level padding. You should not
+   * change this from the default if you aren't applying custom CSS */
+  spacing: number;
+  /** Optional top padding applied after the file header, or before content
+   * when the header is disabled. Defaults to 0 with a header, otherwise
+   * defaults to spacing if header is disabled */
+  paddingTop?: number;
+  /** Optional bottom padding applied after file content, and only if there is
+   * code for the diff. Defaults to spacing if none provided */
+  paddingBottom?: number;
+}
+interface PendingCodeViewLayoutReset {
+  metrics?: VirtualFileMetrics;
+  resetFileLayoutCache: boolean;
+  resetDiffLayoutCache: boolean;
+  includeEstimatedDiffHeights: boolean;
+}
+interface CodeViewLayout {
+  /** Top padding applied to the CodeView sticky container offset. */
+  paddingTop: number;
+  /** Bottom padding added after the final rendered item in CodeView. */
+  paddingBottom: number;
+  /** Vertical gap between virtualized CodeView items. */
+  gap: number;
+}
+interface SmoothScrollSettings {
+  /**
+   * Natural frequency of the critically-damped spring, in rad/ms. 99% settle
+   * takes roughly `6.6 / omega`; 0.015 gives ~440ms. Raise for a snappier
+   * animation; lower for a longer glide.
+   */
+  omega: number;
+  /**
+   * Distance from destination (in CSS pixels) below which the spring is
+   * considered settled. Must also clear `velocityEpsilon` before the
+   * animation actually stops and snaps to destination.
+   */
+  positionEpsilon: number;
+  /**
+   * Velocity magnitude (in CSS pixels per millisecond) below which the
+   * spring is considered effectively stationary. Pairs with
+   * `positionEpsilon` to gate the settle transition.
+   */
+  velocityEpsilon: number;
+}
+/**
+ * Unresolved merge conflict indexes use three different coordinate spaces:
+ * - source line indexes live on `conflict.*LineIndex`
+ * - hunk-content indexes live on the fields below, with `startContentIndex`
+ *   serving as both the conflict-range start and the start-marker anchor
+ * - rendered row indexes live on unresolved `markerRows`
+ */
+interface ProcessFileConflictData {
+  /** Index of the hunk that owns this unresolved conflict. */
+  hunkIndex: number;
+  /** First hunk-content entry that belongs to the conflict region. */
+  startContentIndex: number;
+  /** Last hunk-content entry that belongs to the conflict region. */
+  endContentIndex: number;
+  /** Hunk-content index for the current/ours change block. */
+  currentContentIndex?: number;
+  /** Hunk-content index for the optional base context block. */
+  baseContentIndex?: number;
+  /** Hunk-content index for the incoming/theirs change block. */
+  incomingContentIndex?: number;
+  /** Hunk-content index that anchors the end marker row. */
+  endMarkerContentIndex: number;
+}
+interface AppliedThemeStyleCache {
+  theme: DiffsThemeNames | ThemesType;
+  themeStyles: string;
+  themeType: ThemeTypes;
+  baseThemeType: 'light' | 'dark' | undefined;
+  scrollbarGutter: number | undefined;
+}
+interface StickySpecs {
+  topOffset: number;
+  height: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/editStack.d.ts
+//#region src/editor/editStack.d.ts
+type EditStackEntry<EType extends EditorType, LAnnotation = unknown> = EditHistoryEntry<EType, LAnnotation>;
+/** Options for the edit stack. */
+interface EditStackOptions {
+  /** The maximum number of entries to keep in the undo stack. */
+  maxEntries?: number;
+}
+/** A stack of edit entries. */
+declare class EditStack<EType extends EditorType, LAnnotation = unknown> {
+  #private;
+  constructor(options?: EditStackOptions);
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  /** Return an independent, developer-editable history snapshot. */
+  getState(): EditHistoryState<EType, LAnnotation>;
+  /** Return a live view over this stack without copying its entries. */
+  getLiveState(): EditHistoryState<EType, LAnnotation>;
+  /** Transfer developer-owned history into an edit stack. */
+  static fromState<EType extends EditorType, LAnnotation>(state: EditHistoryState<EType, LAnnotation>): EditStack<EType, LAnnotation>;
+  /** Clears both the undo and redo stacks. */
+  clear(): void;
+  /** Clears the redo stack. */
+  clearRedo(): void;
+  /** Pushes a new entry onto the undo stack. */
+  push(entry: EditStackEntry<EType, LAnnotation>): void;
+  /** Sets the selections after the last undo entry. */
+  setLastUndoSelectionsAfter(selections: EditorSelection[]): void;
+  /** Sets the line annotations after the last undo entry. */
+  setLastUndoLineAnnotations(lineAnnotationsBefore: EditorLineAnnotation<EType, LAnnotation>[], lineAnnotationsAfter: EditorLineAnnotation<EType, LAnnotation>[]): void;
+  /** Returns the last undo entry, or `undefined` if empty. */
+  peekUndo(): EditStackEntry<EType, LAnnotation> | undefined;
+  /** Returns the last undo entry only while its coalescing group is open. */
+  peekUndoForCoalescing(): EditStackEntry<EType, LAnnotation> | undefined;
+  /** Replaces the last undo entry with the given entry. */
+  replaceLastUndo(entry: EditStackEntry<EType, LAnnotation>): void;
+  /** Moves the latest undo entry to the redo stack and returns it, or `undefined` if empty. */
+  popUndoToRedo(): EditStackEntry<EType, LAnnotation> | void;
+  /** Moves the latest redo entry back to the undo stack and returns it, or `undefined` if empty. */
+  popRedoToUndo(): EditStackEntry<EType, LAnnotation> | void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/searchPanel.d.ts
+interface SearchParams {
+  text: string;
+  replaceText: string;
+  caseSensitive: boolean;
+  wholeWord: boolean;
+  regex: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/textDocument.d.ts
+//#region src/editor/textDocument.d.ts
+interface TextDocumentChange {
+  /** The edits that were applied to the text document. */
+  readonly changes: EditorChange[];
+  /** First line whose rendered content or tokenizer state may have changed. */
+  readonly startLine: number;
+  /** Character on the first changed line where the edit began. */
+  readonly startCharacter: number;
+  /** Character on the original last changed line where the edit ended. */
+  readonly endCharacter: number;
+  /** Last line whose rendered content may have changed after the edit. */
+  readonly endLine: number;
+  /** Whether the original edit range ended at the previous document EOF. */
+  readonly endedAtDocumentEnd: boolean;
+  /** Line count before the edit was applied. */
+  readonly previousLineCount: number;
+  /** Line count after the edit was applied. */
+  readonly lineCount: number;
+  /** Difference between the old and new line counts. */
+  readonly lineDelta: number;
+  /** Exact rendered line ranges touched by each edit after the edit was applied. */
+  readonly changedLineRanges: readonly [startLine: number, endLine: number][];
+  /** Per-edit rendered line ranges before adjacent ranges are coalesced. */
+  readonly changedLineChanges?: readonly [startLine: number, endLine: number, lineDelta: number, startCharacter?: number, endCharacter?: number, endedAtDocumentEnd?: boolean][];
+}
+type TextDocumentHistoryResult<EType extends EditorType, LAnnotation> = [change: TextDocumentChange, selections?: EditorSelection[], lineAnnotations?: EditorLineAnnotation<EType, LAnnotation>[], selectionEdits?: ResolvedTextEdit[]];
+/**
+ * A vscode-languageserver-textdocument compatible text document.
+ */
+declare class TextDocument<EType extends EditorType = EditorType, LAnnotation = unknown> {
+  #private;
+  constructor(uri: string, text: string, languageId?: string, version?: number, editStack?: EditStack<EType, LAnnotation>, eol?: '\n' | '\r\n' | '\r');
+  get uri(): string;
+  get languageId(): string;
+  get version(): number;
+  get lineCount(): number;
+  get eol(): '\n' | '\r\n' | '\r';
+  get history(): EditHistoryState<EType, LAnnotation>;
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  /** Clear undo and redo history without changing the document contents. */
+  clearHistory(): void;
+  positionAt(offset: number): Position;
+  positionsAt(offsets: readonly number[]): Position[];
+  offsetAt(position: Position): number;
+  getText(range?: Range): string;
+  getLineText(line: number, includeLineBreak?: boolean): string;
+  normalizeEol(text: string): string;
+  getLineLength(line: number, includeLineBreak?: boolean): number;
+  charAt(offset: number): string;
+  charAt(position: Position): string;
+  getTextSlice(start: number, end: number): string;
+  findNextNonOverlappingSubstring(needle: string, occupied: readonly [start: number, end: number][]): number | undefined;
+  search(searchParams: SearchParams): [start: number, end: number][];
+  applyEdits(edits: TextEdit[], updateHistory?: boolean, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], undoBoundary?: boolean): TextDocumentChange | undefined;
+  resolveEdits(edits: readonly TextEdit[]): ResolvedTextEdit[];
+  applyResolvedEdits(edits: ResolvedTextEdit[], updateHistory?: boolean, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], undoBoundary?: boolean): TextDocumentChange | undefined;
+  setLastUndoSelectionsAfter(selections: EditorSelection[]): void;
+  setLastUndoLineAnnotations(lineAnnotationsBefore: EditorLineAnnotation<EType, LAnnotation>[], lineAnnotationsAfter: EditorLineAnnotation<EType, LAnnotation>[]): void;
+  undo(): TextDocumentHistoryResult<EType, LAnnotation> | undefined;
+  redo(): TextDocumentHistoryResult<EType, LAnnotation> | undefined;
+  normalizePosition(position: Position): Position;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/managers/InteractionManager.d.ts
+//#region src/managers/InteractionManager.d.ts
+type LogTypes = 'click' | 'move' | 'both' | 'none';
+type InteractionManagerMode = 'file' | 'diff';
+interface OnLineClickProps extends LineEventBaseProps {
+  event: PointerEvent;
+}
+interface OnLineEnterLeaveProps extends LineEventBaseProps {
+  event: PointerEvent;
+}
+interface OnDiffLineClickProps extends DiffLineEventBaseProps {
+  event: PointerEvent;
+}
+interface OnDiffLineEnterLeaveProps extends DiffLineEventBaseProps {
+  event: PointerEvent;
+}
+interface SelectionWriteOptions {
+  notify?: boolean;
+  activeLineSide?: SelectionSide;
+  lineNumberOnly?: boolean;
+}
+interface EditorActiveLineWriteOptions {
+  lineNumberOnly?: boolean;
+  side?: SelectionSide;
+}
+type GetLineIndexUtility = (lineNumber: number, side?: SelectionSide) => [number, number] | undefined;
+type EventClickProps<TMode extends InteractionManagerMode> = TMode extends 'file' ? OnLineClickProps : OnDiffLineClickProps;
+type PointerEventEnterLeaveProps<TMode extends InteractionManagerMode> = TMode extends 'file' ? OnLineEnterLeaveProps : OnDiffLineEnterLeaveProps;
+type OnTokenEventProps<TMode extends InteractionManagerMode> = TMode extends 'file' ? TokenEventBase : DiffTokenEventBaseProps;
+type GetHoveredLineResult<TMode extends InteractionManagerMode> = TMode extends 'file' ? {
+  lineNumber: number;
+} : {
+  lineNumber: number;
+  side: AnnotationSide;
+};
+interface MergeConflictActionTarget {
+  kind: 'merge-conflict-action';
+  resolution: MergeConflictResolution;
+  conflictIndex: number;
+}
+interface InteractionManagerBaseOptions<TMode extends InteractionManagerMode> {
+  lineHoverHighlight?: 'disabled' | 'both' | 'number' | 'line';
+  enableTokenInteractionsOnWhitespace?: boolean;
+  enableGutterUtility?: boolean;
+  onGutterUtilityClick?(range: SelectedLineRange): unknown;
+  onLineClick?(props: EventClickProps<TMode>): unknown;
+  onLineNumberClick?(props: EventClickProps<TMode>): unknown;
+  onLineEnter?(props: PointerEventEnterLeaveProps<TMode>): unknown;
+  onLineLeave?(props: PointerEventEnterLeaveProps<TMode>): unknown;
+  onTokenClick?(props: OnTokenEventProps<TMode>, event: MouseEvent): unknown;
+  onTokenEnter?(props: OnTokenEventProps<TMode>, event: PointerEvent): unknown;
+  onTokenLeave?(props: OnTokenEventProps<TMode>, event: PointerEvent): unknown;
+  __debugPointerEvents?: LogTypes;
+  enableLineSelection?: boolean;
+  controlledSelection?: boolean;
+  onLineSelected?: (range: SelectedLineRange | null) => void;
+  onLineSelectionStart?: (range: SelectedLineRange | null) => void;
+  onLineSelectionChange?: (range: SelectedLineRange | null) => void;
+  onLineSelectionEnd?: (range: SelectedLineRange | null) => void;
+  getLineIndex?: GetLineIndexUtility;
+}
+interface InteractionManagerOptions<TMode extends InteractionManagerMode> extends InteractionManagerBaseOptions<TMode> {
+  usesCustomGutterUtility?: boolean;
+  onHunkExpand?(hunkIndex: number, direction: ExpansionDirections, expansionLineCountOverride?: number): unknown;
+  onMergeConflictActionClick?(target: MergeConflictActionTarget): void;
+}
+declare class InteractionManager<TMode extends InteractionManagerMode> {
+  private mode;
+  private options;
+  private hoveredLine;
+  private hoveredToken;
+  private pre;
+  private gutterUtilityLine;
+  private gutterUtilityContainer;
+  private gutterUtilityButton;
+  private gutterUtilitySlot;
+  private interactiveLinesAttr;
+  private interactiveLineNumbersAttr;
+  private hasPointerListeners;
+  private hasDocumentPointerListeners;
+  private selectedRange;
+  private selectedRangeHighlightSide;
+  private selectedRangeLineNumberOnly;
+  private editorActiveLine;
+  private editorActiveLineSide;
+  private editorLineNumberOnly;
+  private proposedSelectedRange;
+  private renderedSelectedLinesState;
+  private renderedEditorActiveLineState;
+  private selectionAnchor;
+  private pointerSession;
+  constructor(mode: TMode, options: InteractionManagerOptions<TMode>);
+  setOptions(options: InteractionManagerOptions<TMode>): void;
+  cleanUp(): void;
+  setup(pre: HTMLPreElement): void;
+  setSelectionDirty(): void;
+  isSelectionDirty(): boolean;
+  setSelection(range: SelectedLineRange | null, options?: SelectionWriteOptions): void;
+  setEditorActiveLine(lineNumber: number | null, { lineNumberOnly, side }?: EditorActiveLineWriteOptions): void;
+  getSelection(): SelectedLineRange | null;
+  getHoveredLine: () => GetHoveredLineResult<TMode> | undefined;
+  handlePointerClick: (event: MouseEvent) => void;
+  handlePointerMove: (event: PointerEvent) => void;
+  handlePointerLeave: (event: PointerEvent) => void;
+  private handlePointerEvent;
+  private syncPointerListeners;
+  private updateInteractiveLineAttributes;
+  private handlePointerDown;
+  private startLineSelectionFromPointerDown;
+  private startGutterSelectionFromPointerDown;
+  private handleDocumentPointerMove;
+  private handleDocumentPointerUp;
+  private handleDocumentPointerCancel;
+  private clearHoveredLine;
+  private setHoveredLine;
+  private clearHoveredToken;
+  private setHoveredToken;
+  private ensureGutterUtilityNode;
+  private revealUtilityFromGutterPath;
+  private placeUtility;
+  private placeUtilityFromSelection;
+  private showUtilityOnLine;
+  private hideUtility;
+  private currentSelectionEnds;
+  private selectionEnds;
+  private selectionPointRowIndex;
+  private targetForSelectionPoint;
+  private attachDocumentPointerListeners;
+  private detachDocumentPointerListeners;
+  private clearPointerSession;
+  private clearPendingSingleLineState;
+  private selectionInfoFromPath;
+  private resolveSelectionInfo;
+  private selectionPointFromPath;
+  private resolveSelectionPoint;
+  private resolveSelectionPath;
+  private pathFromCoordinates;
+  private pathFromEventPath;
+  private pathFromElement;
+  private pathFromAnnotationSlot;
+  private hitTest;
+  private getLineIndex;
+  private getCurrentSelectionRange;
+  private clearProposedSelection;
+  private updateSelection;
+  private getIndexesFromSelection;
+  private getSelectionRenderState;
+  private resolveLineRenderRange;
+  private getLineRenderColumns;
+  private renderSelection;
+  private notifySelectionCommitted;
+  private notifySelectionChangeDelta;
+  private notifySelectionStart;
+  private notifySelectionEnd;
+  private toEventBaseProps;
+  private toTokenEventBaseProps;
+  private buildSelectedLineRange;
+  private buildSelectionRange;
+  private resolvePointerTarget;
+  private isSplitDiff;
+  private parseLineIndex;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/managers/ResizeManager.d.ts
+//#region src/managers/ResizeManager.d.ts
+type ResizeManagerColumnVariableMode = 'apply' | 'measure';
+interface ResizeManagerSetupOptions {
+  disableAnnotations: boolean;
+  columnVariables?: ResizeManagerColumnVariableMode;
+}
+declare class ResizeManager {
+  private static resizeObserver;
+  private static managersByElement;
+  private static getResizeObserver;
+  private static handleSharedResizeEntries;
+  private observedNodes;
+  setup(pre: HTMLPreElement, { disableAnnotations, columnVariables }: ResizeManagerSetupOptions): void;
+  cleanUp(): void;
+  private observe;
+  private unobserve;
+  private handleResizeEntries;
+  private applyAnnotationUpdates;
+  private applyColumnUpdates;
+  private applyNewHeight;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/worker/types.d.ts
+interface WorkerRenderingOptions {
+  theme: DiffsThemeNames | ThemesType;
+  useTokenTransformer: boolean;
+  tokenizeMaxLineLength: number;
+  lineDiffType: LineDiffTypes;
+  maxLineDiffLength: number;
+}
+interface FileRendererInstance {
+  readonly __id: string;
+  onHighlightSuccess(file: FileContents, result: ThemedFileResult, options: RenderFileOptions): unknown;
+  onHighlightError(error: unknown): unknown;
+}
+interface DiffRendererInstance {
+  readonly __id: string;
+  onHighlightSuccess(diff: FileDiffMetadata, result: ThemedDiffResult, options: RenderDiffOptions): unknown;
+  onHighlightError(error: unknown): unknown;
+}
+interface WorkerPoolOptions {
+  /**
+   * Factory function that creates a new Web Worker instance for the pool.
+   * This is called once per worker in the pool during initialization.
+   */
+  workerFactory: () => Worker;
+  /**
+   * Number of workers to create in the pool.
+   * @default 8
+   */
+  poolSize?: number;
+  /**
+   * Maximum time to wait for the worker pool to initialize, in milliseconds.
+   * @default 10000
+   */
+  workerInitializationTimeout?: number;
+  /**
+   * Called for each worker error instead of logging it with console.error.
+   * Call event.preventDefault() to prevent the browser from also reporting it
+   * as an uncaught error.
+   *
+   * Script load failures may provide a plain Event without message or error;
+   * uncaught exceptions provide an ErrorEvent. If initialization fails, the
+   * pool stops its workers and components highlight on the main thread.
+   *
+   * Several workers can report the same script load failure. Track errors in
+   * this callback if your application should report that failure only once.
+   */
+  onWorkerError?: (event: ErrorEvent | Event, worker: Worker) => void;
+  totalASTLRUCacheSize?: number;
+}
+interface WorkerInitializationRenderOptions extends Partial<WorkerRenderingOptions> {
+  langs?: SupportedLanguages[];
+  preferredHighlighter?: HighlighterTypes;
+}
+interface WorkerStats {
+  managerState: 'waiting' | 'initializing' | 'initialized';
+  workersFailed: boolean;
+  totalWorkers: number;
+  busyWorkers: number;
+  queuedTasks: number;
+  activeTasks: number;
+  themeSubscribers: number;
+  fileCacheSize: number;
+  diffCacheSize: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lru_map@0.4.1/node_modules/lru_map/lru.d.ts
+declare class LRUMap<K, V> {
+  // Construct a new cache object which will hold up to limit entries.
+  // When the size == limit, a `put` operation will evict the oldest entry.
+  //
+  // If `entries` is provided, all entries are added to the new map.
+  // `entries` should be an Array or other iterable object whose elements are
+  // key-value pairs (2-element Arrays). Each key-value pair is added to the new Map.
+  // null is treated as undefined.
+  constructor(limit: number, entries?: Iterable<[K, V]>);
+  // Convenience constructor equivalent to `new LRUMap(count(entries), entries)`
+  constructor(entries: Iterable<[K, V]>);
+  // Current number of items
+  size: number;
+  // Maximum number of items this map can hold
+  limit: number;
+  // Least recently-used entry. Invalidated when map is modified.
+  oldest: Entry<K, V>;
+  // Most recently-used entry. Invalidated when map is modified.
+  newest: Entry<K, V>;
+  // Replace all values in this map with key-value pairs (2-element Arrays) from
+  // provided iterable.
+  assign(entries: Iterable<[K, V]>): void;
+  // Put <value> into the cache associated with <key>. Replaces any existing entry
+  // with the same key. Returns `this`.
+  set(key: K, value: V): LRUMap<K, V>;
+  // Purge the least recently used (oldest) entry from the cache.
+  // Returns the removed entry or undefined if the cache was empty.
+  shift(): [K, V] | undefined;
+  // Get and register recent use of <key>.
+  // Returns the value associated with <key> or undefined if not in cache.
+  get(key: K): V | undefined;
+  // Check if there's a value for key in the cache without registering recent use.
+  has(key: K): boolean;
+  // Access value for <key> without registering recent use. Useful if you do not
+  // want to chage the state of the map, but only "peek" at it.
+  // Returns the value associated with <key> if found, or undefined if not found.
+  find(key: K): V | undefined;
+  // Remove entry <key> from cache and return its value.
+  // Returns the removed value, or undefined if not found.
+  delete(key: K): V | undefined;
+  // Removes all entries
+  clear(): void;
+  // Returns an iterator over all keys, starting with the oldest.
+  keys(): Iterator<K>;
+  // Returns an iterator over all values, starting with the oldest.
+  values(): Iterator<V>;
+  // Returns an iterator over all entries, starting with the oldest.
+  entries(): Iterator<[K, V]>;
+  // Returns an iterator over all entries, starting with the oldest.
+  [Symbol.iterator](): Iterator<[K, V]>;
+  // Call `fun` for each entry, starting with the oldest entry.
+  forEach(fun: (value: V, key: K, m: LRUMap<K, V>) => void, thisArg?: any): void;
+  // Returns an object suitable for JSON encoding
+  toJSON(): Array<{
+    key: K;
+    value: V;
+  }>;
+  // Returns a human-readable text representation
+  toString(): string;
+}
+// An entry holds the key and value, and pointers to any older and newer entries.
+interface Entry<K, V> {
+  key: K;
+  value: V;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/worker/WorkerPoolManager.d.ts
+//#region src/worker/WorkerPoolManager.d.ts
+interface GetCachesResult {
+  fileCache: LRUMap<string, RenderFileResult>;
+  diffCache: LRUMap<string, RenderDiffResult>;
+}
+interface ThemeSubscriber {
+  onThemeChange(): void;
+}
+type RenderTaskInstance = FileRendererInstance | DiffRendererInstance;
+declare class WorkerPoolManager {
+  private options;
+  private highlighter;
+  private readonly preferredHighlighter;
+  private renderOptions;
+  private renderOptionsRequestVersion;
+  private renderOptionsVersion;
+  private initialized;
+  private workers;
+  private queuedTasks;
+  private queuedTaskByInstance;
+  private taskByHighlightKey;
+  private activeTaskById;
+  private activeRequestByInstance;
+  private nextRequestId;
+  private themeSubscribers;
+  private workersFailed;
+  private statSubscribers;
+  private fileCache;
+  private diffCache;
+  private _queuedBroadcast;
+  private lifecycleGeneration;
+  constructor(options: WorkerPoolOptions, { langs, theme, useTokenTransformer, lineDiffType, maxLineDiffLength, tokenizeMaxLineLength, preferredHighlighter }: WorkerInitializationRenderOptions);
+  isWorkingPool(): boolean;
+  getFileResultCache(file: FileContents): RenderFileResult | undefined;
+  getDiffResultCache(diff: FileDiffMetadata): RenderDiffResult | undefined;
+  inspectCaches(): GetCachesResult;
+  evictFileFromCache(cacheKey: string): boolean;
+  evictDiffFromCache(cacheKey: string): boolean;
+  setRenderOptions({ theme, useTokenTransformer, lineDiffType, maxLineDiffLength, tokenizeMaxLineLength }: Partial<WorkerRenderingOptions>): Promise<void>;
+  getPreferredHighlighter(): HighlighterTypes;
+  getFileRenderOptions(): RenderFileOptions;
+  getDiffRenderOptions(): RenderDiffOptions;
+  private setRenderOptionsOnWorkers;
+  subscribeToThemeChanges(instance: ThemeSubscriber): () => void;
+  unsubscribeToThemeChanges(instance: ThemeSubscriber): void;
+  subscribeToStatChanges(callback: (stats: WorkerStats) => unknown): () => void;
+  private queueBroadcastStateChanges;
+  private _broadcastStateChanges;
+  cleanUpTasks(instance: RenderTaskInstance): void;
+  isInitialized(): boolean;
+  initialize(languages?: SupportedLanguages[]): Promise<void>;
+  private initializeWorkers;
+  /**
+   * Pass worker errors to onWorkerError, or log them if no callback is set.
+   *
+   * A startup error rejects initialization so components can highlight on the
+   * main thread. Other requests wait for their own responses: worker.ts catches
+   * request errors, so this event may be unrelated to the current request.
+   * A worker that stops responding remains busy and receives no further work.
+   */
+  private handleWorkerError;
+  private drainQueue;
+  highlightFileAST(instance: FileRendererInstance, file: FileContents): void;
+  primeFileHighlightCache(file: FileContents): Promise<void>;
+  private getOrCreateFileHighlightCacheTask;
+  getPlainFileAST(file: FileContents, startingLine: number, totalLines: number, lines?: string[]): ThemedFileResult | undefined;
+  highlightDiffAST(instance: DiffRendererInstance, diff: FileDiffMetadata): void;
+  primeDiffHighlightCache(diff: FileDiffMetadata): Promise<void>;
+  private getOrCreateDiffHighlightCacheTask;
+  getPlainDiffAST(diff: FileDiffMetadata, startingLine: number, totalLines: number, expandedHunks?: Map<number, HunkExpansionRegion> | true, collapsedContextThreshold?: number): ThemedDiffResult | undefined;
+  terminate(): void;
+  private isCurrentLifecycle;
+  private queueInitialization;
+  private cancelActiveWorkerTasks;
+  private terminateWorkers;
+  getStats(): WorkerStats;
+  private submitTask;
+  private submitCacheTask;
+  private enqueueRenderTask;
+  private resolveLanguagesAndExecuteTask;
+  private handleWorkerMessage;
+  private _queuedDrain;
+  private queueDrain;
+  private assignWorkerToTask;
+  private cleanWorkerAndTask;
+  private executeTask;
+  private maybeAttachCustomExtensions;
+  private syncCustomExtensionVersion;
+  private getAvailableWorker;
+  private getFileHighlightKey;
+  private getDiffHighlightKey;
+  private getHighlightKeyForRequest;
+  private hasActiveRequest;
+  private addInstanceToTask;
+  private detachInstanceFromQueuedTasks;
+  private detachInstanceFromRenderTask;
+  private removeQueuedTask;
+  private removeActiveTask;
+  private createRenderTaskCallbacks;
+  private resolveRenderTaskCallbacks;
+  private rejectRenderTaskCallbacks;
+  private invalidateRenderTasks;
+  private clearQueuedInstanceRequests;
+  private clearHighlightKey;
+  private trackInstanceRequests;
+  private clearInstanceRequests;
+  private notifyFileInstances;
+  private notifyDiffInstances;
+  private notifyHighlightError;
+  private hasMatchingFileInstanceTask;
+  private hasMatchingDiffInstanceTask;
+  private getTaskByHighlightKey;
+  private isCurrentRenderTask;
+  private iterateRenderTasks;
+  private generateRequestId;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/renderers/FileRenderer.d.ts
+//#region src/renderers/FileRenderer.d.ts
+interface FileRenderResult {
+  file: FileContents;
+  gutterAST: ElementContent[];
+  contentAST: ElementContent[];
+  preAST: Element$1;
+  headerAST: Element$1 | undefined;
+  css: string;
+  totalLines: number;
+  themeStyles: string;
+  baseThemeType: 'light' | 'dark' | undefined;
+  rowCount: number;
+  bufferBefore: number;
+  bufferAfter: number;
+}
+interface FileRendererOptions extends BaseCodeOptions {
+  headerRenderMode?: FileHeaderRenderMode;
+}
+declare class FileRenderer<LAnnotation = undefined> {
+  options: FileRendererOptions;
+  private annotationSlotName;
+  private onRenderUpdate?;
+  private workerManager?;
+  readonly __id: string;
+  private highlighter;
+  private file;
+  private renderCache;
+  private pendingHighlightResult;
+  private computedLang;
+  private lineAnnotations;
+  private lineCache;
+  private pendingStructuralRows;
+  private textDocumentCache;
+  private editSessionActive;
+  get fileCache(): FileContents | undefined;
+  constructor(options?: FileRendererOptions, annotationSlotName?: (annotation: LineAnnotation<LAnnotation>) => string, onRenderUpdate?: (() => unknown) | undefined, workerManager?: WorkerPoolManager | undefined);
+  setOptions(options: FileRendererOptions): void;
+  mergeOptions(options: Partial<FileRendererOptions>): void;
+  setLineAnnotations(lineAnnotations: LineAnnotation<LAnnotation>[]): void;
+  cleanUp(): void;
+  /**
+   * Enter edit-session mode: rendering happens locally with the token
+   * transformer forced on, and worker-pool requests/results are suspended
+   * for this renderer. Called on initial editor association and whenever its
+   * rendering resumes after recycle.
+   */
+  beginEditSession(file: FileContents, externalFile?: FileContents): void;
+  /**
+   * Leave edit-session mode. Rendering returns to the pool when one works.
+   * When `settledFile` has the content the cache already shows, the cache
+   * adopts it as its identity so the next render treats it as current
+   * instead of a new file.
+   */
+  endEditSession(settledFile?: FileContents): void;
+  /**
+   * Ensures that the DOM is compatible with editor render updates
+   */
+  editorRenderReady(): boolean;
+  recycle(): void;
+  clearRenderCache(): void;
+  hydrate(file: FileContents): void;
+  private getLocalHighlightTheme;
+  getEffectiveCodeOptions(): Pick<BaseCodeOptions, 'theme' | 'tokenizeMaxLineLength'>;
+  private getRenderOptions;
+  /**
+   * Returns the file that the next synchronous render can commit without
+   * changing the current render cache. Virtualized layouts use this to stay
+   * aligned with the DOM while a replacement highlight is still pending.
+   */
+  getFileForNextRender(file: FileContents): FileContents;
+  private canRenderFile;
+  getOrCreateLineCache(file: FileContents): string[];
+  getLineCount(file: FileContents): number;
+  updateRenderCache(dirtyLines: Map<number, Array<HighlightedToken>>, themeType: 'dark' | 'light', lineCountChangeInFlight?: boolean): void;
+  applyDocumentChange(textDocument: TextDocument<'file', LAnnotation>): void;
+  renderFile(file?: FileContents | undefined, renderRange?: RenderRange): FileRenderResult | undefined;
+  asyncRender(file: FileContents, renderRange?: RenderRange): Promise<FileRenderResult>;
+  private asyncHighlight;
+  private renderFileWithHighlighter;
+  private processFileResult;
+  private renderHeader;
+  renderFullHTML(result: FileRenderResult): string;
+  renderFullAST(result: FileRenderResult, children?: ElementContent[]): Element$1;
+  renderCodeAST(result: FileRenderResult): ElementContent[];
+  renderPartialHTML(children: ElementContent[], includeCodeNode?: boolean): string;
+  initializeHighlighter(): Promise<DiffsHighlighter>;
+  onHighlightSuccess(file: FileContents, result: ThemedFileResult, options: RenderFileOptions, highlighted?: boolean): void;
+  private applyHighlightResult;
+  private getMatchingWorkerResultCache;
+  private getReadyRenderResult;
+  private hasHighlightedRenderCache;
+  onHighlightError(error: unknown): void;
+  private getTokenizeMaxLength;
+  private createPreElement;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/File.d.ts
+//#region src/components/File.d.ts
+interface FileRenderProps<LAnnotation> {
+  file: FileContents;
+  fileContainer?: HTMLElement;
+  containerWrapper?: HTMLElement;
+  deferManagers?: boolean;
+  forceRender?: boolean;
+  preventEmit?: boolean;
+  lineAnnotations?: LineAnnotation<LAnnotation>[];
+  renderRange?: RenderRange;
+}
+interface FileHydrateProps<LAnnotation> extends Omit<FileRenderProps<LAnnotation>, 'fileContainer'> {
+  fileContainer: HTMLElement;
+  prerenderedHTML?: string;
+}
+type FileEditChangeHandler<LAnnotation, Caret> = (event: EditorChangeEvent<'file', LAnnotation, Caret>) => void;
+/**
+ * Decides a completed edit synchronously: return `'accept'` to install the
+ * event's `file` and annotations, or `'reject'` to restore the original values.
+ * The event is frozen, so re-key the accepted file in place
+ * (`event.file.cacheKey = '…'`) before accepting. The event's editor is
+ * detached and returns its final state from `getViewState()`. A missing handler
+ * rejects.
+ */
+type FileEditCompleteHandler<LAnnotation, Caret> = (event: FileEditCompleteEvent<LAnnotation, Caret>) => EditCompletionDecision;
+interface FileOptions<LAnnotation, Caret> extends BaseCodeOptions, InteractionManagerBaseOptions<'file'> {
+  disableFileHeader?: boolean;
+  renderHeaderPrefix?: RenderFileMetadata;
+  renderHeaderFilenameSuffix?: RenderFileMetadata;
+  renderHeaderMetadata?: RenderFileMetadata;
+  renderCustomHeader?: RenderFileMetadata;
+  /**
+   * When true, errors during rendering are rethrown instead of being caught
+   * and displayed in the DOM. Useful for testing or when you want to handle
+   * errors yourself.
+   */
+  disableErrorHandling?: boolean;
+  renderAnnotation?(annotation: LineAnnotation<LAnnotation>): HTMLElement | undefined;
+  renderGutterUtility?(getHoveredRow: () => GetHoveredLineResult<'file'> | undefined): HTMLElement | null | undefined;
+  onPostRender?(node: HTMLElement, instance: File<LAnnotation, Caret>, phase: PostRenderPhase): unknown;
+  /**
+   * Fired for every document change of an active edit session on this
+   * component, with the same `EditorChangeEvent` the editor reports through
+   * its own `onChange`. Do not feed the event's file back into the component
+   * while the session is active.
+   */
+  onEditChange?: FileEditChangeHandler<LAnnotation, Caret>;
+  /**
+   * Fired when `edit` toggles false or a component unmounts, including when the
+   * final contents are unchanged. If no callback is provided, the component
+   * reverts to the last `file` and annotations passed into it. The callback
+   * receives the detached editor with its final pre-detach state.
+   */
+  onEditComplete?: FileEditCompleteHandler<LAnnotation, Caret>;
+}
+interface AnnotationElementCache$1<LAnnotation> {
+  element: HTMLElement;
+  annotation: LineAnnotation<LAnnotation>;
+}
+interface HydrationSetup$1<LAnnotation> {
+  file: FileContents;
+  lineAnnotations: LineAnnotation<LAnnotation>[] | undefined;
+}
+declare class File<LAnnotation = undefined, Caret = undefined> {
+  options: FileOptions<LAnnotation, Caret>;
+  private workerManager?;
+  private isContainerManaged;
+  static LoadedCustomComponent: boolean;
+  readonly __id: string;
+  readonly type = "file";
+  protected fileContainer: HTMLElement | undefined;
+  protected spriteSVG: SVGElement | undefined;
+  protected pre: HTMLPreElement | undefined;
+  protected code: HTMLElement | undefined;
+  protected bufferBefore: HTMLElement | undefined;
+  protected bufferAfter: HTMLElement | undefined;
+  protected themeCSSStyle: HTMLStyleElement | undefined;
+  protected appliedThemeCSS: AppliedThemeStyleCache | undefined;
+  protected hasAdoptedThemeCSS: boolean;
+  protected unsafeCSSStyle: HTMLStyleElement | undefined;
+  protected appliedUnsafeCSS: string | undefined;
+  protected gutterUtilityContent: HTMLElement | undefined;
+  protected errorWrapper: HTMLElement | undefined;
+  protected placeHolder: HTMLElement | undefined;
+  protected lastRenderedHeaderHTML: string | undefined;
+  protected cachedHeaderHTML: string | undefined;
+  protected appliedPreAttributes: PrePropertiesConfig | undefined;
+  protected lastRowCount: number | undefined;
+  private mounted;
+  protected headerElement: HTMLElement | undefined;
+  protected headerCustom: HTMLElement | undefined;
+  protected headerPrefix: HTMLElement | undefined;
+  protected headerFilenameSuffix: HTMLElement | undefined;
+  protected headerMetadata: HTMLElement | undefined;
+  protected fileRenderer: FileRenderer<LAnnotation>;
+  protected resizeManager: ResizeManager;
+  protected interactionManager: InteractionManager<'file'>;
+  protected annotationCache: Map<string, AnnotationElementCache$1<LAnnotation>>;
+  protected lineAnnotations: LineAnnotation<LAnnotation>[];
+  protected managersDirty: boolean;
+  file: FileContents | undefined;
+  private editSession;
+  protected renderedFile: FileContents | undefined;
+  protected renderRange: RenderRange | undefined;
+  protected enabled: boolean;
+  protected editor: Editor<'file', LAnnotation, Caret> | undefined;
+  constructor(options?: FileOptions<LAnnotation, Caret>, workerManager?: WorkerPoolManager | undefined, isContainerManaged?: boolean);
+  getAnnotationSlotName: (annotation: LineAnnotation<LAnnotation> | DiffLineAnnotation<LAnnotation>) => string;
+  private handleHighlightRender;
+  rerender(): void;
+  private getTheme;
+  protected getLatestFile(file?: FileContents | undefined): FileContents | undefined;
+  protected getRenderedFile(): FileContents | undefined;
+  protected getLatestAnnotations(): LineAnnotation<LAnnotation>[];
+  protected isNewAnnotations(lineAnnotations: LineAnnotation<LAnnotation>[]): boolean;
+  protected updateExternalFile(incomingFile: FileContents, lineAnnotations?: LineAnnotation<LAnnotation>[]): boolean;
+  private installEditSession;
+  onThemeChange(): void;
+  setOptions(options: FileOptions<LAnnotation, Caret> | undefined): void;
+  protected syncInteractionOptions(): void;
+  private mergeOptions;
+  setThemeType(themeType: ThemeTypes): void;
+  private applyCachedThemeState;
+  private hasThemeChanged;
+  getHoveredLine: () => GetHoveredLineResult<'file'> | undefined;
+  setLineAnnotations(lineAnnotations: LineAnnotation<LAnnotation>[]): void;
+  protected syncEditSessionAnnotationsFromEditor(lineAnnotations: LineAnnotation<LAnnotation>[]): boolean;
+  setSelectedLines(range: SelectedLineRange | null, options?: SelectionWriteOptions): void;
+  setEditorActiveLine(lineNumber: number | null, options?: EditorActiveLineOptions): void;
+  getCodeScrollLeft(): number;
+  setCodeScrollLeft(position: number): void;
+  __getEffectiveCodeOptions(): BaseCodeOptions;
+  flushManagers(): void;
+  protected shouldApplyColumnVariables(overflow: 'scroll' | 'wrap'): boolean;
+  cleanUp(recycle?: boolean): void;
+  virtualizedSetup(): void;
+  hydrate(props: FileHydrateProps<LAnnotation>): void;
+  protected hydrateElements(fileContainer: HTMLElement, prerenderedHTML: string | undefined): void;
+  protected hydrationSetup({ file, lineAnnotations }: HydrationSetup$1<LAnnotation>): void;
+  getOrCreateLineCache(file?: FileContents | undefined): string[];
+  protected updateBuffers(renderRange: RenderRange): void;
+  private syncRenderViewToEditor;
+  /** @internal The editor applied or edited past the pending external replacement. */
+  __acknowledgeDocumentUpdate(): void;
+  /** @internal Settle annotations */
+  __acceptEditorChange(event: EditorChangeEvent<'file', LAnnotation, Caret>): void;
+  emitEditChange(event: EditorChangeEvent<'file', LAnnotation, Caret>): void;
+  /** @internal Plain files have no component-owned diff session state. */
+  __captureDocumentSessionState(): undefined;
+  /** @internal Associate this component with its editor for a render lifecycle. */
+  __attachEditor(editor: Editor<'file', LAnnotation, Caret>): () => void;
+  /** @internal Resume rendering for the editor already associated with this component. */
+  __resumeEditor(editor: Editor<'file', LAnnotation, Caret>): void;
+  private resumeEditorRendering;
+  /**
+   * @internal
+   *
+   * Ends the edit session and settles which file this component renders.
+   * Requires the editor to be detached first. Does nothing when no session
+   * exists, so callers can invoke it again safely after it has settled.
+   *
+   * `onEditComplete` receives the completed file, current external file, and
+   * both annotation collections even when the final text is unchanged. In
+   * `install` mode, accepting installs the completed file and its annotations;
+   * rejecting or having no handler restores the external values. `discard`
+   * mode always restores the external values. An accepted file cannot reuse
+   * the replaced file's `cacheKey`.
+   */
+  __completeEditSession(editor: Editor<'file', LAnnotation, Caret>, mode: 'install' | 'discard'): void;
+  private settleEditSession;
+  applyDocumentChange(textDocument: TextDocument<'file', LAnnotation>, newLineAnnotations?: LineAnnotation<LAnnotation>[]): void;
+  /** Update the session source without editor DOM, then rehighlight on return. */
+  applySuspendedDocumentChange(textDocument: TextDocument<'file', LAnnotation>, newLineAnnotations?: LineAnnotation<LAnnotation>[]): void;
+  updateRenderCache(dirtyLines: Map<number, Array<HighlightedToken>>, themeType: 'dark' | 'light', options?: {
+    lineCountChangeInFlight?: boolean;
+  }): void;
+  render({ file, fileContainer, forceRender, preventEmit, containerWrapper, deferManagers, lineAnnotations, renderRange }: FileRenderProps<LAnnotation>): boolean;
+  protected finalizeRender(): void;
+  private emitPostRender;
+  private removeRenderedCode;
+  private clearAuxiliaryNodes;
+  private canPartiallyRender;
+  renderPlaceholder(height: number): boolean;
+  protected setPlaceholderHeight(height: number): boolean;
+  primeHighlightCache(file?: FileContents | undefined): Promise<void>;
+  private cleanChildNodes;
+  private renderAnnotations;
+  private renderGutterUtility;
+  private injectUnsafeCSS;
+  private applyThemeState;
+  private hydrateMeasuredScrollbar;
+  protected shouldGuardRebuildScroll(): boolean;
+  private applyFullRender;
+  private applyPartialRender;
+  private getColumns;
+  private trimDOMToOverlap;
+  private getDOMBoundaryIndices;
+  private getLineIndexFromDOMNode;
+  private applyBuffers;
+  protected shouldDisableVirtualizationBuffers(): boolean;
+  private applyHeaderToDOM;
+  private clearHeaderSlots;
+  private upsertHeaderSlotElement;
+  private replaceHeaderSlotContent;
+  private createHeaderSlotElement;
+  protected getOrCreateFileContainerNode(fileContainer?: HTMLElement, parentNode?: HTMLElement): HTMLElement;
+  private adoptReusableShellElements;
+  private ensureSpriteSVG;
+  private getOrCreatePreNode;
+  private syncCodeNodeFromPre;
+  private applyPreNodeAttributes;
+  private applyErrorToDOM;
+  private cleanupErrorWrapper;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/managers/ScrollSyncManager.d.ts
+//#region src/managers/ScrollSyncManager.d.ts
+declare class ScrollSyncManager {
+  isDeletionsScrolling: boolean;
+  isAdditionsScrolling: boolean;
+  timeoutId: NodeJS.Timeout;
+  codeDeletions: HTMLElement | undefined;
+  codeAdditions: HTMLElement | undefined;
+  private enabled;
+  cleanUp(): void;
+  setup(pre: HTMLPreElement, codeDeletions?: HTMLElement, codeAdditions?: HTMLElement): void;
+  private handleDeletionsScroll;
+  private handleAdditionsScroll;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/utils/iterateOverDiff.d.ts
+//#region src/utils/iterateOverDiff.d.ts
+interface DiffLineMetadata {
+  unifiedLineIndex: number;
+  splitLineIndex: number;
+  lineIndex: number;
+  lineNumber: number;
+  noEOFCR: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/renderers/DiffHunksRenderer.d.ts
+//#region src/renderers/DiffHunksRenderer.d.ts
+interface DiffHunksRendererOptions extends BaseDiffOptions {
+  headerRenderMode?: FileHeaderRenderMode;
+}
+interface DiffHunksRendererOptionsWithDefaults extends Omit<BaseDiffOptionsWithDefaults, 'themeType'> {
+  headerRenderMode: FileHeaderRenderMode;
+}
+interface UnifiedLineDecorationProps {
+  type: 'context' | 'context-expanded' | 'change';
+  lineType: LineTypes;
+  additionLineIndex: number | undefined;
+  deletionLineIndex: number | undefined;
+}
+interface SplitLineDecorationProps {
+  side: 'deletions' | 'additions';
+  type: 'context' | 'context-expanded' | 'change';
+  lineIndex: number | undefined;
+}
+interface LineDecoration {
+  gutterLineType: LineTypes;
+  gutterProperties?: Properties;
+  contentProperties?: Properties;
+}
+interface RenderedLineContext {
+  type: 'context' | 'context-expanded' | 'change';
+  hunkIndex: number;
+  lineIndex: number;
+  unifiedLineIndex: number;
+  splitLineIndex: number;
+  deletionLine?: DiffLineMetadata;
+  additionLine?: DiffLineMetadata;
+}
+interface InjectedRow {
+  content: Element$1;
+  gutter: Element$1;
+}
+interface SplitInjectedRow {
+  deletion: InjectedRow | undefined;
+  addition: InjectedRow | undefined;
+}
+interface UnifiedInjectedRowPlacement {
+  before?: InjectedRow[];
+  after?: InjectedRow[];
+}
+interface SplitInjectedRowPlacement {
+  before?: SplitInjectedRow[];
+  after?: SplitInjectedRow[];
+}
+interface HunksRenderResult {
+  fileDiff: FileDiffMetadata;
+  unifiedGutterAST: ElementContent[] | undefined;
+  unifiedContentAST: ElementContent[] | undefined;
+  deletionsGutterAST: ElementContent[] | undefined;
+  deletionsContentAST: ElementContent[] | undefined;
+  additionsGutterAST: ElementContent[] | undefined;
+  additionsContentAST: ElementContent[] | undefined;
+  hunkData: HunkData[];
+  css: string;
+  preNode: Element$1;
+  headerElement: Element$1 | undefined;
+  totalLines: number;
+  themeStyles: string;
+  baseThemeType: 'light' | 'dark' | undefined;
+  rowCount: number;
+  bufferBefore: number;
+  bufferAfter: number;
+}
+declare class DiffHunksRenderer<LAnnotation = undefined> {
+  options: DiffHunksRendererOptions;
+  private annotationSlotName;
+  private onRenderUpdate?;
+  private workerManager?;
+  readonly __id: string;
+  private highlighter;
+  private diff;
+  private expandedHunks;
+  private deletionAnnotations;
+  private additionAnnotations;
+  private computedLangs;
+  private renderCache;
+  private pendingHighlightResult;
+  private pendingStructuralRows;
+  private editSessionActive;
+  constructor(options?: DiffHunksRendererOptions, annotationSlotName?: (annotation: DiffLineAnnotation<LAnnotation>) => string, onRenderUpdate?: (() => unknown) | undefined, workerManager?: WorkerPoolManager | undefined);
+  cleanUp(): void;
+  recycle(): void;
+  /**
+   * Enter edit-session mode: hunk updates preserve the current region
+   * skeleton instead of recomputing hunks, and rendering happens locally
+   * with the token transformer forced on (worker-pool requests/results are
+   * suspended for this renderer). When the session was freshly cloned from
+   * `externalDiff`, compatible highlighted markup is detached from its external
+   * cache owner so the editor can reuse it without mutating shared data. An
+   * empty additions document gets one row for the editor's caret.
+   */
+  beginEditSession(diff: FileDiffMetadata, externalDiff?: FileDiffMetadata): void;
+  /** Leave edit-session mode. The exit recompute is the host's concern. */
+  endEditSession(): void;
+  /**
+   * Ensures that the DOM is compatible with editor render updates
+   */
+  editorRenderReady(): boolean;
+  /**
+   * Re-highlights the current diff in the background and stages the fresh
+   * result for the next render. Needed after an edit session's exit recompute:
+   * session passes plain-fill shifted lines in the cached result, and the
+   * recompute mutates the keyless session diff in place, so object identity
+   * alone would otherwise treat the stale highlight as current forever. The
+   * current result — content-correct, mostly highlighted — keeps rendering
+   * until the fresh one is promoted, so no interim paint drops highlighting.
+   */
+  refreshHighlightedResult(): Promise<void>;
+  private applyRefreshedResult;
+  get diffCache(): FileDiffMetadata | undefined;
+  clearRenderCache(): void;
+  setOptions(options: DiffHunksRendererOptions): void;
+  mergeOptions(options: Partial<DiffHunksRendererOptions>): void;
+  expandHunk(index: number, direction: ExpansionDirections, expansionLineCount?: number): void;
+  getExpandedHunk(hunkIndex: number): HunkExpansionRegion;
+  getExpandedHunksMap(): Map<number, HunkExpansionRegion>;
+  /** Replace the whole expansion map (session-exit expansion remapping). */
+  setExpandedHunksMap(expandedHunks: Map<number, HunkExpansionRegion>): void;
+  setLineAnnotations(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): void;
+  /**
+   * Returns true when a session-mode pass changed the region skeleton itself
+   * (a gap edit synthesized or merged regions), which changes the rendered
+   * row set without a line-count change — the host must escalate to a full
+   * re-render instead of its cheap refresh path.
+   */
+  updateRenderCache(dirtyLines: Map<number, Array<HighlightedToken>>, themeType: 'dark' | 'light', lineCountChangeInFlight?: boolean, changedDocumentLines?: ReadonlyMap<number, string>, documentLineCount?: number): boolean;
+  private applyExpansionRemap;
+  applyDocumentChange(textDocument: TextDocument<'file-diff', LAnnotation>): void;
+  private applySessionDocumentChange;
+  private applyRecomputePreservingSessionType;
+  private markEditSessionPass;
+  protected getUnifiedLineDecoration({ lineType }: UnifiedLineDecorationProps): LineDecoration;
+  protected getSplitLineDecoration({ side, type }: SplitLineDecorationProps): LineDecoration;
+  private createAnnotationElement;
+  protected getUnifiedInjectedRowsForLine?: (ctx: RenderedLineContext) => UnifiedInjectedRowPlacement | undefined;
+  protected getSplitInjectedRowsForLine?: (ctx: RenderedLineContext) => SplitInjectedRowPlacement | undefined;
+  protected getOptionsWithDefaults(): DiffHunksRendererOptionsWithDefaults;
+  initializeHighlighter(): Promise<DiffsHighlighter>;
+  hydrate(diff: FileDiffMetadata | undefined): void;
+  private getLocalHighlightTheme;
+  getEffectiveCodeOptions(): Pick<BaseCodeOptions, 'theme' | 'tokenizeMaxLineLength'>;
+  private getRenderOptions;
+  /**
+   * Returns the diff that the next synchronous render can commit without
+   * changing the renderer's current diff or render cache. Components use this
+   * to prepare state that must match the following DOM render.
+   */
+  getDiffForNextRender(diff: FileDiffMetadata): FileDiffMetadata;
+  private canRenderDiff;
+  renderDiff(diff?: FileDiffMetadata | undefined, renderRange?: RenderRange): HunksRenderResult | undefined;
+  asyncRender(diff: FileDiffMetadata, renderRange?: RenderRange): Promise<HunksRenderResult>;
+  protected createPreElement(split: boolean, totalLines: number, customProperties?: CustomPreProperties): Element$1;
+  private asyncHighlight;
+  private renderDiffWithHighlighter;
+  onHighlightSuccess(diff: FileDiffMetadata, result: ThemedDiffResult, options: RenderDiffOptions, highlighted?: boolean): void;
+  private applyHighlightResult;
+  private getMatchingWorkerResultCache;
+  private getReadyRenderResult;
+  private hasHighlightedRenderCache;
+  onHighlightError(error: unknown): void;
+  private getTokenizeMaxLength;
+  private processDiffResult;
+  renderCodeAST(type: 'unified' | 'deletions' | 'additions', result: HunksRenderResult): ElementContent[] | undefined;
+  renderFullAST(result: HunksRenderResult, children?: ElementContent[]): Element$1;
+  renderFullHTML(result: HunksRenderResult, tempChildren?: ElementContent[]): string;
+  renderPartialHTML(children: ElementContent[], columnType?: 'unified' | 'deletions' | 'additions'): string;
+  private pushFileLevelAnnotations;
+  private getAnnotations;
+  private getAnnotationNames;
+  private renderHeader;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/FileDiff.d.ts
+//#region src/components/FileDiff.d.ts
+type LoadedPartialDiffContents$1 = Awaited<ReturnType<NonNullable<BaseDiffOptions['loadDiffFiles']>>>;
+type DeferredSelectedLinesWrite = [range: SelectedLineRange | null, options: SelectionWriteOptions | undefined];
+type DeferredEditorActiveLineWrite = [lineNumber: number | null, options: EditorActiveLineOptions | undefined];
+interface UpdateRenderCacheOptions {
+  shouldRefreshDiffsView?: boolean;
+  lineCountChangeInFlight?: boolean;
+  changedDocumentLines?: ReadonlyMap<number, string>;
+  documentLineCount?: number;
+}
+interface FileDiffRenderBaseProps<LAnnotation> {
+  fileDiff?: FileDiffMetadata;
+  deferManagers?: boolean;
+  forceRender?: boolean;
+  preventEmit?: boolean;
+  fileContainer?: HTMLElement;
+  containerWrapper?: HTMLElement;
+  lineAnnotations?: DiffLineAnnotation<LAnnotation>[];
+  renderRange?: RenderRange;
+}
+type FileDiffRenderProps<LAnnotation> = FileDiffRenderBaseProps<LAnnotation> & MaybeDiffFileInput;
+type FileDiffHydrationProps<LAnnotation> = Omit<FileDiffRenderBaseProps<LAnnotation>, 'fileContainer'> & MaybeDiffFileInput & {
+  fileContainer: HTMLElement;
+  prerenderedHTML?: string;
+};
+type FileDiffType = 'file-diff' | 'unresolved-file';
+type FileDiffEditChangeHandler<LAnnotation, Caret> = (event: EditorChangeEvent<'file-diff', LAnnotation, Caret>) => void;
+/**
+ * Decides a completed edit synchronously: return `'accept'` to install the
+ * event's `fileDiff` and annotations, or `'reject'` to restore the original
+ * values. The event is frozen, so re-key the accepted diff in place
+ * (`event.fileDiff.cacheKey = '…'`) before accepting. The event's editor is
+ * detached and returns its final state from `getViewState()`. A missing handler
+ * rejects.
+ */
+type FileDiffEditCompleteHandler<LAnnotation, Caret> = (event: FileDiffEditCompleteEvent<LAnnotation, Caret>) => EditCompletionDecision;
+interface FileDiffOptions<LAnnotation, Caret> extends Omit<BaseDiffOptions, 'hunkSeparators'>, InteractionManagerBaseOptions<'diff'> {
+  hunkSeparators?: Exclude<HunkSeparators, 'custom'> | /**
+   * @deprecated Custom hunk separator functions are deprecated and will be
+   * removed in a future version.
+   */ ((hunk: HunkData, instance: FileDiff$1<LAnnotation, Caret>) => HTMLElement | DocumentFragment | null | undefined);
+  disableFileHeader?: boolean;
+  renderHeaderPrefix?: RenderHeaderPrefixCallback;
+  renderHeaderFilenameSuffix?: RenderHeaderFilenameSuffixCallback;
+  renderHeaderMetadata?: RenderHeaderMetadataCallback;
+  renderCustomHeader?: RenderHeaderMetadataCallback;
+  /**
+   * When true, errors during rendering are rethrown instead of being caught
+   * and displayed in the DOM. Useful for testing or when you want to handle
+   * errors yourself.
+   */
+  disableErrorHandling?: boolean;
+  renderAnnotation?(annotation: DiffLineAnnotation<LAnnotation>): HTMLElement | undefined;
+  renderGutterUtility?(getHoveredRow: () => GetHoveredLineResult<'diff'> | undefined): HTMLElement | null | undefined;
+  onPostRender?(node: HTMLElement, instance: FileDiff$1<LAnnotation, Caret>, phase: PostRenderPhase): unknown;
+  /**
+   * Fired for every document change of an active edit session on this
+   * component, with the same `EditorChangeEvent` the editor reports through
+   * its own `onChange`. Do not feed the event's file back into the component
+   * while the session is active.
+   */
+  onEditChange?: FileDiffEditChangeHandler<LAnnotation, Caret>;
+  /**
+   * Fired when `edit` toggles false or a component unmounts, including when the
+   * final contents are unchanged. If no callback is provided, the component
+   * reverts to the last `fileDiff` or `oldFile`/`newFiles` and annotations
+   * passed into it. The callback receives the detached editor with its final
+   * pre-detach state.
+   */
+  onEditComplete?: FileDiffEditCompleteHandler<LAnnotation, Caret>;
+}
+interface AnnotationElementCache<LAnnotation> {
+  element: HTMLElement;
+  annotation: DiffLineAnnotation<LAnnotation>;
+}
+interface CustomHunkElementCache {
+  element: HTMLElement;
+  hunkData: HunkData;
+}
+interface PendingFileLoad {
+  fileDiff: FileDiffMetadata;
+  promise: Promise<void>;
+}
+type HydrationSetup<LAnnotation> = {
+  fileDiff: FileDiffMetadata | undefined;
+  lineAnnotations: DiffLineAnnotation<LAnnotation>[] | undefined;
+} & MaybeDiffFileInput;
+interface HeaderCache {
+  lastRenderedHTML: string | undefined;
+  html: string | undefined;
+  fileDiff: FileDiffMetadata | undefined;
+}
+declare class FileDiff$1<LAnnotation = undefined, Caret = undefined> {
+  options: FileDiffOptions<LAnnotation, Caret>;
+  protected workerManager?: WorkerPoolManager | undefined;
+  protected isContainerManaged: boolean;
+  static LoadedCustomComponent: boolean;
+  readonly __id: string;
+  readonly type: FileDiffType;
+  protected fileContainer: HTMLElement | undefined;
+  protected spriteSVG: SVGElement | undefined;
+  protected pre: HTMLPreElement | undefined;
+  protected codeUnified: HTMLElement | undefined;
+  protected codeDeletions: HTMLElement | undefined;
+  protected codeAdditions: HTMLElement | undefined;
+  protected bufferBefore: HTMLElement | undefined;
+  protected bufferAfter: HTMLElement | undefined;
+  protected themeCSSStyle: HTMLStyleElement | undefined;
+  protected appliedThemeCSS: AppliedThemeStyleCache | undefined;
+  protected hasAdoptedThemeCSS: boolean;
+  protected unsafeCSSStyle: HTMLStyleElement | undefined;
+  protected appliedUnsafeCSS: string | undefined;
+  protected gutterUtilityContent: HTMLElement | undefined;
+  protected headerElement: HTMLElement | undefined;
+  protected headerPrefix: HTMLElement | undefined;
+  protected headerFilenameSuffix: HTMLElement | undefined;
+  protected headerMetadata: HTMLElement | undefined;
+  protected headerCustom: HTMLElement | undefined;
+  protected separatorCache: Map<string, CustomHunkElementCache>;
+  protected errorWrapper: HTMLElement | undefined;
+  protected placeHolder: HTMLElement | undefined;
+  protected hunksRenderer: DiffHunksRenderer<LAnnotation>;
+  protected resizeManager: ResizeManager;
+  protected scrollSyncManager: ScrollSyncManager;
+  protected interactionManager: InteractionManager<'diff'>;
+  protected annotationCache: Map<string, AnnotationElementCache<LAnnotation>>;
+  protected lineAnnotations: DiffLineAnnotation<LAnnotation>[];
+  protected managersDirty: boolean;
+  protected deletionFile?: FileContents | null;
+  protected additionFile?: FileContents | null;
+  fileDiff: FileDiffMetadata | undefined;
+  private editSession;
+  protected renderedDiff: FileDiffMetadata | undefined;
+  protected renderRange: RenderRange | undefined;
+  protected pendingFiles: PendingFileLoad | undefined;
+  protected appliedPreAttributes: PrePropertiesConfig | undefined;
+  protected headerCache: HeaderCache;
+  protected lastRowCount: number | undefined;
+  private mounted;
+  protected enabled: boolean;
+  protected editor: Editor<'file-diff', LAnnotation, Caret> | undefined;
+  protected refreshViewTimeout: ReturnType<typeof setTimeout> | undefined;
+  protected lineStateRefreshPending: boolean;
+  protected deferredSelectedLines: DeferredSelectedLinesWrite | undefined;
+  protected deferredEditorActiveLine: DeferredEditorActiveLineWrite | undefined;
+  constructor(options?: FileDiffOptions<LAnnotation, Caret>, workerManager?: WorkerPoolManager | undefined, isContainerManaged?: boolean);
+  protected handleHighlightRender: () => void;
+  private getTheme;
+  protected getHunksRendererOptions(options: FileDiffOptions<LAnnotation, Caret>): DiffHunksRendererOptions;
+  protected createHunksRenderer(options: FileDiffOptions<LAnnotation, Caret>): DiffHunksRenderer<LAnnotation>;
+  getLineIndex: GetLineIndexUtility;
+  protected getDiffForLineIndex(): FileDiffMetadata | undefined;
+  protected getLineIndexForDiff(fileDiff: FileDiffMetadata | undefined, lineNumber: number, side: SelectionSide): [number, number] | undefined;
+  setOptions(options: FileDiffOptions<LAnnotation, Caret> | undefined): void;
+  protected syncInteractionOptions(): void;
+  private mergeOptions;
+  setThemeType(themeType: ThemeTypes): void;
+  private applyCachedThemeState;
+  private hasThemeChanged;
+  getHoveredLine: () => GetHoveredLineResult<'diff'> | undefined;
+  getAnnotationSlotName: (annotation: LineAnnotation<LAnnotation> | DiffLineAnnotation<LAnnotation>) => string;
+  protected getLatestAnnotations(): DiffLineAnnotation<LAnnotation>[];
+  protected isNewAnnotations(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): boolean;
+  setLineAnnotations(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): void;
+  protected syncEditSessionAnnotationsFromEditor(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): boolean;
+  private canPartiallyRender;
+  setSelectedLines(range: SelectedLineRange | null, options?: SelectionWriteOptions): void;
+  setEditorActiveLine(lineNumber: number | null, options?: EditorActiveLineOptions): void;
+  protected flushDeferredLineState(): void;
+  flushManagers(): void;
+  protected shouldApplyColumnVariables(overflow: 'scroll' | 'wrap'): boolean;
+  getCodeScrollLeft(): number;
+  setCodeScrollLeft(position: number): void;
+  __getEffectiveCodeOptions(): BaseCodeOptions;
+  cleanUp(recycle?: boolean): void;
+  virtualizedSetup(): void;
+  hydrate({ fileContainer, prerenderedHTML, preventEmit, lineAnnotations, fileDiff, ...fileInputProps }: FileDiffHydrationProps<LAnnotation>): void;
+  protected hydrateElements(fileContainer: HTMLElement, prerenderedHTML: string | undefined): void;
+  protected hydrationSetup({ fileDiff, oldFile, newFile, lineAnnotations }: HydrationSetup<LAnnotation>): void;
+  rerender(): void;
+  onThemeChange(): void;
+  handleExpandHunk: (hunkIndex: number, direction: ExpansionDirections, expansionLineCountOverride?: number) => void;
+  expandHunk: (hunkIndex: number, direction: ExpansionDirections, expansionLineCountOverride?: number) => void;
+  protected loadFilesIfNecessary(): void;
+  /**
+   * In order to start an edit session, you must be using a `fileDiff` that
+   * includes the full contents for both files. In other words, `isPartial`
+   * must be false You can use `prepareForEditing` to hydrate if
+   * `loadDiffFiles` was passed in to `options`
+   */
+  __canAttachEditor(): boolean;
+  /**
+   * Load a partial diff before starting a new edit session. Call this before
+   * Editor.edit when the diff may still be partial; it resolves only when this
+   * instance has a complete diff to edit.
+   */
+  prepareForEditing(): Promise<void>;
+  /** Hydrate a diff if necessary  */
+  __prepareForEditing(): Promise<void> | undefined;
+  private loadFilesForDiff;
+  protected handleFilesLoaded(expectedDiff: FileDiffMetadata, files: LoadedPartialDiffContents$1): Promise<void>;
+  protected installHydratedSessionDiff(expectedDiff: FileDiffMetadata): boolean;
+  protected updateExternalDiff(incomingExternalDiff: FileDiffMetadata, lineAnnotations?: DiffLineAnnotation<LAnnotation>[]): boolean;
+  private installEditSession;
+  protected setHydratedState(files: LoadedPartialDiffContents$1): void;
+  render({ fileDiff, deferManagers, forceRender, preventEmit, lineAnnotations, fileContainer, containerWrapper, renderRange, ...fileInputProps }: FileDiffRenderProps<LAnnotation>): boolean;
+  protected finalizeRender(): void;
+  protected emitPostRender(unmount?: boolean): void;
+  protected getLatestDiff(fileDiff?: FileDiffMetadata | undefined): FileDiffMetadata | undefined;
+  protected getRenderedDiff(): FileDiffMetadata | undefined;
+  private syncRenderViewToEditor;
+  private computeEditorRenderRange;
+  /** @internal The editor applied or edited past the pending external replacement. */
+  __acknowledgeDocumentUpdate(): void;
+  /** @internal Settle annotations locally. */
+  __acceptEditorChange(event: EditorChangeEvent<'file-diff', LAnnotation, Caret>): void;
+  emitEditChange(event: EditorChangeEvent<'file-diff', LAnnotation, Caret>): void;
+  /**
+   * @internal Capture the current diff session, or return `undefined` when no
+   * complete compatible session exists.
+   *
+   * When `clone` is true, the returned lines and hunks are copied.
+   */
+  __captureDocumentSessionState(clone?: boolean): CapturedDiffSessionState | undefined;
+  /** @internal Associate this component with its editor for a render lifecycle. */
+  __attachEditor(editor: Editor<'file-diff', LAnnotation, Caret>): () => void;
+  /** @internal Resume rendering for the editor already associated with this component. */
+  __resumeEditor(editor: Editor<'file-diff', LAnnotation, Caret>): void;
+  private resumeEditorRendering;
+  private finishEditSession;
+  /**
+   * @internal
+   *
+   * Ends the edit session and settles which diff this component renders.
+   * Requires the editor to be detached first. Does nothing when no session
+   * exists, so callers can invoke it again safely after it has settled.
+   *
+   * `onEditComplete` receives the completed diff, current external diff,
+   * complete file pair, and both annotation collections even when the final
+   * text is unchanged. In `install` mode, accepting installs the completed diff
+   * and its annotations; rejecting or having no handler restores the external
+   * values. `discard` mode always restores the external values. An accepted
+   * diff cannot reuse the replaced diff's `cacheKey`.
+   */
+  __completeEditSession(editor: Editor<'file-diff', LAnnotation, Caret>, mode: 'install' | 'discard'): void;
+  private settleEditSession;
+  /**
+   * Run the session-end recompute: restore recompute-shaped hunks (a
+   * context-only region collapses away, boundaries re-derive), preserve
+   * expansion state best-effort via old-side anchors, and repaint through
+   * the session render path — which also invalidates virtualized layout,
+   * since nothing else does at exit now that editing does not flip
+   * expandUnchanged. Marker-guarded and idempotent; CodeView also calls this
+   * when ending a session whose detach closure was consumed by a recycle.
+   * Safe on a cleaned-up instance: the recompute is pure metadata work and
+   * the deferred rerender is enabled-guarded. Returns true when a recompute
+   * ran.
+   */
+  finalizeEditSessionHunks(): boolean;
+  applyDocumentChange(textDocument: TextDocument<'file-diff', LAnnotation>, newLineAnnotations?: DiffLineAnnotation<LAnnotation>[]): void;
+  /** Update the private diff without editor DOM, then rehighlight on return. */
+  applySuspendedDocumentChange(textDocument: TextDocument<'file-diff', LAnnotation>, newLineAnnotations?: DiffLineAnnotation<LAnnotation>[]): void;
+  updateRenderCache(dirtyLines: Map<number, Array<HighlightedToken>>, themeType: 'dark' | 'light', options?: UpdateRenderCacheOptions): void;
+  private detachAdditionLines;
+  isLineRenderable(lineNumber: number): boolean;
+  getNearestRenderableLine(lineNumber: number, direction: 'up' | 'down'): number | undefined;
+  revealLine(lineNumber: number): boolean;
+  protected shouldSelfHealEditSession(): boolean;
+  protected escalateEditSessionRender(): void;
+  private handleEditSessionRender;
+  private removeRenderedCode;
+  private clearAuxiliaryNodes;
+  renderPlaceholder(height: number): boolean;
+  protected setPlaceholderHeight(height: number): boolean;
+  primeHighlightCache(fileDiff?: FileDiffMetadata | undefined): Promise<void>;
+  private cleanChildNodes;
+  private renderSeparators;
+  protected renderAnnotations(): void;
+  protected renderGutterUtility(): void;
+  protected getOrCreateFileContainer(fileContainer?: HTMLElement, parentNode?: HTMLElement): HTMLElement;
+  private adoptReusableShellElements;
+  private ensureSpriteSVG;
+  private getOrCreatePreNode;
+  protected syncCodeNodesFromPre(pre: HTMLPreElement): void;
+  private applyHeaderToDOM;
+  protected clearReusableHeader(): void;
+  private clearHeaderSlots;
+  private upsertHeaderSlotElement;
+  private replaceHeaderSlotContent;
+  private createHeaderSlotElement;
+  protected injectUnsafeCSS(): void;
+  private applyThemeState;
+  private hydrateMeasuredScrollbar;
+  protected shouldGuardRebuildScroll(): boolean;
+  private applyHunksToDOM;
+  private applyCodeColumnsInPlace;
+  private replaceCodeColumns;
+  private applyPartialRender;
+  private insertPartialHTML;
+  private refreshSplitDiffView;
+  private refreshUnifiedDiffView;
+  private renderPartialColumn;
+  private mergeBuffersIfNecessary;
+  private applyRowSpan;
+  private trimColumnRows;
+  private trimColumns;
+  private getBufferSize;
+  private updateBufferSize;
+  private getColumnPair;
+  private getCodeColumns;
+  protected updateBuffers(renderRange: RenderRange): void;
+  private applyBuffers;
+  protected shouldDisableVirtualizationBuffers(): boolean;
+  protected applyPreNodeAttributes(pre: HTMLPreElement, { additionsContentAST, deletionsContentAST, totalLines }: HunksRenderResult, customProperties?: CustomPreProperties): void;
+  private applyErrorToDOM;
+  private cleanupErrorWrapper;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/command.d.ts
+//#region src/editor/command.d.ts
+type EditorCommand = 'indent' | 'outdent' | 'indentLess' | 'indentMore' | 'undo' | 'redo' | 'selectAll' | 'findNextMatch' | 'openSearchPanel' | 'openSearchReplacePanel' | 'moveLineUp' | 'moveLineDown' | 'copyLineUp' | 'copyLineDown' | 'simplifySelection' | 'insertBlankLine' | 'deleteHardLineForward' | 'toggleComment' | 'toggleBlockComment' | 'moveCursorToDocStart' | 'moveCursorToDocEnd' | 'expandSelectionDocStart' | 'expandSelectionDocEnd';
+type KeyboardKey = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '`' | '-' | '=' | ',' | '.' | '/' | ';' | "'" | '[' | ']' | '\\' | 'Space' | 'Tab' | 'Enter' | 'Escape' | 'Backspace' | 'Delete' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End' | 'PageUp' | 'PageDown' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12';
+type KeyboardModifier = 'cmdOrCtrl' | 'shift' | 'alt' | 'ctrl' | 'cmd';
+type EditorShortcut = KeyboardKey | `${KeyboardModifier}+${KeyboardKey}` | `${KeyboardModifier}+${KeyboardModifier}+${KeyboardKey}`;
+/** Later groups take precedence when bindings overlap. */
+type EditorKeymap = ReadonlyArray<{
+  /** Undefined applies on every platform. */
+  readonly platform?: 'mac' | 'windows' | 'linux';
+  readonly bindings: Readonly<Partial<Record<EditorShortcut, EditorCommand>>>;
+}>;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/editPrediction.d.ts
+//#region src/editor/editPrediction.d.ts
+interface EditPredictRequest {
+  /** Current file name/path as supplied to the File or FileDiff component. */
+  readonly path: string;
+  /** Document version. */
+  readonly version: number;
+  /** Document end-of-line sequence. */
+  readonly eol: '\n' | '\r\n' | '\r';
+  /** Bounded slice of the file around the cursor (not the whole file). */
+  readonly excerptText: string;
+  /** Zero-based document line where the excerpt starts. */
+  readonly excerptStartLine: number;
+  /** UTF-16 cursor offset relative to `excerptText`. */
+  readonly cursorOffsetInExcerpt: number;
+  /** Half-open UTF-16 range within `excerptText` that may be edited. */
+  readonly editableRange: {
+    readonly start: number;
+    readonly end: number;
+  };
+  /** Chronological, bounded edit history for this document. */
+  readonly editHistory: ReadonlyArray<{
+    /** Edit in unified-diff format. */
+    readonly diff: string;
+    /** Edit source. */
+    readonly source: 'user' | 'prediction';
+  }>;
+}
+interface EditPredictContext {
+  /** Aborted when the document or cursor changes. */
+  readonly signal: AbortSignal;
+}
+interface EditPredictResponse {
+  /** Non-overlapping edits using absolute document positions. */
+  readonly edits: readonly TextEdit[];
+  /** Absolute post-edit cursor position. */
+  readonly newCursor: Position;
+}
+interface EditPredictProvider {
+  /** Predicts the next edit for the given request. */
+  predict: (request: EditPredictRequest, context: EditPredictContext) => Promise<EditPredictResponse>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/languages.d.ts
+//#region src/editor/languages.d.ts
+interface LanguageConfig {
+  lineComment?: string | null;
+  blockComment?: readonly [open: string, close: string];
+}
+type LanguageConfigMap = Readonly<Record<string, LanguageConfig>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/marker.d.ts
+//#region src/editor/marker.d.ts
+type MarkerSeverity = 'error' | 'warning' | 'info' | 'hint';
+interface Marker extends Range {
+  severity: MarkerSeverity;
+  message: string | {
+    html: string;
+  } | HTMLElement;
+  source?: string;
+  metadata?: Record<string, unknown>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/selection.d.ts
+type AutoSurround = 'default' | 'never' | 'brackets' | 'quotes' | 'languageDefined';
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/selectionAction.d.ts
+//#region src/editor/selectionAction.d.ts
+interface SelectionActionContext<EType extends EditorType = EditorType, LAnnotation = unknown> {
+  /** The current selection (live: reflects keyboard-driven changes). */
+  selection: EditorSelection;
+  /** The text document. */
+  textDocument: TextDocument<EType, LAnnotation>;
+  /** Applies the edits to the text document. */
+  applyEdits: (edits: TextEdit[]) => void;
+  /** Gets the text of the current selection. */
+  getSelectionText: () => string;
+  /** Replaces the text of the current selection. */
+  replaceSelectionText: (text: string) => void;
+  /** Closes the selection action. */
+  close: () => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/editor.d.ts
+//#region src/editor/editor.d.ts
+interface SyncRenderViewBaseProps {
+  highlighter: DiffsHighlighter;
+  fileContainer: HTMLElement;
+  renderRange: RenderRange | undefined;
+  /** Start fresh history instead of retaining or extending the current history. */
+  resetHistory?: boolean;
+}
+interface SyncFileRenderViewProps<LAnnotation> extends SyncRenderViewBaseProps {
+  file: FileContents;
+  lineAnnotations: LineAnnotation<LAnnotation>[] | undefined;
+  /** Treat the supplied contents as an externally provided document update. */
+  externalDocument?: boolean;
+}
+interface SyncDiffRenderViewProps<LAnnotation> extends SyncRenderViewBaseProps {
+  fileDiff: FileDiffMetadata;
+  lineAnnotations: DiffLineAnnotation<LAnnotation>[] | undefined;
+  /** Treat the supplied contents as an externally provided document update. */
+  externalDocument?: boolean;
+}
+type SyncRenderViewProps<EType extends EditorType, LAnnotation> = EType extends 'file' ? SyncFileRenderViewProps<LAnnotation> : SyncDiffRenderViewProps<LAnnotation>;
+type EditorComponent<EType extends EditorType, LAnnotation, Caret> = EType extends 'file' ? File<LAnnotation, Caret> : FileDiff$1<LAnnotation, Caret>;
+interface EditorOptions<EType extends EditorType, LAnnotation, Caret> {
+  /** The maximum number of entries to keep in the undo stack. */
+  historyMaxEntries?: number;
+  /**
+   * Retain and restore the attached component's vertical viewport position.
+   * Defaults to false because scroll views generally contain multiple items.
+   * This option is captured when the editor is constructed.
+   */
+  ownsVerticalViewport?: boolean;
+  /**
+   * Document and editor state transferred to the first attachment. Missing
+   * fields are initialized from the attached component. The editor takes
+   * ownership and does not clone supplied objects.
+   */
+  initialState?: EditorInitialState<EType, LAnnotation>;
+  /** Custom keymap groups checked before defaults; later groups take precedence. */
+  keymap?: EditorKeymap;
+  /** Render rounded corners for selection ranges, default is true. */
+  roundedSelection?: boolean;
+  /** Highlight matching brackets near the caret, default is true. */
+  matchBrackets?: boolean;
+  /**
+   * Controls auto-surround when typing quotes or brackets over a selection.
+   * Default is `"default"` (both quotes and brackets).
+   */
+  autoSurround?: AutoSurround;
+  /** Per-language comment tokens used by the comment commands. */
+  languageCommentConfig?: LanguageConfigMap;
+  /**
+   * Show a floating selection action popover after a user-created selection.
+   * Defaults to disabled. Programmatic selection updates do not open it.
+   */
+  enabledSelectionAction?: boolean;
+  /**
+   * Configuration for inline edit prediction.
+   */
+  editPrediction?: {
+    /**
+     * The edit prediction mode.
+     * - 'eager': predictions appear inline when the user types.
+     * - 'subtle': pressing the `Alt` key toggles predictions inline.
+     * @default 'eager'
+     */
+    mode?: 'eager' | 'subtle';
+    /**
+     * The edit prediction provider.
+     */
+    provider: EditPredictProvider;
+    /**
+     * Glob or regular-expression patterns for files to include in prediction.
+     * String patterns support `?`, segment-local `*`, and cross-segment `**`.
+     * An empty array matches no files.
+     */
+    include?: readonly (string | RegExp)[];
+    /**
+     * Glob or regular-expression patterns for files to exclude from prediction.
+     * String patterns support `?`, segment-local `*`, and cross-segment `**`.
+     * Exclusions take precedence over inclusions.
+     */
+    exclude?: readonly (string | RegExp)[];
+  };
+  /**
+   * Custom clipboard provider.
+   * Highly recommended to use native clipboard API if you are building an electron app.
+   * see https://www.electronjs.org/docs/latest/api/clipboard
+   */
+  clipboard?: {
+    readText: (type?: string) => Promise<string> | string;
+  };
+  /** Render the selection action widget element. */
+  renderSelectionAction?: (context: SelectionActionContext<EType, LAnnotation>) => HTMLElement;
+  /**
+   * Render an externally owned caret at its normalized document position.
+   */
+  renderCaret?: (caret: EditorCaret<Caret>) => HTMLElement;
+  /** Callback when the editor is attached to a file. */
+  onAttach?: (editor: Editor<EType, LAnnotation, Caret>, fileInstance: EditorComponent<EType, LAnnotation, Caret>) => void;
+  /**
+   * Called with an `EditorChangeEvent` whenever the editor document changes.
+   * Treat this as a document notification; do not feed the changes back into
+   * the editor or you will create loops.
+   */
+  onChange?: (event: EditorChangeEvent<EType, LAnnotation, Caret>) => void;
+  /**
+   * Observes completion with the same frozen event sent to the component. Runs
+   * before the component callback, including when the component callback is
+   * missing. There is no way to accept or reject from this API.
+   */
+  onComplete?: (event: EditorEditCompleteEvent<EType, LAnnotation, Caret>) => void;
+  /** Callback when the editor gains focus. */
+  onFocus?: () => void;
+  /** Callback when the editor loses focus. */
+  onBlur?: () => void;
+  __debug?: boolean;
+}
+interface EditorFocusOptions extends FocusOptions {
+  /** One-based document line number or first editable line with a visible top. */
+  lineNumber?: number | 'first-visible';
+  /** Zero-based character offset for a numeric line. Defaults to 0. */
+  character?: number;
+  /** Non-negative CSS pixels below the viewport or sticky header. */
+  offset?: number;
+}
+declare class Editor<EType extends EditorType = EditorType, LAnnotation = undefined, Caret = undefined> {
+  #private;
+  readonly type: EType;
+  /**
+   * @param type The component surface this editor can attach to.
+   * @param options Configure editor behavior and lifecycle callbacks.
+   * @param editStateKey Retain this editable draft and its undo/redo history
+   * in memory so a later editor using the same type and key can resume them.
+   */
+  constructor(type: EType, options?: EditorOptions<EType, LAnnotation, Caret>, editStateKey?: string);
+  setOptions(options: EditorOptions<EType, LAnnotation, Caret>): void;
+  __emitEditComplete(event: EditorEditCompleteEvent<EType, LAnnotation, Caret>): void;
+  /** @internal */
+  __getGhostTextRows(): ReadonlyMap<number, number>;
+  setCarets(carets: EditorCaret<Caret>[]): void;
+  edit<T extends EditorComponent<EType, LAnnotation, Caret>>(fileInstance: T extends {
+    readonly type: 'unresolved-file';
+  } ? never : T): () => void;
+  /**
+   * Apply edits to current attached file. Every edit joins the undo timeline:
+   * a programmatic edit must leave the document and its history exactly as
+   * the same edit typed by the user would (history equivalence — see
+   * TextDocument.applyResolvedEdits), so it is undoable like any other edit.
+   *
+   * @param updateHistory Whether to record caller selection snapshots for
+   * exact undo/redo restoration. Defaults to true. When false, live selections
+   * are remapped during replay and the text edit still joins the undo timeline.
+   */
+  applyEdits(edits: TextEdit[], updateHistory?: boolean): void;
+  /** Whether there is an edit to undo. */
+  get canUndo(): boolean;
+  /** Whether there is an undone edit to redo. */
+  get canRedo(): boolean;
+  /** Undo the last edit. Does nothing when there is nothing to undo. */
+  undo(): void;
+  /** Redo the last undone edit. Does nothing when there is nothing to redo. */
+  redo(): void;
+  getFile(): FileContents | undefined;
+  getText(): string;
+  /** Return an isolated copy of selections and restorable view state. */
+  getViewState(): EditorViewState;
+  /**
+   * Return the objects that make up the active edit session, or undefined when
+   * no complete session exists.
+   */
+  getEditState(): EditState<EType, LAnnotation> | undefined;
+  setViewState({ selections, view }: EditorViewState): void;
+  setSelections(selections: (Range & {
+    direction: 'none' | 'backward' | 'forward';
+  })[]): void;
+  setMarkers(markers: Marker[]): void;
+  focus(options?: EditorFocusOptions): void;
+  blur(): void;
+  cleanUp(reason?: 'discard' | 'recycle' | 'complete'): void;
+  /** @internal */
+  __postponeBgTokenizeToNextFrame(): void;
+  /** @internal */
+  __captureFocusForDOMReplacement(): void;
+  /** @internal */
+  __getDocumentContents(fallbackFile?: FileContents): FileContents | undefined;
+  /** @internal */
+  __getDocumentSessionState(): RetainedDiffSessionSnapshot | undefined;
+  /** @internal */
+  __syncRenderView(props: SyncRenderViewProps<EType, LAnnotation>): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/editor/types.d.ts
+//#region src/editor/types.d.ts
+/** FileDiff baseline and hunk state needed to resume an editing session. */
+interface RetainedDiffSessionSnapshot {
+  oldFile: {
+    name: string;
+    lines: string[];
+  } | null;
+  type: ChangeTypes;
+  hunks: Hunk[];
+}
+/** @internal Current diff state and whether the document changed while editing. */
+interface CapturedDiffSessionState {
+  diffSession: RetainedDiffSessionSnapshot;
+  hasChanges: boolean;
+}
+/**
+ * An edit-completion handler's decision: `'accept'` installs the completed
+ * value the event carries, `'reject'` restores the external input. The event
+ * is frozen, so re-key the accepted value in place (`event.file.cacheKey =
+ * '…'`) before returning `'accept'`.
+ */
+type EditCompletionDecision = 'accept' | 'reject';
+interface EditorActiveLineOptions {
+  lineNumberOnly?: boolean;
+  side?: SelectionSide;
+}
+type EditorType = 'file' | 'file-diff';
+/**
+ * Position in a text document expressed as zero-based line and character offset.
+ * The offsets are based on a UTF-16 string representation. So a string of the form
+ * `a𐐀b` the character offset of the character `a` is 0, the character offset of `𐐀`
+ * is 1 and the character offset of b is 3 since `𐐀` is represented using two code
+ * units in UTF-16.
+ *
+ * Positions are line end character agnostic. So you can not specify a position that
+ * denotes `\r|\n` or `\n|` where `|` represents the character offset.
+ */
+interface Position {
+  /**
+   * Line position in a document (zero-based).
+   *
+   * If a line number is greater than the number of lines in a document, it
+   * defaults back to the number of lines in the document.
+   * If a line number is negative, it defaults to 0.
+   *
+   * The above two properties are implementation specific.
+   */
+  readonly line: number;
+  /**
+   * Character offset on a line in a document (zero-based).
+   *
+   * The meaning of this offset is determined by the negotiated
+   * `PositionEncodingKind`.
+   *
+   * If the character value is greater than the line length it defaults back
+   * to the line length. This property is implementation specific.
+   */
+  readonly character: number;
+}
+/**
+ * A range in a text document expressed as (zero-based) start and end positions.
+ *
+ * If you want to specify a range that contains a line including the line ending
+ * character(s) then use an end position denoting the start of the next line.
+ * For example:
+ * ```ts
+ * {
+ *     start: { line: 5, character: 23 }
+ *     end : { line 6, character : 0 }
+ * }
+ * ```
+ */
+interface Range {
+  /**
+   * The range's start position.
+   */
+  readonly start: Position;
+  /**
+   * The range's end position.
+   */
+  readonly end: Position;
+}
+/**
+ * A text edit applicable to a text document.
+ */
+interface TextEdit {
+  /**
+   * The range of the text document to be manipulated. To insert
+   * text into a document create a range where start === end.
+   */
+  readonly range: Range;
+  /**
+   * The string to be inserted. For delete operations use an
+   * empty string.
+   */
+  readonly newText: string;
+}
+/** Different with `TextEdit`, the range has been resolved to offsets. */
+interface ResolvedTextEdit {
+  /** The start offset of the text change. */
+  readonly start: number;
+  /** The end offset of the text change. */
+  readonly end: number;
+  /** The string to be inserted. For delete operations use an empty string. */
+  readonly text: string;
+}
+/** A normalized text change reported by the editor. */
+interface EditorChange extends ResolvedTextEdit {
+  /** The replaced range in the document before the change. */
+  range: Range;
+}
+type EditorLineAnnotation<EType extends EditorType = EditorType, LAnnotation = unknown> = EType extends 'file' ? LineAnnotation<LAnnotation> & {
+  side?: never;
+} : DiffLineAnnotation<LAnnotation>;
+/** The document and normalized edits reported after an editor change. */
+type EditorChangeEvent<EType extends EditorType, LAnnotation, Caret> = EType extends EditorType ? {
+  changes: EditorChange[];
+  file: FileContents;
+  editor: Editor<EType, LAnnotation, Caret>;
+  lineAnnotations?: EditorLineAnnotation<EType, LAnnotation>[];
+} : never;
+/**
+ * The direction of a selection.
+ * -1: backward
+ *  0: none
+ *  1: forward
+ */
+type SelectionDirection = -1 | 0 | 1;
+interface EditorSelection extends Range {
+  direction: SelectionDirection;
+}
+/** Visual metadata shared by a remote caret and its optional highlight. */
+interface CaretMetadata {
+  /** CSS color used for the caret and its derived highlight tint. */
+  color: string;
+}
+/**
+ * A non-editable, externally owned selection. This follows the browser's
+ * anchor/focus model: matching positions render a caret, and differing
+ * positions render a highlighted selection with its caret at `focus`.
+ */
+interface EditorCaret<T> {
+  anchor: Position;
+  focus: Position;
+  metadata: T & CaretMetadata;
+}
+interface EditorViewportState {
+  /** Horizontal position owned by the current editable code scroller. */
+  scrollLeft: number;
+  /** Vertical position of the editor viewport. */
+  scrollTop?: number;
+}
+interface EditorViewState {
+  selections?: EditorSelection[];
+  view?: EditorViewportState;
+}
+/**
+ * `onEditComplete` event argument when a file edit session ends.
+ *
+ * `file` is a fresh FileContents with the final contents and no `cacheKey` set;
+ * accepting installs it.
+ *
+ * `originalFile` is the last `file` the component was given externally; a
+ * revert restores it.
+ *
+ * `lineAnnotations` is the completed annotation collection, potentially
+ * modified based on the edit changes to keep annotations aligned to their
+ * intended targets.
+ *
+ * `originalLineAnnotations` is the last collection provided to the component
+ * externally, which a revert keeps.
+ */
+interface FileEditCompleteEvent<LAnnotation, Caret> {
+  file: FileContents;
+  editor: Editor<'file', LAnnotation, Caret>;
+  lineAnnotations: LineAnnotation<LAnnotation>[] | undefined;
+  originalFile: FileContents;
+  originalLineAnnotations: LineAnnotation<LAnnotation>[];
+}
+/**
+ * `onEditComplete` event argument when a diff edit session ends.
+ *
+ * `fileDiff` is a freshly computed diff of the final contents with no
+ * `cacheKey` set; accepting installs it.
+ *
+ * `originalFileDiff` is the last `fileDiff` the component was given externally;
+ * a revert restores it.
+ *
+ * `oldFile`/`newFile` are the completed contents as a file pair, for updating
+ * file-pair or patch inputs. `null` marks the absent side of an added file (a
+ * deleted file cannot be edited).
+ *
+ * `lineAnnotations` is the completed annotation collection, potentially
+ * modified based on the edit changes to keep annotations aligned to their
+ * intended targets.
+ *
+ * `originalLineAnnotations` is the last collection provided to the component
+ * externally, which a revert keeps.
+ */
+interface FileDiffEditCompleteEvent<LAnnotation, Caret> {
+  fileDiff: FileDiffMetadata;
+  editor: Editor<'file-diff', LAnnotation, Caret>;
+  originalFileDiff: FileDiffMetadata;
+  oldFile: FileContents | null;
+  newFile: FileContents | null;
+  lineAnnotations: DiffLineAnnotation<LAnnotation>[] | undefined;
+  originalLineAnnotations: DiffLineAnnotation<LAnnotation>[];
+}
+/**
+ * The exact frozen file or diff completion event observed by the editor before
+ * the corresponding component completion callback.
+ */
+type EditorEditCompleteEvent<EType extends EditorType, LAnnotation, Caret> = EType extends 'file' ? FileEditCompleteEvent<LAnnotation, Caret> : FileDiffEditCompleteEvent<LAnnotation, Caret>;
+type EditHistoryCoalescingMode = 'insert' | 'backspace' | 'delete';
+/** One reversible document transaction. */
+interface EditHistoryEntry<EType extends EditorType, LAnnotation = unknown> {
+  forwardEdits: ResolvedTextEdit[];
+  inverseEdits: ResolvedTextEdit[];
+  versionBefore: number;
+  versionAfter: number;
+  selectionsBefore?: EditorSelection[];
+  selectionsAfter?: EditorSelection[];
+  lineAnnotationsBefore?: EditorLineAnnotation<EType, LAnnotation>[];
+  lineAnnotationsAfter?: EditorLineAnnotation<EType, LAnnotation>[];
+  coalescingMode?: EditHistoryCoalescingMode;
+  undoBoundary?: boolean;
+}
+/** Undo and redo history for a document. */
+interface EditHistoryState<EType extends EditorType, LAnnotation = unknown> {
+  undoStack: EditHistoryEntry<EType, LAnnotation>[];
+  redoStack: EditHistoryEntry<EType, LAnnotation>[];
+  maxEntries: number;
+  canCoalesce: boolean;
+}
+interface EditStateBase<EType extends EditorType, LAnnotation> {
+  document: TextDocument<EType, LAnnotation>;
+  fileInfo: Pick<FileContents, 'name' | 'lang'>;
+  editor: EditorViewState;
+}
+interface FileEditState<LAnnotation = unknown> extends EditStateBase<'file', LAnnotation> {
+  type: 'file';
+  diffSession?: never;
+}
+interface FileDiffEditState<LAnnotation = unknown> extends EditStateBase<'file-diff', LAnnotation> {
+  type: 'file-diff';
+  diffSession: RetainedDiffSessionSnapshot;
+}
+/**
+ * The editor-owned objects that make up a complete session. This state is
+ * transferred by reference when supplied as `initialState`.
+ */
+type EditState<EType extends EditorType = EditorType, LAnnotation = unknown> = EType extends 'file' ? FileEditState<LAnnotation> : FileDiffEditState<LAnnotation>;
+/** State supplied to a new editor, completed from the attached component. */
+type EditorInitialState<EType extends EditorType = EditorType, LAnnotation = unknown> = EType extends 'file' ? {
+  type: 'file';
+} & Partial<Omit<FileEditState<LAnnotation>, 'type'>> : {
+  type: 'file-diff';
+} & Partial<Omit<FileDiffEditState<LAnnotation>, 'type'>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/Virtualizer.d.ts
+//#region src/components/Virtualizer.d.ts
+interface SubscribedInstance {
+  onRender(dirty: boolean): boolean;
+  reconcileHeights(): boolean;
+  setVisibility(visible: boolean): void;
+}
+interface VirtualizerConfig {
+  /** Extra pixels rendered above and below the viewport to reduce blanking during fast scrolls. */
+  overscrollSize: number;
+  /** Margin used by IntersectionObserver to decide when items should be considered visible. */
+  intersectionObserverMargin: number;
+  /** Enables noisy resize logs to help tune metrics and investigate scroll jitter. */
+  resizeDebugging: boolean;
+}
+interface VirtualizerScrollOptions {
+  top: number;
+  behavior?: ScrollBehavior;
+}
+declare class Virtualizer {
+  static __STOP: boolean;
+  static __lastScrollPosition: number;
+  readonly __id: string;
+  readonly config: VirtualizerConfig;
+  type: 'simple';
+  private intersectionObserver;
+  private scrollTop;
+  private height;
+  private scrollHeight;
+  private windowSpecs;
+  private root;
+  private contentContainer;
+  private resizeObserver;
+  private observers;
+  private visibleInstances;
+  private visibleInstancesDirty;
+  private instancesChanged;
+  private reconcileQueue;
+  private scrollDirty;
+  private heightDirty;
+  private scrollHeightDirty;
+  private renderedObservers;
+  private connectQueue;
+  constructor(config?: Partial<VirtualizerConfig>);
+  setup(root: HTMLElement | Document, contentContainer?: Element): void;
+  instanceChanged(instance: SubscribedInstance, domDirty: boolean): void;
+  requestHeightReconcile(instance: SubscribedInstance): void;
+  getWindowSpecs(): VirtualWindowSpecs;
+  getRoot(): HTMLElement | Document | undefined;
+  isInstanceVisible(elementTop: number, elementHeight: number): boolean;
+  private handleContainerResize;
+  private setupWindow;
+  private setupElement;
+  cleanUp(): void;
+  getOffsetInScrollContainer(element: HTMLElement): number;
+  connect(container: HTMLElement, instance: SubscribedInstance): () => void;
+  disconnect(container: HTMLElement): void;
+  private handleWindowResize;
+  private handleWindowScroll;
+  private handleElementScroll;
+  private computeRenderRangeAndEmit;
+  private scrollFix;
+  private applyScrollFix;
+  private getScrollAnchor;
+  private handleIntersectionChange;
+  /** Return the logical vertical position for the scroll container */
+  getScrollTop(): number;
+  /** Scroll to a logical vertical position and queue the normal render pass. */
+  scrollTo({ top, behavior }: VirtualizerScrollOptions): void;
+  private clampScrollTop;
+  private getScrollHeight;
+  private getHeight;
+  markDOMDirty(): void;
+  private getScrollContainerElement;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/VirtualizedFileDiff.d.ts
+//#region src/components/VirtualizedFileDiff.d.ts
+type LoadedPartialDiffContents = Awaited<ReturnType<NonNullable<BaseDiffOptions['loadDiffFiles']>>>;
+declare class VirtualizedFileDiff<LAnnotation = undefined, Caret = undefined> extends FileDiff$1<LAnnotation, Caret> {
+  readonly __id: string;
+  readonly renderType = "virtualized";
+  top: number | undefined;
+  height: number;
+  private metrics;
+  private cache;
+  private isVisible;
+  private isSetup;
+  private virtualizer;
+  private layoutDirty;
+  private forceRenderOverride;
+  private currentCollapsed;
+  private pendingHydratedDiff;
+  private pendingExpansions;
+  private pendingRender;
+  constructor(options: FileDiffOptions<LAnnotation, Caret> | undefined, virtualizer: Virtualizer | CodeView$1<LAnnotation, Caret>, metrics?: Partial<VirtualFileMetrics>, workerManager?: WorkerPoolManager, isContainerManaged?: boolean);
+  setMetrics(metrics?: Partial<VirtualFileMetrics>, force?: boolean): void;
+  setLineAnnotations(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): void;
+  private syncLineAnnotations;
+  protected syncEditSessionAnnotationsFromEditor(lineAnnotations: DiffLineAnnotation<LAnnotation>[]): boolean;
+  private setFileAnnotationHeight;
+  private hasFileAnnotations;
+  private getLineHeight;
+  private getEstimatedLineHeight;
+  setOptions(options: FileDiffOptions<LAnnotation, Caret> | undefined): void;
+  setThemeType(themeType: ThemeTypes): void;
+  private resetLayoutCache;
+  private invalidateDerivedLayoutCache;
+  private applyGhostTextRows;
+  reconcileHeights(): boolean;
+  onRender: (dirty: boolean) => boolean;
+  flushManagers(): void;
+  updateCodeViewLayout(fileDiff: FileDiffMetadata, top: number, reset?: PendingCodeViewLayoutReset, lineAnnotations?: DiffLineAnnotation<LAnnotation>[]): number;
+  getLinePosition(lineNumber: number, side?: SelectionSide): {
+    top: number;
+    height: number;
+  } | undefined;
+  getEditorViewport(): HTMLElement | Document | undefined;
+  getNumericScrollAnchor(localViewportTop: number): NumericScrollLineAnchor | undefined;
+  getVirtualizedHeight(): number;
+  getAdvancedStickySpecs(windowSpecs?: RenderWindow): StickySpecs | undefined;
+  cleanUp(recycle?: boolean): void;
+  expandHunk: (hunkIndex: number, direction: ExpansionDirections, expansionLineCountOverride?: number) => void;
+  protected handleFilesLoaded(expectedDiff: FileDiffMetadata, files: LoadedPartialDiffContents): Promise<void>;
+  protected loadFilesIfNecessary(): void;
+  isLineRenderable(lineNumber: number): boolean;
+  /**
+   * Invalidate layout after an edit session changed the rendered row set
+   * without a line-count change (a mid-session region change or the exit
+   * recompute): estimated heights bake the hunk shapes in, and nothing else
+   * invalidates them now that editing does not flip expandUnchanged. Public
+   * so CodeView can run it when reaping a session whose instance was already
+   * released.
+   */
+  invalidateEditSessionLayout(): void;
+  protected escalateEditSessionRender(): void;
+  protected shouldSelfHealEditSession(): boolean;
+  setVisibility(visible: boolean): void;
+  rerender(): void;
+  syncGhostTextRows(): void;
+  applyDocumentChange(textDocument: TextDocument<'file-diff', LAnnotation>, newLineAnnotations?: DiffLineAnnotation<LAnnotation>[], shouldUpdateBuffer?: boolean): void;
+  private computeApproximateSize;
+  private getLayoutDiff;
+  private getActiveEstimatedHeight;
+  private ensureEstimatedDiffHeights;
+  private validateComputedHeight;
+  render({ fileContainer, fileDiff, forceRender, lineAnnotations, ...fileInputProps }?: FileDiffRenderProps<LAnnotation>): boolean;
+  protected finalizeRender(): void;
+  private updatePendingRender;
+  syncVirtualizedTop(): void;
+  protected shouldDisableVirtualizationBuffers(): boolean;
+  protected shouldGuardRebuildScroll(): boolean;
+  private isSimpleMode;
+  private isAdvancedMode;
+  private getVirtualizedTop;
+  private getSimpleVirtualizer;
+  private getAdvancedVirtualizer;
+  private isResizeDebuggingEnabled;
+  private getDiffStyle;
+  private getHunkSeparatorType;
+  private approximateLayoutCheckpoints;
+  private getLayoutCheckpointBeforeLineIndex;
+  private getLayoutCheckpointBeforeTop;
+  private getExpandedLineCount;
+  private getLayoutLineCount;
+  private computeRenderRangeFromWindow;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/CodeView.d.ts
+//#region src/components/CodeView.d.ts
+type CodeViewCreateEditorOptions<EType extends EditorType, LAnnotation, Caret> = Required<Pick<EditorOptions<EType, LAnnotation, Caret>, 'onChange'>>;
+type CodeViewEditor<LAnnotation, Caret> = Editor<'file', LAnnotation, Caret> | Editor<'file-diff', LAnnotation, Caret>;
+interface AdvancedVirtualizedBaseItem {
+  /** Current index of this record in the ordered items array. */
+  index: number;
+  /** Absolute top offset of this item inside the scroll content. */
+  top: number;
+  /** Total measured height reserved for this item. */
+  height: number;
+  /** Root <diffs-container> node currently mounted for this item, only exists
+   * when rendered. */
+  element: HTMLElement | undefined;
+  /** Last controlled version observed for this record. */
+  version: number | undefined;
+  /** Last CodeView option revision this item rendered with. */
+  renderedOptionsRevision: number;
+}
+interface CodeViewVirtualizedInstanceKey {
+  readonly __id: string;
+  readonly renderType: 'virtualized';
+}
+interface CodeViewDiffItemContext<LAnnotation, Caret> extends AdvancedVirtualizedBaseItem {
+  type: 'diff';
+  /** Latest item snapshot for this record. Controlled updates can replace it. */
+  item: CodeViewDiffItem<LAnnotation>;
+  /** Virtualized diff instance responsible for rendering this item. */
+  instance: VirtualizedFileDiff<LAnnotation, Caret>;
+}
+interface CodeViewFileItemContext<LAnnotation, Caret> extends AdvancedVirtualizedBaseItem {
+  type: 'file';
+  /** Latest item snapshot for this record. Controlled updates can replace it. */
+  item: CodeViewFileItem<LAnnotation>;
+  /** Virtualized file instance responsible for rendering this item. */
+  instance: VirtualizedFile<LAnnotation, Caret>;
+}
+type CodeViewContextItem<LAnnotation, Caret> = CodeViewDiffItemContext<LAnnotation, Caret> | CodeViewFileItemContext<LAnnotation, Caret>;
+interface CodeViewRenderedDiffItem<LAnnotation, Caret> {
+  id: string;
+  type: 'diff';
+  item: CodeViewDiffItem<LAnnotation>;
+  version: number | undefined;
+  element: HTMLElement;
+  instance: VirtualizedFileDiff<LAnnotation, Caret>;
+}
+interface CodeViewRenderedFileItem<LAnnotation, Caret> {
+  id: string;
+  type: 'file';
+  item: CodeViewFileItem<LAnnotation>;
+  version: number | undefined;
+  element: HTMLElement;
+  instance: VirtualizedFile<LAnnotation, Caret>;
+}
+type CodeViewRenderedItem<LAnnotation, Caret> = CodeViewRenderedDiffItem<LAnnotation, Caret> | CodeViewRenderedFileItem<LAnnotation, Caret>;
+interface CodeViewSlotSnapshot<LAnnotation, Caret> {
+  items: CodeViewRenderedItem<LAnnotation, Caret>[] | undefined;
+  header: HTMLElement | undefined;
+  footer: HTMLElement | undefined;
+}
+interface CodeViewLineSelection {
+  id: string;
+  range: SelectedLineRange;
+}
+interface CodeViewCoordinator<LAnnotation, Caret> {
+  hasHeaderRenderers: boolean;
+  hasAnnotationRenderer: boolean;
+  hasGutterRenderer: boolean;
+  onSnapshotChange(snapshot: CodeViewSlotSnapshot<LAnnotation, Caret> | undefined): void;
+}
+type CodeViewScrollListener<LAnnotation, Caret> = (scrollTop: number, viewer: CodeView$1<LAnnotation, Caret>) => void;
+type OverloadCallbackArgs<TCallback> = TCallback extends ((...args: infer TArgs) => unknown) ? TArgs : never;
+type CallbackReturn<TCallback> = TCallback extends ((...args: never[]) => infer TReturn) ? TReturn : never;
+type OverloadFileCallbackArgs<LAnnotation, Caret, TKey extends keyof FileOptions<LAnnotation, Caret>> = OverloadCallbackArgs<NonNullable<FileOptions<LAnnotation, Caret>[TKey]>>;
+type OverloadDiffCallbackArgs<LAnnotation, Caret, TKey extends keyof FileDiffOptions<LAnnotation, Caret>> = OverloadCallbackArgs<NonNullable<FileDiffOptions<LAnnotation, Caret>[TKey]>>;
+type CodeViewOptionCallback<LAnnotation, Caret, TKey extends keyof FileOptions<LAnnotation, Caret> & keyof FileDiffOptions<LAnnotation, Caret>> = {
+  (...args: [...OverloadFileCallbackArgs<LAnnotation, Caret, TKey>, context: CodeViewFileItemContext<LAnnotation, Caret>]): CallbackReturn<NonNullable<FileOptions<LAnnotation, Caret>[TKey]>>;
+  (...args: [...OverloadDiffCallbackArgs<LAnnotation, Caret, TKey>, context: CodeViewDiffItemContext<LAnnotation, Caret>]): CallbackReturn<NonNullable<FileDiffOptions<LAnnotation, Caret>[TKey]>>;
+};
+declare const CODE_VIEW_DIFF_OPTION_KEYS: readonly ['theme', 'disableLineNumbers', 'overflow', 'themeType', 'disableFileHeader', 'disableVirtualizationBuffers', 'preferredHighlighter', 'useCSSClasses', 'useTokenTransformer', 'tokenizeMaxLineLength', 'tokenizeMaxLength', 'unsafeCSS', 'diffStyle', 'diffIndicators', 'disableBackground', 'expandUnchanged', 'loadDiffFiles', 'parseDiffOptions', 'collapsedContextThreshold', 'lineDiffType', 'maxLineDiffLength', 'expansionLineCount', 'lineHoverHighlight', 'enableTokenInteractionsOnWhitespace', 'enableGutterUtility', '__debugPointerEvents', 'enableLineSelection', 'controlledSelection', 'disableErrorHandling'];
+type CodeViewDiffOptionKeys = (typeof CODE_VIEW_DIFF_OPTION_KEYS)[number];
+type CodeViewPassThroughOptions<LAnnotation, Caret> = Pick<FileDiffOptions<LAnnotation, Caret>, CodeViewDiffOptionKeys>;
+type CodeViewMode = 'file' | 'diff';
+interface CodeViewItemEditCompleteEventMap<LAnnotation, Caret> {
+  file: FileEditCompleteEvent<LAnnotation, Caret>;
+  diff: FileDiffEditCompleteEvent<LAnnotation, Caret>;
+}
+interface CodeViewModeItemMap<LAnnotation> {
+  file: CodeViewFileItem<LAnnotation>;
+  diff: CodeViewDiffItem<LAnnotation>;
+}
+type CodeViewItemEditCompleteHandler<LAnnotation, Caret> = <TMode extends CodeViewMode>(event: CodeViewItemEditCompleteEventMap<LAnnotation, Caret>[TMode], item: CodeViewModeItemMap<LAnnotation>[TMode], nextItem: CodeViewModeItemMap<LAnnotation>[TMode]) => EditCompletionDecision;
+declare const CODE_VIEW_SHARED_CALLBACK_KEYS: readonly ['renderCustomHeader', 'renderHeaderPrefix', 'renderHeaderFilenameSuffix', 'renderHeaderMetadata', 'renderAnnotation', 'renderGutterUtility', 'onPostRender', 'onGutterUtilityClick', 'onLineClick', 'onLineNumberClick', 'onLineEnter', 'onLineLeave', 'onTokenClick', 'onTokenEnter', 'onTokenLeave'];
+declare const CODE_VIEW_SELECTION_CALLBACK_KEYS: readonly ['onLineSelected', 'onLineSelectionStart', 'onLineSelectionChange', 'onLineSelectionEnd'];
+type CodeViewSharedCallbackKeys = (typeof CODE_VIEW_SHARED_CALLBACK_KEYS)[number];
+type CodeViewSelectionCallbackKeys = (typeof CODE_VIEW_SELECTION_CALLBACK_KEYS)[number];
+type CodeViewSharedCallbackOptions<LAnnotation, Caret> = { [TKey in CodeViewSharedCallbackKeys]?: CodeViewOptionCallback<LAnnotation, Caret, TKey>; };
+type CodeViewSelectionCallbackOptions<LAnnotation, Caret> = { [TKey in CodeViewSelectionCallbackKeys]?: CodeViewOptionCallback<LAnnotation, Caret, TKey>; };
+interface CodeViewOptions<LAnnotation, Caret> extends CodeViewPassThroughOptions<LAnnotation, Caret>, CodeViewSharedCallbackOptions<LAnnotation, Caret>, CodeViewSelectionCallbackOptions<LAnnotation, Caret> {
+  hunkSeparators?: Exclude<HunkSeparators, 'custom'>;
+  itemMetrics?: Partial<VirtualFileMetrics>;
+  pointerEventsOnScroll?: boolean;
+  smoothScrollSettings?: SmoothScrollSettings;
+  stickyHeaders?: boolean;
+  controlledSelection?: boolean;
+  onSelectedLinesChange?(selection: CodeViewLineSelection | null): void;
+  layout?: CodeViewLayout;
+  /**
+   * Return an in-memory retention key for an item's editable draft and
+   * undo/redo history. Called only when CodeView creates the item's editor.
+   */
+  getEditStateKey?(item: CodeViewItem<LAnnotation>): string | undefined;
+  /**
+   * Create an editor for an item entering edit mode (`edit: true`). Providing
+   * this option is what enables item editing. Pass the given options into the
+   * editor constructor — `new Editor(editorType, options, editStateKey)` —
+   * so CodeView can route document changes to `onItemEditChange` and retain
+   * history when requested. CodeView owns the returned editor's lifecycle: it
+   * associates with the edited item, suspends and resumes rendering across
+   * virtualization unmounts and collapse, and tears the editor down when the
+   * session ends (edit off or removal).
+   */
+  createEditor?<EType extends EditorType>(editorType: EType, options: CodeViewCreateEditorOptions<EType, LAnnotation, Caret>, editStateKey?: string): Editor<EType, LAnnotation, Caret>;
+  /**
+   * Called with the editor's `EditorChangeEvent` and the owning item whenever
+   * the edited document changes, from internal (edit) changes or external
+   * (CodeViewItem) changes. The event contains that same attached editor.
+   *
+   * Do not feed these changes back into item state.
+   */
+  onItemEditChange?(event: EditorChangeEvent<EditorType, LAnnotation, Caret>, item: CodeViewItem<LAnnotation>): void;
+  /**
+   * Called once when an edit session ends: edit to false, the item is removed
+   * from items, or the viewer tears down (`reset()`/`cleanUp()`, where the
+   * result is not installed because the viewer is going away). Collapse does
+   * not call it because the session remains active until the item expands.
+   *
+   * The event carries the completed `file`/`fileDiff` built from the edit
+   * session. `item` is the item that owned the session, and `nextItem` is
+   * the accepted replacement CodeView built from it: the event's completed
+   * value and annotations, `edit: false`, and a bumped `version`. Return
+   * `'accept'` to install the edit — CodeView applies `nextItem` through the
+   * item update path when the item still exists, and a controlled owner puts
+   * the same `nextItem` into its state — or `'reject'` to revert. The event is
+   * frozen; re-key the accepted value in place (`event.fileDiff.cacheKey =
+   * '…'`) before accepting. The event contains the detached editor with its
+   * final pre-detach state.
+   */
+  onItemEditComplete?: CodeViewItemEditCompleteHandler<LAnnotation, Caret>;
+  /** Render a non-virtualized element at the very start of the scroll content,
+   * before the first item. It is always rendered and scrolls with the content.
+   * Return the same element across calls and mutate it in place to update;
+   * height changes are measured automatically. */
+  renderCodeViewHeader?(): HTMLElement | undefined;
+  /** Render a non-virtualized element at the very end of the scroll content,
+   * after the last item. Always rendered; height changes are measured
+   * automatically. */
+  renderCodeViewFooter?(): HTMLElement | undefined;
+  /** Internal dev-only check to ensure your `itemMetrics` are correct.  Its
+   * automatically disabled in a production build because it will hurt
+   * performance fairly significantly */
+  __devOnlyValidateItemHeights?: boolean;
+}
+type CodeViewItemMap<LAnnotation, Caret> = Map<string, CodeViewContextItem<LAnnotation, Caret>>;
+declare class CodeView$1<LAnnotation = undefined, Caret = undefined> {
+  static __STOP: boolean;
+  static __lastScrollPosition: number;
+  type: 'advanced';
+  readonly config: VirtualizerConfig;
+  private items;
+  private idToItem;
+  private selectedLines;
+  private itemEditors;
+  private attachedEditors;
+  private instanceToItem;
+  private layoutDirtyIndex;
+  private pendingLayoutReset;
+  private renderOptionsRevision;
+  private slotCoordinator;
+  private slotSnapshot;
+  private scrollListeners;
+  private scrollHeight;
+  private containerHeight;
+  private scrollTop;
+  private scrollPageOffset;
+  private readonly scrollRebaseConfig;
+  private scrollDirty;
+  private scrollInteractionFixTimer;
+  private pointerEventsDisabled;
+  private codeOverflowFix;
+  private height;
+  private heightDirty;
+  private windowSpecs;
+  private renderState;
+  private itemMetricsCache;
+  private readonly fileOptionsPrototype;
+  private readonly diffOptionsPrototype;
+  private pendingScrollTarget;
+  private pendingLayoutAnchor;
+  private shouldFixContainerFocus;
+  private scrollAnimation;
+  private root;
+  private resizeObserver;
+  private container;
+  private stickyContainer;
+  private stickyOffset;
+  private header;
+  private footer;
+  private elementPool;
+  private elementPoolVersion;
+  private elementPoolTracker;
+  private pendingElementPool;
+  private options;
+  private workerManager;
+  private isReadySubscription;
+  private pendingHighlighterTheme;
+  private isContainerManaged;
+  constructor(options?: CodeViewOptions<LAnnotation, Caret>, workerManager?: WorkerPoolManager | undefined, isContainerManaged?: boolean);
+  private getLayout;
+  private getItemTopOffset;
+  private computeMetricsCache;
+  private getSmoothScrollSettings;
+  private shouldDisablePointerEvents;
+  private shouldValidateItemHeights;
+  private validateRenderedItemHeight;
+  private validateStickyContainerHeight;
+  private clearScrollInteractionTimer;
+  private suspendScrollInteractions;
+  private restoreScrollInteractions;
+  private syncLayout;
+  private reconcileHeaderFooterHosts;
+  private reconcileHost;
+  private setHostHeight;
+  private measureMountedHosts;
+  setup(root: HTMLElement): void;
+  reset(): void;
+  cleanUp(): void;
+  private cleanAllRenderedItems;
+  private primeScrollTarget;
+  private getElementPoolLimit;
+  private acquireElement;
+  private releaseRenderedItem;
+  private renderedItemOwnsFocus;
+  private fixContainerFocus;
+  private cleanElement;
+  private queueElementForPool;
+  private promotePendingPooledElements;
+  private isElementClean;
+  private getElementPoolSize;
+  private clearElementPool;
+  private invalidateElementPool;
+  private markElementPoolGenerationCurrent;
+  private isElementPoolGenerationCurrent;
+  private resolveEffectiveScrollBehavior;
+  scrollTo(target: CodeViewScrollTarget): void;
+  setSelectedLines(selection: CodeViewLineSelection | null, options?: SelectionWriteOptions): void;
+  getSelectedLines(): CodeViewLineSelection | null;
+  clearSelectedLines(options?: SelectionWriteOptions): void;
+  getItem(itemId: string): CodeViewItem<LAnnotation> | undefined;
+  /**
+   * Returns the editor while this item is being edited. Partial diffs get an
+   * editor after their files load; scrolling away or collapsing keeps it.
+   */
+  getEditor(itemId: string): CodeViewEditor<LAnnotation, Caret> | undefined;
+  updateItem(input: CodeViewItem<LAnnotation>): boolean;
+  updateItemId(oldId: string, newId: string): boolean;
+  addItem(input: CodeViewItem<LAnnotation>): void;
+  addItems(inputs: readonly CodeViewItem<LAnnotation>[]): void;
+  removeItem(itemId: string): boolean;
+  setItems(items: readonly CodeViewItem<LAnnotation>[]): void;
+  /**
+   * Append new records to the viewer while preserving existing layout state.
+   * This is the shared path for imperative adds and the append-only reconcile
+   * fast path, so it measures new items immediately and only triggers render
+   * once at the end.
+   */
+  private appendItemsInternal;
+  private canSkipRenderForAppend;
+  onThemeChange(): void;
+  setOptions(options: CodeViewOptions<LAnnotation, Caret> | undefined): void;
+  capturePendingLayoutAnchor(nextItems?: Readonly<CodeViewItemMap<LAnnotation, Caret>>): void;
+  render(immediate?: boolean): void;
+  private isReady;
+  private clearReadySubscription;
+  private isSharedHighlighterReady;
+  instanceChanged(instance: CodeViewVirtualizedInstanceKey, layoutDirty: boolean): void;
+  getWindowSpecs(): VirtualWindowSpecs;
+  getContainerElement(): HTMLElement | undefined;
+  getHeaderElement(): HTMLElement | undefined;
+  getFooterElement(): HTMLElement | undefined;
+  getRenderedItems(): CodeViewRenderedItem<LAnnotation, Caret>[];
+  setSlotCoordinator(coordinator?: CodeViewCoordinator<LAnnotation, Caret>): boolean;
+  getSlotSnapshot(coordinator: CodeViewCoordinator<LAnnotation, Caret>): CodeViewSlotSnapshot<LAnnotation, Caret> | undefined;
+  private buildSlotSnapshot;
+  subscribeToScroll(listener: CodeViewScrollListener<LAnnotation, Caret>): () => void;
+  getLocalTopForInstance(instance: CodeViewVirtualizedInstanceKey): number;
+  getTopForItem(id: string): number | undefined;
+  private createItem;
+  private applySelectedLines;
+  private syncSelection;
+  private isItemInEditMode;
+  /**
+   * Lazily create and attach the editor for a mounted edit-mode item. Called
+   * from the render loop so every mounted item passes through it: fresh
+   * mounts, remounts after virtualization released the item, and items whose
+   * edit flag was just turned on. Editors persist across unmounts, so a
+   * remounted item resumes its existing editor and retained document; the
+   * instance retains its private session model so the remount
+   * paints the edited text without changing the host input.
+   */
+  private attachItemEditor;
+  /**
+   * Reconcile the editors CodeView is holding: complete sessions for items
+   * whose edit turned off or that were removed, and suspend sessions for
+   * collapsed items (the editor tears down, the record and the instance's
+   * session stay for the next expand). Attachment happens in the render loop
+   * via attachItemEditor.
+   */
+  private syncItemEditors;
+  private requireItemFromState;
+  /**
+   * Item-instance `onEditComplete` adapter for file items: builds the
+   * accepted next item, hands it to `onItemEditComplete` alongside the event
+   * and the owning item, and translates the identity of the returned item to
+   * the component return contract.
+   */
+  private completeFileItemEdit;
+  /**
+   * Item-instance `onEditComplete` adapter for diff items; see
+   * completeFileItemEdit.
+   */
+  private completeDiffItemEdit;
+  private renamePendingScrollTarget;
+  private renamePendingLayoutAnchor;
+  private createFileOptionsPrototype;
+  private createDiffOptionsPrototype;
+  private createFileOptions;
+  private createDiffOptions;
+  private updateItemOptionsId;
+  private getItemOptions;
+  private defineItemSharedCallback;
+  private defineItemSelectionCallback;
+  /**
+   * Track the earliest index whose measured layout may now be stale. Later
+   * render passes relayout from this point forward so we do not have to rebuild
+   * positions for the whole list after every change.
+   */
+  private markLayoutDirtyFromIndex;
+  /**
+   * Mark the earliest affected item as layout-dirty after an imperative change.
+   * Each record carries its current array index so this stays O(1) even when
+   * the viewer holds a very large number of items.
+   */
+  private markItemLayoutDirty;
+  /**
+   * Detect the common controlled-update case where the new list simply extends
+   * the existing ordered prefix. When that happens we can reuse every current
+   * record in place, sync any versioned payload changes, and append only the new
+   * tail instead of rebuilding the whole list.
+   */
+  private tryAppendItems;
+  /**
+   * Reconcile a new controlled item list against the existing records by id.
+   * This reuses records and instances when type matches, cleans up removed
+   * records, rebuilds the lookup maps, and marks layout dirty whenever order,
+   * membership, or versioned item data changes.
+   */
+  private reconcileItems;
+  /**
+   * Update a reused record from the latest controlled item only when its item
+   * version changes. Matching versions mean CodeView keeps the current record
+   * snapshot, which lets imperative updates remain in place until the caller
+   * intentionally publishes a newer version.
+   */
+  private syncItemRecord;
+  private getMaxScrollTopForHeight;
+  private getMaxScrollTop;
+  private shouldRebaseScroll;
+  private getPagedScrollHeight;
+  private getMaxPagedScrollTop;
+  private clampPagedScrollTop;
+  /**
+   * Clamps a logical scroll position to the min/max allowable scroll range
+   * based on the full computed content height.
+   */
+  private clampScrollTop;
+  private getMaxScrollPageOffset;
+  private clampScrollPageOffset;
+  private resolveScrollPageWindow;
+  /**
+   * Resolve how a logical scrollTop maps onto the reusable paged scroll window
+   * without mutating the current page offset.
+   */
+  private resolvePagedScrollPosition;
+  private needsScrollPageUpdate;
+  private getPagedLayoutTop;
+  private getStickyHeaderOffset;
+  private getScrollTargetRect;
+  private normalizeScrollTarget;
+  /**
+   * Resolve a target's scroll position
+   * Returns `undefined` when we can't resolve a target for whatever reason
+   */
+  private resolveScrollTargetTop;
+  /**
+   * Given an existing scroll target (scroll top and height), figure out the
+   * correct scroll position to target based on the desired alignment, offset
+   * and stickyOffset if necessary
+   */
+  private resolveAlignedScrollPosition;
+  private getLineScrollPosition;
+  private getRangeScrollPosition;
+  /**
+   * Determine target scroll position for current frame.
+   *
+   * If there's no pendingScrollTarget then we just return the current scroll
+   * position
+   *
+   * If there's a pendingScrollTarget then we depend on whether there's a
+   * smooth scroll animation or not. If not just return the destination, or
+   * compute next position given the smooth scroll spring physics
+   */
+  private computeTargetScrollTopForFrame;
+  /**
+   * Closed-form critical-damped ODE step.
+   *
+   * Stable at any dt (Euler would blow up once ω·dt ≳ 1), so this survives
+   * big RAF gaps (tab-wake, offscreen frames) and resize-driven ticks that
+   * fire outside the normal RAF cadence.
+   */
+  private computeSpringStep;
+  /**
+   * For any given pendingScrollTarget, updates any in flight smooth scroll
+   * animations and returns the target scrollTop to move towards
+   *
+   * Resolves the animation based on frame time and adopts any necessary scroll
+   * anchoring corrections if necessary
+   */
+  private advanceScrollAnimation;
+  private computeRenderRangeAndEmit;
+  private flushManagers;
+  private syncContainerHeight;
+  private getStickyBounds;
+  private applyStickyPositioning;
+  private syncPagedScrollScaffolding;
+  private reconcileRenderedItems;
+  private updateStickyPositioning;
+  private handleScroll;
+  private clearPendingScroll;
+  private handleResize;
+  /**
+   * Figure out scrollTop accounting for sticky header if enabled and
+   * necessary
+   */
+  private getScrollAnchorViewportTop;
+  /**
+   * Attempt to find a scroll anchor based on build in metrics of the existing
+   * rendered files/diff.
+   *
+   * A scroll anchor represents the first fully visible element (in other
+   * words, the first file or first line who's top is fully in the viewport).
+   */
+  private getScrollAnchor;
+  /**
+   * Given a scroll anchor, attempt to resolve a newly updated (and clamped)
+   * scroll position to keep the anchored element in place.
+   *
+   * If we can't resolve a position for whatever reason, we'll return
+   * undefined.
+   */
+  private resolveAnchoredScrollTop;
+  /**
+   * Apply a device-pixel-rounded scroll position if it differs from the last
+   * logical scrollTop synchronized into the paged scroll scaffold.
+   */
+  private applyScrollFix;
+  /**
+   * Decide whether a pending programmatic scroll has reached its
+   * destination and should be cleared.
+   */
+  private isPendingTargetSettled;
+  getScrollTop(): number;
+  getHeight(): number;
+  getScrollHeight(): number;
+  private flushSlotCoordinator;
+  private notifyScroll;
+  /**
+   * Find the first item whose bottom edge crosses into the viewport window.
+   * This lets scroll-time rendering jump directly near the visible range instead
+   * of linearly scanning from the start of very large item lists.
+   */
+  private findFirstVisibleIndex;
+  /**
+   * Find the last item whose top edge is still within the viewport window.
+   * Paired with findFirstVisibleIndex, this bounds the render loop to only the
+   * slice of items that can actually intersect the current scroll range.
+   */
+  private findLastVisibleIndex;
+  /**
+   * Recompute measured tops and heights starting from the earliest dirty item.
+   * Earlier items keep their existing layout, while everything from startIndex
+   * onward is remeasured so downstream positions and total scroll height stay
+   * consistent after inserts, removals, or versioned item updates.
+   */
+  private recomputeLayout;
+  private resetRenderState;
+  private getFitPerfectlyOverscroll;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/VirtualizedFile.d.ts
+//#region src/components/VirtualizedFile.d.ts
+declare class VirtualizedFile<LAnnotation = undefined, Caret = undefined> extends File<LAnnotation, Caret> {
+  private virtualizer;
+  private metrics;
+  readonly __id: string;
+  readonly renderType = "virtualized";
+  top: number | undefined;
+  height: number;
+  private cache;
+  private pendingRender;
+  private isVisible;
+  private isSetup;
+  private layoutDirty;
+  private forceRenderOverride;
+  private currentCollapsed;
+  constructor(options: FileOptions<LAnnotation, Caret> | undefined, virtualizer: Virtualizer | CodeView$1<LAnnotation, Caret>, metrics?: VirtualFileMetrics, workerManager?: WorkerPoolManager, isContainerManaged?: boolean);
+  setMetrics(metrics?: Partial<VirtualFileMetrics>, force?: boolean): void;
+  setLineAnnotations(lineAnnotations: LineAnnotation<LAnnotation>[]): void;
+  private syncLineAnnotations;
+  protected syncEditSessionAnnotationsFromEditor(lineAnnotations: LineAnnotation<LAnnotation>[]): boolean;
+  private hasLineAnnotations;
+  private hasUniformLineHeights;
+  getLineHeight(lineIndex: number, hasMetadataLine?: boolean): number;
+  setOptions(options: FileOptions<LAnnotation, Caret> | undefined): void;
+  setThemeType(themeType: ThemeTypes): void;
+  private resetLayoutCache;
+  private applyGhostTextRows;
+  reconcileHeights(): boolean;
+  onRender: (dirty: boolean) => boolean;
+  updateCodeViewLayout(file: FileContents, top: number, reset?: PendingCodeViewLayoutReset, lineAnnotations?: LineAnnotation<LAnnotation>[]): number;
+  private getLayoutFile;
+  getLinePosition(lineNumber: number): {
+    top: number;
+    height: number;
+  } | undefined;
+  getEditorViewport(): HTMLElement | Document | undefined;
+  getNumericScrollAnchor(localViewportTop: number): NumericScrollLineAnchor | undefined;
+  getVirtualizedHeight(): number;
+  getAdvancedStickySpecs(windowSpecs?: RenderWindow): StickySpecs | undefined;
+  cleanUp(recycle?: boolean): void;
+  private computeApproximateSize;
+  setVisibility(visible: boolean): void;
+  rerender(): void;
+  syncGhostTextRows(): void;
+  applyDocumentChange(textDocument: TextDocument<'file', LAnnotation>, newLineAnnotations?: LineAnnotation<LAnnotation>[], shouldUpdateBuffer?: boolean): void;
+  render({ fileContainer, file, forceRender, lineAnnotations, ...props }: FileRenderProps<LAnnotation>): boolean;
+  protected finalizeRender(): void;
+  private updatePendingRender;
+  syncVirtualizedTop(): void;
+  protected shouldDisableVirtualizationBuffers(): boolean;
+  protected shouldGuardRebuildScroll(): boolean;
+  private isSimpleMode;
+  private isAdvancedMode;
+  private addLayoutCheckpoint;
+  private getLayoutCheckpointBeforeLineIndex;
+  private getLayoutCheckpointBeforeTop;
+  private getVirtualizedTop;
+  private getSimpleVirtualizer;
+  private getAdvancedVirtualizer;
+  private isResizeDebuggingEnabled;
+  private computeRenderRangeFromWindow;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/utils/parseMergeConflictDiffFromFile.d.ts
+interface MergeConflictDiffAction extends ProcessFileConflictData {
+  conflict: MergeConflictRegion;
+  conflictIndex: number;
+  markerLines: {
+    start: string;
+    base?: string;
+    separator: string;
+    end: string;
+  };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/renderers/UnresolvedFileHunksRenderer.d.ts
+//#region src/renderers/UnresolvedFileHunksRenderer.d.ts
+interface BaseUnresolvedOptionsWithDefaults extends DiffHunksRendererOptionsWithDefaults {
+  mergeConflictActionsType: MergeConflictActionsType;
+}
+type MergeConflictActionsType = 'none' | 'default' | 'custom';
+interface UnresolvedFileHunksRendererOptions extends DiffHunksRendererOptions {
+  mergeConflictActionsType?: MergeConflictActionsType;
+}
+declare class UnresolvedFileHunksRenderer<LAnnotation = undefined> extends DiffHunksRenderer<LAnnotation> {
+  private pendingConflictActions;
+  private pendingMarkerRows;
+  private injectedRows;
+  options: UnresolvedFileHunksRendererOptions;
+  constructor(options?: UnresolvedFileHunksRendererOptions, annotationSlotName?: (annotation: DiffLineAnnotation<LAnnotation>) => string, onRenderUpdate?: () => unknown, workerManager?: WorkerPoolManager | undefined);
+  setConflictState(conflictActions: (MergeConflictDiffAction | undefined)[], markerRows: MergeConflictMarkerRow[], diff: FileDiffMetadata): void;
+  private syncInjectedRows;
+  private addInjectedRow;
+  renderDiff(diff?: FileDiffMetadata | undefined, renderRange?: RenderRange): HunksRenderResult | undefined;
+  asyncRender(diff: FileDiffMetadata, renderRange?: RenderRange): Promise<HunksRenderResult>;
+  protected createPreElement(split: boolean, totalLines: number): Element$1;
+  protected getUnifiedLineDecoration({ type, lineType }: UnifiedLineDecorationProps): LineDecoration;
+  protected getSplitLineDecoration({ side, type }: SplitLineDecorationProps): LineDecoration;
+  protected getUnifiedInjectedRowsForLine: (ctx: RenderedLineContext) => UnifiedInjectedRowPlacement | undefined;
+  protected getOptionsWithDefaults(): BaseUnresolvedOptionsWithDefaults;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/components/UnresolvedFile.d.ts
+//#region src/components/UnresolvedFile.d.ts
+type RenderMergeConflictActions<LAnnotation> = (action: MergeConflictDiffAction, instance: UnresolvedFile$1<LAnnotation>) => HTMLElement | DocumentFragment | null | undefined;
+type MergeConflictActionsTypeOption<LAnnotation> = 'none' | 'default' | RenderMergeConflictActions<LAnnotation>;
+interface UnresolvedFileOptions<LAnnotation> extends Omit<FileDiffOptions<LAnnotation, undefined>, 'diffStyle' | 'onPostRender'> {
+  onPostRender?(node: HTMLElement, instance: UnresolvedFile$1<LAnnotation>, phase: PostRenderPhase): unknown;
+  mergeConflictActionsType?: MergeConflictActionsTypeOption<LAnnotation>;
+  onMergeConflictAction?(payload: MergeConflictActionPayload, instance: UnresolvedFile$1<LAnnotation>): void;
+  onMergeConflictResolve?(file: FileContents, payload: MergeConflictActionPayload): void;
+  maxContextLines?: number;
+}
+interface UnresolvedFileRenderProps<LAnnotation> extends FileDiffRenderBaseProps<LAnnotation> {
+  file?: FileContents;
+  actions?: (MergeConflictDiffAction | undefined)[];
+  markerRows?: MergeConflictMarkerRow[];
+}
+interface UnresolvedFileHydrationProps<LAnnotation> extends Omit<UnresolvedFileRenderProps<LAnnotation>, 'file'> {
+  file?: FileContents;
+  fileContainer: HTMLElement;
+  prerenderedHTML?: string;
+}
+interface GetOrComputeDiffProps {
+  file: FileContents | undefined;
+  fileDiff: FileDiffMetadata | undefined;
+  actions: (MergeConflictDiffAction | undefined)[] | undefined;
+  markerRows: MergeConflictMarkerRow[] | undefined;
+}
+interface ResolveConflictReturn {
+  file: FileContents;
+  fileDiff: FileDiffMetadata;
+  actions: (MergeConflictDiffAction | undefined)[];
+  markerRows: MergeConflictMarkerRow[];
+}
+type UnresolvedFileDataCache = GetOrComputeDiffProps;
+declare class UnresolvedFile$1<LAnnotation = undefined> extends FileDiff$1<LAnnotation, undefined> {
+  options: UnresolvedFileOptions<LAnnotation>;
+  readonly __id: string;
+  readonly type = "unresolved-file";
+  protected computedCache: UnresolvedFileDataCache;
+  private conflictActions;
+  private markerRows;
+  private conflictActionCache;
+  constructor(options?: UnresolvedFileOptions<LAnnotation>, workerManager?: WorkerPoolManager | undefined, isContainerManaged?: boolean);
+  setOptions(options: UnresolvedFileOptions<LAnnotation> | undefined): void;
+  protected syncInteractionOptions(): void;
+  protected createHunksRenderer(options: UnresolvedFileOptions<LAnnotation>): UnresolvedFileHunksRenderer<LAnnotation>;
+  protected getHunksRendererOptions(options: UnresolvedFileOptions<LAnnotation>): UnresolvedFileHunksRendererOptions;
+  protected applyPreNodeAttributes(pre: HTMLPreElement, result: HunksRenderResult): void;
+  cleanUp(): void;
+  private getOrComputeDiff;
+  hydrate(props: UnresolvedFileHydrationProps<LAnnotation>): void;
+  rerender(): void;
+  render(props?: UnresolvedFileRenderProps<LAnnotation>): boolean;
+  resolveConflict(conflictIndex: number, resolution: MergeConflictResolution, fileDiff?: FileDiffMetadata | undefined): ResolveConflictReturn | undefined;
+  private resolveConflictAndRender;
+  private setActiveMergeConflictState;
+  private handleMergeConflictActionClick;
+  private renderMergeConflictActionSlots;
+  private renderMergeConflictAction;
+  private clearMergeConflictActionCache;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/utils/getSingularPatch.d.ts
+//#region src/utils/getSingularPatch.d.ts
+declare function getSingularPatch(patch: string): FileDiffMetadata;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/utils/parseDiffFromFile.d.ts
+//#region src/utils/parseDiffFromFile.d.ts
+/**
+ * Parses a diff from two file contents objects.
+ *
+ * If both `oldFile` and `newFile` have a `cacheKey`, the resulting diff gets a
+ * collision-safe key derived from both values.
+ */
+declare function parseDiffFromFile(oldFile: FileContents | null, newFile: FileContents | null, options?: CreatePatchOptionsNonabortable, throwOnError?: boolean): FileDiffMetadata;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.2.8_react@19.2.6__react@19.2.6/node_modules/@pierre/diffs/dist/utils/parsePatchFiles.d.ts
+/**
+ * Parses a patch file string into an array of parsed patches.
+ *
+ * @param data - The raw patch file content (supports multi-commit patches)
+ * @param cacheKeyPrefix - Optional prefix for collision-safe cache keys derived
+ *   from the prefix, patch index, and file index. This enables caching of
+ *   rendered diff results in the worker pool.
+ * @param throwOnError - When true, invalid data throws. When false, invalid data
+ *   is reported with `console.error` and the parser attempts to recover when
+ *   possible. Recovery is best-effort and does not guarantee valid output.
+ */
+declare function parsePatchFiles(data: string, cacheKeyPrefix?: string, throwOnError?: boolean): ParsedPatch[];
+//#endregion
+//#region src/components/code-view.d.ts
+declare const PatchDiff: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  patch: {
+    required: true;
+    type: StringConstructor;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  patch: {
+    required: true;
+    type: StringConstructor;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: SelectedLineRange | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const MultiFileDiff: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  newFile: {
+    required: true;
+    type: import("vue").PropType<FileContents | null>;
+  };
+  oldFile: {
+    required: true;
+    type: import("vue").PropType<FileContents | null>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  newFile: {
+    required: true;
+    type: import("vue").PropType<FileContents | null>;
+  };
+  oldFile: {
+    required: true;
+    type: import("vue").PropType<FileContents | null>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: SelectedLineRange | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const FileDiff: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  fileDiff: {
+    required: true;
+    type: import("vue").PropType<FileDiffMetadata>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  fileDiff: {
+    required: true;
+    type: import("vue").PropType<FileDiffMetadata>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileDiffOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: SelectedLineRange | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const FileView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  file: {
+    required: true;
+    type: import("vue").PropType<FileContents>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<LineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  file: {
+    required: true;
+    type: import("vue").PropType<FileContents>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<LineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<FileOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: SelectedLineRange | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const UnresolvedFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  file: {
+    required: true;
+    type: import("vue").PropType<FileContents>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<UnresolvedFileOptions<unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  file: {
+    required: true;
+    type: import("vue").PropType<FileContents>;
+  };
+  lineAnnotations: {
+    type: import("vue").PropType<DiffLineAnnotation<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<UnresolvedFileOptions<unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<SelectedLineRange | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: SelectedLineRange | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const CodeView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  items: {
+    required: true;
+    type: import("vue").PropType<readonly CodeViewItem<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<CodeViewOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<CodeViewLineSelection | null | undefined>;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  items: {
+    required: true;
+    type: import("vue").PropType<readonly CodeViewItem<unknown>[]>;
+  };
+  options: {
+    type: import("vue").PropType<CodeViewOptions<unknown, unknown>>;
+  };
+  selectedLines: {
+    default: undefined;
+    type: import("vue").PropType<CodeViewLineSelection | null | undefined>;
+  };
+}>> & Readonly<{}>, {
+  selectedLines: CodeViewLineSelection | null | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { FileContents as _, PatchDiff as a, SelectedLineRange as b, parseDiffFromFile as c, CodeViewLineSelection as d, CodeViewOptions as f, DiffLineAnnotation as g, CodeViewItem as h, MultiFileDiff as i, getSingularPatch as l, FileOptions as m, FileDiff as n, UnresolvedFile as o, FileDiffOptions as p, FileView as r, parsePatchFiles as s, CodeView as t, UnresolvedFileOptions as u, FileDiffMetadata as v, LineAnnotation as y };