@toon-protocol/rig 4.2.0 → 4.4.0

package/dist/chunk-TJPIE5X4.js

@@ -1,1294 +0,0 @@
-import {
-  ARWEAVE_FETCH_TIMEOUT_MS,
-  ARWEAVE_GATEWAYS,
-  buildRepoAnnouncement,
-  buildRepoRefs,
-  isValidArweaveTxId
-} from "./chunk-NCEMQUPA.js";
-import {
-  uploadChargeFor
-} from "./chunk-CXREFXB6.js";
-
-// src/objects.ts
-import { createHash } from "crypto";
-var FREE_TIER_MAX_ITEM_BYTES = 107520;
-var MAX_OBJECT_SIZE = FREE_TIER_MAX_ITEM_BYTES;
-var EMPTY_BLOB_SHA = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391";
-function hashGitObject(type, body) {
-  const header = Buffer.from(`${type} ${body.length}\0`);
-  const fullObject = Buffer.concat([header, body]);
-  const sha = createHash("sha1").update(fullObject).digest("hex");
-  return { sha, buffer: fullObject, body };
-}
-function createGitBlob(content) {
-  return hashGitObject("blob", Buffer.from(content, "utf-8"));
-}
-function createGitTree(entries) {
-  const sorted = [...entries].sort(
-    (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
-  );
-  const entryBuffers = [];
-  for (const entry of sorted) {
-    const modeAndName = Buffer.from(`${entry.mode} ${entry.name}\0`);
-    const rawSha = Buffer.from(entry.sha, "hex");
-    entryBuffers.push(Buffer.concat([modeAndName, rawSha]));
-  }
-  return hashGitObject("tree", Buffer.concat(entryBuffers));
-}
-function createGitCommit(opts) {
-  const lines = [
-    `tree ${opts.treeSha}`,
-    ...opts.parentSha ? [`parent ${opts.parentSha}`] : [],
-    `author ${opts.authorName} <${opts.authorPubkey}@nostr> ${opts.timestamp} +0000`,
-    `committer ${opts.authorName} <${opts.authorPubkey}@nostr> ${opts.timestamp} +0000`,
-    "",
-    opts.message
-  ];
-  return hashGitObject("commit", Buffer.from(lines.join("\n"), "utf-8"));
-}
-function createGitTag(opts) {
-  const lines = [
-    `object ${opts.objectSha}`,
-    `type ${opts.objectType}`,
-    `tag ${opts.tagName}`,
-    `tagger ${opts.taggerName} <${opts.taggerPubkey}@nostr> ${opts.timestamp} +0000`,
-    "",
-    opts.message
-  ];
-  return hashGitObject("tag", Buffer.from(lines.join("\n"), "utf-8"));
-}
-
-// 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;
-  }
-  /**
-   * List every blob (file) reachable from a ref's root tree, recursively,
-   * with the path it is served at (#368: the ar.io site manifest join key).
-   * Uses `git ls-tree -r -z` — NUL-terminated records so binary/spaced paths
-   * survive verbatim, and no path quoting to undo. Submodule (`commit`)
-   * gitlink entries and directories are excluded; only real file blobs remain.
-   */
-  async listBlobs(rev) {
-    assertRevision(rev, "ref");
-    const { stdout } = await this.git(["ls-tree", "-r", "-z", rev, "--"]);
-    const blobs = [];
-    for (const record of stdout.split("\0")) {
-      if (!record) continue;
-      const tab = record.indexOf("	");
-      if (tab === -1) {
-        throw new GitError(
-          `unexpected ls-tree record: ${JSON.stringify(record)}`,
-          void 0,
-          ""
-        );
-      }
-      const meta = record.slice(0, tab);
-      const path = record.slice(tab + 1);
-      const [, type, sha] = meta.split(" ");
-      if (type !== "blob") continue;
-      if (!sha || !FULL_SHA_RE.test(sha)) {
-        throw new GitError(
-          `unexpected ls-tree object id: ${JSON.stringify(record)}`,
-          void 0,
-          ""
-        );
-      }
-      blobs.push({ path, sha });
-    }
-    return blobs;
-  }
-  /** 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/object-fetch.ts
-var DEFAULT_CONCURRENCY = 8;
-var ObjectIntegrityError = class extends Error {
-  constructor(objects) {
-    super(
-      `${objects.length} downloaded object(s) failed SHA-1 verification \u2014 the gateway content does not match the announced git SHA(s): ` + objects.map((o) => `${o.sha} (tx ${o.txId})`).join(", ") + ". Refusing to write corrupt/tampered objects."
-    );
-    this.objects = objects;
-    this.name = "ObjectIntegrityError";
-  }
-  objects;
-};
-var OBJECT_TYPES2 = [
-  "blob",
-  "tree",
-  "commit",
-  "tag"
-];
-function verifyObjectBody(expectedSha, bytes) {
-  const body = Buffer.from(bytes);
-  for (const type of OBJECT_TYPES2) {
-    if (hashGitObject(type, body).sha === expectedSha) {
-      return { sha: expectedSha, type, body };
-    }
-  }
-  return null;
-}
-async function fetchTxBytes(txId, options = {}) {
-  if (!isValidArweaveTxId(txId)) return null;
-  const gateways = options.gateways ?? ARWEAVE_GATEWAYS;
-  const fetchFn = options.fetchFn ?? fetch;
-  const timeoutMs = options.timeoutMs ?? ARWEAVE_FETCH_TIMEOUT_MS;
-  for (const gateway of gateways) {
-    try {
-      const response = await fetchFn(`${gateway}/${txId}`, {
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!response.ok) continue;
-      return new Uint8Array(await response.arrayBuffer());
-    } catch {
-    }
-  }
-  return null;
-}
-async function downloadGitObjects(entries, options = {}) {
-  const queue = [...entries];
-  const total = queue.length;
-  const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY);
-  const objects = /* @__PURE__ */ new Map();
-  const unavailable = [];
-  const corrupt = [];
-  let done = 0;
-  const worker = async () => {
-    for (; ; ) {
-      const next = queue.shift();
-      if (!next) return;
-      const [sha, txId] = next;
-      const bytes = await fetchTxBytes(txId, options);
-      if (bytes === null) {
-        unavailable.push({ sha, txId });
-      } else {
-        const verified = verifyObjectBody(sha, bytes);
-        if (verified === null) {
-          corrupt.push({ sha, txId });
-        } else {
-          objects.set(sha, verified);
-        }
-      }
-      done += 1;
-      options.onObject?.(done, total);
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, total) }, () => worker())
-  );
-  if (corrupt.length > 0) throw new ObjectIntegrityError(corrupt);
-  return { objects, unavailable };
-}
-var FULL_SHA_RE2 = /^[0-9a-f]{40}$/;
-var GITLINK_MODE = "160000";
-function bytesToHex(bytes) {
-  let hex = "";
-  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
-  return hex;
-}
-function referencedShas(object) {
-  switch (object.type) {
-    case "blob":
-      return [];
-    case "tree": {
-      const refs = [];
-      const data = object.body;
-      let offset = 0;
-      while (offset < data.length) {
-        const spaceIdx = data.indexOf(32, offset);
-        if (spaceIdx === -1) break;
-        const mode = data.subarray(offset, spaceIdx).toString("utf-8");
-        const nulIdx = data.indexOf(0, spaceIdx + 1);
-        if (nulIdx === -1 || nulIdx + 21 > data.length) break;
-        const sha = bytesToHex(data.subarray(nulIdx + 1, nulIdx + 21));
-        if (mode !== GITLINK_MODE) refs.push(sha);
-        offset = nulIdx + 21;
-      }
-      return refs;
-    }
-    case "commit": {
-      const refs = [];
-      const text = object.body.toString("utf-8");
-      const headerEnd = text.indexOf("\n\n");
-      const header = headerEnd === -1 ? text : text.slice(0, headerEnd);
-      for (const line of header.split("\n")) {
-        if (line.startsWith("tree ")) refs.push(line.slice(5).trim());
-        else if (line.startsWith("parent ")) refs.push(line.slice(7).trim());
-      }
-      return refs.filter((sha) => FULL_SHA_RE2.test(sha));
-    }
-    case "tag": {
-      const text = object.body.toString("utf-8");
-      const match = /^object ([0-9a-f]{40})$/m.exec(text);
-      return match?.[1] ? [match[1]] : [];
-    }
-  }
-}
-function walkClosure(tips, objects, presentLocally = /* @__PURE__ */ new Set()) {
-  const reachable = /* @__PURE__ */ new Set();
-  const missing = /* @__PURE__ */ new Set();
-  const stack = [...new Set(tips)];
-  while (stack.length > 0) {
-    const sha = stack.pop();
-    if (reachable.has(sha) || missing.has(sha)) continue;
-    if (presentLocally.has(sha)) continue;
-    const object = objects.get(sha);
-    if (!object) {
-      missing.add(sha);
-      continue;
-    }
-    reachable.add(sha);
-    for (const ref of referencedShas(object)) {
-      if (!reachable.has(ref) && !missing.has(ref)) stack.push(ref);
-    }
-  }
-  return { reachable, missing: [...missing] };
-}
-
-// src/read-pipeline.ts
-var MAX_PASSES = 64;
-async function collectRepoObjects(options) {
-  const { tips, shaToTxId, resolveMissing } = options;
-  const present = options.presentLocally ?? /* @__PURE__ */ new Set();
-  const txIds = new Map(shaToTxId);
-  const resolverAsked = /* @__PURE__ */ new Set();
-  const undownloadable = /* @__PURE__ */ new Map();
-  const objects = /* @__PURE__ */ new Map();
-  const initial = [];
-  for (const [sha, txId] of txIds) {
-    if (!present.has(sha)) initial.push([sha, txId]);
-  }
-  const bulk = await downloadGitObjects(initial, options);
-  for (const [sha, object] of bulk.objects) objects.set(sha, object);
-  for (const { sha, txId } of bulk.unavailable) undownloadable.set(sha, txId);
-  for (let pass = 0; pass < MAX_PASSES; pass++) {
-    const closure = walkClosure(tips, objects, present);
-    const open = closure.missing.filter((sha) => !undownloadable.has(sha));
-    if (open.length === 0) break;
-    const toResolve = open.filter(
-      (sha) => !txIds.has(sha) && !resolverAsked.has(sha)
-    );
-    for (const sha of toResolve) resolverAsked.add(sha);
-    if (toResolve.length > 0) {
-      const resolved = await resolveMissing(toResolve);
-      for (const [sha, txId] of resolved) txIds.set(sha, txId);
-    }
-    const batch = [];
-    for (const sha of open) {
-      const txId = txIds.get(sha);
-      if (txId !== void 0 && !objects.has(sha)) batch.push([sha, txId]);
-    }
-    if (batch.length === 0) break;
-    const result = await downloadGitObjects(batch, options);
-    for (const [sha, object] of result.objects) objects.set(sha, object);
-    for (const { sha, txId } of result.unavailable)
-      undownloadable.set(sha, txId);
-    if (result.objects.size === 0) break;
-  }
-  let finalClosure = walkClosure(tips, objects, present);
-  if (finalClosure.missing.includes(EMPTY_BLOB_SHA) && !present.has(EMPTY_BLOB_SHA)) {
-    objects.set(EMPTY_BLOB_SHA, {
-      sha: EMPTY_BLOB_SHA,
-      type: "blob",
-      body: Buffer.alloc(0)
-    });
-    finalClosure = walkClosure(tips, objects, present);
-  }
-  const missing = finalClosure.missing.map((sha) => ({
-    sha,
-    txId: txIds.get(sha) ?? null
-  }));
-  const reachable = finalClosure.reachable;
-  const skippedUnavailable = [...undownloadable].filter(
-    ([sha]) => !reachable.has(sha) && !finalClosure.missing.includes(sha)
-  ).map(([sha, txId]) => ({ sha, txId }));
-  return { objects, missing, skippedUnavailable };
-}
-function missingObjectsMessage(missing, context) {
-  const listed = missing.slice(0, 20).map(
-    (m) => `  ${m.sha}${m.txId ? `  (tx ${m.txId})` : "  (no Arweave tx found)"}`
-  ).join("\n");
-  const more = missing.length > 20 ? `
-  \u2026 and ${missing.length - 20} more` : "";
-  return `${context}: ${missing.length} required object(s) could not be downloaded:
-${listed}${more}
-Recently pushed objects can take 10-20 minutes to become fetchable from Arweave gateways \u2014 if this repo was just pushed, retry in a few minutes. Nothing was written.`;
-}
-
-// src/materialize.ts
-import { execFile as execFile2, spawn as spawn2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-var ObjectWriteMismatchError = class extends Error {
-  constructor(expectedSha, writtenSha) {
-    super(
-      `git hash-object wrote ${writtenSha} where ${expectedSha} was expected \u2014 object content does not round-trip; aborting`
-    );
-    this.expectedSha = expectedSha;
-    this.writtenSha = writtenSha;
-    this.name = "ObjectWriteMismatchError";
-  }
-  expectedSha;
-  writtenSha;
-};
-var FULL_SHA_RE3 = /^[0-9a-f]{40}$/;
-function isSafeRefname(refname) {
-  if (!refname.startsWith("refs/") || refname.length > 1024) return false;
-  if (/[\u0000-\u0020~^:?*[\\\u007f]/.test(refname)) return false;
-  if (refname.includes("..") || refname.includes("@{")) return false;
-  if (refname.endsWith("/") || refname.endsWith(".")) return false;
-  for (const part of refname.split("/")) {
-    if (part === "" || part.startsWith(".") || part.startsWith("-"))
-      return false;
-    if (part.endsWith(".lock")) return false;
-  }
-  return true;
-}
-function assertSafeRefname(refname) {
-  if (!isSafeRefname(refname)) {
-    throw new Error(
-      `unsafe ref name from remote state: ${JSON.stringify(refname)} \u2014 refusing`
-    );
-  }
-}
-function assertFullSha2(sha) {
-  if (!FULL_SHA_RE3.test(sha)) {
-    throw new Error(`not a full 40-hex SHA-1: ${JSON.stringify(sha)}`);
-  }
-}
-async function runGit(repoPath, args) {
-  try {
-    const { stdout } = await execFileAsync2("git", args, {
-      cwd: repoPath,
-      encoding: "utf-8",
-      maxBuffer: 64 * 1024 * 1024
-    });
-    return stdout;
-  } catch (err) {
-    const e = err;
-    throw new Error(
-      `git ${args[0]} failed${typeof e.code === "number" ? ` (exit ${e.code})` : ""}: ${(e.stderr ?? e.message ?? "").trim()}`
-    );
-  }
-}
-async function writeGitObject(repoPath, object) {
-  assertFullSha2(object.sha);
-  const written = await new Promise((resolve, reject) => {
-    const child = spawn2(
-      "git",
-      ["hash-object", "-w", "--stdin", "-t", object.type],
-      { cwd: repoPath, stdio: ["pipe", "pipe", "pipe"] }
-    );
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString("utf-8");
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf-8");
-    });
-    child.on("error", (err) => {
-      reject(new Error(`failed to spawn git hash-object: ${err.message}`));
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        return reject(
-          new Error(`git hash-object failed (exit ${code}): ${stderr.trim()}`)
-        );
-      }
-      resolve(stdout.trim());
-    });
-    child.stdin.on("error", () => {
-    });
-    child.stdin.write(object.body);
-    child.stdin.end();
-  });
-  if (written !== object.sha) {
-    throw new ObjectWriteMismatchError(object.sha, written);
-  }
-}
-async function writeGitObjects(repoPath, objects) {
-  let count = 0;
-  for (const object of objects) {
-    await writeGitObject(repoPath, object);
-    count += 1;
-  }
-  return count;
-}
-async function updateRef(repoPath, refname, sha) {
-  assertSafeRefname(refname);
-  assertFullSha2(sha);
-  await runGit(repoPath, ["update-ref", refname, sha]);
-}
-async function setHeadSymref(repoPath, refname) {
-  assertSafeRefname(refname);
-  await runGit(repoPath, ["symbolic-ref", "HEAD", refname]);
-}
-
-// src/npub.ts
-var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-function bech32Polymod(values) {
-  const GEN = [996825010, 642813549, 513874426, 1027748829, 705979059];
-  let chk = 1;
-  for (const v of values) {
-    const b = chk >> 25;
-    chk = (chk & 33554431) << 5 ^ v;
-    for (let i = 0; i < 5; i++) {
-      chk ^= b >> i & 1 ? GEN[i] : 0;
-    }
-  }
-  return chk;
-}
-function bech32HrpExpand(hrp) {
-  const ret = [];
-  for (let i = 0; i < hrp.length; i++) {
-    ret.push(hrp.charCodeAt(i) >> 5);
-  }
-  ret.push(0);
-  for (let i = 0; i < hrp.length; i++) {
-    ret.push(hrp.charCodeAt(i) & 31);
-  }
-  return ret;
-}
-function bech32CreateChecksum(hrp, data) {
-  const values = bech32HrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
-  const polymod = bech32Polymod(values) ^ 1;
-  const ret = [];
-  for (let i = 0; i < 6; i++) {
-    ret.push(polymod >> 5 * (5 - i) & 31);
-  }
-  return ret;
-}
-function convertBits(data, fromBits, toBits, pad) {
-  let acc = 0;
-  let bits = 0;
-  const ret = [];
-  const maxv = (1 << toBits) - 1;
-  for (const value of data) {
-    acc = acc << fromBits | value;
-    bits += fromBits;
-    while (bits >= toBits) {
-      bits -= toBits;
-      ret.push(acc >> bits & maxv);
-    }
-  }
-  if (pad && bits > 0) {
-    ret.push(acc << toBits - bits & maxv);
-  }
-  return ret;
-}
-function hexToBytes(hex) {
-  const bytes = [];
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes.push(parseInt(hex.slice(i, i + 2), 16));
-  }
-  return bytes;
-}
-function hexToNpub(hexPubkey) {
-  const hrp = "npub";
-  const bytes = hexToBytes(hexPubkey);
-  const words = convertBits(bytes, 8, 5, true);
-  const checksum = bech32CreateChecksum(hrp, words);
-  const combined = words.concat(checksum);
-  return hrp + "1" + combined.map((d) => BECH32_CHARSET[d]).join("");
-}
-function npubToHex(npub) {
-  const lower = npub.toLowerCase();
-  if (lower !== npub && npub.toUpperCase() !== npub) {
-    throw new Error("npub: mixed case");
-  }
-  if (!lower.startsWith("npub1")) {
-    throw new Error("npub: invalid prefix");
-  }
-  if (lower.length !== 63) {
-    throw new Error("npub: invalid length");
-  }
-  const data = [];
-  for (let i = 5; i < lower.length; i++) {
-    const idx = BECH32_CHARSET.indexOf(lower[i]);
-    if (idx === -1) throw new Error("npub: invalid character");
-    data.push(idx);
-  }
-  const hrpExpanded = bech32HrpExpand("npub");
-  if (bech32Polymod(hrpExpanded.concat(data)) !== 1) {
-    throw new Error("npub: invalid checksum");
-  }
-  const words = data.slice(0, -6);
-  const bytes = convertBits(words, 5, 8, false);
-  if (bytes.length !== 32) {
-    throw new Error("npub: invalid data length");
-  }
-  const totalBits = words.length * 5;
-  const trailingBits = totalBits - bytes.length * 8;
-  if (trailingBits > 0) {
-    const lastWord = words[words.length - 1];
-    const mask = (1 << trailingBits) - 1;
-    if ((lastWord & mask) !== 0) {
-      throw new Error("npub: non-zero padding bits");
-    }
-  }
-  return bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-var HEX64_RE = /^[0-9a-f]{64}$/;
-function ownerToHex(owner) {
-  if (HEX64_RE.test(owner)) return owner;
-  if (owner.startsWith("npub1")) {
-    try {
-      return npubToHex(owner);
-    } catch (err) {
-      throw new Error(
-        `invalid owner ${JSON.stringify(owner)}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  throw new Error(
-    `invalid owner ${JSON.stringify(owner)}: expected a 64-char lowercase hex pubkey or an npub1\u2026 string`
-  );
-}
-
-// 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(),
-    ...plan.estimate.skippedEmptyCount > 0 ? { skippedEmptyCount: plan.estimate.skippedEmptyCount } : {}
-  };
-}
-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 tipShas = new Set(updates.map((u) => u.localSha));
-  const planned = [];
-  const skippedEmptyObjects = [];
-  for (const stat of stats) {
-    const path = pathBySha.get(stat.sha);
-    const object = {
-      ...stat,
-      ...path ? { path } : {},
-      isRefTip: tipShas.has(stat.sha)
-    };
-    if (stat.sha === EMPTY_BLOB_SHA) skippedEmptyObjects.push(object);
-    else planned.push(object);
-  }
-  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 = objects.reduce(
-    (sum, o) => sum + uploadChargeFor(feeRates, o.size),
-    0n
-  );
-  const eventCount = 1 + (announceNeeded ? 1 : 0);
-  const eventFees = BigInt(eventCount) * feeRates.eventFee;
-  return {
-    repoId,
-    refUpdates,
-    newRefs,
-    headSymref,
-    objects,
-    skippedEmptyObjects,
-    knownShaToTxId,
-    announceNeeded,
-    announcement: {
-      name: options.announcement?.name ?? repoId,
-      description: options.announcement?.description ?? ""
-    },
-    estimate: {
-      objectCount: objects.length,
-      totalObjectBytes,
-      uploadFee,
-      eventCount,
-      eventFees,
-      totalFee: uploadFee + eventFees,
-      skippedEmptyCount: skippedEmptyObjects.length
-    }
-  };
-}
-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,
-        // #368: the path the blob was reached by drives its Content-Type; a
-        // non-blob object (no path) uploads as octet-stream.
-        ...object.path ? { path: object.path } : {}
-      });
-      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 {
-  MAX_OBJECT_SIZE,
-  hashGitObject,
-  createGitBlob,
-  createGitTree,
-  createGitCommit,
-  createGitTag,
-  GitError,
-  GitRepoReader,
-  DEFAULT_CONCURRENCY,
-  ObjectIntegrityError,
-  verifyObjectBody,
-  fetchTxBytes,
-  downloadGitObjects,
-  referencedShas,
-  walkClosure,
-  collectRepoObjects,
-  missingObjectsMessage,
-  ObjectWriteMismatchError,
-  isSafeRefname,
-  runGit,
-  writeGitObject,
-  writeGitObjects,
-  updateRef,
-  setHeadSymref,
-  hexToNpub,
-  npubToHex,
-  ownerToHex,
-  serializeFeeEstimate,
-  serializePushPlan,
-  serializeEventReceipt,
-  serializePushResult,
-  NonFastForwardError,
-  OversizeObjectsError,
-  planPush,
-  executePush
-};
-//# sourceMappingURL=chunk-TJPIE5X4.js.map