@nkzw/codiff-core 1.8.1

package/dist/lib/item-version.d.ts

@@ -0,0 +1 @@
+export declare const getItemVersion: (value: string) => number;

package/dist/lib/keyboard.d.ts

@@ -0,0 +1,2 @@
+export declare const isNativeInputTarget: (target: EventTarget | null) => boolean;
+export declare const isDiffSearchShortcut: (event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>, platform?: string) => boolean;

package/dist/lib/markdown.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+export declare const sanitizeMarkdownImages: (text: string) => string;
+export declare const renderInlineMarkdown: (text: string) => ReactNode;

package/dist/lib/narrative-walkthrough-diff.d.ts

@@ -0,0 +1,113 @@
+declare const HUNK_HEADER: RegExp;
+/** @param {string} path */
+declare const isGeneratedWalkthroughPath: (path: string) => boolean;
+/** @param {{generated?: boolean; path: string}} file */
+declare const isGeneratedWalkthroughFile: (file: {
+    generated?: boolean;
+    path: string;
+}) => boolean;
+/** @param {string} line */
+declare const parseHunkHeader: (line: string) => {
+    additionCount: number;
+    additionEnd: number;
+    additionStart: number;
+    deletionCount: number;
+    deletionEnd: number;
+    deletionStart: number;
+} | null;
+/** @param {string} patch */
+declare const extractPatchHunks: (patch: string) => {
+    additionCount: number;
+    additionEnd: number;
+    additionStart: number;
+    deletionCount: number;
+    deletionEnd: number;
+    deletionStart: number;
+    added: number;
+    deleted: number;
+    header: string;
+}[];
+/** @param {ReadonlyArray<{added: number; deleted: number}>} hunks */
+declare const sumHunkLineCounts: (hunks: ReadonlyArray<{
+    added: number;
+    deleted: number;
+}>) => {
+    added: number;
+    deleted: number;
+};
+/** @param {{kind?: string} | null | undefined} hunk */
+declare const isSyntheticWalkthroughHunk: (hunk: {
+    kind?: string;
+} | null | undefined) => boolean;
+/** @param {ReturnType<typeof extractPatchHunks>[number] & {kind?: string}} hunk */
+declare const hunkDisplayStart: (hunk: ReturnType<typeof extractPatchHunks>[number] & {
+    kind?: string;
+}) => number | undefined;
+/** @param {ReturnType<typeof extractPatchHunks>[number] & {kind?: string}} hunk */
+declare const hunkDisplayEnd: (hunk: ReturnType<typeof extractPatchHunks>[number] & {
+    kind?: string;
+}) => number | undefined;
+/** @param {string} path @param {ReadonlyArray<ReturnType<typeof extractPatchHunks>[number] & {kind?: string}>} hunks */
+declare const buildAnchorDisplay: (path: string, hunks: ReadonlyArray<ReturnType<typeof extractPatchHunks>[number] & {
+    kind?: string;
+}>) => string;
+/**
+ * Codiff's walkthrough hunk ids identify the smallest reviewable diff unit.
+ * Most are textual patch hunks; non-text or metadata-only sections get one
+ * synthetic hunk so walkthroughs remain hunk-based for every visible change.
+ *
+ * @param {{generated?: boolean; oldPath?: string; path: string; status: string}} file
+ * @param {{binary?: boolean; id: string; kind: string; loadState?: string; patch?: string; summary?: {reason?: string}}} section
+ */
+declare const getSectionWalkthroughHunks: (file: {
+    generated?: boolean;
+    oldPath?: string;
+    path: string;
+    status: string;
+}, section: {
+    binary?: boolean;
+    id: string;
+    kind: string;
+    loadState?: string;
+    patch?: string;
+    summary?: {
+        reason?: string;
+    };
+}) => {
+    added: number;
+    deleted: number;
+    id: string;
+    index: number;
+    kind: string;
+    oldPath: string | undefined;
+    path: string;
+    sectionId: string;
+    sectionKind: string;
+    status: string;
+    summary: string | undefined;
+}[] | {
+    additionCount: number;
+    additionEnd: number;
+    additionStart: number;
+    deletionCount: number;
+    deletionEnd: number;
+    deletionStart: number;
+    added: number;
+    deleted: number;
+    header: string;
+    id: string;
+    index: number;
+    kind: string;
+    oldPath: string | undefined;
+    path: string;
+    sectionId: string;
+    sectionKind: string;
+    status: string;
+}[];
+/**
+ * @param {string} patch
+ * @param {string} sectionId
+ * @param {ReadonlyArray<string>} hunkIds
+ */
+declare const filterPatchToHunkIds: (patch: string, sectionId: string, hunkIds: ReadonlyArray<string>) => string | null;
+export { buildAnchorDisplay, extractPatchHunks, filterPatchToHunkIds, getSectionWalkthroughHunks, HUNK_HEADER, hunkDisplayEnd, hunkDisplayStart, isGeneratedWalkthroughFile, isGeneratedWalkthroughPath, isSyntheticWalkthroughHunk, parseHunkHeader, sumHunkLineCounts, };

package/dist/lib/narrative-walkthrough-diff.mjs

@@ -0,0 +1,257 @@
+//#region lib/narrative-walkthrough-diff.js
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+const GENERATED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+	"__generated__",
+	"__snapshots__",
+	".generated",
+	"codegen",
+	"gen",
+	"generated",
+	"generated-sources",
+	"generated-src"
+]);
+const GENERATED_BASENAMES = /* @__PURE__ */ new Set([
+	"bun.lock",
+	"bun.lockb",
+	"cargo.lock",
+	"gemfile.lock",
+	"npm-shrinkwrap.json",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"poetry.lock",
+	"pubspec.lock",
+	"uv.lock",
+	"yarn.lock"
+]);
+const GENERATED_EXTENSIONS = [
+	".d.ts.map",
+	".g.dart",
+	".generated.cjs",
+	".generated.css",
+	".generated.js",
+	".generated.jsx",
+	".generated.mjs",
+	".generated.ts",
+	".generated.tsx",
+	".pb.go",
+	".pb.gw.go",
+	".snap",
+	".snapshot"
+];
+const GENERATED_SUFFIXES = [
+	"-generated.js",
+	"-generated.ts",
+	"-generated.tsx",
+	".min.cjs",
+	".min.css",
+	".min.js",
+	".min.mjs",
+	".pb.cc",
+	".pb.h",
+	".pb.rb",
+	"_generated.go",
+	"_generated.rs",
+	"_pb2.py",
+	"_pb2_grpc.py"
+];
+/** @param {string} path */
+const getPathParts = (path) => path.replaceAll("\\", "/").split("/").filter(Boolean);
+/** @param {string} path */
+const isGeneratedWalkthroughPath = (path) => {
+	const parts = getPathParts(path).map((part) => part.toLowerCase());
+	const basename = parts.at(-1) || "";
+	if (!basename) return false;
+	return parts.some((part) => GENERATED_DIRECTORY_NAMES.has(part)) || GENERATED_BASENAMES.has(basename) || GENERATED_EXTENSIONS.some((extension) => basename.endsWith(extension)) || GENERATED_SUFFIXES.some((suffix) => basename.endsWith(suffix)) || basename.endsWith(".map") && !basename.endsWith(".importmap");
+};
+/** @param {{generated?: boolean; path: string}} file */
+const isGeneratedWalkthroughFile = (file) => file.generated ?? isGeneratedWalkthroughPath(file.path);
+/** @param {string} path */
+const getGeneratedWalkthroughSummary = (path) => {
+	const parts = getPathParts(path).map((part) => part.toLowerCase());
+	const basename = parts.at(-1) || "";
+	if (GENERATED_BASENAMES.has(basename)) return "Lockfile collapsed into one generated-file review unit.";
+	if (parts.includes("__snapshots__") || basename.endsWith(".snap") || basename.endsWith(".snapshot")) return "Snapshot collapsed into one generated-file review unit.";
+	return "Generated file collapsed into one review unit.";
+};
+/** @param {string} line */
+const parseHunkHeader = (line) => {
+	const match = HUNK_HEADER.exec(line);
+	if (!match) return null;
+	const deletionStart = Number(match[1]);
+	const deletionCount = Number(match[2] ?? 1);
+	const additionStart = Number(match[3]);
+	const additionCount = Number(match[4] ?? 1);
+	return {
+		additionCount,
+		additionEnd: additionStart + Math.max(0, additionCount - 1),
+		additionStart,
+		deletionCount,
+		deletionEnd: deletionStart + Math.max(0, deletionCount - 1),
+		deletionStart
+	};
+};
+/** @param {string} patch */
+const extractPatchHunks = (patch) => {
+	const lines = typeof patch === "string" ? patch.split("\n") : [];
+	const hunks = [];
+	let index = 0;
+	while (index < lines.length) {
+		const header = lines[index] ?? "";
+		const parsed = parseHunkHeader(header);
+		if (!parsed) {
+			index += 1;
+			continue;
+		}
+		let additions = 0;
+		let deletions = 0;
+		index += 1;
+		while (index < lines.length && !parseHunkHeader(lines[index] ?? "")) {
+			const line = lines[index] ?? "";
+			if (line.startsWith("+")) additions += 1;
+			else if (line.startsWith("-")) deletions += 1;
+			index += 1;
+		}
+		hunks.push({
+			...parsed,
+			added: additions,
+			deleted: deletions,
+			header
+		});
+	}
+	return hunks;
+};
+/** @param {ReadonlyArray<{added: number; deleted: number}>} hunks */
+const sumHunkLineCounts = (hunks) => hunks.reduce((totals, hunk) => ({
+	added: totals.added + hunk.added,
+	deleted: totals.deleted + hunk.deleted
+}), {
+	added: 0,
+	deleted: 0
+});
+/** @param {{kind?: string} | null | undefined} hunk */
+const isSyntheticWalkthroughHunk = (hunk) => hunk?.kind === "synthetic";
+/** @param {ReturnType<typeof extractPatchHunks>[number] & {kind?: string}} hunk */
+const hunkDisplayStart = (hunk) => {
+	if (isSyntheticWalkthroughHunk(hunk)) return;
+	return hunk.added > 0 ? hunk.additionStart : hunk.deletionStart;
+};
+/** @param {ReturnType<typeof extractPatchHunks>[number] & {kind?: string}} hunk */
+const hunkDisplayEnd = (hunk) => {
+	if (isSyntheticWalkthroughHunk(hunk)) return;
+	return hunk.added > 0 ? hunk.additionEnd : hunk.deletionEnd;
+};
+/** @param {string} path @param {ReadonlyArray<ReturnType<typeof extractPatchHunks>[number] & {kind?: string}>} hunks */
+const buildAnchorDisplay = (path, hunks) => {
+	if (hunks.length === 0) return path;
+	const first = hunks[0];
+	const last = hunks.at(-1);
+	if (!first || !last) return path;
+	if (isSyntheticWalkthroughHunk(first)) return path;
+	const startLine = hunkDisplayStart(first);
+	const endLine = hunkDisplayEnd(last);
+	return startLine && endLine && endLine !== startLine ? `${path}:${startLine}-${endLine}` : `${path}:${startLine || 1}`;
+};
+/** @param {{oldPath?: string; path: string; status?: string}} file */
+const fileHasRenameMetadata = (file) => file.status === "renamed" && file.oldPath != null && file.oldPath !== file.path;
+/**
+* @param {{oldPath?: string; path: string; status?: string}} file
+* @param {{binary?: boolean; loadState?: string; patch?: string; summary?: {reason?: string}}} section
+*/
+const shouldCreateSyntheticHunk = (file, section) => {
+	if (section.binary) return true;
+	if (section.loadState != null && section.loadState !== "ready") return true;
+	if (fileHasRenameMetadata(file)) return true;
+	return typeof section.patch === "string" && section.patch.trim().length > 0;
+};
+/**
+* @param {{generated?: boolean; oldPath?: string; path: string; status: string}} file
+* @param {{binary?: boolean; id: string; kind: string; loadState?: string; patch?: string; summary?: {reason?: string}}} section
+*/
+const createSyntheticSectionHunk = (file, section, lineCount = {
+	added: 0,
+	deleted: 0
+}) => ({
+	added: lineCount.added,
+	deleted: lineCount.deleted,
+	id: `${section.id}:h1`,
+	index: 1,
+	kind: "synthetic",
+	oldPath: file.oldPath,
+	path: file.path,
+	sectionId: section.id,
+	sectionKind: section.kind,
+	status: file.status,
+	summary: section.summary?.reason ?? (isGeneratedWalkthroughFile(file) ? getGeneratedWalkthroughSummary(file.path) : void 0)
+});
+/**
+* Codiff's walkthrough hunk ids identify the smallest reviewable diff unit.
+* Most are textual patch hunks; non-text or metadata-only sections get one
+* synthetic hunk so walkthroughs remain hunk-based for every visible change.
+*
+* @param {{generated?: boolean; oldPath?: string; path: string; status: string}} file
+* @param {{binary?: boolean; id: string; kind: string; loadState?: string; patch?: string; summary?: {reason?: string}}} section
+*/
+const getSectionWalkthroughHunks = (file, section) => {
+	const patchHunks = extractPatchHunks(section.patch || "");
+	if (patchHunks.length > 0 && isGeneratedWalkthroughFile(file)) return [createSyntheticSectionHunk(file, section, sumHunkLineCounts(patchHunks))];
+	if (patchHunks.length > 0) return patchHunks.map((hunk, index) => ({
+		...hunk,
+		id: `${section.id}:h${index + 1}`,
+		index: index + 1,
+		kind: "patch",
+		oldPath: file.oldPath,
+		path: file.path,
+		sectionId: section.id,
+		sectionKind: section.kind,
+		status: file.status
+	}));
+	return shouldCreateSyntheticHunk(file, section) ? [createSyntheticSectionHunk(file, section)] : [];
+};
+/** @param {string} sectionId @param {string} hunkId */
+const getHunkOrdinal = (sectionId, hunkId) => {
+	const prefix = `${sectionId}:h`;
+	if (!hunkId.startsWith(prefix)) return null;
+	const ordinal = Number(hunkId.slice(prefix.length));
+	return Number.isInteger(ordinal) && ordinal > 0 ? ordinal : null;
+};
+/**
+* @param {string} patch
+* @param {string} sectionId
+* @param {ReadonlyArray<string>} hunkIds
+*/
+const filterPatchToHunkIds = (patch, sectionId, hunkIds) => {
+	if (typeof patch !== "string" || patch.trim().length === 0 || hunkIds.length === 0) return null;
+	const patchLines = patch.split("\n");
+	const headerLines = [];
+	const hunkLinesByOrdinal = /* @__PURE__ */ new Map();
+	let index = 0;
+	let foundHunk = false;
+	let ordinal = 0;
+	while (index < patchLines.length) {
+		if (parseHunkHeader(patchLines[index] ?? "")) {
+			foundHunk = true;
+			ordinal += 1;
+			const hunkStart = index;
+			index += 1;
+			while (index < patchLines.length && !parseHunkHeader(patchLines[index] ?? "")) index += 1;
+			hunkLinesByOrdinal.set(ordinal, patchLines.slice(hunkStart, index));
+			continue;
+		}
+		if (!foundHunk) headerLines.push(patchLines[index] ?? "");
+		index += 1;
+	}
+	if (!foundHunk) return null;
+	const selectedHunkLines = [];
+	for (const hunkId of hunkIds) {
+		const ordinal = getHunkOrdinal(sectionId, hunkId);
+		if (ordinal == null) return null;
+		const lines = hunkLinesByOrdinal.get(ordinal);
+		if (!lines) return null;
+		selectedHunkLines.push(...lines);
+	}
+	if (selectedHunkLines.length === 0) return null;
+	const focused = [...headerLines, ...selectedHunkLines].join("\n");
+	return patch.endsWith("\n") && !focused.endsWith("\n") ? `${focused}\n` : focused;
+};
+//#endregion
+export { HUNK_HEADER, buildAnchorDisplay, extractPatchHunks, filterPatchToHunkIds, getSectionWalkthroughHunks, hunkDisplayEnd, hunkDisplayStart, isGeneratedWalkthroughFile, isGeneratedWalkthroughPath, isSyntheticWalkthroughHunk, parseHunkHeader, sumHunkLineCounts };

package/dist/lib/narrative-walkthrough.d.ts

@@ -0,0 +1,108 @@
+import type { ChangedFile, DiffSection, NarrativeWalkthrough, WalkthroughChangeType, WalkthroughChapter, WalkthroughHunk, WalkthroughHunkGroup, WalkthroughIcon, WalkthroughSupportGroup, WalkthroughStop } from '../types.ts';
+/** A stop with a global position in the walkthrough. */
+export type WalkthroughStopView = WalkthroughStop & {
+    chapterId: string;
+    index: number;
+};
+/** A chapter with indexed stops. */
+type WalkthroughChapterView = Omit<WalkthroughChapter, 'stops'> & {
+    stops: ReadonlyArray<WalkthroughStopView>;
+};
+/** Support grouped by reason, preserving first-seen order. */
+type WalkthroughSupportReason = {
+    files: ReadonlyArray<WalkthroughSupportGroup>;
+    reason: string;
+};
+/** Everything a narrative walkthrough needs to render. */
+export type WalkthroughView = {
+    chapters: ReadonlyArray<WalkthroughChapterView>;
+    sequence: ReadonlyArray<WalkthroughStopView>;
+    support: ReadonlyArray<WalkthroughSupportGroup>;
+    supportByReason: ReadonlyArray<WalkthroughSupportReason>;
+};
+export type WalkthroughFileList = {
+    label: string;
+    title: string;
+};
+export type WalkthroughFileLineRow = {
+    added: number;
+    deleted: number;
+    label: string;
+    path?: string;
+    title: string;
+};
+export declare const walkthroughFileName: (path: string) => string;
+export declare const walkthroughItemPaths: (item: WalkthroughHunkGroup) => ReadonlyArray<string>;
+export declare const walkthroughItemTitleFallback: (item: WalkthroughHunkGroup & {
+    prose?: string;
+}) => string;
+export declare const formatWalkthroughFileList: (paths: ReadonlyArray<string>, maxVisibleFiles?: number) => WalkthroughFileList;
+export declare const formatWalkthroughFileLineRows: (items: ReadonlyArray<{
+    added: number;
+    deleted: number;
+    path: string;
+}>, maxVisibleFiles?: number) => ReadonlyArray<WalkthroughFileLineRow>;
+export declare const getUncoveredWalkthroughFiles: (files: ReadonlyArray<ChangedFile>, view: WalkthroughView, showWhitespace: boolean) => ReadonlyArray<ChangedFile>;
+export declare const getUncoveredWalkthroughFileLineItems: (files: ReadonlyArray<ChangedFile>, view: WalkthroughView, showWhitespace: boolean) => ReadonlyArray<{
+    added: number;
+    deleted: number;
+    path: string;
+}>;
+export declare const isWalkthroughCommittable: (walkthrough: NarrativeWalkthrough) => boolean;
+/** Build the walkthrough view-model with globally indexed stops. */
+export declare const buildWalkthroughView: (walkthrough: NarrativeWalkthrough) => WalkthroughView | null;
+/** The changed file + diff section a resolved hunk anchors into, if present in the diff. */
+export type ResolvedWalkthroughHunkFile = {
+    file: ChangedFile;
+    section: DiffSection;
+};
+export type WalkthroughHunkRun = {
+    hunks: ReadonlyArray<WalkthroughHunk>;
+    key: string;
+    resolved: ResolvedWalkthroughHunkFile;
+};
+/** Resolve one normalized hunk to its exact live `ChangedFile` and `DiffSection`. */
+export declare const resolveWalkthroughHunkFile: (hunk: WalkthroughHunk, files: ReadonlyArray<ChangedFile>) => ResolvedWalkthroughHunkFile | null;
+/** Resolve item hunks in authored order, coalescing adjacent hunks from the same file section. */
+export declare const resolveWalkthroughHunkRuns: (item: WalkthroughHunkGroup, files: ReadonlyArray<ChangedFile>) => ReadonlyArray<WalkthroughHunkRun>;
+export declare const getWalkthroughRunNote: (item: WalkthroughHunkGroup, run: WalkthroughHunkRun) => string | undefined;
+/**
+ * Return the changed-file view a walkthrough stop should render for one live diff
+ * section. The patch contains exactly the provided hunk ids, in that order.
+ */
+export declare const focusChangedFileForHunks: (file: ChangedFile, section: DiffSection, hunks: ReadonlyArray<WalkthroughHunk>) => ChangedFile | null;
+/** One unique changed file in the commit composer, with summed line counts. */
+export type CommitFile = {
+    added: number;
+    changeType?: WalkthroughChangeType;
+    deleted: number;
+    itemId: string;
+    name: string;
+    /** The note the generated body uses for this file. */
+    note?: string;
+    path: string;
+};
+/** A group of files in the composer — one per chapter, plus a final support group. */
+export type CommitGroup = {
+    files: ReadonlyArray<CommitFile>;
+    icon: WalkthroughIcon;
+    id: string;
+    isSupport: boolean;
+    title: string;
+};
+export type CommitModel = {
+    /** Every unique file, in group order. */
+    files: ReadonlyArray<CommitFile>;
+    groups: ReadonlyArray<CommitGroup>;
+};
+export declare const changeTypeLabel: Record<WalkthroughChangeType, string>;
+export declare const buildGenericCommitModel: (changedFiles: ReadonlyArray<ChangedFile>) => CommitModel;
+/**
+ * Collapse the walkthrough view into unique changed files. Line counts are
+ * summed across every item that shares a path, and a path is placed in the first
+ * group that mentions it.
+ */
+export declare const buildCommitModel: (view: WalkthroughView, changedFiles?: ReadonlyArray<ChangedFile>) => CommitModel;
+export declare const getCommitSelectionPaths: (view: WalkthroughView | null, changedFiles: ReadonlyArray<ChangedFile>) => ReadonlyArray<string>;
+export declare const importanceLabel: Record<WalkthroughStop['importance'], string>;
+export {};

package/dist/lib/reload-selection.d.ts

@@ -0,0 +1,23 @@
+import type { GitFileStatus, RepositoryState, ReviewSource } from '../types.ts';
+type ReloadSelectionFile = {
+    fingerprint: string;
+    path: string;
+    status: GitFileStatus;
+};
+export type ReloadMainMode = 'commit' | 'review';
+type ReloadSelection = {
+    files: ReadonlyArray<ReloadSelectionFile>;
+    historySource?: ReviewSource | null;
+    mainMode?: ReloadMainMode;
+    root: string;
+    selectedPath: string | null;
+    source: ReviewSource;
+};
+export declare const consumeReloadSelection: () => ReloadSelection | null;
+export declare const getReloadSelectionPath: (selection: ReloadSelection | null, state: RepositoryState) => string | null;
+export declare const getChangedPaths: (previousFiles: ReadonlyArray<ReloadSelectionFile>, nextFiles: ReadonlyArray<ReloadSelectionFile>) => ReadonlySet<string>;
+export declare const getReloadDeltaPaths: (selection: ReloadSelection | null, state: RepositoryState) => ReadonlySet<string>;
+export declare const getReloadHistorySource: (selection: ReloadSelection | null, state: RepositoryState) => ReviewSource | null;
+export declare const getReloadMainMode: (selection: ReloadSelection | null, state: RepositoryState) => ReloadMainMode | null;
+export declare const writeReloadSelection: (state: RepositoryState | null, selectedPath: string | null, historySource?: ReviewSource | null, mainMode?: ReloadMainMode) => void;
+export {};

package/dist/lib/review-command-target.d.ts

@@ -0,0 +1,15 @@
+import type { ChangedFile, ReviewSource } from '../types.ts';
+import type { ReviewIdentity } from './app-types.ts';
+export type ReviewCommandTarget = {
+    file: ChangedFile;
+    reviewIdentity: ReviewIdentity;
+    sourceKey: string;
+};
+export declare const createReviewCommandTarget: (source: ReviewSource, file: ChangedFile, reviewIdentity?: ReviewIdentity) => ReviewCommandTarget;
+export declare const resolveReviewCommandTarget: ({ activeTarget, files, selectedPath, source, useActiveTarget, }: {
+    activeTarget: ReviewCommandTarget | null;
+    files: ReadonlyArray<ChangedFile>;
+    selectedPath: string | null;
+    source: ReviewSource;
+    useActiveTarget: boolean;
+}) => ReviewCommandTarget | null;

package/dist/lib/review-comments.d.ts

@@ -0,0 +1,29 @@
+import type { ChangedFile, PullRequestReviewComment, RepositoryState } from '../types.ts';
+import type { CodeViewInstance, ReviewComment } from './app-types.ts';
+export declare const isInteractiveReviewEvent: (event: PointerEvent) => boolean;
+export declare const hasActiveTextSelection: () => boolean;
+export declare const isFileReviewComment: (comment: Pick<ReviewComment, 'anchor' | 'lineNumber' | 'side'>) => boolean;
+export declare const isLineReviewComment: (comment: ReviewComment) => comment is ReviewComment & {
+    lineNumber: number;
+    side: 'additions' | 'deletions';
+};
+export declare function updateStickyHeaderState(viewer: CodeViewInstance): void;
+export declare const getReviewCommentLineLabel: (comment: Pick<ReviewComment, 'anchor' | 'lineNumber' | 'side' | 'startLineNumber' | 'startSide'>) => string;
+export declare const getReviewCommentRangeProps: (comment: Pick<ReviewComment, 'anchor' | 'lineNumber' | 'side' | 'startLineNumber' | 'startSide'>) => {
+    anchor: 'file';
+} | {
+    anchor?: undefined;
+} | {
+    anchor?: undefined;
+    startLineNumber: number;
+    startSide?: "additions" | "deletions" | undefined;
+};
+export declare const toPullRequestReviewComment: (comment: ReviewComment) => PullRequestReviewComment;
+export declare const getPendingPullRequestReviewComments: (comments: ReadonlyArray<ReviewComment>, activeDraft?: Pick<ReviewComment, 'body' | 'id'> | null) => ReviewComment[];
+export declare const findReusableReviewCommentDraft: (comments: ReadonlyArray<ReviewComment>, activeDraft?: Pick<ReviewComment, 'body' | 'id'> | null) => ReviewComment | undefined;
+export declare const getCommentKey: (comment: Pick<ReviewComment, 'anchor' | 'lineNumber' | 'sectionId' | 'side' | 'startLineNumber' | 'startSide'>) => string;
+export declare const getReviewCommentsDigest: (comments: ReadonlyArray<ReviewComment>) => string;
+export declare const buildReviewCommentsMarkdown: (files: ReadonlyArray<ChangedFile>, comments: ReadonlyArray<ReviewComment>, showWhitespace: boolean, prefix?: string) => string;
+export declare const getReviewCommentsFromState: (state: RepositoryState) => ReadonlyArray<ReviewComment>;
+export declare const getVisibleReviewComments: (comments: ReadonlyArray<ReviewComment>, showOutdated: boolean) => ReadonlyArray<ReviewComment>;
+export declare const shouldDiscardReviewCommentOnEscape: (body: string, confirmDiscard?: (message: string) => boolean) => boolean;

package/dist/lib/review-identity.d.ts

@@ -0,0 +1,7 @@
+import type { ChangedFile } from '../types.ts';
+import type { ReviewIdentity } from './app-types.ts';
+export declare const getFileReviewIdentity: (file: ChangedFile) => ReviewIdentity;
+export declare const getReviewIdentity: (file: ChangedFile, identityByPath?: ReadonlyMap<string, ReviewIdentity>) => ReviewIdentity;
+export declare const isReviewIdentityViewed: (viewed: Readonly<Record<string, string>>, identity: ReviewIdentity) => boolean;
+export declare const updateReviewIdentityViewed: (viewed: Readonly<Record<string, string>>, identity: ReviewIdentity, currentlyViewed: boolean) => Record<string, string>;
+export declare const updateReviewIdentityCollapsed: (collapsed: ReadonlySet<string>, identity: ReviewIdentity, currentlyCollapsed: boolean) => Set<string>;

package/dist/lib/review-scroll.d.ts

@@ -0,0 +1,5 @@
+import type { ChangedFile } from '../types.ts';
+import type { CodeViewInstance } from './app-types.ts';
+type ReviewScrollViewer = Pick<CodeViewInstance, 'getScrollTop' | 'getTopForItem'>;
+export declare const getSelectedPathFromScroll: (viewer: ReviewScrollViewer, files: ReadonlyArray<ChangedFile>, showWhitespace: boolean) => string | null;
+export {};

package/dist/lib/search-highlights.d.ts

@@ -0,0 +1,5 @@
+import type { DiffSearchMatch } from './app-types.ts';
+export declare const applySearchHighlights: (renderedItems: ReadonlyArray<{
+    element: HTMLElement;
+    id: string;
+}>, query: string, activeMatch: DiffSearchMatch | null) => void;

package/dist/lib/sidebar-width.d.ts

@@ -0,0 +1,9 @@
+export declare const SIDEBAR_COLLAPSE_THRESHOLD = 80;
+export declare const SIDEBAR_DEFAULT_WIDTH = 292;
+export declare const SIDEBAR_MAX_WIDTH = 640;
+export declare const SIDEBAR_MIN_WIDTH = 220;
+type SidebarWidthStorage = Pick<Storage, 'getItem' | 'setItem'>;
+export declare const clampSidebarWidth: (width: number) => number;
+export declare const readSidebarWidth: (storage?: SidebarWidthStorage) => number;
+export declare const writeSidebarWidth: (width: number, storage?: SidebarWidthStorage) => void;
+export {};

package/dist/lib/source.d.ts

@@ -0,0 +1,18 @@
+import type { ReviewSource } from '../types.ts';
+import type { RepositoryLoadError } from './app-types.ts';
+export declare const getSourceKey: (source: ReviewSource) => string;
+export declare const getRepositoryLoadError: (error: unknown) => RepositoryLoadError;
+export declare const getShortRef: (ref: string) => string;
+export declare const getSourceLabel: (source: ReviewSource) => string;
+export declare const getHistorySource: (source: ReviewSource) => ReviewSource | undefined;
+export declare const getRefreshSource: (source: ReviewSource) => ReviewSource;
+export declare const supportsLazyDiffContent: (source: ReviewSource) => boolean;
+export declare const supportsDiffSearchContentPreload: (source: ReviewSource) => boolean;
+export declare const shouldStartInHistoryWhenEmpty: (source: ReviewSource) => boolean;
+export declare const usesViewedFileState: (source: ReviewSource) => boolean;
+export declare const getEmptySourceTitle: (source: ReviewSource) => string;
+export declare const getEmptySourceDetail: (source: ReviewSource, root: string) => {
+    kind: 'code' | 'text';
+    text: string;
+    title?: string;
+};

package/dist/lib/viewed.d.ts

@@ -0,0 +1,2 @@
+export declare const readViewed: (root: string) => Record<string, string>;
+export declare const writeViewed: (root: string, viewed: Record<string, string>) => void;

package/dist/react.d.ts

@@ -0,0 +1,3 @@
+export { Button, buttonVariants, type ButtonProps } from './app/components/Button.tsx';
+export { getPlanCommentAffordancePosition, getPlanCommentColorIndex, getPlanCommentIdentityColorIndex, getSharedPlanDownloadContent, PlanReviewSurface, type PlanReviewCommenting, } from './SharedPlanApp.tsx';
+export { ReadOnlyGeneralCommentCard, ReviewSurface, type ReviewCommenting, type ReviewMode, type ReviewSurfaceProps, type ReviewWalkthroughStatus, } from './SharedWalkthroughApp.tsx';