@kubohiroya/turbowarp-plus-editor-git 0.15.0 → 0.16.1

package/dist/{repository-Cx-mxT9l.js → repository-BYno-5f8.js}

@@ -12374,6 +12374,141 @@ async function _resolveFilepath({ fs, cache, gitdir, tree, pathArray, oid, filep
 	throw new NotFoundError(`file or directory found at "${oid}:${filepath}"`);
 }
 /**
+*
+* @typedef {Object} ReadTreeResult - The object returned has the following schema:
+* @property {string} oid - SHA-1 object id of this tree
+* @property {TreeObject} tree - the parsed tree object
+*/
+/**
+* @param {object} args
+* @param {import('../models/FileSystem.js').FileSystem} args.fs
+* @param {any} args.cache
+* @param {string} args.gitdir
+* @param {string} args.oid
+* @param {string} [args.filepath]
+*
+* @returns {Promise<ReadTreeResult>}
+*/
+async function _readTree({ fs, cache, gitdir, oid, filepath = void 0 }) {
+	if (filepath !== void 0) oid = await resolveFilepath({
+		fs,
+		cache,
+		gitdir,
+		oid,
+		filepath
+	});
+	const { tree, oid: treeOid } = await resolveTree({
+		fs,
+		cache,
+		gitdir,
+		oid
+	});
+	return {
+		oid: treeOid,
+		tree: tree.entries()
+	};
+}
+/**
+* Create a branch
+*
+* @param {object} args
+* @param {import('../models/FileSystem.js').FileSystem} args.fs
+* @param {string} args.gitdir
+* @param {string} args.ref
+* @param {string} [args.object = 'HEAD']
+* @param {boolean} [args.checkout = false]
+* @param {boolean} [args.force = false]
+*
+* @returns {Promise<void>} Resolves successfully when filesystem operations are complete
+*
+* @example
+* await git.branch({ dir: '$input((/))', ref: '$input((develop))' })
+* console.log('done')
+*
+*/
+async function _branch({ fs, gitdir, ref, object, checkout = false, force = false }) {
+	if (!isValidRef(ref, true)) throw new InvalidRefNameError(ref, import_lib.default.clean(ref));
+	const fullref = `refs/heads/${ref}`;
+	if (!force) {
+		if (await GitRefManager.exists({
+			fs,
+			gitdir,
+			ref: fullref
+		})) throw new AlreadyExistsError("branch", ref, false);
+	}
+	let oid;
+	try {
+		oid = await GitRefManager.resolve({
+			fs,
+			gitdir,
+			ref: object || "HEAD"
+		});
+	} catch (e) {
+		if (!(e instanceof NotFoundError)) throw e;
+	}
+	if (oid) {
+		oid = (await resolveCommit({
+			fs,
+			cache: {},
+			gitdir,
+			oid
+		})).oid;
+		await GitRefManager.writeRef({
+			fs,
+			gitdir,
+			ref: fullref,
+			value: oid
+		});
+	}
+	if (checkout) await GitRefManager.writeSymbolicRef({
+		fs,
+		gitdir,
+		ref: "HEAD",
+		value: fullref
+	});
+}
+/**
+* Create a branch
+*
+* @param {object} args
+* @param {FsClient} args.fs - a file system implementation
+* @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.ref - What to name the branch
+* @param {string} [args.object = 'HEAD'] - What oid to use as the start point. Accepts a symbolic ref.
+* @param {boolean} [args.checkout = false] - Update `HEAD` to point at the newly created branch
+* @param {boolean} [args.force = false] - Instead of throwing an error if a branched named `ref` already exists, overwrite the existing branch.
+*
+* @returns {Promise<void>} Resolves successfully when filesystem operations are complete
+*
+* @example
+* await git.branch({ fs, dir: '/tutorial', ref: 'develop' })
+* console.log('done')
+*
+*/
+async function branch({ fs, dir, gitdir = join(dir, ".git"), ref, object, checkout = false, force = false }) {
+	try {
+		assertParameter("fs", fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("ref", ref);
+		const fsp = new FileSystem(fs);
+		return await _branch({
+			fs: fsp,
+			gitdir: await discoverGitdir({
+				fsp,
+				dotgit: gitdir
+			}),
+			ref,
+			object,
+			checkout,
+			force
+		});
+	} catch (err) {
+		err.caller = "git.branch";
+		throw err;
+	}
+}
+/**
 * Refuse to materialize a working-tree entry whose parent path traverses a
 * symbolic link. A leading component that is a symlink could otherwise redirect
 * a write or mkdir outside the working tree. git applies the same check: it does
@@ -12867,6 +13002,97 @@ async function batchAllSettled(operationName, tasks, onProgress, batchSize) {
 	if (rejections.length > 0) throw new MultipleGitError(rejections);
 	return results;
 }
+/**
+* Checkout a branch
+*
+* If the branch already exists it will check out that branch. Otherwise, it will create a new remote tracking branch set to track the remote branch of that name.
+*
+* @param {object} args
+* @param {FsClient} args.fs - a file system implementation
+* @param {ProgressCallback} [args.onProgress] - optional progress event callback
+* @param {PostCheckoutCallback} [args.onPostCheckout] - optional post-checkout hook callback
+* @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.ref = 'HEAD'] - Source to checkout files from
+* @param {string[]} [args.filepaths] - Limit the checkout to the given files and directories. If `ref` is not provided, restore them from the index.
+* @param {string} [args.remote = 'origin'] - Which remote repository to use
+* @param {boolean} [args.noCheckout = false] - If true, will update HEAD but won't update the working directory
+* @param {boolean} [args.noUpdateHead] - If true, will update the working directory but won't update HEAD. Defaults to `false` when `ref` is provided, and `true` if `ref` is not provided.
+* @param {boolean} [args.dryRun = false] - If true, simulates a checkout so you can test whether it would succeed.
+* @param {boolean} [args.force = false] - If true, conflicts will be ignored and files will be overwritten regardless of local changes.
+* @param {boolean} [args.track = true] - If false, will not set the remote branch tracking information. Defaults to true.
+* @param {object} [args.cache] - a [cache](cache.md) object
+* @param {boolean} [args.nonBlocking = false] - If true, will use non-blocking file system operations to allow for better performance in certain environments (For example, in Browsers)
+* @param {number} [args.batchSize = 100] - If args.nonBlocking is true, batchSize is the number of files to process at a time avoid blocking the executing thread. The default value of 100 is a good starting point.
+*
+* @returns {Promise<void>} Resolves successfully when filesystem operations are complete
+*
+* @example
+* // switch to the main branch
+* await git.checkout({
+*   fs,
+*   dir: '/tutorial',
+*   ref: 'main'
+* })
+* console.log('done')
+*
+* @example
+* // restore the 'docs' and 'src/docs' folders from the index, overwriting any unstaged changes
+* await git.checkout({
+*   fs,
+*   dir: '/tutorial',
+*   force: true,
+*   filepaths: ['docs', 'src/docs']
+* })
+* console.log('done')
+*
+* @example
+* // restore the 'docs' and 'src/docs' folders to the way they are in the 'develop' branch, overwriting any changes
+* await git.checkout({
+*   fs,
+*   dir: '/tutorial',
+*   ref: 'develop',
+*   noUpdateHead: true,
+*   force: true,
+*   filepaths: ['docs', 'src/docs']
+* })
+* console.log('done')
+*/
+async function checkout({ fs, onProgress, onPostCheckout, dir, gitdir = join(dir, ".git"), remote = "origin", ref: _ref, filepaths, noCheckout = false, noUpdateHead = _ref === void 0, dryRun = false, force = false, track = true, cache = {}, nonBlocking = false, batchSize = 100 }) {
+	try {
+		assertParameter("fs", fs);
+		assertParameter("dir", dir);
+		assertParameter("gitdir", gitdir);
+		const ref = _ref || "HEAD";
+		const restoreFromIndex = _ref === void 0 && filepaths != null && filepaths.length > 0;
+		const fsp = new FileSystem(fs);
+		return await _checkout({
+			fs: fsp,
+			cache,
+			onProgress,
+			onPostCheckout,
+			dir,
+			gitdir: await discoverGitdir({
+				fsp,
+				dotgit: gitdir
+			}),
+			remote,
+			ref,
+			filepaths,
+			noCheckout,
+			noUpdateHead,
+			dryRun,
+			force,
+			track,
+			restoreFromIndex,
+			nonBlocking,
+			batchSize
+		});
+	} catch (err) {
+		err.caller = "git.checkout";
+		throw err;
+	}
+}
 var LINEBREAKS = /^.*(\r?\n|$)/gm;
 function mergeFile({ branches, contents }) {
 	const ourName = branches[1];
@@ -15996,6 +16222,50 @@ async function readCommit({ fs, dir, gitdir = join(dir, ".git"), oid, cache = {}
 	}
 }
 /**
+*
+* @typedef {Object} ReadTreeResult - The object returned has the following schema:
+* @property {string} oid - SHA-1 object id of this tree
+* @property {TreeObject} tree - the parsed tree object
+*/
+/**
+* Read a tree object directly
+*
+* @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.oid - The SHA-1 object id to get. Annotated tags and commits are peeled.
+* @param {string} [args.filepath] - Don't return the object with `oid` itself, but resolve `oid` to a tree and then return the tree object at that filepath.
+* @param {object} [args.cache] - a [cache](cache.md) object
+*
+* @returns {Promise<ReadTreeResult>} Resolves successfully with a git tree object
+* @see ReadTreeResult
+* @see TreeObject
+* @see TreeEntry
+*
+*/
+async function readTree({ fs, dir, gitdir = join(dir, ".git"), oid, filepath = void 0, cache = {} }) {
+	try {
+		assertParameter("fs", fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("oid", oid);
+		const fsp = new FileSystem(fs);
+		return await _readTree({
+			fs: fsp,
+			cache,
+			gitdir: await discoverGitdir({
+				fsp,
+				dotgit: gitdir
+			}),
+			oid,
+			filepath
+		});
+	} catch (err) {
+		err.caller = "git.readTree";
+		throw err;
+	}
+}
+/**
 * Remove a file from the git index (aka staging area)
 *
 * Note that this does NOT delete the file in the working directory.
@@ -17186,7 +17456,8 @@ async function runLocalOperation(root, operation, guard) {
 	var _globalThis$navigator;
 	const execute = async () => {
 		guard();
-		const transaction = createMutationFs(root, false);
+		const switching = operation.kind === "switchBranch" || operation.kind === "createBranch" && operation.checkout;
+		const transaction = createMutationFs(root, switching);
 		const options = {
 			fs: transaction.fs,
 			dir: "/",
@@ -17210,8 +17481,57 @@ async function runLocalOperation(root, operation, guard) {
 			"/.git/REVERT_HEAD",
 			"/.git/rebase-merge",
 			"/.git/rebase-apply"
-		]) if (await exists(path)) throw new GitPanelError("changed");
-		if (operation.kind === "stage") {
+		]) if (await exists(path)) throw new GitPanelError("locked");
+		if (operation.kind === "createBranch" || operation.kind === "switchBranch") {
+			const name = operation.name.trim();
+			const local = `refs/heads/${name}`;
+			if (switching) {
+				if ((await statusMatrix(_objectSpread2(_objectSpread2({}, options), {}, { refresh: false }))).some(([, head, worktree, stage]) => head !== worktree || head !== stage)) throw new GitPanelError("switchUnsafe");
+			}
+			if (operation.kind === "createBranch") {
+				let object;
+				if (operation.at !== void 0) {
+					if (operation.fromRemote || !/^[0-9a-f]{40}$/.test(operation.at)) throw new GitPanelError("invalid");
+					object = await readCommit(_objectSpread2(_objectSpread2({}, options), {}, { oid: operation.at })).then(() => operation.at, () => {
+						throw new GitPanelError("invalid");
+					});
+				} else if (operation.fromRemote) try {
+					object = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: `refs/remotes/origin/${name}` }));
+				} catch (_unused) {
+					throw new GitPanelError("invalid");
+				}
+				else object = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: "HEAD" })).catch(() => {
+					throw new GitPanelError("unsupported");
+				});
+				try {
+					await branch(_objectSpread2(_objectSpread2({}, options), {}, {
+						ref: name,
+						object,
+						checkout: false
+					}));
+				} catch (error) {
+					const code = error === null || error === void 0 ? void 0 : error.code;
+					if (code === "AlreadyExistsError") throw new GitPanelError("branchExists");
+					if (code === "InvalidRefNameError") throw new GitPanelError("branchName");
+					throw error;
+				}
+			} else if (!(await listBranches(options)).includes(name)) throw new GitPanelError("invalid");
+			if (switching) {
+				const commit = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: local }));
+				await walk(_objectSpread2(_objectSpread2({}, options), {}, {
+					trees: [TREE({ ref: commit })],
+					map: async (path, [entry]) => {
+						if (!entry || path === ".") return true;
+						const type = await entry.type();
+						if (type === "tree") return true;
+						if (type !== "blob" || await entry.mode() !== 33188) throw new GitPanelError("unsupported");
+						return true;
+					}
+				}));
+				await checkout(_objectSpread2(_objectSpread2({}, options), {}, { ref: name }));
+				if (await currentBranch(options) !== name) throw new GitPanelError("changed");
+			}
+		} else if (operation.kind === "stage") {
 			const modes = /* @__PURE__ */ new Map();
 			await walk(_objectSpread2(_objectSpread2({}, options), {}, {
 				trees: [STAGE()],
@@ -17259,6 +17579,8 @@ async function runLocalOperation(root, operation, guard) {
 }
 // src/repository.ts
 init_objectSpread2();
+/** Commits read per history page unless asked otherwise. */
+var historyPageSize = 50;
 var projectSourceLimit = 16777216;
 var emptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var textLimit = 1048576;
@@ -17522,6 +17844,7 @@ async function openRepository(root) {
 		}
 		const branch = await currentBranch(options);
 		const branches = await listBranches(options);
+		const remoteBranches = (await listBranches(_objectSpread2(_objectSpread2({}, options), {}, { remote: "origin" }))).filter((name) => name !== "HEAD" && !branches.includes(name)).sort();
 		const commits = head ? (await log(_objectSpread2(_objectSpread2({}, options), {}, {
 			cache,
 			ref: head,
@@ -17577,6 +17900,7 @@ async function openRepository(root) {
 			branch: branch || void 0,
 			head,
 			branches,
+			remoteBranches,
 			commits,
 			changes,
 			scope,
@@ -17585,6 +17909,147 @@ async function openRepository(root) {
 			upstream
 		};
 	};
+	const walks = /* @__PURE__ */ new WeakMap();
+	/**
+	* Reads commits reachable from the local branches, `origin/*` and HEAD, newest committer time first, like
+	* `git log --all --date-order` limited to those refs. A commit is listed only after every child read so far, and
+	* only once no commit still to be read is newer, keeping a page's worth read ahead, so a child stays above its
+	* parents unless committer times run backwards by more than that.
+	*/
+	const history = async ({ limit = 50, after } = {}) => {
+		fs.clearReads();
+		if (!(limit >= 1)) limit = 50;
+		let walk = after ? walks.get(after) : void 0;
+		if (after && !walk) throw new GitPanelError("changed");
+		if (after) walks.delete(after);
+		const readNode = async (oid) => {
+			try {
+				const { commit } = await readCommit(_objectSpread2(_objectSpread2({}, options), {}, {
+					cache,
+					oid
+				}));
+				return {
+					commit: {
+						oid,
+						parents: commit.parent,
+						message: commit.message.split("\n")[0],
+						author: commit.author.name,
+						timestamp: commit.author.timestamp,
+						refs: []
+					},
+					time: commit.committer.timestamp,
+					children: 0,
+					expanded: false
+				};
+			} catch (error) {
+				if (errorCode(error) === "NotFoundError") return null;
+				throw error;
+			}
+		};
+		if (!walk) {
+			walk = {
+				nodes: /* @__PURE__ */ new Map(),
+				pending: /* @__PURE__ */ new Set(),
+				frontier: /* @__PURE__ */ new Set()
+			};
+			const tips = [];
+			const branch = await currentBranch(options);
+			for (const name of (await listBranches(options)).sort()) tips.push({
+				ref: `refs/heads/${name}`,
+				label: {
+					kind: "branch",
+					name,
+					current: name === branch
+				}
+			});
+			for (const name of (await listBranches(_objectSpread2(_objectSpread2({}, options), {}, { remote: "origin" }))).sort()) if (name !== "HEAD") tips.push({
+				ref: `refs/remotes/origin/${name}`,
+				label: {
+					kind: "remote",
+					name: `origin/${name}`,
+					current: false
+				}
+			});
+			if (!branch) tips.push({
+				ref: "HEAD",
+				label: {
+					kind: "head",
+					name: "HEAD",
+					current: true
+				}
+			});
+			for (const { ref, label } of tips) {
+				let oid;
+				try {
+					oid = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref }));
+				} catch (error) {
+					if (errorCode(error) === "NotFoundError") continue;
+					throw error;
+				}
+				let node = walk.nodes.get(oid);
+				if (!node) {
+					const read = await readNode(oid);
+					if (!read) continue;
+					node = read;
+					walk.nodes.set(oid, node);
+					walk.pending.add(node);
+					walk.frontier.add(node);
+				}
+				node.commit.refs.push(label);
+			}
+		}
+		const { nodes, pending, frontier } = walk;
+		const expand = async (node) => {
+			frontier.delete(node);
+			node.expanded = true;
+			for (const parent of new Set(node.commit.parents)) {
+				let next = nodes.get(parent);
+				if (!next) {
+					const read = await readNode(parent);
+					if (!read) continue;
+					next = read;
+					nodes.set(parent, next);
+					pending.add(next);
+					frontier.add(next);
+				}
+				if (pending.has(node) && pending.has(next)) next.children++;
+			}
+		};
+		const newer = (a, b) => a.time !== b.time ? a.time > b.time : a.commit.oid > b.commit.oid;
+		const pick = (items, accept) => {
+			let best = null;
+			for (const node of items) if (accept(node) && (!best || newer(node, best))) best = node;
+			return best;
+		};
+		const commits = [];
+		while (commits.length < limit) {
+			let ready = pick(pending, (node) => node.children === 0);
+			let latest = pick(frontier, () => true);
+			while (latest && (!ready || !ready.expanded || latest.time >= ready.time || pending.size < limit * 2)) {
+				await expand(latest);
+				ready = pick(pending, (node) => node.children === 0);
+				latest = pick(frontier, () => true);
+			}
+			if (!ready) break;
+			pending.delete(ready);
+			for (const parent of new Set(ready.commit.parents)) {
+				const node = nodes.get(parent);
+				if (node && pending.has(node) && ready.expanded) node.children--;
+			}
+			commits.push(ready.commit);
+		}
+		await fs.checkReads();
+		if (!pending.size) return {
+			commits,
+			cursor: null
+		};
+		const cursor = Object.freeze({ continues: "history" });
+		walks.set(cursor, walk);
+		return {
+			commits,
+			cursor
+		};
+	};
 	const historyChanges = async (snapshot, oid) => {
 		fs.clearReads();
 		await assertSnapshot(snapshot);
@@ -17872,10 +18337,32 @@ async function openRepository(root) {
 		}),
 		/** Stages, unstages or commits; see `runLocalOperation`. `guard` throws to stop before each write. */
 		localOperation: (operation, guard) => serial(() => runLocalOperation(root, operation, guard)),
+		/**
+		* Whether a local branch, `origin/<name>` with `remote`, or the commit `name` with `remote` set to `'commit'`,
+		* has the folder `path` (the root always exists).
+		*/
+		hasFolder: (name, path, remote = false) => serial(async () => {
+			const ref = remote === "commit" ? name : remote ? `refs/remotes/origin/${name}` : `refs/heads/${name}`;
+			if (!path) return true;
+			try {
+				const { tree } = await readTree(_objectSpread2(_objectSpread2({}, options), {}, {
+					oid: await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref })),
+					filepath: path
+				}));
+				return tree.length > 0;
+			} catch (_unused5) {
+				return false;
+			}
+		}),
 		read: (scope) => serial(() => read(scope)),
 		readDiff: (snapshot, change) => serial(() => readDiff(snapshot, change)),
 		historyChanges: (snapshot, oid) => serial(() => historyChanges(snapshot, oid)),
 		/**
+		* Reads one page of the commits reachable from the local branches, `origin/*` and a detached HEAD, newest first
+		* with each child above its parents, and the refs at each. Pass the returned `cursor` as `after` for the next page.
+		*/
+		history: (options) => serial(() => history(options)),
+		/**
 		* Reads the assets of both versions of a selected project file, for thumbnails. Staged changes compare HEAD with
 		* the index, unstaged ones the index with the working tree, untracked ones nothing with the working tree, and
 		* commit changes the first parent with the commit. Each version's sb3-source.json names its assets directory.
@@ -17891,4 +18378,4 @@ async function openRepository(root) {
 		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 { createReadOnlyFs as i, upstreamWalkLimit as n, GitPanelError as r, openRepository as t };
+export { createReadOnlyFs as a, GitPanelError as i, openRepository as n, upstreamWalkLimit as r, historyPageSize as t };

package/dist/repository.d.ts

@@ -30,11 +30,42 @@ export type ProjectComparison = {
     kind: 'commit';
     commit: string;
 };
+/** A ref drawn next to a commit in the history: a local branch, `origin/<name>`, or HEAD when it is detached. */
+export interface HistoryRef {
+    kind: 'branch' | 'remote' | 'head';
+    /** The branch name; `origin/<name>` for remote branches; `HEAD` for a detached HEAD. */
+    name: string;
+    /** The branch HEAD is on, or the detached HEAD. */
+    current: boolean;
+}
+export interface HistoryCommit {
+    oid: string;
+    parents: string[];
+    /** The first line of the message. */
+    message: string;
+    author: string;
+    /** Author time in seconds. */
+    timestamp: number;
+    refs: HistoryRef[];
+}
+/** Where `history` continues. It only works with the repository that returned it. */
+export type HistoryCursor = {
+    readonly continues: 'history';
+};
+export interface HistoryPage {
+    commits: HistoryCommit[];
+    /** Pass as `after` to read the next page; `null` when every commit has been read. */
+    cursor: HistoryCursor | null;
+}
+/** Commits read per history page unless asked otherwise. */
+export declare const historyPageSize = 50;
 type Metadata = Map<string, Uint8Array | null>;
 export interface Snapshot {
     branch: string | undefined;
     head: string | null;
     branches: string[];
+    /** Branches fetched from `origin` that have no local branch of the same name yet. */
+    remoteBranches: string[];
     commits: Commit[];
     changes: FileChange[];
     scope: string;
@@ -87,9 +118,22 @@ export declare function openRepository(root: FileSystemDirectoryHandle): Promise
     remoteOperation: (operation: RemoteOperation, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal) => Promise<void>;
     /** Stages, unstages or commits; see `runLocalOperation`. `guard` throws to stop before each write. */
     localOperation: (operation: LocalOperation, guard: () => void) => Promise<void>;
+    /**
+     * Whether a local branch, `origin/<name>` with `remote`, or the commit `name` with `remote` set to `'commit'`,
+     * has the folder `path` (the root always exists).
+     */
+    hasFolder: (name: string, path: string, remote?: boolean | "commit") => Promise<boolean>;
     read: (scope?: string) => Promise<Snapshot>;
     readDiff: (snapshot: Snapshot, change: FileChange) => Promise<FileDiff>;
     historyChanges: (snapshot: Snapshot, oid: string) => Promise<FileChange[]>;
+    /**
+     * Reads one page of the commits reachable from the local branches, `origin/*` and a detached HEAD, newest first
+     * with each child above its parents, and the refs at each. Pass the returned `cursor` as `after` for the next page.
+     */
+    history: (options?: {
+        limit?: number;
+        after?: HistoryCursor | null;
+    }) => Promise<HistoryPage>;
     /**
      * Reads the assets of both versions of a selected project file, for thumbnails. Staged changes compare HEAD with
      * the index, unstaged ones the index with the working tree, untracked ones nothing with the working tree, and

package/dist/repository.js

@@ -1 +1 @@
-export { r as GitPanelError, i as createReadOnlyFs, t as openRepository, n as upstreamWalkLimit } from "./repository-Cx-mxT9l.js";
+export { i as GitPanelError, a as createReadOnlyFs, t as historyPageSize, n as openRepository, r as upstreamWalkLimit } from "./repository-BYno-5f8.js";