@toon-protocol/git 1.0.0

package/dist/chunk-4WFGAICZ.js

@@ -0,0 +1,707 @@
+import {
+  buildRepoAnnouncement,
+  buildRepoRefs
+} from "./chunk-KXXHAUXL.js";
+import {
+  MAX_OBJECT_SIZE
+} from "./chunk-M7O4SEVW.js";
+
+// src/repo-reader.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 256 * 1024 * 1024;
+var GitError = class extends Error {
+  constructor(message, exitCode, stderr) {
+    super(message);
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "GitError";
+  }
+  exitCode;
+  stderr;
+};
+var FULL_SHA_RE = /^[0-9a-f]{40}$/;
+var REV_TOKEN_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]*(?:[~^][0-9]*)*$/;
+function isValidRevision(rev) {
+  if (rev.length === 0 || rev.length > 1024) return false;
+  if (!REV_TOKEN_RE.test(rev)) return false;
+  if (rev.includes("..")) return false;
+  if (rev.endsWith(".lock") || rev.endsWith("/") || rev.endsWith(".")) return false;
+  return true;
+}
+function assertRevision(rev, what) {
+  if (!isValidRevision(rev)) {
+    throw new Error(
+      `${what} is not a valid git revision (got ${JSON.stringify(rev)}); expected a SHA or simple refname \u2014 options/ranges are rejected`
+    );
+  }
+}
+function assertFullSha(sha, what) {
+  if (!FULL_SHA_RE.test(sha)) {
+    throw new Error(
+      `${what} is not a full 40-hex SHA-1 (got ${JSON.stringify(sha)})`
+    );
+  }
+}
+function assertRange(range, what) {
+  const parts = range.split(/\.{2,3}/);
+  const separators = range.match(/\.{2,3}/g) ?? [];
+  const ok = parts.length <= 2 && separators.length === parts.length - 1 && parts.every((p) => isValidRevision(p));
+  if (!ok) {
+    throw new Error(
+      `${what} is not a valid revision range (got ${JSON.stringify(range)}); expected <rev>, <rev>..<rev>, or <rev>...<rev>`
+    );
+  }
+}
+var OBJECT_TYPES = /* @__PURE__ */ new Set(["blob", "tree", "commit", "tag"]);
+var BatchParser = class {
+  buf = Buffer.alloc(0);
+  pending = null;
+  objects = [];
+  missing = [];
+  push(chunk) {
+    this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+    this.drain();
+  }
+  /** True when no partially-parsed record remains. */
+  isComplete() {
+    return this.pending === null && this.buf.length === 0;
+  }
+  drain() {
+    for (; ; ) {
+      if (this.pending) {
+        const needed = this.pending.size + 1;
+        if (this.buf.length < needed) return;
+        const body = Buffer.from(this.buf.subarray(0, this.pending.size));
+        this.objects.push({ sha: this.pending.sha, type: this.pending.type, body });
+        this.buf = this.buf.subarray(needed);
+        this.pending = null;
+        continue;
+      }
+      const nl = this.buf.indexOf(10);
+      if (nl === -1) return;
+      const header = this.buf.subarray(0, nl).toString("utf-8");
+      this.buf = this.buf.subarray(nl + 1);
+      const [name, second, third] = header.split(" ");
+      if (name && second === "missing" && third === void 0) {
+        this.missing.push(name);
+        continue;
+      }
+      if (name && second && third !== void 0 && OBJECT_TYPES.has(second)) {
+        const size = Number.parseInt(third, 10);
+        if (Number.isSafeInteger(size) && size >= 0) {
+          this.pending = { sha: name, type: second, size };
+          continue;
+        }
+      }
+      throw new GitError(
+        `unexpected cat-file --batch header: ${JSON.stringify(header)}`,
+        void 0,
+        ""
+      );
+    }
+  }
+};
+var GitRepoReader = class {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
+  repoPath;
+  /** Run git with argument-array safety; resolves stdout as UTF-8. */
+  async git(args, opts = {}) {
+    try {
+      const { stdout } = await execFileAsync("git", args, {
+        cwd: this.repoPath,
+        maxBuffer: MAX_BUFFER,
+        encoding: "utf-8"
+      });
+      return { stdout, exitCode: 0 };
+    } catch (err) {
+      const e = err;
+      const exitCode = typeof e.code === "number" ? e.code : void 0;
+      if (exitCode !== void 0 && opts.allowExitCodes?.includes(exitCode)) {
+        return { stdout: e.stdout ?? "", exitCode };
+      }
+      throw new GitError(
+        `git ${args[0]} failed${exitCode !== void 0 ? ` (exit ${exitCode})` : ""}: ${(e.stderr ?? e.message ?? "").trim()}`,
+        exitCode,
+        (e.stderr ?? "").trim()
+      );
+    }
+  }
+  /**
+   * List all branches and tags plus the symbolic HEAD.
+   *
+   * Annotated tags report the tag object's SHA/type with the peeled target
+   * in `peeledSha`. A detached HEAD is tolerated (`head` is `undefined`).
+   */
+  async listRefs() {
+    const format = "%(refname)%00%(objectname)%00%(objecttype)%00%(*objectname)";
+    const [refsRes, headRes] = await Promise.all([
+      this.git(["for-each-ref", `--format=${format}`, "refs/heads", "refs/tags"]),
+      // Exit 1 = detached HEAD (or unborn branch pointer oddities) — tolerated.
+      this.git(["symbolic-ref", "--quiet", "HEAD"], { allowExitCodes: [1] })
+    ]);
+    const refs = [];
+    for (const line of refsRes.stdout.split("\n")) {
+      if (!line) continue;
+      const [refname, sha, objecttype, peeled] = line.split("\0");
+      if (!refname || !sha || !objecttype || !OBJECT_TYPES.has(objecttype)) {
+        throw new GitError(`unexpected for-each-ref line: ${JSON.stringify(line)}`, void 0, "");
+      }
+      refs.push({
+        refname,
+        sha,
+        type: objecttype,
+        ...peeled ? { peeledSha: peeled } : {}
+      });
+    }
+    const head = headRes.exitCode === 0 ? headRes.stdout.trim() || void 0 : void 0;
+    return { head, refs };
+  }
+  /**
+   * SHAs of every object reachable from `want` but not from `have`
+   * (`git rev-list --objects <want…> --not <have…>`), i.e. the push delta.
+   *
+   * Haves that don't exist locally (e.g. remote tips we never fetched) are
+   * filtered out first via one `cat-file --batch-check` pass — rev-list
+   * would otherwise die on them.
+   */
+  async objectsBetween(want, have) {
+    const objects = await this.objectsBetweenWithPaths(want, have);
+    return objects.map((o) => o.sha);
+  }
+  /**
+   * Like {@link objectsBetween} but keeps the path each object was reached
+   * by (`rev-list --objects` emits `<sha> <path>` for blobs and non-root
+   * trees) — used by push planning to report actionable oversize errors.
+   */
+  async objectsBetweenWithPaths(want, have) {
+    for (const w of want) assertRevision(w, "want");
+    for (const h of have) assertRevision(h, "have");
+    if (want.length === 0) return [];
+    const knownHaves = await this.filterExisting(have);
+    const args = ["rev-list", "--objects", ...want];
+    if (knownHaves.length > 0) args.push("--not", ...knownHaves);
+    args.push("--");
+    const { stdout } = await this.git(args);
+    const objects = [];
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx === -1) {
+        objects.push({ sha: line });
+      } else {
+        const path = line.slice(spaceIdx + 1);
+        objects.push({
+          sha: line.slice(0, spaceIdx),
+          ...path ? { path } : {}
+        });
+      }
+    }
+    return objects;
+  }
+  /** Run git feeding `input` on stdin; resolves collected stdout bytes. */
+  runWithStdin(args, input) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd: this.repoPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const out = [];
+      let stderr = "";
+      child.stdout.on("data", (chunk) => out.push(chunk));
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        reject(new GitError(`failed to spawn git ${args[0]}: ${err.message}`, void 0, ""));
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          return reject(
+            new GitError(`git ${args[0]} failed (exit ${code}): ${stderr.trim()}`, code ?? void 0, stderr.trim())
+          );
+        }
+        resolve(Buffer.concat(out));
+      });
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(input);
+      child.stdin.end();
+    });
+  }
+  /** Of the given revisions, keep only those resolvable locally. */
+  async filterExisting(revs) {
+    if (revs.length === 0) return [];
+    const { missing } = await this.batchCheck(revs);
+    const missingSet = new Set(missing);
+    return revs.filter((r) => !missingSet.has(r));
+  }
+  /** One `cat-file --batch-check` pass; returns names reported missing. */
+  async batchCheck(names) {
+    const stdout = await this.runWithStdin(
+      ["cat-file", "--batch-check"],
+      names.join("\n") + "\n"
+    );
+    const missing = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+      if (line.endsWith(" missing")) missing.push(line.slice(0, -" missing".length));
+    }
+    return { missing };
+  }
+  /**
+   * Object metadata (type + body size) for a batch of SHAs via one
+   * `cat-file --batch-check` pass — no bodies are read. Missing objects are
+   * reported, not thrown.
+   */
+  async statObjects(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return { objects: [], missing: [] };
+    const stdout = await this.runWithStdin(
+      ["cat-file", "--batch-check"],
+      shas.join("\n") + "\n"
+    );
+    const objects = [];
+    const missing = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+      if (!line) continue;
+      if (line.endsWith(" missing")) {
+        missing.push(line.slice(0, -" missing".length));
+        continue;
+      }
+      const [sha, type, sizeStr] = line.split(" ");
+      const size = Number.parseInt(sizeStr ?? "", 10);
+      if (!sha || !type || !OBJECT_TYPES.has(type) || !Number.isSafeInteger(size) || size < 0) {
+        throw new GitError(
+          `unexpected cat-file --batch-check line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      objects.push({ sha, type, size });
+    }
+    return { objects, missing };
+  }
+  /**
+   * Read raw object bodies via a single streaming `git cat-file --batch`
+   * child process. Bodies may be binary and are parsed size-driven across
+   * chunk boundaries. Missing objects are reported, not thrown.
+   */
+  async readObjects(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return { objects: [], missing: [] };
+    const parser = new BatchParser();
+    await new Promise((resolve, reject) => {
+      const child = spawn("git", ["cat-file", "--batch"], {
+        cwd: this.repoPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stderr = "";
+      let parseError = null;
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.stdout.on("data", (chunk) => {
+        if (parseError) return;
+        try {
+          parser.push(chunk);
+        } catch (err) {
+          parseError = err;
+          child.kill();
+        }
+      });
+      child.on("error", (err) => {
+        reject(new GitError(`failed to spawn git cat-file: ${err.message}`, void 0, ""));
+      });
+      child.on("close", (code) => {
+        if (parseError) return reject(parseError);
+        if (code !== 0) {
+          return reject(
+            new GitError(`git cat-file --batch failed (exit ${code}): ${stderr.trim()}`, code ?? void 0, stderr.trim())
+          );
+        }
+        if (!parser.isComplete()) {
+          return reject(
+            new GitError("git cat-file --batch output ended mid-record", code ?? void 0, stderr.trim())
+          );
+        }
+        resolve();
+      });
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(shas.join("\n") + "\n");
+      child.stdin.end();
+    });
+    return { objects: parser.objects, missing: parser.missing };
+  }
+  /**
+   * `git merge-base --is-ancestor <a> <b>` — true when `a` is an ancestor
+   * of `b` (fast-forward check / force detection). Exit codes other than
+   * 0/1 (e.g. unknown revisions) throw.
+   */
+  async isAncestor(a, b) {
+    assertRevision(a, "ancestor candidate");
+    assertRevision(b, "descendant candidate");
+    const { exitCode } = await this.git(
+      ["merge-base", "--is-ancestor", a, b],
+      { allowExitCodes: [1] }
+    );
+    return exitCode === 0;
+  }
+  /**
+   * `git format-patch --stdout <range>` — the full mbox-formatted patch
+   * series text (empty string when the range selects no commits).
+   */
+  async formatPatch(range) {
+    assertRange(range, "range");
+    const { stdout } = await this.git(["format-patch", "--stdout", range, "--"]);
+    return stdout;
+  }
+  /**
+   * Parent SHAs for a batch of commit SHAs via one
+   * `git rev-list --no-walk=unsorted --parents` pass. Root commits map to an
+   * empty array. Used to derive the kind:1617 `commit`/`parent-commit` tag
+   * pairs for exactly the commits a format-patch series carries.
+   */
+  async commitParents(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return /* @__PURE__ */ new Map();
+    const { stdout } = await this.git([
+      "rev-list",
+      "--no-walk=unsorted",
+      "--parents",
+      ...shas,
+      "--"
+    ]);
+    const parents = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const [sha, ...rest] = line.split(" ");
+      if (!sha || !FULL_SHA_RE.test(sha) || rest.some((p) => !FULL_SHA_RE.test(p))) {
+        throw new GitError(
+          `unexpected rev-list --parents line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      parents.set(sha, rest);
+    }
+    return parents;
+  }
+  /**
+   * Resolve a ref/revision to a full SHA via `git rev-parse --verify`.
+   * Throws {@link GitError} when the name doesn't resolve.
+   */
+  async resolveRef(name) {
+    assertRevision(name, "ref name");
+    const { stdout } = await this.git(["rev-parse", "--verify", "--quiet", name]);
+    const sha = stdout.trim();
+    if (!FULL_SHA_RE.test(sha)) {
+      throw new GitError(
+        `rev-parse --verify returned unexpected output for ${JSON.stringify(name)}: ${JSON.stringify(sha)}`,
+        void 0,
+        ""
+      );
+    }
+    return sha;
+  }
+};
+
+// src/routes.ts
+function serializeFeeEstimate(plan) {
+  return {
+    objectCount: plan.estimate.objectCount,
+    totalObjectBytes: plan.estimate.totalObjectBytes,
+    uploadFee: plan.estimate.uploadFee.toString(),
+    eventCount: plan.estimate.eventCount,
+    eventFees: plan.estimate.eventFees.toString(),
+    totalFee: plan.estimate.totalFee.toString()
+  };
+}
+function serializePushPlan(plan) {
+  return {
+    repoId: plan.repoId,
+    refUpdates: plan.refUpdates,
+    newRefs: plan.newRefs,
+    headSymref: plan.headSymref,
+    objects: plan.objects,
+    knownShaToTxId: Object.fromEntries(plan.knownShaToTxId),
+    announceNeeded: plan.announceNeeded,
+    announcement: plan.announcement,
+    estimate: serializeFeeEstimate(plan)
+  };
+}
+function serializeEventReceipt(kind, receipt) {
+  return {
+    eventId: receipt.eventId,
+    feePaid: receipt.feePaid.toString(),
+    kind
+  };
+}
+function serializePushResult(plan, result) {
+  return {
+    repoId: plan.repoId,
+    refUpdates: plan.refUpdates,
+    uploads: result.uploads.map((u) => ({
+      sha: u.sha,
+      txId: u.txId,
+      feePaid: u.feePaid.toString(),
+      skipped: u.skipped
+    })),
+    announceReceipt: result.announceReceipt ? {
+      eventId: result.announceReceipt.eventId,
+      feePaid: result.announceReceipt.feePaid.toString()
+    } : null,
+    refsReceipt: {
+      eventId: result.refsReceipt.eventId,
+      feePaid: result.refsReceipt.feePaid.toString()
+    },
+    arweaveMap: Object.fromEntries(result.arweaveMap),
+    totalFeePaid: result.totalFeePaid.toString(),
+    estimate: serializeFeeEstimate(plan)
+  };
+}
+
+// src/push.ts
+var NonFastForwardError = class extends Error {
+  constructor(refs) {
+    super(
+      `non-fast-forward update rejected for ${refs.map((r) => r.refname).join(", ")} \u2014 re-run with force to overwrite the remote ref(s)`
+    );
+    this.refs = refs;
+    this.name = "NonFastForwardError";
+  }
+  refs;
+};
+var OversizeObjectsError = class extends Error {
+  constructor(objects) {
+    super(
+      `${objects.length} object(s) exceed the ${MAX_OBJECT_SIZE} byte upload limit: ` + objects.map((o) => `${o.path ?? o.sha} (${o.size} bytes)`).join(", ")
+    );
+    this.objects = objects;
+    this.name = "OversizeObjectsError";
+  }
+  objects;
+};
+async function planPush(options) {
+  const { repoReader, remoteState, feeRates, repoId, force = false } = options;
+  const resolveMissing = options.resolveMissing ?? remoteState.resolveMissing.bind(remoteState);
+  const { head, refs: localRefs } = await repoReader.listRefs();
+  const localByName = new Map(localRefs.map((r) => [r.refname, r]));
+  let selected;
+  if (options.refs !== void 0) {
+    selected = options.refs.map((name) => {
+      const ref = localByName.get(name);
+      if (!ref) {
+        throw new Error(
+          `ref ${JSON.stringify(name)} does not exist locally (ref deletion is out of scope in v1)`
+        );
+      }
+      return ref;
+    });
+  } else {
+    selected = localRefs;
+  }
+  const refUpdates = [];
+  const rejected = [];
+  for (const ref of selected) {
+    const remoteSha = remoteState.refs.get(ref.refname) ?? null;
+    if (remoteSha === null) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "new" });
+      continue;
+    }
+    if (remoteSha === ref.sha) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "up-to-date" });
+      continue;
+    }
+    let fastForward = false;
+    try {
+      fastForward = await repoReader.isAncestor(remoteSha, ref.sha);
+    } catch (err) {
+      if (!(err instanceof GitError)) throw err;
+      fastForward = false;
+    }
+    if (fastForward) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "fast-forward" });
+    } else if (force) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "forced" });
+    } else {
+      rejected.push({ refname: ref.refname, localSha: ref.sha, remoteSha });
+    }
+  }
+  if (rejected.length > 0) throw new NonFastForwardError(rejected);
+  const updates = refUpdates.filter((u) => u.kind !== "up-to-date");
+  const wantTips = [...new Set(updates.map((u) => u.localSha))];
+  const haveTips = [...new Set(remoteState.refs.values())];
+  const delta = wantTips.length > 0 ? await repoReader.objectsBetweenWithPaths(wantTips, haveTips) : [];
+  const knownShaToTxId = new Map(remoteState.shaToTxId);
+  let candidates = delta.filter((o) => !knownShaToTxId.has(o.sha));
+  if (candidates.length > 0) {
+    const resolved = await resolveMissing(candidates.map((o) => o.sha));
+    for (const [sha, txId] of resolved) knownShaToTxId.set(sha, txId);
+    candidates = candidates.filter((o) => !knownShaToTxId.has(o.sha));
+  }
+  const pathBySha = new Map(candidates.map((c) => [c.sha, c.path]));
+  const { objects: stats, missing } = await repoReader.statObjects(
+    candidates.map((c) => c.sha)
+  );
+  if (missing.length > 0) {
+    throw new Error(
+      `objects vanished from the local repository during planning: ${missing.join(", ")}`
+    );
+  }
+  const oversize = [];
+  for (const stat of stats) {
+    if (stat.size > MAX_OBJECT_SIZE) {
+      const path = pathBySha.get(stat.sha);
+      oversize.push({ ...stat, ...path ? { path } : {} });
+    }
+  }
+  if (oversize.length > 0) throw new OversizeObjectsError(oversize);
+  const tipShas = new Set(updates.map((u) => u.localSha));
+  const planned = stats.map((stat) => {
+    const path = pathBySha.get(stat.sha);
+    return { ...stat, ...path ? { path } : {}, isRefTip: tipShas.has(stat.sha) };
+  });
+  const objects = [
+    ...planned.filter((o) => !o.isRefTip),
+    ...planned.filter((o) => o.isRefTip)
+  ];
+  const newRefsMap = new Map(remoteState.refs);
+  for (const update of updates) newRefsMap.set(update.refname, update.localSha);
+  const headSymref = head && newRefsMap.has(head) ? head : remoteState.headSymref && newRefsMap.has(remoteState.headSymref) ? remoteState.headSymref : [...newRefsMap.keys()][0] ?? null;
+  const newRefs = {};
+  const headSha = headSymref ? newRefsMap.get(headSymref) : void 0;
+  if (headSymref && headSha) newRefs[headSymref] = headSha;
+  for (const [refname, sha] of newRefsMap) {
+    if (refname !== headSymref) newRefs[refname] = sha;
+  }
+  const announceNeeded = !remoteState.announced;
+  const totalObjectBytes = objects.reduce((sum, o) => sum + o.size, 0);
+  const uploadFee = BigInt(totalObjectBytes) * feeRates.uploadFeePerByte;
+  const eventCount = 1 + (announceNeeded ? 1 : 0);
+  const eventFees = BigInt(eventCount) * feeRates.eventFee;
+  return {
+    repoId,
+    refUpdates,
+    newRefs,
+    headSymref,
+    objects,
+    knownShaToTxId,
+    announceNeeded,
+    announcement: {
+      name: options.announcement?.name ?? repoId,
+      description: options.announcement?.description ?? ""
+    },
+    estimate: {
+      objectCount: objects.length,
+      totalObjectBytes,
+      uploadFee,
+      eventCount,
+      eventFees,
+      totalFee: uploadFee + eventFees
+    }
+  };
+}
+var READ_BATCH_SIZE = 100;
+async function executePush(options) {
+  const { plan, publisher, remoteState, repoReader, relayUrls } = options;
+  const merged = new Map([...remoteState.shaToTxId, ...plan.knownShaToTxId]);
+  const resultBySha = /* @__PURE__ */ new Map();
+  let totalFeePaid = 0n;
+  const pending = [];
+  for (const object of plan.objects) {
+    const knownTxId = merged.get(object.sha);
+    if (knownTxId !== void 0) {
+      resultBySha.set(object.sha, {
+        sha: object.sha,
+        txId: knownTxId,
+        feePaid: 0n,
+        skipped: true
+      });
+    } else {
+      pending.push(object);
+    }
+  }
+  for (let i = 0; i < pending.length; i += READ_BATCH_SIZE) {
+    const batch = pending.slice(i, i + READ_BATCH_SIZE);
+    const { objects: read, missing } = await repoReader.readObjects(
+      batch.map((o) => o.sha)
+    );
+    if (missing.length > 0) {
+      throw new Error(
+        `objects vanished from the local repository during push: ${missing.join(", ")}`
+      );
+    }
+    const bodyBySha = new Map(read.map((r) => [r.sha, r.body]));
+    for (const object of batch) {
+      const body = bodyBySha.get(object.sha);
+      if (!body) {
+        throw new Error(
+          `internal: cat-file returned no body for ${object.sha}`
+        );
+      }
+      const receipt = await publisher.uploadGitObject({
+        sha: object.sha,
+        type: object.type,
+        body,
+        repoId: plan.repoId
+      });
+      merged.set(object.sha, receipt.txId);
+      totalFeePaid += receipt.feePaid;
+      resultBySha.set(object.sha, {
+        sha: object.sha,
+        txId: receipt.txId,
+        feePaid: receipt.feePaid,
+        skipped: false
+      });
+    }
+  }
+  let announceReceipt = null;
+  if (plan.announceNeeded && !remoteState.announced) {
+    const announceEvent = buildRepoAnnouncement(
+      plan.repoId,
+      plan.announcement.name,
+      plan.announcement.description
+    );
+    announceReceipt = await publisher.publishEvent(announceEvent, relayUrls);
+    totalFeePaid += announceReceipt.feePaid;
+  }
+  const refsEvent = buildRepoRefs(
+    plan.repoId,
+    plan.newRefs,
+    Object.fromEntries(merged)
+  );
+  const refsReceipt = await publisher.publishEvent(refsEvent, relayUrls);
+  totalFeePaid += refsReceipt.feePaid;
+  const uploads = plan.objects.map((o) => {
+    const step = resultBySha.get(o.sha);
+    if (!step) {
+      throw new Error(`internal: no upload result recorded for ${o.sha}`);
+    }
+    return step;
+  });
+  return {
+    uploads,
+    announceReceipt,
+    refsReceipt,
+    arweaveMap: merged,
+    totalFeePaid
+  };
+}
+
+export {
+  GitError,
+  GitRepoReader,
+  serializeFeeEstimate,
+  serializePushPlan,
+  serializeEventReceipt,
+  serializePushResult,
+  NonFastForwardError,
+  OversizeObjectsError,
+  planPush,
+  executePush
+};
+//# sourceMappingURL=chunk-4WFGAICZ.js.map