git-fs-s3 0.15.0 → 0.15.3

package/dist/index.js

@@ -1,692 +1,612 @@
-import {
-  MemoryObjectStore
-} from "./chunk-HLYCSNJ2.js";
-import {
-  classifyGitdirPath,
-  getObjectSize,
-  isMutableGitdirEntry,
-  parseLooseObjectPath
-} from "./chunk-T5M5EYCZ.js";
-import {
-  GitAuthenticationError,
-  GitAuthorizationError,
-  GitConflictError,
-  GitError,
-  GitInvalidRequestError,
-  GitObjectNotFoundError,
-  GitPathNotFoundError,
-  GitProtocolError,
-  GitRateLimitError,
-  GitRefNotFoundError,
-  GitRepositoryNotFoundError,
-  PACK_FILE_KINDS,
-  READABLE_PACK_FILE_KINDS,
-  concat,
-  decodeAscii,
-  decodeUtf8,
-  deflate,
-  encodeUtf8,
-  formatErrorResponse,
-  fromHex,
-  hasNullByte,
-  isFullSha,
-  isNotFoundError,
-  isSafeBranchName,
-  isSafeFullRefName,
-  isSafeRefName,
-  isSafeRepoPath,
-  isSafeTreePath,
-  packFileName,
-  parsePackDirectory,
-  parsePackFileName,
-  qualifyBranchRef,
-  readBlobContent,
-  sha1,
-  toBase64,
-  toHex
-} from "./chunk-OKBQISUC.js";
-
-// src/cache.ts
+import { A as GitRefNotFoundError, B as fromHex, C as GitConflictError, D as GitPathNotFoundError, E as GitObjectNotFoundError, F as concat, G as sha1, I as decodeAscii, K as toBase64, L as decodeUtf8, M as formatErrorResponse, N as isAbsentError, O as GitProtocolError, P as isNotFoundError, R as deflate, S as GitAuthorizationError, T as GitInvalidRequestError, V as hasNullByte, W as readBlobContent, _ as READABLE_PACK_FILE_KINDS, a as isSafeRepoPath, b as parsePackFileName, g as PACK_FILE_KINDS, i as isSafeRefName, j as GitRepositoryNotFoundError, k as GitRateLimitError, n as isSafeBranchName, o as isSafeTreePath, q as toHex, r as isSafeFullRefName, s as qualifyBranchRef, t as isFullSha, v as packFileName, w as GitError, x as GitAuthenticationError, y as parsePackDirectory, z as encodeUtf8 } from "./refs-Cb_NfKWI.js";
+import { i as parseLooseObjectPath, n as classifyGitdirPath, r as isMutableGitdirEntry, t as getObjectSize } from "./object-size-BJAsnZzw.js";
+import { t as MemoryObjectStore } from "./memory-M2cCuVF-.js";
 import { LRUCache } from "lru-cache";
-var MISS = /* @__PURE__ */ Symbol("miss");
+//#region src/cache.ts
+const MISS = Symbol("miss");
 function listEntrySize(entry) {
-  let size = entry.prefix.length + 16;
-  for (const o of entry.result.objects) size += o.key.length + 8;
-  for (const p of entry.result.prefixes) size += p.length;
-  return size;
+	let size = entry.prefix.length + 16;
+	for (const o of entry.result.objects) size += o.key.length + 8;
+	for (const p of entry.result.prefixes) size += p.length;
+	return size;
 }
 function copyListResult(result) {
-  return {
-    objects: result.objects.map((o) => ({ ...o })),
-    prefixes: [...result.prefixes]
-  };
+	return {
+		objects: result.objects.map((o) => ({ ...o })),
+		prefixes: [...result.prefixes]
+	};
 }
+/**
+* Wrap an {@link ObjectStore} with an in-process LRU read cache.
+*
+* Git object keys are content-addressed and therefore immutable, which makes
+* them ideal cache entries; mutable keys (refs, packed-refs) are bounded by
+* `ttlMs`. Writes and deletes through this wrapper invalidate their key and
+* any cached listings they affect — with one asymmetry: a non-empty `limit: 1`
+* probe (a "directory exists" answer) survives writes underneath it, because
+* adding a key below a prefix cannot make that prefix stop existing, while
+* empty probes and full listings are always dropped.
+*/
 function createCachedStore(store, options = {}) {
-  const maxBytes = options.maxBytes ?? 50 * 1024 * 1024;
-  const maxEntryBytes = options.maxEntryBytes ?? Math.ceil(maxBytes / 10);
-  const ttl = options.ttlMs ?? 6e4;
-  const ttlForKey = options.ttlForKey;
-  const cacheMisses = options.cacheMisses ?? false;
-  const cacheLists = options.cacheLists ?? false;
-  const range = store.getRange?.bind(store);
-  const coalesce = options.coalesce ?? true;
-  const copy = options.copy ?? true;
-  const clone = (data) => copy ? data.slice() : data;
-  const onHit = options.onHit;
-  const onMiss = options.onMiss;
-  const cache = new LRUCache({
-    maxSize: maxBytes,
-    sizeCalculation: (value) => value === MISS ? 1 : value.byteLength || 1,
-    ttl
-  });
-  const listCache = new LRUCache({
-    maxSize: Math.max(1, Math.ceil(maxBytes / 10)),
-    sizeCalculation: listEntrySize,
-    ttl
-  });
-  const pendingGets = /* @__PURE__ */ new Map();
-  const pendingHeads = /* @__PURE__ */ new Map();
-  const pendingLists = /* @__PURE__ */ new Map();
-  let generation = 0;
-  const unchangedSince = (start) => generation === start;
-  const admit = (key, data) => {
-    if (data.byteLength <= maxEntryBytes) {
-      cache.set(key, clone(data), { ttl: ttlForKey?.(key) });
-    }
-  };
-  function clearStaleListEntries(key) {
-    for (const [listKey, entry] of listCache.entries()) {
-      if (!key.startsWith(entry.prefix)) continue;
-      if (entry.probe && !entry.empty) continue;
-      listCache.delete(listKey);
-    }
-    for (const listKey of pendingLists.keys()) {
-      const prefix = listKey.split("|").slice(2).join("|");
-      if (key.startsWith(prefix)) pendingLists.delete(listKey);
-    }
-  }
-  function noteWrite(key) {
-    generation++;
-    pendingGets.delete(key);
-    pendingHeads.delete(key);
-  }
-  function coalesced(pending, key, fn) {
-    if (!coalesce) return fn();
-    const inflight = pending.get(key);
-    if (inflight !== void 0) return inflight;
-    const p = fn().finally(() => {
-      if (pending.get(key) === p) pending.delete(key);
-    });
-    pending.set(key, p);
-    return p;
-  }
-  return {
-    async get(key) {
-      const cached = cache.get(key);
-      if (cached !== void 0) {
-        onHit?.(key);
-        return cached === MISS ? null : clone(cached);
-      }
-      const data = await coalesced(pendingGets, key, async () => {
-        onMiss?.(key);
-        const start = generation;
-        const fetched = await store.get(key);
-        if (unchangedSince(start)) {
-          if (fetched !== null) {
-            admit(key, fetched);
-          } else if (cacheMisses) {
-            cache.set(key, MISS, { ttl: ttlForKey?.(key) });
-          }
-        }
-        return fetched;
-      });
-      return data === null ? null : clone(data);
-    },
-    async put(key, data) {
-      noteWrite(key);
-      try {
-        await store.put(key, data);
-      } finally {
-        noteWrite(key);
-        cache.delete(key);
-        clearStaleListEntries(key);
-      }
-      admit(key, data);
-    },
-    async delete(key) {
-      noteWrite(key);
-      try {
-        await store.delete(key);
-      } finally {
-        noteWrite(key);
-        cache.delete(key);
-        clearStaleListEntries(key);
-      }
-      if (cacheMisses) {
-        cache.set(key, MISS, { ttl: ttlForKey?.(key) });
-      } else {
-        cache.delete(key);
-      }
-    },
-    async head(key) {
-      const cached = cache.get(key);
-      if (cached !== void 0) {
-        onHit?.(key);
-        return cached === MISS ? null : { size: cached.byteLength };
-      }
-      return coalesced(pendingHeads, key, async () => {
-        onMiss?.(key);
-        const start = generation;
-        const stat = await store.head(key);
-        if (stat === null && cacheMisses && unchangedSince(start)) {
-          cache.set(key, MISS, { ttl: ttlForKey?.(key) });
-        }
-        return stat;
-      });
-    },
-    async list(prefix, listOptions) {
-      if (!cacheLists) return store.list(prefix, listOptions);
-      const listKey = `${listOptions?.delimiter ?? ""}|${listOptions?.limit ?? ""}|${prefix}`;
-      const cached = listCache.get(listKey);
-      if (cached !== void 0) {
-        onHit?.(prefix);
-        return copyListResult(cached.result);
-      }
-      const result = await coalesced(pendingLists, listKey, async () => {
-        onMiss?.(prefix);
-        const start = generation;
-        const fetched = await store.list(prefix, listOptions);
-        if (!unchangedSince(start)) return fetched;
-        listCache.set(
-          listKey,
-          {
-            result: copyListResult(fetched),
-            prefix,
-            probe: listOptions?.limit === 1,
-            empty: fetched.objects.length === 0 && fetched.prefixes.length === 0
-          },
-          { ttl: ttlForKey?.(prefix) }
-        );
-        return fetched;
-      });
-      return copyListResult(result);
-    },
-    // Forwarded straight to the backing store: a range read is a handful of
-    // bytes at a known offset, so caching one buys nothing, and bypassing the
-    // cache here keeps this wrapper's read paths unchanged.
-    ...range ? {
-      getRange: (key, start, end) => range(key, start, end)
-    } : {},
-    invalidate(prefix) {
-      generation++;
-      for (const key of [...pendingGets.keys()]) {
-        if (key.startsWith(prefix)) pendingGets.delete(key);
-      }
-      for (const key of [...pendingHeads.keys()]) {
-        if (key.startsWith(prefix)) pendingHeads.delete(key);
-      }
-      pendingLists.clear();
-      for (const key of cache.keys()) {
-        if (key.startsWith(prefix)) cache.delete(key);
-      }
-      for (const [listKey, entry] of listCache.entries()) {
-        if (entry.prefix.startsWith(prefix) || prefix.startsWith(entry.prefix)) {
-          listCache.delete(listKey);
-        }
-      }
-    }
-  };
+	const maxBytes = options.maxBytes ?? 52428800;
+	const maxEntryBytes = options.maxEntryBytes ?? Math.ceil(maxBytes / 10);
+	const ttl = options.ttlMs ?? 6e4;
+	const ttlForKey = options.ttlForKey;
+	const cacheMisses = options.cacheMisses ?? false;
+	const cacheLists = options.cacheLists ?? false;
+	const range = store.getRange?.bind(store);
+	const coalesce = options.coalesce ?? true;
+	const copy = options.copy ?? true;
+	const clone = (data) => copy ? data.slice() : data;
+	const onHit = options.onHit;
+	const onMiss = options.onMiss;
+	const cache = new LRUCache({
+		maxSize: maxBytes,
+		sizeCalculation: (value) => value === MISS ? 1 : value.byteLength || 1,
+		ttl
+	});
+	const listCache = new LRUCache({
+		maxSize: Math.max(1, Math.ceil(maxBytes / 10)),
+		sizeCalculation: listEntrySize,
+		ttl
+	});
+	const pendingGets = /* @__PURE__ */ new Map();
+	const pendingHeads = /* @__PURE__ */ new Map();
+	const pendingLists = /* @__PURE__ */ new Map();
+	/**
+	* Bumped by every write, delete and invalidation. A backend read that
+	* started before one of those may finish after it carrying the old answer
+	* (the old bytes, or "missing" for a key that now exists); it still
+	* answers its own callers, but only a read that saw no write in between
+	* may populate the cache — otherwise a stale miss could hide a freshly
+	* written object for the whole TTL.
+	*/
+	let generation = 0;
+	const unchangedSince = (start) => generation === start;
+	const admit = (key, data) => {
+		if (data.byteLength <= maxEntryBytes) cache.set(key, clone(data), { ttl: ttlForKey?.(key) });
+	};
+	/** Drop list entries a write/delete at `key` may have made stale. */
+	function clearStaleListEntries(key) {
+		for (const [listKey, entry] of listCache.entries()) {
+			if (!key.startsWith(entry.prefix)) continue;
+			if (entry.probe && !entry.empty) continue;
+			listCache.delete(listKey);
+		}
+		for (const listKey of pendingLists.keys()) {
+			const prefix = listKey.split("|").slice(2).join("|");
+			if (key.startsWith(prefix)) pendingLists.delete(listKey);
+		}
+	}
+	/** A write to `key` happened: no in-flight read of it may be joined or cached. */
+	function noteWrite(key) {
+		generation++;
+		pendingGets.delete(key);
+		pendingHeads.delete(key);
+	}
+	function coalesced(pending, key, fn) {
+		if (!coalesce) return fn();
+		const inflight = pending.get(key);
+		if (inflight !== void 0) return inflight;
+		const p = fn().finally(() => {
+			if (pending.get(key) === p) pending.delete(key);
+		});
+		pending.set(key, p);
+		return p;
+	}
+	return {
+		async get(key) {
+			const cached = cache.get(key);
+			if (cached !== void 0) {
+				onHit?.(key);
+				return cached === MISS ? null : clone(cached);
+			}
+			const data = await coalesced(pendingGets, key, async () => {
+				onMiss?.(key);
+				const start = generation;
+				const fetched = await store.get(key);
+				if (unchangedSince(start)) {
+					if (fetched !== null) admit(key, fetched);
+					else if (cacheMisses) cache.set(key, MISS, { ttl: ttlForKey?.(key) });
+				}
+				return fetched;
+			});
+			return data === null ? null : clone(data);
+		},
+		async put(key, data) {
+			noteWrite(key);
+			try {
+				await store.put(key, data);
+			} finally {
+				noteWrite(key);
+				cache.delete(key);
+				clearStaleListEntries(key);
+			}
+			admit(key, data);
+		},
+		async delete(key) {
+			noteWrite(key);
+			try {
+				await store.delete(key);
+			} finally {
+				noteWrite(key);
+				cache.delete(key);
+				clearStaleListEntries(key);
+			}
+			if (cacheMisses) cache.set(key, MISS, { ttl: ttlForKey?.(key) });
+			else cache.delete(key);
+		},
+		async head(key) {
+			const cached = cache.get(key);
+			if (cached !== void 0) {
+				onHit?.(key);
+				return cached === MISS ? null : { size: cached.byteLength };
+			}
+			return coalesced(pendingHeads, key, async () => {
+				onMiss?.(key);
+				const start = generation;
+				const stat = await store.head(key);
+				if (stat === null && cacheMisses && unchangedSince(start)) cache.set(key, MISS, { ttl: ttlForKey?.(key) });
+				return stat;
+			});
+		},
+		async list(prefix, listOptions) {
+			if (!cacheLists) return store.list(prefix, listOptions);
+			const listKey = `${listOptions?.delimiter ?? ""}|${listOptions?.limit ?? ""}|${prefix}`;
+			const cached = listCache.get(listKey);
+			if (cached !== void 0) {
+				onHit?.(prefix);
+				return copyListResult(cached.result);
+			}
+			return copyListResult(await coalesced(pendingLists, listKey, async () => {
+				onMiss?.(prefix);
+				const start = generation;
+				const fetched = await store.list(prefix, listOptions);
+				if (!unchangedSince(start)) return fetched;
+				listCache.set(listKey, {
+					result: copyListResult(fetched),
+					prefix,
+					probe: listOptions?.limit === 1,
+					empty: fetched.objects.length === 0 && fetched.prefixes.length === 0
+				}, { ttl: ttlForKey?.(prefix) });
+				return fetched;
+			}));
+		},
+		...range ? { getRange: (key, start, end) => range(key, start, end) } : {},
+		invalidate(prefix) {
+			generation++;
+			for (const key of [...pendingGets.keys()]) if (key.startsWith(prefix)) pendingGets.delete(key);
+			for (const key of [...pendingHeads.keys()]) if (key.startsWith(prefix)) pendingHeads.delete(key);
+			pendingLists.clear();
+			for (const key of cache.keys()) if (key.startsWith(prefix)) cache.delete(key);
+			for (const [listKey, entry] of listCache.entries()) if (entry.prefix.startsWith(prefix) || prefix.startsWith(entry.prefix)) listCache.delete(listKey);
+		}
+	};
 }
-
-// src/errors.ts
+//#endregion
+//#region src/errors.ts
+/**
+* Node-style filesystem error carrying a `code` property, which is what
+* isomorphic-git inspects to distinguish "file not found" from real failures.
+*/
 var FsError = class extends Error {
-  code;
-  syscall;
-  path;
-  constructor(code, syscall, path) {
-    super(`${code}: ${syscall} '${path}'`);
-    this.name = "FsError";
-    this.code = code;
-    this.syscall = syscall;
-    this.path = path;
-  }
+	code;
+	syscall;
+	path;
+	constructor(code, syscall, path) {
+		super(`${code}: ${syscall} '${path}'`);
+		this.name = "FsError";
+		this.code = code;
+		this.syscall = syscall;
+		this.path = path;
+	}
 };
-var enoent = (syscall, path) => new FsError("ENOENT", syscall, path);
-var enotdir = (syscall, path) => new FsError("ENOTDIR", syscall, path);
-var enotempty = (syscall, path) => new FsError("ENOTEMPTY", syscall, path);
-var einval = (syscall, path) => new FsError("EINVAL", syscall, path);
-var eperm = (syscall, path) => new FsError("EPERM", syscall, path);
-
-// src/git-fs.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
-
-// src/path.ts
+const enoent = (syscall, path) => new FsError("ENOENT", syscall, path);
+const enotdir = (syscall, path) => new FsError("ENOTDIR", syscall, path);
+const enotempty = (syscall, path) => new FsError("ENOTEMPTY", syscall, path);
+const einval = (syscall, path) => new FsError("EINVAL", syscall, path);
+const eperm = (syscall, path) => new FsError("EPERM", syscall, path);
+//#endregion
+//#region src/path.ts
+/**
+* Normalize an absolute-or-relative filesystem path into a storage key
+* segment: no leading/trailing slashes, `.` segments dropped, `..` resolved.
+* A `..` that would escape the root throws EINVAL — paths handed to the fs
+* must never address keys outside the configured prefix.
+*/
 function normalizePath(filepath) {
-  const segments = filepath.split("/");
-  const out = [];
-  for (const segment of segments) {
-    if (segment === "" || segment === ".") continue;
-    if (segment === "..") {
-      if (out.length === 0) throw einval("resolve", filepath);
-      out.pop();
-      continue;
-    }
-    out.push(segment);
-  }
-  return out.join("/");
+	const segments = filepath.split("/");
+	const out = [];
+	for (const segment of segments) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (out.length === 0) throw einval("resolve", filepath);
+			out.pop();
+			continue;
+		}
+		out.push(segment);
+	}
+	return out.join("/");
 }
+/** Join a configured key prefix with a normalized path. */
 function toKey(prefix, filepath) {
-  const normalized = normalizePath(filepath);
-  if (prefix === "") return normalized;
-  return normalized === "" ? prefix : `${prefix}/${normalized}`;
+	const normalized = normalizePath(filepath);
+	if (prefix === "") return normalized;
+	return normalized === "" ? prefix : `${prefix}/${normalized}`;
 }
-
-// src/git-fs.ts
-var FILE_MODE = 33188;
-var DIR_MODE = 16384;
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
+//#endregion
+//#region src/git-fs.ts
+const FILE_MODE = 33188;
+const DIR_MODE = 16384;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
 function makeStat(type, size) {
-  const epoch = /* @__PURE__ */ new Date(0);
-  return {
-    type,
-    mode: type === "file" ? FILE_MODE : DIR_MODE,
-    size,
-    ino: 0,
-    mtimeMs: 0,
-    ctimeMs: 0,
-    uid: 0,
-    gid: 0,
-    dev: 0,
-    mtime: epoch,
-    ctime: epoch,
-    isFile: () => type === "file",
-    isDirectory: () => type === "dir",
-    isSymbolicLink: () => false
-  };
+	const epoch = /* @__PURE__ */ new Date(0);
+	return {
+		type,
+		mode: type === "file" ? FILE_MODE : DIR_MODE,
+		size,
+		ino: 0,
+		mtimeMs: 0,
+		ctimeMs: 0,
+		uid: 0,
+		gid: 0,
+		dev: 0,
+		mtime: epoch,
+		ctime: epoch,
+		isFile: () => type === "file",
+		isDirectory: () => type === "dir",
+		isSymbolicLink: () => false
+	};
 }
 function resolveEncoding(options) {
-  if (typeof options === "string") return options;
-  return options?.encoding;
+	if (typeof options === "string") return options;
+	return options?.encoding;
 }
+/**
+* Create a promise-based filesystem client for isomorphic-git backed by an
+* {@link ObjectStore}.
+*
+* Semantics:
+* - Directories are implicit, as in object storage: `mkdir` is a no-op and a
+*   directory "exists" whenever at least one key lives under its prefix.
+* - Symbolic links are not supported (`readlink`/`symlink` throw). Bare
+*   repositories never contain them.
+* - Designed for bare, server-side repositories (`git.init({bare: true})`,
+*   plumbing commands, ref updates). Worktree checkouts belong on a real disk.
+*/
 function createGitFs(store, options = {}) {
-  const prefix = options.prefix ?? "";
-  const useLooseHints = options.looseObjectHints ?? false;
-  const onNote = options.onNote;
-  const toKey2 = (path) => toKey(prefix, path);
-  const looseHints = new LRUCache2({
-    max: 1024,
-    ttl: options.hintTtlMs ?? 36e5
-  });
-  const registeredGitdirs = new LRUCache2({
-    max: 4096
-  });
-  function registeredAbsent(path) {
-    const slash = path.lastIndexOf("/");
-    if (slash < 0) return false;
-    const absent = registeredGitdirs.get(path.slice(0, slash));
-    return absent?.has(path.slice(slash + 1)) ?? false;
-  }
-  function looseScope(path) {
-    return parseLooseObjectPath(path)?.gitdir ?? null;
-  }
-  const pendingDetections = /* @__PURE__ */ new Map();
-  async function knownAbsent(path) {
-    if (registeredAbsent(path)) return true;
-    if (!useLooseHints) return false;
-    const scope = looseScope(path);
-    if (scope === null) return false;
-    if (!looseHints.has(scope)) {
-      let pending = pendingDetections.get(scope);
-      if (!pending) {
-        pending = detectLooseObjects(scope).finally(
-          () => pendingDetections.delete(scope)
-        );
-        pendingDetections.set(scope, pending);
-      }
-      await pending;
-    }
-    return looseHints.get(scope) === "none";
-  }
-  async function isDirectory(dirKey) {
-    const { objects, prefixes } = await store.list(`${dirKey}/`, {
-      limit: 1
-    });
-    return objects.length > 0 || prefixes.length > 0;
-  }
-  async function stat(filepath, syscall) {
-    const path = normalizePath(filepath);
-    if (await knownAbsent(path)) throw enoent(syscall, filepath);
-    const k = toKey2(path);
-    if (k === prefix || k === "" || registeredGitdirs.has(path)) {
-      return makeStat("dir", 0);
-    }
-    const fileStat = await store.head(k);
-    if (fileStat) return makeStat("file", fileStat.size);
-    if (useLooseHints && looseScope(path) !== null) {
-      throw enoent(syscall, filepath);
-    }
-    if (await isDirectory(k)) return makeStat("dir", 0);
-    throw enoent(syscall, filepath);
-  }
-  const range = store.getRange?.bind(store);
-  const promises = {
-    // Only defined when the backing store supports ranges, so a caller can
-    // test for it rather than have to interpret a failure.
-    ...range ? {
-      getRange: (filepath, start, end) => range(toKey2(normalizePath(filepath)), start, end)
-    } : {},
-    async readFile(filepath, opts) {
-      const path = normalizePath(filepath);
-      if (await knownAbsent(path)) throw enoent("open", filepath);
-      const data = await store.get(toKey2(path));
-      if (data === null) throw enoent("open", filepath);
-      return resolveEncoding(opts) === "utf8" ? textDecoder.decode(data) : data;
-    },
-    async writeFile(filepath, data, _opts) {
-      const path = normalizePath(filepath);
-      if (useLooseHints) {
-        const scope = looseScope(path);
-        if (scope !== null) looseHints.set(scope, "present");
-      }
-      const bytes = typeof data === "string" ? textEncoder.encode(data) : data;
-      await store.put(toKey2(path), bytes);
-    },
-    async unlink(filepath) {
-      const k = toKey2(normalizePath(filepath));
-      if (await store.head(k) === null) throw enoent("unlink", filepath);
-      await store.delete(k);
-    },
-    async readdir(dirpath) {
-      const k = toKey2(normalizePath(dirpath));
-      const isRoot = k === prefix || k === "";
-      const listPrefix = isRoot && k === "" ? "" : `${k}/`;
-      const { objects, prefixes } = await store.list(listPrefix, {
-        delimiter: "/"
-      });
-      if (objects.length === 0 && prefixes.length === 0) {
-        if (!isRoot && await store.head(k) !== null) {
-          throw enotdir("scandir", dirpath);
-        }
-        if (!isRoot) throw enoent("scandir", dirpath);
-      }
-      const names = objects.map((o) => o.key.slice(listPrefix.length));
-      const dirNames = prefixes.map(
-        (p) => p.slice(listPrefix.length).replace(/\/$/, "")
-      );
-      return [...names, ...dirNames].sort();
-    },
-    async mkdir(_dirpath, _opts) {
-    },
-    async rmdir(dirpath) {
-      const k = toKey2(normalizePath(dirpath));
-      const { objects, prefixes } = await store.list(`${k}/`, { limit: 1 });
-      if (objects.length > 0 || prefixes.length > 0) {
-        throw enotempty("rmdir", dirpath);
-      }
-    },
-    stat: (filepath) => stat(filepath, "stat"),
-    lstat: (filepath) => stat(filepath, "lstat"),
-    async readlink(filepath) {
-      throw enoent("readlink", filepath);
-    },
-    async symlink(_target, filepath) {
-      throw eperm("symlink", filepath);
-    },
-    async chmod(_filepath, _mode) {
-    }
-  };
-  async function detectLooseObjects(gitdir) {
-    if (!useLooseHints) return;
-    const scope = normalizePath(gitdir);
-    if (looseHints.has(scope)) return;
-    try {
-      const { objects } = await store.list(`${toKey2(scope)}/objects/`, {
-        limit: 1
-      });
-      const first = objects[0]?.key;
-      const hint = first !== void 0 && parseLooseObjectPath(first) !== null ? "present" : "none";
-      looseHints.set(scope, hint);
-      onNote?.(`loose objects ${hint} under ${scope}`);
-    } catch {
-    }
-  }
-  async function prefetchPacks(gitdir, prefetchOptions) {
-    const maxPacks = prefetchOptions?.maxPacks ?? 30;
-    const packDir = `${normalizePath(gitdir)}/objects/pack`;
-    const entries = parsePackDirectory(
-      await promises.readdir(packDir).catch(() => [])
-    ).filter((file) => READABLE_PACK_FILE_KINDS.has(file.kind)).map((file) => file.name);
-    if (entries.length > maxPacks * 2) {
-      await detectLooseObjects(gitdir);
-      return;
-    }
-    await Promise.all([
-      detectLooseObjects(gitdir),
-      ...entries.map(
-        (name) => promises.readFile(`${packDir}/${name}`).catch(() => void 0)
-      )
-    ]);
-  }
-  async function listFilesRecursively(dirpath) {
-    const directory = toKey2(normalizePath(dirpath));
-    const listPrefix = directory === "" ? "" : `${directory}/`;
-    const { objects } = await store.list(listPrefix);
-    return objects.map((object) => object.key.slice(listPrefix.length)).filter((path) => path.length > 0).sort();
-  }
-  function registerGitdir(gitdir, facts) {
-    registeredGitdirs.set(
-      normalizePath(gitdir),
-      new Set(facts?.absentFiles ?? [])
-    );
-  }
-  function invalidate(pathPrefix) {
-    const normalized = normalizePath(pathPrefix);
-    for (const dir of registeredGitdirs.keys()) {
-      if (dir.startsWith(normalized)) registeredGitdirs.delete(dir);
-    }
-    for (const scope of looseHints.keys()) {
-      if (scope.startsWith(normalized)) looseHints.delete(scope);
-    }
-    const maybe = store;
-    maybe.invalidate?.(toKey2(normalized));
-  }
-  return {
-    promises,
-    listFilesRecursively,
-    detectLooseObjects,
-    prefetchPacks,
-    invalidate,
-    registerGitdir
-  };
+	const prefix = options.prefix ?? "";
+	const useLooseHints = options.looseObjectHints ?? false;
+	const onNote = options.onNote;
+	const toKey$1 = (path) => toKey(prefix, path);
+	/**
+	* Per-gitdir "does any loose object exist" hint. Entries are only created
+	* by {@link GitFs.detectLooseObjects}, so a pathological ref that merely
+	* looks like a loose object (`refs/heads/objects/aa/…`) derives a scope
+	* that was never registered and can never be wrongly short-circuited.
+	*/
+	const looseHints = new LRUCache({
+		max: 1024,
+		ttl: options.hintTtlMs ?? 36e5
+	});
+	/** Gitdirs the caller vouched for via {@link GitFs.registerGitdir}. */
+	const registeredGitdirs = new LRUCache({ max: 4096 });
+	/** Whether `path` is a top-level file its registered gitdir lacks. */
+	function registeredAbsent(path) {
+		const slash = path.lastIndexOf("/");
+		if (slash < 0) return false;
+		return registeredGitdirs.get(path.slice(0, slash))?.has(path.slice(slash + 1)) ?? false;
+	}
+	/** The gitdir scope of a loose-object path, or null when it isn't one. */
+	function looseScope(path) {
+		return parseLooseObjectPath(path)?.gitdir ?? null;
+	}
+	const pendingDetections = /* @__PURE__ */ new Map();
+	/**
+	* Resolve the loose-object hint for `path`'s gitdir before answering, so a
+	* read that runs before any explicit `detectLooseObjects` call (e.g. the
+	* first commit read of a request) doesn't pay a doomed GET. One coalesced
+	* listing per gitdir, cached for `hintTtlMs`.
+	*/
+	async function knownAbsent(path) {
+		if (registeredAbsent(path)) return true;
+		if (!useLooseHints) return false;
+		const scope = looseScope(path);
+		if (scope === null) return false;
+		if (!looseHints.has(scope)) {
+			let pending = pendingDetections.get(scope);
+			if (!pending) {
+				pending = detectLooseObjects(scope).finally(() => pendingDetections.delete(scope));
+				pendingDetections.set(scope, pending);
+			}
+			await pending;
+		}
+		return looseHints.get(scope) === "none";
+	}
+	async function isDirectory(dirKey) {
+		const { objects, prefixes } = await store.list(`${dirKey}/`, { limit: 1 });
+		return objects.length > 0 || prefixes.length > 0;
+	}
+	async function stat(filepath, syscall) {
+		const path = normalizePath(filepath);
+		if (await knownAbsent(path)) throw enoent(syscall, filepath);
+		const k = toKey$1(path);
+		if (k === prefix || k === "" || registeredGitdirs.has(path)) return makeStat("dir", 0);
+		const fileStat = await store.head(k);
+		if (fileStat) return makeStat("file", fileStat.size);
+		if (useLooseHints && looseScope(path) !== null) throw enoent(syscall, filepath);
+		if (await isDirectory(k)) return makeStat("dir", 0);
+		throw enoent(syscall, filepath);
+	}
+	const range = store.getRange?.bind(store);
+	const promises = {
+		...range ? { getRange: (filepath, start, end) => range(toKey$1(normalizePath(filepath)), start, end) } : {},
+		async readFile(filepath, opts) {
+			const path = normalizePath(filepath);
+			if (await knownAbsent(path)) throw enoent("open", filepath);
+			const data = await store.get(toKey$1(path));
+			if (data === null) throw enoent("open", filepath);
+			return resolveEncoding(opts) === "utf8" ? textDecoder.decode(data) : data;
+		},
+		async writeFile(filepath, data, _opts) {
+			const path = normalizePath(filepath);
+			if (useLooseHints) {
+				const scope = looseScope(path);
+				if (scope !== null) looseHints.set(scope, "present");
+			}
+			const bytes = typeof data === "string" ? textEncoder.encode(data) : data;
+			await store.put(toKey$1(path), bytes);
+		},
+		async unlink(filepath) {
+			const k = toKey$1(normalizePath(filepath));
+			if (await store.head(k) === null) throw enoent("unlink", filepath);
+			await store.delete(k);
+		},
+		async readdir(dirpath) {
+			const k = toKey$1(normalizePath(dirpath));
+			const isRoot = k === prefix || k === "";
+			const listPrefix = isRoot && k === "" ? "" : `${k}/`;
+			const { objects, prefixes } = await store.list(listPrefix, { delimiter: "/" });
+			if (objects.length === 0 && prefixes.length === 0) {
+				if (!isRoot && await store.head(k) !== null) throw enotdir("scandir", dirpath);
+				if (!isRoot) throw enoent("scandir", dirpath);
+			}
+			const names = objects.map((o) => o.key.slice(listPrefix.length));
+			const dirNames = prefixes.map((p) => p.slice(listPrefix.length).replace(/\/$/, ""));
+			return [...names, ...dirNames].sort();
+		},
+		async mkdir(_dirpath, _opts) {},
+		async rmdir(dirpath) {
+			const k = toKey$1(normalizePath(dirpath));
+			const { objects, prefixes } = await store.list(`${k}/`, { limit: 1 });
+			if (objects.length > 0 || prefixes.length > 0) throw enotempty("rmdir", dirpath);
+		},
+		stat: (filepath) => stat(filepath, "stat"),
+		lstat: (filepath) => stat(filepath, "lstat"),
+		async readlink(filepath) {
+			throw enoent("readlink", filepath);
+		},
+		async symlink(_target, filepath) {
+			throw eperm("symlink", filepath);
+		},
+		async chmod(_filepath, _mode) {}
+	};
+	async function detectLooseObjects(gitdir) {
+		if (!useLooseHints) return;
+		const scope = normalizePath(gitdir);
+		if (looseHints.has(scope)) return;
+		try {
+			const { objects } = await store.list(`${toKey$1(scope)}/objects/`, { limit: 1 });
+			const first = objects[0]?.key;
+			const hint = first !== void 0 && parseLooseObjectPath(first) !== null ? "present" : "none";
+			looseHints.set(scope, hint);
+			onNote?.(`loose objects ${hint} under ${scope}`);
+		} catch {}
+	}
+	async function prefetchPacks(gitdir, prefetchOptions) {
+		const maxPacks = prefetchOptions?.maxPacks ?? 30;
+		const packDir = `${normalizePath(gitdir)}/objects/pack`;
+		const entries = parsePackDirectory(await promises.readdir(packDir).catch(() => [])).filter((file) => READABLE_PACK_FILE_KINDS.has(file.kind)).map((file) => file.name);
+		if (entries.length > maxPacks * 2) {
+			await detectLooseObjects(gitdir);
+			return;
+		}
+		await Promise.all([detectLooseObjects(gitdir), ...entries.map((name) => promises.readFile(`${packDir}/${name}`).catch(() => void 0))]);
+	}
+	async function listFilesRecursively(dirpath) {
+		const directory = toKey$1(normalizePath(dirpath));
+		const listPrefix = directory === "" ? "" : `${directory}/`;
+		const { objects } = await store.list(listPrefix);
+		return objects.map((object) => object.key.slice(listPrefix.length)).filter((path) => path.length > 0).sort();
+	}
+	function registerGitdir(gitdir, facts) {
+		registeredGitdirs.set(normalizePath(gitdir), new Set(facts?.absentFiles ?? []));
+	}
+	function invalidate(pathPrefix) {
+		const normalized = normalizePath(pathPrefix);
+		for (const dir of registeredGitdirs.keys()) if (dir.startsWith(normalized)) registeredGitdirs.delete(dir);
+		for (const scope of looseHints.keys()) if (scope.startsWith(normalized)) looseHints.delete(scope);
+		store.invalidate?.(toKey$1(normalized));
+	}
+	return {
+		promises,
+		listFilesRecursively,
+		detectLooseObjects,
+		prefetchPacks,
+		invalidate,
+		registerGitdir
+	};
 }
-
-// src/prefix.ts
-var BATCH = 20;
+//#endregion
+//#region src/prefix.ts
+const BATCH = 20;
 async function inBatches(items, fn) {
-  for (let i = 0; i < items.length; i += BATCH) {
-    await Promise.all(items.slice(i, i + BATCH).map(fn));
-  }
+	for (let i = 0; i < items.length; i += BATCH) await Promise.all(items.slice(i, i + BATCH).map(fn));
 }
+/**
+* Delete every object under `prefix` (one paginated LIST, then batched
+* deletes). Returns the number of objects deleted. Callers serialise against
+* concurrent writers (e.g. a repository lock) and invalidate any cache
+* layered above `store`.
+*/
 async function deletePrefix(store, prefix) {
-  const { objects } = await store.list(prefix);
-  await inBatches(objects, (object) => store.delete(object.key));
-  return objects.length;
+	const { objects } = await store.list(prefix);
+	await inBatches(objects, (object) => store.delete(object.key));
+	return objects.length;
 }
+/**
+* Move every object under `from` to the same relative key under `to`: copy
+* everything first, then delete the old keys only once every copy succeeded,
+* so a failed copy leaves the source untouched (a partial destination may
+* remain; call {@link deletePrefix} on it to clean up). Returns the number of
+* objects moved. `from` and `to` must not overlap.
+*/
 async function movePrefix(store, from, to, options = {}) {
-  if (from.startsWith(to) || to.startsWith(from)) {
-    throw new Error(`movePrefix: prefixes overlap (${from} -> ${to})`);
-  }
-  const copy = options.copy ?? (async (fromKey, toKey2) => {
-    const data = await store.get(fromKey);
-    if (data) await store.put(toKey2, data);
-  });
-  const { objects } = await store.list(from);
-  await inBatches(
-    objects,
-    (object) => copy(object.key, to + object.key.slice(from.length))
-  );
-  await inBatches(objects, (object) => store.delete(object.key));
-  return objects.length;
+	if (from.startsWith(to) || to.startsWith(from)) throw new Error(`movePrefix: prefixes overlap (${from} -> ${to})`);
+	const copy = options.copy ?? (async (fromKey, toKey) => {
+		const data = await store.get(fromKey);
+		if (data) await store.put(toKey, data);
+	});
+	const { objects } = await store.list(from);
+	await inBatches(objects, (object) => copy(object.key, to + object.key.slice(from.length)));
+	await inBatches(objects, (object) => store.delete(object.key));
+	return objects.length;
 }
-
-// src/retry.ts
+//#endregion
+//#region src/retry.ts
+/**
+* Thrown instead of calling the backend while the circuit breaker is open.
+* Carries `code: "EUNAVAILABLE"` so callers can map it to a 503.
+*/
 var CircuitOpenError = class extends Error {
-  code = "EUNAVAILABLE";
-  constructor() {
-    super("Circuit breaker is open, object store unavailable");
-    this.name = "CircuitOpenError";
-  }
+	code = "EUNAVAILABLE";
+	constructor() {
+		super("Circuit breaker is open, object store unavailable");
+		this.name = "CircuitOpenError";
+	}
 };
-var RETRYABLE_NAMES = /* @__PURE__ */ new Set([
-  "TimeoutError",
-  "RequestTimeout",
-  "RequestTimeoutException",
-  "SlowDown",
-  "ThrottlingException",
-  "TooManyRequestsException"
+const RETRYABLE_NAMES = /* @__PURE__ */ new Set([
+	"TimeoutError",
+	"RequestTimeout",
+	"RequestTimeoutException",
+	"SlowDown",
+	"ThrottlingException",
+	"TooManyRequestsException"
 ]);
-var RETRYABLE_CODES = /* @__PURE__ */ new Set([
-  "ECONNRESET",
-  "ECONNREFUSED",
-  "EPIPE",
-  "ETIMEDOUT",
-  "ENOTFOUND",
-  "EAI_AGAIN",
-  "EPROTO"
+const RETRYABLE_CODES = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"EPIPE",
+	"ETIMEDOUT",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EPROTO"
 ]);
+/**
+* The default retry classifier: network faults, timeouts, throttling and HTTP
+* 5xx/429 (including `$metadata.httpStatusCode`-shaped errors). `fetch`
+* reports a dropped connection as a bare `TypeError`, which counts too.
+* Compose it in a custom `isRetryable`.
+*/
 function isRetryableError(error) {
-  if (error instanceof TypeError) return true;
-  if (typeof error !== "object" || error === null) return false;
-  const err = error;
-  if (err.name !== void 0 && RETRYABLE_NAMES.has(err.name)) return true;
-  if (err.code !== void 0 && RETRYABLE_CODES.has(err.code)) return true;
-  const status = err.$metadata?.httpStatusCode;
-  return status !== void 0 && (status >= 500 || status === 429);
+	if (error instanceof TypeError) return true;
+	if (typeof error !== "object" || error === null) return false;
+	const err = error;
+	if (err.name !== void 0 && RETRYABLE_NAMES.has(err.name)) return true;
+	if (err.code !== void 0 && RETRYABLE_CODES.has(err.code)) return true;
+	const status = err.$metadata?.httpStatusCode;
+	return status !== void 0 && (status >= 500 || status === 429);
 }
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Wrap an {@link ObjectStore} with retries (exponential backoff + jitter) and
+* an optional per-instance circuit breaker.
+*
+* Place this decorator closest to the network store, underneath any cache:
+* the cache then never stores transient failures, and callers coalesced onto
+* one request share a single retried attempt.
+*/
 function createRetryStore(store, options = {}) {
-  const retries = options.retries ?? 3;
-  const initialDelayMs = options.initialDelayMs ?? 100;
-  const maxDelayMs = options.maxDelayMs ?? 5e3;
-  const jitter = options.jitter ?? 0.3;
-  const isRetryable = options.isRetryable ?? isRetryableError;
-  const breaker = options.breaker === false ? null : {
-    threshold: options.breaker?.threshold ?? 5,
-    resetMs: options.breaker?.resetMs ?? 3e4
-  };
-  let failures = 0;
-  let lastFailureAt = 0;
-  let state = "closed";
-  let probing = false;
-  async function guarded(fn) {
-    if (breaker === null) return fn();
-    let isProbe = false;
-    if (state !== "closed") {
-      if (probing || state === "open" && Date.now() - lastFailureAt < breaker.resetMs) {
-        throw new CircuitOpenError();
-      }
-      state = "half-open";
-      probing = true;
-      isProbe = true;
-    }
-    try {
-      const result = await fn();
-      failures = 0;
-      state = "closed";
-      return result;
-    } catch (error) {
-      if (isRetryable(error)) {
-        failures++;
-        lastFailureAt = Date.now();
-        if (failures >= breaker.threshold || isProbe) state = "open";
-      } else if (isProbe) {
-        failures = 0;
-        state = "closed";
-      }
-      throw error;
-    } finally {
-      if (isProbe) probing = false;
-    }
-  }
-  async function run(op, key, fn) {
-    let lastError;
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        return await guarded(fn);
-      } catch (error) {
-        lastError = error;
-        if (error instanceof CircuitOpenError) throw error;
-        if (!isRetryable(error) || attempt === retries) throw error;
-        const base = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
-        const delayMs = Math.round(base + Math.random() * base * jitter);
-        options.onRetry?.({ key, op, attempt: attempt + 1, delayMs });
-        await sleep(delayMs);
-      }
-    }
-    throw lastError;
-  }
-  const range = store.getRange?.bind(store);
-  return {
-    get: (key) => run("get", key, () => store.get(key)),
-    put: (key, data) => run("put", key, () => store.put(key, data)),
-    delete: (key) => run("delete", key, () => store.delete(key)),
-    head: (key) => run("head", key, () => store.head(key)),
-    list: (prefix, listOptions) => run("list", prefix, () => store.list(prefix, listOptions)),
-    ...range ? {
-      getRange: (key, start, end) => run("getRange", key, () => range(key, start, end))
-    } : {}
-  };
+	const retries = options.retries ?? 3;
+	const initialDelayMs = options.initialDelayMs ?? 100;
+	const maxDelayMs = options.maxDelayMs ?? 5e3;
+	const jitter = options.jitter ?? .3;
+	const isRetryable = options.isRetryable ?? isRetryableError;
+	const breaker = options.breaker === false ? null : {
+		threshold: options.breaker?.threshold ?? 5,
+		resetMs: options.breaker?.resetMs ?? 3e4
+	};
+	let failures = 0;
+	let lastFailureAt = 0;
+	let state = "closed";
+	let probing = false;
+	/**
+	* Consecutive transient failures open the circuit; any success closes it
+	* and resets the count. Non-retryable errors (a 403, a malformed request)
+	* say nothing about the backend's health and never count. Once the reset
+	* window passes, exactly one request probes the backend (half-open);
+	* everything else keeps failing fast until that probe settles.
+	*/
+	async function guarded(fn) {
+		if (breaker === null) return fn();
+		let isProbe = false;
+		if (state !== "closed") {
+			if (probing || state === "open" && Date.now() - lastFailureAt < breaker.resetMs) throw new CircuitOpenError();
+			state = "half-open";
+			probing = true;
+			isProbe = true;
+		}
+		try {
+			const result = await fn();
+			failures = 0;
+			state = "closed";
+			return result;
+		} catch (error) {
+			if (isRetryable(error)) {
+				failures++;
+				lastFailureAt = Date.now();
+				if (failures >= breaker.threshold || isProbe) state = "open";
+			} else if (isProbe) {
+				failures = 0;
+				state = "closed";
+			}
+			throw error;
+		} finally {
+			if (isProbe) probing = false;
+		}
+	}
+	async function run(op, key, fn) {
+		let lastError;
+		for (let attempt = 0; attempt <= retries; attempt++) try {
+			return await guarded(fn);
+		} catch (error) {
+			lastError = error;
+			if (error instanceof CircuitOpenError) throw error;
+			if (!isRetryable(error) || attempt === retries) throw error;
+			const base = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
+			const delayMs = Math.round(base + Math.random() * base * jitter);
+			options.onRetry?.({
+				key,
+				op,
+				attempt: attempt + 1,
+				delayMs
+			});
+			await sleep(delayMs);
+		}
+		throw lastError;
+	}
+	const range = store.getRange?.bind(store);
+	return {
+		get: (key) => run("get", key, () => store.get(key)),
+		put: (key, data) => run("put", key, () => store.put(key, data)),
+		delete: (key) => run("delete", key, () => store.delete(key)),
+		head: (key) => run("head", key, () => store.head(key)),
+		list: (prefix, listOptions) => run("list", prefix, () => store.list(prefix, listOptions)),
+		...range ? { getRange: (key, start, end) => run("getRange", key, () => range(key, start, end)) } : {}
+	};
 }
-export {
-  CircuitOpenError,
-  FsError,
-  GitAuthenticationError,
-  GitAuthorizationError,
-  GitConflictError,
-  GitError,
-  GitInvalidRequestError,
-  GitObjectNotFoundError,
-  GitPathNotFoundError,
-  GitProtocolError,
-  GitRateLimitError,
-  GitRefNotFoundError,
-  GitRepositoryNotFoundError,
-  MemoryObjectStore,
-  PACK_FILE_KINDS,
-  READABLE_PACK_FILE_KINDS,
-  classifyGitdirPath,
-  concat,
-  createCachedStore,
-  createGitFs,
-  createRetryStore,
-  decodeAscii,
-  decodeUtf8,
-  deflate,
-  deletePrefix,
-  encodeUtf8,
-  formatErrorResponse,
-  fromHex,
-  getObjectSize,
-  hasNullByte,
-  isFullSha,
-  isMutableGitdirEntry,
-  isNotFoundError,
-  isRetryableError,
-  isSafeBranchName,
-  isSafeFullRefName,
-  isSafeRefName,
-  isSafeRepoPath,
-  isSafeTreePath,
-  movePrefix,
-  packFileName,
-  parseLooseObjectPath,
-  parsePackDirectory,
-  parsePackFileName,
-  qualifyBranchRef,
-  readBlobContent,
-  sha1,
-  toBase64,
-  toHex
-};
+//#endregion
+export { CircuitOpenError, FsError, GitAuthenticationError, GitAuthorizationError, GitConflictError, GitError, GitInvalidRequestError, GitObjectNotFoundError, GitPathNotFoundError, GitProtocolError, GitRateLimitError, GitRefNotFoundError, GitRepositoryNotFoundError, MemoryObjectStore, PACK_FILE_KINDS, READABLE_PACK_FILE_KINDS, classifyGitdirPath, concat, createCachedStore, createGitFs, createRetryStore, decodeAscii, decodeUtf8, deflate, deletePrefix, encodeUtf8, formatErrorResponse, fromHex, getObjectSize, hasNullByte, isAbsentError, isFullSha, isMutableGitdirEntry, isNotFoundError, isRetryableError, isSafeBranchName, isSafeFullRefName, isSafeRefName, isSafeRepoPath, isSafeTreePath, movePrefix, packFileName, parseLooseObjectPath, parsePackDirectory, parsePackFileName, qualifyBranchRef, readBlobContent, sha1, toBase64, toHex };
+
 //# sourceMappingURL=index.js.map