git-fs-s3 0.3.5

package/dist/http.cjs

@@ -0,0 +1,692 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/http/index.ts
+var http_exports = {};
+__export(http_exports, {
+  FLUSH: () => FLUSH,
+  REPACK_PACK_COUNT_THRESHOLD: () => REPACK_PACK_COUNT_THRESHOLD,
+  applyReceivePack: () => applyReceivePack,
+  applyRefUpdates: () => applyRefUpdates,
+  collectReachableOids: () => collectReachableOids,
+  ensureRepoInitialized: () => ensureRepoInitialized,
+  handleInfoRefs: () => handleInfoRefs,
+  handleUploadPack: () => handleUploadPack,
+  indexIncomingPack: () => indexIncomingPack,
+  listAllRefs: () => listAllRefs,
+  parsePktLines: () => parsePktLines,
+  parseReceivePackBody: () => parseReceivePackBody,
+  pktLine: () => pktLine,
+  pktLineBuffer: () => pktLineBuffer,
+  rawFs: () => rawFs,
+  receivePackResponse: () => receivePackResponse,
+  repackRepository: () => repackRepository,
+  sideBandPackfile: () => sideBandPackfile
+});
+module.exports = __toCommonJS(http_exports);
+
+// src/http/info-refs.ts
+var import_isomorphic_git = __toESM(require("isomorphic-git"), 1);
+
+// src/edge-utils.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeUtf8(data) {
+  return textEncoder.encode(data);
+}
+function decodeUtf8(data) {
+  return textDecoder.decode(data);
+}
+function decodeAscii(data) {
+  let s = "";
+  for (let i = 0; i < data.length; i++)
+    s += String.fromCharCode(data[i]);
+  return s;
+}
+function concat(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+function toHex(data) {
+  let hex = "";
+  for (let i = 0; i < data.length; i++)
+    hex += data[i].toString(16).padStart(2, "0");
+  return hex;
+}
+async function sha1(data) {
+  const bytes = typeof data === "string" ? encodeUtf8(data) : data;
+  const hash = await globalThis.crypto.subtle.digest("SHA-1", bytes);
+  return toHex(new Uint8Array(hash));
+}
+async function deflate(data) {
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+
+// src/http/pkt-line.ts
+var FLUSH = new Uint8Array([
+  48,
+  48,
+  48,
+  48
+]);
+function pktLine(data) {
+  const body = encodeUtf8(data);
+  const len = (body.length + 4).toString(16).padStart(4, "0");
+  return concat(encodeUtf8(len), body);
+}
+function pktLineBuffer(body) {
+  const len = (body.length + 4).toString(16).padStart(4, "0");
+  return concat(encodeUtf8(len), body);
+}
+function parsePktLines(buf) {
+  const lines = [];
+  let pos = 0;
+  while (pos + 4 <= buf.length) {
+    const len = Number.parseInt(decodeAscii(buf.subarray(pos, pos + 4)), 16);
+    if (len === 0) {
+      lines.push(null);
+      pos += 4;
+    } else if (len >= 4) {
+      lines.push(decodeUtf8(buf.subarray(pos + 4, pos + len)));
+      pos += len;
+    } else {
+      break;
+    }
+  }
+  return lines;
+}
+var SIDE_BAND_MAX_CHUNK = 65515;
+function sideBandPackfile(packData) {
+  const parts = [];
+  for (let offset = 0; offset < packData.length; offset += SIDE_BAND_MAX_CHUNK) {
+    const chunk = packData.subarray(offset, offset + SIDE_BAND_MAX_CHUNK);
+    parts.push(pktLineBuffer(concat(new Uint8Array([1]), chunk)));
+  }
+  parts.push(FLUSH);
+  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 = "main") {
+  const [branches, tags, headOid, headSymref] = await Promise.all([
+    import_isomorphic_git.default.listBranches(repo),
+    import_isomorphic_git.default.listTags(repo),
+    import_isomorphic_git.default.resolveRef({ ...repo, ref: "HEAD" }).catch(() => null),
+    // Wrap with Promise.resolve so a mock/stub returning undefined doesn't crash .then()
+    Promise.resolve(import_isomorphic_git.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 import_isomorphic_git.default.resolveRef({
+            ...repo,
+            ref: `refs/heads/${branch}`
+          });
+          return { name: `refs/heads/${branch}`, oid };
+        } catch {
+          return null;
+        }
+      })
+    ),
+    Promise.all(
+      tags.map(async (tag) => {
+        try {
+          const oid = await import_isomorphic_git.default.resolveRef({
+            ...repo,
+            ref: `refs/tags/${tag}`
+          });
+          return { name: `refs/tags/${tag}`, oid };
+        } catch {
+          return null;
+        }
+      })
+    )
+  ]);
+  const refs = [];
+  if (headOid) refs.push({ name: "HEAD", oid: headOid });
+  for (const r of branchRefs) if (r) refs.push(r);
+  for (const r of tagRefs) if (r) refs.push(r);
+  return { refs, headSymref };
+}
+async function handleInfoRefs(repo, options, hooks) {
+  const { service } = options;
+  const agent = options.agent ?? "git-fs-s3";
+  const { refs, headSymref } = await runStep(
+    hooks,
+    "listAllRefs",
+    () => listAllRefs(repo, options.defaultBranch ?? "main")
+  );
+  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 parts = [pktLine(`# service=${service}
+`), FLUSH];
+  if (refs.length === 0) {
+    parts.push(
+      pktLine(
+        `0000000000000000000000000000000000000000 capabilities^{}\0${caps}
+`
+      )
+    );
+  } else {
+    let first = true;
+    for (const { name, oid } of refs) {
+      parts.push(
+        pktLine(first ? `${oid} ${name}\0${caps}
+` : `${oid} ${name}
+`)
+      );
+      first = false;
+    }
+  }
+  parts.push(FLUSH);
+  return {
+    status: 200,
+    headers: {
+      "Content-Type": `application/x-${service}-advertisement`,
+      "Cache-Control": "no-cache"
+    },
+    body: concat(...parts)
+  };
+}
+
+// src/http/reachability.ts
+var import_isomorphic_git2 = __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) {
+  const seen = /* @__PURE__ */ new Set();
+  let complete = true;
+  const promises = /* @__PURE__ */ new Map();
+  async function readAndVisitChildren(oid) {
+    const obj = await import_isomorphic_git2.default.readObject({ ...repo, oid });
+    seen.add(oid);
+    let children = [];
+    if (obj.type === "commit") {
+      const { commit } = await import_isomorphic_git2.default.readCommit({ ...repo, oid });
+      children = [commit.tree, ...commit.parent];
+    } else if (obj.type === "tree") {
+      const { tree } = await import_isomorphic_git2.default.readTree({ ...repo, oid });
+      children = tree.map((e) => e.oid);
+    } else if (obj.type === "tag") {
+      const { tag } = await import_isomorphic_git2.default.readTag({ ...repo, oid });
+      children = [tag.object];
+    }
+    await Promise.all(children.map(visit));
+  }
+  function visit(oid) {
+    const existing = promises.get(oid);
+    if (existing) return existing;
+    const p = (async () => {
+      try {
+        await readAndVisitChildren(oid);
+      } catch {
+        try {
+          await delay(MISSING_OBJECT_RETRY_DELAY_MS);
+          await readAndVisitChildren(oid);
+        } catch (err) {
+          complete = false;
+          hooks?.onWarn?.(`missing object ${oid}`, err);
+        }
+      }
+    })();
+    promises.set(oid, p);
+    return p;
+  }
+  await Promise.all(startOids.map(visit));
+  return { oids: Array.from(seen), complete };
+}
+
+// src/http/receive-pack.ts
+var import_isomorphic_git4 = __toESM(require("isomorphic-git"), 1);
+
+// src/refs.ts
+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(\/|$)/
+);
+function isSafeFullRefName(ref) {
+  if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/tags/")) {
+    return false;
+  }
+  return !BAD_REF_COMPONENT.test(ref);
+}
+
+// src/http/repack.ts
+var import_isomorphic_git3 = __toESM(require("isomorphic-git"), 1);
+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;
+  for (let i = 0; i < oids.length; i += BATCH_SIZE) {
+    const batch = oids.slice(i, i + BATCH_SIZE);
+    const entries = await Promise.all(
+      batch.map(async (oid) => {
+        const { type, object } = await import_isomorphic_git3.default.readObject({
+          ...repo,
+          oid,
+          format: "content"
+        });
+        const content = object;
+        const actualOid = await hashGitObject(type, content);
+        if (actualOid !== oid) {
+          throw new Error(
+            `repack: object ${oid} failed independent SHA-1 verification (recomputed ${actualOid}) \u2014 refusing to trust this read, aborting repack`
+          );
+        }
+        return { oid, type, content };
+      })
+    );
+    for (const { oid, type, content } of entries) {
+      objects.set(oid, { type, content });
+    }
+  }
+  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);
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+var REPACK_PACK_COUNT_THRESHOLD = 4;
+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;
+  }
+}
+async function repackRepository(repo, options, hooks) {
+  const threshold = options?.threshold ?? REPACK_PACK_COUNT_THRESHOLD;
+  const fsp = rawFs(repo);
+  try {
+    if (await countPacks(repo) < threshold) {
+      return [];
+    }
+    const [branches, tags] = await Promise.all([
+      import_isomorphic_git3.default.listBranches(repo),
+      import_isomorphic_git3.default.listTags(repo)
+    ]);
+    const refNames = [
+      ...branches.map((b) => `refs/heads/${b}`),
+      ...tags.map((t) => `refs/tags/${t}`)
+    ];
+    const tipOids = (await Promise.all(
+      refNames.map(
+        (ref) => import_isomorphic_git3.default.resolveRef({ ...repo, ref }).catch(() => null)
+      )
+    )).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 packDir = `${repo.gitdir}/objects/pack`;
+    await fsp.mkdir(packDir, { recursive: true });
+    const newBase = `pack-${Date.now()}`;
+    const newPackFile = `${newBase}.pack`;
+    const newIdxFile = `${newBase}.idx`;
+    await fsp.writeFile(`${packDir}/${newPackFile}`, packBuffer);
+    const { oids: indexedOids } = await import_isomorphic_git3.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(() => {
+      });
+      throw new Error(
+        "repack: indexed pack's oid set didn't match the verified reachable set \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"))
+    );
+    await Promise.all(
+      staleFiles.map((f) => fsp.unlink(`${packDir}/${f}`).catch(() => {
+      }))
+    );
+    return staleFiles.map((f) => `objects/pack/${f}`);
+  } catch (err) {
+    hooks?.onWarn?.("repack failed (non-fatal)", err);
+    return [];
+  }
+}
+
+// src/http/receive-pack.ts
+var ZERO_OID = "0".repeat(40);
+function parseReceivePackBody(body) {
+  const refUpdates = [];
+  let pos = 0;
+  while (pos + 4 <= body.length) {
+    const len = Number.parseInt(decodeAscii(body.subarray(pos, pos + 4)), 16);
+    if (len === 0) {
+      pos += 4;
+      break;
+    }
+    if (len < 4) break;
+    const line = decodeUtf8(body.subarray(pos + 4, pos + len)).replace(/\n$/, "").split("\0")[0];
+    pos += len;
+    const parts = (line ?? "").split(" ");
+    const [oldOid, newOid, refName] = parts;
+    if (oldOid && newOid && refName) {
+      refUpdates.push({ oldOid, newOid, refName });
+    }
+  }
+  return { refUpdates, packData: body.subarray(pos) };
+}
+async function ensureRepoInitialized(repo, defaultBranch = "main") {
+  const fsp = rawFs(repo);
+  try {
+    await fsp.stat(`${repo.gitdir}/HEAD`);
+  } catch {
+    await fsp.mkdir(repo.gitdir, { recursive: true }).catch(() => {
+    });
+    await import_isomorphic_git4.default.init({ ...repo, dir: repo.gitdir, defaultBranch, bare: true });
+  }
+}
+async function indexIncomingPack(repo, packData, hooks) {
+  if (packData.length < 4) return;
+  await runStep(hooks, "write + indexPack incoming pack", async () => {
+    const fsp = rawFs(repo);
+    const packDir = `${repo.gitdir}/objects/pack`;
+    await fsp.mkdir(packDir, { recursive: true });
+    const packName = `recv-${Date.now()}`;
+    await fsp.writeFile(`${packDir}/${packName}.pack`, packData);
+    await import_isomorphic_git4.default.indexPack({
+      ...repo,
+      dir: packDir,
+      filepath: `${packName}.pack`
+    });
+  });
+}
+async function applyRefUpdates(repo, refUpdates, hooks) {
+  return runStep(
+    hooks,
+    "apply ref updates",
+    () => Promise.all(
+      refUpdates.map(async ({ oldOid, newOid, refName }) => {
+        if (!isSafeFullRefName(refName)) {
+          return { refName, ok: false, reason: "invalid ref name" };
+        }
+        const currentOid = await import_isomorphic_git4.default.resolveRef({ ...repo, ref: refName }).catch(() => ZERO_OID);
+        if (currentOid !== oldOid) {
+          return {
+            refName,
+            ok: false,
+            reason: "non-fast-forward, ref updated by another push"
+          };
+        }
+        if (newOid === ZERO_OID) {
+          await import_isomorphic_git4.default.deleteRef({ ...repo, ref: refName }).catch(() => {
+          });
+        } else {
+          await import_isomorphic_git4.default.writeRef({
+            ...repo,
+            ref: refName,
+            value: newOid,
+            force: true
+          });
+        }
+        return { refName, ok: true };
+      })
+    )
+  );
+}
+function receivePackResponse(results) {
+  const responseBody = concat(
+    pktLine("unpack ok\n"),
+    ...results.map(
+      ({ refName, ok, reason }) => pktLine(ok ? `ok ${refName}
+` : `ng ${refName} ${reason}
+`)
+    ),
+    FLUSH
+  );
+  return {
+    status: 200,
+    headers: {
+      "Content-Type": "application/x-git-receive-pack-result",
+      "Cache-Control": "no-cache"
+    },
+    body: responseBody
+  };
+}
+async function applyReceivePack(repo, parsed, options, hooks) {
+  await ensureRepoInitialized(repo, options?.defaultBranch ?? "main");
+  await indexIncomingPack(repo, parsed.packData, hooks);
+  const results = await applyRefUpdates(repo, parsed.refUpdates, hooks);
+  const repackOptions = options?.repack;
+  const stalePackPaths = repackOptions === false ? [] : await runStep(
+    hooks,
+    "repack",
+    () => repackRepository(repo, repackOptions, hooks)
+  );
+  return { results, stalePackPaths };
+}
+
+// src/http/upload-pack.ts
+var import_isomorphic_git5 = __toESM(require("isomorphic-git"), 1);
+var ZERO_OID2 = "0".repeat(40);
+async function handleUploadPack(repo, body, options, hooks) {
+  const lines = parsePktLines(body);
+  const wants = [];
+  const haves = [];
+  let done = false;
+  for (const line of lines) {
+    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);
+      }
+    }
+    if (line.startsWith("done")) {
+      done = true;
+    }
+  }
+  if (wants.length === 0) {
+    return {
+      status: 200,
+      headers: { "Content-Type": "application/x-git-upload-pack-result" },
+      body: concat(pktLine("NAK\n"))
+    };
+  }
+  if (haves.length > 0 && !done) {
+    return {
+      status: 200,
+      headers: { "Content-Type": "application/x-git-upload-pack-result" },
+      body: concat(pktLine("NAK\n"))
+    };
+  }
+  if (haves.length === 0) {
+    const packDirPath = `${repo.gitdir}/objects/pack`;
+    const entries = await runStep(
+      hooks,
+      "readdir objects/pack",
+      () => rawFs(repo).readdir(packDirPath).catch(() => [])
+    );
+    const packNames = entries.filter((f) => f.endsWith(".pack"));
+    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))
+      };
+    }
+  }
+  if (options?.beforeWalk) {
+    await runStep(hooks, "beforeWalk", options.beforeWalk);
+  }
+  const { oids: wantOids } = await runStep(
+    hooks,
+    "collectReachableOids(wants)",
+    () => collectReachableOids(repo, wants, hooks)
+  );
+  let oids = wantOids;
+  if (haves.length > 0) {
+    const { oids: haveOids } = await runStep(
+      hooks,
+      "collectReachableOids(haves)",
+      () => collectReachableOids(repo, haves, hooks)
+    );
+    const haveSet = new Set(haveOids);
+    oids = oids.filter((oid) => !haveSet.has(oid));
+  }
+  const { packfile } = await runStep(
+    hooks,
+    `packObjects (${oids.length} oids)`,
+    () => import_isomorphic_git5.default.packObjects({ ...repo, oids })
+  );
+  const packBytes = 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))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLUSH,
+  REPACK_PACK_COUNT_THRESHOLD,
+  applyReceivePack,
+  applyRefUpdates,
+  collectReachableOids,
+  ensureRepoInitialized,
+  handleInfoRefs,
+  handleUploadPack,
+  indexIncomingPack,
+  listAllRefs,
+  parsePktLines,
+  parseReceivePackBody,
+  pktLine,
+  pktLineBuffer,
+  rawFs,
+  receivePackResponse,
+  repackRepository,
+  sideBandPackfile
+});
+//# sourceMappingURL=http.cjs.map