git-edge 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,143 @@
+import { FsClient } from 'isomorphic-git';
+
+interface ParsedObjectCacheOptions {
+    /** Maximum estimated size in bytes (default: 256 MB). */
+    maxSize?: number;
+    /** Time-to-live in milliseconds (default: 1 hour). */
+    ttl?: number;
+}
+interface ParsedObjectStore {
+    get<T extends object>(key: string): T | null;
+    set<T extends object>(key: string, value: T): void;
+    delete(key: string): void;
+    /** Delete all keys matching a prefix. */
+    invalidatePrefix(prefix: string): void;
+}
+/**
+ * Create a parsed-object cache instance.
+ *
+ * `key` convention: `"${oid}:${format}"` or any caller-chosen string.
+ * `sizeCalculation` uses `JSON.stringify(v).length` as a byte estimate.
+ */
+declare function createParsedObjectCache(options?: ParsedObjectCacheOptions): ParsedObjectStore;
+
+/**
+ * Error types for git-edge.
+ *
+ * Edge-compatible: no node: imports.
+ */
+/** Base class for all git-edge errors. */
+declare class GitEdgeError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a three-way merge has unresolvable conflicts. */
+declare class GitMergeConflictError extends GitEdgeError {
+    readonly conflictingPaths: string[];
+    constructor(conflictingPaths: string[]);
+}
+
+/**
+ * Object-level three-way merge for isomorphic-git.
+ *
+ * Merges two commits by walking their trees directly — no worktree, no disk.
+ * Returns the merged commit OID, or throws MergeConflictError with the list of
+ * conflicting file paths.
+ *
+ * Edge-compatible: no node: imports, uses only isomorphic-git object APIs.
+ */
+
+/** Options for threeWayMerge. */
+interface MergeOpts {
+    /** Merge commit message (default: "Merge <source> into <target>"). */
+    message?: string;
+    /** Author name (default: "Git Edge"). */
+    authorName?: string;
+    /** Author email (default: "git-edge@local"). */
+    authorEmail?: string;
+}
+/** Result of a successful merge. */
+interface MergeResult {
+    commitOid: string;
+}
+/** Analysis of whether a merge is possible. */
+interface MergeAnalysis {
+    /** True if both refs resolved. */
+    canMerge: boolean;
+    /** True if source is an ancestor of target (fast-forward possible). */
+    fastForward: boolean;
+    /** True if source and target diverged. */
+    diverged: boolean;
+}
+/** The repo fs+gitdir shape used by isomorphic-git. */
+interface Repo$1 {
+    fs: FsClient;
+    gitdir: string;
+    cache?: object;
+}
+/**
+ * Analyze whether a merge is possible between two refs.
+ *
+ * Returns `canMerge`, `fastForward`, and `diverged` — does not attempt
+ * a real content merge (no conflict detection in analysis).
+ *
+ * `canMerge: false` means one of the refs didn't resolve (deleted branch,
+ * typo) — a `NotFoundError` from `git.resolveRef`. Any other failure (a
+ * network/storage error reading the ref, a corrupted repo) is rethrown
+ * rather than folded into `canMerge: false`, which would otherwise report
+ * "this branch doesn't exist" for a transient failure that has nothing to
+ * do with whether the branches can merge.
+ */
+declare function analyzeMerge(repo: Repo$1, sourceRef: string, targetRef: string): Promise<MergeAnalysis>;
+/**
+ * Perform an object-level three-way merge.
+ *
+ * - If source is an ancestor of target (fast-forward), moves target ref to source.
+ * - If target is an ancestor of source (reverse FF), moves target ref to source.
+ * - Otherwise, performs a true 3-way merge at the tree level.
+ *
+ * Throws `GitMergeConflictError` if the merge has unresolvable conflicts.
+ */
+declare function threeWayMerge(repo: Repo$1, sourceRef: string, targetRef: string, opts?: MergeOpts): Promise<MergeResult>;
+
+/**
+ * Repository management utilities.
+ *
+ * Edge-compatible helpers for isomorphic-git repos: bare repo init,
+ * packfile-only disk usage, and isomorphic-git cache management.
+ *
+ * No node: imports. The `fs` parameter is caller-provided.
+ */
+
+/** The repo fs+gitdir shape used by isomorphic-git. */
+interface Repo {
+    fs: FsClient;
+    gitdir: string;
+    cache?: object;
+}
+declare function getRepoCache(ownerKey: string, repoName: string): object;
+declare function invalidateRepoCache(ownerKey: string, repoName: string): void;
+/**
+ * Initialize a new bare git repository.
+ *
+ * Accepts any fs implementation — works with node:fs, S3-backed fs,
+ * or any isomorphic-git-compatible filesystem.
+ *
+ * Returns the gitdir path.
+ */
+declare function initBareRepo(repo: Repo, defaultBranch?: string): Promise<void>;
+/**
+ * Estimate the disk usage of a bare repo's git objects.
+ *
+ * This walks the loose object directories and reads `.pack` file sizes
+ * from the `objects/` directory. For S3-backed repos, this may be
+ * expensive — prefer tracking size at write time if possible.
+ *
+ * The caller must provide a `stat` function that works with their fs.
+ * For node:fs this is `fs.stat`; for edge runtimes it may be a HEAD
+ * request to the S3 object.
+ */
+declare function estimateRepoSize(repo: Repo, stat: (path: string) => Promise<{
+    size: number;
+}>, list: (path: string) => Promise<string[]>): Promise<number>;
+
+export { GitEdgeError, GitMergeConflictError, type MergeAnalysis, type MergeOpts, type MergeResult, type ParsedObjectCacheOptions, type ParsedObjectStore, type Repo$1 as Repo, analyzeMerge, createParsedObjectCache, estimateRepoSize, getRepoCache, initBareRepo, invalidateRepoCache, threeWayMerge };

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import { FsClient } from 'isomorphic-git';
+
+interface ParsedObjectCacheOptions {
+    /** Maximum estimated size in bytes (default: 256 MB). */
+    maxSize?: number;
+    /** Time-to-live in milliseconds (default: 1 hour). */
+    ttl?: number;
+}
+interface ParsedObjectStore {
+    get<T extends object>(key: string): T | null;
+    set<T extends object>(key: string, value: T): void;
+    delete(key: string): void;
+    /** Delete all keys matching a prefix. */
+    invalidatePrefix(prefix: string): void;
+}
+/**
+ * Create a parsed-object cache instance.
+ *
+ * `key` convention: `"${oid}:${format}"` or any caller-chosen string.
+ * `sizeCalculation` uses `JSON.stringify(v).length` as a byte estimate.
+ */
+declare function createParsedObjectCache(options?: ParsedObjectCacheOptions): ParsedObjectStore;
+
+/**
+ * Error types for git-edge.
+ *
+ * Edge-compatible: no node: imports.
+ */
+/** Base class for all git-edge errors. */
+declare class GitEdgeError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a three-way merge has unresolvable conflicts. */
+declare class GitMergeConflictError extends GitEdgeError {
+    readonly conflictingPaths: string[];
+    constructor(conflictingPaths: string[]);
+}
+
+/**
+ * Object-level three-way merge for isomorphic-git.
+ *
+ * Merges two commits by walking their trees directly — no worktree, no disk.
+ * Returns the merged commit OID, or throws MergeConflictError with the list of
+ * conflicting file paths.
+ *
+ * Edge-compatible: no node: imports, uses only isomorphic-git object APIs.
+ */
+
+/** Options for threeWayMerge. */
+interface MergeOpts {
+    /** Merge commit message (default: "Merge <source> into <target>"). */
+    message?: string;
+    /** Author name (default: "Git Edge"). */
+    authorName?: string;
+    /** Author email (default: "git-edge@local"). */
+    authorEmail?: string;
+}
+/** Result of a successful merge. */
+interface MergeResult {
+    commitOid: string;
+}
+/** Analysis of whether a merge is possible. */
+interface MergeAnalysis {
+    /** True if both refs resolved. */
+    canMerge: boolean;
+    /** True if source is an ancestor of target (fast-forward possible). */
+    fastForward: boolean;
+    /** True if source and target diverged. */
+    diverged: boolean;
+}
+/** The repo fs+gitdir shape used by isomorphic-git. */
+interface Repo$1 {
+    fs: FsClient;
+    gitdir: string;
+    cache?: object;
+}
+/**
+ * Analyze whether a merge is possible between two refs.
+ *
+ * Returns `canMerge`, `fastForward`, and `diverged` — does not attempt
+ * a real content merge (no conflict detection in analysis).
+ *
+ * `canMerge: false` means one of the refs didn't resolve (deleted branch,
+ * typo) — a `NotFoundError` from `git.resolveRef`. Any other failure (a
+ * network/storage error reading the ref, a corrupted repo) is rethrown
+ * rather than folded into `canMerge: false`, which would otherwise report
+ * "this branch doesn't exist" for a transient failure that has nothing to
+ * do with whether the branches can merge.
+ */
+declare function analyzeMerge(repo: Repo$1, sourceRef: string, targetRef: string): Promise<MergeAnalysis>;
+/**
+ * Perform an object-level three-way merge.
+ *
+ * - If source is an ancestor of target (fast-forward), moves target ref to source.
+ * - If target is an ancestor of source (reverse FF), moves target ref to source.
+ * - Otherwise, performs a true 3-way merge at the tree level.
+ *
+ * Throws `GitMergeConflictError` if the merge has unresolvable conflicts.
+ */
+declare function threeWayMerge(repo: Repo$1, sourceRef: string, targetRef: string, opts?: MergeOpts): Promise<MergeResult>;
+
+/**
+ * Repository management utilities.
+ *
+ * Edge-compatible helpers for isomorphic-git repos: bare repo init,
+ * packfile-only disk usage, and isomorphic-git cache management.
+ *
+ * No node: imports. The `fs` parameter is caller-provided.
+ */
+
+/** The repo fs+gitdir shape used by isomorphic-git. */
+interface Repo {
+    fs: FsClient;
+    gitdir: string;
+    cache?: object;
+}
+declare function getRepoCache(ownerKey: string, repoName: string): object;
+declare function invalidateRepoCache(ownerKey: string, repoName: string): void;
+/**
+ * Initialize a new bare git repository.
+ *
+ * Accepts any fs implementation — works with node:fs, S3-backed fs,
+ * or any isomorphic-git-compatible filesystem.
+ *
+ * Returns the gitdir path.
+ */
+declare function initBareRepo(repo: Repo, defaultBranch?: string): Promise<void>;
+/**
+ * Estimate the disk usage of a bare repo's git objects.
+ *
+ * This walks the loose object directories and reads `.pack` file sizes
+ * from the `objects/` directory. For S3-backed repos, this may be
+ * expensive — prefer tracking size at write time if possible.
+ *
+ * The caller must provide a `stat` function that works with their fs.
+ * For node:fs this is `fs.stat`; for edge runtimes it may be a HEAD
+ * request to the S3 object.
+ */
+declare function estimateRepoSize(repo: Repo, stat: (path: string) => Promise<{
+    size: number;
+}>, list: (path: string) => Promise<string[]>): Promise<number>;
+
+export { GitEdgeError, GitMergeConflictError, type MergeAnalysis, type MergeOpts, type MergeResult, type ParsedObjectCacheOptions, type ParsedObjectStore, type Repo$1 as Repo, analyzeMerge, createParsedObjectCache, estimateRepoSize, getRepoCache, initBareRepo, invalidateRepoCache, threeWayMerge };

package/dist/index.js

@@ -0,0 +1,403 @@
+// src/cache.ts
+import { LRUCache } from "lru-cache";
+function createParsedObjectCache(options) {
+  const maxSize = options?.maxSize ?? 256 * 1024 * 1024;
+  const ttl = options?.ttl ?? 3600 * 1e3;
+  const cache = new LRUCache({
+    maxSize,
+    sizeCalculation: (v) => JSON.stringify(v).length,
+    ttl
+  });
+  return {
+    get(key) {
+      return cache.get(key) ?? null;
+    },
+    set(key, value) {
+      cache.set(key, value);
+    },
+    delete(key) {
+      cache.delete(key);
+    },
+    invalidatePrefix(prefix) {
+      for (const k of cache.keys()) {
+        if (k.startsWith(prefix)) cache.delete(k);
+      }
+    }
+  };
+}
+
+// src/errors.ts
+var GitEdgeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitEdgeError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var GitMergeConflictError = class extends GitEdgeError {
+  conflictingPaths;
+  constructor(conflictingPaths) {
+    super(
+      `Merge conflict in ${conflictingPaths.length} file(s): ${conflictingPaths.join(", ")}`
+    );
+    this.name = "GitMergeConflictError";
+    this.conflictingPaths = conflictingPaths;
+  }
+};
+
+// src/merge.ts
+import git from "isomorphic-git";
+function defaultAuthor() {
+  return {
+    name: "Git Edge",
+    email: "git-edge@local",
+    timestamp: Math.floor(Date.now() / 1e3),
+    timezoneOffset: 0
+  };
+}
+async function flattenTreeDeep(repo, treeOid, prefix) {
+  const map = /* @__PURE__ */ new Map();
+  const entries = (await git.readTree({ ...repo, oid: treeOid })).tree;
+  await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = prefix ? `${prefix}/${entry.path}` : entry.path;
+      if (entry.type === "tree") {
+        const sub = await flattenTreeDeep(repo, entry.oid, fullPath);
+        for (const [k, v] of sub) map.set(k, v);
+      } else {
+        map.set(fullPath, entry.oid);
+      }
+    })
+  );
+  return map;
+}
+async function readBlob(repo, oid) {
+  const { blob } = await git.readBlob({ ...repo, oid });
+  return blob;
+}
+async function writeBlob(repo, content) {
+  return git.writeBlob({ ...repo, blob: content });
+}
+async function writeTreeObject(repo, entries) {
+  return git.writeObject({
+    ...repo,
+    type: "tree",
+    object: entries.map((e) => ({
+      path: e.path,
+      oid: e.oid,
+      mode: e.mode,
+      type: e.type
+    })),
+    format: "parsed"
+  });
+}
+async function writeTreeFromFlat(repo, flat) {
+  const root = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const [p, v] of flat) {
+    const slash = p.indexOf("/");
+    if (slash === -1) {
+      root.set(p, v);
+    } else {
+      const dir = p.slice(0, slash);
+      const rest = p.slice(slash + 1);
+      if (!children.has(dir)) children.set(dir, /* @__PURE__ */ new Map());
+      children.get(dir)?.set(rest, v);
+    }
+  }
+  const treeEntries = [];
+  for (const [name, { oid, mode }] of root) {
+    treeEntries.push({ path: name, oid, mode, type: "blob" });
+  }
+  for (const [dirName, subMap] of children) {
+    const subOid = await writeTreeFromFlat(repo, subMap);
+    treeEntries.push({
+      path: dirName,
+      oid: subOid,
+      mode: "040000",
+      type: "tree"
+    });
+  }
+  return writeTreeObject(repo, treeEntries);
+}
+function mergeContents(base, ours, theirs) {
+  const baseLines = decodeLines(base);
+  const oursLines = decodeLines(ours);
+  const theirsLines = decodeLines(theirs);
+  if (arraysEqual(baseLines, oursLines)) return theirs;
+  if (arraysEqual(baseLines, theirsLines)) return ours;
+  if (arraysEqual(oursLines, theirsLines)) return ours;
+  const result = [];
+  let bi = 0, oi = 0, ti = 0;
+  while (bi < baseLines.length || oi < oursLines.length || ti < theirsLines.length) {
+    const b = bi < baseLines.length ? baseLines[bi] : void 0;
+    const o = oi < oursLines.length ? oursLines[oi] : void 0;
+    const t = ti < theirsLines.length ? theirsLines[ti] : void 0;
+    if (b === o && b === t) {
+      result.push(b);
+      bi++;
+      oi++;
+      ti++;
+    } else if (b === o) {
+      result.push(t);
+      bi++;
+      oi++;
+      ti++;
+    } else if (b === t) {
+      result.push(o);
+      bi++;
+      oi++;
+      ti++;
+    } else {
+      result.push(`<<<<<<< ours`);
+      result.push(o);
+      result.push(`=======`);
+      result.push(t);
+      result.push(`>>>>>>> theirs`);
+      bi++;
+      oi++;
+      ti++;
+    }
+  }
+  return encodeLines(result);
+}
+function decodeLines(data) {
+  const text = new TextDecoder().decode(data);
+  if (text === "") return [];
+  return text.split("\n");
+}
+function encodeLines(lines) {
+  return new TextEncoder().encode(lines.join("\n"));
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+async function analyzeMerge(repo, sourceRef, targetRef) {
+  try {
+    const sourceOid = await git.resolveRef({ ...repo, ref: sourceRef });
+    const targetOid = await git.resolveRef({ ...repo, ref: targetRef });
+    const isDescendant = await git.isDescendent({
+      ...repo,
+      oid: sourceOid,
+      ancestor: targetOid
+    });
+    return {
+      canMerge: true,
+      fastForward: isDescendant,
+      diverged: !isDescendant
+    };
+  } catch (err) {
+    if (err?.code !== "NotFoundError") {
+      throw err;
+    }
+    return { canMerge: false, fastForward: false, diverged: false };
+  }
+}
+async function threeWayMerge(repo, sourceRef, targetRef, opts) {
+  const [sourceOid, targetOid] = await Promise.all([
+    git.resolveRef({ ...repo, ref: sourceRef }),
+    git.resolveRef({ ...repo, ref: targetRef })
+  ]);
+  if (sourceOid === targetOid) {
+    return { commitOid: sourceOid };
+  }
+  const isSourceAhead = await git.isDescendent({
+    ...repo,
+    oid: sourceOid,
+    ancestor: targetOid
+  });
+  if (isSourceAhead) {
+    await git.writeRef({
+      ...repo,
+      ref: targetRef,
+      value: sourceOid,
+      force: true
+    });
+    return { commitOid: sourceOid };
+  }
+  const isTargetAhead = await git.isDescendent({
+    ...repo,
+    oid: targetOid,
+    ancestor: sourceOid
+  });
+  if (isTargetAhead) {
+    await git.writeRef({
+      ...repo,
+      ref: targetRef,
+      value: sourceOid,
+      force: true
+    });
+    return { commitOid: sourceOid };
+  }
+  const baseOids = await git.findMergeBase({
+    ...repo,
+    oids: [sourceOid, targetOid]
+  });
+  if (!baseOids || baseOids.length === 0) {
+    throw new Error("No merge base found between source and target");
+  }
+  const baseOid = baseOids[0];
+  const [baseCommit, sourceCommit, targetCommit] = await Promise.all([
+    git.readCommit({ ...repo, oid: baseOid }),
+    git.readCommit({ ...repo, oid: sourceOid }),
+    git.readCommit({ ...repo, oid: targetOid })
+  ]);
+  const baseTreeOid = baseCommit.commit.tree;
+  const sourceTreeOid = sourceCommit.commit.tree;
+  const targetTreeOid = targetCommit.commit.tree;
+  const [baseMap, sourceMap, targetMap] = await Promise.all([
+    flattenTreeDeep(repo, baseTreeOid, ""),
+    flattenTreeDeep(repo, sourceTreeOid, ""),
+    flattenTreeDeep(repo, targetTreeOid, "")
+  ]);
+  const allPaths = /* @__PURE__ */ new Set([
+    ...baseMap.keys(),
+    ...sourceMap.keys(),
+    ...targetMap.keys()
+  ]);
+  const resultEntries = /* @__PURE__ */ new Map();
+  const conflictingPaths = [];
+  for (const filepath of allPaths) {
+    const baseOid2 = baseMap.get(filepath);
+    const sourceOid2 = sourceMap.get(filepath);
+    const targetOid2 = targetMap.get(filepath);
+    const _baseExists = baseOid2 !== void 0;
+    const sourceExists = sourceOid2 !== void 0;
+    const targetExists = targetOid2 !== void 0;
+    if (sourceExists && !targetExists) {
+      resultEntries.set(filepath, { oid: sourceOid2, mode: "100644" });
+    } else if (!sourceExists && targetExists) {
+      resultEntries.set(filepath, { oid: targetOid2, mode: "100644" });
+    } else if (sourceExists && targetExists) {
+      const sourceChanged = sourceOid2 !== baseOid2;
+      const targetChanged = targetOid2 !== baseOid2;
+      if (!sourceChanged && !targetChanged) {
+        resultEntries.set(filepath, { oid: targetOid2, mode: "100644" });
+      } else if (!sourceChanged) {
+        resultEntries.set(filepath, { oid: targetOid2, mode: "100644" });
+      } else if (!targetChanged) {
+        resultEntries.set(filepath, { oid: sourceOid2, mode: "100644" });
+      } else {
+        const [baseContent, sourceContent, targetContent] = await Promise.all([
+          readBlob(repo, baseOid2),
+          readBlob(repo, sourceOid2),
+          readBlob(repo, targetOid2)
+        ]);
+        if (baseContent.length === sourceContent.length && baseContent.every((b, i) => b === sourceContent[i])) {
+          resultEntries.set(filepath, { oid: targetOid2, mode: "100644" });
+        } else if (baseContent.length === targetContent.length && baseContent.every((b, i) => b === targetContent[i])) {
+          resultEntries.set(filepath, { oid: sourceOid2, mode: "100644" });
+        } else if (sourceContent.length === targetContent.length && sourceContent.every((b, i) => b === targetContent[i])) {
+          resultEntries.set(filepath, { oid: sourceOid2, mode: "100644" });
+        } else {
+          const merged = mergeContents(
+            baseContent,
+            sourceContent,
+            targetContent
+          );
+          const mergedText = new TextDecoder().decode(merged);
+          if (mergedText.includes("<<<<<<< ours") || mergedText.includes(">>>>>>> theirs")) {
+            conflictingPaths.push(filepath);
+            const mergedOid = await writeBlob(repo, merged);
+            resultEntries.set(filepath, { oid: mergedOid, mode: "100644" });
+          } else {
+            const mergedOid = await writeBlob(repo, merged);
+            resultEntries.set(filepath, { oid: mergedOid, mode: "100644" });
+          }
+        }
+      }
+    } else {
+    }
+  }
+  if (conflictingPaths.length > 0) {
+    throw new GitMergeConflictError(conflictingPaths);
+  }
+  const resultTreeOid = await writeTreeFromFlat(repo, resultEntries);
+  const author = opts?.authorName ? {
+    name: opts.authorName,
+    email: opts.authorEmail || "git-edge@local",
+    timestamp: Math.floor(Date.now() / 1e3),
+    timezoneOffset: 0
+  } : defaultAuthor();
+  const message = opts?.message || `Merge ${sourceRef} into ${targetRef}`;
+  const mergeCommitOid = await git.commit({
+    ...repo,
+    message,
+    tree: resultTreeOid,
+    parent: [targetOid, sourceOid],
+    author,
+    committer: author
+  });
+  await git.writeRef({
+    ...repo,
+    ref: targetRef,
+    value: mergeCommitOid,
+    force: true
+  });
+  return { commitOid: mergeCommitOid };
+}
+
+// src/repo.ts
+import git2 from "isomorphic-git";
+var repoCaches = /* @__PURE__ */ new Map();
+function getRepoCache(ownerKey, repoName) {
+  const key = `${ownerKey}/${repoName}`;
+  let cache = repoCaches.get(key);
+  if (!cache) {
+    cache = {};
+    repoCaches.set(key, cache);
+  }
+  return cache;
+}
+function invalidateRepoCache(ownerKey, repoName) {
+  repoCaches.delete(`${ownerKey}/${repoName}`);
+}
+async function initBareRepo(repo, defaultBranch = "main") {
+  await git2.init({
+    ...repo,
+    dir: repo.gitdir,
+    defaultBranch,
+    bare: true
+  });
+}
+async function estimateRepoSize(repo, stat, list) {
+  let total = 0;
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await list(dir);
+    } catch {
+      return;
+    }
+    const sizes = await Promise.all(
+      entries.map(async (name) => {
+        const fullPath = `${dir}/${name}`;
+        try {
+          const s = await stat(fullPath);
+          return s.size;
+        } catch {
+          return 0;
+        }
+      })
+    );
+    for (const size of sizes) total += size;
+  }
+  await walk(`${repo.gitdir}/objects`);
+  return total;
+}
+export {
+  GitEdgeError,
+  GitMergeConflictError,
+  analyzeMerge,
+  createParsedObjectCache,
+  estimateRepoSize,
+  getRepoCache,
+  initBareRepo,
+  invalidateRepoCache,
+  threeWayMerge
+};
+//# sourceMappingURL=index.js.map