git-fs-s3 0.6.0 → 0.8.0

package/dist/http.js

@@ -1,23 +1,26 @@
 import {
-  packFileName,
-  parsePackDirectory
-} from "./chunk-RMAOPWHJ.js";
-import {
+  encodePack,
+  hashGitObject,
   listBranches,
   listLooseRefNames,
-  resolveLooseRefFast
-} from "./chunk-XNSZTA4Y.js";
+  packBaseName,
+  rawFs,
+  resolveLooseRefFast,
+  runStep,
+  storePack
+} from "./chunk-HBOJR5D3.js";
 import {
   concat,
   decodeAscii,
   decodeUtf8,
-  deflate,
   encodeUtf8,
   fromHex,
   isSafeFullRefName,
+  packFileName,
+  parsePackDirectory,
   sha1,
   toHex
-} from "./chunk-FIFWOMPM.js";
+} from "./chunk-PASVUPKR.js";
 
 // src/http/info-refs.ts
 import git from "isomorphic-git";
@@ -66,18 +69,6 @@ function sideBandPackfile(packData) {
   return concat(...parts);
 }
 
-// src/http/types.ts
-var runStep = (hooks, label, fn) => hooks?.step ? hooks.step(label, fn) : fn();
-function rawFs(repo) {
-  const fs = repo.fs;
-  if (!fs?.promises) {
-    throw new TypeError(
-      "This operation needs a promise fs (`fs.promises`) \u2014 node:fs and createGitFs both provide one"
-    );
-  }
-  return fs.promises;
-}
-
 // src/http/info-refs.ts
 async function listAllRefs(repo, defaultBranch) {
   const [branches, tagNames] = await Promise.all([
@@ -114,7 +105,7 @@ async function handleInfoRefs(repo, options, hooks) {
     () => listAllRefs(repo, options.defaultBranch)
   );
   const isUpload = service === "git-upload-pack";
-  const caps = isUpload ? `no-progress side-band-64k symref=HEAD:${headSymref} allow-tip-sha1-in-want allow-reachable-sha1-in-want agent=${agent}` : `delete-refs report-status no-done agent=${agent}`;
+  const caps = isUpload ? `no-progress side-band-64k symref=HEAD:${headSymref} allow-tip-sha1-in-want allow-reachable-sha1-in-want agent=${agent}` : `report-status delete-refs side-band-64k agent=${agent}`;
   const parts = [pktLine(`# service=${service}
 `), FLUSH];
   if (refs.length === 0) {
@@ -203,6 +194,45 @@ async function collectReachableOids(repo, startOids, hooks, haveOids, options) {
   await Promise.all(startOids.map((oid) => visit(oid)));
   return { oids: Array.from(seen), complete };
 }
+async function collectCommitAncestry(repo, startOids, stopAt) {
+  const commits = /* @__PURE__ */ new Set();
+  const boundary = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set();
+  let frontier = [...new Set(startOids)];
+  const BATCH = 50;
+  while (frontier.length > 0) {
+    const next = [];
+    for (let i = 0; i < frontier.length; i += BATCH) {
+      await Promise.all(
+        frontier.slice(i, i + BATCH).map(async (oid) => {
+          if (stopAt?.has(oid)) {
+            boundary.add(oid);
+            return;
+          }
+          const object = await git2.readObject({ ...repo, oid }).catch(() => null);
+          if (object?.type === "tag") {
+            const target = object.object.object;
+            if (!queued.has(target)) {
+              queued.add(target);
+              next.push(target);
+            }
+            return;
+          }
+          if (object?.type !== "commit") return;
+          commits.add(oid);
+          for (const parent of object.object.parent) {
+            if (!queued.has(parent)) {
+              queued.add(parent);
+              next.push(parent);
+            }
+          }
+        })
+      );
+    }
+    frontier = next;
+  }
+  return { commits, boundary };
+}
 
 // src/http/receive-pack.ts
 import git4 from "isomorphic-git";
@@ -370,30 +400,6 @@ async function buildPackFromExistingPacks(repo, oids) {
 }
 
 // src/http/repack.ts
-var PACK_OBJECT_TYPE_BITS = {
-  commit: 16,
-  tree: 32,
-  blob: 48,
-  tag: 64
-};
-function encodePackObjectHeader(type, length) {
-  const bytes = [];
-  let more = length > 15;
-  bytes.push(
-    (more ? 128 : 0) | PACK_OBJECT_TYPE_BITS[type] | length & 15
-  );
-  length >>>= 4;
-  while (more) {
-    more = length > 127;
-    bytes.push((more ? 128 : 0) | length & 127);
-    length >>>= 7;
-  }
-  return new Uint8Array(bytes);
-}
-async function hashGitObject(type, content) {
-  const prefix = encodeUtf8(`${type} ${content.length}\0`);
-  return sha1(concat(prefix, content));
-}
 async function readAndVerifyObjects(repo, oids) {
   const objects = /* @__PURE__ */ new Map();
   const BATCH_SIZE = 100;
@@ -422,36 +428,6 @@ async function readAndVerifyObjects(repo, oids) {
   }
   return objects;
 }
-async function buildVerifiedPack(oids, objects) {
-  const header = new Uint8Array(12);
-  const view = new DataView(header.buffer);
-  header.set(encodeUtf8("PACK"), 0);
-  view.setUint32(4, 2, false);
-  view.setUint32(8, oids.length, false);
-  const chunks = [header];
-  const BATCH_SIZE = 100;
-  for (let i = 0; i < oids.length; i += BATCH_SIZE) {
-    const batch = oids.slice(i, i + BATCH_SIZE);
-    const encoded = await Promise.all(
-      batch.map(async (oid) => {
-        const entry = objects.get(oid);
-        if (!entry) {
-          throw new Error(`repack: missing verified object for ${oid}`);
-        }
-        const objHeader = encodePackObjectHeader(
-          entry.type,
-          entry.content.length
-        );
-        const compressed = await deflate(entry.content);
-        return concat(objHeader, compressed);
-      })
-    );
-    chunks.push(...encoded);
-  }
-  const packBody = concat(...chunks);
-  const trailer = fromHex(await sha1(packBody));
-  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(() => []);
@@ -485,17 +461,30 @@ async function repackRepository(repo, options, hooks) {
     const { oids: reachable, complete } = await collectReachableOids(
       repo,
       tipOids,
-      hooks
+      hooks,
+      void 0,
+      { verifyBlobs: false }
     );
     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)
-    );
+    const packBuffer = await buildPackFromExistingPacks(repo, reachable) ?? await (async () => {
+      const objects = await readAndVerifyObjects(repo, reachable);
+      return encodePack(
+        reachable.map((oid) => {
+          const object = objects.get(oid);
+          if (!object) {
+            throw new Error(`repack: missing verified object for ${oid}`);
+          }
+          return object;
+        })
+      );
+    })();
     await fsp.mkdir(packDir, { recursive: true });
-    const newBase = `pack-${Date.now()}`;
+    const newBase = packBaseName(packBuffer);
     const newPackFile = packFileName(newBase, "pack");
+    const preexisting = (await readPackDirectory(repo)).some(
+      (file) => file.base === newBase
+    );
     await fsp.writeFile(`${packDir}/${newPackFile}`, packBuffer);
     const { oids: indexedOids } = await git3.indexPack({
       ...repo,
@@ -504,12 +493,13 @@ async function repackRepository(repo, options, hooks) {
     });
     const indexed = new Set(indexedOids);
     if (reachable.some((oid) => !indexed.has(oid))) {
-      await Promise.all(
-        ["pack", "idx"].map(
-          (kind) => fsp.unlink(`${packDir}/${packFileName(newBase, kind)}`).catch(() => {
-          })
-        )
-      );
+      if (!preexisting)
+        await Promise.all(
+          ["pack", "idx"].map(
+            (kind) => fsp.unlink(`${packDir}/${packFileName(newBase, kind)}`).catch(() => {
+            })
+          )
+        );
       throw new Error(
         "repack: indexed pack is missing reachable objects \u2014 aborting"
       );
@@ -517,12 +507,14 @@ async function repackRepository(repo, options, hooks) {
     const stale = (await readPackDirectory(repo)).filter(
       (file) => file.base !== newBase
     );
-    await Promise.all(
-      stale.map(
+    const unlinkAll = (files) => Promise.all(
+      files.map(
         (file) => fsp.unlink(`${packDir}/${file.name}`).catch(() => {
         })
       )
     );
+    await unlinkAll(stale.filter((file) => file.kind === "idx"));
+    await unlinkAll(stale.filter((file) => file.kind !== "idx"));
     return stale.map((file) => `objects/pack/${file.name}`);
   } catch (err) {
     hooks?.onWarn?.("repack failed (non-fatal)", err);
@@ -532,8 +524,10 @@ async function repackRepository(repo, options, hooks) {
 
 // src/http/receive-pack.ts
 var ZERO_OID = "0".repeat(40);
+var OID_RE = /^[0-9a-f]{40}$/;
 function parseReceivePackBody(body) {
   const refUpdates = [];
+  let capabilities;
   let pos = 0;
   while (pos + 4 <= body.length) {
     const len = Number.parseInt(decodeAscii(body.subarray(pos, pos + 4)), 16);
@@ -542,15 +536,21 @@ function parseReceivePackBody(body) {
       break;
     }
     if (len < 4) break;
-    const line = decodeUtf8(body.subarray(pos + 4, pos + len)).replace(/\n$/, "").split("\0")[0];
+    const [line, caps] = decodeUtf8(body.subarray(pos + 4, pos + len)).replace(/\n$/, "").split("\0");
+    if (capabilities === void 0) {
+      capabilities = (caps ?? "").split(" ").filter(Boolean);
+    }
     pos += len;
-    const parts = (line ?? "").split(" ");
-    const [oldOid, newOid, refName] = parts;
-    if (oldOid && newOid && refName) {
+    const [oldOid, newOid, refName] = (line ?? "").split(" ");
+    if (oldOid && newOid && refName && OID_RE.test(oldOid) && OID_RE.test(newOid)) {
       refUpdates.push({ oldOid, newOid, refName });
     }
   }
-  return { refUpdates, packData: body.subarray(pos) };
+  return {
+    refUpdates,
+    packData: body.subarray(pos),
+    capabilities: capabilities ?? []
+  };
 }
 async function ensureRepoInitialized(repo, defaultBranch) {
   const fsp = rawFs(repo);
@@ -568,17 +568,8 @@ async function indexIncomingPack(repo, packData, hooks) {
     hooks,
     "write + indexPack incoming pack",
     async () => {
-      const fsp = rawFs(repo);
-      const packDir = `${repo.gitdir}/objects/pack`;
-      await fsp.mkdir(packDir, { recursive: true });
-      const packName2 = `recv-${Date.now()}`;
-      await fsp.writeFile(`${packDir}/${packName2}.pack`, packData);
-      await git4.indexPack({
-        ...repo,
-        dir: packDir,
-        filepath: `${packName2}.pack`
-      });
-      return packName2;
+      const { base } = await storePack(repo, packData);
+      return base;
     }
   );
   return [
@@ -611,11 +602,27 @@ async function collectExistingRefTips(repo) {
   );
   return new Set(oids.filter((oid) => oid !== null));
 }
+async function currentBranchRef(repo) {
+  return git4.currentBranch({ ...repo, fullname: true }).then((ref) => ref ?? null).catch(() => null);
+}
 async function validateRefUpdates(repo, refUpdates) {
+  const headRef = await currentBranchRef(repo);
+  const seen = /* @__PURE__ */ new Set();
   return Promise.all(
-    refUpdates.map(
-      async ({ oldOid, refName }) => await checkRefCas(repo, refName, oldOid) ?? { refName, ok: true }
-    )
+    refUpdates.map(async ({ oldOid, newOid, refName }) => {
+      if (seen.has(refName)) {
+        return { refName, ok: false, reason: "duplicate ref update" };
+      }
+      seen.add(refName);
+      if (newOid === ZERO_OID && refName === headRef) {
+        return {
+          refName,
+          ok: false,
+          reason: "deletion of the current branch prohibited"
+        };
+      }
+      return await checkRefCas(repo, refName, oldOid) ?? { refName, ok: true };
+    })
   );
 }
 async function applyRefUpdates(repo, refUpdates, hooks) {
@@ -630,6 +637,16 @@ async function applyRefUpdates(repo, refUpdates, hooks) {
           await git4.deleteRef({ ...repo, ref: refName }).catch(() => {
           });
         } else {
+          if (refName.startsWith("refs/heads/")) {
+            const { type } = await git4.readObject({ ...repo, oid: newOid, format: "content" }).catch(() => ({ type: "missing" }));
+            if (type !== "commit") {
+              return {
+                refName,
+                ok: false,
+                reason: `branch must point at a commit, not a ${type}`
+              };
+            }
+          }
           await git4.writeRef({
             ...repo,
             ref: refName,
@@ -642,16 +659,21 @@ async function applyRefUpdates(repo, refUpdates, hooks) {
     )
   );
 }
-function receivePackResponse(results) {
-  const responseBody = concat(
-    pktLine("unpack ok\n"),
+function receivePackResponse(results, options) {
+  const capabilities = options?.capabilities ?? ["report-status"];
+  const report = capabilities.includes("report-status") ? concat(
+    pktLine(
+      options?.unpackError ? `unpack ${options.unpackError}
+` : "unpack ok\n"
+    ),
     ...results.map(
       ({ refName, ok, reason }) => pktLine(ok ? `ok ${refName}
 ` : `ng ${refName} ${reason}
 `)
     ),
     FLUSH
-  );
+  ) : new Uint8Array();
+  const responseBody = capabilities.includes("side-band-64k") && report.length > 0 ? sideBandPackfile(report) : report;
   return {
     status: 200,
     headers: {
@@ -667,11 +689,29 @@ async function applyReceivePack(repo, parsed, options, hooks) {
   const acceptedUpdates = parsed.refUpdates.filter(
     (_, index) => preflight[index]?.ok
   );
-  const incomingPackPaths = await indexIncomingPack(
-    repo,
-    acceptedUpdates.some((update) => update.newOid !== ZERO_OID) ? parsed.packData : new Uint8Array(),
-    hooks
+  const fsp = rawFs(repo);
+  const packDir = `${repo.gitdir}/objects/pack`;
+  const existingPacks = new Set(
+    await fsp.readdir(packDir).catch(() => [])
   );
+  let incomingPackPaths;
+  try {
+    incomingPackPaths = await indexIncomingPack(
+      repo,
+      acceptedUpdates.some((update) => update.newOid !== ZERO_OID) ? parsed.packData : new Uint8Array(),
+      hooks
+    );
+  } catch (err) {
+    hooks?.onWarn?.("receive-pack: incoming pack rejected", err);
+    return {
+      results: preflight.map(
+        (result2) => result2.ok ? { ...result2, ok: false, reason: "unpacker error" } : result2
+      ),
+      stalePackPaths: [],
+      unpackError: "index-pack failed"
+    };
+  }
+  const removableIncoming = incomingPackPaths.filter((path) => !existingPacks.has(path.slice(packDir.length + 1))).sort((a, b) => Number(b.endsWith(".idx")) - Number(a.endsWith(".idx")));
   const newTips = acceptedUpdates.filter((update) => update.newOid !== ZERO_OID).map((update) => update.newOid);
   if (newTips.length > 0) {
     const haveOids = await collectExistingRefTips(repo);
@@ -685,15 +725,13 @@ async function applyReceivePack(repo, parsed, options, hooks) {
       haveOids
     );
     if (!complete) {
-      await Promise.all(
-        incomingPackPaths.map(
-          (filepath) => rawFs(repo).unlink(filepath).catch(() => {
-          })
-        )
-      );
+      for (const filepath of removableIncoming) {
+        await fsp.unlink(filepath).catch(() => {
+        });
+      }
       return {
         results: preflight.map(
-          (result) => result.ok ? { ...result, ok: false, reason: "incomplete object graph" } : result
+          (result2) => result2.ok ? { ...result2, ok: false, reason: "incomplete object graph" } : result2
         ),
         stalePackPaths: []
       };
@@ -701,12 +739,12 @@ async function applyReceivePack(repo, parsed, options, hooks) {
   }
   const applied = await applyRefUpdates(repo, acceptedUpdates, hooks);
   const results = preflight.map(
-    (result, index) => result.ok ? applied.find(
+    (result2, index) => result2.ok ? applied.find(
       (entry) => entry.refName === parsed.refUpdates[index]?.refName
-    ) ?? result : result
+    ) ?? result2 : result2
   );
   const repackOptions = options.repack;
-  const stalePackPaths = repackOptions === false || !results.some((result) => result.ok) ? [] : await runStep(
+  const stalePackPaths = repackOptions === false || !results.some((result2) => result2.ok) ? [] : await runStep(
     hooks,
     "repack",
     () => repackRepository(repo, repackOptions, hooks)
@@ -717,87 +755,161 @@ async function applyReceivePack(repo, parsed, options, hooks) {
 // src/http/upload-pack.ts
 import git5 from "isomorphic-git";
 var ZERO_OID2 = "0".repeat(40);
-async function handleUploadPack(repo, body, options, hooks) {
-  const lines = parsePktLines(body);
+var OID_RE2 = /^[0-9a-f]{40}$/;
+var LOOSE_FANOUT_RE = /^[0-9a-f]{2}$/;
+function result(body) {
+  return {
+    status: 200,
+    headers: {
+      "Content-Type": "application/x-git-upload-pack-result",
+      "Cache-Control": "no-cache"
+    },
+    body
+  };
+}
+function errorResult(message) {
+  return result(pktLine(`ERR ${message}
+`));
+}
+function parseUploadPackRequest(body) {
   const wants = [];
   const haves = [];
   let done = false;
-  for (const line of lines) {
+  let invalid = false;
+  let capabilities;
+  for (const line of parsePktLines(body)) {
     if (!line) continue;
-    if (line.startsWith("want ")) {
-      wants.push(line.slice(5, 45));
-    }
-    if (line.startsWith("have ")) {
-      const sha = line.slice(5, 45);
-      if (sha !== ZERO_OID2) {
-        haves.push(sha);
+    const text = line.replace(/\n$/, "");
+    if (text.startsWith("want ")) {
+      const [oid, ...caps] = text.slice(5).split(" ");
+      if (capabilities === void 0) capabilities = caps.filter(Boolean);
+      if (oid !== void 0 && OID_RE2.test(oid)) wants.push(oid);
+      else invalid = true;
+    } else if (text.startsWith("have ")) {
+      const oid = text.slice(5).trim();
+      if (OID_RE2.test(oid)) {
+        if (oid !== ZERO_OID2) haves.push(oid);
+      } else {
+        invalid = true;
       }
-    }
-    if (line.startsWith("done")) {
+    } else if (text === "done") {
       done = true;
     }
   }
-  if (wants.length === 0) {
-    return {
-      status: 200,
-      headers: { "Content-Type": "application/x-git-upload-pack-result" },
-      body: concat(pktLine("NAK\n"))
-    };
+  return {
+    wants: [...new Set(wants)],
+    haves: [...new Set(haves)],
+    done,
+    capabilities: capabilities ?? [],
+    invalid
+  };
+}
+async function servableSinglePack(repo, wants, hooks) {
+  const fsp = rawFs(repo);
+  const objectsDir = `${repo.gitdir}/objects`;
+  const [objectEntries, packEntries] = await runStep(
+    hooks,
+    "readdir objects + objects/pack",
+    () => Promise.all([
+      fsp.readdir(objectsDir).catch(() => []),
+      fsp.readdir(`${objectsDir}/pack`).catch(() => [])
+    ])
+  );
+  if (objectEntries.some((name) => LOOSE_FANOUT_RE.test(name))) return null;
+  const packs = parsePackDirectory(packEntries).filter(
+    (file) => file.kind === "pack"
+  );
+  const pack = packs[0];
+  if (packs.length !== 1 || pack === void 0) return null;
+  const [packData, idxData] = await runStep(
+    hooks,
+    "read consolidated pack (fast path)",
+    () => Promise.all([
+      fsp.readFile(`${objectsDir}/pack/${pack.name}`),
+      fsp.readFile(`${objectsDir}/pack/${packFileName(pack.base, "idx")}`)
+    ]).catch(() => [null, null])
+  );
+  if (!(packData instanceof Uint8Array) || !(idxData instanceof Uint8Array)) {
+    return null;
   }
-  if (haves.length > 0 && !done) {
-    return {
-      status: 200,
-      headers: { "Content-Type": "application/x-git-upload-pack-result" },
-      body: concat(pktLine("NAK\n"))
-    };
+  const indexed = readPackIndex(idxData);
+  if (!indexed) return null;
+  const oids = new Set(indexed.map((entry) => entry.oid));
+  return wants.every((oid) => oids.has(oid)) ? packData : null;
+}
+async function handleUploadPack(repo, body, options, hooks) {
+  const request = parseUploadPackRequest(body);
+  if (request.invalid) {
+    return errorResult("upload-pack: protocol error, malformed object id");
   }
-  if (haves.length === 0) {
-    const packDirPath = `${repo.gitdir}/objects/pack`;
-    const entries = await runStep(
+  const { wants, haves, done, capabilities } = request;
+  const frame = (pack) => capabilities.includes("side-band-64k") || capabilities.includes("side-band") ? sideBandPackfile(pack) : concat(pack);
+  if (wants.length === 0 || haves.length > 0 && !done) {
+    return result(concat(pktLine("NAK\n")));
+  }
+  const { refs } = await runStep(
+    hooks,
+    "listAllRefs",
+    () => listAllRefs(repo, "HEAD")
+  );
+  const tips = new Set(refs.map((ref) => ref.oid));
+  const untipped = wants.filter((oid) => !tips.has(oid));
+  if (untipped.length > 0) {
+    const { commits } = await runStep(
       hooks,
-      "readdir objects/pack",
-      () => rawFs(repo).readdir(packDirPath).catch(() => [])
+      "verify wants reachable",
+      () => collectCommitAncestry(repo, [...tips])
     );
-    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(
-        hooks,
-        "read consolidated pack (fast path)",
-        () => rawFs(repo).readFile(`${packDirPath}/${packName}`)
-      );
-      const bytes = packData instanceof Uint8Array ? packData : new TextEncoder().encode(packData);
-      return {
-        status: 200,
-        headers: {
-          "Content-Type": "application/x-git-upload-pack-result",
-          "Cache-Control": "no-cache"
-        },
-        body: concat(pktLine("NAK\n"), sideBandPackfile(bytes))
-      };
+    const missing = untipped.find((oid) => !commits.has(oid));
+    if (missing !== void 0) {
+      return errorResult(`upload-pack: not our ref ${missing}`);
     }
   }
+  if (haves.length === 0) {
+    const pack = await servableSinglePack(repo, wants, hooks);
+    if (pack) return result(concat(pktLine("NAK\n"), frame(pack)));
+  }
   if (options?.beforeWalk) {
     await runStep(hooks, "beforeWalk", options.beforeWalk);
   }
   let haveSet;
   if (haves.length > 0) {
-    const { oids: haveOids } = await runStep(
-      hooks,
-      "collectReachableOids(haves)",
-      () => collectReachableOids(repo, haves, hooks, void 0, {
-        verifyBlobs: false
-      })
-    );
-    haveSet = new Set(haveOids);
+    haveSet = await runStep(hooks, "have boundary", async () => {
+      const { commits: clientCommits } = await collectCommitAncestry(
+        repo,
+        haves
+      );
+      const { boundary } = await collectCommitAncestry(
+        repo,
+        wants,
+        clientCommits
+      );
+      const boundaryTrees = await Promise.all(
+        [...boundary].map(async (oid) => {
+          const { commit } = await git5.readCommit({ ...repo, oid });
+          return commit.tree;
+        })
+      );
+      const { oids: boundaryObjects } = await collectReachableOids(
+        repo,
+        boundaryTrees,
+        hooks,
+        void 0,
+        { verifyBlobs: false }
+      );
+      return /* @__PURE__ */ new Set([...clientCommits, ...boundaryObjects]);
+    });
   }
-  const { oids: wantOids } = await runStep(
+  const { oids: wantOids, complete } = await runStep(
     hooks,
     "collectReachableOids(wants)",
     () => collectReachableOids(repo, wants, hooks, haveSet, {
       verifyBlobs: false
     })
   );
+  if (!complete) {
+    return errorResult("upload-pack: repository is missing objects");
+  }
   const oids = haveSet ? wantOids.filter((oid) => !haveSet.has(oid)) : wantOids;
   const reused = await runStep(
     hooks,
@@ -808,14 +920,7 @@ async function handleUploadPack(repo, body, options, hooks) {
     const { packfile } = await git5.packObjects({ ...repo, oids });
     return packfile instanceof Uint8Array ? packfile : new Uint8Array(packfile ?? []);
   });
-  return {
-    status: 200,
-    headers: {
-      "Content-Type": "application/x-git-upload-pack-result",
-      "Cache-Control": "no-cache"
-    },
-    body: concat(pktLine("NAK\n"), sideBandPackfile(packBytes))
-  };
+  return result(concat(pktLine("NAK\n"), frame(packBytes)));
 }
 export {
   FLUSH,