git-fs-s3 0.4.0 → 0.6.0

package/dist/http.cjs

@@ -1,1063 +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(\/|$)/
-);
-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_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;
-}
-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) {
-    try {
-      const content = await promisesFs.readFile(
-        `${repo.gitdir}/${ref}`,
-        "utf8"
-      );
-      const oid = decodeFileContent(content).trim();
-      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([
-  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, 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 });
-  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, options) {
-  const verifyBlobs = options?.verifyBlobs ?? true;
-  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);
-    const children = [];
-    if (obj.type === "commit") {
-      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 = obj.object;
-      for (const entry of tree) {
-        if (entry.type === "commit") continue;
-        children.push([entry.oid, entry.type]);
-      }
-    } else if (obj.type === "tag") {
-      children.push([obj.object.object, void 0]);
-    }
-    await Promise.all(children.map(([child, type]) => visit(child, type)));
-  }
-  function visit(oid, type) {
-    const existing = promises.get(oid);
-    if (existing) return existing;
-    if (have.has(oid) || type === "blob" && !verifyBlobs) {
-      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((oid) => visit(oid)));
-  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);
-
-// 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,
-  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 readPackDirectory(repo) {
-  const entries = await rawFs(repo).readdir(`${repo.gitdir}/objects/pack`).catch(() => []);
-  return parsePackDirectory(entries);
-}
-async function countPacks(repo) {
-  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;
-  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: 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 = packFileName(newBase, "pack");
-    await fsp.writeFile(`${packDir}/${newPackFile}`, packBuffer);
-    const { oids: indexedOids } = await import_isomorphic_git4.default.indexPack({
-      ...repo,
-      dir: packDir,
-      filepath: newPackFile
-    });
-    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(() => {
-          })
-        )
-      );
-      throw new Error(
-        "repack: indexed pack is missing reachable objects \u2014 aborting"
-      );
-    }
-    const stale = (await readPackDirectory(repo)).filter(
-      (file) => file.base !== newBase
-    );
-    await Promise.all(
-      stale.map(
-        (file) => fsp.unlink(`${packDir}/${file.name}`).catch(() => {
-        })
-      )
-    );
-    return stale.map((file) => `objects/pack/${file.name}`);
-  } 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 = 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))
-      };
-    }
-  }
-  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);
-  }
-  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,
-    `reuse pack entries (${oids.length} oids)`,
-    () => buildPackFromExistingPacks(repo, oids)
-  );
-  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: {
-      "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