git-fs-s3 0.3.13 → 0.4.0

package/dist/chunk-RMAOPWHJ.js

@@ -0,0 +1,38 @@
+// src/pack-files.ts
+var PACK_FILE_KINDS = [
+  "pack",
+  "idx",
+  "keep",
+  "bitmap",
+  "rev"
+];
+var READABLE_PACK_FILE_KINDS = /* @__PURE__ */ new Set([
+  "pack",
+  "idx"
+]);
+var KNOWN_KINDS = new Set(PACK_FILE_KINDS);
+function isPackFileKind(value) {
+  return KNOWN_KINDS.has(value);
+}
+function parsePackFileName(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const kind = name.slice(dot + 1);
+  if (!isPackFileKind(kind)) return null;
+  return { base: name.slice(0, dot), kind, name };
+}
+function packFileName(base, kind) {
+  return `${base}.${kind}`;
+}
+function parsePackDirectory(entries) {
+  return entries.map(parsePackFileName).filter((file) => file !== null);
+}
+
+export {
+  PACK_FILE_KINDS,
+  READABLE_PACK_FILE_KINDS,
+  parsePackFileName,
+  packFileName,
+  parsePackDirectory
+};
+//# sourceMappingURL=chunk-RMAOPWHJ.js.map

package/dist/chunk-RMAOPWHJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pack-files.ts"],"sourcesContent":["/**\n * Typed view of a git `objects/pack` directory listing.\n *\n * Every pack is a set of sibling files sharing one base name\n * (`pack-<hash>.pack`, `.idx`, and optionally `.keep`/`.bitmap`/`.rev`).\n * Parsing names once into {@link PackFileName} lets callers group, filter and\n * rename by kind instead of re-matching filename strings at each call site.\n *\n * Edge-compatible: no node: imports.\n */\n\n/** Every file kind git writes into `objects/pack`. */\nexport const PACK_FILE_KINDS = [\n\t\"pack\",\n\t\"idx\",\n\t\"keep\",\n\t\"bitmap\",\n\t\"rev\",\n] as const;\nexport type PackFileKind = (typeof PACK_FILE_KINDS)[number];\n\n/** Kinds isomorphic-git actually reads; the rest are git-CLI accelerators. */\nexport const READABLE_PACK_FILE_KINDS: ReadonlySet<PackFileKind> = new Set([\n\t\"pack\",\n\t\"idx\",\n]);\n\nexport interface PackFileName {\n\t/** Shared base of a pack's sibling files, e.g. `pack-1a2b…`. */\n\treadonly base: string;\n\treadonly kind: PackFileKind;\n\t/** The file name as listed, e.g. `pack-1a2b….idx`. */\n\treadonly name: string;\n}\n\nconst KNOWN_KINDS: ReadonlySet<string> = new Set(PACK_FILE_KINDS);\n\nfunction isPackFileKind(value: string): value is PackFileKind {\n\treturn KNOWN_KINDS.has(value);\n}\n\n/** Parse a pack-directory entry; `null` for anything git didn't put there. */\nexport function parsePackFileName(name: string): PackFileName | null {\n\tconst dot = name.lastIndexOf(\".\");\n\tif (dot <= 0) return null;\n\tconst kind = name.slice(dot + 1);\n\tif (!isPackFileKind(kind)) return null;\n\treturn { base: name.slice(0, dot), kind, name };\n}\n\n/** File name of the `kind` sibling of the pack with this base name. */\nexport function packFileName(base: string, kind: PackFileKind): string {\n\treturn `${base}.${kind}`;\n}\n\n/** Parse a directory listing, dropping entries that aren't pack files. */\nexport function parsePackDirectory(entries: readonly string[]): PackFileName[] {\n\treturn entries\n\t\t.map(parsePackFileName)\n\t\t.filter((file): file is PackFileName => file !== null);\n}\n"],"mappings":";AAYO,IAAM,kBAAkB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD;AAIO,IAAM,2BAAsD,oBAAI,IAAI;AAAA,EAC1E;AAAA,EACA;AACD,CAAC;AAUD,IAAM,cAAmC,IAAI,IAAI,eAAe;AAEhE,SAAS,eAAe,OAAsC;AAC7D,SAAO,YAAY,IAAI,KAAK;AAC7B;AAGO,SAAS,kBAAkB,MAAmC;AACpE,QAAM,MAAM,KAAK,YAAY,GAAG;AAChC,MAAI,OAAO,EAAG,QAAO;AACrB,QAAM,OAAO,KAAK,MAAM,MAAM,CAAC;AAC/B,MAAI,CAAC,eAAe,IAAI,EAAG,QAAO;AAClC,SAAO,EAAE,MAAM,KAAK,MAAM,GAAG,GAAG,GAAG,MAAM,KAAK;AAC/C;AAGO,SAAS,aAAa,MAAc,MAA4B;AACtE,SAAO,GAAG,IAAI,IAAI,IAAI;AACvB;AAGO,SAAS,mBAAmB,SAA4C;AAC9E,SAAO,QACL,IAAI,iBAAiB,EACrB,OAAO,CAAC,SAA+B,SAAS,IAAI;AACvD;","names":[]}

package/dist/{chunk-3BDDEGAP.js → chunk-Z4656PGE.js}

@@ -22,8 +22,11 @@ function decodeFileContent(content) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
 async function listLooseBranches(repo) {
+  return listLooseRefNames(repo, "refs/heads");
+}
+async function listLooseRefNames(repo, dir) {
   if (!hasRecursiveFileLister(repo.fs)) return null;
-  const names = await repo.fs.listFilesRecursively(`${repo.gitdir}/refs/heads`);
+  const names = await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`);
   return names.filter(isSafeBranchName);
 }
 async function readPackedBranches(repo) {
@@ -116,10 +119,11 @@ async function assertBranchExists(repo, name) {
 
 export {
   assertSafeBranchName,
+  listLooseRefNames,
   resolveLooseRefFast,
   listBranches,
   createBranchFrom,
   deleteBranchByName,
   assertBranchExists
 };
-//# sourceMappingURL=chunk-3BDDEGAP.js.map
+//# sourceMappingURL=chunk-Z4656PGE.js.map

package/dist/chunk-Z4656PGE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ops/branch.ts"],"sourcesContent":["import git from \"isomorphic-git\";\nimport { GitInvalidRequestError } from \"../git-errors.js\";\nimport { isSafeBranchName } from \"../refs.js\";\nimport type { Repo } from \"./types.js\";\n\nexport interface Branch {\n\tname: string;\n\tcommit: string;\n\tisDefault: boolean;\n}\n\n/**\n * Defense in depth for every branch-name argument below: `git.deleteBranch`\n * and raw resolveRef/writeRef reads don't validate ref names internally the\n * way `git.branch` does (see refs.ts) — guard at the point the primitives are\n * actually called, not just at an API boundary far above.\n */\nexport function assertSafeBranchName(name: string): void {\n\tif (!isSafeBranchName(name)) {\n\t\tthrow new GitInvalidRequestError(`Invalid branch name: ${name}`);\n\t}\n}\n\nconst FULL_SHA_RE = /^[0-9a-f]{40}$/i;\n\ntype RecursiveFileLister = {\n\tlistFilesRecursively(dirpath: string): Promise<string[]>;\n};\n\nfunction hasRecursiveFileLister(\n\tfs: Repo[\"fs\"],\n): fs is Repo[\"fs\"] & RecursiveFileLister {\n\treturn (\n\t\ttypeof fs === \"object\" &&\n\t\tfs !== null &&\n\t\t\"listFilesRecursively\" in fs &&\n\t\ttypeof (fs as Partial<RecursiveFileLister>).listFilesRecursively ===\n\t\t\t\"function\"\n\t);\n}\n\ntype PromisesFs = {\n\treadFile(path: string, encoding: \"utf8\"): Promise<string | Uint8Array>;\n};\n\n// Repo.fs is typed as isomorphic-git's own fs union (promise- or\n// callback-based) since that's what git.readTree's signature allows, but\n// every fs this package actually constructs (git-fs.ts) is promise-based —\n// this just keeps the callback-style branch honest instead of crashing on\n// it. Shared by every loose-ref fast path below instead of each repeating\n// the same cast + presence check.\nfunction getPromisesFs(fs: Repo[\"fs\"]): PromisesFs | null {\n\tconst promises = (fs as { promises?: PromisesFs }).promises;\n\treturn promises ?? null;\n}\n\nfunction decodeFileContent(content: string | Uint8Array): string {\n\treturn typeof content === \"string\"\n\t\t? content\n\t\t: new TextDecoder().decode(content);\n}\n\n/**\n * Lists loose branch names without isomorphic-git's recursive readdir/stat\n * traversal. Object stores already return only leaf keys in a recursive LIST,\n * so this is one request regardless of branch-name nesting. Ordinary\n * filesystems retain isomorphic-git's implementation and packed refs remain\n * supported there.\n */\nasync function listLooseBranches(repo: Repo): Promise<string[] | null> {\n\treturn listLooseRefNames(repo, \"refs/heads\");\n}\n\n/**\n * Loose ref names under `dir` (e.g. `refs/tags`) in one recursive listing,\n * or `null` when the fs can't list recursively (use isomorphic-git's walk).\n */\nexport async function listLooseRefNames(\n\trepo: Repo,\n\tdir: \"refs/heads\" | \"refs/tags\",\n): Promise<string[] | null> {\n\tif (!hasRecursiveFileLister(repo.fs)) return null;\n\tconst names = await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`);\n\treturn names.filter(isSafeBranchName);\n}\n\n/** Read packed branch refs so the object-store fast path preserves Git semantics. */\nasync function readPackedBranches(repo: Repo): Promise<Map<string, string>> {\n\tif (!hasRecursiveFileLister(repo.fs)) return new Map();\n\tconst promisesFs = getPromisesFs(repo.fs);\n\tif (!promisesFs) return new Map();\n\ttry {\n\t\tconst content = await promisesFs.readFile(\n\t\t\t`${repo.gitdir}/packed-refs`,\n\t\t\t\"utf8\",\n\t\t);\n\t\tconst refs = new Map<string, string>();\n\t\tfor (const line of decodeFileContent(content).split(\"\\n\")) {\n\t\t\tconst match = /^([0-9a-f]{40}) refs\\/heads\\/(.+)$/i.exec(line);\n\t\t\tif (match?.[1] && match[2] && isSafeBranchName(match[2])) {\n\t\t\t\trefs.set(match[2], match[1]);\n\t\t\t}\n\t\t}\n\t\treturn refs;\n\t} catch {\n\t\treturn new Map();\n\t}\n}\n\n/** Read the symbolic HEAD directly when the object-store fs is available. */\nasync function getCurrentLooseBranch(repo: Repo): Promise<string | null> {\n\tif (!hasRecursiveFileLister(repo.fs)) return null;\n\tconst promisesFs = getPromisesFs(repo.fs);\n\tif (!promisesFs) return null;\n\ttry {\n\t\tconst content = await promisesFs.readFile(`${repo.gitdir}/HEAD`, \"utf8\");\n\t\tconst head = decodeFileContent(content).trim();\n\t\tconst match = /^ref: refs\\/heads\\/(.+)$/.exec(head);\n\t\treturn match?.[1] && isSafeBranchName(match[1]) ? match[1] : null;\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/**\n * Resolve a fully-qualified ref's oid with one read instead of isomorphic-\n * git's own `resolveRef`, which does a stat *then* a read for a loose ref\n * (two round trips against object storage) — wasteful specifically here,\n * where the caller already knows the ref exists (it came from a directory\n * listing moments earlier). Reads the loose file directly and falls back to\n * `git.resolveRef` only when that doesn't pan out (packed-refs, or anything\n * else the plain-loose-file assumption doesn't cover), so correctness for\n * those cases is unchanged — this only removes the redundant round trip on\n * the common path.\n */\nexport async function resolveLooseRefFast(\n\trepo: Repo,\n\tref: string,\n): Promise<string> {\n\tconst promisesFs = getPromisesFs(repo.fs);\n\tif (promisesFs) {\n\t\ttry {\n\t\t\tconst content = await promisesFs.readFile(\n\t\t\t\t`${repo.gitdir}/${ref}`,\n\t\t\t\t\"utf8\",\n\t\t\t);\n\t\t\tconst oid = decodeFileContent(content).trim();\n\t\t\tif (FULL_SHA_RE.test(oid)) return oid;\n\t\t} catch {\n\t\t\t// Not a loose file (packed-refs, or genuinely absent) — fall through.\n\t\t}\n\t}\n\treturn git.resolveRef({ ...repo, ref });\n}\n\n/** All branches with their tip commits; [] for an empty repository. */\nexport async function listBranches(repo: Repo): Promise<Branch[]> {\n\ttry {\n\t\tconst [looseBranches, looseCurrentBranch, packedBranches] =\n\t\t\tawait Promise.all([\n\t\t\t\tlistLooseBranches(repo),\n\t\t\t\tgetCurrentLooseBranch(repo),\n\t\t\t\treadPackedBranches(repo),\n\t\t\t]);\n\t\tconst branches =\n\t\t\tlooseBranches === null\n\t\t\t\t? await git.listBranches(repo)\n\t\t\t\t: [...new Set([...looseBranches, ...packedBranches.keys()])].sort();\n\t\tconst currentBranch =\n\t\t\tlooseBranches === null\n\t\t\t\t? await git\n\t\t\t\t\t\t.currentBranch({ ...repo, fullname: false })\n\t\t\t\t\t\t.catch(() => null)\n\t\t\t\t: looseCurrentBranch;\n\n\t\treturn Promise.all(\n\t\t\tbranches.map(async (branch) => {\n\t\t\t\tconst packedCommit = packedBranches.get(branch);\n\t\t\t\treturn {\n\t\t\t\t\tname: branch,\n\t\t\t\t\tcommit:\n\t\t\t\t\t\tpackedCommit && !looseBranches?.includes(branch)\n\t\t\t\t\t\t\t? packedCommit\n\t\t\t\t\t\t\t: await resolveLooseRefFast(repo, `refs/heads/${branch}`),\n\t\t\t\t\tisDefault: branch === currentBranch,\n\t\t\t\t};\n\t\t\t}),\n\t\t);\n\t} catch (err: unknown) {\n\t\tif ((err as { code?: string }).code === \"NotFoundError\") return [];\n\t\tthrow err;\n\t}\n}\n\n/** Create `name` pointing at the tip of `startPoint` (no checkout). */\nexport async function createBranchFrom(\n\trepo: Repo,\n\tname: string,\n\tstartPoint = \"main\",\n): Promise<void> {\n\tassertSafeBranchName(name);\n\tassertSafeBranchName(startPoint);\n\tconst object = await resolveLooseRefFast(repo, `refs/heads/${startPoint}`);\n\tawait git.branch({ ...repo, ref: name, checkout: false, object });\n}\n\n/** Delete a branch ref (validated — deleteBranch has no internal ref check). */\nexport async function deleteBranchByName(\n\trepo: Repo,\n\tname: string,\n): Promise<void> {\n\tassertSafeBranchName(name);\n\tawait git.deleteBranch({ ...repo, ref: name });\n}\n\n/** Throws (NotFoundError) unless the branch resolves. */\nexport async function assertBranchExists(\n\trepo: Repo,\n\tname: string,\n): Promise<void> {\n\tassertSafeBranchName(name);\n\tawait resolveLooseRefFast(repo, `refs/heads/${name}`);\n}\n"],"mappings":"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","names":[]}

package/dist/http.cjs

@@ -111,15 +111,24 @@ var BAD_REF_COMPONENT = (
   // biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what git's own ref-name rules reject — this needs to match the same range.
   /(^|[/.])([/.]|$)|^@$|@\{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/
 );
+var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
 function isSafeFullRefName(ref) {
   if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/tags/")) {
     return false;
   }
   return !BAD_REF_COMPONENT.test(ref);
 }
+function isSafeBranchName(name) {
+  if (!name || name.startsWith("refs/") || name === "HEAD") return false;
+  if (FULL_SHA_RE.test(name)) return false;
+  return !BAD_REF_COMPONENT.test(name);
+}
 
 // src/ops/branch.ts
-var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+var FULL_SHA_RE2 = /^[0-9a-f]{40}$/i;
+function hasRecursiveFileLister(fs) {
+  return typeof fs === "object" && fs !== null && "listFilesRecursively" in fs && typeof fs.listFilesRecursively === "function";
+}
 function getPromisesFs(fs) {
   const promises = fs.promises;
   return promises ?? null;
@@ -127,6 +136,48 @@ function getPromisesFs(fs) {
 function decodeFileContent(content) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
+async function listLooseBranches(repo) {
+  return listLooseRefNames(repo, "refs/heads");
+}
+async function listLooseRefNames(repo, dir) {
+  if (!hasRecursiveFileLister(repo.fs)) return null;
+  const names = await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`);
+  return names.filter(isSafeBranchName);
+}
+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 {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function getCurrentLooseBranch(repo) {
+  if (!hasRecursiveFileLister(repo.fs)) return null;
+  const promisesFs = getPromisesFs(repo.fs);
+  if (!promisesFs) return null;
+  try {
+    const content = await promisesFs.readFile(`${repo.gitdir}/HEAD`, "utf8");
+    const head = decodeFileContent(content).trim();
+    const match = /^ref: refs\/heads\/(.+)$/.exec(head);
+    return match?.[1] && isSafeBranchName(match[1]) ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
 async function resolveLooseRefFast(repo, ref) {
   const promisesFs = getPromisesFs(repo.fs);
   if (promisesFs) {
@@ -136,12 +187,36 @@ async function resolveLooseRefFast(repo, ref) {
         "utf8"
       );
       const oid = decodeFileContent(content).trim();
-      if (FULL_SHA_RE.test(oid)) return oid;
+      if (FULL_SHA_RE2.test(oid)) return oid;
     } catch {
     }
   }
   return import_isomorphic_git.default.resolveRef({ ...repo, ref });
 }
+async function listBranches(repo) {
+  try {
+    const [looseBranches, looseCurrentBranch, packedBranches] = await Promise.all([
+      listLooseBranches(repo),
+      getCurrentLooseBranch(repo),
+      readPackedBranches(repo)
+    ]);
+    const branches = looseBranches === null ? await import_isomorphic_git.default.listBranches(repo) : [.../* @__PURE__ */ new Set([...looseBranches, ...packedBranches.keys()])].sort();
+    const currentBranch = looseBranches === null ? await import_isomorphic_git.default.currentBranch({ ...repo, fullname: false }).catch(() => null) : 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;
+  }
+}
 
 // src/http/pkt-line.ts
 var FLUSH = new Uint8Array([
@@ -201,34 +276,24 @@ function rawFs(repo) {
 
 // src/http/info-refs.ts
 async function listAllRefs(repo, defaultBranch = "main") {
-  const [branches, tags, headSymref] = await Promise.all([
-    import_isomorphic_git2.default.listBranches(repo),
-    import_isomorphic_git2.default.listTags(repo),
-    // Wrap with Promise.resolve so a mock/stub returning undefined doesn't crash .then()
-    Promise.resolve(import_isomorphic_git2.default.currentBranch({ ...repo, fullname: true })).then((cb) => cb ?? `refs/heads/${defaultBranch}`).catch(() => `refs/heads/${defaultBranch}`)
-  ]);
-  const [branchRefs, tagRefs] = await Promise.all([
-    Promise.all(
-      branches.map(async (branch) => {
-        try {
-          const oid = await resolveLooseRefFast(repo, `refs/heads/${branch}`);
-          return { name: `refs/heads/${branch}`, oid };
-        } catch {
-          return null;
-        }
-      })
-    ),
-    Promise.all(
-      tags.map(async (tag) => {
-        try {
-          const oid = await resolveLooseRefFast(repo, `refs/tags/${tag}`);
-          return { name: `refs/tags/${tag}`, oid };
-        } catch {
-          return null;
-        }
-      })
+  const [branches, tagNames] = await Promise.all([
+    listBranches(repo),
+    listLooseRefNames(repo, "refs/tags").then(
+      (names) => names ?? import_isomorphic_git2.default.listTags(repo)
     )
   ]);
+  const tagRefs = await Promise.all(
+    tagNames.map(async (tag) => {
+      const name = `refs/tags/${tag}`;
+      return resolveLooseRefFast(repo, name).then((oid) => ({ name, oid })).catch(() => null);
+    })
+  );
+  const branchRefs = branches.map((b) => ({
+    name: `refs/heads/${b.name}`,
+    oid: b.commit
+  }));
+  const defaultRef = branches.find((b) => b.isDefault);
+  const headSymref = defaultRef ? `refs/heads/${defaultRef.name}` : await Promise.resolve(import_isomorphic_git2.default.currentBranch({ ...repo, fullname: true })).then((cb) => cb ?? `refs/heads/${defaultBranch}`).catch(() => `refs/heads/${defaultBranch}`);
   const headOid = branchRefs.find((r) => r?.name === headSymref)?.oid ?? await import_isomorphic_git2.default.resolveRef({ ...repo, ref: "HEAD" }).catch(() => null);
   const refs = [];
   if (headOid) refs.push({ name: "HEAD", oid: headOid });
@@ -281,7 +346,8 @@ async function handleInfoRefs(repo, options, hooks) {
 var import_isomorphic_git3 = __toESM(require("isomorphic-git"), 1);
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var MISSING_OBJECT_RETRY_DELAY_MS = 200;
-async function collectReachableOids(repo, startOids, hooks, haveOids) {
+async function collectReachableOids(repo, startOids, hooks, haveOids, options) {
+  const verifyBlobs = options?.verifyBlobs ?? true;
   const have = haveOids instanceof Set ? haveOids : new Set(haveOids ?? []);
   const seen = /* @__PURE__ */ new Set();
   let complete = true;
@@ -289,23 +355,26 @@ async function collectReachableOids(repo, startOids, hooks, haveOids) {
   async function readAndVisitChildren(oid) {
     const obj = await import_isomorphic_git3.default.readObject({ ...repo, oid });
     seen.add(oid);
-    let children = [];
+    const children = [];
     if (obj.type === "commit") {
-      const { commit } = await import_isomorphic_git3.default.readCommit({ ...repo, oid });
-      children = [commit.tree, ...commit.parent];
+      const commit = obj.object;
+      children.push([commit.tree, "tree"]);
+      for (const parent of commit.parent) children.push([parent, "commit"]);
     } else if (obj.type === "tree") {
-      const { tree } = await import_isomorphic_git3.default.readTree({ ...repo, oid });
-      children = tree.map((e) => e.oid);
+      const tree = obj.object;
+      for (const entry of tree) {
+        if (entry.type === "commit") continue;
+        children.push([entry.oid, entry.type]);
+      }
     } else if (obj.type === "tag") {
-      const { tag } = await import_isomorphic_git3.default.readTag({ ...repo, oid });
-      children = [tag.object];
+      children.push([obj.object.object, void 0]);
     }
-    await Promise.all(children.map(visit));
+    await Promise.all(children.map(([child, type]) => visit(child, type)));
   }
-  function visit(oid) {
+  function visit(oid, type) {
     const existing = promises.get(oid);
     if (existing) return existing;
-    if (have.has(oid)) {
+    if (have.has(oid) || type === "blob" && !verifyBlobs) {
       seen.add(oid);
       const p2 = Promise.resolve();
       promises.set(oid, p2);
@@ -327,7 +396,7 @@ async function collectReachableOids(repo, startOids, hooks, haveOids) {
     promises.set(oid, p);
     return p;
   }
-  await Promise.all(startOids.map(visit));
+  await Promise.all(startOids.map((oid) => visit(oid)));
   return { oids: Array.from(seen), complete };
 }
 
@@ -336,6 +405,193 @@ var import_isomorphic_git5 = __toESM(require("isomorphic-git"), 1);
 
 // src/http/repack.ts
 var import_isomorphic_git4 = __toESM(require("isomorphic-git"), 1);
+
+// src/pack-files.ts
+var PACK_FILE_KINDS = [
+  "pack",
+  "idx",
+  "keep",
+  "bitmap",
+  "rev"
+];
+var KNOWN_KINDS = new Set(PACK_FILE_KINDS);
+function isPackFileKind(value) {
+  return KNOWN_KINDS.has(value);
+}
+function parsePackFileName(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const kind = name.slice(dot + 1);
+  if (!isPackFileKind(kind)) return null;
+  return { base: name.slice(0, dot), kind, name };
+}
+function packFileName(base, kind) {
+  return `${base}.${kind}`;
+}
+function parsePackDirectory(entries) {
+  return entries.map(parsePackFileName).filter((file) => file !== null);
+}
+
+// src/http/pack-reuse.ts
+var OBJ_OFS_DELTA = 6;
+var OBJ_REF_DELTA = 7;
+var OID_BYTES = 20;
+var PACK_TRAILER_BYTES = 20;
+var IDX_V2 = {
+  magic: 4285812579,
+  version: 2,
+  headerBytes: 8,
+  fanoutEntries: 256,
+  /** Offsets with this bit set index the 64-bit large-offset table. */
+  largeOffsetFlag: 2147483648
+};
+function readPackIndex(idx) {
+  const view = new DataView(idx.buffer, idx.byteOffset, idx.byteLength);
+  const namesStart = IDX_V2.headerBytes + IDX_V2.fanoutEntries * 4;
+  if (idx.byteLength < namesStart || view.getUint32(0) !== IDX_V2.magic || view.getUint32(4) !== IDX_V2.version) {
+    return null;
+  }
+  const count = view.getUint32(namesStart - 4);
+  const crcStart = namesStart + count * OID_BYTES;
+  const offsetsStart = crcStart + count * 4;
+  if (idx.byteLength < offsetsStart + count * 4) return null;
+  const entries = [];
+  for (let i = 0; i < count; i++) {
+    const offset = view.getUint32(offsetsStart + i * 4);
+    if (offset & IDX_V2.largeOffsetFlag) return null;
+    const at = namesStart + i * OID_BYTES;
+    entries.push({ oid: toHex(idx.subarray(at, at + OID_BYTES)), offset });
+  }
+  return entries;
+}
+function indexPack(idx, pack) {
+  const located = readPackIndex(idx);
+  if (!located) return null;
+  located.sort((a, b) => a.offset - b.offset);
+  const entries = /* @__PURE__ */ new Map();
+  const oidAtOffset = /* @__PURE__ */ new Map();
+  const packEnd = pack.byteLength - PACK_TRAILER_BYTES;
+  for (let i = 0; i < located.length; i++) {
+    const { oid, offset } = located[i];
+    const end = located[i + 1]?.offset ?? packEnd;
+    entries.set(oid, { pack, start: offset, end });
+    oidAtOffset.set(offset, oid);
+  }
+  return { entries, oidAtOffset };
+}
+function readEntryHeader(bytes, start) {
+  let byte = bytes[start];
+  const type = byte >> 4 & 7;
+  let size = byte & 15;
+  let shift = 4;
+  let at = start + 1;
+  while (byte & 128) {
+    byte = bytes[at++];
+    size += (byte & 127) * 2 ** shift;
+    shift += 7;
+  }
+  return { type, size, length: at - start };
+}
+function encodeEntryHeader(type, size) {
+  const bytes = [];
+  let rest = Math.floor(size / 16);
+  bytes.push((rest > 0 ? 128 : 0) | type << 4 | size % 16);
+  while (rest > 0) {
+    const low = rest % 128;
+    rest = Math.floor(rest / 128);
+    bytes.push((rest > 0 ? 128 : 0) | low);
+  }
+  return new Uint8Array(bytes);
+}
+function readOfsDeltaOffset(bytes, start) {
+  let at = start;
+  let byte = bytes[at++];
+  let distance = byte & 127;
+  while (byte & 128) {
+    byte = bytes[at++];
+    distance = (distance + 1) * 128 + (byte & 127);
+  }
+  return { distance, length: at - start };
+}
+function reusableEntry(entry, indexed) {
+  const { pack, start, end } = entry;
+  const header = readEntryHeader(pack, start);
+  const bodyStart = start + header.length;
+  if (header.type === OBJ_REF_DELTA) {
+    return {
+      bytes: pack.subarray(start, end),
+      baseOid: toHex(pack.subarray(bodyStart, bodyStart + OID_BYTES))
+    };
+  }
+  if (header.type !== OBJ_OFS_DELTA) {
+    return { bytes: pack.subarray(start, end), baseOid: null };
+  }
+  const { distance, length } = readOfsDeltaOffset(pack, bodyStart);
+  const baseOid = indexed.oidAtOffset.get(start - distance);
+  if (baseOid === void 0) return null;
+  return {
+    bytes: concat(
+      encodeEntryHeader(OBJ_REF_DELTA, header.size),
+      fromHex(baseOid),
+      pack.subarray(bodyStart + length, end)
+    ),
+    baseOid
+  };
+}
+async function buildPackFromExistingPacks(repo, oids) {
+  const fsp = rawFs(repo);
+  const packDir = `${repo.gitdir}/objects/pack`;
+  const packs = parsePackDirectory(
+    await fsp.readdir(packDir).catch(() => [])
+  ).filter((file) => file.kind === "pack");
+  const indexes = [];
+  for (const { base } of packs) {
+    const [pack, idx] = await Promise.all([
+      fsp.readFile(`${packDir}/${packFileName(base, "pack")}`),
+      fsp.readFile(`${packDir}/${packFileName(base, "idx")}`)
+    ]).catch(() => [null, null]);
+    if (!(pack instanceof Uint8Array) || !(idx instanceof Uint8Array)) {
+      return null;
+    }
+    const indexed = indexPack(idx, pack);
+    if (!indexed) return null;
+    indexes.push(indexed);
+  }
+  const locate = (oid) => {
+    for (const indexed of indexes) {
+      const entry = indexed.entries.get(oid);
+      if (entry) return reusableEntry(entry, indexed);
+    }
+    return null;
+  };
+  const ordered = [];
+  const done = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Set();
+  const visit = (oid) => {
+    if (done.has(oid)) return true;
+    if (pending.has(oid)) return false;
+    const entry = locate(oid);
+    if (!entry) return false;
+    pending.add(oid);
+    if (entry.baseOid !== null && !visit(entry.baseOid)) return false;
+    pending.delete(oid);
+    done.add(oid);
+    ordered.push(entry.bytes);
+    return true;
+  };
+  for (const oid of oids) {
+    if (!visit(oid)) return null;
+  }
+  const header = new Uint8Array(12);
+  header.set(encodeUtf8("PACK"), 0);
+  const view = new DataView(header.buffer);
+  view.setUint32(4, 2);
+  view.setUint32(8, ordered.length);
+  const body = concat(header, ...ordered);
+  return concat(body, fromHex(await sha1(body)));
+}
+
+// src/http/repack.ts
 var PACK_OBJECT_TYPE_BITS = {
   commit: 16,
   tree: 32,
@@ -419,13 +675,13 @@ async function buildVerifiedPack(oids, objects) {
   return concat(packBody, trailer);
 }
 var REPACK_PACK_COUNT_THRESHOLD = 4;
+async function readPackDirectory(repo) {
+  const entries = await rawFs(repo).readdir(`${repo.gitdir}/objects/pack`).catch(() => []);
+  return parsePackDirectory(entries);
+}
 async function countPacks(repo) {
-  try {
-    const entries = await rawFs(repo).readdir(`${repo.gitdir}/objects/pack`);
-    return entries.filter((f) => f.endsWith(".pack")).length;
-  } catch {
-    return 0;
-  }
+  const files = await readPackDirectory(repo);
+  return files.filter((file) => file.kind === "pack").length;
 }
 async function repackRepository(repo, options, hooks) {
   const threshold = options?.threshold ?? REPACK_PACK_COUNT_THRESHOLD;
@@ -448,41 +704,48 @@ async function repackRepository(repo, options, hooks) {
       )
     )).filter((oid) => oid !== null);
     if (tipOids.length === 0) return [];
-    const { oids, complete } = await collectReachableOids(repo, tipOids, hooks);
-    if (!complete || oids.length === 0) return [];
-    const objects = await readAndVerifyObjects(repo, oids);
-    const packBuffer = await buildVerifiedPack(oids, objects);
+    const { oids: reachable, complete } = await collectReachableOids(
+      repo,
+      tipOids,
+      hooks
+    );
+    if (!complete || reachable.length === 0) return [];
     const packDir = `${repo.gitdir}/objects/pack`;
+    const packBuffer = await buildPackFromExistingPacks(repo, reachable) ?? await buildVerifiedPack(
+      reachable,
+      await readAndVerifyObjects(repo, reachable)
+    );
     await fsp.mkdir(packDir, { recursive: true });
     const newBase = `pack-${Date.now()}`;
-    const newPackFile = `${newBase}.pack`;
-    const newIdxFile = `${newBase}.idx`;
+    const newPackFile = packFileName(newBase, "pack");
     await fsp.writeFile(`${packDir}/${newPackFile}`, packBuffer);
     const { oids: indexedOids } = await import_isomorphic_git4.default.indexPack({
       ...repo,
       dir: packDir,
       filepath: newPackFile
     });
-    const expected = new Set(oids);
     const indexed = new Set(indexedOids);
-    if (indexed.size !== expected.size || oids.some((oid) => !indexed.has(oid))) {
-      await fsp.unlink(`${packDir}/${newPackFile}`).catch(() => {
-      });
-      await fsp.unlink(`${packDir}/${newIdxFile}`).catch(() => {
-      });
+    if (reachable.some((oid) => !indexed.has(oid))) {
+      await Promise.all(
+        ["pack", "idx"].map(
+          (kind) => fsp.unlink(`${packDir}/${packFileName(newBase, kind)}`).catch(() => {
+          })
+        )
+      );
       throw new Error(
-        "repack: indexed pack's oid set didn't match the verified reachable set \u2014 aborting"
+        "repack: indexed pack is missing reachable objects \u2014 aborting"
       );
     }
-    const allEntries = await fsp.readdir(packDir).catch(() => []);
-    const staleFiles = allEntries.filter(
-      (f) => f !== newPackFile && f !== newIdxFile && (f.endsWith(".pack") || f.endsWith(".idx") || f.endsWith(".keep"))
+    const stale = (await readPackDirectory(repo)).filter(
+      (file) => file.base !== newBase
     );
     await Promise.all(
-      staleFiles.map((f) => fsp.unlink(`${packDir}/${f}`).catch(() => {
-      }))
+      stale.map(
+        (file) => fsp.unlink(`${packDir}/${file.name}`).catch(() => {
+        })
+      )
     );
-    return staleFiles.map((f) => `objects/pack/${f}`);
+    return stale.map((file) => `objects/pack/${file.name}`);
   } catch (err) {
     hooks?.onWarn?.("repack failed (non-fatal)", err);
     return [];
@@ -717,7 +980,7 @@ async function handleUploadPack(repo, body, options, hooks) {
       "readdir objects/pack",
       () => rawFs(repo).readdir(packDirPath).catch(() => [])
     );
-    const packNames = entries.filter((f) => f.endsWith(".pack"));
+    const packNames = parsePackDirectory(entries).filter((file) => file.kind === "pack").map((file) => file.name);
     const packName = packNames[0];
     if (packNames.length === 1 && packName !== void 0) {
       const packData = await runStep(
@@ -739,27 +1002,34 @@ async function handleUploadPack(repo, body, options, hooks) {
   if (options?.beforeWalk) {
     await runStep(hooks, "beforeWalk", options.beforeWalk);
   }
-  const { oids: wantOids } = await runStep(
-    hooks,
-    "collectReachableOids(wants)",
-    () => collectReachableOids(repo, wants, hooks)
-  );
-  let oids = wantOids;
+  let haveSet;
   if (haves.length > 0) {
     const { oids: haveOids } = await runStep(
       hooks,
       "collectReachableOids(haves)",
-      () => collectReachableOids(repo, haves, hooks)
+      () => collectReachableOids(repo, haves, hooks, void 0, {
+        verifyBlobs: false
+      })
     );
-    const haveSet = new Set(haveOids);
-    oids = oids.filter((oid) => !haveSet.has(oid));
+    haveSet = new Set(haveOids);
   }
-  const { packfile } = await runStep(
+  const { oids: wantOids } = await runStep(
+    hooks,
+    "collectReachableOids(wants)",
+    () => collectReachableOids(repo, wants, hooks, haveSet, {
+      verifyBlobs: false
+    })
+  );
+  const oids = haveSet ? wantOids.filter((oid) => !haveSet.has(oid)) : wantOids;
+  const reused = await runStep(
     hooks,
-    `packObjects (${oids.length} oids)`,
-    () => import_isomorphic_git6.default.packObjects({ ...repo, oids })
+    `reuse pack entries (${oids.length} oids)`,
+    () => buildPackFromExistingPacks(repo, oids)
   );
-  const packBytes = packfile instanceof Uint8Array ? packfile : new Uint8Array(packfile ?? []);
+  const packBytes = reused ?? await runStep(hooks, `packObjects (${oids.length} oids)`, async () => {
+    const { packfile } = await import_isomorphic_git6.default.packObjects({ ...repo, oids });
+    return packfile instanceof Uint8Array ? packfile : new Uint8Array(packfile ?? []);
+  });
   return {
     status: 200,
     headers: {