git-fs-s3 0.3.5

package/dist/index.cjs

@@ -0,0 +1,801 @@
+"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,
+  concat: () => concat,
+  createCachedStore: () => createCachedStore,
+  createGitFs: () => createGitFs,
+  createRetryStore: () => createRetryStore,
+  decodeAscii: () => decodeAscii,
+  decodeUtf8: () => decodeUtf8,
+  deflate: () => deflate,
+  encodeUtf8: () => encodeUtf8,
+  formatErrorResponse: () => formatErrorResponse,
+  fromHex: () => fromHex,
+  hasNullByte: () => hasNullByte,
+  isFullSha: () => isFullSha,
+  isSafeBranchName: () => isSafeBranchName,
+  isSafeFullRefName: () => isSafeFullRefName,
+  isSafeRefName: () => isSafeRefName,
+  isSafeRepoPath: () => isSafeRepoPath,
+  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 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, data.slice(), { 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 : cached.slice();
+      }
+      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 : data.slice();
+    },
+    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/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("/");
+}
+
+// src/git-fs.ts
+var FILE_MODE = 33188;
+var DIR_MODE = 16384;
+var LOOSE_OBJECT_RE = /(^|\/)objects\/[0-9a-f]{2}\/[0-9a-f]{38}$/;
+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 toKey = (path) => {
+    if (prefix === "") return path;
+    return path === "" ? prefix : `${prefix}/${path}`;
+  };
+  const looseHints = new import_lru_cache2.LRUCache({
+    max: 1024,
+    ttl: options.hintTtlMs ?? 36e5
+  });
+  function looseScope(path) {
+    const match = LOOSE_OBJECT_RE.exec(path);
+    if (match === null) return null;
+    return path.slice(0, match.index);
+  }
+  function knownAbsent(path) {
+    if (structurallyAbsent?.(path)) return true;
+    if (!useLooseHints) return false;
+    const scope = looseScope(path);
+    return scope !== null && 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 (knownAbsent(path)) throw enoent(syscall, filepath);
+    const k = toKey(path);
+    if (k === prefix || k === "") 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 (knownAbsent(path)) throw enoent("open", filepath);
+      const data = await store.get(toKey(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(toKey(path), bytes);
+    },
+    async unlink(filepath) {
+      const k = toKey(normalizePath(filepath));
+      if (await store.head(k) === null) throw enoent("unlink", filepath);
+      await store.delete(k);
+    },
+    async readdir(dirpath) {
+      const k = toKey(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(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(scope)}/objects/`, {
+        limit: 1
+      });
+      const first = objects[0]?.key;
+      const hint = first !== void 0 && LOOSE_OBJECT_RE.test(first) ? "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 = await promises.readdir(packDir).catch(() => []);
+    if (entries.length > maxPacks * 2) {
+      await detectLooseObjects(gitdir);
+      return;
+    }
+    await Promise.all([
+      detectLooseObjects(gitdir),
+      ...entries.map(
+        (name) => promises.readFile(`${packDir}/${name}`).catch(() => void 0)
+      )
+    ]);
+  }
+  function invalidate(pathPrefix) {
+    const normalized = normalizePath(pathPrefix);
+    for (const scope of looseHints.keys()) {
+      if (scope.startsWith(normalized)) looseHints.delete(scope);
+    }
+    const maybe = store;
+    maybe.invalidate?.(toKey(normalized));
+  }
+  return { promises, detectLooseObjects, prefetchPacks, invalidate };
+}
+
+// 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,
+  concat,
+  createCachedStore,
+  createGitFs,
+  createRetryStore,
+  decodeAscii,
+  decodeUtf8,
+  deflate,
+  encodeUtf8,
+  formatErrorResponse,
+  fromHex,
+  hasNullByte,
+  isFullSha,
+  isSafeBranchName,
+  isSafeFullRefName,
+  isSafeRefName,
+  isSafeRepoPath,
+  qualifyBranchRef,
+  readBlobContent,
+  sha1,
+  toBase64,
+  toHex
+});
+//# sourceMappingURL=index.cjs.map