git-fs-s3 0.3.12 → 0.4.0

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 [];
@@ -556,6 +819,20 @@ async function checkRefCas(repo, refName, oldOid) {
     reason: "non-fast-forward, ref updated by another push"
   };
 }
+async function collectExistingRefTips(repo) {
+  const [branches, tags] = await Promise.all([
+    import_isomorphic_git5.default.listBranches(repo),
+    import_isomorphic_git5.default.listTags(repo)
+  ]);
+  const refs = [
+    ...branches.map((b) => `refs/heads/${b}`),
+    ...tags.map((t) => `refs/tags/${t}`)
+  ];
+  const oids = await Promise.all(
+    refs.map((ref) => import_isomorphic_git5.default.resolveRef({ ...repo, ref }).catch(() => null))
+  );
+  return new Set(oids.filter((oid) => oid !== null));
+}
 async function validateRefUpdates(repo, refUpdates) {
   return Promise.all(
     refUpdates.map(
@@ -619,7 +896,10 @@ async function applyReceivePack(repo, parsed, options, hooks) {
   );
   const newTips = acceptedUpdates.filter((update) => update.newOid !== ZERO_OID).map((update) => update.newOid);
   if (newTips.length > 0) {
-    const haveOids = acceptedUpdates.map((update) => update.oldOid).filter((oid) => oid !== ZERO_OID);
+    const haveOids = await collectExistingRefTips(repo);
+    for (const update of acceptedUpdates) {
+      if (update.oldOid !== ZERO_OID) haveOids.add(update.oldOid);
+    }
     const { complete } = await collectReachableOids(
       repo,
       newTips,
@@ -700,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(
@@ -722,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: {