git-fs-s3 0.15.2 → 0.15.3

package/dist/ops.js

@@ -1,740 +1,710 @@
-import {
-  getObjectSize,
-  parseLooseObjectPath
-} from "./chunk-T5M5EYCZ.js";
-import {
-  HISTORY_WALK_DEPTH,
-  assertBranchExists,
-  assertSafeBranchName,
-  createBranchFrom,
-  createSemaphore,
-  deleteBranchByName,
-  deleteFromTree,
-  encodePack,
-  findTreeEntry,
-  getBlob,
-  getCommit,
-  getCommitHistory,
-  getCommitLog,
-  getFileContent,
-  getTreeFromRef,
-  listBranches,
-  listTags,
-  listTreeEntries,
-  peelToCommit,
-  resolveCommit,
-  resolveLooseRefFast,
-  resultKeyPrefixes,
-  runStep,
-  storePack,
-  summarizeCommit,
-  upsertTree
-} from "./chunk-IAKZRWBZ.js";
-import {
-  GitInvalidRequestError,
-  GitPathNotFoundError,
-  inflate,
-  isSafeTreePath,
-  qualifyBranchRef,
-  readBlobContent
-} from "./chunk-OKBQISUC.js";
-
-// src/ops/commit.ts
+import { D as GitPathNotFoundError, H as inflate, T as GitInvalidRequestError, W as readBlobContent, o as isSafeTreePath, s as qualifyBranchRef } from "./refs-Cb_NfKWI.js";
+import { i as parseLooseObjectPath, t as getObjectSize } from "./object-size-BJAsnZzw.js";
+import { C as summarizeCommit, D as findTreeEntry, E as deleteFromTree, O as listTreeEntries, S as resolveCommit, T as runStep, _ as getCommitHistory, a as storePack, b as getTreeFromRef, c as createBranchFrom, f as listTags, g as getCommit, h as getBlob, k as upsertTree, l as deleteBranchByName, m as HISTORY_WALK_DEPTH, n as encodePack, o as assertBranchExists, p as resolveLooseRefFast, s as assertSafeBranchName, t as createSemaphore, u as listBranches, v as getCommitLog, w as resultKeyPrefixes, x as peelToCommit, y as getFileContent } from "./semaphore-BviNoQuJ.js";
 import git from "isomorphic-git";
-
-// src/ops/packed-writes.ts
-var OBJECT_TYPES = /* @__PURE__ */ new Set(["commit", "tree", "blob", "tag"]);
+import { createTwoFilesPatch } from "diff";
+//#region src/ops/packed-writes.ts
+/**
+* Packed writes: run git plumbing (writeBlob/writeTree/writeCommit, and
+* anything built on them) against a repository, but store the objects it
+* creates as one pack instead of one loose object each.
+*
+* Why it matters on object storage: one PUT per object becomes two per
+* operation (pack + index), and a repository that is never given loose
+* objects stays "fully packed" forever — which is what makes the loose-object
+* hint (`GitFs.detectLooseObjects`) safe across processes. A process that
+* once saw "no loose objects" in a gitdir can't be told when another process
+* writes one; if nothing ever writes loose objects, that answer stays true.
+*
+* Ordering is preserved: the pending objects are flushed (pack, then its
+* index) before any other file is written — so a ref written inside `fn`
+* never becomes visible before the objects it names.
+*/
+const OBJECT_TYPES = /* @__PURE__ */ new Set([
+	"commit",
+	"tree",
+	"blob",
+	"tag"
+]);
+/** Split a loose object's inflated bytes ("<type> <size>\0<content>"). */
 function parseLooseObject(raw) {
-  const nul = raw.indexOf(0);
-  const header = new TextDecoder().decode(raw.subarray(0, nul));
-  const [type, size] = header.split(" ");
-  const content = raw.slice(nul + 1);
-  if (!OBJECT_TYPES.has(type) || Number(size) !== content.length) {
-    throw new Error(`packed writes: malformed object header "${header}"`);
-  }
-  return { type, content };
+	const nul = raw.indexOf(0);
+	const header = new TextDecoder().decode(raw.subarray(0, nul));
+	const [type, size] = header.split(" ");
+	const content = raw.slice(nul + 1);
+	if (!OBJECT_TYPES.has(type) || Number(size) !== content.length) throw new Error(`packed writes: malformed object header "${header}"`);
+	return {
+		type,
+		content
+	};
 }
 function fileStat(size) {
-  const epoch = /* @__PURE__ */ new Date(0);
-  return {
-    type: "file",
-    mode: 33188,
-    size,
-    ino: 0,
-    mtimeMs: 0,
-    ctimeMs: 0,
-    uid: 0,
-    gid: 0,
-    dev: 0,
-    mtime: epoch,
-    ctime: epoch,
-    isFile: () => true,
-    isDirectory: () => false,
-    isSymbolicLink: () => false
-  };
+	const epoch = /* @__PURE__ */ new Date(0);
+	return {
+		type: "file",
+		mode: 33188,
+		size,
+		ino: 0,
+		mtimeMs: 0,
+		ctimeMs: 0,
+		uid: 0,
+		gid: 0,
+		dev: 0,
+		mtime: epoch,
+		ctime: epoch,
+		isFile: () => true,
+		isDirectory: () => false,
+		isSymbolicLink: () => false
+	};
 }
+/**
+* Run `fn` with a repo whose new objects are buffered and stored as a single
+* pack. Objects are flushed before any non-object write inside `fn`, and once
+* more when `fn` resolves; if `fn` throws, still-unflushed objects are
+* discarded (they'd be unreachable anyway). Serialize concurrent writers to
+* the same repository externally, as for any write.
+*/
 async function withPackedWrites(repo, fn) {
-  const base = repo.fs.promises;
-  const pending = /* @__PURE__ */ new Map();
-  async function flush() {
-    if (pending.size === 0) return;
-    const objects = await Promise.all(
-      [...pending.values()].map(
-        async (deflated) => parseLooseObject(await inflate(deflated))
-      )
-    );
-    await storePack(repo, await encodePack(objects));
-    pending.clear();
-  }
-  const promises = new Proxy(base, {
-    get(target, property, receiver) {
-      switch (property) {
-        case "writeFile":
-          return async (path, data, options) => {
-            if (parseLooseObjectPath(path) !== null && typeof data !== "string") {
-              pending.set(path, new Uint8Array(data));
-              return;
-            }
-            await flush();
-            return target.writeFile(path, data, options);
-          };
-        case "readFile":
-          return async (path, options) => {
-            const data = pending.get(path);
-            if (data === void 0) return target.readFile(path, options);
-            return data;
-          };
-        case "stat":
-        case "lstat":
-          return async (path) => {
-            const data = pending.get(path);
-            if (data !== void 0) return fileStat(data.length);
-            return target[property](path);
-          };
-        default: {
-          const value = Reflect.get(target, property, receiver);
-          return typeof value === "function" ? value.bind(target) : value;
-        }
-      }
-    }
-  });
-  const packedRepo = { ...repo, fs: { promises } };
-  const result = await fn(packedRepo);
-  await flush();
-  return result;
+	const base = repo.fs.promises;
+	const pending = /* @__PURE__ */ new Map();
+	async function flush() {
+		if (pending.size === 0) return;
+		const objects = await Promise.all([...pending.values()].map(async (deflated) => parseLooseObject(await inflate(deflated))));
+		await storePack(repo, await encodePack(objects));
+		pending.clear();
+	}
+	const promises = new Proxy(base, { get(target, property, receiver) {
+		switch (property) {
+			case "writeFile": return async (path, data, options) => {
+				if (parseLooseObjectPath(path) !== null && typeof data !== "string") {
+					pending.set(path, new Uint8Array(data));
+					return;
+				}
+				await flush();
+				return target.writeFile(path, data, options);
+			};
+			case "readFile": return async (path, options) => {
+				const data = pending.get(path);
+				if (data === void 0) return target.readFile(path, options);
+				return data;
+			};
+			case "stat":
+			case "lstat": return async (path) => {
+				const data = pending.get(path);
+				if (data !== void 0) return fileStat(data.length);
+				return target[property](path);
+			};
+			default: {
+				const value = Reflect.get(target, property, receiver);
+				return typeof value === "function" ? value.bind(target) : value;
+			}
+		}
+	} });
+	const result = await fn({
+		...repo,
+		fs: { promises }
+	});
+	await flush();
+	return result;
 }
-
-// src/ops/commit.ts
+//#endregion
+//#region src/ops/commit.ts
+/** An author stamped with the current time. */
 function authorNow(name, email) {
-  return {
-    name,
-    email,
-    timestamp: Math.floor(Date.now() / 1e3),
-    timezoneOffset: 0
-  };
+	return {
+		name,
+		email,
+		timestamp: Math.floor(Date.now() / 1e3),
+		timezoneOffset: 0
+	};
 }
+/**
+* Write a commit directly to a bare repository — no worktree, no checkout.
+* `buildTree` receives the parent commit's tree oid (undefined on an empty
+* repo / unborn branch) and returns the new root tree oid; this function
+* writes the commit object and force-updates `refs/heads/<branch>`.
+*
+* Every object the commit creates (blobs, trees, the commit) is stored as one
+* pack (see {@link withPackedWrites}), written before the ref.
+*
+* Serialize concurrent writers externally (a per-repo lock): the
+* resolve-ref → write-ref sequence is not atomic on object storage.
+*/
 async function writeCommitToBare(repo, options) {
-  assertSafeBranchName(options.branch);
-  return withPackedWrites(repo, (packed) => writeCommit(packed, options));
+	assertSafeBranchName(options.branch);
+	return withPackedWrites(repo, (packed) => writeCommit(packed, options));
 }
 async function writeCommit(repo, options) {
-  let parentOid;
-  let parentTreeOid;
-  try {
-    parentOid = await git.resolveRef({
-      ...repo,
-      ref: `refs/heads/${options.branch}`
-    });
-    const { commit } = await git.readCommit({ ...repo, oid: parentOid });
-    parentTreeOid = commit.tree;
-  } catch (err) {
-    if (err?.code !== "NotFoundError") {
-      throw err;
-    }
-  }
-  const treeOid = await options.buildTree(parentTreeOid, repo);
-  const commitOid = await git.writeCommit({
-    ...repo,
-    commit: {
-      message: options.message,
-      tree: treeOid,
-      parent: parentOid ? [parentOid] : [],
-      author: options.author,
-      committer: options.author
-    }
-  });
-  await git.writeRef({
-    ...repo,
-    ref: `refs/heads/${options.branch}`,
-    value: commitOid,
-    force: true
-  });
-  return commitOid;
+	let parentOid;
+	let parentTreeOid;
+	try {
+		parentOid = await git.resolveRef({
+			...repo,
+			ref: `refs/heads/${options.branch}`
+		});
+		const { commit } = await git.readCommit({
+			...repo,
+			oid: parentOid
+		});
+		parentTreeOid = commit.tree;
+	} catch (err) {
+		if (err?.code !== "NotFoundError") throw err;
+	}
+	const treeOid = await options.buildTree(parentTreeOid, repo);
+	const commitOid = await git.writeCommit({
+		...repo,
+		commit: {
+			message: options.message,
+			tree: treeOid,
+			parent: parentOid ? [parentOid] : [],
+			author: options.author,
+			committer: options.author
+		}
+	});
+	await git.writeRef({
+		...repo,
+		ref: `refs/heads/${options.branch}`,
+		value: commitOid,
+		force: true
+	});
+	return commitOid;
 }
+/**
+* Commit a set of files onto a branch, straight to the bare repo. Each blob
+* is written to its own content-addressed key — no shared state between
+* files, so they're written in parallel.
+*/
 async function commitFilesToBare(repo, options) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const file of options.files) {
-    if (!isSafeTreePath(file.path)) {
-      throw new GitInvalidRequestError(`Invalid file path: ${file.path}`);
-    }
-    if (paths.has(file.path)) {
-      throw new GitInvalidRequestError(`Duplicate file path: ${file.path}`);
-    }
-    paths.add(file.path);
-  }
-  if (paths.size === 0) {
-    throw new GitInvalidRequestError("A commit needs at least one file");
-  }
-  return writeCommitToBare(repo, {
-    branch: options.branch,
-    message: options.message,
-    author: options.author,
-    buildTree: async (parentTreeOid, writeRepo) => {
-      const blobs = /* @__PURE__ */ new Map();
-      await Promise.all(
-        options.files.map(async (file) => {
-          const content = typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
-          const oid = await git.writeBlob({ ...writeRepo, blob: content });
-          blobs.set(file.path, oid);
-        })
-      );
-      return upsertTree(writeRepo, parentTreeOid, blobs);
-    }
-  });
+	const paths = /* @__PURE__ */ new Set();
+	for (const file of options.files) {
+		if (!isSafeTreePath(file.path)) throw new GitInvalidRequestError(`Invalid file path: ${file.path}`);
+		if (paths.has(file.path)) throw new GitInvalidRequestError(`Duplicate file path: ${file.path}`);
+		paths.add(file.path);
+	}
+	if (paths.size === 0) throw new GitInvalidRequestError("A commit needs at least one file");
+	return writeCommitToBare(repo, {
+		branch: options.branch,
+		message: options.message,
+		author: options.author,
+		buildTree: async (parentTreeOid, writeRepo) => {
+			const blobs = /* @__PURE__ */ new Map();
+			await Promise.all(options.files.map(async (file) => {
+				const content = typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
+				const oid = await git.writeBlob({
+					...writeRepo,
+					blob: content
+				});
+				blobs.set(file.path, oid);
+			}));
+			return upsertTree(writeRepo, parentTreeOid, blobs);
+		}
+	});
 }
+/** Commit the removal of one file from a branch, straight to the bare repo. */
 async function deleteFileFromBare(repo, options) {
-  if (!isSafeTreePath(options.filePath)) {
-    throw new GitInvalidRequestError(`Invalid file path: ${options.filePath}`);
-  }
-  return writeCommitToBare(repo, {
-    branch: options.branch,
-    message: options.message,
-    author: options.author,
-    buildTree: async (parentTreeOid, writeRepo) => {
-      if (!parentTreeOid) {
-        throw new GitPathNotFoundError(`Branch ${options.branch} is empty`);
-      }
-      return deleteFromTree(writeRepo, parentTreeOid, options.filePath);
-    }
-  });
+	if (!isSafeTreePath(options.filePath)) throw new GitInvalidRequestError(`Invalid file path: ${options.filePath}`);
+	return writeCommitToBare(repo, {
+		branch: options.branch,
+		message: options.message,
+		author: options.author,
+		buildTree: async (parentTreeOid, writeRepo) => {
+			if (!parentTreeOid) throw new GitPathNotFoundError(`Branch ${options.branch} is empty`);
+			return deleteFromTree(writeRepo, parentTreeOid, options.filePath);
+		}
+	});
 }
-
-// src/ops/diff.ts
-import { createTwoFilesPatch } from "diff";
-import git2 from "isomorphic-git";
-var MAX_DIFF_TEXT_BYTES = 1024 * 1024;
-var MAX_CONCURRENT_READS = 16;
+//#endregion
+//#region src/ops/diff.ts
+/** Text files larger than this get no patch (kind "too-large"). */
+const MAX_DIFF_TEXT_BYTES = 1048576;
+/**
+* Blob reads and size probes one diff may have in flight at once. The walk
+* visits a directory's entries concurrently, so without a bound a commit
+* touching a wide tree issues one object-store request per entry at once; each
+* read also materialises a whole blob. High enough to stay pipelined, low
+* enough that a wide change can't exhaust sockets or memory from one request.
+*/
+const MAX_CONCURRENT_READS = 16;
 function countContentLines(content) {
-  if (content.length === 0) return 0;
-  const lines = content.split("\n");
-  if (lines.at(-1) === "") lines.pop();
-  return lines.length;
+	if (content.length === 0) return 0;
+	const lines = content.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines.length;
 }
 function unifiedPatch(path, before, after) {
-  const body = createTwoFilesPatch(
-    before ? `a/${path}` : "/dev/null",
-    after ? `b/${path}` : "/dev/null",
-    before?.text ?? "",
-    after?.text ?? "",
-    "",
-    "",
-    { context: 3 }
-  ).replace(/^=+\n/, "");
-  return `diff --git a/${path} b/${path}
-${body}`;
+	return `diff --git a/${path} b/${path}\n${createTwoFilesPatch(before ? `a/${path}` : "/dev/null", after ? `b/${path}` : "/dev/null", before?.text ?? "", after?.text ?? "", "", "", { context: 3 }).replace(/^=+\n/, "")}`;
 }
+/** One changed path: `before` null for an addition, `after` null for a deletion. */
 function buildDiffFile(path, before, after) {
-  const kind = before?.isBinary || after?.isBinary ? "binary" : Math.max(before?.bytes.length ?? 0, after?.bytes.length ?? 0) > MAX_DIFF_TEXT_BYTES ? "too-large" : "text";
-  const isText = kind === "text";
-  return {
-    path,
-    status: !before ? "added" : !after ? "deleted" : "modified",
-    kind,
-    additions: isText && after ? countContentLines(after.text) : 0,
-    deletions: isText && before ? countContentLines(before.text) : 0,
-    patch: isText ? unifiedPatch(path, before, after) : "",
-    oldSize: before?.bytes.length,
-    newSize: after?.bytes.length
-  };
+	const kind = before?.isBinary || after?.isBinary ? "binary" : Math.max(before?.bytes.length ?? 0, after?.bytes.length ?? 0) > 1048576 ? "too-large" : "text";
+	const isText = kind === "text";
+	return {
+		path,
+		status: !before ? "added" : !after ? "deleted" : "modified",
+		kind,
+		additions: isText && after ? countContentLines(after.text) : 0,
+		deletions: isText && before ? countContentLines(before.text) : 0,
+		patch: isText ? unifiedPatch(path, before, after) : "",
+		oldSize: before?.bytes.length,
+		newSize: after?.bytes.length
+	};
 }
 async function readDiffEntry(entry) {
-  return entry ? {
-    type: await entry.type(),
-    oid: await entry.oid(),
-    mode: await entry.mode()
-  } : void 0;
+	return entry ? {
+		type: await entry.type(),
+		oid: await entry.oid(),
+		mode: await entry.mode()
+	} : void 0;
 }
+/** Submodules are pointer diffs even when replacing a regular file or directory. */
 function buildSubmoduleDiff(filepath, before, after) {
-  if (before?.type === after?.type && before?.oid === after?.oid)
-    return void 0;
-  const line = (entry) => entry ? `${entry.type === "commit" ? "Subproject commit" : entry.type === "tree" ? "Directory" : "File"} ${entry.oid}
-` : "";
-  return {
-    path: filepath,
-    status: !before ? "added" : !after ? "deleted" : "modified",
-    kind: "submodule",
-    additions: 0,
-    deletions: 0,
-    oldEntry: before,
-    newEntry: after,
-    patch: createTwoFilesPatch(
-      before ? `a/${filepath}` : "/dev/null",
-      after ? `b/${filepath}` : "/dev/null",
-      line(before),
-      line(after),
-      "",
-      "",
-      { context: 3 }
-    )
-  };
+	if (before?.type === after?.type && before?.oid === after?.oid) return void 0;
+	const line = (entry) => entry ? `${entry.type === "commit" ? "Subproject commit" : entry.type === "tree" ? "Directory" : "File"} ${entry.oid}\n` : "";
+	return {
+		path: filepath,
+		status: !before ? "added" : !after ? "deleted" : "modified",
+		kind: "submodule",
+		additions: 0,
+		deletions: 0,
+		oldEntry: before,
+		newEntry: after,
+		patch: createTwoFilesPatch(before ? `a/${filepath}` : "/dev/null", after ? `b/${filepath}` : "/dev/null", line(before), line(after), "", "", { context: 3 })
+	};
 }
+/**
+* Every file that differs between two trees; `oldTreeOid` null diffs against
+* nothing (a root commit: every file is an addition).
+*/
 async function diffTrees(repo, oldTreeOid, newTreeOid) {
-  const reads = createSemaphore(MAX_CONCURRENT_READS);
-  const sideMeta = async (entry) => {
-    if (!entry || await entry.type() !== "blob") return null;
-    const oid = await entry.oid();
-    return { oid, size: await reads.run(() => getObjectSize(repo, oid)) };
-  };
-  const readContent = async (side) => {
-    if (!side) return null;
-    const { blob } = await reads.run(
-      () => git2.readBlob({ ...repo, oid: side.oid })
-    );
-    return readBlobContent(blob);
-  };
-  const trees = oldTreeOid ? [git2.TREE({ ref: oldTreeOid }), git2.TREE({ ref: newTreeOid })] : [git2.TREE({ ref: newTreeOid })];
-  const changes = await git2.walk({
-    ...repo,
-    trees,
-    map: async (filepath, entries) => {
-      const [oldEntry, newEntry] = oldTreeOid ? [entries[0] ?? null, entries[1] ?? null] : [null, entries[0] ?? null];
-      const [oldType, newType] = await Promise.all([
-        oldEntry?.type(),
-        newEntry?.type()
-      ]);
-      if (oldType === "commit" || newType === "commit") {
-        const [before2, after2] = await Promise.all([
-          readDiffEntry(oldEntry),
-          readDiffEntry(newEntry)
-        ]);
-        return buildSubmoduleDiff(filepath, before2, after2);
-      }
-      if (oldType !== "blob" && newType !== "blob") return void 0;
-      if (oldEntry && newEntry && oldType === newType) {
-        const [oldOid, newOid] = await Promise.all([
-          oldEntry.oid(),
-          newEntry.oid()
-        ]);
-        if (oldOid === newOid) return void 0;
-      }
-      const [oldSide, newSide] = await Promise.all([
-        sideMeta(oldEntry),
-        sideMeta(newEntry)
-      ]);
-      if ((oldSide?.size ?? 0) > MAX_DIFF_TEXT_BYTES || (newSide?.size ?? 0) > MAX_DIFF_TEXT_BYTES) {
-        return {
-          path: filepath,
-          status: !oldSide ? "added" : !newSide ? "deleted" : "modified",
-          kind: "too-large",
-          additions: 0,
-          deletions: 0,
-          patch: "",
-          oldSize: oldSide?.size ?? void 0,
-          newSize: newSide?.size ?? void 0
-        };
-      }
-      const [before, after] = await Promise.all([
-        readContent(oldSide),
-        readContent(newSide)
-      ]);
-      return before || after ? buildDiffFile(filepath, before, after) : void 0;
-    }
-  });
-  const files = (changes ?? []).filter((file) => !!file);
-  return {
-    files,
-    totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
-    totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
-    totalFiles: files.length
-  };
+	const reads = createSemaphore(MAX_CONCURRENT_READS);
+	/**
+	* A blob side's oid plus its size from its pack entry — asked before any
+	* content is read, so a file over {@link MAX_DIFF_TEXT_BYTES} is rejected
+	* without ever being inflated. `size` is `null` when the size isn't
+	* available (a loose object, or a store without range reads), in which case
+	* the caller reads the blob and the size check below still applies.
+	*/
+	const sideMeta = async (entry) => {
+		if (!entry || await entry.type() !== "blob") return null;
+		const oid = await entry.oid();
+		return {
+			oid,
+			size: await reads.run(() => getObjectSize(repo, oid))
+		};
+	};
+	/** The side's content, or `null` when it isn't there. */
+	const readContent = async (side) => {
+		if (!side) return null;
+		const { blob } = await reads.run(() => git.readBlob({
+			...repo,
+			oid: side.oid
+		}));
+		return readBlobContent(blob);
+	};
+	const trees = oldTreeOid ? [git.TREE({ ref: oldTreeOid }), git.TREE({ ref: newTreeOid })] : [git.TREE({ ref: newTreeOid })];
+	const files = (await git.walk({
+		...repo,
+		trees,
+		map: async (filepath, entries) => {
+			const [oldEntry, newEntry] = oldTreeOid ? [entries[0] ?? null, entries[1] ?? null] : [null, entries[0] ?? null];
+			const [oldType, newType] = await Promise.all([oldEntry?.type(), newEntry?.type()]);
+			if (oldType === "commit" || newType === "commit") {
+				const [before, after] = await Promise.all([readDiffEntry(oldEntry), readDiffEntry(newEntry)]);
+				return buildSubmoduleDiff(filepath, before, after);
+			}
+			if (oldType !== "blob" && newType !== "blob") return void 0;
+			if (oldEntry && newEntry && oldType === newType) {
+				const [oldOid, newOid] = await Promise.all([oldEntry.oid(), newEntry.oid()]);
+				if (oldOid === newOid) return void 0;
+			}
+			const [oldSide, newSide] = await Promise.all([sideMeta(oldEntry), sideMeta(newEntry)]);
+			if ((oldSide?.size ?? 0) > 1048576 || (newSide?.size ?? 0) > 1048576) return {
+				path: filepath,
+				status: !oldSide ? "added" : !newSide ? "deleted" : "modified",
+				kind: "too-large",
+				additions: 0,
+				deletions: 0,
+				patch: "",
+				oldSize: oldSide?.size ?? void 0,
+				newSize: newSide?.size ?? void 0
+			};
+			const [before, after] = await Promise.all([readContent(oldSide), readContent(newSide)]);
+			return before || after ? buildDiffFile(filepath, before, after) : void 0;
+		}
+	}) ?? []).filter((file) => !!file);
+	return {
+		files,
+		totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
+		totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
+		totalFiles: files.length
+	};
 }
+/** The diff a single commit introduced (against its first parent). */
 async function getCommitDiff(repo, commitSha) {
-  const { commit } = await getCommit(repo, commitSha);
-  const parent = commit.parent[0];
-  const parentTree = parent ? (await getCommit(repo, parent)).commit.tree : null;
-  return {
-    ...await diffTrees(repo, parentTree, commit.tree),
-    oldRef: parent,
-    newRef: commitSha
-  };
+	const { commit } = await getCommit(repo, commitSha);
+	const parent = commit.parent[0];
+	return {
+		...await diffTrees(repo, parent ? (await getCommit(repo, parent)).commit.tree : null, commit.tree),
+		oldRef: parent,
+		newRef: commitSha
+	};
 }
+/**
+* What `compareRef` changed since it diverged from `baseRef` — a pull
+* request's diff (git's three-dot `base...compare`): compared against their
+* merge base, so commits that landed on `baseRef` since the branch point
+* don't show up as reverted. Throws GitRefNotFoundError for a missing ref.
+*/
 async function getDiffBetweenRefs(repo, baseRef, compareRef) {
-  const [base, compare] = await Promise.all([
-    resolveCommit(repo, baseRef),
-    resolveCommit(repo, compareRef)
-  ]);
-  const [mergeBase] = await git2.findMergeBase({
-    ...repo,
-    oids: [base.oid, compare.oid]
-  });
-  const baseTree = mergeBase === void 0 ? null : mergeBase === base.oid ? base.commit.tree : (await getCommit(repo, mergeBase)).commit.tree;
-  return {
-    ...await diffTrees(repo, baseTree, compare.commit.tree),
-    oldRef: mergeBase,
-    newRef: compare.oid
-  };
+	const [base, compare] = await Promise.all([resolveCommit(repo, baseRef), resolveCommit(repo, compareRef)]);
+	const [mergeBase] = await git.findMergeBase({
+		...repo,
+		oids: [base.oid, compare.oid]
+	});
+	return {
+		...await diffTrees(repo, mergeBase === void 0 ? null : mergeBase === base.oid ? base.commit.tree : (await getCommit(repo, mergeBase)).commit.tree, compare.commit.tree),
+		oldRef: mergeBase,
+		newRef: compare.oid
+	};
 }
-
-// src/ops/file-history.ts
-var BANNER_WALK_DEPTH = 60;
-var PREFETCH_WINDOW = 24;
+//#endregion
+//#region src/ops/file-history.ts
+/**
+* A shallow walk for a "latest commit touching this file" banner, which only
+* shows `entries[0]`; a full History view is a click away.
+*/
+const BANNER_WALK_DEPTH = 60;
+/** Tree reads are prefetched in parallel windows; see getLastCommitsForTree. */
+const PREFETCH_WINDOW$1 = 24;
+/**
+* All commits (newest first) that changed a single file's blob oid, walking
+* the first-parent chain — same approach as getLastCommitsForTree but for one
+* path and collecting every match instead of stopping at the first.
+*/
 async function getFileHistory(repo, options, hooks) {
-  const limit = options.limit ?? 30;
-  const maxDepth = options.maxDepth ?? HISTORY_WALK_DEPTH;
-  const walkDepth = Math.max(maxDepth, limit);
-  const commits = await runStep(
-    hooks,
-    `getCommitLog depth=${walkDepth}`,
-    () => getCommitLog(repo, { ref: options.ref, depth: walkDepth }, hooks)
-  );
-  const head = commits[0];
-  if (!head) return { entries: [], truncated: false };
-  const cacheKey = `file-history:${repo.gitdir}:${head.oid}:${options.filePath}:${limit}:${maxDepth}`;
-  const cached = hooks?.resultCache?.get(cacheKey);
-  if (cached) {
-    hooks?.onNote?.("getFileHistory: result-cache HIT, skipping history walk");
-    return cached;
-  }
-  hooks?.onNote?.("getFileHistory: result-cache MISS, walking history");
-  const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
-  const oidByCommitTree = /* @__PURE__ */ new Map();
-  async function resolveOid(commitTreeOid) {
-    const cachedOid = oidByCommitTree.get(commitTreeOid);
-    if (cachedOid !== void 0) return cachedOid;
-    const entry = await findTreeEntry(repo, commitTreeOid, options.filePath);
-    const oid = entry && entry.type !== "tree" ? entry.oid : null;
-    oidByCommitTree.set(commitTreeOid, oid);
-    return oid;
-  }
-  const entries = [];
-  let truncated = false;
-  outer: for (let windowStart = 0; windowStart < commits.length; windowStart += PREFETCH_WINDOW) {
-    const windowEnd = Math.min(windowStart + PREFETCH_WINDOW, commits.length);
-    const prefetchEnd = Math.min(windowEnd + 1, commits.length);
-    await Promise.all(
-      commits.slice(windowStart, prefetchEnd).map((commit) => resolveOid(commit.commit.tree))
-    );
-    for (let i = windowStart; i < windowEnd; i++) {
-      const commit = commits[i];
-      if (!commit) break outer;
-      const parentSha = commit.commit.parent[0];
-      const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
-      if (parentSha && !parentCommit) {
-        truncated = true;
-        break outer;
-      }
-      const [oid, parentOid] = await Promise.all([
-        resolveOid(commit.commit.tree),
-        parentCommit ? resolveOid(parentCommit.commit.tree) : Promise.resolve(null)
-      ]);
-      if (oid !== parentOid) {
-        entries.push(summarizeCommit(commit));
-        if (entries.length >= limit) {
-          truncated = i < commits.length - 1;
-          break outer;
-        }
-      }
-    }
-  }
-  const result = { entries, truncated };
-  hooks?.resultCache?.set(cacheKey, result);
-  return result;
+	const limit = options.limit ?? 30;
+	const maxDepth = options.maxDepth ?? 400;
+	const walkDepth = Math.max(maxDepth, limit);
+	const commits = await runStep(hooks, `getCommitLog depth=${walkDepth}`, () => getCommitLog(repo, {
+		ref: options.ref,
+		depth: walkDepth
+	}, hooks));
+	const head = commits[0];
+	if (!head) return {
+		entries: [],
+		truncated: false
+	};
+	const cacheKey = `file-history:${repo.gitdir}:${head.oid}:${options.filePath}:${limit}:${maxDepth}`;
+	const cached = hooks?.resultCache?.get(cacheKey);
+	if (cached) {
+		hooks?.onNote?.("getFileHistory: result-cache HIT, skipping history walk");
+		return cached;
+	}
+	hooks?.onNote?.("getFileHistory: result-cache MISS, walking history");
+	const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
+	const oidByCommitTree = /* @__PURE__ */ new Map();
+	async function resolveOid(commitTreeOid) {
+		const cachedOid = oidByCommitTree.get(commitTreeOid);
+		if (cachedOid !== void 0) return cachedOid;
+		const entry = await findTreeEntry(repo, commitTreeOid, options.filePath);
+		const oid = entry && entry.type !== "tree" ? entry.oid : null;
+		oidByCommitTree.set(commitTreeOid, oid);
+		return oid;
+	}
+	const entries = [];
+	let truncated = false;
+	outer: for (let windowStart = 0; windowStart < commits.length; windowStart += PREFETCH_WINDOW$1) {
+		const windowEnd = Math.min(windowStart + PREFETCH_WINDOW$1, commits.length);
+		const prefetchEnd = Math.min(windowEnd + 1, commits.length);
+		await Promise.all(commits.slice(windowStart, prefetchEnd).map((commit) => resolveOid(commit.commit.tree)));
+		for (let i = windowStart; i < windowEnd; i++) {
+			const commit = commits[i];
+			if (!commit) break outer;
+			const parentSha = commit.commit.parent[0];
+			const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
+			if (parentSha && !parentCommit) {
+				truncated = true;
+				break outer;
+			}
+			const [oid, parentOid] = await Promise.all([resolveOid(commit.commit.tree), parentCommit ? resolveOid(parentCommit.commit.tree) : Promise.resolve(null)]);
+			if (oid !== parentOid) {
+				entries.push(summarizeCommit(commit));
+				if (entries.length >= limit) {
+					truncated = i < commits.length - 1;
+					break outer;
+				}
+			}
+		}
+	}
+	const result = {
+		entries,
+		truncated
+	};
+	hooks?.resultCache?.set(cacheKey, result);
+	return result;
 }
-
-// src/ops/last-commit.ts
-var PREFETCH_WINDOW2 = 24;
+//#endregion
+//#region src/ops/last-commit.ts
+/**
+* The walk itself is inherently sequential (each step needs to know what's
+* still "remaining" from the step before), but the tree-object reads that
+* back it are not — each commit's tree oid is already known upfront from the
+* commit log. Prefetching a window of tree reads in parallel turns ~1 network
+* round trip per commit (serialized) into ~1 round trip per window, which is
+* where nearly all of this function's wall-clock time goes on object storage.
+*/
+const PREFETCH_WINDOW = 24;
+/**
+* For each direct child of `treePath` (at the tip of `ref`), find the most
+* recent commit that changed it — the tree view's "last commit" column. Walks
+* history newest-to-oldest, comparing the directory's tree oid
+* commit-to-commit and only descending one level to diff child oids when
+* something under the directory actually changed. Preserve the two-phase
+* structure (parallel prefetch, then sequential resolve) when touching this —
+* the "which entries are still unresolved" state must advance
+* commit-by-commit.
+*/
 async function getLastCommitsForTree(repo, options, hooks) {
-  const treePath = options.treePath ?? "";
-  const depth = options.depth ?? HISTORY_WALK_DEPTH;
-  const commits = await runStep(
-    hooks,
-    `getCommitLog depth=${depth}`,
-    () => getCommitLog(repo, { ref: options.ref, depth }, hooks)
-  );
-  hooks?.onNote?.(`getLastCommitsForTree: ${commits.length} commits in log`);
-  const head = commits[0];
-  if (!head) return {};
-  const cacheKey = `last-commits:${repo.gitdir}:${head.oid}:${treePath}`;
-  const cachedResult = hooks?.resultCache?.get(cacheKey);
-  if (cachedResult) {
-    hooks?.onNote?.(
-      "getLastCommitsForTree: result-cache HIT, skipping history walk"
-    );
-    return cachedResult;
-  }
-  hooks?.onNote?.("getLastCommitsForTree: result-cache MISS, walking history");
-  const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
-  const dirOidByCommitTree = /* @__PURE__ */ new Map();
-  const childrenByDirOid = /* @__PURE__ */ new Map();
-  async function resolveDirOid(commitTreeOid) {
-    const cached = dirOidByCommitTree.get(commitTreeOid);
-    if (cached !== void 0) return cached;
-    const entry = await findTreeEntry(repo, commitTreeOid, treePath);
-    const dirOid = entry?.type === "tree" ? entry.oid : null;
-    dirOidByCommitTree.set(commitTreeOid, dirOid);
-    return dirOid;
-  }
-  async function resolveChildren(dirOid) {
-    if (dirOid === null) return [];
-    const cached = childrenByDirOid.get(dirOid);
-    if (cached) return cached;
-    const children = await listTreeEntries(repo, dirOid, treePath);
-    childrenByDirOid.set(dirOid, children);
-    return children;
-  }
-  const headDirOid = await resolveDirOid(head.commit.tree);
-  if (headDirOid === null) return {};
-  const headChildren = await resolveChildren(headDirOid);
-  const remaining = new Set(headChildren.map((entry) => entry.path));
-  const result = {};
-  let commitsWalked = 0;
-  let prefetchWindows = 0;
-  const walkStart = performance.now();
-  outer: for (let windowStart = 0; windowStart < commits.length && remaining.size > 0; windowStart += PREFETCH_WINDOW2) {
-    const windowEnd = Math.min(windowStart + PREFETCH_WINDOW2, commits.length);
-    const prefetchEnd = Math.min(windowEnd + 1, commits.length);
-    prefetchWindows++;
-    const dirOids = await Promise.all(
-      commits.slice(windowStart, prefetchEnd).map((commit) => resolveDirOid(commit.commit.tree))
-    );
-    await Promise.all(
-      [...new Set(dirOids)].map((dirOid) => resolveChildren(dirOid))
-    );
-    for (let i = windowStart; i < windowEnd; i++) {
-      if (remaining.size === 0) break outer;
-      const commit = commits[i];
-      if (!commit) break outer;
-      commitsWalked++;
-      const parentSha = commit.commit.parent[0];
-      const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
-      if (parentSha && !parentCommit) break outer;
-      const [dirOid, parentDirOid] = await Promise.all([
-        resolveDirOid(commit.commit.tree),
-        parentCommit ? resolveDirOid(parentCommit.commit.tree) : Promise.resolve(null)
-      ]);
-      if (dirOid === parentDirOid) continue;
-      const [children, parentChildren] = await Promise.all([
-        resolveChildren(dirOid),
-        resolveChildren(parentDirOid)
-      ]);
-      const childByName = new Map(
-        children.map((entry) => [entry.path, entry.oid])
-      );
-      const parentChildByName = new Map(
-        parentChildren.map((entry) => [entry.path, entry.oid])
-      );
-      for (const name of remaining) {
-        if (childByName.get(name) !== parentChildByName.get(name)) {
-          result[name] = summarizeCommit(commit);
-        }
-      }
-      for (const name of Object.keys(result)) {
-        remaining.delete(name);
-      }
-    }
-  }
-  hooks?.onNote?.(
-    `getLastCommitsForTree: walked ${commitsWalked}/${commits.length} commits across ${prefetchWindows} prefetch windows in ${(performance.now() - walkStart).toFixed(1)}ms, ${dirOidByCommitTree.size} unique tree lookups, ${remaining.size} entries never resolved`
-  );
-  hooks?.resultCache?.set(cacheKey, result);
-  return result;
+	const treePath = options.treePath ?? "";
+	const depth = options.depth ?? 400;
+	const commits = await runStep(hooks, `getCommitLog depth=${depth}`, () => getCommitLog(repo, {
+		ref: options.ref,
+		depth
+	}, hooks));
+	hooks?.onNote?.(`getLastCommitsForTree: ${commits.length} commits in log`);
+	const head = commits[0];
+	if (!head) return {};
+	const cacheKey = `last-commits:${repo.gitdir}:${head.oid}:${treePath}`;
+	const cachedResult = hooks?.resultCache?.get(cacheKey);
+	if (cachedResult) {
+		hooks?.onNote?.("getLastCommitsForTree: result-cache HIT, skipping history walk");
+		return cachedResult;
+	}
+	hooks?.onNote?.("getLastCommitsForTree: result-cache MISS, walking history");
+	const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
+	const dirOidByCommitTree = /* @__PURE__ */ new Map();
+	const childrenByDirOid = /* @__PURE__ */ new Map();
+	async function resolveDirOid(commitTreeOid) {
+		const cached = dirOidByCommitTree.get(commitTreeOid);
+		if (cached !== void 0) return cached;
+		const entry = await findTreeEntry(repo, commitTreeOid, treePath);
+		const dirOid = entry?.type === "tree" ? entry.oid : null;
+		dirOidByCommitTree.set(commitTreeOid, dirOid);
+		return dirOid;
+	}
+	async function resolveChildren(dirOid) {
+		if (dirOid === null) return [];
+		const cached = childrenByDirOid.get(dirOid);
+		if (cached) return cached;
+		const children = await listTreeEntries(repo, dirOid, treePath);
+		childrenByDirOid.set(dirOid, children);
+		return children;
+	}
+	const headDirOid = await resolveDirOid(head.commit.tree);
+	if (headDirOid === null) return {};
+	const headChildren = await resolveChildren(headDirOid);
+	const remaining = new Set(headChildren.map((entry) => entry.path));
+	const result = {};
+	let commitsWalked = 0;
+	let prefetchWindows = 0;
+	const walkStart = performance.now();
+	outer: for (let windowStart = 0; windowStart < commits.length && remaining.size > 0; windowStart += PREFETCH_WINDOW) {
+		const windowEnd = Math.min(windowStart + PREFETCH_WINDOW, commits.length);
+		const prefetchEnd = Math.min(windowEnd + 1, commits.length);
+		prefetchWindows++;
+		const dirOids = await Promise.all(commits.slice(windowStart, prefetchEnd).map((commit) => resolveDirOid(commit.commit.tree)));
+		await Promise.all([...new Set(dirOids)].map((dirOid) => resolveChildren(dirOid)));
+		for (let i = windowStart; i < windowEnd; i++) {
+			if (remaining.size === 0) break outer;
+			const commit = commits[i];
+			if (!commit) break outer;
+			commitsWalked++;
+			const parentSha = commit.commit.parent[0];
+			const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
+			if (parentSha && !parentCommit) break outer;
+			const [dirOid, parentDirOid] = await Promise.all([resolveDirOid(commit.commit.tree), parentCommit ? resolveDirOid(parentCommit.commit.tree) : Promise.resolve(null)]);
+			if (dirOid === parentDirOid) continue;
+			const [children, parentChildren] = await Promise.all([resolveChildren(dirOid), resolveChildren(parentDirOid)]);
+			const childByName = new Map(children.map((entry) => [entry.path, entry.oid]));
+			const parentChildByName = new Map(parentChildren.map((entry) => [entry.path, entry.oid]));
+			for (const name of remaining) if (childByName.get(name) !== parentChildByName.get(name)) result[name] = summarizeCommit(commit);
+			for (const name of Object.keys(result)) remaining.delete(name);
+		}
+	}
+	hooks?.onNote?.(`getLastCommitsForTree: walked ${commitsWalked}/${commits.length} commits across ${prefetchWindows} prefetch windows in ${(performance.now() - walkStart).toFixed(1)}ms, ${dirOidByCommitTree.size} unique tree lookups, ${remaining.size} entries never resolved`);
+	hooks?.resultCache?.set(cacheKey, result);
+	return result;
 }
-
-// src/ops/merge.ts
-import git3 from "isomorphic-git";
+//#endregion
+//#region src/ops/merge.ts
+/**
+* Cheap pre-merge check: do both branches exist, and is this a fast-forward?
+* `canMerge`/`fastForward` are the only fields this actually determines —
+* `hasConflicts`/`conflictingFiles` are NOT a real content-conflict check
+* (isomorphic-git's `git.merge` doesn't expose a dry-run), they only ever
+* reflect "one of the branches couldn't be resolved" (`canMerge: false`).
+* Real merge conflicts are only discoverable by actually attempting the
+* merge.
+*/
 async function analyzeMerge(repo, sourceBranch, targetBranch) {
-  assertSafeBranchName(sourceBranch);
-  assertSafeBranchName(targetBranch);
-  try {
-    const [sourceOid, targetOid] = await Promise.all([
-      git3.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
-      git3.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
-    ]);
-    const isDescendant = sourceOid === targetOid || await git3.isDescendent({
-      ...repo,
-      oid: sourceOid,
-      ancestor: targetOid
-    });
-    return {
-      canMerge: true,
-      hasConflicts: false,
-      conflictingFiles: [],
-      fastForward: isDescendant
-    };
-  } catch (err) {
-    if (err?.code !== "NotFoundError") {
-      throw err;
-    }
-    return {
-      canMerge: false,
-      hasConflicts: true,
-      conflictingFiles: [],
-      fastForward: false
-    };
-  }
+	assertSafeBranchName(sourceBranch);
+	assertSafeBranchName(targetBranch);
+	try {
+		const [sourceOid, targetOid] = await Promise.all([git.resolveRef({
+			...repo,
+			ref: qualifyBranchRef(sourceBranch)
+		}), git.resolveRef({
+			...repo,
+			ref: qualifyBranchRef(targetBranch)
+		})]);
+		return {
+			canMerge: true,
+			hasConflicts: false,
+			conflictingFiles: [],
+			fastForward: sourceOid === targetOid || await git.isDescendent({
+				...repo,
+				oid: sourceOid,
+				ancestor: targetOid
+			})
+		};
+	} catch (err) {
+		if (err?.code !== "NotFoundError") throw err;
+		return {
+			canMerge: false,
+			hasConflicts: true,
+			conflictingFiles: [],
+			fastForward: false
+		};
+	}
 }
+/**
+* Attempt a fast-forward merge directly against the bare repo: when source is
+* a descendant of target, just move the target ref — no worktree, no new
+* commit. Returns null when the merge is not a fast-forward (callers fall
+* back to a real three-way merge, which needs a worktree). Serialize with a
+* per-repo lock: resolve → writeRef is not atomic.
+*/
 async function fastForwardMerge(repo, sourceBranch, targetBranch) {
-  assertSafeBranchName(sourceBranch);
-  assertSafeBranchName(targetBranch);
-  const [sourceOid, targetOid] = await Promise.all([
-    git3.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
-    git3.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
-  ]);
-  if (sourceOid === targetOid || await git3.isDescendent({ ...repo, oid: targetOid, ancestor: sourceOid })) {
-    return { success: true, commitSha: targetOid };
-  }
-  const isFF = await git3.isDescendent({
-    ...repo,
-    oid: sourceOid,
-    ancestor: targetOid
-  });
-  if (!isFF) return null;
-  await git3.writeRef({
-    ...repo,
-    ref: `refs/heads/${targetBranch}`,
-    value: sourceOid,
-    force: true
-  });
-  return { success: true, commitSha: sourceOid };
+	assertSafeBranchName(sourceBranch);
+	assertSafeBranchName(targetBranch);
+	const [sourceOid, targetOid] = await Promise.all([git.resolveRef({
+		...repo,
+		ref: `refs/heads/${sourceBranch}`
+	}), git.resolveRef({
+		...repo,
+		ref: `refs/heads/${targetBranch}`
+	})]);
+	if (sourceOid === targetOid || await git.isDescendent({
+		...repo,
+		oid: targetOid,
+		ancestor: sourceOid
+	})) return {
+		success: true,
+		commitSha: targetOid
+	};
+	if (!await git.isDescendent({
+		...repo,
+		oid: sourceOid,
+		ancestor: targetOid
+	})) return null;
+	await git.writeRef({
+		...repo,
+		ref: `refs/heads/${targetBranch}`,
+		value: sourceOid,
+		force: true
+	});
+	return {
+		success: true,
+		commitSha: sourceOid
+	};
 }
-
-// src/ops/submodules.ts
+//#endregion
+//#region src/ops/submodules.ts
+/** Git config values: comments outside quotes, quoted whitespace, and Git's escapes. */
 function parseValue(raw) {
-  let value = "";
-  let spaces = "";
-  let quoted = false;
-  const escapes = {
-    n: "\n",
-    t: "	",
-    b: "\b",
-    "\\": "\\",
-    '"': '"'
-  };
-  for (let i = 0; i < raw.length; i++) {
-    const c = raw.charAt(i);
-    if (c === "\\") {
-      const escaped = escapes[raw.charAt(++i)];
-      if (escaped === void 0) return null;
-      value += spaces + escaped;
-      spaces = "";
-    } else if (c === '"') {
-      value += spaces;
-      spaces = "";
-      quoted = !quoted;
-    } else if (!quoted && (c === "#" || c === ";")) break;
-    else if (!quoted && /\s/.test(c)) {
-      if (value) spaces += c;
-    } else {
-      value += spaces + c;
-      spaces = "";
-    }
-  }
-  return quoted ? null : value;
+	let value = "";
+	let spaces = "";
+	let quoted = false;
+	const escapes = {
+		n: "\n",
+		t: "	",
+		b: "\b",
+		"\\": "\\",
+		"\"": "\""
+	};
+	for (let i = 0; i < raw.length; i++) {
+		const c = raw.charAt(i);
+		if (c === "\\") {
+			const escaped = escapes[raw.charAt(++i)];
+			if (escaped === void 0) return null;
+			value += spaces + escaped;
+			spaces = "";
+		} else if (c === "\"") {
+			value += spaces;
+			spaces = "";
+			quoted = !quoted;
+		} else if (!quoted && (c === "#" || c === ";")) break;
+		else if (!quoted && /\s/.test(c)) {
+			if (value) spaces += c;
+		} else {
+			value += spaces + c;
+			spaces = "";
+		}
+	}
+	return quoted ? null : value;
 }
+/**
+* Read only submodule path/url records. Never expands includes, executes Git
+* commands, or fetches URLs. Ambiguous paths and malformed records are ignored.
+*/
 function parseGitmodules(content) {
-  const sections = /* @__PURE__ */ new Map();
-  let current;
-  const lines = [];
-  let pending = "";
-  for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
-    const slashes = /\\+$/.exec(line)?.[0].length ?? 0;
-    if (slashes % 2 === 1) pending += line.slice(0, -1);
-    else {
-      lines.push(pending + line);
-      pending = "";
-    }
-  }
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || /^[#;]/.test(trimmed)) continue;
-    if (trimmed.startsWith("[")) {
-      const match = /^\[submodule\s+"((?:[^"\\]|\\["\\])*)"\]\s*(?:[#;].*)?$/i.exec(
-        trimmed
-      );
-      current = void 0;
-      if (!match?.[1]) continue;
-      const name = match[1].replace(/\\(["\\])/g, "$1");
-      current = sections.get(name) ?? { name };
-      sections.set(name, current);
-      continue;
-    }
-    if (!current) continue;
-    const field = /^(path|url)\s*=\s*(.*)$/i.exec(trimmed);
-    if (!field?.[1] || field[2] === void 0) continue;
-    const key = field[1].toLowerCase();
-    const value = parseValue(field[2]);
-    if (value === null) delete current[key];
-    else current[key] = value;
-  }
-  const valid = [...sections.values()].filter(
-    (s) => !!s.name && !!s.path && !!s.url && ![...s.path + s.url].some(
-      (c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127
-    ) && !s.path.startsWith("/") && !s.path.includes("\\") && s.path.split("/").every(
-      (p) => p !== "" && p !== "." && p !== ".." && p.toLowerCase() !== ".git"
-    )
-  );
-  const counts = /* @__PURE__ */ new Map();
-  for (const s of valid) counts.set(s.path, (counts.get(s.path) ?? 0) + 1);
-  return valid.filter((s) => counts.get(s.path) === 1);
+	const sections = /* @__PURE__ */ new Map();
+	let current;
+	const lines = [];
+	let pending = "";
+	for (const line of content.replace(/\r\n/g, "\n").split("\n")) if ((/\\+$/.exec(line)?.[0].length ?? 0) % 2 === 1) pending += line.slice(0, -1);
+	else {
+		lines.push(pending + line);
+		pending = "";
+	}
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || /^[#;]/.test(trimmed)) continue;
+		if (trimmed.startsWith("[")) {
+			const match = /^\[submodule\s+"((?:[^"\\]|\\["\\])*)"\]\s*(?:[#;].*)?$/i.exec(trimmed);
+			current = void 0;
+			if (!match?.[1]) continue;
+			const name = match[1].replace(/\\(["\\])/g, "$1");
+			current = sections.get(name) ?? { name };
+			sections.set(name, current);
+			continue;
+		}
+		if (!current) continue;
+		const field = /^(path|url)\s*=\s*(.*)$/i.exec(trimmed);
+		if (!field?.[1] || field[2] === void 0) continue;
+		const key = field[1].toLowerCase();
+		const value = parseValue(field[2]);
+		if (value === null) delete current[key];
+		else current[key] = value;
+	}
+	const valid = [...sections.values()].filter((s) => !!s.name && !!s.path && !!s.url && ![...s.path + s.url].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127) && !s.path.startsWith("/") && !s.path.includes("\\") && s.path.split("/").every((p) => p !== "" && p !== "." && p !== ".." && p.toLowerCase() !== ".git"));
+	const counts = /* @__PURE__ */ new Map();
+	for (const s of valid) counts.set(s.path, (counts.get(s.path) ?? 0) + 1);
+	return valid.filter((s) => counts.get(s.path) === 1);
 }
+/** The root .gitmodules at this exact revision; absent/oversized config yields no links. */
 async function getSubmodules(repo, ref, hooks) {
-  let bytes;
-  try {
-    bytes = await getFileContent(repo, ".gitmodules", ref, hooks);
-  } catch (error) {
-    if (error instanceof GitPathNotFoundError) return [];
-    throw error;
-  }
-  if (bytes.length > 1024 * 1024) return [];
-  return parseGitmodules(new TextDecoder().decode(bytes));
+	let bytes;
+	try {
+		bytes = await getFileContent(repo, ".gitmodules", ref, hooks);
+	} catch (error) {
+		if (error instanceof GitPathNotFoundError) return [];
+		throw error;
+	}
+	if (bytes.length > 1048576) return [];
+	return parseGitmodules(new TextDecoder().decode(bytes));
 }
-export {
-  BANNER_WALK_DEPTH,
-  HISTORY_WALK_DEPTH,
-  MAX_DIFF_TEXT_BYTES,
-  analyzeMerge,
-  assertBranchExists,
-  assertSafeBranchName,
-  authorNow,
-  commitFilesToBare,
-  createBranchFrom,
-  deleteBranchByName,
-  deleteFileFromBare,
-  deleteFromTree,
-  fastForwardMerge,
-  findTreeEntry,
-  getBlob,
-  getCommit,
-  getCommitDiff,
-  getCommitHistory,
-  getCommitLog,
-  getDiffBetweenRefs,
-  getFileContent,
-  getFileHistory,
-  getLastCommitsForTree,
-  getSubmodules,
-  getTreeFromRef,
-  listBranches,
-  listTags,
-  listTreeEntries,
-  parseGitmodules,
-  peelToCommit,
-  resolveCommit,
-  resolveLooseRefFast,
-  resultKeyPrefixes,
-  summarizeCommit,
-  upsertTree,
-  withPackedWrites,
-  writeCommitToBare
-};
+//#endregion
+export { BANNER_WALK_DEPTH, HISTORY_WALK_DEPTH, MAX_DIFF_TEXT_BYTES, analyzeMerge, assertBranchExists, assertSafeBranchName, authorNow, commitFilesToBare, createBranchFrom, deleteBranchByName, deleteFileFromBare, deleteFromTree, fastForwardMerge, findTreeEntry, getBlob, getCommit, getCommitDiff, getCommitHistory, getCommitLog, getDiffBetweenRefs, getFileContent, getFileHistory, getLastCommitsForTree, getSubmodules, getTreeFromRef, listBranches, listTags, listTreeEntries, parseGitmodules, peelToCommit, resolveCommit, resolveLooseRefFast, resultKeyPrefixes, summarizeCommit, upsertTree, withPackedWrites, writeCommitToBare };
+
 //# sourceMappingURL=ops.js.map