@catmint-fs/git 0.0.0-prealpha.0

package/dist/index.js

@@ -0,0 +1,3871 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils.ts
+async function sha1(data) {
+  if (typeof globalThis.crypto?.subtle?.digest === "function") {
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-1", data);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const { createHash } = await import("crypto");
+  return createHash("sha1").update(data).digest("hex");
+}
+async function sha1Bytes(data) {
+  if (typeof globalThis.crypto?.subtle?.digest === "function") {
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-1", data);
+    return new Uint8Array(hashBuffer);
+  }
+  const { createHash } = await import("crypto");
+  const buf = createHash("sha1").update(data).digest();
+  return new Uint8Array(buf);
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function encode(str) {
+  return encoder.encode(str);
+}
+function decode(bytes) {
+  return decoder.decode(bytes);
+}
+function concat(...arrays) {
+  let totalLen = 0;
+  for (const a of arrays) totalLen += a.length;
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+function normalizePath(path) {
+  let p = path.replace(/^\.\//, "").replace(/\/+$/, "");
+  p = p.replace(/\/+/g, "/");
+  return p;
+}
+var encoder, decoder;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    encoder = new TextEncoder();
+    decoder = new TextDecoder();
+  }
+});
+
+// src/pack/read.ts
+var read_exports = {};
+__export(read_exports, {
+  PackReader: () => PackReader
+});
+import pako from "pako";
+function readVarint(data, pos) {
+  let value = 0;
+  let shift = 0;
+  let byte;
+  do {
+    byte = data[pos++];
+    value |= (byte & 127) << shift;
+    shift += 7;
+  } while (byte & 128);
+  return [value, pos];
+}
+function applyDelta(base, delta) {
+  let pos = 0;
+  [, pos] = readVarint(delta, pos);
+  let targetSize;
+  [targetSize, pos] = readVarint(delta, pos);
+  const result = new Uint8Array(targetSize);
+  let resultPos = 0;
+  while (pos < delta.length) {
+    const cmd = delta[pos++];
+    if (cmd & 128) {
+      let copyOffset = 0;
+      let copySize = 0;
+      if (cmd & 1) copyOffset = delta[pos++];
+      if (cmd & 2) copyOffset |= delta[pos++] << 8;
+      if (cmd & 4) copyOffset |= delta[pos++] << 16;
+      if (cmd & 8) copyOffset |= delta[pos++] << 24;
+      if (cmd & 16) copySize = delta[pos++];
+      if (cmd & 32) copySize |= delta[pos++] << 8;
+      if (cmd & 64) copySize |= delta[pos++] << 16;
+      if (copySize === 0) copySize = 65536;
+      result.set(base.subarray(copyOffset, copyOffset + copySize), resultPos);
+      resultPos += copySize;
+    } else if (cmd > 0) {
+      result.set(delta.subarray(pos, pos + cmd), resultPos);
+      resultPos += cmd;
+      pos += cmd;
+    } else {
+      throw new Error("Unexpected delta opcode 0");
+    }
+  }
+  return result;
+}
+function inflateWithConsumed(data, pos) {
+  const inf = new pako.Inflate({ raw: true });
+  inf.push(data.subarray(pos + 2), true);
+  if (inf.err) {
+    throw new Error(`Inflate error: ${inf.msg}`);
+  }
+  const result = inf.result;
+  const strm = inf.strm;
+  const rawConsumed = strm?.total_in ?? data.length - pos - 6;
+  return [result, 2 + rawConsumed + 4];
+}
+function readUint32(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+var OBJ_COMMIT, OBJ_TREE, OBJ_BLOB, OBJ_TAG, OBJ_OFS_DELTA, OBJ_REF_DELTA, TYPE_MAP, PackReader;
+var init_read = __esm({
+  "src/pack/read.ts"() {
+    "use strict";
+    init_utils();
+    OBJ_COMMIT = 1;
+    OBJ_TREE = 2;
+    OBJ_BLOB = 3;
+    OBJ_TAG = 4;
+    OBJ_OFS_DELTA = 6;
+    OBJ_REF_DELTA = 7;
+    TYPE_MAP = {
+      [OBJ_COMMIT]: "commit",
+      [OBJ_TREE]: "tree",
+      [OBJ_BLOB]: "blob",
+      [OBJ_TAG]: "tag"
+    };
+    PackReader = class {
+      constructor(layer, packPath, idxPath) {
+        this.layer = layer;
+        this.packPath = packPath;
+        this.idxPath = idxPath;
+      }
+      packData = null;
+      index = null;
+      async readObject(oid) {
+        await this.ensureLoaded();
+        if (!this.index) return null;
+        const offset = this.index.offsets.get(oid);
+        if (offset === void 0) return null;
+        return this.readObjectAtOffset(offset);
+      }
+      /**
+       * Extract all objects from the packfile without requiring an index.
+       * Parses the pack header to get the object count, then reads each object
+       * sequentially.
+       */
+      async extractAll() {
+        if (!this.packData) {
+          this.packData = await this.layer.readFile(this.packPath);
+        }
+        const data = this.packData;
+        const objects = [];
+        if (data.length < 12) {
+          throw new Error("Pack data too short");
+        }
+        const version = readUint32(data, 4);
+        const objectCount = readUint32(data, 8);
+        let pos = 12;
+        for (let i = 0; i < objectCount; i++) {
+          const startPos = pos;
+          let byte = data[pos++];
+          const type = byte >> 4 & 7;
+          let size = byte & 15;
+          let shift = 4;
+          while (byte & 128) {
+            byte = data[pos++];
+            size |= (byte & 127) << shift;
+            shift += 7;
+          }
+          if (type === OBJ_OFS_DELTA) {
+            byte = data[pos++];
+            let negOffset = byte & 127;
+            while (byte & 128) {
+              byte = data[pos++];
+              negOffset = negOffset + 1 << 7 | byte & 127;
+            }
+            const baseOffset = startPos - negOffset;
+            const base = this.readObjectAtOffset(baseOffset);
+            const [deltaData, consumed] = inflateWithConsumed(data, pos);
+            pos += consumed;
+            const result = applyDelta(base.content, deltaData);
+            objects.push({ type: base.type, content: result });
+          } else if (type === OBJ_REF_DELTA) {
+            const baseSha = bytesToHex(data.subarray(pos, pos + 20));
+            pos += 20;
+            let baseObj;
+            if (this.index) {
+              const baseOffset = this.index.offsets.get(baseSha);
+              if (baseOffset !== void 0) {
+                baseObj = this.readObjectAtOffset(baseOffset);
+              }
+            }
+            if (!baseObj) {
+              throw new Error(`Base object not found in pack: ${baseSha}`);
+            }
+            const [deltaData, consumed] = inflateWithConsumed(data, pos);
+            pos += consumed;
+            const result = applyDelta(baseObj.content, deltaData);
+            objects.push({ type: baseObj.type, content: result });
+          } else {
+            const typeName = TYPE_MAP[type];
+            if (!typeName) {
+              throw new Error(`Unknown pack object type: ${type}`);
+            }
+            const [content, consumed] = inflateWithConsumed(data, pos);
+            pos += consumed;
+            objects.push({ type: typeName, content });
+          }
+        }
+        return objects;
+      }
+      async ensureLoaded() {
+        if (this.packData && (this.index || !this.idxPath)) return;
+        this.packData = await this.layer.readFile(this.packPath);
+        if (this.idxPath) {
+          const idxData = await this.layer.readFile(this.idxPath);
+          this.index = this.parseIndex(idxData);
+        }
+      }
+      parseIndex(data) {
+        const offsets = /* @__PURE__ */ new Map();
+        if (data[0] !== 255 || data[1] !== 116 || data[2] !== 79 || data[3] !== 99) {
+          return { offsets };
+        }
+        const version = readUint32(data, 4);
+        if (version !== 2) return { offsets };
+        const fanoutStart = 8;
+        const totalObjects = readUint32(data, fanoutStart + 255 * 4);
+        const shaStart = fanoutStart + 256 * 4;
+        const crcStart = shaStart + totalObjects * 20;
+        const offsetStart = crcStart + totalObjects * 4;
+        for (let i = 0; i < totalObjects; i++) {
+          const shaBytes = data.subarray(shaStart + i * 20, shaStart + (i + 1) * 20);
+          const oid = bytesToHex(shaBytes);
+          const offset = readUint32(data, offsetStart + i * 4);
+          offsets.set(oid, offset);
+        }
+        return { offsets };
+      }
+      readObjectAtOffset(offset) {
+        const data = this.packData;
+        let pos = offset;
+        let byte = data[pos++];
+        const type = byte >> 4 & 7;
+        let size = byte & 15;
+        let shift = 4;
+        while (byte & 128) {
+          byte = data[pos++];
+          size |= (byte & 127) << shift;
+          shift += 7;
+        }
+        if (type === OBJ_OFS_DELTA) {
+          return this.readOfsDelta(pos, offset, size);
+        }
+        if (type === OBJ_REF_DELTA) {
+          return this.readRefDelta(pos, size);
+        }
+        const typeName = TYPE_MAP[type];
+        if (!typeName) {
+          throw new Error(`Unknown pack object type: ${type}`);
+        }
+        const content = pako.inflate(data.subarray(pos));
+        return { type: typeName, content };
+      }
+      readOfsDelta(pos, currentOffset, _size) {
+        const data = this.packData;
+        let byte = data[pos++];
+        let negOffset = byte & 127;
+        while (byte & 128) {
+          byte = data[pos++];
+          negOffset = negOffset + 1 << 7 | byte & 127;
+        }
+        const baseOffset = currentOffset - negOffset;
+        const base = this.readObjectAtOffset(baseOffset);
+        const deltaData = pako.inflate(data.subarray(pos));
+        const result = applyDelta(base.content, deltaData);
+        return { type: base.type, content: result };
+      }
+      readRefDelta(pos, _size) {
+        const data = this.packData;
+        const baseSha = bytesToHex(data.subarray(pos, pos + 20));
+        pos += 20;
+        const baseOffset = this.index.offsets.get(baseSha);
+        if (baseOffset === void 0) {
+          throw new Error(`Base object not found in pack: ${baseSha}`);
+        }
+        const base = this.readObjectAtOffset(baseOffset);
+        const deltaData = pako.inflate(data.subarray(pos));
+        const result = applyDelta(base.content, deltaData);
+        return { type: base.type, content: result };
+      }
+    };
+  }
+});
+
+// src/object-db.ts
+init_utils();
+import pako2 from "pako";
+
+// src/errors.ts
+var GitError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "GitError";
+    this.code = code;
+  }
+};
+
+// src/object-db.ts
+init_read();
+var ObjectDB = class {
+  constructor(layer, gitDir) {
+    this.layer = layer;
+    this.gitDir = gitDir;
+  }
+  // ---- Write objects -----------------------------------------------------
+  async writeObject(type, content) {
+    const header = encode(`${type} ${content.length}\0`);
+    const store = concat(header, content);
+    const oid = await sha1(store);
+    const dir = `${this.gitDir}/objects/${oid.substring(0, 2)}`;
+    const filePath = `${dir}/${oid.substring(2)}`;
+    if (await this.layer.exists(filePath)) {
+      return oid;
+    }
+    await this.layer.mkdir(dir, { recursive: true });
+    const compressed = pako2.deflate(store);
+    await this.layer.writeFile(filePath, compressed);
+    return oid;
+  }
+  // ---- Read objects ------------------------------------------------------
+  async readObject(oid) {
+    const dir = oid.substring(0, 2);
+    const file = oid.substring(2);
+    const loosePath = `${this.gitDir}/objects/${dir}/${file}`;
+    if (await this.layer.exists(loosePath)) {
+      const compressed = await this.layer.readFile(loosePath);
+      const data = pako2.inflate(compressed);
+      return this.parseRawObject(data, oid);
+    }
+    const packResult = await this.readFromPacks(oid);
+    if (packResult) return packResult;
+    throw new GitError("INVALID_OBJECT", `Object not found: ${oid}`);
+  }
+  async existsObject(oid) {
+    const dir = oid.substring(0, 2);
+    const file = oid.substring(2);
+    const loosePath = `${this.gitDir}/objects/${dir}/${file}`;
+    if (await this.layer.exists(loosePath)) return true;
+    try {
+      const packResult = await this.readFromPacks(oid);
+      return packResult !== null;
+    } catch {
+      return false;
+    }
+  }
+  // ---- Parse raw git object ----------------------------------------------
+  parseRawObject(data, oid) {
+    let nullIdx = -1;
+    for (let i = 0; i < data.length; i++) {
+      if (data[i] === 0) {
+        nullIdx = i;
+        break;
+      }
+    }
+    if (nullIdx < 0) {
+      throw new GitError("INVALID_OBJECT", `Malformed object: ${oid}`);
+    }
+    const header = decode(data.subarray(0, nullIdx));
+    const spaceIdx = header.indexOf(" ");
+    if (spaceIdx < 0) {
+      throw new GitError("INVALID_OBJECT", `Malformed object header: ${oid}`);
+    }
+    const type = header.substring(0, spaceIdx);
+    const content = data.subarray(nullIdx + 1);
+    return { type, content };
+  }
+  // ---- Packfile search ---------------------------------------------------
+  async readFromPacks(oid) {
+    const packDir = `${this.gitDir}/objects/pack`;
+    if (!await this.layer.exists(packDir)) return null;
+    const entries = await this.layer.readdir(packDir);
+    for (const entry of entries) {
+      if (!entry.name.endsWith(".idx")) continue;
+      const baseName = entry.name.replace(/\.idx$/, "");
+      const idxPath = `${packDir}/${entry.name}`;
+      const packPath = `${packDir}/${baseName}.pack`;
+      if (!await this.layer.exists(packPath)) continue;
+      const reader = new PackReader(this.layer, packPath, idxPath);
+      const obj = await reader.readObject(oid);
+      if (obj) return obj;
+    }
+    return null;
+  }
+  // ---- High-level object construction ------------------------------------
+  async writeBlob(content) {
+    return this.writeObject("blob", content);
+  }
+  async writeTree(entries) {
+    const sorted = [...entries].sort((a, b) => {
+      const aName = a.mode.startsWith("40") ? a.name + "/" : a.name;
+      const bName = b.mode.startsWith("40") ? b.name + "/" : b.name;
+      return aName < bName ? -1 : aName > bName ? 1 : 0;
+    });
+    const parts = [];
+    for (const entry of sorted) {
+      const modeName = encode(`${entry.mode} ${entry.name}\0`);
+      const shaBytes = hexToBytes(entry.oid);
+      parts.push(modeName, shaBytes);
+    }
+    return this.writeObject("tree", concat(...parts));
+  }
+  parseTree(content) {
+    const entries = [];
+    let offset = 0;
+    while (offset < content.length) {
+      let spaceIdx = offset;
+      while (spaceIdx < content.length && content[spaceIdx] !== 32) spaceIdx++;
+      const mode = decode(content.subarray(offset, spaceIdx));
+      let nullIdx = spaceIdx + 1;
+      while (nullIdx < content.length && content[nullIdx] !== 0) nullIdx++;
+      const name = decode(content.subarray(spaceIdx + 1, nullIdx));
+      const shaBytes = content.subarray(nullIdx + 1, nullIdx + 21);
+      const oid = bytesToHex(shaBytes);
+      entries.push({ mode, name, oid });
+      offset = nullIdx + 21;
+    }
+    return entries;
+  }
+  async writeCommit(tree, parents, author, committer, message) {
+    let content = `tree ${tree}
+`;
+    for (const parent of parents) {
+      content += `parent ${parent}
+`;
+    }
+    content += `author ${formatIdentity(author)}
+`;
+    content += `committer ${formatIdentity(committer)}
+`;
+    content += `
+${message}`;
+    return this.writeObject("commit", encode(content));
+  }
+  parseCommit(content) {
+    const text = decode(content);
+    const headerEnd = text.indexOf("\n\n");
+    const headerPart = headerEnd >= 0 ? text.substring(0, headerEnd) : text;
+    const message = headerEnd >= 0 ? text.substring(headerEnd + 2) : "";
+    const lines = headerPart.split("\n");
+    let tree = "";
+    const parents = [];
+    let author;
+    let committer;
+    for (const line of lines) {
+      if (line.startsWith("tree ")) {
+        tree = line.substring(5);
+      } else if (line.startsWith("parent ")) {
+        parents.push(line.substring(7));
+      } else if (line.startsWith("author ")) {
+        author = parseIdentity(line.substring(7));
+      } else if (line.startsWith("committer ")) {
+        committer = parseIdentity(line.substring(10));
+      }
+    }
+    if (!author || !committer) {
+      throw new GitError(
+        "INVALID_OBJECT",
+        "Commit missing author or committer"
+      );
+    }
+    return { tree, parents, author, committer, message };
+  }
+  async writeTag(object, type, tagName, tagger, message) {
+    let content = `object ${object}
+`;
+    content += `type ${type}
+`;
+    content += `tag ${tagName}
+`;
+    content += `tagger ${formatIdentity(tagger)}
+`;
+    content += `
+${message}`;
+    return this.writeObject("tag", encode(content));
+  }
+  parseTag(content) {
+    const text = decode(content);
+    const headerEnd = text.indexOf("\n\n");
+    const headerPart = headerEnd >= 0 ? text.substring(0, headerEnd) : text;
+    const message = headerEnd >= 0 ? text.substring(headerEnd + 2) : "";
+    const lines = headerPart.split("\n");
+    let object = "";
+    let type = "commit";
+    let tag = "";
+    let tagger;
+    for (const line of lines) {
+      if (line.startsWith("object ")) object = line.substring(7);
+      else if (line.startsWith("type ")) type = line.substring(5);
+      else if (line.startsWith("tag ")) tag = line.substring(4);
+      else if (line.startsWith("tagger ")) tagger = parseIdentity(line.substring(7));
+    }
+    if (!tagger) {
+      throw new GitError("INVALID_OBJECT", "Tag missing tagger");
+    }
+    return { object, type, tag, tagger, message };
+  }
+  // ---- Hash object without writing (for comparison) ----------------------
+  async hashObject(type, content) {
+    const header = encode(`${type} ${content.length}\0`);
+    const store = concat(header, content);
+    return sha1(store);
+  }
+};
+function formatIdentity(id) {
+  const sign = id.timezoneOffset >= 0 ? "+" : "-";
+  const absOffset = Math.abs(id.timezoneOffset);
+  const hours = Math.floor(absOffset / 60).toString().padStart(2, "0");
+  const minutes = (absOffset % 60).toString().padStart(2, "0");
+  return `${id.name} <${id.email}> ${id.timestamp} ${sign}${hours}${minutes}`;
+}
+function parseIdentity(str) {
+  const emailStart = str.indexOf("<");
+  const emailEnd = str.indexOf(">");
+  if (emailStart < 0 || emailEnd < 0) {
+    throw new GitError("INVALID_OBJECT", `Invalid identity: ${str}`);
+  }
+  const name = str.substring(0, emailStart).trim();
+  const email = str.substring(emailStart + 1, emailEnd);
+  const rest = str.substring(emailEnd + 1).trim();
+  const parts = rest.split(" ");
+  const timestamp = parseInt(parts[0], 10);
+  const tz = parts[1] || "+0000";
+  const tzSign = tz.startsWith("-") ? -1 : 1;
+  const tzHours = parseInt(tz.substring(1, 3), 10);
+  const tzMinutes = parseInt(tz.substring(3, 5), 10);
+  const timezoneOffset = tzSign * (tzHours * 60 + tzMinutes);
+  return { name, email, timestamp, timezoneOffset };
+}
+
+// src/ref-store.ts
+init_utils();
+var RefStore = class {
+  constructor(layer, gitDir) {
+    this.layer = layer;
+    this.gitDir = gitDir;
+  }
+  // ---- Read refs ---------------------------------------------------------
+  async readRef(ref) {
+    const path = `${this.gitDir}/${ref}`;
+    if (!await this.layer.exists(path)) {
+      return this.readPackedRef(ref);
+    }
+    const content = decode(await this.layer.readFile(path)).trim();
+    if (content.startsWith("ref: ")) {
+      return null;
+    }
+    return content;
+  }
+  async readSymbolicRef(ref) {
+    const path = `${this.gitDir}/${ref}`;
+    if (!await this.layer.exists(path)) return null;
+    const content = decode(await this.layer.readFile(path)).trim();
+    if (content.startsWith("ref: ")) {
+      return content.substring(5);
+    }
+    return null;
+  }
+  async resolveRef(ref) {
+    return this.resolveRefInner(ref, 0);
+  }
+  async resolveRefInner(ref, depth) {
+    if (depth > 10) {
+      throw new GitError("INVALID_OBJECT", `Ref loop detected: ${ref}`);
+    }
+    if (/^[0-9a-f]{40}$/.test(ref)) {
+      return ref;
+    }
+    const path = `${this.gitDir}/${ref}`;
+    if (await this.layer.exists(path)) {
+      const content = decode(await this.layer.readFile(path)).trim();
+      if (content.startsWith("ref: ")) {
+        return this.resolveRefInner(content.substring(5), depth + 1);
+      }
+      if (/^[0-9a-f]{40}$/.test(content)) {
+        return content;
+      }
+    }
+    const packed = await this.readPackedRef(ref);
+    if (packed) return packed;
+    throw new GitError("NOT_FOUND", `Ref not found: ${ref}`);
+  }
+  // ---- Resolve short ref names ------------------------------------------
+  async expandRef(shortName) {
+    const candidates = [
+      shortName,
+      `refs/${shortName}`,
+      `refs/tags/${shortName}`,
+      `refs/heads/${shortName}`,
+      `refs/remotes/${shortName}`,
+      `refs/remotes/${shortName}/HEAD`
+    ];
+    for (const candidate of candidates) {
+      try {
+        await this.resolveRef(candidate);
+        return candidate;
+      } catch {
+      }
+    }
+    if (/^[0-9a-f]{40}$/.test(shortName)) {
+      return shortName;
+    }
+    throw new GitError("NOT_FOUND", `Ref not found: ${shortName}`);
+  }
+  // ---- Write refs --------------------------------------------------------
+  async writeRef(ref, oid) {
+    const path = `${this.gitDir}/${ref}`;
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    await this.layer.mkdir(dir, { recursive: true });
+    await this.layer.writeFile(path, encode(`${oid}
+`));
+  }
+  async writeSymbolicRef(ref, target) {
+    const path = `${this.gitDir}/${ref}`;
+    await this.layer.writeFile(path, encode(`ref: ${target}
+`));
+  }
+  async deleteRef(ref) {
+    const path = `${this.gitDir}/${ref}`;
+    if (await this.layer.exists(path)) {
+      await this.layer.rm(path);
+    }
+    await this.removeFromPackedRefs(ref);
+  }
+  // ---- List refs ---------------------------------------------------------
+  async listRefs(prefix = "refs/") {
+    const results = [];
+    await this.listLooseRefs(`${this.gitDir}/${prefix}`, prefix, results);
+    const packed = await this.readAllPackedRefs();
+    for (const [ref, oid] of packed) {
+      if (ref.startsWith(prefix)) {
+        if (!results.some((r) => r.name === ref)) {
+          results.push({ name: ref, oid });
+        }
+      }
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async listLooseRefs(dirPath, refPrefix, results) {
+    if (!await this.layer.exists(dirPath)) return;
+    const entries = await this.layer.readdir(dirPath);
+    for (const entry of entries) {
+      const refName = refPrefix + entry.name;
+      if (entry.isDirectory()) {
+        await this.listLooseRefs(`${dirPath}/${entry.name}`, `${refName}/`, results);
+      } else {
+        try {
+          const content = decode(
+            await this.layer.readFile(`${dirPath}/${entry.name}`)
+          ).trim();
+          if (/^[0-9a-f]{40}$/.test(content)) {
+            results.push({ name: refName, oid: content });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  // ---- Packed refs -------------------------------------------------------
+  async readPackedRef(ref) {
+    const packed = await this.readAllPackedRefs();
+    return packed.get(ref) ?? null;
+  }
+  async readAllPackedRefs() {
+    const result = /* @__PURE__ */ new Map();
+    const path = `${this.gitDir}/packed-refs`;
+    if (!await this.layer.exists(path)) return result;
+    const content = decode(await this.layer.readFile(path));
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("#") || line.startsWith("^") || !line.trim()) continue;
+      const parts = line.trim().split(" ");
+      if (parts.length >= 2 && /^[0-9a-f]{40}$/.test(parts[0])) {
+        result.set(parts[1], parts[0]);
+      }
+    }
+    return result;
+  }
+  async removeFromPackedRefs(ref) {
+    const path = `${this.gitDir}/packed-refs`;
+    if (!await this.layer.exists(path)) return;
+    const content = decode(await this.layer.readFile(path));
+    const lines = content.split("\n");
+    const filtered = lines.filter((line) => {
+      if (line.startsWith("#") || !line.trim()) return true;
+      const parts = line.trim().split(" ");
+      return parts.length < 2 || parts[1] !== ref;
+    });
+    await this.layer.writeFile(path, encode(filtered.join("\n")));
+  }
+};
+
+// src/index-file.ts
+init_utils();
+var INDEX_SIGNATURE = 1145655875;
+var INDEX_VERSION = 2;
+var IndexFile = class {
+  constructor(layer, gitDir) {
+    this.layer = layer;
+    this.gitDir = gitDir;
+  }
+  entries = [];
+  // ---- Read index --------------------------------------------------------
+  async read() {
+    const path = `${this.gitDir}/index`;
+    if (!await this.layer.exists(path)) {
+      this.entries = [];
+      return;
+    }
+    const data = await this.layer.readFile(path);
+    this.parse(data);
+  }
+  parse(data) {
+    const entries = [];
+    let offset = 0;
+    const sig = readUint322(data, offset);
+    offset += 4;
+    if (sig !== INDEX_SIGNATURE) {
+      throw new Error("Invalid index signature");
+    }
+    const version = readUint322(data, offset);
+    offset += 4;
+    if (version !== INDEX_VERSION) {
+      throw new Error(`Unsupported index version: ${version}`);
+    }
+    const entryCount = readUint322(data, offset);
+    offset += 4;
+    for (let i = 0; i < entryCount; i++) {
+      const entryStart = offset;
+      const ctimeSeconds = readUint322(data, offset);
+      offset += 4;
+      const ctimeNanoseconds = readUint322(data, offset);
+      offset += 4;
+      const mtimeSeconds = readUint322(data, offset);
+      offset += 4;
+      const mtimeNanoseconds = readUint322(data, offset);
+      offset += 4;
+      const dev = readUint322(data, offset);
+      offset += 4;
+      const ino = readUint322(data, offset);
+      offset += 4;
+      const mode = readUint322(data, offset);
+      offset += 4;
+      const uid = readUint322(data, offset);
+      offset += 4;
+      const gid = readUint322(data, offset);
+      offset += 4;
+      const size = readUint322(data, offset);
+      offset += 4;
+      const oid = bytesToHex(data.subarray(offset, offset + 20));
+      offset += 20;
+      const flags = readUint16(data, offset);
+      offset += 2;
+      const nameLength = flags & 4095;
+      const stage = flags >> 12 & 3;
+      let pathEnd = offset;
+      while (pathEnd < data.length && data[pathEnd] !== 0) {
+        pathEnd++;
+      }
+      const path = decode(data.subarray(offset, pathEnd));
+      const entrySize = pathEnd - entryStart + 1;
+      const paddedSize = Math.ceil(entrySize / 8) * 8;
+      offset = entryStart + paddedSize;
+      entries.push({
+        ctimeSeconds,
+        ctimeNanoseconds,
+        mtimeSeconds,
+        mtimeNanoseconds,
+        dev,
+        ino,
+        mode,
+        uid,
+        gid,
+        size,
+        oid,
+        flags,
+        path,
+        stage
+      });
+    }
+    this.entries = entries;
+  }
+  // ---- Write index -------------------------------------------------------
+  async write() {
+    const data = await this.serialize();
+    await this.layer.writeFile(`${this.gitDir}/index`, data);
+  }
+  async serialize() {
+    const sorted = [...this.entries].sort(
+      (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+    );
+    const parts = [];
+    const header = new Uint8Array(12);
+    writeUint32(header, 0, INDEX_SIGNATURE);
+    writeUint32(header, 4, INDEX_VERSION);
+    writeUint32(header, 8, sorted.length);
+    parts.push(header);
+    for (const entry of sorted) {
+      const pathBytes = encode(entry.path);
+      const fixedSize = 62;
+      const entryDataSize = fixedSize + pathBytes.length + 1;
+      const paddedSize = Math.ceil(entryDataSize / 8) * 8;
+      const entryBuf = new Uint8Array(paddedSize);
+      let offset = 0;
+      writeUint32(entryBuf, offset, entry.ctimeSeconds);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.ctimeNanoseconds);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.mtimeSeconds);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.mtimeNanoseconds);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.dev);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.ino);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.mode);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.uid);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.gid);
+      offset += 4;
+      writeUint32(entryBuf, offset, entry.size);
+      offset += 4;
+      entryBuf.set(hexToBytes(entry.oid), offset);
+      offset += 20;
+      const nameLen = Math.min(pathBytes.length, 4095);
+      const flags = entry.stage << 12 | nameLen;
+      writeUint16(entryBuf, offset, flags);
+      offset += 2;
+      entryBuf.set(pathBytes, offset);
+      parts.push(entryBuf);
+    }
+    const content = concat(...parts);
+    const checksum = await sha1Bytes(content);
+    return concat(content, checksum);
+  }
+  // ---- Entry manipulation ------------------------------------------------
+  addEntry(entry) {
+    this.entries = this.entries.filter(
+      (e) => !(e.path === entry.path && e.stage === entry.stage)
+    );
+    this.entries.push(entry);
+    this.sortEntries();
+  }
+  removeEntry(path) {
+    this.entries = this.entries.filter((e) => e.path !== path);
+  }
+  removeEntriesUnder(dirPath) {
+    const prefix = dirPath.endsWith("/") ? dirPath : dirPath + "/";
+    this.entries = this.entries.filter((e) => !e.path.startsWith(prefix));
+  }
+  getEntry(path, stage = 0) {
+    return this.entries.find((e) => e.path === path && e.stage === stage);
+  }
+  hasConflicts() {
+    return this.entries.some((e) => e.stage !== 0);
+  }
+  getConflictedPaths() {
+    const paths = /* @__PURE__ */ new Set();
+    for (const e of this.entries) {
+      if (e.stage !== 0) paths.add(e.path);
+    }
+    return [...paths];
+  }
+  clearConflictEntries(path) {
+    this.entries = this.entries.filter(
+      (e) => e.path !== path || e.stage === 0
+    );
+  }
+  sortEntries() {
+    this.entries.sort((a, b) => {
+      if (a.path < b.path) return -1;
+      if (a.path > b.path) return 1;
+      return a.stage - b.stage;
+    });
+  }
+};
+function readUint322(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function readUint16(data, offset) {
+  return (data[offset] << 8 | data[offset + 1]) >>> 0;
+}
+function writeUint32(data, offset, value) {
+  data[offset] = value >>> 24 & 255;
+  data[offset + 1] = value >>> 16 & 255;
+  data[offset + 2] = value >>> 8 & 255;
+  data[offset + 3] = value & 255;
+}
+function writeUint16(data, offset, value) {
+  data[offset] = value >>> 8 & 255;
+  data[offset + 1] = value & 255;
+}
+
+// src/config.ts
+init_utils();
+var GitConfig = class {
+  constructor(layer, gitDir) {
+    this.layer = layer;
+    this.gitDir = gitDir;
+  }
+  sections = [];
+  loaded = false;
+  // ---- Load / save -------------------------------------------------------
+  async load() {
+    const path = `${this.gitDir}/config`;
+    if (!await this.layer.exists(path)) {
+      this.sections = [];
+      this.loaded = true;
+      return;
+    }
+    const content = decode(await this.layer.readFile(path));
+    this.sections = this.parseConfig(content);
+    this.loaded = true;
+  }
+  async save() {
+    const content = this.serialize();
+    await this.layer.writeFile(`${this.gitDir}/config`, encode(content));
+  }
+  // ---- Get / set / delete ------------------------------------------------
+  get(key) {
+    const { section, subsection, name } = this.parseKey(key);
+    for (const s of this.sections) {
+      if (s.name.toLowerCase() === section.toLowerCase() && (subsection === void 0 ? s.subsection === void 0 : s.subsection === subsection)) {
+        for (const entry of s.entries) {
+          if (entry.key.toLowerCase() === name.toLowerCase()) {
+            return entry.value;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  getAll(key) {
+    const { section, subsection, name } = this.parseKey(key);
+    const results = [];
+    for (const s of this.sections) {
+      if (s.name.toLowerCase() === section.toLowerCase() && (subsection === void 0 ? s.subsection === void 0 : s.subsection === subsection)) {
+        for (const entry of s.entries) {
+          if (entry.key.toLowerCase() === name.toLowerCase()) {
+            results.push(entry.value);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  set(key, value) {
+    const { section, subsection, name } = this.parseKey(key);
+    for (const s of this.sections) {
+      if (s.name.toLowerCase() === section.toLowerCase() && (subsection === void 0 ? s.subsection === void 0 : s.subsection === subsection)) {
+        for (const entry of s.entries) {
+          if (entry.key.toLowerCase() === name.toLowerCase()) {
+            entry.value = value;
+            return;
+          }
+        }
+        s.entries.push({ key: name, value });
+        return;
+      }
+    }
+    this.sections.push({
+      name: section,
+      subsection,
+      entries: [{ key: name, value }]
+    });
+  }
+  delete(key) {
+    const { section, subsection, name } = this.parseKey(key);
+    for (const s of this.sections) {
+      if (s.name.toLowerCase() === section.toLowerCase() && (subsection === void 0 ? s.subsection === void 0 : s.subsection === subsection)) {
+        const idx = s.entries.findIndex(
+          (e) => e.key.toLowerCase() === name.toLowerCase()
+        );
+        if (idx >= 0) {
+          s.entries.splice(idx, 1);
+          if (s.entries.length === 0) {
+            this.sections = this.sections.filter((x) => x !== s);
+          }
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  deleteSection(sectionKey) {
+    const parts = sectionKey.split(".");
+    const section = parts[0];
+    const subsection = parts.length > 1 ? parts[1] : void 0;
+    const before = this.sections.length;
+    this.sections = this.sections.filter((s) => {
+      if (s.name.toLowerCase() !== section.toLowerCase()) return true;
+      if (subsection === void 0) return s.subsection !== void 0;
+      return s.subsection !== subsection;
+    });
+    return this.sections.length < before;
+  }
+  // ---- Parse / serialize -------------------------------------------------
+  parseConfig(content) {
+    const sections = [];
+    let current = null;
+    const lines = content.split("\n");
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+      const sectionMatch = line.match(
+        /^\[([a-zA-Z][a-zA-Z0-9-]*)(?:\s+"([^"]*)")?\]$/
+      );
+      if (sectionMatch) {
+        current = {
+          name: sectionMatch[1],
+          subsection: sectionMatch[2] ?? void 0,
+          entries: []
+        };
+        sections.push(current);
+        continue;
+      }
+      if (current) {
+        const kvMatch = line.match(/^([a-zA-Z][a-zA-Z0-9-]*)\s*=\s*(.*)$/);
+        if (kvMatch) {
+          current.entries.push({
+            key: kvMatch[1],
+            value: kvMatch[2].trim()
+          });
+        }
+      }
+    }
+    return sections;
+  }
+  serialize() {
+    const lines = [];
+    for (const section of this.sections) {
+      if (section.subsection !== void 0) {
+        lines.push(`[${section.name} "${section.subsection}"]`);
+      } else {
+        lines.push(`[${section.name}]`);
+      }
+      for (const entry of section.entries) {
+        lines.push(`	${entry.key} = ${entry.value}`);
+      }
+    }
+    return lines.join("\n") + "\n";
+  }
+  // ---- Key parsing -------------------------------------------------------
+  parseKey(key) {
+    const parts = key.split(".");
+    if (parts.length === 2) {
+      return { section: parts[0], name: parts[1] };
+    }
+    if (parts.length === 3) {
+      return { section: parts[0], subsection: parts[1], name: parts[2] };
+    }
+    throw new Error(`Invalid config key: ${key}`);
+  }
+};
+
+// src/ignore.ts
+init_utils();
+var GitIgnore = class {
+  constructor(layer, workDir) {
+    this.layer = layer;
+    this.workDir = workDir;
+  }
+  rules = [];
+  async load() {
+    this.rules = [];
+    await this.loadFile(`${this.workDir}/.gitignore`, "");
+  }
+  async loadNested(dirPath) {
+    const ignoreFile = dirPath ? `${this.workDir}/${dirPath}/.gitignore` : `${this.workDir}/.gitignore`;
+    if (await this.layer.exists(ignoreFile)) {
+      await this.loadFile(ignoreFile, dirPath);
+    }
+  }
+  async loadFile(path, basePath) {
+    if (!await this.layer.exists(path)) return;
+    const content = decode(await this.layer.readFile(path));
+    this.parseRules(content, basePath);
+  }
+  parseRules(content, basePath) {
+    const lines = content.split("\n");
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith("#")) continue;
+      let negation = false;
+      let directoryOnly = false;
+      if (line.startsWith("!")) {
+        negation = true;
+        line = line.substring(1);
+      }
+      if (line.endsWith("/")) {
+        directoryOnly = true;
+        line = line.substring(0, line.length - 1);
+      }
+      line = line.replace(/(?<!\\)\s+$/, "");
+      if (!line) continue;
+      const regex = globToRegex(line, basePath);
+      this.rules.push({
+        pattern: line,
+        negation,
+        directoryOnly,
+        regex,
+        basePath
+      });
+    }
+  }
+  isIgnored(path, isDirectory = false) {
+    if (path === ".git" || path.startsWith(".git/")) return true;
+    let ignored = false;
+    for (const rule of this.rules) {
+      if (rule.directoryOnly && !isDirectory) continue;
+      const testPath = path;
+      if (rule.regex.test(testPath)) {
+        ignored = !rule.negation;
+      }
+    }
+    return ignored;
+  }
+  addRules(content, basePath = "") {
+    this.parseRules(content, basePath);
+  }
+};
+function globToRegex(pattern, basePath) {
+  const hasSlash = pattern.includes("/");
+  let regexStr = "";
+  if (hasSlash && !pattern.startsWith("/")) {
+    if (basePath) {
+      regexStr = "^" + escapeRegExp(basePath) + "/";
+    } else {
+      regexStr = "^";
+    }
+  } else if (pattern.startsWith("/")) {
+    pattern = pattern.substring(1);
+    if (basePath) {
+      regexStr = "^" + escapeRegExp(basePath) + "/";
+    } else {
+      regexStr = "^";
+    }
+  }
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          regexStr += "(?:.+/)?";
+          i += 3;
+          continue;
+        } else {
+          regexStr += ".*";
+          i += 2;
+          continue;
+        }
+      }
+      regexStr += "[^/]*";
+      i++;
+    } else if (c === "?") {
+      regexStr += "[^/]";
+      i++;
+    } else if (c === "[") {
+      let j = i + 1;
+      let classStr = "[";
+      if (j < pattern.length && pattern[j] === "!") {
+        classStr += "^";
+        j++;
+      }
+      while (j < pattern.length && pattern[j] !== "]") {
+        classStr += pattern[j];
+        j++;
+      }
+      classStr += "]";
+      regexStr += classStr;
+      i = j + 1;
+    } else {
+      regexStr += escapeRegExp(c);
+      i++;
+    }
+  }
+  if (!hasSlash) {
+    regexStr = "(?:^|/)" + regexStr + "$";
+  } else {
+    regexStr += "$";
+  }
+  return new RegExp(regexStr);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/diff-engine.ts
+init_utils();
+var DiffEngine = class {
+  constructor(layer, workDir, objectDB, indexFile, refStore, gitDir) {
+    this.layer = layer;
+    this.workDir = workDir;
+    this.objectDB = objectDB;
+    this.indexFile = indexFile;
+    this.refStore = refStore;
+    this.gitDir = gitDir;
+  }
+  // ---- Public API --------------------------------------------------------
+  async diff(options = {}) {
+    if (options.from && options.to) {
+      return this.diffRefs(options.from, options.to, options.path);
+    }
+    if (options.staged) {
+      return this.diffCached(options.path, options.contextLines);
+    }
+    return this.diffWorkingTree(options.path, options.contextLines);
+  }
+  // ---- Working tree vs index --------------------------------------------
+  async diffWorkingTree(path, contextLines) {
+    const files = [];
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage !== 0) continue;
+      if (path && !entry.path.startsWith(path)) continue;
+      const filePath = `${this.workDir}/${entry.path}`;
+      if (!await this.layer.exists(filePath)) {
+        const oldContent = await this.readBlob(entry.oid);
+        files.push(
+          this.createDiffFile(entry.path, void 0, "deleted", oldContent, "", contextLines)
+        );
+        continue;
+      }
+      const workingContent = decode(await this.layer.readFile(filePath));
+      const indexContent = await this.readBlob(entry.oid);
+      if (workingContent !== indexContent) {
+        files.push(
+          this.createDiffFile(
+            entry.path,
+            void 0,
+            "modified",
+            indexContent,
+            workingContent,
+            contextLines
+          )
+        );
+      }
+    }
+    return { files };
+  }
+  // ---- Index vs HEAD (cached/staged) ------------------------------------
+  async diffCached(path, contextLines) {
+    const files = [];
+    const headTree = await this.getHeadTree();
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage !== 0) continue;
+      if (path && !entry.path.startsWith(path)) continue;
+      const headOid = headTree.get(entry.path);
+      if (!headOid) {
+        const content = await this.readBlob(entry.oid);
+        files.push(
+          this.createDiffFile(entry.path, void 0, "added", "", content, contextLines)
+        );
+      } else if (headOid !== entry.oid) {
+        const oldContent = await this.readBlob(headOid);
+        const newContent = await this.readBlob(entry.oid);
+        files.push(
+          this.createDiffFile(
+            entry.path,
+            void 0,
+            "modified",
+            oldContent,
+            newContent,
+            contextLines
+          )
+        );
+      }
+    }
+    for (const [filePath, oid] of headTree) {
+      if (path && !filePath.startsWith(path)) continue;
+      if (!this.indexFile.getEntry(filePath)) {
+        const content = await this.readBlob(oid);
+        files.push(
+          this.createDiffFile(filePath, void 0, "deleted", content, "", contextLines)
+        );
+      }
+    }
+    return { files };
+  }
+  // ---- Ref vs Ref -------------------------------------------------------
+  async diffRefs(fromRef, toRef, path) {
+    const fromTree = await this.getTreeForRef(fromRef);
+    const toTree = await this.getTreeForRef(toRef);
+    const files = [];
+    for (const [filePath, oid] of toTree) {
+      if (path && !filePath.startsWith(path)) continue;
+      const fromOid = fromTree.get(filePath);
+      if (!fromOid) {
+        const content = await this.readBlob(oid);
+        files.push(this.createDiffFile(filePath, void 0, "added", "", content));
+      } else if (fromOid !== oid) {
+        const oldContent = await this.readBlob(fromOid);
+        const newContent = await this.readBlob(oid);
+        files.push(
+          this.createDiffFile(filePath, void 0, "modified", oldContent, newContent)
+        );
+      }
+    }
+    for (const [filePath, oid] of fromTree) {
+      if (path && !filePath.startsWith(path)) continue;
+      if (!toTree.has(filePath)) {
+        const content = await this.readBlob(oid);
+        files.push(this.createDiffFile(filePath, void 0, "deleted", content, ""));
+      }
+    }
+    return { files };
+  }
+  // ---- Tree flattening ---------------------------------------------------
+  async getHeadTree() {
+    try {
+      const headOid = await this.refStore.resolveRef("HEAD");
+      return this.getTreeForCommit(headOid);
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  async getTreeForRef(ref) {
+    const oid = await this.refStore.resolveRef(ref);
+    return this.getTreeForCommit(oid);
+  }
+  async getTreeForCommit(commitOid) {
+    const obj = await this.objectDB.readObject(commitOid);
+    const commit = this.objectDB.parseCommit(obj.content);
+    return this.flattenTree(commit.tree, "");
+  }
+  async flattenTree(treeOid, prefix) {
+    const result = /* @__PURE__ */ new Map();
+    const obj = await this.objectDB.readObject(treeOid);
+    const entries = this.objectDB.parseTree(obj.content);
+    for (const entry of entries) {
+      const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.mode === "40000" || entry.mode === "40") {
+        const subTree = await this.flattenTree(entry.oid, path);
+        for (const [p, o] of subTree) {
+          result.set(p, o);
+        }
+      } else {
+        result.set(path, entry.oid);
+      }
+    }
+    return result;
+  }
+  /**
+   * Look up the OID of a specific path in a tree without flattening
+   * the entire tree. Walks tree objects one path segment at a time.
+   * Returns null if the path does not exist in the tree.
+   */
+  async lookupPathInTree(treeOid, filePath) {
+    const segments = filePath.split("/").filter(Boolean);
+    let currentTreeOid = treeOid;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const obj = await this.objectDB.readObject(currentTreeOid);
+      const entries = this.objectDB.parseTree(obj.content);
+      const entry = entries.find((e) => e.name === segment);
+      if (!entry) {
+        return null;
+      }
+      if (i === segments.length - 1) {
+        return entry.oid;
+      }
+      if (entry.mode !== "40000" && entry.mode !== "40") {
+        return null;
+      }
+      currentTreeOid = entry.oid;
+    }
+    return null;
+  }
+  /**
+   * Get the OID of a specific path in a commit's tree.
+   * Returns null if the path does not exist.
+   */
+  async getPathOidInCommit(commitOid, filePath) {
+    const obj = await this.objectDB.readObject(commitOid);
+    const commit = this.objectDB.parseCommit(obj.content);
+    return this.lookupPathInTree(commit.tree, filePath);
+  }
+  // ---- Diff computation --------------------------------------------------
+  createDiffFile(path, oldPath, status, oldContent, newContent, contextLines) {
+    if (isBinary(oldContent) || isBinary(newContent)) {
+      return { path, oldPath, status, binary: true, hunks: [] };
+    }
+    const hunks = computeDiffHunks(oldContent, newContent, contextLines);
+    return { path, oldPath, status, binary: false, hunks };
+  }
+  async readBlob(oid) {
+    const obj = await this.objectDB.readObject(oid);
+    return decode(obj.content);
+  }
+};
+function isBinary(content) {
+  for (let i = 0; i < Math.min(content.length, 8e3); i++) {
+    if (content.charCodeAt(i) === 0) return true;
+  }
+  return false;
+}
+function myersDiff(oldLines, newLines) {
+  const n = oldLines.length;
+  const m = newLines.length;
+  if (n === 0 && m === 0) return [];
+  if (n === 0) {
+    return newLines.map((line) => ({ type: "insert", newLine: line }));
+  }
+  if (m === 0) {
+    return oldLines.map((line) => ({ type: "delete", oldLine: line }));
+  }
+  const max = n + m;
+  const vSize = 2 * max + 1;
+  const v = new Array(vSize).fill(0);
+  const trace = [];
+  for (let d = 0; d <= max; d++) {
+    trace.push([...v]);
+    for (let k = -d; k <= d; k += 2) {
+      let x;
+      if (k === -d || k !== d && v[k - 1 + max] < v[k + 1 + max]) {
+        x = v[k + 1 + max];
+      } else {
+        x = v[k - 1 + max] + 1;
+      }
+      let y = x - k;
+      while (x < n && y < m && oldLines[x] === newLines[y]) {
+        x++;
+        y++;
+      }
+      v[k + max] = x;
+      if (x >= n && y >= m) {
+        return backtrack(trace, oldLines, newLines, d, max);
+      }
+    }
+  }
+  return [
+    ...oldLines.map((line) => ({ type: "delete", oldLine: line })),
+    ...newLines.map((line) => ({ type: "insert", newLine: line }))
+  ];
+}
+function backtrack(trace, oldLines, newLines, d, max) {
+  const ops = [];
+  let x = oldLines.length;
+  let y = newLines.length;
+  for (let step = d; step > 0; step--) {
+    const v = trace[step - 1];
+    const k = x - y;
+    let prevK;
+    if (k === -step || k !== step && v[k - 1 + max] < v[k + 1 + max]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = v[prevK + max];
+    const prevY = prevX - prevK;
+    while (x > prevX + (prevK < k ? 1 : 0) && y > prevY + (prevK < k ? 0 : 1)) {
+      x--;
+      y--;
+      ops.push({ type: "equal", oldLine: oldLines[x], newLine: newLines[y] });
+    }
+    if (step > 0) {
+      if (prevK < k) {
+        x--;
+        ops.push({ type: "delete", oldLine: oldLines[x] });
+      } else {
+        y--;
+        ops.push({ type: "insert", newLine: newLines[y] });
+      }
+    }
+  }
+  while (x > 0 && y > 0) {
+    x--;
+    y--;
+    ops.push({ type: "equal", oldLine: oldLines[x], newLine: newLines[y] });
+  }
+  ops.reverse();
+  return ops;
+}
+function computeDiffHunks(oldContent, newContent, contextLines = 3) {
+  const oldLines = oldContent ? oldContent.split("\n") : [];
+  const newLines = newContent ? newContent.split("\n") : [];
+  const ops = myersDiff(oldLines, newLines);
+  if (ops.length === 0) return [];
+  const diffLines = [];
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  for (const op of ops) {
+    switch (op.type) {
+      case "equal":
+        diffLines.push({
+          origin: " ",
+          content: op.oldLine,
+          oldLineNumber: oldLineNum,
+          newLineNumber: newLineNum
+        });
+        oldLineNum++;
+        newLineNum++;
+        break;
+      case "delete":
+        diffLines.push({
+          origin: "-",
+          content: op.oldLine,
+          oldLineNumber: oldLineNum
+        });
+        oldLineNum++;
+        break;
+      case "insert":
+        diffLines.push({
+          origin: "+",
+          content: op.newLine,
+          newLineNumber: newLineNum
+        });
+        newLineNum++;
+        break;
+    }
+  }
+  return groupIntoHunks(diffLines, contextLines);
+}
+function groupIntoHunks(allLines, contextLines) {
+  const changed = [];
+  for (let i = 0; i < allLines.length; i++) {
+    if (allLines[i].origin !== " ") {
+      changed.push(i);
+    }
+  }
+  if (changed.length === 0) return [];
+  const hunks = [];
+  let hunkStart = Math.max(0, changed[0] - contextLines);
+  let hunkEnd = Math.min(allLines.length - 1, changed[0] + contextLines);
+  for (let i = 1; i < changed.length; i++) {
+    const start = Math.max(0, changed[i] - contextLines);
+    const end = Math.min(allLines.length - 1, changed[i] + contextLines);
+    if (start <= hunkEnd + 1) {
+      hunkEnd = end;
+    } else {
+      hunks.push(buildHunk(allLines, hunkStart, hunkEnd));
+      hunkStart = start;
+      hunkEnd = end;
+    }
+  }
+  hunks.push(buildHunk(allLines, hunkStart, hunkEnd));
+  return hunks;
+}
+function buildHunk(allLines, start, end) {
+  const lines = allLines.slice(start, end + 1);
+  let oldStart = 0;
+  let oldCount = 0;
+  let newStart = 0;
+  let newCount = 0;
+  for (const line of lines) {
+    if (line.origin === " ") {
+      if (oldStart === 0 && line.oldLineNumber) oldStart = line.oldLineNumber;
+      if (newStart === 0 && line.newLineNumber) newStart = line.newLineNumber;
+      oldCount++;
+      newCount++;
+    } else if (line.origin === "-") {
+      if (oldStart === 0 && line.oldLineNumber) oldStart = line.oldLineNumber;
+      oldCount++;
+    } else if (line.origin === "+") {
+      if (newStart === 0 && line.newLineNumber) newStart = line.newLineNumber;
+      newCount++;
+    }
+  }
+  if (oldStart === 0) oldStart = 1;
+  if (newStart === 0) newStart = 1;
+  const header = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`;
+  return {
+    oldStart,
+    oldLines: oldCount,
+    newStart,
+    newLines: newCount,
+    header,
+    lines
+  };
+}
+
+// src/merge-engine.ts
+init_utils();
+var MergeEngine = class {
+  constructor(layer, workDir, gitDir, objectDB, indexFile, refStore, diffEngine) {
+    this.layer = layer;
+    this.workDir = workDir;
+    this.gitDir = gitDir;
+    this.objectDB = objectDB;
+    this.indexFile = indexFile;
+    this.refStore = refStore;
+    this.diffEngine = diffEngine;
+  }
+  // ---- Find merge base ---------------------------------------------------
+  async findMergeBase(oid1, oid2) {
+    const ancestors1 = /* @__PURE__ */ new Set();
+    const queue1 = [oid1];
+    while (queue1.length > 0) {
+      const current = queue1.shift();
+      if (ancestors1.has(current)) continue;
+      ancestors1.add(current);
+      try {
+        const obj = await this.objectDB.readObject(current);
+        const commit = this.objectDB.parseCommit(obj.content);
+        for (const parent of commit.parents) {
+          queue1.push(parent);
+        }
+      } catch {
+      }
+    }
+    const visited2 = /* @__PURE__ */ new Set();
+    const queue2 = [oid2];
+    while (queue2.length > 0) {
+      const current = queue2.shift();
+      if (visited2.has(current)) continue;
+      visited2.add(current);
+      if (ancestors1.has(current)) {
+        return current;
+      }
+      try {
+        const obj = await this.objectDB.readObject(current);
+        const commit = this.objectDB.parseCommit(obj.content);
+        for (const parent of commit.parents) {
+          queue2.push(parent);
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  // ---- Three-way merge --------------------------------------------------
+  async merge(oursOid, theirsOid, message, author, committer) {
+    const base = await this.findMergeBase(oursOid, theirsOid);
+    if (base === theirsOid) {
+      return { type: "already-up-to-date", oid: oursOid, conflicts: [] };
+    }
+    if (base === oursOid) {
+      return {
+        type: "fast-forward",
+        oid: theirsOid,
+        conflicts: []
+      };
+    }
+    const baseTree = base ? await this.diffEngine.getTreeForCommit(base) : /* @__PURE__ */ new Map();
+    const oursTree = await this.diffEngine.getTreeForCommit(oursOid);
+    const theirsTree = await this.diffEngine.getTreeForCommit(theirsOid);
+    const conflicts = [];
+    const mergedFiles = /* @__PURE__ */ new Map();
+    const allPaths = /* @__PURE__ */ new Set();
+    for (const path of baseTree.keys()) allPaths.add(path);
+    for (const path of oursTree.keys()) allPaths.add(path);
+    for (const path of theirsTree.keys()) allPaths.add(path);
+    for (const path of allPaths) {
+      const baseOid = baseTree.get(path);
+      const oursOidFile = oursTree.get(path);
+      const theirsOidFile = theirsTree.get(path);
+      if (oursOidFile === theirsOidFile) {
+        if (oursOidFile) mergedFiles.set(path, oursOidFile);
+        continue;
+      }
+      if (oursOidFile === baseOid) {
+        if (theirsOidFile) {
+          mergedFiles.set(path, theirsOidFile);
+        }
+        continue;
+      }
+      if (theirsOidFile === baseOid) {
+        if (oursOidFile) {
+          mergedFiles.set(path, oursOidFile);
+        }
+        continue;
+      }
+      if (oursOidFile && theirsOidFile) {
+        const baseContent = baseOid ? await this.readBlobText(baseOid) : "";
+        const oursContent = await this.readBlobText(oursOidFile);
+        const theirsContent = await this.readBlobText(theirsOidFile);
+        if (isBinary2(baseContent) || isBinary2(oursContent) || isBinary2(theirsContent)) {
+          conflicts.push(path);
+          mergedFiles.set(path, oursOidFile);
+          continue;
+        }
+        const result = threeWayMergeText(
+          baseContent,
+          oursContent,
+          theirsContent
+        );
+        if (result.conflict) {
+          conflicts.push(path);
+          const conflictContent = encode(result.content);
+          await this.layer.writeFile(
+            `${this.workDir}/${path}`,
+            conflictContent
+          );
+          if (baseOid) {
+            this.addConflictEntry(path, baseOid, 1);
+          }
+          this.addConflictEntry(path, oursOidFile, 2);
+          this.addConflictEntry(path, theirsOidFile, 3);
+          this.indexFile.entries = this.indexFile.entries.filter(
+            (e) => !(e.path === path && e.stage === 0)
+          );
+        } else {
+          const mergedOid = await this.objectDB.writeBlob(
+            encode(result.content)
+          );
+          mergedFiles.set(path, mergedOid);
+        }
+      } else if (!oursOidFile && !theirsOidFile) {
+      } else {
+        conflicts.push(path);
+        if (oursOidFile) {
+          mergedFiles.set(path, oursOidFile);
+        }
+      }
+    }
+    if (conflicts.length > 0) {
+      for (const [path, oid] of mergedFiles) {
+        if (!conflicts.includes(path)) {
+          this.indexFile.addEntry(
+            this.createIndexEntry(path, oid, 33188)
+          );
+          const obj = await this.objectDB.readObject(oid);
+          await this.layer.writeFile(
+            `${this.workDir}/${path}`,
+            obj.content
+          );
+        }
+      }
+      await this.layer.writeFile(
+        `${this.gitDir}/MERGE_HEAD`,
+        encode(`${theirsOid}
+`)
+      );
+      await this.layer.writeFile(
+        `${this.gitDir}/MERGE_MSG`,
+        encode(message + "\n")
+      );
+      await this.indexFile.write();
+      return { type: "merge-commit", conflicts, oid: void 0 };
+    }
+    const treeOid = await this.buildTreeFromPaths(mergedFiles);
+    this.indexFile.entries = [];
+    for (const [path, oid] of mergedFiles) {
+      this.indexFile.addEntry(this.createIndexEntry(path, oid, 33188));
+    }
+    const mergeCommitOid = await this.objectDB.writeCommit(
+      treeOid,
+      [oursOid, theirsOid],
+      author,
+      committer,
+      message
+    );
+    for (const [path, oid] of mergedFiles) {
+      const obj = await this.objectDB.readObject(oid);
+      const dir = path.includes("/") ? `${this.workDir}/${path.substring(0, path.lastIndexOf("/"))}` : this.workDir;
+      await this.layer.mkdir(dir, { recursive: true });
+      await this.layer.writeFile(`${this.workDir}/${path}`, obj.content);
+    }
+    await this.indexFile.write();
+    return {
+      type: "merge-commit",
+      oid: mergeCommitOid,
+      conflicts: []
+    };
+  }
+  // ---- Build tree from flat path->oid map --------------------------------
+  async buildTreeFromPaths(paths) {
+    const root = { entries: /* @__PURE__ */ new Map(), children: /* @__PURE__ */ new Map() };
+    for (const [path, oid] of paths) {
+      const parts = path.split("/");
+      let node = root;
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (!node.children.has(parts[i])) {
+          node.children.set(parts[i], { entries: /* @__PURE__ */ new Map(), children: /* @__PURE__ */ new Map() });
+        }
+        node = node.children.get(parts[i]);
+      }
+      const fileName = parts[parts.length - 1];
+      node.entries.set(fileName, { oid, mode: "100644" });
+    }
+    return this.writeTreeNode(root);
+  }
+  async writeTreeNode(node) {
+    const treeEntries = [];
+    for (const [name, { oid, mode }] of node.entries) {
+      treeEntries.push({ mode, name, oid });
+    }
+    for (const [name, child] of node.children) {
+      const childOid = await this.writeTreeNode(child);
+      treeEntries.push({ mode: "40000", name, oid: childOid });
+    }
+    return this.objectDB.writeTree(treeEntries);
+  }
+  // ---- Helpers -----------------------------------------------------------
+  async readBlobText(oid) {
+    const obj = await this.objectDB.readObject(oid);
+    return decode(obj.content);
+  }
+  addConflictEntry(path, oid, stage) {
+    this.indexFile.addEntry(
+      this.createIndexEntry(path, oid, 33188, stage)
+    );
+  }
+  createIndexEntry(path, oid, mode, stage = 0) {
+    const now = Math.floor(Date.now() / 1e3);
+    return {
+      ctimeSeconds: now,
+      ctimeNanoseconds: 0,
+      mtimeSeconds: now,
+      mtimeNanoseconds: 0,
+      dev: 0,
+      ino: 0,
+      mode,
+      uid: 0,
+      gid: 0,
+      size: 0,
+      oid,
+      flags: 0,
+      path,
+      stage
+    };
+  }
+};
+function threeWayMergeText(base, ours, theirs) {
+  const baseLines = base.split("\n");
+  const oursLines = ours.split("\n");
+  const theirsLines = theirs.split("\n");
+  const oursChanges = computeLineChanges(baseLines, oursLines);
+  const theirsChanges = computeLineChanges(baseLines, theirsLines);
+  const resultLines = [];
+  let hasConflict = false;
+  let baseIdx = 0;
+  let oursIdx = 0;
+  let theirsIdx = 0;
+  while (baseIdx < baseLines.length || oursIdx < oursLines.length || theirsIdx < theirsLines.length) {
+    const oursChange = oursChanges.get(baseIdx);
+    const theirsChange = theirsChanges.get(baseIdx);
+    if (!oursChange && !theirsChange) {
+      if (baseIdx < baseLines.length) {
+        resultLines.push(baseLines[baseIdx]);
+        baseIdx++;
+        oursIdx++;
+        theirsIdx++;
+      } else {
+        break;
+      }
+    } else if (oursChange && !theirsChange) {
+      for (const line of oursChange.newLines) {
+        resultLines.push(line);
+      }
+      baseIdx += oursChange.baseCount;
+      oursIdx += oursChange.newLines.length;
+      theirsIdx += oursChange.baseCount;
+    } else if (!oursChange && theirsChange) {
+      for (const line of theirsChange.newLines) {
+        resultLines.push(line);
+      }
+      baseIdx += theirsChange.baseCount;
+      oursIdx += theirsChange.baseCount;
+      theirsIdx += theirsChange.newLines.length;
+    } else {
+      if (oursChange.newLines.join("\n") === theirsChange.newLines.join("\n")) {
+        for (const line of oursChange.newLines) {
+          resultLines.push(line);
+        }
+        baseIdx += oursChange.baseCount;
+        oursIdx += oursChange.newLines.length;
+        theirsIdx += theirsChange.newLines.length;
+      } else {
+        hasConflict = true;
+        resultLines.push("<<<<<<< ours");
+        for (const line of oursChange.newLines) {
+          resultLines.push(line);
+        }
+        resultLines.push("=======");
+        for (const line of theirsChange.newLines) {
+          resultLines.push(line);
+        }
+        resultLines.push(">>>>>>> theirs");
+        baseIdx += Math.max(oursChange.baseCount, theirsChange.baseCount);
+        oursIdx += oursChange.newLines.length;
+        theirsIdx += theirsChange.newLines.length;
+      }
+    }
+  }
+  return { content: resultLines.join("\n"), conflict: hasConflict };
+}
+function computeLineChanges(baseLines, modifiedLines) {
+  const changes = /* @__PURE__ */ new Map();
+  let baseIdx = 0;
+  let modIdx = 0;
+  while (baseIdx < baseLines.length || modIdx < modifiedLines.length) {
+    if (baseIdx < baseLines.length && modIdx < modifiedLines.length && baseLines[baseIdx] === modifiedLines[modIdx]) {
+      baseIdx++;
+      modIdx++;
+      continue;
+    }
+    let foundBase = -1;
+    let foundMod = -1;
+    for (let ahead = 1; ahead < 20; ahead++) {
+      if (foundBase < 0 && baseIdx + ahead < baseLines.length) {
+        if (modIdx < modifiedLines.length && baseLines[baseIdx + ahead] === modifiedLines[modIdx]) {
+          foundBase = baseIdx + ahead;
+          foundMod = modIdx;
+          break;
+        }
+      }
+      if (foundMod < 0 && modIdx + ahead < modifiedLines.length) {
+        if (baseIdx < baseLines.length && modifiedLines[modIdx + ahead] === baseLines[baseIdx]) {
+          foundBase = baseIdx;
+          foundMod = modIdx + ahead;
+          break;
+        }
+      }
+    }
+    if (foundBase >= 0 && foundMod >= 0) {
+      const baseCount = foundBase - baseIdx;
+      const newLines = modifiedLines.slice(modIdx, foundMod);
+      if (baseCount > 0 || newLines.length > 0) {
+        changes.set(baseIdx, { baseStart: baseIdx, baseCount, newLines });
+      }
+      baseIdx = foundBase;
+      modIdx = foundMod;
+    } else {
+      const newLines = modifiedLines.slice(modIdx);
+      const baseCount = baseLines.length - baseIdx;
+      changes.set(baseIdx, { baseStart: baseIdx, baseCount, newLines });
+      break;
+    }
+  }
+  return changes;
+}
+function isBinary2(content) {
+  for (let i = 0; i < Math.min(content.length, 8e3); i++) {
+    if (content.charCodeAt(i) === 0) return true;
+  }
+  return false;
+}
+
+// src/stash.ts
+init_utils();
+var StashManager = class {
+  constructor(layer, workDir, gitDir, objectDB, indexFile, refStore, diffEngine, mergeEngine) {
+    this.layer = layer;
+    this.workDir = workDir;
+    this.gitDir = gitDir;
+    this.objectDB = objectDB;
+    this.indexFile = indexFile;
+    this.refStore = refStore;
+    this.diffEngine = diffEngine;
+    this.mergeEngine = mergeEngine;
+  }
+  // ---- Push stash --------------------------------------------------------
+  async push(message, author, includeUntracked = false) {
+    const headOid = await this.refStore.resolveRef("HEAD");
+    const indexTree = await this.buildIndexTree();
+    const workingTree = await this.buildWorkingTree(includeUntracked);
+    const indexCommitOid = await this.objectDB.writeCommit(
+      indexTree,
+      [headOid],
+      author,
+      author,
+      `index on ${message}`
+    );
+    const parents = [headOid, indexCommitOid];
+    const stashCommitOid = await this.objectDB.writeCommit(
+      workingTree,
+      parents,
+      author,
+      author,
+      message || `WIP on ${await this.getCurrentBranchName()}`
+    );
+    await this.pushStashRef(stashCommitOid, message);
+    await this.resetToHead(headOid);
+    return stashCommitOid;
+  }
+  // ---- Apply stash -------------------------------------------------------
+  async apply(index = 0) {
+    const stashes = await this.list();
+    if (index >= stashes.length) {
+      throw new GitError("NOT_FOUND", `Stash @{${index}} not found`);
+    }
+    const stashOid = stashes[index].oid;
+    const stashObj = await this.objectDB.readObject(stashOid);
+    const stashCommit = this.objectDB.parseCommit(stashObj.content);
+    const stashedTree = await this.diffEngine.flattenTree(
+      stashCommit.tree,
+      ""
+    );
+    for (const [path, oid] of stashedTree) {
+      const obj = await this.objectDB.readObject(oid);
+      const dir = path.includes("/") ? `${this.workDir}/${path.substring(0, path.lastIndexOf("/"))}` : this.workDir;
+      await this.layer.mkdir(dir, { recursive: true });
+      await this.layer.writeFile(`${this.workDir}/${path}`, obj.content);
+    }
+    await this.indexFile.read();
+    for (const [path, oid] of stashedTree) {
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  // ---- Pop stash ---------------------------------------------------------
+  async pop(index = 0) {
+    await this.apply(index);
+    await this.drop(index);
+  }
+  // ---- Drop stash --------------------------------------------------------
+  async drop(index = 0) {
+    const stashes = await this.list();
+    if (index >= stashes.length) {
+      throw new GitError("NOT_FOUND", `Stash @{${index}} not found`);
+    }
+    stashes.splice(index, 1);
+    await this.writeStashList(stashes);
+  }
+  // ---- List stashes ------------------------------------------------------
+  async list() {
+    const stashListPath = `${this.gitDir}/refs/stash-list`;
+    if (!await this.layer.exists(stashListPath)) {
+      return [];
+    }
+    const content = decode(await this.layer.readFile(stashListPath));
+    const lines = content.trim().split("\n").filter(Boolean);
+    return lines.map((line, index) => {
+      const [oid, ...messageParts] = line.split(" ");
+      return {
+        index,
+        oid,
+        message: messageParts.join(" ")
+      };
+    });
+  }
+  // ---- Internal helpers --------------------------------------------------
+  async pushStashRef(oid, message) {
+    const stashes = await this.list();
+    stashes.unshift({
+      index: 0,
+      oid,
+      message: message || "WIP"
+    });
+    for (let i = 0; i < stashes.length; i++) {
+      stashes[i].index = i;
+    }
+    await this.writeStashList(stashes);
+    await this.refStore.writeRef("refs/stash", oid);
+  }
+  async writeStashList(stashes) {
+    const stashListPath = `${this.gitDir}/refs/stash-list`;
+    if (stashes.length === 0) {
+      if (await this.layer.exists(stashListPath)) {
+        await this.layer.rm(stashListPath);
+      }
+      try {
+        await this.refStore.deleteRef("refs/stash");
+      } catch {
+      }
+      return;
+    }
+    const content = stashes.map((s) => `${s.oid} ${s.message}`).join("\n") + "\n";
+    await this.layer.mkdir(`${this.gitDir}/refs`, { recursive: true });
+    await this.layer.writeFile(stashListPath, encode(content));
+    await this.refStore.writeRef("refs/stash", stashes[0].oid);
+  }
+  async buildIndexTree() {
+    const paths = /* @__PURE__ */ new Map();
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage === 0) {
+        paths.set(entry.path, entry.oid);
+      }
+    }
+    return this.mergeEngine.buildTreeFromPaths(paths);
+  }
+  async buildWorkingTree(includeUntracked) {
+    const paths = /* @__PURE__ */ new Map();
+    const indexPaths = /* @__PURE__ */ new Set();
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage === 0) {
+        indexPaths.add(entry.path);
+        const filePath = `${this.workDir}/${entry.path}`;
+        if (await this.layer.exists(filePath)) {
+          const content = await this.layer.readFile(filePath);
+          const oid = await this.objectDB.writeBlob(content);
+          paths.set(entry.path, oid);
+        }
+      }
+    }
+    if (includeUntracked) {
+      const untrackedPaths = /* @__PURE__ */ new Set();
+      await this.collectWorkingTreePaths("", untrackedPaths);
+      for (const p of untrackedPaths) {
+        if (indexPaths.has(p)) continue;
+        const filePath = `${this.workDir}/${p}`;
+        const content = await this.layer.readFile(filePath);
+        const oid = await this.objectDB.writeBlob(content);
+        paths.set(p, oid);
+      }
+    }
+    return this.mergeEngine.buildTreeFromPaths(paths);
+  }
+  /**
+   * Recursively collects all file paths in the working directory,
+   * excluding .git directories.
+   */
+  async collectWorkingTreePaths(dir, paths) {
+    const fullDir = dir ? this.workDir === "/" ? `/${dir}` : `${this.workDir}/${dir}` : this.workDir;
+    let entries;
+    try {
+      entries = await this.layer.readdir(fullDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const childPath = dir ? `${dir}/${entry.name}` : entry.name;
+      if (entry.name === ".git") continue;
+      if (entry.isDirectory()) {
+        await this.collectWorkingTreePaths(childPath, paths);
+      } else {
+        paths.add(childPath);
+      }
+    }
+  }
+  async resetToHead(headOid) {
+    const headTree = await this.diffEngine.getTreeForCommit(headOid);
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage !== 0) continue;
+      const filePath = `${this.workDir}/${entry.path}`;
+      if (await this.layer.exists(filePath)) {
+        await this.layer.rm(filePath);
+      }
+    }
+    this.indexFile.entries = [];
+    for (const [path, oid] of headTree) {
+      const obj = await this.objectDB.readObject(oid);
+      const dir = path.includes("/") ? `${this.workDir}/${path.substring(0, path.lastIndexOf("/"))}` : this.workDir;
+      await this.layer.mkdir(dir, { recursive: true });
+      await this.layer.writeFile(`${this.workDir}/${path}`, obj.content);
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  async getCurrentBranchName() {
+    const sym = await this.refStore.readSymbolicRef("HEAD");
+    if (sym && sym.startsWith("refs/heads/")) {
+      return sym.substring(11);
+    }
+    return "HEAD";
+  }
+};
+
+// src/repository.ts
+init_utils();
+
+// src/pack/write.ts
+init_utils();
+import pako3 from "pako";
+var TYPE_NUMBERS = {
+  commit: 1,
+  tree: 2,
+  blob: 3,
+  tag: 4
+};
+async function createPackfile(objects) {
+  const parts = [];
+  const header = new Uint8Array(12);
+  header[0] = 80;
+  header[1] = 65;
+  header[2] = 67;
+  header[3] = 75;
+  writeUint322(header, 4, 2);
+  writeUint322(header, 8, objects.length);
+  parts.push(header);
+  for (const obj of objects) {
+    const typeNum = TYPE_NUMBERS[obj.type];
+    if (!typeNum) throw new Error(`Unknown object type: ${obj.type}`);
+    const objHeader = encodeTypeAndSize(typeNum, obj.content.length);
+    parts.push(objHeader);
+    const compressed = pako3.deflate(obj.content);
+    parts.push(compressed);
+  }
+  const packWithoutChecksum = concat(...parts);
+  const checksum = await sha1Bytes(packWithoutChecksum);
+  return concat(packWithoutChecksum, checksum);
+}
+function encodeTypeAndSize(type, size) {
+  const bytes = [];
+  let byte = (type & 7) << 4 | size & 15;
+  size >>= 4;
+  if (size > 0) {
+    byte |= 128;
+  }
+  bytes.push(byte);
+  while (size > 0) {
+    byte = size & 127;
+    size >>= 7;
+    if (size > 0) byte |= 128;
+    bytes.push(byte);
+  }
+  return new Uint8Array(bytes);
+}
+function writeUint322(buf, offset, value) {
+  buf[offset] = value >>> 24 & 255;
+  buf[offset + 1] = value >>> 16 & 255;
+  buf[offset + 2] = value >>> 8 & 255;
+  buf[offset + 3] = value & 255;
+}
+
+// src/repository.ts
+var Repository = class {
+  workDir;
+  gitDir;
+  objectDB;
+  refStore;
+  indexFile;
+  config;
+  ignore;
+  diffEngine;
+  mergeEngine;
+  stashManager;
+  transport = null;
+  constructor(layer, workDir = "/") {
+    this.workDir = workDir.replace(/\/$/, "") || "/";
+    this.gitDir = this.workDir === "/" ? "/.git" : `${this.workDir}/.git`;
+    this.objectDB = new ObjectDB(layer, this.gitDir);
+    this.refStore = new RefStore(layer, this.gitDir);
+    this.indexFile = new IndexFile(layer, this.gitDir);
+    this.config = new GitConfig(layer, this.gitDir);
+    this.ignore = new GitIgnore(layer, this.workDir);
+    this.diffEngine = new DiffEngine(
+      layer,
+      this.workDir,
+      this.objectDB,
+      this.indexFile,
+      this.refStore,
+      this.gitDir
+    );
+    this.mergeEngine = new MergeEngine(
+      layer,
+      this.workDir,
+      this.gitDir,
+      this.objectDB,
+      this.indexFile,
+      this.refStore,
+      this.diffEngine
+    );
+    this.stashManager = new StashManager(
+      layer,
+      this.workDir,
+      this.gitDir,
+      this.objectDB,
+      this.indexFile,
+      this.refStore,
+      this.diffEngine,
+      this.mergeEngine
+    );
+    this._layer = layer;
+  }
+  // Keep a private ref to the layer for operations that need direct FS access
+  _layer;
+  setTransport(transport) {
+    this.transport = transport;
+  }
+  // ---- Initialization ----------------------------------------------------
+  async load() {
+    await this.config.load();
+    await this.indexFile.read();
+    await this.ignore.load();
+  }
+  // ======================================================================
+  // BRANCH OPERATIONS
+  // ======================================================================
+  async currentBranch() {
+    const sym = await this.refStore.readSymbolicRef("HEAD");
+    if (!sym) return null;
+    if (sym.startsWith("refs/heads/")) {
+      return sym.substring(11);
+    }
+    return null;
+  }
+  async createBranch(name, options = {}) {
+    const { startPoint, force } = options;
+    let oid;
+    if (startPoint) {
+      const ref = await this.refStore.expandRef(startPoint);
+      oid = await this.refStore.resolveRef(ref);
+    } else {
+      oid = await this.refStore.resolveRef("HEAD");
+    }
+    const refPath = `refs/heads/${name}`;
+    try {
+      await this.refStore.resolveRef(refPath);
+      if (!force) {
+        throw new GitError("ALREADY_EXISTS", `Branch '${name}' already exists`);
+      }
+    } catch (e) {
+      if (e instanceof GitError && e.code === "ALREADY_EXISTS") throw e;
+    }
+    await this.refStore.writeRef(refPath, oid);
+  }
+  async deleteBranch(name, options = {}) {
+    const { force } = options;
+    const current = await this.currentBranch();
+    if (current === name) {
+      throw new GitError("CURRENT_BRANCH", `Cannot delete current branch '${name}'`);
+    }
+    const refPath = `refs/heads/${name}`;
+    try {
+      await this.refStore.resolveRef(refPath);
+    } catch {
+      throw new GitError("NOT_FOUND", `Branch '${name}' not found`);
+    }
+    if (!force) {
+    }
+    await this.refStore.deleteRef(refPath);
+  }
+  async listBranches(options = {}) {
+    const branches = [];
+    const currentBranchName = await this.currentBranch();
+    if (!options.remote) {
+      const localRefs = await this.refStore.listRefs("refs/heads/");
+      for (const { name: refName, oid } of localRefs) {
+        const branchName = refName.substring(11);
+        const remote = this.config.get(`branch.${branchName}.remote`);
+        const merge = this.config.get(`branch.${branchName}.merge`);
+        let upstream = null;
+        if (remote && merge) {
+          const upstreamBranch = merge.startsWith("refs/heads/") ? merge.substring(11) : merge;
+          upstream = `${remote}/${upstreamBranch}`;
+        }
+        branches.push({
+          name: branchName,
+          current: branchName === currentBranchName,
+          commit: oid,
+          upstream
+        });
+      }
+    }
+    if (options.remote) {
+      const remoteRefs = await this.refStore.listRefs("refs/remotes/");
+      for (const { name: refName, oid } of remoteRefs) {
+        const branchName = refName.substring(13);
+        if (branchName.endsWith("/HEAD")) continue;
+        branches.push({
+          name: branchName,
+          current: false,
+          commit: oid,
+          upstream: null
+        });
+      }
+    }
+    return branches;
+  }
+  async renameBranch(oldName, newName) {
+    const oldRef = `refs/heads/${oldName}`;
+    const newRef = `refs/heads/${newName}`;
+    let oid;
+    try {
+      oid = await this.refStore.resolveRef(oldRef);
+    } catch {
+      throw new GitError("NOT_FOUND", `Branch '${oldName}' not found`);
+    }
+    try {
+      await this.refStore.resolveRef(newRef);
+      throw new GitError("ALREADY_EXISTS", `Branch '${newName}' already exists`);
+    } catch (e) {
+      if (e instanceof GitError && e.code === "ALREADY_EXISTS") throw e;
+    }
+    await this.refStore.writeRef(newRef, oid);
+    await this.refStore.deleteRef(oldRef);
+    const current = await this.currentBranch();
+    if (current === oldName) {
+      await this.refStore.writeSymbolicRef("HEAD", newRef);
+    }
+    const merge = this.config.get(`branch.${oldName}.merge`);
+    const remote = this.config.get(`branch.${oldName}.remote`);
+    if (merge || remote) {
+      this.config.deleteSection(`branch.${oldName}`);
+      if (merge) this.config.set(`branch.${newName}.merge`, merge);
+      if (remote) this.config.set(`branch.${newName}.remote`, remote);
+      await this.config.save();
+    }
+  }
+  async checkout(ref, options = {}) {
+    const { force, create } = options;
+    if (create) {
+      await this.createBranch(ref);
+    }
+    let targetOid;
+    let targetRef = null;
+    try {
+      const expanded = await this.refStore.expandRef(ref);
+      targetOid = await this.refStore.resolveRef(expanded);
+      if (expanded.startsWith("refs/heads/")) {
+        targetRef = expanded;
+      }
+    } catch {
+      throw new GitError("NOT_FOUND", `Ref '${ref}' not found`);
+    }
+    if (!force) {
+    }
+    const targetTree = await this.diffEngine.getTreeForCommit(targetOid);
+    const currentTree = await this.diffEngine.getHeadTree();
+    for (const [path] of currentTree) {
+      if (!targetTree.has(path)) {
+        const filePath = this.workDir === "/" ? `/${path}` : `${this.workDir}/${path}`;
+        if (await this._layer.exists(filePath)) {
+          await this._layer.rm(filePath);
+        }
+      }
+    }
+    for (const [path, oid] of targetTree) {
+      const obj = await this.objectDB.readObject(oid);
+      const filePath = this.workDir === "/" ? `/${path}` : `${this.workDir}/${path}`;
+      const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+      if (dir) {
+        await this._layer.mkdir(dir, { recursive: true });
+      }
+      await this._layer.writeFile(filePath, obj.content);
+    }
+    this.indexFile.entries = [];
+    for (const [path, oid] of targetTree) {
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+    if (targetRef) {
+      await this.refStore.writeSymbolicRef("HEAD", targetRef);
+    } else {
+      const headPath = `${this.gitDir}/HEAD`;
+      await this._layer.writeFile(headPath, encode(`${targetOid}
+`));
+    }
+  }
+  /**
+   * Update working tree and index to match the given commit OID,
+   * without changing HEAD's symbolic ref. Used by merge to avoid
+   * accidentally switching branches.
+   */
+  async updateWorkingTreeToCommit(commitOid) {
+    const targetTree = await this.diffEngine.getTreeForCommit(commitOid);
+    const currentTree = await this.diffEngine.getHeadTree();
+    for (const [path] of currentTree) {
+      if (!targetTree.has(path)) {
+        const filePath = this.workDir === "/" ? `/${path}` : `${this.workDir}/${path}`;
+        if (await this._layer.exists(filePath)) {
+          await this._layer.rm(filePath);
+        }
+      }
+    }
+    for (const [path, oid] of targetTree) {
+      const obj = await this.objectDB.readObject(oid);
+      const filePath = this.workDir === "/" ? `/${path}` : `${this.workDir}/${path}`;
+      const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+      if (dir) {
+        await this._layer.mkdir(dir, { recursive: true });
+      }
+      await this._layer.writeFile(filePath, obj.content);
+    }
+    this.indexFile.entries = [];
+    for (const [path, oid] of targetTree) {
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  // ======================================================================
+  // STAGING (add, unstage, remove, status)
+  // ======================================================================
+  async add(pathOrPaths) {
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
+    for (let p of paths) {
+      p = normalizePath(p);
+      const filePath = this.workDir === "/" ? `/${p}` : `${this.workDir}/${p}`;
+      if (!await this._layer.exists(filePath)) {
+        this.indexFile.removeEntry(p);
+        continue;
+      }
+      const stat = await this._layer.stat(filePath);
+      if (stat.isDirectory()) {
+        await this.addDirectory(p);
+        continue;
+      }
+      const content = await this._layer.readFile(filePath);
+      const oid = await this.objectDB.writeBlob(content);
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.clearConflictEntries(p);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: stat.isFile() ? 33188 : 40960,
+        uid: 0,
+        gid: 0,
+        size: content.length,
+        oid,
+        flags: 0,
+        path: p,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  async addDirectory(dirPath) {
+    const fullPath = this.workDir === "/" ? `/${dirPath}` : `${this.workDir}/${dirPath}`;
+    const entries = await this._layer.readdir(fullPath);
+    for (const entry of entries) {
+      const childPath = dirPath ? `${dirPath}/${entry.name}` : entry.name;
+      if (this.ignore.isIgnored(childPath, entry.isDirectory())) continue;
+      if (entry.isDirectory()) {
+        await this.addDirectory(childPath);
+      } else {
+        await this.add([childPath]);
+      }
+    }
+  }
+  async unstage(pathOrPaths) {
+    const headTree = await this.diffEngine.getHeadTree();
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
+    for (let p of paths) {
+      p = normalizePath(p);
+      const headOid = headTree.get(p);
+      if (headOid) {
+        const now = Math.floor(Date.now() / 1e3);
+        this.indexFile.addEntry({
+          ctimeSeconds: now,
+          ctimeNanoseconds: 0,
+          mtimeSeconds: now,
+          mtimeNanoseconds: 0,
+          dev: 0,
+          ino: 0,
+          mode: 33188,
+          uid: 0,
+          gid: 0,
+          size: 0,
+          oid: headOid,
+          flags: 0,
+          path: p,
+          stage: 0
+        });
+      } else {
+        this.indexFile.removeEntry(p);
+      }
+    }
+    await this.indexFile.write();
+  }
+  async remove(pathOrPaths, options = {}) {
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
+    for (let p of paths) {
+      p = normalizePath(p);
+      this.indexFile.removeEntry(p);
+      if (!options.cached) {
+        const filePath = this.workDir === "/" ? `/${p}` : `${this.workDir}/${p}`;
+        if (await this._layer.exists(filePath)) {
+          await this._layer.rm(filePath, { recursive: options.recursive });
+        }
+      }
+    }
+    await this.indexFile.write();
+  }
+  async status(path) {
+    const results = [];
+    const headTree = await this.diffEngine.getHeadTree();
+    const indexPaths = /* @__PURE__ */ new Set();
+    const workingPaths = /* @__PURE__ */ new Set();
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage === 0) {
+        indexPaths.add(entry.path);
+      }
+    }
+    await this.collectWorkingTreePaths("", workingPaths);
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage !== 0) continue;
+      const headOid = headTree.get(entry.path);
+      let index = "unmodified";
+      if (!headOid) {
+        index = "added";
+      } else if (headOid !== entry.oid) {
+        index = "modified";
+      }
+      let workingTree = "unmodified";
+      const filePath = this.workDir === "/" ? `/${entry.path}` : `${this.workDir}/${entry.path}`;
+      if (!await this._layer.exists(filePath)) {
+        workingTree = "deleted";
+      } else {
+        const content = await this._layer.readFile(filePath);
+        const workingOid = await this.objectDB.hashObject("blob", content);
+        if (workingOid !== entry.oid) {
+          workingTree = "modified";
+        }
+      }
+      if (index !== "unmodified" || workingTree !== "unmodified") {
+        results.push({
+          path: entry.path,
+          index,
+          workingTree
+        });
+      }
+    }
+    for (const [entryPath] of headTree) {
+      if (!indexPaths.has(entryPath)) {
+        results.push({
+          path: entryPath,
+          index: "deleted",
+          workingTree: "unmodified"
+        });
+      }
+    }
+    for (const entryPath of workingPaths) {
+      if (!indexPaths.has(entryPath) && !this.ignore.isIgnored(entryPath, false)) {
+        results.push({
+          path: entryPath,
+          index: "unmodified",
+          workingTree: "untracked"
+        });
+      }
+    }
+    const sorted = results.sort((a, b) => a.path.localeCompare(b.path));
+    if (path !== void 0) {
+      const normalized = normalizePath(path);
+      const entry = sorted.find((e) => e.path === normalized);
+      return entry ?? null;
+    }
+    return sorted;
+  }
+  async collectWorkingTreePaths(dir, paths) {
+    const fullDir = dir ? this.workDir === "/" ? `/${dir}` : `${this.workDir}/${dir}` : this.workDir;
+    let entries;
+    try {
+      entries = await this._layer.readdir(fullDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const childPath = dir ? `${dir}/${entry.name}` : entry.name;
+      if (entry.name === ".git") continue;
+      if (this.ignore.isIgnored(childPath, entry.isDirectory())) continue;
+      if (entry.isDirectory()) {
+        await this.collectWorkingTreePaths(childPath, paths);
+      } else {
+        paths.add(childPath);
+      }
+    }
+  }
+  async listFiles() {
+    return this.indexFile.entries.filter((e) => e.stage === 0).map((e) => e.path).sort();
+  }
+  async isIgnored(path) {
+    return this.ignore.isIgnored(path, false);
+  }
+  // ======================================================================
+  // COMMIT
+  // ======================================================================
+  async commit(options) {
+    const { message, author, committer, amend, allowEmpty } = options;
+    if (this.indexFile.hasConflicts()) {
+      throw new GitError(
+        "UNRESOLVED_CONFLICT",
+        "Cannot commit with unresolved conflicts"
+      );
+    }
+    const identity = await this.buildIdentity(author);
+    const committerIdentity = await this.buildIdentity(committer || author);
+    let parents;
+    let headTree;
+    if (amend) {
+      const headOid = await this.refStore.resolveRef("HEAD");
+      const headObj = await this.objectDB.readObject(headOid);
+      const headCommit = this.objectDB.parseCommit(headObj.content);
+      parents = headCommit.parents;
+      if (parents.length > 0) {
+        headTree = await this.diffEngine.getTreeForCommit(parents[0]);
+      } else {
+        headTree = /* @__PURE__ */ new Map();
+      }
+    } else {
+      try {
+        const headOid = await this.refStore.resolveRef("HEAD");
+        parents = [headOid];
+        headTree = await this.diffEngine.getTreeForCommit(headOid);
+      } catch {
+        parents = [];
+        headTree = /* @__PURE__ */ new Map();
+      }
+      const mergeHeadPath2 = `${this.gitDir}/MERGE_HEAD`;
+      if (await this._layer.exists(mergeHeadPath2)) {
+        const mergeHead = decode(
+          await this._layer.readFile(mergeHeadPath2)
+        ).trim();
+        parents.push(mergeHead);
+      }
+    }
+    const treeOid = await this.buildTreeFromIndex();
+    if (!allowEmpty && parents.length > 0) {
+      let parentTreeOid;
+      if (amend && parents.length > 0) {
+        const parentObj = await this.objectDB.readObject(parents[0]);
+        const parentCommit = this.objectDB.parseCommit(parentObj.content);
+        parentTreeOid = parentCommit.tree;
+      } else {
+        const headObj = await this.objectDB.readObject(parents[0]);
+        const headCommit = this.objectDB.parseCommit(headObj.content);
+        parentTreeOid = headCommit.tree;
+      }
+      if (treeOid === parentTreeOid) {
+        throw new GitError("NOTHING_TO_COMMIT", "Nothing to commit");
+      }
+    }
+    const commitOid = await this.objectDB.writeCommit(
+      treeOid,
+      parents,
+      identity,
+      committerIdentity,
+      message
+    );
+    const sym = await this.refStore.readSymbolicRef("HEAD");
+    if (sym) {
+      await this.refStore.writeRef(sym, commitOid);
+    } else {
+      await this._layer.writeFile(
+        `${this.gitDir}/HEAD`,
+        encode(`${commitOid}
+`)
+      );
+    }
+    const mergeHeadPath = `${this.gitDir}/MERGE_HEAD`;
+    if (await this._layer.exists(mergeHeadPath)) {
+      await this._layer.rm(mergeHeadPath);
+    }
+    const mergeMsgPath = `${this.gitDir}/MERGE_MSG`;
+    if (await this._layer.exists(mergeMsgPath)) {
+      await this._layer.rm(mergeMsgPath);
+    }
+    return commitOid;
+  }
+  async log(options = {}) {
+    const { ref, maxCount = 50, skip = 0, path: filterPath } = options;
+    const results = [];
+    let startOid;
+    try {
+      if (ref) {
+        const expanded = await this.refStore.expandRef(ref);
+        startOid = await this.refStore.resolveRef(expanded);
+      } else {
+        startOid = await this.refStore.resolveRef("HEAD");
+      }
+    } catch {
+      return [];
+    }
+    const queue = [startOid];
+    const visited = /* @__PURE__ */ new Set();
+    let skipped = 0;
+    while (queue.length > 0 && results.length < maxCount) {
+      const oid = queue.shift();
+      if (visited.has(oid)) continue;
+      visited.add(oid);
+      const obj = await this.objectDB.readObject(oid);
+      if (obj.type !== "commit") continue;
+      const commit = this.objectDB.parseCommit(obj.content);
+      for (const parent of commit.parents) {
+        queue.push(parent);
+      }
+      if (options.since && commit.author.timestamp < options.since.getTime() / 1e3) {
+        continue;
+      }
+      if (options.until && commit.author.timestamp > options.until.getTime() / 1e3) {
+        continue;
+      }
+      if (filterPath) {
+        const commitPathOid = await this.diffEngine.lookupPathInTree(
+          commit.tree,
+          filterPath
+        );
+        let pathChanged = false;
+        if (commit.parents.length === 0) {
+          pathChanged = commitPathOid !== null;
+        } else {
+          for (const parentOid of commit.parents) {
+            const parentPathOid = await this.diffEngine.getPathOidInCommit(
+              parentOid,
+              filterPath
+            );
+            if (commitPathOid !== parentPathOid) {
+              pathChanged = true;
+              break;
+            }
+          }
+        }
+        if (!pathChanged) {
+          continue;
+        }
+      }
+      if (skipped < skip) {
+        skipped++;
+        continue;
+      }
+      results.push({
+        oid,
+        tree: commit.tree,
+        parents: commit.parents,
+        author: commit.author,
+        committer: commit.committer,
+        message: commit.message
+      });
+    }
+    return results;
+  }
+  async readCommit(oid) {
+    const obj = await this.objectDB.readObject(oid);
+    if (obj.type !== "commit") {
+      throw new GitError("INVALID_OBJECT", `Not a commit: ${oid}`);
+    }
+    const commit = this.objectDB.parseCommit(obj.content);
+    return {
+      oid,
+      tree: commit.tree,
+      parents: commit.parents,
+      author: commit.author,
+      committer: commit.committer,
+      message: commit.message
+    };
+  }
+  // ======================================================================
+  // REMOTES
+  // ======================================================================
+  async addRemote(name, url) {
+    if (this.config.get(`remote.${name}.url`)) {
+      throw new GitError("ALREADY_EXISTS", `Remote '${name}' already exists`);
+    }
+    this.config.set(`remote.${name}.url`, url);
+    this.config.set(
+      `remote.${name}.fetch`,
+      `+refs/heads/*:refs/remotes/${name}/*`
+    );
+    await this.config.save();
+  }
+  async listRemotes() {
+    const remotes = [];
+    await this.config.load();
+    const configContent = this.config.serialize();
+    const parsed = this.config.parseConfig(configContent);
+    for (const section of parsed) {
+      if (section.name === "remote" && section.subsection) {
+        const url = section.entries.find((e) => e.key === "url")?.value ?? "";
+        remotes.push({
+          name: section.subsection,
+          url
+        });
+      }
+    }
+    return remotes;
+  }
+  async deleteRemote(name) {
+    if (!this.config.get(`remote.${name}.url`)) {
+      throw new GitError("NOT_FOUND", `Remote '${name}' not found`);
+    }
+    this.config.deleteSection(`remote.${name}`);
+    await this.config.save();
+    try {
+      const remoteBranchDir = `${this.gitDir}/refs/remotes/${name}`;
+      if (await this._layer.exists(remoteBranchDir)) {
+        await this._layer.rm(remoteBranchDir, { recursive: true });
+      }
+    } catch {
+    }
+  }
+  // ======================================================================
+  // FETCH / PULL / PUSH
+  // ======================================================================
+  async fetch(remote, options = {}) {
+    const transport = options.transport || this.transport;
+    if (!transport) {
+      throw new GitError("TRANSPORT_ERROR", "No transport configured");
+    }
+    const remoteName = remote;
+    const remoteUrl = this.config.get(`remote.${remoteName}.url`);
+    if (!remoteUrl) {
+      throw new GitError("NOT_FOUND", `Remote '${remoteName}' not found`);
+    }
+    const discovery = await transport.discover(
+      remoteUrl,
+      "git-upload-pack"
+    );
+    const wants = [];
+    const haves = [];
+    for (const remoteRef of discovery.refs) {
+      if (remoteRef.name.startsWith("refs/heads/")) {
+        if (options.branch) {
+          const branchName = remoteRef.name.substring(11);
+          if (branchName !== options.branch) continue;
+        }
+        const exists = await this.objectDB.existsObject(remoteRef.oid);
+        if (!exists) {
+          wants.push(remoteRef.oid);
+        }
+      }
+    }
+    const localRefs = await this.refStore.listRefs("refs/");
+    for (const localRef of localRefs) {
+      haves.push(localRef.oid);
+    }
+    const updated = [];
+    if (wants.length > 0) {
+      const response = await transport.fetch(remoteUrl, {
+        wants,
+        haves,
+        depth: options.depth
+      });
+      if (response.packfile.length > 0) {
+        await this.storePackData(response.packfile);
+      }
+    }
+    for (const remoteRef of discovery.refs) {
+      if (remoteRef.name.startsWith("refs/heads/")) {
+        if (options.branch) {
+          const branchName = remoteRef.name.substring(11);
+          if (branchName !== options.branch) continue;
+        }
+        const trackingRef = `refs/remotes/${remoteName}/${remoteRef.name.substring(11)}`;
+        let oldOid = null;
+        try {
+          oldOid = await this.refStore.resolveRef(trackingRef);
+        } catch {
+        }
+        if (oldOid !== remoteRef.oid) {
+          await this.refStore.writeRef(trackingRef, remoteRef.oid);
+          updated.push({ ref: trackingRef, oldOid, newOid: remoteRef.oid });
+        }
+      }
+    }
+    return { updated };
+  }
+  async pull(remote, options = {}) {
+    await this.fetch(remote, {
+      auth: options.auth,
+      depth: options.depth,
+      tags: options.tags,
+      transport: options.transport,
+      branch: options.branch
+    });
+    const branch = await this.currentBranch();
+    if (!branch) {
+      throw new GitError("DETACHED_HEAD", "Cannot pull with detached HEAD");
+    }
+    const remoteBranch = options.branch || branch;
+    const trackingRef = `refs/remotes/${remote}/${remoteBranch}`;
+    let remoteOid;
+    try {
+      remoteOid = await this.refStore.resolveRef(trackingRef);
+    } catch {
+      throw new GitError("NOT_FOUND", `Remote tracking branch not found: ${trackingRef}`);
+    }
+    const headOid = await this.refStore.resolveRef("HEAD");
+    return this.merge(
+      trackingRef,
+      {
+        message: `Merge branch '${remoteBranch}' of ${remote}`,
+        author: options.author,
+        fastForwardOnly: options.fastForwardOnly
+      }
+    );
+  }
+  async push(remote, options = {}) {
+    const transport = options.transport || this.transport;
+    if (!transport) {
+      throw new GitError("TRANSPORT_ERROR", "No transport configured");
+    }
+    const remoteName = remote;
+    const remoteUrl = this.config.get(`remote.${remoteName}.url`);
+    if (!remoteUrl) {
+      throw new GitError("NOT_FOUND", `Remote '${remoteName}' not found`);
+    }
+    const branch = options.branch || await this.currentBranch();
+    if (!branch) {
+      throw new GitError("DETACHED_HEAD", "Cannot push with detached HEAD");
+    }
+    const localOid = await this.refStore.resolveRef(`refs/heads/${branch}`);
+    const discovery = await transport.discover(
+      remoteUrl,
+      "git-receive-pack"
+    );
+    const remoteRef = discovery.refs.find(
+      (r) => r.name === `refs/heads/${branch}`
+    );
+    const oldOid = remoteRef?.oid || "0".repeat(40);
+    const objects = await this.collectObjectsForPush(
+      localOid,
+      oldOid === "0".repeat(40) ? null : oldOid
+    );
+    const packData = await createPackfile(objects);
+    const result = await transport.push(remoteUrl, {
+      updates: [
+        {
+          ref: `refs/heads/${branch}`,
+          oldOid,
+          newOid: localOid
+        }
+      ],
+      packfile: packData
+    });
+    if (options.setUpstream) {
+      await this.setUpstream(branch, `${remoteName}/${branch}`);
+    }
+    return result;
+  }
+  async collectObjectsForPush(localOid, remoteOid) {
+    const objects = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [localOid];
+    while (queue.length > 0) {
+      const oid = queue.shift();
+      if (visited.has(oid)) continue;
+      if (oid === remoteOid) continue;
+      visited.add(oid);
+      const obj = await this.objectDB.readObject(oid);
+      objects.push({ type: obj.type, content: obj.content });
+      if (obj.type === "commit") {
+        const commit = this.objectDB.parseCommit(obj.content);
+        queue.push(commit.tree);
+        for (const parent of commit.parents) {
+          if (parent !== remoteOid) {
+            queue.push(parent);
+          }
+        }
+      } else if (obj.type === "tree") {
+        const entries = this.objectDB.parseTree(obj.content);
+        for (const entry of entries) {
+          queue.push(entry.oid);
+        }
+      }
+    }
+    return objects;
+  }
+  async storePackData(packData) {
+    const { PackReader: PackReader2 } = await Promise.resolve().then(() => (init_read(), read_exports));
+    if (packData.length < 12 || packData[0] !== 80 || packData[1] !== 65 || packData[2] !== 67 || packData[3] !== 75) {
+      throw new GitError("TRANSPORT_ERROR", "Invalid pack data");
+    }
+    const packDir = `${this.gitDir}/objects/pack`;
+    await this._layer.mkdir(packDir, { recursive: true });
+    const packHash = await this.objectDB.hashObject("blob", packData);
+    const packPath = `${packDir}/pack-${packHash}.pack`;
+    await this._layer.writeFile(packPath, packData);
+    const reader = new PackReader2(this._layer, packPath);
+    const objects = await reader.extractAll();
+    for (const obj of objects) {
+      await this.objectDB.writeObject(obj.type, obj.content);
+    }
+    try {
+      await this._layer.rm(packPath);
+    } catch {
+    }
+  }
+  // ======================================================================
+  // MERGE
+  // ======================================================================
+  async merge(ref, options = {}) {
+    const { message, noFastForward, fastForwardOnly, author } = options;
+    let theirsOid;
+    try {
+      const expanded = await this.refStore.expandRef(ref);
+      theirsOid = await this.refStore.resolveRef(expanded);
+    } catch {
+      throw new GitError("NOT_FOUND", `Ref '${ref}' not found`);
+    }
+    const oursOid = await this.refStore.resolveRef("HEAD");
+    const identity = await this.buildIdentity(author);
+    const mergeMsg = message || `Merge branch '${ref}'`;
+    const result = await this.mergeEngine.merge(
+      oursOid,
+      theirsOid,
+      mergeMsg,
+      identity,
+      identity
+    );
+    if (result.type === "already-up-to-date") {
+      return result;
+    }
+    if (result.type === "fast-forward" && noFastForward) {
+      const theirsObj = await this.objectDB.readObject(theirsOid);
+      const commit = this.objectDB.parseCommit(theirsObj.content);
+      const commitOid = await this.objectDB.writeCommit(
+        commit.tree,
+        [oursOid, theirsOid],
+        identity,
+        identity,
+        mergeMsg
+      );
+      const sym = await this.refStore.readSymbolicRef("HEAD");
+      if (sym) {
+        await this.refStore.writeRef(sym, commitOid);
+      }
+      await this.updateWorkingTreeToCommit(commitOid);
+      return { type: "merge-commit", oid: commitOid, conflicts: [] };
+    }
+    if (result.type === "fast-forward" && !noFastForward) {
+      const sym = await this.refStore.readSymbolicRef("HEAD");
+      if (sym) {
+        await this.refStore.writeRef(sym, theirsOid);
+      }
+      await this.updateWorkingTreeToCommit(theirsOid);
+      return result;
+    }
+    if (fastForwardOnly && result.type === "merge-commit") {
+      throw new GitError("NON_FAST_FORWARD", "Fast-forward only merge requested but a merge commit is required");
+    }
+    if (result.conflicts.length === 0 && result.oid) {
+      const sym = await this.refStore.readSymbolicRef("HEAD");
+      if (sym) {
+        await this.refStore.writeRef(sym, result.oid);
+      }
+    }
+    return result;
+  }
+  async abortMerge() {
+    const mergeHeadPath = `${this.gitDir}/MERGE_HEAD`;
+    if (!await this._layer.exists(mergeHeadPath)) {
+      throw new GitError("NOT_MERGING", "Not currently merging");
+    }
+    const headOid = await this.refStore.resolveRef("HEAD");
+    await this.resetHard(headOid);
+    await this._layer.rm(mergeHeadPath);
+    const mergeMsgPath = `${this.gitDir}/MERGE_MSG`;
+    if (await this._layer.exists(mergeMsgPath)) {
+      await this._layer.rm(mergeMsgPath);
+    }
+  }
+  // ======================================================================
+  // TAGS
+  // ======================================================================
+  async createTag(name, options = {}) {
+    const { target, message, tagger } = options;
+    let targetOid;
+    if (target) {
+      const expanded = await this.refStore.expandRef(target);
+      targetOid = await this.refStore.resolveRef(expanded);
+    } else {
+      targetOid = await this.refStore.resolveRef("HEAD");
+    }
+    const tagRef = `refs/tags/${name}`;
+    try {
+      await this.refStore.resolveRef(tagRef);
+      throw new GitError("ALREADY_EXISTS", `Tag '${name}' already exists`);
+    } catch (e) {
+      if (e instanceof GitError && e.code === "ALREADY_EXISTS") throw e;
+    }
+    if (message) {
+      const identity = await this.buildIdentity(tagger);
+      const tagOid = await this.objectDB.writeTag(
+        targetOid,
+        "commit",
+        name,
+        identity,
+        message || ""
+      );
+      await this.refStore.writeRef(tagRef, tagOid);
+    } else {
+      await this.refStore.writeRef(tagRef, targetOid);
+    }
+  }
+  async deleteTag(name) {
+    const tagRef = `refs/tags/${name}`;
+    try {
+      await this.refStore.resolveRef(tagRef);
+    } catch {
+      throw new GitError("NOT_FOUND", `Tag '${name}' not found`);
+    }
+    await this.refStore.deleteRef(tagRef);
+  }
+  async listTags() {
+    const tagRefs = await this.refStore.listRefs("refs/tags/");
+    const tags = [];
+    for (const { name: refName, oid } of tagRefs) {
+      const tagName = refName.substring(10);
+      try {
+        const obj = await this.objectDB.readObject(oid);
+        if (obj.type === "tag") {
+          const tag = this.objectDB.parseTag(obj.content);
+          tags.push({
+            name: tagName,
+            oid,
+            type: "annotated",
+            target: tag.object,
+            tagger: tag.tagger,
+            message: tag.message
+          });
+        } else {
+          tags.push({
+            name: tagName,
+            oid,
+            type: "lightweight"
+          });
+        }
+      } catch {
+        tags.push({ name: tagName, oid, type: "lightweight" });
+      }
+    }
+    return tags;
+  }
+  // ======================================================================
+  // DIFF
+  // ======================================================================
+  async diff(options = {}) {
+    return this.diffEngine.diff(options);
+  }
+  // ======================================================================
+  // STASH
+  // ======================================================================
+  async stash(options = {}) {
+    const statusEntries = await this.status();
+    const entries = Array.isArray(statusEntries) ? statusEntries : statusEntries ? [statusEntries] : [];
+    const hasChanges = entries.some(
+      (e) => e.index !== "unmodified" || e.workingTree !== "unmodified" && e.workingTree !== "untracked"
+    );
+    if (!hasChanges) {
+      throw new GitError("NOTHING_TO_STASH", "No changes to stash");
+    }
+    const identity = await this.buildIdentity();
+    const message = options.message || `WIP on ${await this.currentBranch() || "HEAD"}`;
+    await this.stashManager.push(
+      message,
+      identity,
+      options.includeUntracked ?? false
+    );
+  }
+  async listStashes() {
+    return this.stashManager.list();
+  }
+  async applyStash(options = {}) {
+    return this.stashManager.apply(options.index ?? 0);
+  }
+  async popStash(options = {}) {
+    return this.stashManager.pop(options.index ?? 0);
+  }
+  async dropStash(index = 0) {
+    return this.stashManager.drop(index);
+  }
+  // ======================================================================
+  // CONFIG
+  // ======================================================================
+  async getConfig(key) {
+    return this.config.get(key) ?? null;
+  }
+  async setConfig(key, value) {
+    this.config.set(key, value);
+    await this.config.save();
+  }
+  async deleteConfig(key) {
+    const result = this.config.delete(key);
+    if (result) await this.config.save();
+  }
+  // ======================================================================
+  // REFS
+  // ======================================================================
+  async resolveRef(ref) {
+    const expanded = await this.refStore.expandRef(ref);
+    return this.refStore.resolveRef(expanded);
+  }
+  async listRefs(prefix) {
+    return this.refStore.listRefs(prefix);
+  }
+  async setUpstream(branch, upstream) {
+    const slashIdx = upstream.indexOf("/");
+    if (slashIdx < 0) {
+      throw new GitError("INVALID_OBJECT", `Invalid upstream format: ${upstream}. Expected "remote/branch".`);
+    }
+    const remote = upstream.substring(0, slashIdx);
+    const remoteBranch = upstream.substring(slashIdx + 1);
+    this.config.set(`branch.${branch}.remote`, remote);
+    this.config.set(`branch.${branch}.merge`, `refs/heads/${remoteBranch}`);
+    await this.config.save();
+  }
+  // ======================================================================
+  // RESET
+  // ======================================================================
+  async reset(ref, options = {}) {
+    const { mode = "mixed", paths } = options;
+    const resolvedRef = await this.resolveRefExpression(ref);
+    if (paths && paths.length > 0) {
+      const expanded = await this.refStore.expandRef(resolvedRef);
+      const targetOid2 = await this.refStore.resolveRef(expanded);
+      const targetTree = await this.diffEngine.getTreeForCommit(targetOid2);
+      for (let p of paths) {
+        p = normalizePath(p);
+        const treeOid = targetTree.get(p);
+        if (treeOid) {
+          const now = Math.floor(Date.now() / 1e3);
+          this.indexFile.addEntry({
+            ctimeSeconds: now,
+            ctimeNanoseconds: 0,
+            mtimeSeconds: now,
+            mtimeNanoseconds: 0,
+            dev: 0,
+            ino: 0,
+            mode: 33188,
+            uid: 0,
+            gid: 0,
+            size: 0,
+            oid: treeOid,
+            flags: 0,
+            path: p,
+            stage: 0
+          });
+        } else {
+          this.indexFile.removeEntry(p);
+        }
+      }
+      await this.indexFile.write();
+      return;
+    }
+    let targetOid;
+    try {
+      const expanded = await this.refStore.expandRef(resolvedRef);
+      targetOid = await this.refStore.resolveRef(expanded);
+    } catch {
+      throw new GitError("NOT_FOUND", `Ref '${ref}' not found`);
+    }
+    const sym = await this.refStore.readSymbolicRef("HEAD");
+    if (sym) {
+      await this.refStore.writeRef(sym, targetOid);
+    } else {
+      await this._layer.writeFile(
+        `${this.gitDir}/HEAD`,
+        encode(`${targetOid}
+`)
+      );
+    }
+    if (mode === "soft") {
+      return;
+    }
+    if (mode === "mixed") {
+      await this.resetIndex(targetOid);
+      return;
+    }
+    if (mode === "hard") {
+      await this.resetHard(targetOid);
+    }
+  }
+  /**
+   * Resolve ref expressions like HEAD~1, HEAD~3, HEAD^, main~2, etc.
+   */
+  async resolveRefExpression(ref) {
+    const tildeMatch = ref.match(/^(.+)~(\d+)$/);
+    if (tildeMatch) {
+      const baseRef = tildeMatch[1];
+      const count = parseInt(tildeMatch[2], 10);
+      let expanded;
+      try {
+        expanded = await this.refStore.expandRef(baseRef);
+      } catch {
+        expanded = baseRef;
+      }
+      let oid = await this.refStore.resolveRef(expanded);
+      for (let i = 0; i < count; i++) {
+        const obj = await this.objectDB.readObject(oid);
+        if (obj.type !== "commit") {
+          throw new GitError("INVALID_OBJECT", `Not a commit: ${oid}`);
+        }
+        const commit = this.objectDB.parseCommit(obj.content);
+        if (commit.parents.length === 0) {
+          throw new GitError("NOT_FOUND", `Cannot go back ${count} commits from '${ref}' \u2014 ran out of parents`);
+        }
+        oid = commit.parents[0];
+      }
+      return oid;
+    }
+    const caretMatch = ref.match(/^(.+)\^$/);
+    if (caretMatch) {
+      const baseRef = caretMatch[1];
+      let expanded;
+      try {
+        expanded = await this.refStore.expandRef(baseRef);
+      } catch {
+        expanded = baseRef;
+      }
+      const oid = await this.refStore.resolveRef(expanded);
+      const obj = await this.objectDB.readObject(oid);
+      if (obj.type !== "commit") {
+        throw new GitError("INVALID_OBJECT", `Not a commit: ${oid}`);
+      }
+      const commit = this.objectDB.parseCommit(obj.content);
+      if (commit.parents.length === 0) {
+        throw new GitError("NOT_FOUND", `'${ref}' has no parent commit`);
+      }
+      return commit.parents[0];
+    }
+    return ref;
+  }
+  async resetIndex(commitOid) {
+    const tree = await this.diffEngine.getTreeForCommit(commitOid);
+    this.indexFile.entries = [];
+    for (const [path, oid] of tree) {
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  async resetHard(commitOid) {
+    const tree = await this.diffEngine.getTreeForCommit(commitOid);
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage !== 0) continue;
+      const filePath = this.workDir === "/" ? `/${entry.path}` : `${this.workDir}/${entry.path}`;
+      if (await this._layer.exists(filePath)) {
+        await this._layer.rm(filePath);
+      }
+    }
+    this.indexFile.entries = [];
+    for (const [path, oid] of tree) {
+      const obj = await this.objectDB.readObject(oid);
+      const filePath = this.workDir === "/" ? `/${path}` : `${this.workDir}/${path}`;
+      const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+      if (dir) {
+        await this._layer.mkdir(dir, { recursive: true });
+      }
+      await this._layer.writeFile(filePath, obj.content);
+      const now = Math.floor(Date.now() / 1e3);
+      this.indexFile.addEntry({
+        ctimeSeconds: now,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: now,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 33188,
+        uid: 0,
+        gid: 0,
+        size: 0,
+        oid,
+        flags: 0,
+        path,
+        stage: 0
+      });
+    }
+    await this.indexFile.write();
+  }
+  // ======================================================================
+  // HELPERS
+  // ======================================================================
+  async buildIdentity(identity) {
+    const name = identity?.name || this.config.get("user.name") || "Unknown";
+    const email = identity?.email || this.config.get("user.email") || "unknown@example.com";
+    return {
+      name,
+      email,
+      timestamp: identity?.timestamp ?? Math.floor(Date.now() / 1e3),
+      timezoneOffset: identity?.timezoneOffset ?? 0
+    };
+  }
+  async buildTreeFromIndex() {
+    const paths = /* @__PURE__ */ new Map();
+    for (const entry of this.indexFile.entries) {
+      if (entry.stage === 0) {
+        paths.set(entry.path, entry.oid);
+      }
+    }
+    return this.mergeEngine.buildTreeFromPaths(paths);
+  }
+};
+
+// src/index.ts
+init_utils();
+
+// src/transport/http.ts
+init_utils();
+var HttpTransport = class {
+  headers;
+  constructor(options = {}) {
+    const headers = { ...options.headers };
+    if (options.auth) {
+      headers["Authorization"] = `Basic ${btoa(`${options.auth.username}:${options.auth.password}`)}`;
+    }
+    this.headers = headers;
+  }
+  // ---- Discovery ---------------------------------------------------------
+  async discover(url, service) {
+    const infoUrl = `${url.replace(/\/$/, "")}/info/refs?service=${service}`;
+    const response = await fetch(infoUrl, {
+      headers: {
+        ...this.headers,
+        "User-Agent": "catmint-fs-git/0.1"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const body = new Uint8Array(await response.arrayBuffer());
+    return this.parseDiscovery(body, service);
+  }
+  parseDiscovery(data, service) {
+    const refs = [];
+    const capabilities = [];
+    let offset = 0;
+    let firstLine = true;
+    while (offset < data.length) {
+      const { line, nextOffset } = readPktLine(data, offset);
+      offset = nextOffset;
+      if (line === null) continue;
+      if (line.length === 0) continue;
+      const text = decode(line).trim();
+      if (text === `# service=${service}`) continue;
+      if (!text) continue;
+      if (firstLine) {
+        const nullIdx = text.indexOf("\0");
+        if (nullIdx >= 0) {
+          const refPart = text.substring(0, nullIdx);
+          const capsPart = text.substring(nullIdx + 1);
+          capabilities.push(...capsPart.split(" ").filter(Boolean));
+          const [oid, name] = refPart.split(" ");
+          if (oid && name) {
+            refs.push({ oid, name });
+          }
+        } else {
+          const [oid, name] = text.split(" ");
+          if (oid && name) {
+            refs.push({ oid, name });
+          }
+        }
+        firstLine = false;
+      } else {
+        const [oid, name] = text.split(" ");
+        if (oid && name && /^[0-9a-f]{40}$/.test(oid)) {
+          refs.push({ oid, name });
+        }
+      }
+    }
+    return { refs, capabilities };
+  }
+  // ---- Fetch -------------------------------------------------------------
+  async fetch(url, request) {
+    const body = this.buildFetchRequest(request);
+    const response = await fetch(`${url.replace(/\/$/, "")}/git-upload-pack`, {
+      method: "POST",
+      headers: {
+        ...this.headers,
+        "Content-Type": "application/x-git-upload-pack-request",
+        "User-Agent": "catmint-fs-git/0.1"
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const responseData = new Uint8Array(await response.arrayBuffer());
+    return this.parseFetchResponse(responseData);
+  }
+  buildFetchRequest(request) {
+    const lines = [];
+    for (const want of request.wants) {
+      lines.push(writePktLine(`want ${want}
+`));
+    }
+    if (request.depth) {
+      lines.push(writePktLine(`deepen ${request.depth}
+`));
+    }
+    lines.push(flushPkt());
+    for (const have of request.haves) {
+      lines.push(writePktLine(`have ${have}
+`));
+    }
+    lines.push(writePktLine("done\n"));
+    return concat(...lines);
+  }
+  parseFetchResponse(data) {
+    const acks = [];
+    let offset = 0;
+    while (offset < data.length) {
+      if (data[offset] === 80 && data[offset + 1] === 65 && data[offset + 2] === 67 && data[offset + 3] === 75) {
+        break;
+      }
+      const { line, nextOffset } = readPktLine(data, offset);
+      offset = nextOffset;
+      if (line === null) continue;
+      const text = decode(line).trim();
+      if (text.startsWith("ACK ")) {
+        acks.push(text.substring(4).split(" ")[0]);
+      }
+      if (text === "NAK") {
+      }
+    }
+    const packfile = data.subarray(offset);
+    return { packfile, acks };
+  }
+  // ---- Push --------------------------------------------------------------
+  async push(url, request) {
+    const body = this.buildPushRequest(request);
+    const response = await fetch(`${url.replace(/\/$/, "")}/git-receive-pack`, {
+      method: "POST",
+      headers: {
+        ...this.headers,
+        "Content-Type": "application/x-git-receive-pack-request",
+        "User-Agent": "catmint-fs-git/0.1"
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const responseData = new Uint8Array(await response.arrayBuffer());
+    return this.parsePushResponse(responseData);
+  }
+  buildPushRequest(request) {
+    const lines = [];
+    for (let i = 0; i < request.updates.length; i++) {
+      const update = request.updates[i];
+      let line = `${update.oldOid} ${update.newOid} ${update.ref}`;
+      if (i === 0) {
+        line += "\0 report-status";
+      }
+      lines.push(writePktLine(line + "\n"));
+    }
+    lines.push(flushPkt());
+    lines.push(request.packfile);
+    return concat(...lines);
+  }
+  parsePushResponse(data) {
+    const refs = [];
+    let ok = true;
+    let offset = 0;
+    while (offset < data.length) {
+      const { line, nextOffset } = readPktLine(data, offset);
+      offset = nextOffset;
+      if (line === null) continue;
+      const text = decode(line).trim();
+      if (text.startsWith("ok ")) {
+        refs.push({ ref: text.substring(3), status: "ok" });
+      } else if (text.startsWith("ng ")) {
+        ok = false;
+        const parts = text.substring(3).split(" ");
+        const ref = parts[0];
+        const reason = parts.slice(1).join(" ");
+        refs.push({ ref, status: "rejected", reason });
+      }
+    }
+    return { ok, refs };
+  }
+};
+function readPktLine(data, offset) {
+  if (offset + 4 > data.length) {
+    return { line: null, nextOffset: data.length };
+  }
+  const lenHex = decode(data.subarray(offset, offset + 4));
+  const len = parseInt(lenHex, 16);
+  if (len === 0) {
+    return { line: null, nextOffset: offset + 4 };
+  }
+  if (len < 4) {
+    return { line: null, nextOffset: offset + 4 };
+  }
+  const line = data.subarray(offset + 4, offset + len);
+  return { line, nextOffset: offset + len };
+}
+function writePktLine(text) {
+  const data = encode(text);
+  const len = data.length + 4;
+  const lenHex = len.toString(16).padStart(4, "0");
+  return concat(encode(lenHex), data);
+}
+function flushPkt() {
+  return encode("0000");
+}
+
+// src/index.ts
+async function initRepository(layer, options = {}) {
+  const bare = options.bare ?? false;
+  const defaultBranch = options.defaultBranch || "main";
+  const workDir = bare ? "/" : "/";
+  const gitDir = bare ? "/" : "/.git";
+  if (bare) {
+    if (await layer.exists("/refs") || await layer.exists("/objects")) {
+      throw new GitError("REPO_NOT_EMPTY", "Repository already exists");
+    }
+  } else {
+    if (await layer.exists(gitDir)) {
+      throw new GitError("REPO_NOT_EMPTY", "Repository already exists");
+    }
+  }
+  await layer.mkdir(`${gitDir}/objects`, { recursive: true });
+  await layer.mkdir(`${gitDir}/refs/heads`, { recursive: true });
+  await layer.mkdir(`${gitDir}/refs/tags`, { recursive: true });
+  await layer.writeFile(
+    `${gitDir}/HEAD`,
+    encode(`ref: refs/heads/${defaultBranch}
+`)
+  );
+  const configContent = [
+    "[core]",
+    "	repositoryformatversion = 0",
+    "	filemode = true",
+    `	bare = ${bare}`,
+    ""
+  ].join("\n");
+  await layer.writeFile(`${gitDir}/config`, encode(configContent));
+  const repo = new Repository(layer, workDir);
+  await repo.load();
+  return repo;
+}
+async function openRepository(layer) {
+  const gitDir = "/.git";
+  if (!await layer.exists(gitDir)) {
+    throw new GitError("NOT_A_GIT_REPO", "Not a git repository");
+  }
+  const repo = new Repository(layer, "/");
+  await repo.load();
+  return repo;
+}
+async function cloneRepository(layer, options) {
+  try {
+    const entries = await layer.readdir("/");
+    if (entries.length > 0) {
+      throw new GitError("REPO_NOT_EMPTY", "Destination directory is not empty");
+    }
+  } catch (e) {
+    if (e instanceof GitError) throw e;
+  }
+  const repo = await initRepository(layer, {
+    defaultBranch: options.branch || "main",
+    bare: options.bare
+  });
+  const transport = options.transport || new HttpTransport({
+    headers: options.auth ? {
+      Authorization: `Basic ${btoa(`${options.auth.username}:${options.auth.password}`)}`
+    } : void 0
+  });
+  repo.setTransport(transport);
+  await repo.addRemote("origin", options.url);
+  await repo.fetch("origin", {
+    depth: options.depth,
+    transport
+  });
+  if (!options.bare) {
+    const branch = options.branch || "main";
+    const trackingRef = `refs/remotes/origin/${branch}`;
+    try {
+      const oid = await repo.refStore.resolveRef(trackingRef);
+      await repo.refStore.writeRef(`refs/heads/${branch}`, oid);
+      await repo.checkout(branch);
+    } catch {
+    }
+  }
+  return repo;
+}
+function httpTransport(options) {
+  return new HttpTransport(options);
+}
+export {
+  DiffEngine,
+  GitConfig,
+  GitError,
+  GitIgnore,
+  HttpTransport,
+  IndexFile,
+  MergeEngine,
+  ObjectDB,
+  RefStore,
+  Repository,
+  StashManager,
+  cloneRepository,
+  computeDiffHunks,
+  formatIdentity,
+  httpTransport,
+  initRepository,
+  openRepository,
+  parseIdentity
+};