@nkzw/codiff-core 1.8.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,15 @@
+# @nkzw/codiff-core
+
+Reusable code diffing primitives from Codiff.
+
+## Example
+
+```tsx
+import type { SharedWalkthroughSnapshot } from '@nkzw/codiff-core';
+import { ReviewSurface } from '@nkzw/codiff-core/react';
+import '@nkzw/codiff-core/styles.css';
+
+export function Review({ snapshot }: { snapshot: SharedWalkthroughSnapshot }) {
+  return <ReviewSurface snapshot={snapshot} />;
+}
+```

package/dist/SharedPlanApp.d.ts

@@ -0,0 +1,32 @@
+import { type MarkdownCommentTarget } from '@nkzw/mdx-editor';
+import type { GitIdentity, PlanCommentThread, SharedPlanSnapshot } from './types.ts';
+export declare const getPlanCommentColorIndex: (username: string) => number;
+export declare const getPlanCommentIdentityColorIndex: (identity: GitIdentity | null, threads: ReadonlyArray<PlanCommentThread>) => number | null;
+export declare const getPlanCommentAffordancePosition: ({ contentPaddingRight, contentRight, target, workspaceLeft, workspaceTop, }: {
+    contentPaddingRight: number;
+    contentRight: number;
+    target: MarkdownCommentTarget;
+    workspaceLeft: number;
+    workspaceTop: number;
+}) => {
+    left: number;
+    target: MarkdownCommentTarget;
+    top: number;
+    width: number;
+};
+export type PlanReviewCommenting = {
+    canComment: boolean;
+    identity: GitIdentity | null;
+    onCreateThread: (anchor: MarkdownCommentTarget['anchor'], body: string) => Promise<void>;
+    onDeleteMessage: (messageId: string) => Promise<void>;
+    onReply: (threadId: string, body: string) => Promise<void>;
+    onResolve: (threadId: string, resolved: boolean) => Promise<void>;
+    onSignIn: () => Promise<void> | void;
+    onUpdateMessage: (messageId: string, body: string) => Promise<void>;
+};
+export declare const getSharedPlanDownloadContent: (snapshot: SharedPlanSnapshot) => string;
+export declare function PlanReviewSurface({ commenting, signInLabel, snapshot, }: {
+    commenting?: PlanReviewCommenting;
+    signInLabel?: string;
+    snapshot: SharedPlanSnapshot;
+}): import("react").JSX.Element;

package/dist/SharedWalkthroughApp.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+import { type ReviewCommenting } from './app/components/merge-request/GeneralComments.tsx';
+import type { GitIdentity, PullRequestMergeOptions, PullRequestExistingReviewComment, PullRequestReviewComment, PullRequestReviewEvent, SharedWalkthroughSnapshot } from './types.ts';
+export { ReadOnlyGeneralCommentCard, type ReviewCommenting, } from './app/components/merge-request/GeneralComments.tsx';
+export type ReviewWalkthroughStatus = 'failed' | 'generating' | 'idle' | 'ready';
+export type ReviewMode = 'comments' | 'tree' | 'walkthrough';
+export type ReviewSurfaceProps = {
+    commenting?: ReviewCommenting;
+    externalUrl?: string;
+    gitIdentity?: GitIdentity | null;
+    initialMode?: ReviewMode;
+    interactive?: {
+        onCancelAutoMerge?: () => Promise<void> | void;
+        onClosePullRequest?: () => Promise<void> | void;
+        onGenerateWalkthrough: () => Promise<void> | void;
+        onHome: () => void;
+        onMergePullRequest?: (options: PullRequestMergeOptions & {
+            autoMerge: boolean;
+        }) => Promise<void> | void;
+        onResolveDiscussion?: (discussionId: string, resolved: boolean) => Promise<void>;
+        onSubmitComment: (comment: PullRequestReviewComment) => Promise<PullRequestExistingReviewComment>;
+        onSubmitGeneralComment: (body: string) => Promise<void>;
+        onSubmitReview: (event: PullRequestReviewEvent, comments: ReadonlyArray<PullRequestReviewComment>, body?: string) => Promise<void>;
+        onUpdateComment: (commentId: string, body: string) => Promise<void>;
+        onUpdateDescription?: (body: string) => Promise<void> | void;
+        onUpdateGeneralComment: (commentId: string, body: string) => Promise<void>;
+        onUpdateTitle?: (title: string) => Promise<void> | void;
+        onUploadDescriptionAsset?: (file: File) => Promise<string> | string;
+        walkthroughError?: string | null;
+        walkthroughStatus: ReviewWalkthroughStatus;
+    };
+    onModeChange?: (mode: ReviewMode) => void;
+    providerLabel?: string;
+    settingsBar?: ReactNode;
+    signInLabel?: string;
+    snapshot: SharedWalkthroughSnapshot;
+    sourceDescriptionFooterAside?: ReactNode;
+    title?: string;
+};
+export declare function ReviewSurface({ commenting, externalUrl, gitIdentity, initialMode, interactive, onModeChange, providerLabel, settingsBar, signInLabel, snapshot, sourceDescriptionFooterAside, title, }: ReviewSurfaceProps): import("react").JSX.Element;

package/dist/app/components/Avatar.d.ts

@@ -0,0 +1,6 @@
+declare function Avatar({ name, size, url }: {
+    name: string;
+    size: 'medium' | 'small';
+    url?: string;
+}): import("react").JSX.Element;
+export { Avatar };

package/dist/app/components/Button.d.ts

@@ -0,0 +1,12 @@
+import { type VariantProps } from 'class-variance-authority';
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+export declare const buttonVariants: (props?: ({
+    size?: "default" | "icon" | "lg" | "sm" | null | undefined;
+    variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonVariants> & {
+    action?: () => Promise<unknown> | unknown;
+    asChild?: boolean;
+    pendingPlaceholder?: ReactNode;
+};
+export declare function Button({ action, asChild, children, className, disabled, onClick: initialOnClick, pendingPlaceholder, size, type, variant, ...props }: ButtonProps): import("react").JSX.Element;

package/dist/app/components/CommandBar.d.ts

@@ -0,0 +1,8 @@
+import type { CodiffKeymap } from '../../config/types.ts';
+import type { Command } from '../../lib/command-registry.ts';
+export declare function CommandBar({ commands, keymap, onClose, visible, }: {
+    commands: ReadonlyArray<Command>;
+    keymap: CodiffKeymap;
+    onClose: () => void;
+    visible: boolean;
+}): import("react").JSX.Element | null;

package/dist/app/components/FileTree.d.ts

@@ -0,0 +1,10 @@
+import type { ChangedFile } from '../../types.ts';
+export declare function ReviewFileTree({ files, onActivatePath, reloadDeltaPaths, scrollSelectedPathIntoView, selectedPath, showWhitespace, viewed, }: {
+    files: ReadonlyArray<ChangedFile>;
+    onActivatePath: (path: string) => void;
+    reloadDeltaPaths?: ReadonlySet<string>;
+    scrollSelectedPathIntoView?: boolean;
+    selectedPath: string | null;
+    showWhitespace: boolean;
+    viewed?: Readonly<Record<string, string>>;
+}): import("react").JSX.Element;

package/dist/app/components/KeyboardShortcutsHelp.d.ts

@@ -0,0 +1,5 @@
+import type { CodiffKeymap } from '../../config/types.ts';
+export declare function KeyboardShortcutsHelp({ keymap, visible, }: {
+    keymap: CodiffKeymap;
+    visible: boolean;
+}): import("react").JSX.Element | null;

package/dist/app/components/MarkdownDocumentEditor.d.ts

@@ -0,0 +1,26 @@
+import type { MarkdownAnnotation, MarkdownAnnotationAnchor, MarkdownAnnotationLayout, MarkdownCommentTarget } from '@nkzw/mdx-editor';
+import type { CodiffMarkdownDocument } from '../../types.ts';
+export type MarkdownDocumentEditorHandle = {
+    createAnnotation: (id: string, target?: MarkdownCommentTarget | null) => MarkdownAnnotationAnchor | null;
+    flush: () => Promise<boolean>;
+    focusAnnotation: (id: string) => void;
+    getAnnotationAnchor: (id: string) => MarkdownAnnotationAnchor | null;
+    removeAnnotation: (id: string) => void;
+};
+export declare const MarkdownDocumentEditor: import("react").ForwardRefExoticComponent<{
+    activeAnnotationId?: string | null;
+    annotations?: ReadonlyArray<MarkdownAnnotation>;
+    autoFocus?: boolean;
+    className?: string;
+    document: CodiffMarkdownDocument;
+    onAnnotationAnchorChange?: (id: string, anchor: MarkdownAnnotationAnchor | null) => void;
+    onAnnotationLayoutChange?: (layouts: ReadonlyArray<MarkdownAnnotationLayout>) => void;
+    onCommentTargetChange?: (target: MarkdownCommentTarget | null) => void;
+    onDocumentChange?: (document: CodiffMarkdownDocument) => void;
+    onHeightChange?: (height: number) => void;
+    readOnly?: boolean;
+} & import("react").RefAttributes<MarkdownDocumentEditorHandle>>;
+export declare const RepositoryMarkdownEditor: import("react").ForwardRefExoticComponent<{
+    onHeightChange?: (height: number) => void;
+    path: string;
+} & import("react").RefAttributes<MarkdownDocumentEditorHandle>>;

package/dist/app/components/Panels.d.ts

@@ -0,0 +1,71 @@
+import { type ReactNode } from 'react';
+import type { CodiffKeymap } from '../../config/types.ts';
+import type { RepositoryLoadError, ReviewComment } from '../../lib/app-types.ts';
+import type { ChangedFile, PullRequestMergeOptions, PullRequestMergeState, PullRequestReviewEvent, PullRequestReviewStatus } from '../../types.ts';
+export declare function ReviewSourceLoading(): import("react").JSX.Element;
+export declare function RepositoryChangeBanner({ onRefresh, visible, }: {
+    onRefresh: () => void;
+    visible: boolean;
+}): import("react").JSX.Element;
+export declare function WalkthroughOutdatedBanner({ onDismiss, reason, }: {
+    onDismiss: () => void;
+    reason: string | null;
+}): import("react").JSX.Element;
+export declare function FirstRunPanel({ agentSkillInstalled, agentSkillInstalling, agentSkillLabel, installing, onInstallAgentSkill, onInstallTerminalHelper, }: {
+    agentSkillInstalled: boolean;
+    agentSkillInstalling: boolean;
+    agentSkillLabel: string;
+    installing: boolean;
+    onInstallAgentSkill: () => void;
+    onInstallTerminalHelper: () => void;
+}): import("react").JSX.Element;
+export declare function RepositoryLoadErrorPanel({ error }: {
+    error: RepositoryLoadError;
+}): import("react").JSX.Element;
+export declare function AgentUnavailablePanel({ agentLabel, onShowFiles, reason, title, }: {
+    agentLabel: string;
+    onShowFiles: () => void;
+    reason?: string;
+    title?: string;
+}): import("react").JSX.Element;
+export declare function DiffSearchPanel({ activeIndex, focusRequest, keymap, matchCount, onChange, onClose, onNext, onPrevious, query, visible, }: {
+    activeIndex: number;
+    focusRequest: number;
+    keymap: CodiffKeymap;
+    matchCount: number;
+    onChange: (query: string) => void;
+    onClose: () => void;
+    onNext: () => void;
+    onPrevious: () => void;
+    query: string;
+    visible: boolean;
+}): import("react").JSX.Element;
+export declare function CopyCommentsButton({ comments, files, reviewCommentsPrefix, showWhitespace, }: {
+    comments: ReadonlyArray<ReviewComment>;
+    files: ReadonlyArray<ChangedFile>;
+    reviewCommentsPrefix: string;
+    showWhitespace: boolean;
+}): import("react").JSX.Element | null;
+export declare const isPullRequestReviewActionDisabled: (reviewStatus: PullRequestReviewStatus | undefined, event: PullRequestReviewEvent) => boolean;
+export declare function PullRequestReviewButtons({ children, disabled, hasPendingComments, onClosePullRequest, onSubmitReview, reviewStatus, showCommentReview, }: {
+    children?: ReactNode;
+    disabled: boolean;
+    hasPendingComments: boolean;
+    onClosePullRequest?: () => void;
+    onSubmitReview: (event: PullRequestReviewEvent, body?: string) => Promise<void> | void;
+    reviewStatus?: PullRequestReviewStatus;
+    showCommentReview?: boolean;
+}): import("react").JSX.Element | null;
+export declare const isTerminalPullRequestMergeState: (mergeState: PullRequestMergeState) => boolean;
+export declare function PullRequestMergeStatusBadge({ mergeState }: {
+    mergeState: PullRequestMergeState;
+}): import("react").JSX.Element | null;
+export declare function PullRequestMergeControls({ disabled, isPending, mergeState, onCancelAutoMerge, onMergePullRequest, }: {
+    disabled: boolean;
+    isPending?: boolean;
+    mergeState: PullRequestMergeState;
+    onCancelAutoMerge?: () => Promise<void> | void;
+    onMergePullRequest?: (options: PullRequestMergeOptions & {
+        autoMerge: boolean;
+    }) => Promise<void> | void;
+}): import("react").JSX.Element | null;

package/dist/app/components/PlanEditorView.d.ts

@@ -0,0 +1,18 @@
+import type { CodiffMarkdownDocument, PlanCommentThread } from '../../types.ts';
+export declare function PlanCommentCard({ active, detached, onActivate, onBodyChange, onDelete, onEmptyBlur, onHeightChange, onReveal, readOnly, showDelete, thread, }: {
+    active: boolean;
+    detached: boolean;
+    onActivate: () => void;
+    onBodyChange: (body: string) => void;
+    onDelete: () => void;
+    onEmptyBlur: () => void;
+    onHeightChange: () => void;
+    onReveal: () => void;
+    readOnly: boolean;
+    showDelete: boolean;
+    thread: PlanCommentThread;
+}): import("react").JSX.Element;
+export declare function PlanEditorView({ document: initialDocument, shareEnabled, }: {
+    document: CodiffMarkdownDocument;
+    shareEnabled?: boolean;
+}): import("react").JSX.Element;

package/dist/app/components/ReadOnlyMarkdownView.d.ts

@@ -0,0 +1,16 @@
+import { MarkdownEditor } from '@nkzw/mdx-editor';
+import type { ComponentProps, ReactNode } from 'react';
+type MarkdownEditorProps = ComponentProps<typeof MarkdownEditor>;
+export declare const normalizeReadOnlyMarkdownValue: (value: string) => string;
+export declare function ReadOnlyMarkdownView({ additionalPlugins, ariaLabel, className, contentClassName, density, fallback, onHeightChange, value, variant, }: {
+    additionalPlugins?: MarkdownEditorProps['additionalPlugins'];
+    ariaLabel: string;
+    className: string;
+    contentClassName?: string;
+    density?: MarkdownEditorProps['density'];
+    fallback?: ReactNode;
+    onHeightChange?: (height: number) => void;
+    value: string;
+    variant?: MarkdownEditorProps['variant'];
+}): import("react").JSX.Element | null;
+export {};

package/dist/app/components/ReviewCodeView.d.ts

@@ -0,0 +1,103 @@
+import { type FileDiffLoadedFiles } from '@pierre/diffs';
+import { type ReactNode } from 'react';
+import type { CodiffDiffStyle, CodiffKeymap } from '../../config/types.ts';
+import type { CodeViewInstance, DiffSearchMatch, ReviewComment, ReviewIdentity, ReviewScrollTarget, WalkthroughNote } from '../../lib/app-types.ts';
+import type { ChangedFile, CodiffPreferences, CommitMetadata, DiffImageContentRequest, DiffImageContentResult, DiffSection, GitIdentity, PullRequestCodeQualityFinding, ReviewSource } from '../../types.ts';
+type PullRequestSource = Extract<ReviewSource, {
+    type: 'pull-request';
+}>;
+export declare function PullRequestSourceDescription({ actions, footer, keymap, onUpdateDescription, onUpdateTitle, onUploadDescriptionAsset, source, }: {
+    actions?: ReactNode;
+    footer?: ReactNode;
+    keymap?: CodiffKeymap;
+    onUpdateDescription?: (body: string) => Promise<void> | void;
+    onUpdateTitle?: (title: string) => Promise<void> | void;
+    onUploadDescriptionAsset?: (file: File) => Promise<string> | string;
+    source: PullRequestSource;
+}): import("react").JSX.Element | null;
+type HunkNavigationRequest = {
+    direction: 1 | -1;
+    request: number;
+};
+type FileReviewDiffBlock = {
+    comments?: ReadonlyArray<ReviewComment>;
+    file: ChangedFile;
+    fileSelected?: boolean;
+    header?: ReactNode;
+    headerSelected?: boolean;
+    id: string;
+    itemIdPrefix?: string;
+    note?: string;
+    reviewIdentity?: ReviewIdentity;
+    selected?: boolean;
+};
+type HeaderReviewDiffBlock = {
+    file?: undefined;
+    header: ReactNode;
+    headerSelected?: boolean;
+    id: string;
+    selected?: boolean;
+};
+export type ReviewDiffBlock = FileReviewDiffBlock | HeaderReviewDiffBlock;
+export declare function ReviewCodeView({ activeSearchMatch, agentId, agentLabel, allowViewedToggle, blocks, bottomInset, codeQualityFindings, collapsed, comments, commitMetadata, diffLineHeight, diffStyle, disableWorkerPool, expandedGenerated, files, focusCommentId, focusCommentRequest, forceExpandedPaths, gitIdentity, hunkNavigation, initialMarkdownPreviewSectionIds, isPullRequest, isReadOnly, itemVersionByKey, keymap, loadingSectionIds, onActiveBlockChange, onAskCodex, onCommentDraftChange, onCreateComment, onDeleteComment, onLoadImageContent, onLoadSection, onLoadSectionContents, onOpenFile, onRefreshMarkdown, onResolveThread, onSaveCommentEdit, onSelectPathFromScroll, onSubmitComment, onToggleCollapsed, onToggleViewed, onUpdateComment, onUpdateSourceDescription, onUpdateSourceTitle, onUploadSourceDescriptionAsset, reviewIdentityByPath, scrollTarget, searchQuery, selectedPath, showSourceDescription, showWhitespace, source, sourceDescriptionActions, sourceDescriptionFooter, theme, viewed, walkthroughNotes, wordWrap, }: {
+    activeSearchMatch: DiffSearchMatch | null;
+    agentId: 'codex' | 'claude' | 'opencode' | 'pi';
+    agentLabel: string;
+    allowViewedToggle?: boolean;
+    blocks?: ReadonlyArray<ReviewDiffBlock>;
+    bottomInset?: number;
+    codeQualityFindings?: ReadonlyArray<PullRequestCodeQualityFinding>;
+    collapsed: ReadonlySet<string>;
+    comments: ReadonlyArray<ReviewComment>;
+    commitMetadata: CommitMetadata | null;
+    diffLineHeight?: number;
+    diffStyle: CodiffDiffStyle;
+    disableWorkerPool?: boolean;
+    expandedGenerated?: ReadonlySet<string>;
+    files: ReadonlyArray<ChangedFile>;
+    focusCommentId: string | null;
+    focusCommentRequest: number;
+    forceExpandedPaths: ReadonlySet<string>;
+    gitIdentity: GitIdentity | null;
+    hunkNavigation: HunkNavigationRequest | null;
+    initialMarkdownPreviewSectionIds?: ReadonlySet<string>;
+    isPullRequest: boolean;
+    isReadOnly?: boolean;
+    itemVersionByKey: Readonly<Record<string, number>>;
+    keymap: CodiffKeymap;
+    loadingSectionIds: ReadonlySet<string>;
+    onActiveBlockChange?: (blockId: string) => void;
+    onAskCodex?: (commentId: string) => void;
+    onCommentDraftChange?: (comment: Pick<ReviewComment, 'body' | 'id'> | null) => void;
+    onCreateComment: (comment: Omit<ReviewComment, 'body' | 'id'>) => void;
+    onDeleteComment: (commentId: string) => void;
+    onLoadImageContent?: (request: DiffImageContentRequest) => Promise<DiffImageContentResult>;
+    onLoadSection: (file: ChangedFile, section: DiffSection) => void;
+    onLoadSectionContents?: (file: ChangedFile, section: DiffSection) => Promise<FileDiffLoadedFiles>;
+    onOpenFile?: (file: ChangedFile) => void;
+    onRefreshMarkdown?: (file: ChangedFile, section: DiffSection) => Promise<boolean>;
+    onResolveThread?: (threadId: string, resolved: boolean) => Promise<void> | void;
+    onSaveCommentEdit: (commentId: string, body: string) => Promise<void> | void;
+    onSelectPathFromScroll: (viewer: CodeViewInstance) => void;
+    onSubmitComment: (commentId: string) => void;
+    onToggleCollapsed: (file: ChangedFile, isCollapsed: boolean, reviewKey: string) => void;
+    onToggleViewed: (file: ChangedFile, isViewed: boolean, reviewIdentity: ReviewIdentity) => void;
+    onUpdateComment: (commentId: string, body: string) => void;
+    onUpdateSourceDescription?: (body: string) => Promise<void> | void;
+    onUpdateSourceTitle?: (title: string) => Promise<void> | void;
+    onUploadSourceDescriptionAsset?: (file: File) => Promise<string> | string;
+    reviewIdentityByPath?: ReadonlyMap<string, ReviewIdentity>;
+    scrollTarget: ReviewScrollTarget | null;
+    searchQuery: string;
+    selectedPath: string | null;
+    showSourceDescription?: boolean;
+    showWhitespace: boolean;
+    source: ReviewSource;
+    sourceDescriptionActions?: ReactNode;
+    sourceDescriptionFooter?: ReactNode;
+    theme?: CodiffPreferences['theme'];
+    viewed: Record<string, string>;
+    walkthroughNotes: ReadonlyMap<string, WalkthroughNote>;
+    wordWrap: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/app/components/Sidebar.d.ts

@@ -0,0 +1,48 @@
+import type { CodiffKeymap } from '../../config/types.ts';
+import type { DiffLineCount, PullRequestSource, SidebarMode, WalkthroughError } from '../../lib/app-types.ts';
+import type { ChangedFile, HistoryEntry, NarrativeWalkthrough, ReviewSource } from '../../types.ts';
+import type { NarrativeNavigation } from './walkthrough/useNarrativeNavigation.ts';
+export declare function Sidebar({ branchSource, commitFiles, commitViewOpen, currentSource, files, historyEntries, historyHasMore, historyLoading, keymap, mode, narrativeNavigation, narrativeWalkthrough, onActivatePath, onLoadMoreHistory, onModeChange, onSearchQueryChange, onSelectSource, onShareWalkthrough, onToggleCommitView, pullRequestSource, reloadDeltaPaths, searchQuery, selectedPath, shareWalkthroughDisabled, showWhitespace, viewed, walkthroughError, walkthroughLoading, walkthroughOutdatedPaths, walkthroughProgress, walkthroughUnread, }: {
+    branchSource: Extract<ReviewSource, {
+        type: 'branch-diff';
+    }> | null;
+    commitFiles: ReadonlyArray<ChangedFile>;
+    commitViewOpen: boolean;
+    currentSource: ReviewSource;
+    files: ReadonlyArray<ChangedFile>;
+    historyEntries: ReadonlyArray<HistoryEntry>;
+    historyHasMore: boolean;
+    historyLoading: boolean;
+    keymap: CodiffKeymap;
+    mode: SidebarMode;
+    narrativeNavigation: NarrativeNavigation;
+    narrativeWalkthrough: NarrativeWalkthrough | null;
+    onActivatePath: (path: string) => void;
+    onLoadMoreHistory: () => void;
+    onModeChange: (mode: SidebarMode) => void;
+    onSearchQueryChange: (query: string) => void;
+    onSelectSource: (source: ReviewSource) => void;
+    onShareWalkthrough?: () => void;
+    onToggleCommitView: () => void;
+    pullRequestSource: PullRequestSource | null;
+    reloadDeltaPaths: ReadonlySet<string>;
+    searchQuery: string;
+    selectedPath: string | null;
+    shareWalkthroughDisabled?: boolean;
+    showWhitespace: boolean;
+    viewed: Record<string, string>;
+    walkthroughError: WalkthroughError | null;
+    walkthroughLoading: boolean;
+    walkthroughOutdatedPaths: ReadonlySet<string>;
+    walkthroughProgress: {
+        phase: import('../../types.ts').WalkthroughProgressPhase | null;
+        responseLabelIndex: number;
+        stageRevision: number;
+    };
+    walkthroughUnread: boolean;
+}): import("react").JSX.Element;
+export declare function DiffLineCountBadge({ ariaLabelPrefix, className, lineCount, }: {
+    ariaLabelPrefix?: string;
+    className?: string;
+    lineCount: DiffLineCount;
+}): import("react").JSX.Element | null;

package/dist/app/components/WalkthroughFileError.d.ts

@@ -0,0 +1,4 @@
+export type WalkthroughFileError = {
+    path: string;
+    reason: string;
+};

package/dist/app/components/merge-request/GeneralComments.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode } from 'react';
+import type { CodiffKeymap } from '../../../config/types.ts';
+import type { GitIdentity, PullRequestExistingReviewComment, PullRequestGeneralComment, PullRequestGeneralCommentThread, PullRequestReviewComment } from '../../../types.ts';
+export type ReviewCommenting = {
+    canComment: boolean;
+    onDeleteComment: (commentId: string) => Promise<void>;
+    onDeleteGeneralComment: (commentId: string) => Promise<void>;
+    onReplyGeneralComment: (threadId: string, body: string) => Promise<void>;
+    onResolveDiscussion: (discussionId: string, resolved: boolean) => Promise<void>;
+    onSignIn: () => Promise<void> | void;
+    onSubmitComment: (comment: PullRequestReviewComment) => Promise<PullRequestExistingReviewComment>;
+    onSubmitGeneralComment: (body: string) => Promise<void>;
+    onUpdateComment: (commentId: string, body: string) => Promise<void>;
+    onUpdateGeneralComment: (commentId: string, body: string) => Promise<void>;
+};
+export declare function ReadOnlyGeneralCommentCard({ className, comment, focused, }: {
+    className?: string;
+    comment: PullRequestGeneralComment;
+    focused?: boolean;
+}): import("react").JSX.Element;
+export declare function SidebarGeneralCommentList({ comments, focusedCommentId, onActivateComment, }: {
+    comments: ReadonlyArray<PullRequestGeneralComment>;
+    focusedCommentId: string | null;
+    onActivateComment: (commentId: string) => void;
+}): import("react").JSX.Element;
+export declare function MergeRequestCommentsView({ canComment, commenting, draft, editDraft, editError, editingCommentId, editSubmitting, error, focusedCommentId, focusedCommentRequest, gitIdentity, keymap, onCancelEdit, onChangeDraft, onChangeEditDraft, onSaveEdit, onStartEdit, onSubmit, signInLabel, sourceDescription, submitting, threads, }: {
+    canComment: boolean;
+    commenting?: ReviewCommenting;
+    draft: string;
+    editDraft: string;
+    editError: string | null;
+    editingCommentId: string | null;
+    editSubmitting: boolean;
+    error: string | null;
+    focusedCommentId: string | null;
+    focusedCommentRequest: number;
+    gitIdentity: GitIdentity | null;
+    keymap: CodiffKeymap;
+    onCancelEdit: () => void;
+    onChangeDraft: (draft: string) => void;
+    onChangeEditDraft: (draft: string) => void;
+    onSaveEdit: () => void;
+    onStartEdit: (comment: PullRequestGeneralComment) => void;
+    onSubmit: () => void;
+    signInLabel: string;
+    sourceDescription?: ReactNode;
+    submitting: boolean;
+    threads: ReadonlyArray<PullRequestGeneralCommentThread>;
+}): import("react").JSX.Element;

package/dist/app/components/useCopiedState.d.ts

@@ -0,0 +1 @@
+export declare function useCopiedState(timeoutMs: number): readonly [boolean, () => void];

package/dist/app/components/walkthrough/CommitView.d.ts

@@ -0,0 +1,23 @@
+import { type CommitModel } from '../../../lib/narrative-walkthrough.ts';
+import type { WalkthroughCommitMessageRequest, WalkthroughCommitMessageResult, WalkthroughCommitRequest, WalkthroughCommitResult } from '../../../types.ts';
+export type CommitHandler = (request: WalkthroughCommitRequest) => Promise<WalkthroughCommitResult>;
+export type CommitMessageHandler = (request: WalkthroughCommitMessageRequest) => Promise<WalkthroughCommitMessageResult>;
+/** Subscribe to live commit output (pre-commit hook logs); returns unsubscribe. */
+export type CommitOutputSubscriber = (callback: (chunk: string) => void) => () => void;
+export type CommitDraftState = {
+    commitBody: string;
+    commitSelected: ReadonlySet<string>;
+    commitSubject: string;
+    setCommitBody: (value: string) => void;
+    setCommitSubject: (value: string) => void;
+    toggleCommitFile: (path: string) => void;
+    toggleCommitGroup: (paths: ReadonlyArray<string>) => void;
+};
+export declare function CommitView({ branch, draft, model, onCommit, onCommitOutput, onUpdateMessage, }: {
+    branch: string | null;
+    draft: CommitDraftState;
+    model: CommitModel;
+    onCommit: CommitHandler;
+    onCommitOutput?: CommitOutputSubscriber;
+    onUpdateMessage: CommitMessageHandler;
+}): import("react").JSX.Element;

package/dist/app/components/walkthrough/NarrativeSidebar.d.ts

@@ -0,0 +1,12 @@
+import type { ChangedFile, NarrativeWalkthrough } from '../../../types.ts';
+import type { NarrativeNavigation } from './useNarrativeNavigation.ts';
+export declare function NarrativeSidebar({ allowCommit, changedPaths, files, navigation, onShareWalkthrough, shareWalkthroughDisabled, showWhitespace, walkthrough, }: {
+    allowCommit?: boolean;
+    changedPaths?: ReadonlySet<string>;
+    files: ReadonlyArray<ChangedFile>;
+    navigation: NarrativeNavigation;
+    onShareWalkthrough?: () => void;
+    shareWalkthroughDisabled?: boolean;
+    showWhitespace: boolean;
+    walkthrough: NarrativeWalkthrough;
+}): import("react").JSX.Element;

package/dist/app/components/walkthrough/NarrativeWalkthroughView.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from 'react';
+import type { ReviewIdentity } from '../../../lib/app-types.ts';
+import type { ReviewScrollBehavior } from '../../../lib/app-types.ts';
+import type { ChangedFile, NarrativeWalkthrough } from '../../../types.ts';
+import type { ReviewDiffBlock } from '../ReviewCodeView.tsx';
+import { type CommitHandler, type CommitMessageHandler, type CommitOutputSubscriber } from './CommitView.tsx';
+import type { NarrativeNavigation } from './useNarrativeNavigation.ts';
+export type WalkthroughReviewTarget = {
+    file: ChangedFile;
+    reviewIdentity: ReviewIdentity;
+};
+export type WalkthroughBlockScrollTarget = {
+    behavior?: ReviewScrollBehavior;
+    blockId: string;
+    request: number;
+};
+export declare const getWalkthroughBlockScrollTarget: ({ activeBlockId, firstSupportBlockId, mode, stopScrollRequest, supportScrollRequest, }: {
+    activeBlockId: string | null | undefined;
+    firstSupportBlockId: string | null;
+    mode: NarrativeNavigation['mode'];
+    stopScrollRequest: number;
+    supportScrollRequest: number;
+}) => WalkthroughBlockScrollTarget | null;
+export type RenderWalkthroughDiffBlocks = (blocks: ReadonlyArray<ReviewDiffBlock>, scrollTarget: WalkthroughBlockScrollTarget | null, onActiveBlockChange: (blockId: string) => void) => ReactNode;
+type WalkthroughNavigationKeyEvent = Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>;
+export declare const getWalkthroughNavigationKeyDirection: (event: WalkthroughNavigationKeyEvent) => -1 | 0 | 1;
+export declare function NarrativeWalkthroughView({ allowCommit, changedPaths, files, navigation, onActiveReviewTargetChange, onCommit, onCommitOutput, onRegenerateWalkthrough, onShareWalkthrough, onUpdateCommitMessage, regenerateDisabled, renderDiffBlocks, shareWalkthroughDisabled, showWhitespace, walkthrough, }: {
+    allowCommit?: boolean;
+    changedPaths?: ReadonlySet<string>;
+    files: ReadonlyArray<ChangedFile>;
+    navigation: NarrativeNavigation;
+    onActiveReviewTargetChange: (target: WalkthroughReviewTarget | null) => void;
+    onCommit: CommitHandler;
+    onCommitOutput?: CommitOutputSubscriber;
+    onRegenerateWalkthrough?: () => void;
+    onShareWalkthrough?: () => void;
+    onUpdateCommitMessage: CommitMessageHandler;
+    regenerateDisabled?: boolean;
+    renderDiffBlocks: RenderWalkthroughDiffBlocks;
+    shareWalkthroughDisabled?: boolean;
+    showWhitespace: boolean;
+    walkthrough: NarrativeWalkthrough;
+}): import("react").JSX.Element;
+export {};

package/dist/app/components/walkthrough/WalkthroughDiffSurface.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentProps } from 'react';
+import { ReviewCodeView, type ReviewDiffBlock } from '../ReviewCodeView.tsx';
+import type { WalkthroughBlockScrollTarget } from './NarrativeWalkthroughView.tsx';
+type ReviewCodeViewProps = ComponentProps<typeof ReviewCodeView>;
+type WalkthroughReviewProps = Omit<ReviewCodeViewProps, 'blocks' | 'bottomInset' | 'commitMetadata' | 'files' | 'forceExpandedPaths' | 'onActiveBlockChange' | 'onSelectPathFromScroll' | 'scrollTarget' | 'selectedPath' | 'showSourceDescription' | 'walkthroughNotes'>;
+export declare function WalkthroughDiffSurface({ allowViewedToggle, blocks, forceExpandedPaths, onActiveBlockChange, reviewProps, scrollTarget, sourceDescriptionActions, sourceDescriptionFooter, }: {
+    allowViewedToggle?: boolean;
+    blocks: ReadonlyArray<ReviewDiffBlock>;
+    forceExpandedPaths?: ReadonlySet<string>;
+    onActiveBlockChange: (blockId: string) => void;
+    reviewProps: WalkthroughReviewProps;
+    scrollTarget: WalkthroughBlockScrollTarget | null;
+    sourceDescriptionActions?: ReviewCodeViewProps['sourceDescriptionActions'];
+    sourceDescriptionFooter?: ReviewCodeViewProps['sourceDescriptionFooter'];
+}): import("react").JSX.Element;
+export {};

package/dist/app/components/walkthrough/WalkthroughProgress.d.ts

@@ -0,0 +1,8 @@
+import type { WalkthroughProgressPhase } from '../../../types.ts';
+export declare const walkthroughResponseLabels: readonly ['Building walkthrough…', 'Composing walkthrough…', 'Writing walkthrough…', 'Assembling walkthrough…', 'Creating walkthrough…', 'Producing walkthrough…'];
+export declare const nextWalkthroughResponseLabelIndex: (current: number) => number;
+export declare function WalkthroughProgress({ phase, responseLabelIndex, stageRevision, }: {
+    phase: WalkthroughProgressPhase | null;
+    responseLabelIndex: number;
+    stageRevision: number;
+}): import("react").JSX.Element;

package/dist/app/components/walkthrough/parts.d.ts

@@ -0,0 +1,15 @@
+import type { WalkthroughIcon, WalkthroughStop } from '../../../types.ts';
+export declare function ChapterIcon({ icon, size }: {
+    icon: WalkthroughIcon;
+    size?: number;
+}): import("react").JSX.Element;
+export declare function ImportancePill({ importance }: {
+    importance: WalkthroughStop['importance'];
+}): import("react").JSX.Element;
+export declare function WalkthroughLineCount({ added, deleted }: {
+    added: number;
+    deleted: number;
+}): import("react").JSX.Element;
+export declare function Narration({ prose }: {
+    prose: string;
+}): import("react").JSX.Element;