git-fs-s3 0.15.2 → 0.16.0

package/dist/semaphore-CPjn7Iqh.js

@@ -0,0 +1,686 @@
+import { A as GitRefNotFoundError, B as fromHex, C as GitConflictError, D as GitPathNotFoundError, E as GitObjectNotFoundError, F as concat, G as sha1, N as isAbsentError, R as deflate, T as GitInvalidRequestError, m as rawFs, n as isSafeBranchName, q as toHex, s as qualifyBranchRef, v as packFileName, z as encodeUtf8 } from "./refs-Cb_NfKWI.js";
+import git from "isomorphic-git";
+//#region src/ops/tree.ts
+const joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
+/** File modes a blob entry can carry; anything else isn't a regular file. */
+const BLOB_MODES = /* @__PURE__ */ new Set([
+	"100644",
+	"100755",
+	"120000"
+]);
+/**
+* Build/update a git tree by overlaying new blobs onto an existing tree,
+* returning the new root tree oid. `entries` maps relative paths to blob oids.
+*
+* An updated file keeps its existing mode (executable bit, symlink); a path
+* that names an existing directory, or runs through an existing file, is
+* rejected rather than silently replacing what's there.
+*/
+async function upsertTree(repo, treeOid, entries) {
+	const existing = treeOid ? (await git.readTree({
+		...repo,
+		oid: treeOid
+	})).tree : [];
+	const byName = new Map(existing.map((e) => [e.path, e]));
+	const direct = /* @__PURE__ */ new Map();
+	const nested = /* @__PURE__ */ new Map();
+	for (const [filePath, blobOid] of entries) {
+		const slash = filePath.indexOf("/");
+		if (slash === -1) direct.set(filePath, blobOid);
+		else {
+			const dir = filePath.slice(0, slash);
+			const rest = filePath.slice(slash + 1);
+			if (!nested.has(dir)) nested.set(dir, /* @__PURE__ */ new Map());
+			nested.get(dir)?.set(rest, blobOid);
+		}
+	}
+	for (const [name, blobOid] of direct) {
+		const current = byName.get(name);
+		if (current && current.type !== "blob") throw new GitInvalidRequestError(`"${name}" is a directory, not a file`);
+		byName.set(name, {
+			mode: current && BLOB_MODES.has(current.mode) ? current.mode : "100644",
+			path: name,
+			oid: blobOid,
+			type: "blob"
+		});
+	}
+	const nestedResults = await Promise.all(Array.from(nested, async ([dir, subEntries]) => {
+		const entry = byName.get(dir);
+		if (entry && entry.type !== "tree") throw new GitInvalidRequestError(`"${dir}" is a file, not a directory`);
+		const subtreeOid = entry?.oid;
+		return [dir, await upsertTree(repo, subtreeOid, subEntries)];
+	}));
+	for (const [dir, newOid] of nestedResults) byName.set(dir, {
+		mode: "040000",
+		path: dir,
+		oid: newOid,
+		type: "tree"
+	});
+	return git.writeTree({
+		...repo,
+		tree: Array.from(byName.values())
+	});
+}
+/**
+* Remove a file path from a tree, returning the new root tree oid. Throws
+* GitPathNotFoundError when there's no such file; directories left empty
+* are dropped, as git never stores an empty subtree.
+*/
+async function deleteFromTree(repo, treeOid, filePath) {
+	return await deleteFromSubtree(repo, treeOid, filePath, filePath) ?? git.writeTree({
+		...repo,
+		tree: []
+	});
+}
+/** The new subtree oid, or null when removing the file left it empty. */
+async function deleteFromSubtree(repo, treeOid, filePath, fullPath) {
+	const existing = (await git.readTree({
+		...repo,
+		oid: treeOid
+	})).tree;
+	const byName = new Map(existing.map((e) => [e.path, e]));
+	const slash = filePath.indexOf("/");
+	const name = slash === -1 ? filePath : filePath.slice(0, slash);
+	const entry = byName.get(name);
+	if (slash === -1) {
+		if (entry?.type !== "blob") throw new GitPathNotFoundError(`No such file: ${fullPath}`);
+		byName.delete(name);
+	} else {
+		if (entry?.type !== "tree") throw new GitPathNotFoundError(`No such file: ${fullPath}`);
+		const newOid = await deleteFromSubtree(repo, entry.oid, filePath.slice(slash + 1), fullPath);
+		if (newOid === null) byName.delete(name);
+		else byName.set(name, {
+			...entry,
+			oid: newOid
+		});
+	}
+	if (byName.size === 0) return null;
+	return git.writeTree({
+		...repo,
+		tree: Array.from(byName.values())
+	});
+}
+/** Resolve a path inside a tree to its entry, or null when absent. */
+async function findTreeEntry(repo, rootTreeOid, treePath) {
+	if (!treePath) return {
+		path: "",
+		mode: "040000",
+		type: "tree",
+		oid: rootTreeOid
+	};
+	const parts = treePath.split("/").filter(Boolean);
+	let currentTreeOid = rootTreeOid;
+	let currentPath = "";
+	for (const [index, part] of parts.entries()) {
+		const entry = (await git.readTree({
+			...repo,
+			oid: currentTreeOid
+		})).tree.find((candidate) => candidate.path === part);
+		if (!entry) return null;
+		currentPath = currentPath ? joinPath(currentPath, entry.path) : entry.path;
+		if (index === parts.length - 1) return {
+			path: currentPath,
+			mode: entry.mode,
+			type: entry.type,
+			oid: entry.oid
+		};
+		if (entry.type !== "tree") return null;
+		currentTreeOid = entry.oid;
+	}
+	return null;
+}
+/** List a tree's direct entries, with paths prefixed by `prefix`. */
+async function listTreeEntries(repo, treeOid, prefix = "") {
+	return (await git.readTree({
+		...repo,
+		oid: treeOid
+	})).tree.map((entry) => ({
+		path: prefix ? joinPath(prefix, entry.path) : entry.path,
+		mode: entry.mode,
+		type: entry.type,
+		oid: entry.oid
+	}));
+}
+//#endregion
+//#region src/ops/types.ts
+const runStep = (hooks, label, fn) => hooks?.step ? hooks.step(label, fn) : fn();
+/**
+* The result-cache key prefixes holding entries for `gitdir` — evict these
+* from your {@link ResultCache} when the repo's storage was rewritten outside
+* a normal push (rename, repack).
+*/
+function resultKeyPrefixes(gitdir) {
+	return [
+		`commitlog:${gitdir}:`,
+		`tree:${gitdir}:`,
+		`last-commits:${gitdir}:`,
+		`file-history:${gitdir}:`
+	];
+}
+//#endregion
+//#region src/ops/history.ts
+/** How far back history walks look by default (commit count). */
+const HISTORY_WALK_DEPTH = 400;
+function summarizeCommit(commit) {
+	return {
+		sha: commit.oid,
+		message: commit.commit.message.trim(),
+		authorName: commit.commit.author.name,
+		authorEmail: commit.commit.author.email,
+		createdAt: (/* @__PURE__ */ new Date(commit.commit.author.timestamp * 1e3)).toISOString()
+	};
+}
+const isNotFound = (err) => err?.code === "NotFoundError";
+/**
+* A ref that doesn't resolve is an expected condition (empty repo, unborn
+* branch) each caller handles. An object missing *underneath* a resolved ref
+* means storage is inconsistent — raised as GitObjectNotFoundError so it is
+* never mistaken for "empty".
+*/
+function wrapMissingObject(promise, context) {
+	return promise.catch((err) => {
+		if (isNotFound(err)) throw new GitObjectNotFoundError(`Git data for ${context} is missing from storage`);
+		throw err;
+	});
+}
+/** The commit a branch name, full ref or sha points at; GitRefNotFoundError if none. */
+/**
+* A short name tries `refs/heads/<name>` first and then `refs/tags/<name>`,
+* so a branch wins over a same-named tag. Annotated tags are peeled to the
+* commit they point at, so every read accepts a tag wherever it accepts a
+* branch.
+*/
+async function resolveRefOid(repo, ref) {
+	const qualified = qualifyBranchRef(ref);
+	const candidates = qualified === `refs/heads/${ref}` ? [qualified, `refs/tags/${ref}`] : [qualified];
+	for (const candidate of candidates) try {
+		return await peelToCommit(repo, await git.resolveRef({
+			...repo,
+			ref: candidate
+		}));
+	} catch (err) {
+		if (!isNotFound(err)) throw err;
+	}
+	throw new GitRefNotFoundError(`Ref ${ref} does not exist`);
+}
+/** Follow annotated tags (possibly nested) down to the object they name. */
+async function peelToCommit(repo, oid) {
+	let current = oid;
+	for (let depth = 0; depth < 10; depth++) {
+		const { type, object } = await git.readObject({
+			...repo,
+			oid: current,
+			format: "parsed"
+		});
+		if (type !== "tag") return current;
+		current = object.object;
+	}
+	throw new GitRefNotFoundError(`Tag chain at ${oid} is too deep`);
+}
+const HEX_SHA_RE = /^[0-9a-f]{4,40}$/i;
+/**
+* The commit oid a revision names: a branch, tag, `HEAD`, a full ref, a full
+* sha or an abbreviated sha (4+ hex digits). Refs win over an abbreviated sha
+* of the same spelling, as in git. Throws GitRefNotFoundError when nothing
+* matches or an abbreviation is ambiguous. An abbreviation scans the pack
+* indexes, so resolve once and read by the returned (immutable) oid.
+*/
+async function resolveCommitOid(repo, rev) {
+	const oid = await lookupCommitOid(repo, rev);
+	try {
+		await git.readCommit({
+			...repo,
+			oid
+		});
+	} catch (err) {
+		if (isNotFound(err) || err?.code === "ObjectTypeError") throw new GitRefNotFoundError(`Ref ${rev} does not exist`);
+		throw err;
+	}
+	return oid;
+}
+async function lookupCommitOid(repo, rev) {
+	try {
+		return await resolveRefOid(repo, rev);
+	} catch (err) {
+		if (!(err instanceof GitRefNotFoundError) || !HEX_SHA_RE.test(rev)) throw err;
+	}
+	const sha = rev.toLowerCase();
+	if (sha.length === 40) return peelToCommit(repo, sha).catch(notFoundAsRef(rev));
+	return git.expandOid({
+		...repo,
+		oid: sha
+	}).then((full) => peelToCommit(repo, full)).catch(notFoundAsRef(rev));
+}
+function notFoundAsRef(rev) {
+	return (err) => {
+		if (isNotFound(err) || err?.code === "AmbiguousError") throw new GitRefNotFoundError(`Ref ${rev} does not exist`);
+		throw err;
+	};
+}
+/** Resolve a branch name / full ref / sha to its commit. */
+async function resolveCommit(repo, ref) {
+	const oid = await resolveRefOid(repo, ref);
+	const { commit } = await wrapMissingObject(git.readCommit({
+		...repo,
+		oid
+	}), `${repo.gitdir} commit ${oid}`);
+	return {
+		oid,
+		commit
+	};
+}
+/** Read a blob's bytes by oid. */
+async function getBlob(repo, sha) {
+	const { blob } = await wrapMissingObject(git.readBlob({
+		...repo,
+		oid: sha
+	}), `${repo.gitdir} blob ${sha}`);
+	return blob;
+}
+/** Read a file's bytes at a ref. Throws GitPathNotFoundError when absent. */
+async function getFileContent(repo, filePath, ref, hooks) {
+	if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+	const { commit } = await resolveCommit(repo, ref);
+	const context = `${repo.gitdir}@${ref}:${filePath}`;
+	const entry = await wrapMissingObject(findTreeEntry(repo, commit.tree, filePath), context);
+	if (entry?.type !== "blob") throw new GitPathNotFoundError(`File not found: ${filePath}`);
+	const { blob } = await wrapMissingObject(git.readBlob({
+		...repo,
+		oid: entry.oid
+	}), context);
+	return blob;
+}
+/** Read one commit by sha. */
+async function getCommit(repo, sha) {
+	const result = await wrapMissingObject(git.readCommit({
+		...repo,
+		oid: sha
+	}), `${repo.gitdir} commit ${sha}`);
+	return {
+		oid: result.oid,
+		commit: result.commit,
+		payload: result.payload
+	};
+}
+/**
+* The commit chain from a ref, newest first; [] when the ref doesn't exist.
+* Walking is sequential and round-trip-bound on object storage, so the
+* deepest walk seen per head is memoized in `hooks.resultCache` and sliced
+* for shallower requests.
+*/
+async function getCommitLog(repo, options, hooks) {
+	const { ref } = options;
+	const depth = options.depth ?? 50;
+	let headSha = options.knownHeadSha;
+	if (headSha === void 0) try {
+		headSha = await resolveRefOid(repo, ref);
+	} catch (err) {
+		if (err instanceof GitRefNotFoundError) return [];
+		throw err;
+	}
+	const cacheKey = `commitlog:${repo.gitdir}:${headSha}`;
+	const cached = hooks?.resultCache?.get(cacheKey);
+	const fullyWalked = cached?.at(-1)?.commit.parent.length === 0;
+	if (cached && (cached.length >= depth || fullyWalked)) {
+		hooks?.onNote?.(`getCommitLog: cache hit ${cacheKey} (depth=${depth})`);
+		return cached.slice(0, depth);
+	}
+	hooks?.onNote?.(`getCommitLog: cache miss ${cacheKey} (depth=${depth})`);
+	if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+	const result = (await wrapMissingObject(runStep(hooks, `git.log ${ref} depth=${depth}`, () => git.log({
+		...repo,
+		ref: headSha,
+		depth
+	})), `${repo.gitdir}@${ref} history`)).map(({ oid, commit, payload }) => ({
+		oid,
+		commit,
+		payload: payload ?? ""
+	}));
+	if (!cached || result.length > cached.length) hooks?.resultCache?.set(cacheKey, result);
+	return result;
+}
+/**
+* List a directory at the tip of a ref. Throws GitRefNotFoundError when the
+* ref doesn't resolve and GitPathNotFoundError when `treePath` doesn't exist.
+* Memoized per head sha.
+*/
+async function getTreeFromRef(repo, options, hooks) {
+	const { ref } = options;
+	const treePath = options.treePath ?? "";
+	const { commit, oid: headSha } = await resolveCommit(repo, ref);
+	const cacheKey = `tree:${repo.gitdir}:${headSha}:${treePath}`;
+	const cached = hooks?.resultCache?.get(cacheKey);
+	if (cached) {
+		hooks?.onNote?.(`getTreeFromRef: cache hit ${cacheKey}`);
+		return cached;
+	}
+	hooks?.onNote?.(`getTreeFromRef: cache miss ${cacheKey}`);
+	if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+	const context = `${repo.gitdir}@${ref}:${treePath || "/"}`;
+	const dir = treePath ? await wrapMissingObject(runStep(hooks, `findTreeEntry ${treePath}`, () => findTreeEntry(repo, commit.tree, treePath)), context) : {
+		path: "",
+		type: "tree",
+		oid: commit.tree
+	};
+	if (!dir) throw new GitPathNotFoundError(`Path "${treePath}" does not exist at ${ref}`);
+	const result = dir.type === "tree" ? await wrapMissingObject(runStep(hooks, `listTreeEntries ${treePath || "/"}`, () => listTreeEntries(repo, dir.oid, dir.path)), context) : [];
+	hooks?.resultCache?.set(cacheKey, result);
+	return result;
+}
+/**
+* A page of commit history from a ref tip; [] when the ref doesn't exist.
+* Pages are slices of {@link getCommitLog}'s memoized walk.
+*/
+async function getCommitHistory(repo, options, hooks) {
+	const limit = options.limit ?? 50;
+	const skip = options.skip ?? 0;
+	return (await getCommitLog(repo, {
+		ref: options.ref,
+		depth: limit + skip
+	}, hooks)).slice(skip, skip + limit);
+}
+//#endregion
+//#region src/ops/branch.ts
+/**
+* Defense in depth for every branch-name argument below: `git.deleteBranch`
+* and raw resolveRef/writeRef reads don't validate ref names internally the
+* way `git.branch` does (see refs.ts) — guard at the point the primitives are
+* actually called, not just at an API boundary far above.
+*/
+function assertSafeBranchName(name) {
+	if (!isSafeBranchName(name)) throw new GitInvalidRequestError(`Invalid branch name: ${name}`);
+}
+const FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+function hasRecursiveFileLister(fs) {
+	return typeof fs === "object" && fs !== null && "listFilesRecursively" in fs && typeof fs.listFilesRecursively === "function";
+}
+function getPromisesFs(fs) {
+	return fs.promises ?? null;
+}
+function decodeFileContent(content) {
+	return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+/**
+* Lists loose branch names without isomorphic-git's recursive readdir/stat
+* traversal. Object stores already return only leaf keys in a recursive LIST,
+* so this is one request regardless of branch-name nesting. Ordinary
+* filesystems retain isomorphic-git's implementation and packed refs remain
+* supported there.
+*/
+async function listLooseBranches(repo) {
+	return listLooseRefNames(repo, "refs/heads");
+}
+/**
+* Loose ref names under `dir` (e.g. `refs/tags`) in one recursive listing,
+* or `null` when the fs can't list recursively (use isomorphic-git's walk).
+*/
+async function listLooseRefNames(repo, dir) {
+	if (!hasRecursiveFileLister(repo.fs)) return null;
+	return (await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`)).filter(isSafeBranchName);
+}
+/** Read packed branch refs so the object-store fast path preserves Git semantics. */
+async function readPackedBranches(repo) {
+	if (!hasRecursiveFileLister(repo.fs)) return /* @__PURE__ */ new Map();
+	const promisesFs = getPromisesFs(repo.fs);
+	if (!promisesFs) return /* @__PURE__ */ new Map();
+	try {
+		const content = await promisesFs.readFile(`${repo.gitdir}/packed-refs`, "utf8");
+		const refs = /* @__PURE__ */ new Map();
+		for (const line of decodeFileContent(content).split("\n")) {
+			const match = /^([0-9a-f]{40}) refs\/heads\/(.+)$/i.exec(line);
+			if (match?.[1] && match[2] && isSafeBranchName(match[2])) refs.set(match[2], match[1]);
+		}
+		return refs;
+	} catch (error) {
+		if (isAbsentError(error)) return /* @__PURE__ */ new Map();
+		throw error;
+	}
+}
+/** Read the symbolic HEAD directly when the object-store fs is available. */
+async function getCurrentLooseBranch(repo) {
+	if (!hasRecursiveFileLister(repo.fs)) return null;
+	const promisesFs = getPromisesFs(repo.fs);
+	if (!promisesFs) return null;
+	try {
+		const head = decodeFileContent(await promisesFs.readFile(`${repo.gitdir}/HEAD`, "utf8")).trim();
+		const match = /^ref: refs\/heads\/(.+)$/.exec(head);
+		return match?.[1] && isSafeBranchName(match[1]) ? match[1] : null;
+	} catch (error) {
+		if (isAbsentError(error)) return null;
+		throw error;
+	}
+}
+/**
+* Resolve a fully-qualified ref's oid with one read instead of isomorphic-
+* git's own `resolveRef`, which does a stat *then* a read for a loose ref
+* (two round trips against object storage) — wasteful specifically here,
+* where the caller already knows the ref exists (it came from a directory
+* listing moments earlier). Reads the loose file directly and falls back to
+* `git.resolveRef` only when that doesn't pan out (packed-refs, or anything
+* else the plain-loose-file assumption doesn't cover), so correctness for
+* those cases is unchanged — this only removes the redundant round trip on
+* the common path.
+*/
+async function resolveLooseRefFast(repo, ref) {
+	const promisesFs = getPromisesFs(repo.fs);
+	if (promisesFs) try {
+		const oid = decodeFileContent(await promisesFs.readFile(`${repo.gitdir}/${ref}`, "utf8")).trim();
+		if (FULL_SHA_RE.test(oid)) return oid;
+	} catch {}
+	return git.resolveRef({
+		...repo,
+		ref
+	});
+}
+/** All branches with their tip commits; [] for an empty repository. */
+async function listBranches(repo) {
+	try {
+		const [looseBranches, looseCurrentBranch, packedBranches] = await Promise.all([
+			listLooseBranches(repo),
+			getCurrentLooseBranch(repo),
+			readPackedBranches(repo)
+		]);
+		const branches = looseBranches === null ? await git.listBranches(repo) : [.../* @__PURE__ */ new Set([...looseBranches, ...packedBranches.keys()])].sort();
+		const currentBranch = looseBranches === null ? await git.currentBranch({
+			...repo,
+			fullname: false
+		}).catch((error) => {
+			if (isAbsentError(error)) return null;
+			throw error;
+		}) : looseCurrentBranch;
+		return Promise.all(branches.map(async (branch) => {
+			const packedCommit = packedBranches.get(branch);
+			return {
+				name: branch,
+				commit: packedCommit && !looseBranches?.includes(branch) ? packedCommit : await resolveLooseRefFast(repo, `refs/heads/${branch}`),
+				isDefault: branch === currentBranch
+			};
+		}));
+	} catch (err) {
+		if (err.code === "NotFoundError") return [];
+		throw err;
+	}
+}
+/** Create `name` pointing at the tip of `startPoint` (no checkout). */
+async function createBranchFrom(repo, name, startPoint) {
+	assertSafeBranchName(name);
+	assertSafeBranchName(startPoint);
+	const object = await resolveLooseRefFast(repo, `refs/heads/${startPoint}`);
+	try {
+		await git.branch({
+			...repo,
+			ref: name,
+			checkout: false,
+			object
+		});
+	} catch (err) {
+		if (err.code === "AlreadyExistsError") throw new GitConflictError(`Branch ${name} already exists`);
+		throw err;
+	}
+}
+/** Delete a branch ref (validated — deleteBranch has no internal ref check). */
+async function deleteBranchByName(repo, name) {
+	assertSafeBranchName(name);
+	if ((await getCurrentLooseBranch(repo) ?? await git.currentBranch({
+		...repo,
+		fullname: false
+	}).catch((error) => {
+		if (isAbsentError(error)) return null;
+		throw error;
+	})) === name) throw new GitInvalidRequestError(`Cannot delete ${name}: it is the default branch`);
+	await git.deleteBranch({
+		...repo,
+		ref: name
+	});
+}
+/** Throws (NotFoundError) unless the branch resolves. */
+async function assertBranchExists(repo, name) {
+	assertSafeBranchName(name);
+	await resolveLooseRefFast(repo, `refs/heads/${name}`);
+}
+/** All tags with the commits they name, sorted by name; [] when there are none. */
+async function listTags(repo) {
+	const names = await listLooseRefNames(repo, "refs/tags") ?? [];
+	const all = /* @__PURE__ */ new Set([...names, ...await git.listTags(repo).catch((error) => {
+		if (isAbsentError(error)) return [];
+		throw error;
+	})]);
+	return (await Promise.all([...all].filter(isSafeBranchName).map(async (name) => {
+		try {
+			const oid = await resolveLooseRefFast(repo, `refs/tags/${name}`);
+			const commit = await peelToCommit(repo, oid);
+			return commit === oid ? {
+				name,
+				commit
+			} : {
+				name,
+				commit,
+				tagObject: oid
+			};
+		} catch (error) {
+			if (isAbsentError(error)) return null;
+			throw error;
+		}
+	}))).filter((tag) => tag !== null).sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true }));
+}
+//#endregion
+//#region src/pack-write.ts
+/**
+* Writing packfiles: serialize whole (never deltified) objects into a pack,
+* and store a pack plus its index in a repository. Shared by repack (the
+* loose-object fallback) and packed writes (ops/packed-writes.ts).
+*
+* Edge-compatible: Web Crypto SHA-1, CompressionStream, Uint8Array only.
+*/
+const PACK_OBJECT_TYPE_BITS = {
+	commit: 16,
+	tree: 32,
+	blob: 48,
+	tag: 64
+};
+function encodePackObjectHeader(type, length) {
+	const bytes = [];
+	let more = length > 15;
+	bytes.push((more ? 128 : 0) | PACK_OBJECT_TYPE_BITS[type] | length & 15);
+	let rest = Math.floor(length / 16);
+	while (more) {
+		more = rest > 127;
+		bytes.push((more ? 128 : 0) | rest & 127);
+		rest = Math.floor(rest / 128);
+	}
+	return new Uint8Array(bytes);
+}
+/** Git's object id: sha1("<type> <byte length>\0<content>"). */
+function hashGitObject(type, content) {
+	return sha1(concat(encodeUtf8(`${type} ${content.length}\0`), content));
+}
+/** A version-2 pack holding `objects` as full entries, in order. */
+async function encodePack(objects) {
+	const header = /* @__PURE__ */ new Uint8Array(12);
+	const view = new DataView(header.buffer);
+	header.set(encodeUtf8("PACK"), 0);
+	view.setUint32(4, 2, false);
+	view.setUint32(8, objects.length, false);
+	const chunks = [header];
+	const BATCH_SIZE = 100;
+	for (let i = 0; i < objects.length; i += BATCH_SIZE) {
+		const encoded = await Promise.all(objects.slice(i, i + BATCH_SIZE).map(async (object) => concat(encodePackObjectHeader(object.type, object.content.length), await deflate(object.content))));
+		chunks.push(...encoded);
+	}
+	const body = concat(...chunks);
+	return concat(body, fromHex(await sha1(body)));
+}
+/**
+* A pack's conventional base name, `pack-<checksum>`: the trailer SHA-1 is a
+* function of the content, so two writers can never pick the same name for
+* different packs, and rewriting the same pack is idempotent.
+*/
+function packBaseName(pack) {
+	return `pack-${toHex(pack.subarray(pack.length - 20))}`;
+}
+/**
+* Store `pack` in `repo` and index it (isomorphic-git's `indexPack`, which
+* re-hashes every object). The `.idx` is written last: a pack only becomes
+* visible to readers once its index exists. Returns the base name and the
+* oids the index lists.
+*/
+async function storePack(repo, pack) {
+	const fsp = rawFs(repo);
+	const packDir = `${repo.gitdir}/objects/pack`;
+	const base = packBaseName(pack);
+	await fsp.mkdir(packDir, { recursive: true });
+	await fsp.writeFile(`${packDir}/${packFileName(base, "pack")}`, pack);
+	const { oids } = await git.indexPack({
+		...repo,
+		dir: packDir,
+		filepath: packFileName(base, "pack")
+	});
+	return {
+		base,
+		oids
+	};
+}
+//#endregion
+//#region src/semaphore.ts
+/**
+* Create a FIFO semaphore admitting at most `limit` concurrent `run`
+* executions. Waiters are queued as promises and released in call order — no
+* polling or timers — so a caller blocked on a full semaphore is woken the
+* instant a permit frees, not on the next tick of a poll loop.
+*/
+function createSemaphore(limit) {
+	if (!Number.isInteger(limit) || limit < 1) throw new Error(`createSemaphore: limit must be an integer >= 1, got ${limit}`);
+	let active = 0;
+	const waiting = [];
+	/**
+	* Hand the permit to the next waiter instead of dropping it, so `active`
+	* only decreases when nothing is queued and never exceeds `limit`.
+	*/
+	function release() {
+		const next = waiting.shift();
+		if (next) next();
+		else active--;
+	}
+	function acquire() {
+		if (active < limit) {
+			active++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			waiting.push(resolve);
+		});
+	}
+	return { run(fn) {
+		return acquire().then(async () => {
+			try {
+				return await fn();
+			} finally {
+				release();
+			}
+		});
+	} };
+}
+//#endregion
+export { upsertTree as A, resolveCommitOid as C, deleteFromTree as D, runStep as E, findTreeEntry as O, resolveCommit as S, resultKeyPrefixes as T, getCommitHistory as _, storePack as a, getTreeFromRef as b, createBranchFrom as c, listLooseRefNames as d, listTags as f, getCommit as g, getBlob as h, packBaseName as i, listTreeEntries as k, deleteBranchByName as l, HISTORY_WALK_DEPTH as m, encodePack as n, assertBranchExists as o, resolveLooseRefFast as p, hashGitObject as r, assertSafeBranchName as s, createSemaphore as t, listBranches as u, getCommitLog as v, summarizeCommit as w, peelToCommit as x, getFileContent as y };
+
+//# sourceMappingURL=semaphore-CPjn7Iqh.js.map