git-fs-s3 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -1,944 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  CircuitOpenError: () => CircuitOpenError,
-  FsError: () => FsError,
-  GitAuthenticationError: () => GitAuthenticationError,
-  GitAuthorizationError: () => GitAuthorizationError,
-  GitConflictError: () => GitConflictError,
-  GitError: () => GitError,
-  GitInvalidRequestError: () => GitInvalidRequestError,
-  GitObjectNotFoundError: () => GitObjectNotFoundError,
-  GitPathNotFoundError: () => GitPathNotFoundError,
-  GitProtocolError: () => GitProtocolError,
-  GitRateLimitError: () => GitRateLimitError,
-  GitRefNotFoundError: () => GitRefNotFoundError,
-  GitRepositoryNotFoundError: () => GitRepositoryNotFoundError,
-  MemoryObjectStore: () => MemoryObjectStore,
-  PACK_FILE_KINDS: () => PACK_FILE_KINDS,
-  READABLE_PACK_FILE_KINDS: () => READABLE_PACK_FILE_KINDS,
-  classifyGitdirPath: () => classifyGitdirPath,
-  concat: () => concat,
-  createCachedStore: () => createCachedStore,
-  createGitFs: () => createGitFs,
-  createRetryStore: () => createRetryStore,
-  decodeAscii: () => decodeAscii,
-  decodeUtf8: () => decodeUtf8,
-  deflate: () => deflate,
-  encodeUtf8: () => encodeUtf8,
-  formatErrorResponse: () => formatErrorResponse,
-  fromHex: () => fromHex,
-  hasNullByte: () => hasNullByte,
-  isFullSha: () => isFullSha,
-  isMutableGitdirEntry: () => isMutableGitdirEntry,
-  isSafeBranchName: () => isSafeBranchName,
-  isSafeFullRefName: () => isSafeFullRefName,
-  isSafeRefName: () => isSafeRefName,
-  isSafeRepoPath: () => isSafeRepoPath,
-  packFileName: () => packFileName,
-  parseLooseObjectPath: () => parseLooseObjectPath,
-  parsePackDirectory: () => parsePackDirectory,
-  parsePackFileName: () => parsePackFileName,
-  qualifyBranchRef: () => qualifyBranchRef,
-  readBlobContent: () => readBlobContent,
-  sha1: () => sha1,
-  toBase64: () => toBase64,
-  toHex: () => toHex
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/cache.ts
-var import_lru_cache = require("lru-cache");
-var MISS = /* @__PURE__ */ 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;
-}
-function copyListResult(result) {
-  return {
-    objects: result.objects.map((o) => ({ ...o })),
-    prefixes: [...result.prefixes]
-  };
-}
-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 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 import_lru_cache.LRUCache({
-    maxSize: maxBytes,
-    sizeCalculation: (value) => value === MISS ? 1 : value.byteLength || 1,
-    ttl
-  });
-  const listCache = new import_lru_cache.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();
-  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);
-    }
-  }
-  function coalesced(pending, key, fn) {
-    if (!coalesce) return fn();
-    const inflight = pending.get(key);
-    if (inflight !== void 0) return inflight;
-    const p = fn().finally(() => 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 fetched = await store.get(key);
-        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) {
-      await store.put(key, data);
-      admit(key, data);
-      if (data.byteLength > maxEntryBytes) cache.delete(key);
-      clearStaleListEntries(key);
-    },
-    async delete(key) {
-      await store.delete(key);
-      if (cacheMisses) {
-        cache.set(key, MISS, { ttl: ttlForKey?.(key) });
-      } else {
-        cache.delete(key);
-      }
-      clearStaleListEntries(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 stat = await store.head(key);
-        if (stat === null && cacheMisses) {
-          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 fetched = await store.list(prefix, listOptions);
-        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);
-    },
-    invalidate(prefix) {
-      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/edge-utils.ts
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-function encodeUtf8(data) {
-  return textEncoder.encode(data);
-}
-function decodeUtf8(data) {
-  return textDecoder.decode(data);
-}
-function decodeAscii(data) {
-  let s = "";
-  for (let i = 0; i < data.length; i++)
-    s += String.fromCharCode(data[i]);
-  return s;
-}
-function concat(...parts) {
-  let total = 0;
-  for (const p of parts) total += p.length;
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const p of parts) {
-    out.set(p, offset);
-    offset += p.length;
-  }
-  return out;
-}
-function toHex(data) {
-  let hex = "";
-  for (let i = 0; i < data.length; i++)
-    hex += data[i].toString(16).padStart(2, "0");
-  return hex;
-}
-function toBase64(data) {
-  let binary = "";
-  for (let i = 0; i < data.length; i++)
-    binary += String.fromCharCode(data[i]);
-  return btoa(binary);
-}
-function fromHex(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-async function sha1(data) {
-  const bytes = typeof data === "string" ? encodeUtf8(data) : data;
-  const hash = await globalThis.crypto.subtle.digest("SHA-1", bytes);
-  return toHex(new Uint8Array(hash));
-}
-async function deflate(data) {
-  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate"));
-  return new Uint8Array(await new Response(stream).arrayBuffer());
-}
-function hasNullByte(data) {
-  return data.includes(0);
-}
-function readBlobContent(blob) {
-  const isBinary = hasNullByte(blob);
-  return {
-    isBinary,
-    text: isBinary ? "" : decodeUtf8(blob),
-    bytes: blob
-  };
-}
-
-// src/errors.ts
-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;
-  }
-};
-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-errors.ts
-var GitError = class extends Error {
-  statusCode;
-  retryable;
-  constructor(message, statusCode = 500, retryable = false) {
-    super(message);
-    this.name = this.constructor.name;
-    this.statusCode = statusCode;
-    this.retryable = retryable;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      error: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      retryable: this.retryable
-    };
-  }
-};
-var GitPathNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitObjectNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitRefNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitRepositoryNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitConflictError = class extends GitError {
-  conflicts;
-  constructor(message, conflicts = []) {
-    super(message, 409, false);
-    this.conflicts = conflicts;
-  }
-  toJSON() {
-    return { ...super.toJSON(), conflicts: this.conflicts };
-  }
-};
-var GitAuthenticationError = class extends GitError {
-  constructor(message) {
-    super(message, 401, false);
-  }
-};
-var GitAuthorizationError = class extends GitError {
-  constructor(message) {
-    super(message, 403, false);
-  }
-};
-var GitRateLimitError = class extends GitError {
-  constructor(message) {
-    super(message, 429, false);
-  }
-};
-var GitInvalidRequestError = class extends GitError {
-  constructor(message) {
-    super(message, 400, false);
-  }
-};
-var GitProtocolError = class extends GitError {
-  constructor(message) {
-    super(message, 400, false);
-  }
-};
-function formatErrorResponse(error) {
-  if (error instanceof GitError) {
-    return {
-      status: error.statusCode,
-      body: error.toJSON(),
-      headers: error.statusCode === 401 ? { "WWW-Authenticate": 'Basic realm="Git Repository"' } : void 0
-    };
-  }
-  if (error instanceof Error) {
-    return {
-      status: 500,
-      body: {
-        error: "InternalServerError",
-        message: "An internal error occurred",
-        retryable: true
-      }
-    };
-  }
-  return {
-    status: 500,
-    body: {
-      error: "UnknownError",
-      message: "An unknown error occurred",
-      retryable: true
-    }
-  };
-}
-
-// src/git-fs.ts
-var import_lru_cache2 = require("lru-cache");
-
-// src/pack-files.ts
-var PACK_FILE_KINDS = [
-  "pack",
-  "idx",
-  "keep",
-  "bitmap",
-  "rev"
-];
-var READABLE_PACK_FILE_KINDS = /* @__PURE__ */ new Set([
-  "pack",
-  "idx"
-]);
-var KNOWN_KINDS = new Set(PACK_FILE_KINDS);
-function isPackFileKind(value) {
-  return KNOWN_KINDS.has(value);
-}
-function parsePackFileName(name) {
-  const dot = name.lastIndexOf(".");
-  if (dot <= 0) return null;
-  const kind = name.slice(dot + 1);
-  if (!isPackFileKind(kind)) return null;
-  return { base: name.slice(0, dot), kind, name };
-}
-function packFileName(base, kind) {
-  return `${base}.${kind}`;
-}
-function parsePackDirectory(entries) {
-  return entries.map(parsePackFileName).filter((file) => file !== null);
-}
-
-// src/git-layout.ts
-var HEX = new Set("0123456789abcdef");
-function isHex(value, length) {
-  if (value.length !== length) return false;
-  for (const char of value) if (!HEX.has(char)) return false;
-  return true;
-}
-function classifyGitdirPath(path) {
-  const segments = path.split("/");
-  const [first, second, third, ...rest] = segments;
-  if (segments.length === 1) {
-    if (first === "HEAD") return { kind: "head" };
-    if (first === "config") return { kind: "config" };
-    if (first === "refs") return { kind: "refs", path };
-    return { kind: "other" };
-  }
-  if (first === "refs") return { kind: "refs", path };
-  if (first !== "objects" || second === void 0) return { kind: "other" };
-  if (segments.length === 2 && second === "") return { kind: "objects-dir" };
-  if (second === "pack" && third !== void 0 && rest.length === 0) {
-    if (third === "") return { kind: "pack-dir" };
-    const file = parsePackFileName(third);
-    return file ? { kind: "pack-file", file } : { kind: "other" };
-  }
-  if (third !== void 0 && rest.length === 0 && isHex(second, 2) && isHex(third, 38)) {
-    return { kind: "loose-object", oid: second + third };
-  }
-  return { kind: "other" };
-}
-function isMutableGitdirEntry(entry) {
-  switch (entry.kind) {
-    case "head":
-    case "refs":
-    case "objects-dir":
-    case "pack-dir":
-      return true;
-    default:
-      return false;
-  }
-}
-function parseLooseObjectPath(path) {
-  const segments = path.split("/");
-  if (segments.length < 3) return null;
-  const gitdirSegments = segments.slice(0, -3);
-  const entry = classifyGitdirPath(segments.slice(-3).join("/"));
-  if (entry.kind !== "loose-object") return null;
-  return { gitdir: gitdirSegments.join("/"), oid: entry.oid };
-}
-
-// src/path.ts
-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("/");
-}
-function toKey(prefix, filepath) {
-  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 textEncoder2 = new TextEncoder();
-var textDecoder2 = 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
-  };
-}
-function resolveEncoding(options) {
-  if (typeof options === "string") return options;
-  return options?.encoding;
-}
-function createGitFs(store, options = {}) {
-  const prefix = options.prefix ?? "";
-  const structurallyAbsent = options.isStructurallyAbsent;
-  const useLooseHints = options.looseObjectHints ?? false;
-  const onNote = options.onNote;
-  const toKey2 = (path) => toKey(prefix, path);
-  const looseHints = new import_lru_cache2.LRUCache({
-    max: 1024,
-    ttl: options.hintTtlMs ?? 36e5
-  });
-  const registeredGitdirs = new import_lru_cache2.LRUCache({
-    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 (structurallyAbsent?.(path) || 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 promises = {
-    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" ? textDecoder2.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" ? textEncoder2.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
-  };
-}
-
-// src/refs.ts
-var BAD_REF_COMPONENT = (
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what git's own ref-name rules reject — this needs to match the same range.
-  /(^|[/.])([/.]|$)|^@$|@\{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/
-);
-var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
-function isSafeFullRefName(ref) {
-  if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/tags/")) {
-    return false;
-  }
-  return !BAD_REF_COMPONENT.test(ref);
-}
-function isSafeBranchName(name) {
-  if (!name || name.startsWith("refs/") || name === "HEAD") return false;
-  if (FULL_SHA_RE.test(name)) return false;
-  return !BAD_REF_COMPONENT.test(name);
-}
-function isFullSha(value) {
-  return FULL_SHA_RE.test(value);
-}
-function isSafeRefName(value) {
-  return isSafeBranchName(value) || isFullSha(value);
-}
-function isSafeRepoPath(p) {
-  if (p.startsWith("/")) return false;
-  if (p.split("/").some((segment) => segment === "..")) return false;
-  if (/^\.git(\/|$)/i.test(p)) return false;
-  if (p.includes("\0")) return false;
-  return true;
-}
-function qualifyBranchRef(ref) {
-  if (ref.startsWith("refs/") || ref === "HEAD" || FULL_SHA_RE.test(ref)) {
-    return ref;
-  }
-  return `refs/heads/${ref}`;
-}
-
-// src/retry.ts
-var CircuitOpenError = class extends Error {
-  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"
-]);
-var RETRYABLE_CODES = /* @__PURE__ */ new Set([
-  "ECONNRESET",
-  "ECONNREFUSED",
-  "EPIPE",
-  "ETIMEDOUT",
-  "ENOTFOUND",
-  "EAI_AGAIN",
-  "EPROTO"
-]);
-function defaultIsRetryable(error) {
-  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));
-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 ?? defaultIsRetryable;
-  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";
-  async function guarded(fn) {
-    if (breaker === null) return fn();
-    if (state === "open") {
-      if (Date.now() - lastFailureAt < breaker.resetMs) {
-        throw new CircuitOpenError();
-      }
-      state = "half-open";
-    }
-    try {
-      const result = await fn();
-      if (state === "half-open") {
-        state = "closed";
-        failures = 0;
-      }
-      return result;
-    } catch (error) {
-      failures++;
-      lastFailureAt = Date.now();
-      if (failures >= breaker.threshold) state = "open";
-      throw error;
-    }
-  }
-  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;
-  }
-  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))
-  };
-}
-
-// src/stores/memory.ts
-var MemoryObjectStore = class {
-  objects = /* @__PURE__ */ new Map();
-  async get(key) {
-    const data = this.objects.get(key);
-    return data ? data.slice() : null;
-  }
-  async put(key, data) {
-    this.objects.set(key, data.slice());
-  }
-  async delete(key) {
-    this.objects.delete(key);
-  }
-  async head(key) {
-    const data = this.objects.get(key);
-    return data ? { size: data.byteLength } : null;
-  }
-  async list(prefix, options) {
-    const delimiter = options?.delimiter;
-    const limit = options?.limit ?? Number.POSITIVE_INFINITY;
-    const objects = [];
-    const prefixes = /* @__PURE__ */ new Set();
-    for (const [key, data] of this.objects) {
-      if (!key.startsWith(prefix)) continue;
-      const rest = key.slice(prefix.length);
-      if (delimiter !== void 0) {
-        const idx = rest.indexOf(delimiter);
-        if (idx !== -1) {
-          prefixes.add(prefix + rest.slice(0, idx + delimiter.length));
-        } else {
-          objects.push({ key, size: data.byteLength });
-        }
-      } else {
-        objects.push({ key, size: data.byteLength });
-      }
-      if (objects.length + prefixes.size >= limit) break;
-    }
-    return { objects, prefixes: [...prefixes] };
-  }
-  /** Number of stored objects (test convenience, not part of ObjectStore). */
-  get size() {
-    return this.objects.size;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  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,
-  encodeUtf8,
-  formatErrorResponse,
-  fromHex,
-  hasNullByte,
-  isFullSha,
-  isMutableGitdirEntry,
-  isSafeBranchName,
-  isSafeFullRefName,
-  isSafeRefName,
-  isSafeRepoPath,
-  packFileName,
-  parseLooseObjectPath,
-  parsePackDirectory,
-  parsePackFileName,
-  qualifyBranchRef,
-  readBlobContent,
-  sha1,
-  toBase64,
-  toHex
-});
-//# sourceMappingURL=index.cjs.map