@kubohiroya/turbowarp-plus-editor-git 0.14.1 → 0.16.0

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

@@ -11822,6 +11822,132 @@ async function _writeObject({ fs, gitdir, type, object, format = "content", oid
 	});
 	return oid;
 }
+function posixifyPathBuffer(buffer) {
+	let idx;
+	while (~(idx = buffer.indexOf(92))) buffer[idx] = 47;
+	return buffer;
+}
+/**
+* Add a file to the git index (aka staging area)
+*
+* @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|string[]} args.filepath - The path to the file to add to the index
+* @param {object} [args.cache] - a [cache](cache.md) object
+* @param {boolean} [args.force=false] - add to index even if matches gitignore. Think `git add --force`
+* @param {boolean} [args.parallel=false] - process each input file in parallel. Parallel processing will result in more memory consumption but less process time
+*
+* @returns {Promise<void>} Resolves successfully once the git index has been updated
+*
+* @example
+* await fs.promises.writeFile('/tutorial/README.md', `# TEST`)
+* await git.add({ fs, dir: '/tutorial', filepath: 'README.md' })
+* console.log('done')
+*
+*/
+async function add({ fs: _fs, dir, gitdir = join(dir, ".git"), filepath, cache = {}, force = false, parallel = true }) {
+	try {
+		assertParameter("fs", _fs);
+		assertParameter("dir", dir);
+		assertParameter("gitdir", gitdir);
+		assertParameter("filepath", filepath);
+		const fs = new FileSystem(_fs);
+		const updatedGitdir = await discoverGitdir({
+			fsp: fs,
+			dotgit: gitdir
+		});
+		await GitIndexManager.acquire({
+			fs,
+			gitdir: updatedGitdir,
+			cache
+		}, async (index) => {
+			const autocrlf = await (await GitConfigManager.get({
+				fs,
+				gitdir: updatedGitdir
+			})).get("core.autocrlf");
+			return addToIndex({
+				dir,
+				gitdir: updatedGitdir,
+				fs,
+				filepath,
+				index,
+				force,
+				parallel,
+				autocrlf
+			});
+		});
+	} catch (err) {
+		err.caller = "git.add";
+		throw err;
+	}
+}
+function isTracked(index, filepath) {
+	if (index.has({ filepath })) return true;
+	const prefix = `${filepath}/`;
+	for (const entry of index.entriesMap.keys()) if (entry.startsWith(prefix)) return true;
+	return false;
+}
+async function addToIndex({ dir, gitdir, fs, filepath, index, force, parallel, autocrlf }) {
+	filepath = Array.isArray(filepath) ? filepath : [filepath];
+	const promises = filepath.map(async (currentFilepath) => {
+		if (!force && !isTracked(index, currentFilepath)) {
+			if (await GitIgnoreManager.isIgnored({
+				fs,
+				dir,
+				gitdir,
+				filepath: currentFilepath
+			})) return;
+		}
+		const stats = await fs.lstat(join(dir, currentFilepath));
+		if (!stats) throw new NotFoundError(currentFilepath);
+		if (stats.isDirectory()) {
+			const children = await fs.readdir(join(dir, currentFilepath));
+			if (parallel) {
+				const promises = children.map((child) => addToIndex({
+					dir,
+					gitdir,
+					fs,
+					filepath: [join(currentFilepath, child)],
+					index,
+					force,
+					parallel,
+					autocrlf
+				}));
+				await Promise.all(promises);
+			} else for (const child of children) await addToIndex({
+				dir,
+				gitdir,
+				fs,
+				filepath: [join(currentFilepath, child)],
+				index,
+				force,
+				parallel,
+				autocrlf
+			});
+		} else {
+			const object = stats.isSymbolicLink() ? await fs.readlink(join(dir, currentFilepath)).then(posixifyPathBuffer) : await fs.read(join(dir, currentFilepath), { autocrlf });
+			if (object === null) throw new NotFoundError(currentFilepath);
+			const oid = await _writeObject({
+				fs,
+				gitdir,
+				type: "blob",
+				object
+			});
+			index.insert({
+				filepath: currentFilepath,
+				stats,
+				oid
+			});
+		}
+	});
+	const settledPromises = await Promise.allSettled(promises);
+	const rejectedPromises = settledPromises.filter((settle) => settle.status === "rejected").map((settle) => settle.reason);
+	if (rejectedPromises.length > 1) throw new MultipleGitError(rejectedPromises);
+	if (rejectedPromises.length === 1) throw rejectedPromises[0];
+	return settledPromises.filter((settle) => settle.status === "fulfilled" && settle.value).map((settle) => settle.value);
+}
 async function hasObjectLoose({ fs, gitdir, oid }) {
 	const source = `objects/${oid.slice(0, 2)}/${oid.slice(2)}`;
 	return fs.exists(`${gitdir}/${source}`);
@@ -12248,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
@@ -12741,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];
@@ -14037,6 +14389,81 @@ async function _fetch({ fs, cache, http, onProgress, onMessage, onAuth, onAuthSu
 	return res;
 }
 /**
+* Create a new commit
+*
+* @param {Object} args
+* @param {FsClient} args.fs - a file system implementation
+* @param {SignCallback} [args.onSign] - a PGP signing 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.message] - The commit message to use. Required, unless `amend === true`
+* @param {Object} [args.author] - The details about the author.
+* @param {string} [args.author.name] - Default is `user.name` config.
+* @param {string} [args.author.email] - Default is `user.email` config.
+* @param {number} [args.author.timestamp=Math.floor(Date.now()/1000)] - Set the author timestamp field. This is the integer number of seconds since the Unix epoch (1970-01-01 00:00:00).
+* @param {number} [args.author.timezoneOffset] - Set the author timezone offset field. This is the difference, in minutes, from the current timezone to UTC. Default is `(new Date()).getTimezoneOffset()`.
+* @param {Object} [args.committer = author] - The details about the commit committer, in the same format as the author parameter. If not specified, the author details are used.
+* @param {string} [args.committer.name] - Default is `user.name` config.
+* @param {string} [args.committer.email] - Default is `user.email` config.
+* @param {number} [args.committer.timestamp=Math.floor(Date.now()/1000)] - Set the committer timestamp field. This is the integer number of seconds since the Unix epoch (1970-01-01 00:00:00).
+* @param {number} [args.committer.timezoneOffset] - Set the committer timezone offset field. This is the difference, in minutes, from the current timezone to UTC. Default is `(new Date()).getTimezoneOffset()`.
+* @param {string} [args.signingKey] - Sign the tag object using this private PGP key.
+* @param {boolean} [args.amend = false] - If true, replaces the last commit pointed to by `ref` with a new commit.
+* @param {boolean} [args.dryRun = false] - If true, simulates making a commit so you can test whether it would succeed. Implies `noUpdateBranch`.
+* @param {boolean} [args.noUpdateBranch = false] - If true, does not update the branch pointer after creating the commit.
+* @param {boolean} [args.disallowEmpty = false] - If true, throws an error instead of creating a commit with no staged changes.
+* @param {string} [args.ref] - The fully expanded name of the branch to commit to. Default is the current branch pointed to by HEAD. (TODO: fix it so it can expand branch names without throwing if the branch doesn't exist yet.)
+* @param {string[]} [args.parent] - The SHA-1 object ids of the commits to use as parents. If not specified, the commit pointed to by `ref` is used.
+* @param {string} [args.tree] - The SHA-1 object id of the tree to use. If not specified, a new tree object is created from the current git index.
+* @param {object} [args.cache] - a [cache](cache.md) object
+*
+* @returns {Promise<string>} Resolves successfully with the SHA-1 object id of the newly created commit.
+*
+* @example
+* let sha = await git.commit({
+*   fs,
+*   dir: '/tutorial',
+*   author: {
+*     name: 'Mr. Test',
+*     email: 'mrtest@example.com',
+*   },
+*   message: 'Added the a.txt file'
+* })
+* console.log(sha)
+*
+*/
+async function commit({ fs: _fs, onSign, dir, gitdir = join(dir, ".git"), message, author, committer, signingKey, amend = false, dryRun = false, noUpdateBranch = false, disallowEmpty = false, ref, parent, tree, cache = {} }) {
+	try {
+		assertParameter("fs", _fs);
+		if (!amend) assertParameter("message", message);
+		if (signingKey) assertParameter("onSign", onSign);
+		const fs = new FileSystem(_fs);
+		return await _commit({
+			fs,
+			cache,
+			onSign,
+			gitdir: await discoverGitdir({
+				fsp: fs,
+				dotgit: gitdir
+			}),
+			message,
+			author,
+			committer,
+			signingKey,
+			amend,
+			dryRun,
+			noUpdateBranch,
+			disallowEmpty,
+			ref,
+			parent,
+			tree
+		});
+	} catch (err) {
+		err.caller = "git.commit";
+		throw err;
+	}
+}
+/**
 * Get the name of the branch currently pointed to by .git/HEAD
 *
 * @param {Object} args
@@ -15795,6 +16222,192 @@ 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.
+*
+* @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|string[]} args.filepath - The path to the file to remove from the index, or an array of paths
+* @param {object} [args.cache] - a [cache](cache.md) object
+*
+* @returns {Promise<void>} Resolves successfully once the git index has been updated
+*
+* @example
+* await git.remove({ fs, dir: '/tutorial', filepath: 'README.md' })
+* console.log('done')
+*
+* @example
+* // remove several files from the index with a single write of the index
+* await git.remove({ fs, dir: '/tutorial', filepath: ['README.md', 'docs/old.md'] })
+* console.log('done')
+*
+*/
+async function remove({ fs: _fs, dir, gitdir = join(dir, ".git"), filepath, cache = {} }) {
+	try {
+		assertParameter("fs", _fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("filepath", filepath);
+		const fsp = new FileSystem(_fs);
+		const updatedGitdir = await discoverGitdir({
+			fsp,
+			dotgit: gitdir
+		});
+		await GitIndexManager.acquire({
+			fs: fsp,
+			gitdir: updatedGitdir,
+			cache
+		}, async function(index) {
+			const filepaths = Array.isArray(filepath) ? filepath : [filepath];
+			for (const currentFilepath of filepaths) index.delete({ filepath: currentFilepath });
+		});
+	} catch (err) {
+		err.caller = "git.remove";
+		throw err;
+	}
+}
+async function hashObject$1({ gitdir, type, object }) {
+	return shasum(GitObject.wrap({
+		type,
+		object
+	}));
+}
+/**
+* Reset a file in the git index (aka staging area)
+*
+* Note that this does NOT modify the file in the working directory.
+*
+* @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.filepath - The path to the file to reset in the index
+* @param {string} [args.ref = 'HEAD'] - A ref to the commit to use
+* @param {object} [args.cache] - a [cache](cache.md) object
+*
+* @returns {Promise<void>} Resolves successfully once the git index has been updated
+*
+* @example
+* await git.resetIndex({ fs, dir: '/tutorial', filepath: 'README.md' })
+* console.log('done')
+*
+*/
+async function resetIndex({ fs: _fs, dir, gitdir = join(dir, ".git"), filepath, ref, cache = {} }) {
+	try {
+		assertParameter("fs", _fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("filepath", filepath);
+		const fs = new FileSystem(_fs);
+		const updatedGitdir = await discoverGitdir({
+			fsp: fs,
+			dotgit: gitdir
+		});
+		let oid;
+		let workdirOid;
+		try {
+			oid = await GitRefManager.resolve({
+				fs,
+				gitdir: updatedGitdir,
+				ref: ref || "HEAD"
+			});
+		} catch (e) {
+			if (ref || !(e instanceof NotFoundError)) throw e;
+		}
+		if (oid) try {
+			oid = await resolveFilepath({
+				fs,
+				cache,
+				gitdir: updatedGitdir,
+				oid,
+				filepath
+			});
+		} catch (e) {
+			if (!(e instanceof NotFoundError) && !(e instanceof InvalidFilepathError) && !(e instanceof ObjectTypeError && e.data.filepath)) throw e;
+			oid = null;
+		}
+		let stats = {
+			ctime: /* @__PURE__ */ new Date(0),
+			mtime: /* @__PURE__ */ new Date(0),
+			dev: 0,
+			ino: 0,
+			mode: 0,
+			uid: 0,
+			gid: 0,
+			size: 0
+		};
+		const object = dir && await fs.read(join(dir, filepath));
+		if (object) {
+			workdirOid = await hashObject$1({
+				gitdir: updatedGitdir,
+				type: "blob",
+				object
+			});
+			if (oid === workdirOid) stats = await fs.lstat(join(dir, filepath));
+		}
+		await GitIndexManager.acquire({
+			fs,
+			gitdir: updatedGitdir,
+			cache
+		}, async function(index) {
+			index.delete({ filepath });
+			if (oid) index.insert({
+				filepath,
+				stats,
+				oid
+			});
+		});
+	} catch (err) {
+		err.caller = "git.reset";
+		throw err;
+	}
+}
+/**
 * Get the value of a symbolic ref or resolve a ref to its SHA-1 object id
 *
 * @param {object} args
@@ -16494,7 +17107,7 @@ async function readOptional(fs, path) {
 }
 var sameBytes = (left, right) => left === right || Boolean(left && right && left.length === right.length && left.every((byte, i) => byte === right[i]));
 // src/mutation-fs.ts
-var missing = (error) => {
+var missing$1 = (error) => {
 	var _errorCode;
 	return ["ENOENT", "ENOTDIR"].includes((_errorCode = errorCode(error)) !== null && _errorCode !== void 0 ? _errorCode : "");
 };
@@ -16538,7 +17151,7 @@ function createMutationFs(root, worktree) {
 				time: stat.mtimeMs
 			};
 		} catch (error) {
-			if (missing(error)) return null;
+			if (missing$1(error)) return null;
 			throw error;
 		}
 	}
@@ -16549,7 +17162,7 @@ function createMutationFs(root, worktree) {
 		try {
 			return (await base.promises.stat(path)).isDirectory() ? "directory" : "file";
 		} catch (error) {
-			if (!missing(error)) throw error;
+			if (!missing$1(error)) throw error;
 		}
 	}
 	async function stage(path, after) {
@@ -16570,7 +17183,7 @@ function createMutationFs(root, worktree) {
 		try {
 			for (const entry of await base.promises.readdir(path)) names.add(entry);
 		} catch (error) {
-			if (!missing(error)) throw error;
+			if (!missing$1(error)) throw error;
 		}
 		for (const change of changes.values()) {
 			if (parent(change.path) !== path) continue;
@@ -16824,8 +17437,150 @@ async function runRemoteOperation(root, operation, getSession, guard, signal) {
 	};
 	return ((_globalThis$navigator = globalThis.navigator) === null || _globalThis$navigator === void 0 ? void 0 : _globalThis$navigator.locks) ? navigator.locks.request("tw-plus-git-mutation", execute) : execute();
 }
+// src/local-operations.ts
+init_objectSpread2();
+var missing = (error) => {
+	var _errorCode;
+	return [
+		"ENOENT",
+		"ENOTDIR",
+		"NotFoundError"
+	].includes((_errorCode = errorCode(error)) !== null && _errorCode !== void 0 ? _errorCode : "");
+};
+/**
+* Stages, unstages or commits in the granted repository. Like pull, Git's writes are collected first and applied
+* after the files they replace are checked again; a failure part way puts back what was applied. Only `.git/index`,
+* objects and the current branch ref are written. The work tree and `.git/config` are never written.
+*/
+async function runLocalOperation(root, operation, guard) {
+	var _globalThis$navigator;
+	const execute = async () => {
+		guard();
+		const switching = operation.kind === "switchBranch" || operation.kind === "createBranch" && operation.checkout;
+		const transaction = createMutationFs(root, switching);
+		const options = {
+			fs: transaction.fs,
+			dir: "/",
+			gitdir: "/.git",
+			cache: {}
+		};
+		const read = createReadOnlyFs(root).promises;
+		const exists = async (path) => {
+			try {
+				await read.stat(path);
+				return true;
+			} catch (error) {
+				if (missing(error)) return false;
+				throw error;
+			}
+		};
+		for (const path of [
+			"/.git/index.lock",
+			"/.git/MERGE_HEAD",
+			"/.git/CHERRY_PICK_HEAD",
+			"/.git/REVERT_HEAD",
+			"/.git/rebase-merge",
+			"/.git/rebase-apply"
+		]) 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()],
+				map: async (path, [entry]) => {
+					if (entry && path !== "." && await entry.type() === "blob") modes.set(path, await entry.mode());
+					return true;
+				}
+			}));
+			for (const path of operation.paths) {
+				pathParts(path);
+				const mode = modes.get(path);
+				if (mode !== void 0 && mode !== 33188) throw new GitPanelError("unsupported");
+				if (await exists("/" + path)) await add(_objectSpread2(_objectSpread2({}, options), {}, { filepath: path }));
+				else await remove(_objectSpread2(_objectSpread2({}, options), {}, { filepath: path }));
+			}
+		} else if (operation.kind === "unstage") for (const path of operation.paths) {
+			pathParts(path);
+			await resetIndex(_objectSpread2(_objectSpread2({}, options), {}, { filepath: path }));
+		}
+		else {
+			var _await$configured, _operation$author, _await$configured2, _operation$author2;
+			const message = operation.message.trim();
+			if (!message) throw new GitPanelError("commitMessage");
+			if (!await currentBranch(options)) throw new GitPanelError("unsupported");
+			const configured = async (path) => {
+				const value = await getConfig(_objectSpread2(_objectSpread2({}, options), {}, { path }));
+				return typeof value === "string" && value.trim() ? value : void 0;
+			};
+			const name = (_await$configured = await configured("user.name")) !== null && _await$configured !== void 0 ? _await$configured : (_operation$author = operation.author) === null || _operation$author === void 0 || (_operation$author = _operation$author.name) === null || _operation$author === void 0 ? void 0 : _operation$author.trim();
+			const email = (_await$configured2 = await configured("user.email")) !== null && _await$configured2 !== void 0 ? _await$configured2 : (_operation$author2 = operation.author) === null || _operation$author2 === void 0 || (_operation$author2 = _operation$author2.email) === null || _operation$author2 === void 0 ? void 0 : _operation$author2.trim();
+			if (!name || !email) throw new GitPanelError("author");
+			if (!(await statusMatrix(_objectSpread2(_objectSpread2({}, options), {}, { refresh: false }))).some(([, head, , stage]) => head !== stage)) throw new GitPanelError("nothingStaged");
+			await commit(_objectSpread2(_objectSpread2({}, options), {}, {
+				message: message + "\n",
+				author: {
+					name,
+					email
+				}
+			}));
+		}
+		guard();
+		await transaction.commit(guard);
+	};
+	return ((_globalThis$navigator = globalThis.navigator) === null || _globalThis$navigator === void 0 ? void 0 : _globalThis$navigator.locks) ? navigator.locks.request("tw-plus-git-mutation", execute) : execute();
+}
 // 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;
@@ -17089,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,
@@ -17144,6 +17900,7 @@ async function openRepository(root) {
 			branch: branch || void 0,
 			head,
 			branches,
+			remoteBranches,
 			commits,
 			changes,
 			scope,
@@ -17152,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);
@@ -17437,10 +18335,34 @@ async function openRepository(root) {
 				throw error;
 			}
 		}),
+		/** 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.
@@ -17456,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 };