@kubohiroya/turbowarp-plus-editor-git 0.8.0 → 0.10.0

package/dist/messages.d.ts

@@ -51,6 +51,23 @@ export declare const messages: {
         remoteDone: string;
         pulledProject: string;
         confirmPush: string;
+        details: string;
+        branch: string;
+        head: string;
+        groups: string;
+        added: string;
+        modified: string;
+        deleted: string;
+        gitStaged: string;
+        gitUnstaged: string;
+        gitUntracked: string;
+        upstreamSame: string;
+        upstreamAhead: string;
+        upstreamBehind: string;
+        upstreamDiverged: string;
+        upstreamUnknown: string;
+        records: string;
+        checkedAt: string;
         failed: string;
     };
     ja: {
@@ -105,6 +122,23 @@ export declare const messages: {
         remoteDone: string;
         pulledProject: string;
         confirmPush: string;
+        details: string;
+        branch: string;
+        head: string;
+        groups: string;
+        added: string;
+        modified: string;
+        deleted: string;
+        gitStaged: string;
+        gitUnstaged: string;
+        gitUntracked: string;
+        upstreamSame: string;
+        upstreamAhead: string;
+        upstreamBehind: string;
+        upstreamDiverged: string;
+        upstreamUnknown: string;
+        records: string;
+        checkedAt: string;
         failed: string;
     };
 };

package/dist/project-assets.d.ts

@@ -15,5 +15,9 @@ export declare function currentCostume(target: ProjectTarget): {
     md5ext: string;
     type: string;
 } | null;
+/** The image type of an asset file name, or `undefined` for sounds and anything that is not an image. */
+export declare function assetImageType(md5ext: string): string | undefined;
+/** Loads one image asset of one version as an object URL, or `null` while it is unavailable or not an image. */
+export declare function useAssetImage(md5ext: string | undefined, version: ProjectVersion, loadAsset?: ProjectAssetLoader): string | null;
 /** Loads the current costume of one version of a target as an object URL for an image, or `null` while it is unavailable. */
 export declare function useCostumeImage(target: ProjectTarget | undefined, version: ProjectVersion, loadAsset?: ProjectAssetLoader): string | null;

package/dist/project-change-list.d.ts

@@ -0,0 +1,81 @@
+import React from 'react';
+import type { ChangedFile, ProjectChangeList, ProjectElementChange, ProjectTargetChanges } from './project-change-model.js';
+import type { ProjectAssetLoader } from './project-assets.js';
+import type { ChangeGroup, FileChange, Repository, Snapshot } from './repository.js';
+import type { ProjectBlockRenderer } from './scratch-block-diff-renderer.js';
+declare const en: {
+    title: string;
+    stage: string;
+    code: (count: number) => string;
+    costumes: string;
+    backdrops: string;
+    sounds: string;
+    data: string;
+    settings: string;
+    project: string;
+    other: string;
+    added: string;
+    removed: string;
+    updated: string;
+    files: string;
+    before: string;
+    after: string;
+    absent: string;
+    loading: string;
+    unreadable: string;
+    fileList: string;
+    property: string;
+    format: string;
+    rate: string;
+    samples: string;
+    file: string;
+    noImage: string;
+    groups: Record<ChangeGroup, string>;
+};
+type Labels = typeof en;
+export declare const projectChangeLabels: (locale: string) => Labels;
+export interface ProjectChanges {
+    list: ProjectChangeList;
+    sources: {
+        before: string | null;
+        after: string | null;
+    };
+    loadAsset: ProjectAssetLoader;
+}
+/**
+ * Reads the selected project folder in the last commit and the working tree (or a commit and its parent) and arranges
+ * the changed files by stage, sprite and element. `undefined` while there is no project; `'loading'` and `'unreadable'`
+ * tell the panel to keep the list by file.
+ */
+export declare function useProjectChanges(repository: Repository | null, snapshot: Snapshot | null, project: string | null, commit: string | null, changes: readonly FileChange[]): ProjectChanges | 'loading' | 'unreadable' | undefined;
+/** The change list arranged by the project's stage, sprites and elements, with files outside the project after them. */
+export declare function ProjectChangeListView({ changes, selected, locale, busy, onSelect, onSelectFile, fileList, fileListOpen, setFileListOpen }: {
+    changes: ProjectChanges;
+    selected: string | null;
+    locale: string;
+    busy: boolean;
+    onSelect(key: string): void;
+    onSelectFile(file: ChangedFile): void;
+    fileList: React.ReactNode;
+    fileListOpen: boolean;
+    setFileListOpen(open: boolean): void;
+}): React.JSX.Element;
+export declare function findElement(list: ProjectChangeList, key: string | null): {
+    element: ProjectElementChange;
+    target: ProjectTargetChanges;
+} | {
+    element: ProjectElementChange;
+    target: null;
+} | null;
+/** The details of one selected row: its code, pictures or values in both versions, and the files behind it. */
+export declare function ProjectElementView({ changes, selection, locale, renderBlock, onSelectFile }: {
+    changes: ProjectChanges;
+    selection: {
+        element: ProjectElementChange;
+        target: ProjectTargetChanges | null;
+    };
+    locale: string;
+    renderBlock?: ProjectBlockRenderer;
+    onSelectFile(file: ChangedFile): void;
+}): React.JSX.Element;
+export {};

package/dist/project-change-model.d.ts

@@ -0,0 +1,73 @@
+import type { ChangeGroup } from './repository.js';
+import type { ProjectSource, ProjectTarget } from './project-source-patch.js';
+/** One changed file of the repository, with the Git group it was listed under. A path can appear in several groups. */
+export interface ChangedFile {
+    path: string;
+    group: ChangeGroup;
+}
+export type ProjectElementKind = 'code' | 'costumes' | 'sounds' | 'data' | 'settings';
+export type ProjectChangeStatus = 'added' | 'removed' | 'updated';
+/** One row of the project-shaped change list: something a person recognizes in the Editor. */
+export interface ProjectElementChange {
+    /** Stable within one list, for React keys and selection. */
+    key: string;
+    kind: ProjectElementKind;
+    status: ProjectChangeStatus;
+    /** Costume or sound name; absent for code, data and settings rows. */
+    name?: string;
+    /** The costume or sound entry in each version, for costume and sound rows. */
+    before?: Record<string, unknown>;
+    after?: Record<string, unknown>;
+    /** Asset file names (`md5ext`) of each version, for costume and sound rows. */
+    md5ext?: {
+        before?: string;
+        after?: string;
+    };
+    /**
+     * Changed property keys, for data and settings rows (for example `variables`, `x`, `visible`), and for
+     * project-level rows (`monitors`, `extensions`, `meta`).
+     */
+    properties?: string[];
+    /** Number of changed code items (as counted by the review comparison), for code rows. */
+    scripts?: number;
+    /** The changed repository files behind this row, so the details view can show them with their Git groups. */
+    files: ChangedFile[];
+}
+export interface ProjectTargetChanges {
+    key: string;
+    name: string;
+    isStage: boolean;
+    status: ProjectChangeStatus;
+    before?: ProjectTarget;
+    after?: ProjectTarget;
+    /** In the order code, costumes, sounds, data, settings; costumes and sounds in their order in the target. */
+    elements: ProjectElementChange[];
+}
+export interface ProjectChangeList {
+    /** The stage first, then sprites in project order; removed targets after the existing ones. */
+    targets: ProjectTargetChanges[];
+    /** Project-level changes outside the targets (monitors, extensions, meta and other top-level keys). */
+    project: ProjectElementChange[];
+    /** Changed files that belong to no element: sb3-source.json, embedded-extensions.json, unreferenced assets and the rest. */
+    other: ChangedFile[];
+}
+export interface OrganizeProjectChangesInput {
+    /** The project folder relative to the repository root, `''` for the root. */
+    folder: string;
+    /** The project data of each version, `null` where the version has no project file. */
+    before: ProjectSource | null;
+    after: ProjectSource | null;
+    /** The assets directory of each version, relative to the folder (from sb3-source.json; `assets` by default). */
+    assetsDirectory: {
+        before: string;
+        after: string;
+    };
+    /** Every changed file in the folder, from all Git groups. */
+    files: readonly ChangedFile[];
+}
+/** The Japanese or English name of a project or target property key; unknown keys are returned as they are. */
+export declare function projectPropertyLabel(key: string, locale?: string): string;
+/** The asset file name of a costume or sound entry: `md5ext`, or `assetId.dataFormat`; `''` when it has neither. */
+export declare function assetFileName(entry: Record<string, unknown>): string;
+/** Arranges the changed files of one project folder by stage, sprite and element. Pure; reads nothing. */
+export declare function organizeProjectChanges(input: OrganizeProjectChangesInput): ProjectChangeList;

package/dist/project-source-diff.d.ts

@@ -10,6 +10,8 @@ export type { ProjectBlockLocation, ProjectBlockLocator, ScratchBlockLocationWor
 export type { BlockPart } from './project-source-patch.js';
 export { createProjectSourceDiff } from './project-source-patch.js';
 export { currentCostume } from './project-assets.js';
+export { assetFileName, organizeProjectChanges, projectPropertyLabel } from './project-change-model.js';
+export type { ChangedFile, OrganizeProjectChangesInput, ProjectChangeList, ProjectChangeStatus, ProjectElementChange, ProjectElementKind, ProjectTargetChanges } from './project-change-model.js';
 export type { ProjectAssetLoader, ProjectVersion } from './project-assets.js';
 export { createScratchBlocksDiffRenderer } from './scratch-block-diff-renderer.js';
 export type { BlockPreviewView, BlockPreviewViewport, ProjectBlockRenderer, ProjectBlockRendering, ScratchBlockDiffRendererOptions, ScratchBlocksPort } from './scratch-block-diff-renderer.js';

package/dist/project-source-diff.js

@@ -1,4 +1,4 @@
-import { a as gitHubRepositoryFromOrigin, c as BlockPreview, d as currentCostume, f as compareProjectBlocks, i as createGitHubPullRequests, l as createPreviewSync, m as readProjectSourceDiff, n as createScratchBlocksDiffLocator, o as ProjectSourceComparison, p as createProjectSourceDiff, s as ProjectSourceReview, t as createScratchBlocksDiffRenderer, u as usePreviewSync } from "./scratch-block-diff-renderer-xS8OYsRl.js";
+import { _ as compareProjectBlocks, a as gitHubRepositoryFromOrigin, b as readProjectSourceDiff, c as projectPropertyLabel, d as BlockPreview, f as createPreviewSync, i as createGitHubPullRequests, l as ProjectSourceComparison, m as currentCostume, n as createScratchBlocksDiffLocator, o as assetFileName, p as usePreviewSync, s as organizeProjectChanges, t as createScratchBlocksDiffRenderer, u as ProjectSourceReview, v as createProjectSourceDiff } from "./scratch-block-diff-renderer-DZR8ep-T.js";
 import { n as init_objectSpread2, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
 import React, { useEffect, useMemo, useRef, useState } from "react";
 // src/project-source-diff.tsx
@@ -169,4 +169,4 @@ function ProjectSourceBlockDiff({ patch, beforeSource, renderBlock, locateBlock,
 		})
 	}, labels.more));
 }
-export { ProjectSourceBlockDiff, ProjectSourceComparison, ProjectSourceReview, createGitHubPullRequests, createPreviewSync, createProjectSourceDiff, createScratchBlocksDiffLocator, createScratchBlocksDiffRenderer, currentCostume, gitHubRepositoryFromOrigin };
+export { ProjectSourceBlockDiff, ProjectSourceComparison, ProjectSourceReview, assetFileName, createGitHubPullRequests, createPreviewSync, createProjectSourceDiff, createScratchBlocksDiffLocator, createScratchBlocksDiffRenderer, currentCostume, gitHubRepositoryFromOrigin, organizeProjectChanges, projectPropertyLabel };

package/dist/project-source-review.d.ts

@@ -32,7 +32,12 @@ export interface ProjectSourceComparisonProps {
     fallback?: React.ReactNode;
     /** Reads the images of both versions for thumbnails. Without it, stages and sprites are shown by name. */
     loadAsset?: ProjectAssetLoader;
+    /** Shows only the code of this stage or sprite, without the overview and the changes outside the code. */
+    target?: {
+        isStage: boolean;
+        name: string;
+    };
 }
 /** Compares two versions of a project.source.json by stage, sprite and code, as the pull request review does. */
-export declare function ProjectSourceComparison({ before, after, renderBlock, locale, fallback, loadAsset }: ProjectSourceComparisonProps): React.JSX.Element;
+export declare function ProjectSourceComparison({ before, after, renderBlock, locale, fallback, loadAsset, target }: ProjectSourceComparisonProps): React.JSX.Element;
 export declare function ProjectSourceReview({ title, description, verification, files, renderBlock, locale }: ProjectSourceReviewProps): React.JSX.Element;

package/dist/{repository-BQkADJmK.js → repository-CtvWYPQ8.js}

@@ -14562,6 +14562,37 @@ async function fetch({ fs, http, onProgress, onMessage, onAuth, onAuthSuccess, o
 	}
 }
 /**
+* Find the merge base for a set of commits
+*
+* @param {object} args
+* @param {FsClient} args.fs - a file system client
+* @param {string} [args.dir] - The [working tree](dir-vs-gitdir.md) directory path
+* @param {string} [args.gitdir=join(dir,'.git')] - [required] The [git directory](dir-vs-gitdir.md) path
+* @param {string[]} args.oids - Which commits
+* @param {object} [args.cache] - a [cache](cache.md) object
+*
+*/
+async function findMergeBase({ fs, dir, gitdir = join(dir, ".git"), oids, cache = {} }) {
+	try {
+		assertParameter("fs", fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("oids", oids);
+		const fsp = new FileSystem(fs);
+		return await _findMergeBase({
+			fs: fsp,
+			cache,
+			gitdir: await discoverGitdir({
+				fsp,
+				dotgit: gitdir
+			}),
+			oids
+		});
+	} catch (err) {
+		err.caller = "git.findMergeBase";
+		throw err;
+	}
+}
+/**
 * Read an entry from the git config files.
 *
 * *Caveats:*
@@ -16795,10 +16826,14 @@ async function runRemoteOperation(root, operation, getSession, guard, signal) {
 }
 // src/repository.ts
 init_objectSpread2();
+var projectSourceLimit = 16777216;
 var emptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var textLimit = 1048576;
 var inScope = (path, scope) => !scope || path === scope || path.startsWith(scope + "/");
 var probeLimit = 5e3;
+/** Most commits read to count how far a branch is ahead of or behind its tracking branch. */
+var upstreamWalkLimit = 1e3;
+var trackingRef = (branchRef) => "refs/remotes/origin/" + branchRef.slice(11);
 var sameMetadata = (a, b) => a.size === b.size && [...a].every(([path, bytes]) => {
 	var _b$get;
 	return sameBytes(bytes, (_b$get = b.get(path)) !== null && _b$get !== void 0 ? _b$get : null);
@@ -16838,7 +16873,7 @@ async function openRepository(root) {
 		if (text.startsWith("ref: refs/heads/")) {
 			const ref = text.slice(5);
 			pathParts(ref);
-			paths.push("/.git/" + ref);
+			paths.push("/.git/" + ref, "/.git/" + trackingRef(ref));
 		} else if (!/^[0-9a-f]{40}$/.test(text)) throw new GitPanelError("invalid");
 		const result = /* @__PURE__ */ new Map();
 		for (const path of paths) {
@@ -16884,7 +16919,7 @@ async function openRepository(root) {
 			} catch (_unused) {
 				return "locked";
 			}
-			paths.push(".git/" + head.slice(5));
+			paths.push(".git/" + head.slice(5), ".git/" + trackingRef(head.slice(5)));
 		}
 		const lines = [];
 		for (const path of paths) {
@@ -16956,6 +16991,86 @@ async function openRepository(root) {
 			mode
 		}]));
 	};
+	/**
+	* Compares `refs/heads/<branch>` with `refs/remotes/origin/<branch>` from local refs only. Counts by painting
+	* commits from both tips in committer-time order until every queued commit is reachable from both, like
+	* `git rev-list --left-right --count`, reading at most `upstreamWalkLimit` commits.
+	*/
+	const upstreamRelation = async (branch, head) => {
+		const unknown = {
+			state: "unknown",
+			ahead: 0,
+			behind: 0
+		};
+		if (!branch || !head) return unknown;
+		pathParts(trackingRef("refs/heads/" + branch));
+		try {
+			const remote = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: trackingRef("refs/heads/" + branch) }));
+			if (remote === head) return {
+				state: "same",
+				ahead: 0,
+				behind: 0
+			};
+			const bases = await findMergeBase(_objectSpread2(_objectSpread2({}, options), {}, {
+				cache,
+				oids: [head, remote]
+			}));
+			const hasAhead = !bases.includes(head), hasBehind = !bases.includes(remote);
+			const local = 1, tracking = 2, both = 3;
+			const flags = /* @__PURE__ */ new Map([[head, local], [remote, tracking]]);
+			const time = async (oid) => (await readCommit(_objectSpread2(_objectSpread2({}, options), {}, {
+				cache,
+				oid
+			}))).commit;
+			const queue = [];
+			const enqueue = async (oid) => {
+				const commit = await time(oid);
+				queue.push({
+					oid,
+					time: commit.committer.timestamp,
+					parents: commit.parent
+				});
+			};
+			await enqueue(head);
+			await enqueue(remote);
+			let read = 2;
+			let complete = true;
+			while (queue.some((item) => flags.get(item.oid) !== both)) {
+				if (read >= 1e3) {
+					complete = false;
+					break;
+				}
+				queue.sort((a, b) => b.time - a.time);
+				const item = queue.shift();
+				const flag = flags.get(item.oid);
+				for (const parent of item.parents) {
+					var _flags$get;
+					const previous = (_flags$get = flags.get(parent)) !== null && _flags$get !== void 0 ? _flags$get : 0;
+					if ((previous | flag) === previous) continue;
+					flags.set(parent, previous | flag);
+					if (!queue.some((entry) => entry.oid === parent)) {
+						await enqueue(parent);
+						read++;
+					}
+				}
+			}
+			let ahead = 0, behind = 0;
+			for (const flag of flags.values()) if (flag === local) ahead++;
+			else if (flag === tracking) behind++;
+			if (!complete) {
+				ahead = hasAhead ? upstreamWalkLimit : 0;
+				behind = hasBehind ? upstreamWalkLimit : 0;
+			}
+			return {
+				state: hasAhead && hasBehind ? "diverged" : hasAhead ? "ahead" : hasBehind ? "behind" : "same",
+				ahead: hasAhead ? Math.max(ahead, 1) : 0,
+				behind: hasBehind ? Math.max(behind, 1) : 0
+			};
+		} catch (error) {
+			if (errorCode(error) === "NotFoundError") return unknown;
+			throw error;
+		}
+	};
 	const assertSnapshot = async (snapshot) => {
 		if (!sameMetadata(snapshot.metadata, await metadata())) throw new GitPanelError("changed");
 	};
@@ -16984,6 +17099,7 @@ async function openRepository(root) {
 			author: commit.author.name,
 			timestamp: commit.author.timestamp
 		})) : [];
+		const upstream = await upstreamRelation(branch || void 0, head);
 		const matrix = await statusMatrix(_objectSpread2(_objectSpread2({}, options), {}, {
 			cache,
 			refresh: false,
@@ -17032,7 +17148,8 @@ async function openRepository(root) {
 			changes,
 			scope,
 			metadata: before,
-			probe: fingerprint
+			probe: fingerprint,
+			upstream
 		};
 	};
 	const historyChanges = async (snapshot, oid) => {
@@ -17170,13 +17287,31 @@ async function openRepository(root) {
 		}));
 		return blob.byteLength <= limit ? blob : null;
 	};
-	const readAsset = async (snapshot, change, version, md5ext, signal) => {
+	const comparisonSource = async (snapshot, comparison, version) => {
+		if (comparison.kind === "worktree") return version === "after" ? { kind: "worktree" } : snapshot.head ? {
+			kind: "tree",
+			ref: snapshot.head
+		} : null;
+		if (version === "after") return {
+			kind: "tree",
+			ref: comparison.commit
+		};
+		const parent = (await readCommit(_objectSpread2(_objectSpread2({}, options), {}, {
+			cache,
+			oid: comparison.commit
+		}))).commit.parent[0];
+		return parent ? {
+			kind: "tree",
+			ref: parent
+		} : null;
+	};
+	const readAsset = (snapshot, change, version, md5ext, signal) => readFolderAsset(snapshot, pathParts(change.path).slice(0, -1), () => sourceOf(snapshot, change, version), md5ext, signal);
+	const readFolderAsset = async (snapshot, folder, resolve, md5ext, signal) => {
 		if (signal.aborted) return null;
 		fs.clearReads();
 		await assertSnapshot(snapshot);
-		const source = await sourceOf(snapshot, change, version);
+		const source = await resolve();
 		if (!source) return null;
-		const folder = pathParts(change.path).slice(0, -1);
 		const settings = await readVersion(source, [...folder, "sb3-source.json"].join("/"), folderSettingsLimit);
 		const directory = assetsDirectoryParts(settings && new TextDecoder().decode(settings));
 		if (!directory || signal.aborted) return null;
@@ -17188,6 +17323,43 @@ async function openRepository(root) {
 		await fs.checkReads();
 		return bytes && !signal.aborted ? new Blob([bytes]) : null;
 	};
+	/** Reads the project file and the assets directory of both versions of a project folder. */
+	const readProject = async (snapshot, folder, comparison) => {
+		fs.clearReads();
+		await assertSnapshot(snapshot);
+		const parts = pathParts(folder);
+		const read = async (version) => {
+			const source = await comparisonSource(snapshot, comparison, version);
+			if (!source) return {
+				source: null,
+				assetsDirectory: "assets"
+			};
+			const bytes = await readVersion(source, [...parts, "project.source.json"].join("/"), projectSourceLimit);
+			const settings = await readVersion(source, [...parts, "sb3-source.json"].join("/"), folderSettingsLimit);
+			const directory = assetsDirectoryParts(settings && new TextDecoder().decode(settings));
+			let text = null;
+			if (bytes) try {
+				text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+			} catch (_unused4) {
+				throw new GitPanelError("unsupported");
+			}
+			return {
+				source: text,
+				assetsDirectory: directory ? directory.join("/") : "assets"
+			};
+		};
+		const before = await read("before"), after = await read("after");
+		await assertSnapshot(snapshot);
+		await fs.checkReads();
+		return {
+			before: before.source,
+			after: after.source,
+			assetsDirectory: {
+				before: before.assetsDirectory,
+				after: after.assetsDirectory
+			}
+		};
+	};
 	const directoryAt = async (path) => {
 		let directory = root;
 		for (const part of pathParts(path)) directory = await directory.getDirectoryHandle(part);
@@ -17274,7 +17446,14 @@ async function openRepository(root) {
 		* commit changes the first parent with the commit. Each version's sb3-source.json names its assets directory.
 		* Reads never write, and resolve `null` for anything missing, invalid, larger than 10 MiB or changed since the snapshot.
 		*/
-		assetLoader: (snapshot, change) => ({ version, md5ext, signal }) => !isAssetName(md5ext) || signal.aborted ? Promise.resolve(null) : serial(() => readAsset(snapshot, change, version, md5ext, signal)).catch(() => null)
+		assetLoader: (snapshot, change) => ({ version, md5ext, signal }) => !isAssetName(md5ext) || signal.aborted ? Promise.resolve(null) : serial(() => readAsset(snapshot, change, version, md5ext, signal)).catch(() => null),
+		/**
+		* Reads the project file of a folder in both versions of a comparison, with each version's assets directory.
+		* `null` stands for a version without the file. Throws `changed` when the repository changed since the snapshot.
+		*/
+		readProject: (snapshot, folder, comparison) => serial(() => readProject(snapshot, folder, comparison)),
+		/** Reads the assets of a folder in both versions of a comparison, like `assetLoader`. */
+		projectAssetLoader: (snapshot, folder, comparison) => ({ version, md5ext, signal }) => !isAssetName(md5ext) || signal.aborted ? Promise.resolve(null) : serial(() => readFolderAsset(snapshot, pathParts(folder), () => comparisonSource(snapshot, comparison, version), md5ext, signal)).catch(() => null)
 	};
 }
-export { GitPanelError as n, createReadOnlyFs as r, openRepository as t };
+export { createReadOnlyFs as i, upstreamWalkLimit as n, GitPanelError as r, openRepository as t };

package/dist/repository.d.ts

@@ -19,6 +19,16 @@ export interface Commit {
     author: string;
     timestamp: number;
 }
+/**
+ * Two versions of a project folder as a person sees them: the last commit and the working tree, so changes split
+ * across the index and the working tree read as one; or one commit and its first parent.
+ */
+export type ProjectComparison = {
+    kind: 'worktree';
+} | {
+    kind: 'commit';
+    commit: string;
+};
 type Metadata = Map<string, Uint8Array | null>;
 export interface Snapshot {
     branch: string | undefined;
@@ -30,6 +40,21 @@ export interface Snapshot {
     metadata: Metadata;
     /** Size and time fingerprint taken before the read. Compare it with `probe(scope)` to see later changes. */
     probe: string;
+    /**
+     * How the current branch stands against `refs/remotes/origin/<branch>` as of the last fetch, from local refs only.
+     * `unknown` when there is no current branch or no tracking ref yet.
+     */
+    upstream: UpstreamRelation;
+}
+export interface UpstreamRelation {
+    state: 'same' | 'ahead' | 'behind' | 'diverged' | 'unknown';
+    /**
+     * Commits on the local branch that the tracking branch lacks, and the reverse. Zero when unknown. Counting reads at
+     * most `upstreamWalkLimit` (1000) commits; past that, a side that has commits of its own reports exactly that limit,
+     * meaning "this many or more". The state itself comes from the merge base and stays exact.
+     */
+    ahead: number;
+    behind: number;
 }
 export interface FileDiff {
     binary: boolean;
@@ -46,6 +71,8 @@ export interface FileDiff {
     afterSize: number;
     tooLarge: boolean;
 }
+/** Most commits read to count how far a branch is ahead of or behind its tracking branch. */
+export declare const upstreamWalkLimit = 1000;
 export declare function openRepository(root: FileSystemDirectoryHandle): Promise<{
     root: FileSystemDirectoryHandle;
     openProject: (path: string) => Promise<FileSystemDirectoryHandle>;
@@ -67,5 +94,19 @@ export declare function openRepository(root: FileSystemDirectoryHandle): Promise
      * Reads never write, and resolve `null` for anything missing, invalid, larger than 10 MiB or changed since the snapshot.
      */
     assetLoader: (snapshot: Snapshot, change: FileChange) => ProjectAssetLoader;
+    /**
+     * Reads the project file of a folder in both versions of a comparison, with each version's assets directory.
+     * `null` stands for a version without the file. Throws `changed` when the repository changed since the snapshot.
+     */
+    readProject: (snapshot: Snapshot, folder: string, comparison: ProjectComparison) => Promise<{
+        before: string | null;
+        after: string | null;
+        assetsDirectory: {
+            before: string;
+            after: string;
+        };
+    }>;
+    /** Reads the assets of a folder in both versions of a comparison, like `assetLoader`. */
+    projectAssetLoader: (snapshot: Snapshot, folder: string, comparison: ProjectComparison) => ProjectAssetLoader;
 }>;
 export type Repository = Awaited<ReturnType<typeof openRepository>>;

package/dist/repository.js

@@ -1 +1 @@
-export { n as GitPanelError, r as createReadOnlyFs, t as openRepository } from "./repository-BQkADJmK.js";
+export { r as GitPanelError, i as createReadOnlyFs, t as openRepository, n as upstreamWalkLimit } from "./repository-CtvWYPQ8.js";