git-fs-s3 0.3.13 → 0.5.0

package/dist/http.cjs

@@ -1,793 +0,0 @@
-"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_git2 = __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;
-}
-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;
-}
-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/ops/branch.ts
-var import_isomorphic_git = __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/ops/branch.ts
-var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
-function getPromisesFs(fs) {
-  const promises = fs.promises;
-  return promises ?? null;
-}
-function decodeFileContent(content) {
-  return typeof content === "string" ? content : new TextDecoder().decode(content);
-}
-async function resolveLooseRefFast(repo, ref) {
-  const promisesFs = getPromisesFs(repo.fs);
-  if (promisesFs) {
-    try {
-      const content = await promisesFs.readFile(
-        `${repo.gitdir}/${ref}`,
-        "utf8"
-      );
-      const oid = decodeFileContent(content).trim();
-      if (FULL_SHA_RE.test(oid)) return oid;
-    } catch {
-    }
-  }
-  return import_isomorphic_git.default.resolveRef({ ...repo, ref });
-}
-
-// 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, 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 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 });
-  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_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) {
-  const have = haveOids instanceof Set ? haveOids : new Set(haveOids ?? []);
-  const seen = /* @__PURE__ */ new Set();
-  let complete = true;
-  const promises = /* @__PURE__ */ new Map();
-  async function readAndVisitChildren(oid) {
-    const obj = await import_isomorphic_git3.default.readObject({ ...repo, oid });
-    seen.add(oid);
-    let children = [];
-    if (obj.type === "commit") {
-      const { commit } = await import_isomorphic_git3.default.readCommit({ ...repo, oid });
-      children = [commit.tree, ...commit.parent];
-    } else if (obj.type === "tree") {
-      const { tree } = await import_isomorphic_git3.default.readTree({ ...repo, oid });
-      children = tree.map((e) => e.oid);
-    } else if (obj.type === "tag") {
-      const { tag } = await import_isomorphic_git3.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;
-    if (have.has(oid)) {
-      seen.add(oid);
-      const p2 = Promise.resolve();
-      promises.set(oid, p2);
-      return p2;
-    }
-    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_git5 = __toESM(require("isomorphic-git"), 1);
-
-// src/http/repack.ts
-var import_isomorphic_git4 = __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_git4.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);
-}
-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_git4.default.listBranches(repo),
-      import_isomorphic_git4.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_git4.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_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(() => {
-      });
-      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_git5.default.init({ ...repo, dir: repo.gitdir, defaultBranch, bare: true });
-  }
-}
-async function indexIncomingPack(repo, packData, hooks) {
-  if (packData.length < 4) return [];
-  const packName = 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 packName2 = `recv-${Date.now()}`;
-      await fsp.writeFile(`${packDir}/${packName2}.pack`, packData);
-      await import_isomorphic_git5.default.indexPack({
-        ...repo,
-        dir: packDir,
-        filepath: `${packName2}.pack`
-      });
-      return packName2;
-    }
-  );
-  return [
-    `${repo.gitdir}/objects/pack/${packName}.pack`,
-    `${repo.gitdir}/objects/pack/${packName}.idx`
-  ];
-}
-async function checkRefCas(repo, refName, oldOid) {
-  if (!isSafeFullRefName(refName)) {
-    return { refName, ok: false, reason: "invalid ref name" };
-  }
-  const currentOid = await import_isomorphic_git5.default.resolveRef({ ...repo, ref: refName }).catch(() => ZERO_OID);
-  return currentOid === oldOid ? null : {
-    refName,
-    ok: false,
-    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(
-      async ({ oldOid, refName }) => await checkRefCas(repo, refName, oldOid) ?? { refName, ok: true }
-    )
-  );
-}
-async function applyRefUpdates(repo, refUpdates, hooks) {
-  return runStep(
-    hooks,
-    "apply ref updates",
-    () => Promise.all(
-      refUpdates.map(async ({ oldOid, newOid, refName }) => {
-        const failure = await checkRefCas(repo, refName, oldOid);
-        if (failure) return failure;
-        if (newOid === ZERO_OID) {
-          await import_isomorphic_git5.default.deleteRef({ ...repo, ref: refName }).catch(() => {
-          });
-        } else {
-          await import_isomorphic_git5.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");
-  const preflight = await validateRefUpdates(repo, parsed.refUpdates);
-  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 newTips = acceptedUpdates.filter((update) => update.newOid !== ZERO_OID).map((update) => update.newOid);
-  if (newTips.length > 0) {
-    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,
-      hooks,
-      haveOids
-    );
-    if (!complete) {
-      await Promise.all(
-        incomingPackPaths.map(
-          (filepath) => rawFs(repo).unlink(filepath).catch(() => {
-          })
-        )
-      );
-      return {
-        results: preflight.map(
-          (result) => result.ok ? { ...result, ok: false, reason: "incomplete object graph" } : result
-        ),
-        stalePackPaths: []
-      };
-    }
-  }
-  const applied = await applyRefUpdates(repo, acceptedUpdates, hooks);
-  const results = preflight.map(
-    (result, index) => result.ok ? applied.find(
-      (entry) => entry.refName === parsed.refUpdates[index]?.refName
-    ) ?? result : result
-  );
-  const repackOptions = options?.repack;
-  const stalePackPaths = repackOptions === false || !results.some((result) => result.ok) ? [] : await runStep(
-    hooks,
-    "repack",
-    () => repackRepository(repo, repackOptions, hooks)
-  );
-  return { results, stalePackPaths };
-}
-
-// src/http/upload-pack.ts
-var import_isomorphic_git6 = __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_git6.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