@toon-protocol/rig 2.1.0 → 2.3.0

package/dist/{chunk-LFGDLD6J.js → chunk-W2SDL2PE.js}

@@ -1,9 +1,13 @@
 import {
+  ARWEAVE_FETCH_TIMEOUT_MS,
+  ARWEAVE_GATEWAYS,
   buildRepoAnnouncement,
-  buildRepoRefs
-} from "./chunk-HPSOQP7Q.js";
+  buildRepoRefs,
+  isValidArweaveTxId
+} from "./chunk-3HRFDH7H.js";
 import {
-  MAX_OBJECT_SIZE
+  MAX_OBJECT_SIZE,
+  hashGitObject
 } from "./chunk-X2CZPPDM.js";
 
 // src/repo-reader.ts
@@ -409,6 +413,443 @@ var GitRepoReader = class {
   }
 };
 
+// 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;
+  }
+  const 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 {
@@ -695,6 +1136,25 @@ async function executePush(options) {
 export {
   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,
@@ -704,4 +1164,4 @@ export {
   planPush,
   executePush
 };
-//# sourceMappingURL=chunk-LFGDLD6J.js.map
+//# sourceMappingURL=chunk-W2SDL2PE.js.map