git-fs-s3 0.15.0 → 0.15.3

package/dist/http.js

@@ -1,914 +1,970 @@
-import {
-  createSemaphore,
-  encodePack,
-  hashGitObject,
-  listBranches,
-  listLooseRefNames,
-  packBaseName,
-  resolveLooseRefFast,
-  storePack
-} from "./chunk-IAKZRWBZ.js";
-import {
-  OBJ_OFS_DELTA,
-  OBJ_REF_DELTA,
-  OID_BYTES,
-  concat,
-  decodeAscii,
-  decodeUtf8,
-  encodeEntryHeader,
-  encodeUtf8,
-  fromHex,
-  isSafeFullRefName,
-  packFileName,
-  parsePackDirectory,
-  rawFs,
-  readEntryHeader,
-  readOfsDeltaOffset,
-  readPackIndex,
-  runStep,
-  sha1,
-  toHex
-} from "./chunk-OKBQISUC.js";
-
-// src/http/info-refs.ts
+import { B as fromHex, F as concat, G as sha1, I as decodeAscii, L as decodeUtf8, N as isAbsentError, P as isNotFoundError, f as readEntryHeader, h as runStep, l as readPackIndex, m as rawFs, p as readOfsDeltaOffset, q as toHex, r as isSafeFullRefName, u as encodeEntryHeader, v as packFileName, y as parsePackDirectory, z as encodeUtf8 } from "./refs-Cb_NfKWI.js";
+import { a as storePack, d as listLooseRefNames, i as packBaseName, n as encodePack, p as resolveLooseRefFast, r as hashGitObject, t as createSemaphore, u as listBranches } from "./semaphore-BviNoQuJ.js";
 import git from "isomorphic-git";
-
-// src/http/pkt-line.ts
-var FLUSH = new Uint8Array([
-  48,
-  48,
-  48,
-  48
+//#region src/http/pkt-line.ts
+/**
+* Git pkt-line framing (smart HTTP protocol wire format).
+*
+* Edge-compatible: uses Uint8Array instead of Buffer.
+*/
+/** Flush packet: exactly four zero bytes. */
+const FLUSH = new Uint8Array([
+	48,
+	48,
+	48,
+	48
 ]);
-var PKT_LINE_MAX_BODY = 65535 - 4;
+/**
+* A pkt-line length prefix is four hex digits, so 0xffff (65535) bytes total
+* is the most a frame can describe — a body of 65531. Callers with longer
+* payloads must chunk them (see {@link sideBandPackfile}); framing one here
+* would emit a five-digit prefix no client can parse.
+*/
+const PKT_LINE_MAX_BODY = 65531;
 function assertPktLineFits(bodyLength) {
-  if (bodyLength > PKT_LINE_MAX_BODY) {
-    throw new Error(
-      `pkt-line body of ${bodyLength} bytes exceeds the protocol limit of ${PKT_LINE_MAX_BODY} bytes (0xffff total, including the 4-hex-digit length prefix)`
-    );
-  }
+	if (bodyLength > PKT_LINE_MAX_BODY) throw new Error(`pkt-line body of ${bodyLength} bytes exceeds the protocol limit of ${PKT_LINE_MAX_BODY} bytes (0xffff total, including the 4-hex-digit length prefix)`);
 }
+/**
+* Frame a UTF-8 string as one pkt-line. The 65531-byte body limit is a
+* property of pkt-line framing, not of this function: the length prefix is
+* fixed at four hex digits, so a longer frame is unparseable rather than
+* merely unusual.
+*/
 function pktLine(data) {
-  const body = encodeUtf8(data);
-  assertPktLineFits(body.length);
-  const len = (body.length + 4).toString(16).padStart(4, "0");
-  return concat(encodeUtf8(len), body);
+	const body = encodeUtf8(data);
+	assertPktLineFits(body.length);
+	const len = (body.length + 4).toString(16).padStart(4, "0");
+	return concat(encodeUtf8(len), body);
 }
+/**
+* Frame raw bytes as one pkt-line. Throws above the 65531-byte body limit of
+* the framing itself (see {@link pktLine}) instead of emitting a malformed
+* frame.
+*/
 function pktLineBuffer(body) {
-  assertPktLineFits(body.length);
-  const len = (body.length + 4).toString(16).padStart(4, "0");
-  return concat(encodeUtf8(len), body);
+	assertPktLineFits(body.length);
+	const len = (body.length + 4).toString(16).padStart(4, "0");
+	return concat(encodeUtf8(len), body);
 }
+/** Decode pkt-lines to strings; `null` marks a flush-pkt. Stops on garbage. */
 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;
+	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;
+/**
+* Per the git protocol, once side-band-64k has been negotiated, packfile
+* bytes in the upload-pack response must be chunked into pkt-lines each
+* prefixed with a control byte (0x01 = packfile data), terminated by a
+* flush-pkt. Without this, clients that don't special-case "no side-band" —
+* e.g. isomorphic-git's GitSideBand.demux, which always treats the response
+* as side-band-framed — misparse the raw packfile bytes as bogus pkt-line
+* length headers and spin forever. (Native `git` tolerates a raw unframed
+* stream when side-band isn't negotiated, so this only surfaces with
+* isomorphic-git as the HTTP client.)
+*/
+const 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);
+	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/info-refs.ts
+//#endregion
+//#region src/http/info-refs.ts
+/** All refs with resolved oids, plus the symref HEAD should advertise. */
 async function listAllRefs(repo, defaultBranch) {
-  const [branches, tagNames] = await Promise.all([
-    listBranches(repo),
-    listLooseRefNames(repo, "refs/tags").then(
-      (names) => names ?? git.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 current = defaultRef ? null : await git.currentBranch({ ...repo, fullname: true }).catch(() => void 0);
-  const headSymref = defaultRef ? `refs/heads/${defaultRef.name}` : current ?? `refs/heads/${defaultBranch}`;
-  const headOid = branchRefs.find((r) => r.name === headSymref)?.oid ?? (defaultRef || current ? null : await git.resolveRef({ ...repo, ref: "HEAD" }).catch(() => null));
-  const refs = [];
-  if (headOid) refs.push({ name: "HEAD", oid: headOid });
-  refs.push(...branchRefs);
-  for (const r of tagRefs) if (r) refs.push(r);
-  return { refs, headSymref };
+	const [branches, tagNames] = await Promise.all([listBranches(repo), listLooseRefNames(repo, "refs/tags").then((names) => names ?? git.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((error) => {
+			if (isAbsentError(error)) return null;
+			throw error;
+		});
+	}));
+	const branchRefs = branches.map((b) => ({
+		name: `refs/heads/${b.name}`,
+		oid: b.commit
+	}));
+	const defaultRef = branches.find((b) => b.isDefault);
+	const current = defaultRef ? null : await git.currentBranch({
+		...repo,
+		fullname: true
+	}).catch(() => void 0);
+	const headSymref = defaultRef ? `refs/heads/${defaultRef.name}` : current ?? `refs/heads/${defaultBranch}`;
+	const headOid = branchRefs.find((r) => r.name === headSymref)?.oid ?? (defaultRef || current ? null : await git.resolveRef({
+		...repo,
+		ref: "HEAD"
+	}).catch(() => null));
+	const refs = [];
+	if (headOid) refs.push({
+		name: "HEAD",
+		oid: headOid
+	});
+	refs.push(...branchRefs);
+	for (const r of tagRefs) if (r) refs.push(r);
+	return {
+		refs,
+		headSymref
+	};
 }
+/**
+* `GET …/info/refs?service=…` — the ref advertisement. Authentication and
+* authorization are the caller's job before invoking this.
+*
+* Capabilities advertised match what the sibling handlers implement:
+* side-band-64k (honored by handleUploadPack's response framing — clients
+* like isomorphic-git unconditionally expect it), tip/reachable sha1 wants,
+* delete-refs and report-status for pushes.
+*/
 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)
-  );
-  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}` : `report-status delete-refs side-band-64k 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)
-  };
+	const { service } = options;
+	const agent = options.agent ?? "git-fs-s3";
+	const { refs, headSymref } = await runStep(hooks, "listAllRefs", () => listAllRefs(repo, options.defaultBranch));
+	const caps = service === "git-upload-pack" ? `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}\n`), FLUSH];
+	if (refs.length === 0) parts.push(pktLine(`0000000000000000000000000000000000000000 capabilities^{}\0${caps}\n`));
+	else {
+		let first = true;
+		for (const { name, oid } of refs) {
+			parts.push(pktLine(first ? `${oid} ${name}\0${caps}\n` : `${oid} ${name}\n`));
+			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
-import git2 from "isomorphic-git";
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var MISSING_OBJECT_RETRY_DELAY_MS = 200;
-var MAX_CONCURRENT_READS = 16;
+//#endregion
+//#region src/http/reachability.ts
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* A read landing in the gap between a repack's new consolidated pack being
+* uploaded and the stale-pack cleanup finishing can transiently miss an
+* object that is not actually lost — it exists in the new pack the whole
+* time; the reader's cached pack listing was just taken mid-transition. One
+* retry after a short delay is enough to observe the consistent listing.
+*/
+const MISSING_OBJECT_RETRY_DELAY_MS = 200;
+/**
+* Walk the object graph from `startOids`, returning every reachable oid.
+* Concurrent traversal paths are deduplicated promise-per-oid; a missing
+* object is retried once, then reported through `hooks.onWarn` and
+* reflected in `complete: false`.
+*
+* `haveOids` bounds the walk: any oid in this set is assumed already
+* verified (it was reachable from a ref that existed before this call) and
+* is recorded in `seen` without being read or descended into. Without a
+* boundary, every call re-walks the *entire* history from scratch — for
+* receive-pack validation (see receive-pack.ts) that means every push pays
+* for reading every object in the repo, not just the ones it introduced,
+* and one transient read failure anywhere in that whole history rejects an
+* otherwise-valid push.
+*
+* Commits, trees and tags are read once each (parsed). Blobs have no
+* children, so `verifyBlobs: false` records a blob from its tree entry
+* without reading (and inflating) it — for callers that read every blob
+* themselves afterwards anyway, like upload-pack's `packObjects`. Leave it
+* true wherever the walk *is* the existence check (receive-pack, repack).
+*
+* Object reads are bounded by one shared {@link MAX_CONCURRENT_READS}
+* semaphore for the whole walk, held only for the read itself — not per
+* level, since the walk recurses and a per-level limit would still multiply
+* with depth, and not across the child recursion, which would deadlock a wide
+* tree once every permit belonged to a parent awaiting its children.
+*/
 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();
-  const reads = createSemaphore(MAX_CONCURRENT_READS);
-  async function readAndVisitChildren(oid) {
-    const obj = await reads.run(() => git2.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 };
+	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();
+	const reads = createSemaphore(16);
+	async function readAndVisitChildren(oid) {
+		const obj = await reads.run(() => git.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 p = Promise.resolve();
+			promises.set(oid, p);
+			return p;
+		}
+		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
+	};
 }
+/**
+* Commit-only ancestry walk: every commit reachable from `startOids`
+* (annotated tags peeled), stopping at — and not descending into — commits in
+* `stopAt`. Reads commit objects only, never trees or blobs, so it costs a
+* fraction of {@link collectReachableOids} over the same history. Start oids
+* that don't exist (or aren't commits/tags) are skipped. Returns the commits
+* walked and the `stopAt` commits the walk ran into.
+*/
 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 };
+	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 git.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";
-
-// src/http/repack.ts
-import git3 from "isomorphic-git";
-
-// src/http/pack-reuse.ts
-var PACK_TRAILER_BYTES = 20;
+//#endregion
+//#region src/http/pack-reuse.ts
+/**
+* Build a packfile by copying already-compressed entries out of existing
+* packs ("pack reuse"), instead of inflating and re-deflating every object.
+*
+* Entries keep their stored form, deltas included, so the output is as
+* compact as the packs it came from. `OFS_DELTA` entries are rewritten as
+* `REF_DELTA` (base named by oid), since offsets don't survive the move into
+* a new pack; delta bases are always included and written before the deltas
+* that use them. Formats: gitformat-pack(5).
+*
+* Edge-compatible: Web Crypto SHA-1 and Uint8Array only.
+*/
+const PACK_TRAILER_BYTES = 20;
+/** Locate every entry of `pack` using its `.idx`. */
 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 };
+	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
+	};
 }
+/** Copy one entry, rewriting `OFS_DELTA` to `REF_DELTA`. */
 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
-  };
+	const { pack, start, end } = entry;
+	const header = readEntryHeader(pack, start);
+	const bodyStart = start + header.length;
+	if (header.type === 7) return {
+		bytes: pack.subarray(start, end),
+		baseOid: toHex(pack.subarray(bodyStart, bodyStart + 20))
+	};
+	if (header.type !== 6) 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(7, header.size), fromHex(baseOid), pack.subarray(bodyStart + length, end)),
+		baseOid
+	};
 }
+/**
+* A pack holding at least `oids`, built from stored entries, or `null` when
+* any of them (or a delta base they need) isn't in a readable pack — e.g. a
+* loose object — so the caller should build the pack another way.
+*/
 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)));
+	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 = /* @__PURE__ */ 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
+//#endregion
+//#region src/http/repack.ts
+/**
+* Pack consolidation: merge all packs into one, reusing stored (possibly
+* deltified) entries when every object is packed.
+*
+* Edge-compatible: uses Web Crypto (SHA-1), CompressionStream (deflate),
+* and Uint8Array throughout — no node:crypto, node:zlib, or Buffer.
+*/
+/**
+* Read every reachable object and independently re-derive its oid from the
+* bytes isomorphic-git handed back, instead of trusting the oid it was asked
+* for. isomorphic-git's *packed*-object read path never verifies the
+* resolved content's SHA-1 against the requested oid — only the
+* loose-object branch does.
+*/
 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 git3.readObject({
-          ...repo,
-          oid,
-          format: "content"
-        });
-        const content = new Uint8Array(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;
+	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 git.readObject({
+				...repo,
+				oid,
+				format: "content"
+			});
+			const content = new Uint8Array(object);
+			const actualOid = await hashGitObject(type, content);
+			if (actualOid !== oid) throw new Error(`repack: object ${oid} failed independent SHA-1 verification (recomputed ${actualOid}) — 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;
 }
-var REPACK_PACK_COUNT_THRESHOLD = 4;
+/**
+* Default repack threshold. Consolidating is O(total repo object count) —
+* so paying it on every push makes push latency grow with repo size forever.
+*/
+const REPACK_PACK_COUNT_THRESHOLD = 4;
 async function readPackDirectory(repo) {
-  const entries = await rawFs(repo).readdir(`${repo.gitdir}/objects/pack`).catch(() => []);
-  return parsePackDirectory(entries);
+	const entries = await rawFs(repo).readdir(`${repo.gitdir}/objects/pack`).catch((error) => {
+		if (isAbsentError(error)) return [];
+		throw error;
+	});
+	return parsePackDirectory(entries);
 }
 async function countPacks(repo) {
-  const files = await readPackDirectory(repo);
-  return files.filter((file) => file.kind === "pack").length;
+	return (await readPackDirectory(repo)).filter((file) => file.kind === "pack").length;
 }
+/**
+* Consolidate all pack files into one, returning the gitdir-relative paths
+* of the old .pack/.idx files it removed — after syncing the new pack to any
+* secondary storage, delete those same paths there too.
+*
+* A failure rejects rather than being swallowed: whether a failed
+* consolidation is fatal depends on the caller — a post-write repack must
+* not fail an already-durable write, an explicit maintenance repack must
+* report its failure — so the decision belongs at the call site. Leaving a
+* failed run behind is safe (an unconsolidated repo still reads correctly),
+* which is what lets those callers treat it as best-effort.
+*/
 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([
-      git3.listBranches(repo),
-      git3.listTags(repo)
-    ]);
-    const refNames = [
-      ...branches.map((b) => `refs/heads/${b}`),
-      ...tags.map((t) => `refs/tags/${t}`)
-    ];
-    const tipOids = (await Promise.all(
-      refNames.map(
-        (ref) => git3.resolveRef({ ...repo, ref }).catch(() => null)
-      )
-    )).filter((oid) => oid !== null);
-    if (tipOids.length === 0) return [];
-    const { oids: reachable, complete } = await collectReachableOids(
-      repo,
-      tipOids,
-      hooks,
-      void 0,
-      { verifyBlobs: false }
-    );
-    if (!complete || reachable.length === 0) return [];
-    const packDir = `${repo.gitdir}/objects/pack`;
-    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 = 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,
-      dir: packDir,
-      filepath: newPackFile
-    });
-    const indexed = new Set(indexedOids);
-    if (reachable.some((oid) => !indexed.has(oid))) {
-      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"
-      );
-    }
-    const stale = (await readPackDirectory(repo)).filter(
-      (file) => file.base !== newBase
-    );
-    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);
-    return [];
-  }
+	const threshold = options?.threshold ?? 4;
+	const fsp = rawFs(repo);
+	if (await countPacks(repo) < threshold) return [];
+	const [branches, tags] = await Promise.all([git.listBranches(repo), git.listTags(repo)]);
+	const refNames = [...branches.map((b) => `refs/heads/${b}`), ...tags.map((t) => `refs/tags/${t}`)];
+	const tipOids = (await Promise.all(refNames.map(async (ref) => {
+		try {
+			return await git.resolveRef({
+				...repo,
+				ref
+			});
+		} catch (error) {
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+	}))).filter((oid) => oid !== null);
+	if (tipOids.length === 0) return [];
+	const { oids: reachable, complete } = await collectReachableOids(repo, tipOids, hooks, void 0, { verifyBlobs: false });
+	if (!complete || reachable.length === 0) return [];
+	const packDir = `${repo.gitdir}/objects/pack`;
+	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 = 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 git.indexPack({
+		...repo,
+		dir: packDir,
+		filepath: newPackFile
+	});
+	const indexed = new Set(indexedOids);
+	if (reachable.some((oid) => !indexed.has(oid))) {
+		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 — aborting");
+	}
+	const stale = (await readPackDirectory(repo)).filter((file) => file.base !== newBase);
+	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}`);
 }
-
-// src/http/receive-pack.ts
-var ZERO_OID = "0".repeat(40);
-var OID_RE = /^[0-9a-f]{40}$/;
+//#endregion
+//#region src/http/receive-pack.ts
+const ZERO_OID$1 = "0".repeat(40);
+const OID_RE$1 = /^[0-9a-f]{40}$/;
+/**
+* Split a receive-pack body: pkt-line ref commands, flush, then raw PACK.
+* A command whose oids aren't 40 lowercase hex digits is dropped — it can
+* never be applied, and its oids would otherwise reach object-path lookups.
+*/
 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);
-    if (len === 0) {
-      pos += 4;
-      break;
-    }
-    if (len < 4) break;
-    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 [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),
-    capabilities: capabilities ?? []
-  };
+	const refUpdates = [];
+	let capabilities;
+	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, caps] = decodeUtf8(body.subarray(pos + 4, pos + len)).replace(/\n$/, "").split("\0");
+		if (capabilities === void 0) capabilities = (caps ?? "").split(" ").filter(Boolean);
+		pos += len;
+		const [oldOid, newOid, refName] = (line ?? "").split(" ");
+		if (oldOid && newOid && refName && OID_RE$1.test(oldOid) && OID_RE$1.test(newOid)) refUpdates.push({
+			oldOid,
+			newOid,
+			refName
+		});
+	}
+	return {
+		refUpdates,
+		packData: body.subarray(pos),
+		capabilities: capabilities ?? []
+	};
 }
+/** Initialize the repo when its HEAD doesn't exist yet (first push). */
 async function ensureRepoInitialized(repo, defaultBranch) {
-  const fsp = rawFs(repo);
-  try {
-    await fsp.stat(`${repo.gitdir}/HEAD`);
-  } catch {
-    await fsp.mkdir(repo.gitdir, { recursive: true }).catch(() => {
-    });
-    await git4.init({ ...repo, dir: repo.gitdir, defaultBranch, bare: true });
-  }
+	const fsp = rawFs(repo);
+	try {
+		await fsp.stat(`${repo.gitdir}/HEAD`);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+		await fsp.mkdir(repo.gitdir, { recursive: true }).catch(() => {});
+		await git.init({
+			...repo,
+			dir: repo.gitdir,
+			defaultBranch,
+			bare: true
+		});
+	}
 }
+/** Write the incoming PACK into objects/pack/ and index it. */
 async function indexIncomingPack(repo, packData, hooks) {
-  if (packData.length < 4) return [];
-  const packName = await runStep(
-    hooks,
-    "write + indexPack incoming pack",
-    async () => {
-      const { base } = await storePack(repo, packData);
-      return base;
-    }
-  );
-  return [
-    `${repo.gitdir}/objects/pack/${packName}.pack`,
-    `${repo.gitdir}/objects/pack/${packName}.idx`
-  ];
+	if (packData.length < 4) return [];
+	const packName = await runStep(hooks, "write + indexPack incoming pack", async () => {
+		const { base } = await storePack(repo, packData);
+		return base;
+	});
+	return [`${repo.gitdir}/objects/pack/${packName}.pack`, `${repo.gitdir}/objects/pack/${packName}.idx`];
 }
+/**
+* Validate a ref name and compare-and-swap it against its claimed current
+* oid. Returns the failure result to report if either check fails, or
+* `null` when both pass — shared by the preflight check (`validateRefUpdates`,
+* run before the possibly-slow pack indexing/graph-walk work, purely to
+* avoid doing that work for an update already doomed to fail) and the real
+* atomicity guarantee (`applyRefUpdates`, run again right before writing,
+* since a concurrent push could have moved the ref in the time that work
+* took).
+*/
 async function checkRefCas(repo, refName, oldOid) {
-  if (!isSafeFullRefName(refName)) {
-    return { refName, ok: false, reason: "invalid ref name" };
-  }
-  const currentOid = await git4.resolveRef({ ...repo, ref: refName }).catch(() => ZERO_OID);
-  return currentOid === oldOid ? null : {
-    refName,
-    ok: false,
-    reason: "non-fast-forward, ref updated by another push"
-  };
+	if (!isSafeFullRefName(refName)) return {
+		refName,
+		ok: false,
+		reason: "invalid ref name"
+	};
+	let currentOid;
+	try {
+		currentOid = await git.resolveRef({
+			...repo,
+			ref: refName
+		});
+	} catch (error) {
+		if (!isNotFoundError(error)) throw error;
+		currentOid = ZERO_OID$1;
+	}
+	return currentOid === oldOid ? null : {
+		refName,
+		ok: false,
+		reason: "non-fast-forward, ref updated by another push"
+	};
 }
+/** Every branch/tag tip currently in the repo, as a validation boundary — see
+* its call site in {@link applyReceivePack}. */
 async function collectExistingRefTips(repo) {
-  const [branches, tags] = await Promise.all([
-    git4.listBranches(repo),
-    git4.listTags(repo)
-  ]);
-  const refs = [
-    ...branches.map((b) => `refs/heads/${b}`),
-    ...tags.map((t) => `refs/tags/${t}`)
-  ];
-  const oids = await Promise.all(
-    refs.map((ref) => git4.resolveRef({ ...repo, ref }).catch(() => null))
-  );
-  return new Set(oids.filter((oid) => oid !== null));
+	const [branches, tags] = await Promise.all([git.listBranches(repo), git.listTags(repo)]);
+	const refs = [...branches.map((b) => `refs/heads/${b}`), ...tags.map((t) => `refs/tags/${t}`)];
+	const oids = await Promise.all(refs.map(async (ref) => {
+		try {
+			return await git.resolveRef({
+				...repo,
+				ref
+			});
+		} catch (error) {
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+	}));
+	return new Set(oids.filter((oid) => oid !== null));
 }
+/**
+* The branch HEAD names, or null when HEAD is detached or unborn. A HEAD read
+* that *failed* must reject the push: `validateRefUpdates` reads null as "no
+* default branch to protect", so swallowing a real failure would let a push
+* delete the branch HEAD points at, leaving the repository with no default
+* branch (see #91).
+*/
 async function currentBranchRef(repo) {
-  return git4.currentBranch({ ...repo, fullname: true }).then((ref) => ref ?? null).catch(() => null);
+	try {
+		return await git.currentBranch({
+			...repo,
+			fullname: true
+		}) ?? null;
+	} catch (error) {
+		if (!isNotFoundError(error)) throw error;
+		return null;
+	}
 }
 async function validateRefUpdates(repo, refUpdates) {
-  const headRef = await currentBranchRef(repo);
-  const seen = /* @__PURE__ */ new Set();
-  return Promise.all(
-    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 };
-    })
-  );
+	const headRef = await currentBranchRef(repo);
+	const seen = /* @__PURE__ */ new Set();
+	return Promise.all(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$1 && refName === headRef) return {
+			refName,
+			ok: false,
+			reason: "deletion of the current branch prohibited"
+		};
+		return await checkRefCas(repo, refName, oldOid) ?? {
+			refName,
+			ok: true
+		};
+	}));
 }
+/**
+* Apply ref updates, enforcing compare-and-swap against each command's
+* claimed oldOid. Every client-supplied refName is validated before any
+* filesystem call reads or writes through it.
+*/
 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 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,
-            value: newOid,
-            force: true
-          });
-        }
-        return { refName, ok: true };
-      })
-    )
-  );
+	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$1) try {
+			await git.deleteRef({
+				...repo,
+				ref: refName
+			});
+		} catch (error) {
+			if (!isNotFoundError(error)) throw error;
+		}
+		else {
+			if (refName.startsWith("refs/heads/")) {
+				let type;
+				try {
+					({type} = await git.readObject({
+						...repo,
+						oid: newOid,
+						format: "content"
+					}));
+				} catch (error) {
+					if (!isNotFoundError(error)) throw error;
+					type = "missing";
+				}
+				if (type !== "commit") return {
+					refName,
+					ok: false,
+					reason: `branch must point at a commit, not a ${type}`
+				};
+			}
+			await git.writeRef({
+				...repo,
+				ref: refName,
+				value: newOid,
+				force: true
+			});
+		}
+		return {
+			refName,
+			ok: true
+		};
+	})));
 }
+/**
+* The report-status response for a set of ref-update results — empty unless
+* the client asked for `report-status`, and side-band-64k framed when it
+* asked for that (git and isomorphic-git both do; isomorphic-git always
+* demuxes the response as side-band). `unpackError` reports a pack that
+* couldn't be stored or indexed.
+*/
 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: {
-      "Content-Type": "application/x-git-receive-pack-result",
-      "Cache-Control": "no-cache"
-    },
-    body: responseBody
-  };
+	const capabilities = options?.capabilities ?? ["report-status"];
+	const report = capabilities.includes("report-status") ? concat(pktLine(options?.unpackError ? `unpack ${options.unpackError}\n` : "unpack ok\n"), ...results.map(({ refName, ok, reason }) => pktLine(ok ? `ok ${refName}\n` : `ng ${refName} ${reason}\n`)), FLUSH) : /* @__PURE__ */ new Uint8Array();
+	return {
+		status: 200,
+		headers: {
+			"Content-Type": "application/x-git-receive-pack-result",
+			"Cache-Control": "no-cache"
+		},
+		body: capabilities.includes("side-band-64k") && report.length > 0 ? sideBandPackfile(report) : report
+	};
 }
+/**
+* The storage half of a push against `repo`: initialize if needed, index the
+* incoming pack, CAS-apply ref updates, then repack when enough packs have
+* accumulated. Serialize concurrent pushes to the same repo externally (a
+* per-repo lock); build the HTTP response afterwards with
+* {@link receivePackResponse}.
+*
+* A push that changes nothing must not leak its pack: ref updates only ever
+* fail here (a stale compare-and-swap, a branch pointed at a non-commit,
+* HEAD's branch deleted), so when none of them succeeded the incoming pack is
+* unlinked again — no ref names it, and the threshold repack only runs for
+* accepted pushes, so nothing would ever reclaim it.
+*/
 async function applyReceivePack(repo, parsed, options, hooks) {
-  await ensureRepoInitialized(repo, options.defaultBranch);
-  const preflight = await validateRefUpdates(repo, parsed.refUpdates);
-  const acceptedUpdates = parsed.refUpdates.filter(
-    (_, index) => preflight[index]?.ok
-  );
-  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);
-    for (const update of acceptedUpdates) {
-      if (update.oldOid !== ZERO_OID) haveOids.add(update.oldOid);
-    }
-    const { complete } = await collectReachableOids(
-      repo,
-      newTips,
-      hooks,
-      haveOids
-    );
-    if (!complete) {
-      for (const filepath of removableIncoming) {
-        await fsp.unlink(filepath).catch(() => {
-        });
-      }
-      return {
-        results: preflight.map(
-          (result2) => result2.ok ? { ...result2, ok: false, reason: "incomplete object graph" } : result2
-        ),
-        stalePackPaths: []
-      };
-    }
-  }
-  const applied = await applyRefUpdates(repo, acceptedUpdates, hooks);
-  const results = preflight.map(
-    (result2, index) => result2.ok ? applied.find(
-      (entry) => entry.refName === parsed.refUpdates[index]?.refName
-    ) ?? result2 : result2
-  );
-  if (!results.some((result2) => result2.ok)) {
-    for (const filepath of removableIncoming) {
-      await fsp.unlink(filepath).catch(() => {
-      });
-    }
-    return { results, stalePackPaths: [] };
-  }
-  const repackOptions = options.repack;
-  const stalePackPaths = repackOptions === false ? [] : await runStep(
-    hooks,
-    "repack",
-    () => repackRepository(repo, repackOptions, hooks)
-  );
-  return { results, stalePackPaths };
+	await ensureRepoInitialized(repo, options.defaultBranch);
+	const preflight = await validateRefUpdates(repo, parsed.refUpdates);
+	const acceptedUpdates = parsed.refUpdates.filter((_, index) => preflight[index]?.ok);
+	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$1) ? parsed.packData : /* @__PURE__ */ new Uint8Array(), hooks);
+	} catch (err) {
+		hooks?.onWarn?.("receive-pack: incoming pack rejected", err);
+		return {
+			results: preflight.map((result) => result.ok ? {
+				...result,
+				ok: false,
+				reason: "unpacker error"
+			} : result),
+			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$1).map((update) => update.newOid);
+	if (newTips.length > 0) {
+		const haveOids = await collectExistingRefTips(repo);
+		for (const update of acceptedUpdates) if (update.oldOid !== ZERO_OID$1) haveOids.add(update.oldOid);
+		const { complete } = await collectReachableOids(repo, newTips, hooks, haveOids);
+		if (!complete) {
+			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),
+				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);
+	if (!results.some((result) => result.ok)) {
+		for (const filepath of removableIncoming) await fsp.unlink(filepath).catch(() => {});
+		return {
+			results,
+			stalePackPaths: []
+		};
+	}
+	const repackOptions = options.repack;
+	let stalePackPaths = [];
+	if (repackOptions !== false) try {
+		stalePackPaths = await runStep(hooks, "repack", () => repackRepository(repo, repackOptions, hooks));
+	} catch (error) {
+		hooks?.onWarn?.("repack after push failed (non-fatal)", error);
+	}
+	return {
+		results,
+		stalePackPaths
+	};
 }
-
-// src/http/upload-pack.ts
-import git5 from "isomorphic-git";
-var ZERO_OID2 = "0".repeat(40);
-var OID_RE2 = /^[0-9a-f]{40}$/;
-var LOOSE_FANOUT_RE = /^[0-9a-f]{2}$/;
+//#endregion
+//#region src/http/upload-pack.ts
+const ZERO_OID = "0".repeat(40);
+/**
+* `POST …/git-upload-pack` — serve a clone/fetch. Authorization is the
+* caller's job. Negotiation is client-driven (no multi_ack advertised):
+* "have" batches without "done" get a bare NAK; the final batch gets the
+* packfile, side-band-64k framed.
+*
+* Fast path: a fresh clone (no haves) of a repo consolidated down to a
+* single pack serves that pack's bytes directly — skipping the O(objects)
+* traversal + repack entirely.
+*/
+const OID_RE = /^[0-9a-f]{40}$/;
+const 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
-  };
+	return {
+		status: 200,
+		headers: {
+			"Content-Type": "application/x-git-upload-pack-result",
+			"Cache-Control": "no-cache"
+		},
+		body
+	};
 }
+/** A protocol-level error the client prints ("ERR …"), not an HTTP failure. */
 function errorResult(message) {
-  return result(pktLine(`ERR ${message}
-`));
+	return result(pktLine(`ERR ${message}\n`));
 }
+/** Parsed upload-pack request: oids are always 40 lowercase hex digits. */
 function parseUploadPackRequest(body) {
-  const wants = [];
-  const haves = [];
-  let done = false;
-  let invalid = false;
-  let capabilities;
-  for (const line of parsePktLines(body)) {
-    if (!line) continue;
-    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;
-      }
-    } else if (text === "done") {
-      done = true;
-    }
-  }
-  return {
-    wants: [...new Set(wants)],
-    haves: [...new Set(haves)],
-    done,
-    capabilities: capabilities ?? [],
-    invalid
-  };
+	const wants = [];
+	const haves = [];
+	let done = false;
+	let invalid = false;
+	let capabilities;
+	for (const line of parsePktLines(body)) {
+		if (!line) continue;
+		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_RE.test(oid)) wants.push(oid);
+			else invalid = true;
+		} else if (text.startsWith("have ")) {
+			const oid = text.slice(5).trim();
+			if (OID_RE.test(oid)) {
+				if (oid !== ZERO_OID) haves.push(oid);
+			} else invalid = true;
+		} else if (text === "done") done = true;
+	}
+	return {
+		wants: [...new Set(wants)],
+		haves: [...new Set(haves)],
+		done,
+		capabilities: capabilities ?? [],
+		invalid
+	};
 }
+/**
+* The single pack a fresh clone can be served verbatim, or null. Only safe
+* when nothing lives outside it (no loose objects, exactly one pack) and it
+* holds every wanted object — a repo with commits written as loose objects
+* after its last repack would otherwise clone incomplete.
+*/
 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;
-  }
-  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;
+	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;
+	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;
 }
+/**
+* `POST …/git-upload-pack` — serve a clone/fetch. Authorization is the
+* caller's job. Negotiation is client-driven (no multi_ack advertised):
+* "have" batches without "done" get a bare NAK; the final batch gets the
+* packfile, side-band-64k framed when the client asked for it.
+*
+* Only objects reachable from the repository's refs are served: a want that
+* isn't a ref tip must be an ancestor of one ("not our ref" otherwise), so a
+* force-pushed-away commit still sitting in a pack can't be fetched by id.
+*
+* A fetch with haves reads only the client's commit ancestry plus the trees
+* of the boundary commits (the haves the new history builds on) — not every
+* tree the client already has.
+*
+* Fast path: a fresh clone (no haves) of a repo consolidated down to a
+* single pack, with no loose objects, serves that pack's bytes directly —
+* skipping the O(objects) traversal + repack entirely.
+*/
 async function handleUploadPack(repo, body, options, hooks) {
-  const request = parseUploadPackRequest(body);
-  if (request.invalid) {
-    return errorResult("upload-pack: protocol error, malformed object id");
-  }
-  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,
-      "verify wants reachable",
-      () => collectCommitAncestry(repo, [...tips])
-    );
-    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;
-  let commonHave;
-  if (haves.length > 0) {
-    haveSet = await runStep(hooks, "have boundary", async () => {
-      const { commits: clientCommits } = await collectCommitAncestry(
-        repo,
-        haves
-      );
-      commonHave = haves.find((oid) => clientCommits.has(oid));
-      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, 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,
-    `reuse pack entries (${oids.length} oids)`,
-    () => buildPackFromExistingPacks(repo, oids)
-  );
-  const packBytes = reused ?? await runStep(hooks, `packObjects (${oids.length} oids)`, async () => {
-    const { packfile } = await git5.packObjects({ ...repo, oids });
-    return packfile instanceof Uint8Array ? packfile : new Uint8Array(packfile ?? []);
-  });
-  const ack = commonHave ? `ACK ${commonHave}
-` : "NAK\n";
-  return result(concat(pktLine(ack), frame(packBytes)));
+	const request = parseUploadPackRequest(body);
+	if (request.invalid) return errorResult("upload-pack: protocol error, malformed object id");
+	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, "verify wants reachable", () => collectCommitAncestry(repo, [...tips]));
+		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;
+	let commonHave;
+	if (haves.length > 0) haveSet = await runStep(hooks, "have boundary", async () => {
+		const { commits: clientCommits } = await collectCommitAncestry(repo, haves);
+		commonHave = haves.find((oid) => clientCommits.has(oid));
+		const { boundary } = await collectCommitAncestry(repo, wants, clientCommits);
+		const { oids: boundaryObjects } = await collectReachableOids(repo, await Promise.all([...boundary].map(async (oid) => {
+			const { commit } = await git.readCommit({
+				...repo,
+				oid
+			});
+			return commit.tree;
+		})), hooks, void 0, { verifyBlobs: false });
+		return /* @__PURE__ */ new Set([...clientCommits, ...boundaryObjects]);
+	});
+	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 packBytes = await runStep(hooks, `reuse pack entries (${oids.length} oids)`, () => buildPackFromExistingPacks(repo, oids)) ?? await runStep(hooks, `packObjects (${oids.length} oids)`, async () => {
+		const { packfile } = await git.packObjects({
+			...repo,
+			oids
+		});
+		return packfile instanceof Uint8Array ? packfile : new Uint8Array(packfile ?? []);
+	});
+	const ack = commonHave ? `ACK ${commonHave}\n` : "NAK\n";
+	return result(concat(pktLine(ack), frame(packBytes)));
 }
-export {
-  FLUSH,
-  REPACK_PACK_COUNT_THRESHOLD,
-  applyReceivePack,
-  applyRefUpdates,
-  collectReachableOids,
-  ensureRepoInitialized,
-  handleInfoRefs,
-  handleUploadPack,
-  indexIncomingPack,
-  listAllRefs,
-  parsePktLines,
-  parseReceivePackBody,
-  parseUploadPackRequest,
-  pktLine,
-  pktLineBuffer,
-  rawFs,
-  receivePackResponse,
-  repackRepository,
-  sideBandPackfile
-};
+//#endregion
+export { FLUSH, REPACK_PACK_COUNT_THRESHOLD, applyReceivePack, applyRefUpdates, collectReachableOids, ensureRepoInitialized, handleInfoRefs, handleUploadPack, indexIncomingPack, listAllRefs, parsePktLines, parseReceivePackBody, parseUploadPackRequest, pktLine, pktLineBuffer, rawFs, receivePackResponse, repackRepository, sideBandPackfile };
+
 //# sourceMappingURL=http.js.map