@toon-protocol/rig 4.5.0 → 4.7.0

package/dist/{chunk-S2BMLXAD.js → chunk-3IVO2MSZ.js}

@@ -1,15 +1,18 @@
 import {
   ARWEAVE_FETCH_TIMEOUT_MS,
   ARWEAVE_GATEWAYS,
+  MAINTAINERS_TAG,
+  MAX_ARWEAVE_TAGS_PER_EVENT,
   MissingIdentityError,
+  PAYOUT_TAG,
   authorizedStatusAuthors,
-  buildRepoAnnouncement,
   buildRepoRefs,
   defaultWebSocketFactory,
   isValidArweaveTxId,
+  parseMaintainers,
   queryRelay,
   resolveIdentity
-} from "./chunk-HMED76GU.js";
+} from "./chunk-S3KKQ4IC.js";
 import {
   defaultDaemonPort,
   standaloneForced,
@@ -65,6 +68,203 @@ function createGitTag(opts) {
   return hashGitObject("tag", Buffer.from(lines.join("\n"), "utf-8"));
 }
 
+// src/repo-announcement.ts
+import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+var RELAYS_TAG = "relays";
+var WEB_TAG = "web";
+var EARLIEST_UNIQUE_COMMIT_MARKER = "euc";
+function multiValueTag(name, values2) {
+  const kept = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values2) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    kept.push(trimmed);
+  }
+  return kept.length > 0 ? [[name, ...kept]] : [];
+}
+var named = (name) => (tag) => tag[0] === name;
+var SLOTS = /* @__PURE__ */ new Map([
+  ["d", { matches: named("d"), rewrite: (e) => [["d", e.repoId]] }],
+  [
+    "name",
+    {
+      matches: named("name"),
+      rewrite: (e) => e.name === void 0 ? null : [["name", e.name]]
+    }
+  ],
+  [
+    "description",
+    {
+      matches: named("description"),
+      rewrite: (e) => e.description === void 0 ? null : [["description", e.description]]
+    }
+  ],
+  [
+    "maintainers",
+    {
+      matches: named(MAINTAINERS_TAG),
+      rewrite: (e) => {
+        if (e.maintainers === void 0) return null;
+        const declared = parseMaintainers([
+          [MAINTAINERS_TAG, ...e.maintainers]
+        ]);
+        return declared.length > 0 ? [[MAINTAINERS_TAG, ...declared]] : [];
+      }
+    }
+  ],
+  [
+    "payout",
+    {
+      matches: named(PAYOUT_TAG),
+      rewrite: (e) => e.payout === void 0 ? null : e.payout ? [[PAYOUT_TAG, e.payout.chain, e.payout.address]] : []
+    }
+  ],
+  [
+    "relays",
+    {
+      matches: named(RELAYS_TAG),
+      rewrite: (e) => e.relays === void 0 ? null : e.relays ? multiValueTag(RELAYS_TAG, e.relays) : []
+    }
+  ],
+  [
+    "web",
+    {
+      matches: named(WEB_TAG),
+      rewrite: (e) => e.web === void 0 ? null : e.web ? multiValueTag(WEB_TAG, e.web) : []
+    }
+  ],
+  [
+    "euc",
+    {
+      // Only the euc marker is ours. Every other `r` tag is someone else's.
+      matches: (tag) => tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER,
+      rewrite: (e) => e.earliestUniqueCommit === void 0 ? null : e.earliestUniqueCommit ? [["r", e.earliestUniqueCommit, EARLIEST_UNIQUE_COMMIT_MARKER]] : []
+    }
+  ]
+]);
+function slotOf(tag) {
+  for (const [slot, spec] of SLOTS) {
+    if (spec.matches(tag)) return slot;
+  }
+  return null;
+}
+function rewrittenSlots(edits) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [slot, spec] of SLOTS) {
+    const next = spec.rewrite(edits);
+    if (next !== null) out.set(slot, next);
+  }
+  return out;
+}
+function amendRepoAnnouncement(current, edits) {
+  const rewritten = rewrittenSlots(edits);
+  const tags = [["d", edits.repoId]];
+  const emitted = /* @__PURE__ */ new Set(["d"]);
+  for (const tag of current?.tags ?? []) {
+    const slot = slotOf(tag);
+    const replacement = slot === null ? void 0 : rewritten.get(slot);
+    if (slot === null || replacement === void 0) {
+      tags.push([...tag]);
+      continue;
+    }
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  for (const [slot, replacement] of rewritten) {
+    if (emitted.has(slot)) continue;
+    for (const next of replacement) tags.push([...next]);
+    emitted.add(slot);
+  }
+  return {
+    kind: REPOSITORY_ANNOUNCEMENT_KIND,
+    content: current?.content ?? "",
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildRepoAnnouncement(repoId, name, description, maintainers = [], payout) {
+  return amendRepoAnnouncement(null, {
+    repoId,
+    name,
+    description,
+    maintainers,
+    payout: payout ?? null
+  });
+}
+async function earliestUniqueCommit(reader) {
+  const all = await reader.rootCommits();
+  if (all.length === 0) return null;
+  if (all.length === 1) return all[0] ?? null;
+  const onDefaultBranch = await reader.rootCommits("HEAD");
+  const candidates = onDefaultBranch.length > 0 ? onDefaultBranch : all;
+  return [...candidates].sort()[0] ?? null;
+}
+function announcedEuc(current) {
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === "r" && tag[2] === EARLIEST_UNIQUE_COMMIT_MARKER) {
+      const sha = tag[1];
+      if (sha !== void 0 && sha.length > 0) return sha;
+    }
+  }
+  return null;
+}
+function unionValues(current, name, additions) {
+  const existing = [];
+  for (const tag of current?.tags ?? []) {
+    if (tag[0] === name) existing.push(...tag.slice(1));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of [...existing, ...additions]) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+function conformanceEdits(current, facts) {
+  const edits = {};
+  const relays = unionValues(current, RELAYS_TAG, facts.relays);
+  if (relays.length > 0) edits.relays = relays;
+  const web = unionValues(current, WEB_TAG, facts.web === null ? [] : [facts.web]);
+  if (web.length > 0) edits.web = web;
+  if (announcedEuc(current) === null && facts.earliestUniqueCommit !== null) {
+    edits.earliestUniqueCommit = facts.earliestUniqueCommit;
+  }
+  return edits;
+}
+function tagKey(tag) {
+  return JSON.stringify(tag);
+}
+function diffAnnouncementTags(current, next) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const tag of current?.tags ?? []) {
+    remaining.set(tagKey(tag), (remaining.get(tagKey(tag)) ?? 0) + 1);
+  }
+  const added = [];
+  for (const tag of next.tags) {
+    const key = tagKey(tag);
+    const count = remaining.get(key) ?? 0;
+    if (count > 0) remaining.set(key, count - 1);
+    else added.push([...tag]);
+  }
+  const removed = [];
+  for (const [key, count] of remaining) {
+    for (let i = 0; i < count; i += 1) {
+      removed.push(JSON.parse(key));
+    }
+  }
+  return {
+    added,
+    removed,
+    unchanged: added.length === 0 && removed.length === 0
+  };
+}
+
 // src/repo-reader.ts
 import { execFile, spawn } from "child_process";
 import { promisify } from "util";
@@ -261,6 +461,140 @@ var GitRepoReader = class {
     }
     return objects;
   }
+  /**
+   * Run git and hand each stdout line to `visit` as it arrives, never holding
+   * the whole output in memory. Returning `false` from `visit` ends the walk:
+   * the child is killed and the promise resolves with what was seen.
+   *
+   * Every other git call here buffers into one `execFile` string, which is
+   * fine for bounded output. These object walks are not bounded — they grow
+   * with the size of the repository — so on a repo big enough to need the
+   * object-map cap they would be the thing that breaks (#162).
+   */
+  streamLines(args, visit) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd: this.repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let pending = "";
+      let stderr = "";
+      let settled = false;
+      const finish = (err) => {
+        if (settled) return;
+        settled = true;
+        if (err) reject(err);
+        else resolve();
+      };
+      child.stdout.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        if (settled) return;
+        pending += chunk;
+        let idx = pending.indexOf("\n");
+        while (idx !== -1) {
+          const line = pending.slice(0, idx);
+          pending = pending.slice(idx + 1);
+          if (line && !visit(line)) {
+            child.kill("SIGTERM");
+            return finish();
+          }
+          idx = pending.indexOf("\n");
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        finish(
+          new GitError(
+            `failed to spawn git ${args[0]}: ${err.message}`,
+            void 0,
+            ""
+          )
+        );
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        if (code !== 0) {
+          return finish(
+            new GitError(
+              `git ${args[0]} failed (exit ${code}): ${stderr.trim()}`,
+              code ?? void 0,
+              stderr.trim()
+            )
+          );
+        }
+        if (pending) visit(pending);
+        finish();
+      });
+    });
+  }
+  /**
+   * Every object SHA in the local object database, in no particular order
+   * (`git cat-file --batch-all-objects --batch-check`, no bodies read).
+   *
+   * This is the honest answer to "what does this repository already have",
+   * which `rig fetch` needs to compute its delta. It deliberately does NOT
+   * consult the remote's kind:30618 `arweave` map: that map is capped (#162)
+   * and is a hint cache, never an index of local presence.
+   *
+   * Streamed, so the listing never has to fit in one buffer.
+   */
+  async listAllObjectShas() {
+    const shas = [];
+    await this.streamLines(
+      [
+        "cat-file",
+        "--batch-check=%(objectname)",
+        "--batch-all-objects",
+        "--unordered"
+      ],
+      (line) => {
+        shas.push(line);
+        return true;
+      }
+    );
+    return shas;
+  }
+  /**
+   * SHAs of every object reachable from `tips`, newest first: commits in
+   * reverse-chronological order, each commit immediately followed by the
+   * trees and blobs it is the first to reference
+   * (`git rev-list --objects --in-commit-order`).
+   *
+   * Used to rank the kind:30618 object map when it exceeds
+   * `MAX_ARWEAVE_TAGS_PER_EVENT` (#162): the entries most likely to be wanted
+   * by the next clone or fetch are the ones nearest the tips. Tips that do
+   * not resolve locally (a remote ref we never fetched) are dropped rather
+   * than failing the walk.
+   *
+   * `limit` stops the walk once that many SHAs have been seen — the ranking
+   * caller never needs more than the cap, and a full walk of a repository big
+   * enough to hit the cap is exactly the work worth not doing. The walk is
+   * streamed, so neither its output nor this array is ever bigger than that.
+   */
+  async reachableObjectsNewestFirst(tips, limit = Infinity) {
+    for (const tip of tips) assertRevision(tip, "tip");
+    const known = await this.filterExisting([...new Set(tips)]);
+    if (known.length === 0 || limit < 1) return [];
+    const shas = [];
+    await this.streamLines(
+      [
+        "rev-list",
+        "--objects",
+        "--in-commit-order",
+        ...known,
+        "--"
+        // nothing user-supplied can become a pathspec
+      ],
+      (line) => {
+        const spaceIdx = line.indexOf(" ");
+        shas.push(spaceIdx === -1 ? line : line.slice(0, spaceIdx));
+        return shas.length < limit;
+      }
+    );
+    return shas;
+  }
   /**
    * 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).
@@ -485,6 +819,46 @@ var GitRepoReader = class {
     }
     return parents;
   }
+  /**
+   * SHAs of the repo's ROOT commits — the parentless commits a history starts
+   * from — via `git rev-list --max-parents=0`.
+   *
+   * The repo's *earliest unique commit* (NIP-34's `euc` fork-identity tag) is
+   * chosen from these; the choosing rule lives in `repo-announcement.ts`.
+   *
+   * @param rev - Consider only roots reachable from this revision. Omit for
+   *   every root in the repository (`--all`).
+   * @returns The roots in `rev-list` order, or `[]` when the revision does not
+   *   resolve — an unborn `HEAD` in a repo with no commits is not an error.
+   */
+  async rootCommits(rev) {
+    const args = ["rev-list", "--max-parents=0"];
+    if (rev === void 0) {
+      args.push("--all");
+    } else {
+      assertRevision(rev, "rev");
+      args.push(rev);
+    }
+    args.push("--");
+    const { stdout, exitCode } = await this.git(args, {
+      allowExitCodes: [128]
+    });
+    if (exitCode !== 0) return [];
+    const roots = [];
+    for (const line of stdout.split("\n")) {
+      const sha = line.trim();
+      if (!sha) continue;
+      if (!FULL_SHA_RE.test(sha)) {
+        throw new GitError(
+          `unexpected rev-list --max-parents=0 line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      roots.push(sha);
+    }
+    return roots;
+  }
   /**
    * Resolve a ref/revision to a full SHA via `git rev-parse --verify`.
    * Throws {@link GitError} when the name doesn't resolve.
@@ -1140,6 +1514,7 @@ async function planPush(options) {
     if (refname !== headSymref) newRefs[refname] = sha;
   }
   const announceNeeded = !remoteState.announced;
+  const euc = announceNeeded ? await earliestUniqueCommit(repoReader) : null;
   const totalObjectBytes = objects.reduce((sum, o) => sum + o.size, 0);
   const uploadFee = objects.reduce(
     (sum, o) => sum + uploadChargeFor(feeRates, o.size),
@@ -1158,7 +1533,9 @@ async function planPush(options) {
     announceNeeded,
     announcement: {
       name: options.announcement?.name ?? repoId,
-      description: options.announcement?.description ?? ""
+      description: options.announcement?.description ?? "",
+      ...options.announcement?.web ? { web: options.announcement.web } : {},
+      ...euc ? { earliestUniqueCommit: euc } : {}
     },
     estimate: {
       objectCount: objects.length,
@@ -1172,6 +1549,32 @@ async function planPush(options) {
   };
 }
 var READ_BATCH_SIZE = 100;
+async function boundObjectMap(merged, plan, repoReader) {
+  if (merged.size <= MAX_ARWEAVE_TAGS_PER_EVENT) return merged;
+  const kept = /* @__PURE__ */ new Map();
+  const take = (sha) => {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT || kept.has(sha)) return;
+    const txId = merged.get(sha);
+    if (txId !== void 0) kept.set(sha, txId);
+  };
+  for (const object of plan.objects) take(object.sha);
+  if (kept.size < MAX_ARWEAVE_TAGS_PER_EVENT) {
+    const tips = [...new Set(Object.values(plan.newRefs))];
+    const reachable = await repoReader.reachableObjectsNewestFirst(
+      tips,
+      MAX_ARWEAVE_TAGS_PER_EVENT
+    );
+    for (const sha of reachable) {
+      if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+      take(sha);
+    }
+  }
+  for (const [sha, txId] of merged) {
+    if (kept.size >= MAX_ARWEAVE_TAGS_PER_EVENT) break;
+    if (!kept.has(sha)) kept.set(sha, txId);
+  }
+  return kept;
+}
 async function executePush(options) {
   const { plan, publisher, remoteState, repoReader, relayUrls } = options;
   const merged = new Map([...remoteState.shaToTxId, ...plan.knownShaToTxId]);
@@ -1230,18 +1633,22 @@ async function executePush(options) {
   }
   let announceReceipt = null;
   if (plan.announceNeeded && !remoteState.announced) {
-    const announceEvent = buildRepoAnnouncement(
-      plan.repoId,
-      plan.announcement.name,
-      plan.announcement.description
-    );
+    const announceEvent = amendRepoAnnouncement(null, {
+      repoId: plan.repoId,
+      name: plan.announcement.name,
+      description: plan.announcement.description,
+      relays: relayUrls,
+      ...plan.announcement.web ? { web: [plan.announcement.web] } : {},
+      ...plan.announcement.earliestUniqueCommit ? { earliestUniqueCommit: plan.announcement.earliestUniqueCommit } : {}
+    });
     announceReceipt = await publisher.publishEvent(announceEvent, relayUrls);
     totalFeePaid += announceReceipt.feePaid;
   }
+  const published = await boundObjectMap(merged, plan, repoReader);
   const refsEvent = buildRepoRefs(
     plan.repoId,
     plan.newRefs,
-    Object.fromEntries(merged)
+    Object.fromEntries(published)
   );
   const refsReceipt = await publisher.publishEvent(refsEvent, relayUrls);
   totalFeePaid += refsReceipt.feePaid;
@@ -1256,7 +1663,7 @@ async function executePush(options) {
     uploads,
     announceReceipt,
     refsReceipt,
-    arweaveMap: merged,
+    arweaveMap: published,
     totalFeePaid
   };
 }
@@ -1270,10 +1677,16 @@ var CI_MANUAL_TRIGGER_KIND = 9840;
 var CI_JOB_RESULT_KIND = 9841;
 var CI_WORKFLOW_RESULT_KIND = 9842;
 var CI_WORKFLOW_PROGRESS_KIND = 39842;
+var CI_LIVE_LOG_TAIL_KIND = 39841;
 var CI_RUNNER_FAMILY = "act";
 var CI_SOFTWARE = "rig";
 var CI_MAX_ADVERTISEMENT_TTL = 30 * 60;
 var CI_MAX_PROGRESS_TTL = 30 * 60;
+var CI_MAX_LIVE_LOG_TAIL_TTL = 30 * 60;
+var CI_LIVE_LOG_TAIL_INTERVAL_MS = 1e4;
+var CI_LIVE_LOG_TAIL_JOB_BYTES = 16 * 1024;
+var CI_LIVE_LOG_TAIL_MAX_BYTES = 64 * 1024;
+var CI_RUNNER_CHANNEL_KEY = "~runner";
 var REPO_ANNOUNCEMENT_KIND = 30617;
 var CONCLUSIONS = /* @__PURE__ */ new Set([
   "success",
@@ -2005,6 +2418,138 @@ function parseCiWorkflowProgress(ev) {
   if (provenance) result.provenance = provenance;
   return result;
 }
+function liveLogTailBudget(entries) {
+  if (!Number.isFinite(entries) || entries <= 1) {
+    return CI_LIVE_LOG_TAIL_JOB_BYTES;
+  }
+  const share = Math.floor(CI_LIVE_LOG_TAIL_MAX_BYTES / entries);
+  return Math.max(1, Math.min(CI_LIVE_LOG_TAIL_JOB_BYTES, share));
+}
+function liveLogTailEventBudget(runTimeoutMs) {
+  if (!Number.isFinite(runTimeoutMs) || runTimeoutMs <= 0) return 1;
+  return Math.ceil(runTimeoutMs / CI_LIVE_LOG_TAIL_INTERVAL_MS) + 1;
+}
+function sliceLogTail(text, maxBytes) {
+  const bytes = Buffer.from(text, "utf8");
+  if (bytes.length <= maxBytes) return { tail: text, omitted: 0 };
+  if (maxBytes <= 0) return { tail: "", omitted: bytes.length };
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start] & 192) === 128) {
+    start += 1;
+  }
+  return { tail: bytes.subarray(start).toString("utf8"), omitted: start };
+}
+function assertOmitted(omitted, what) {
+  if (!Number.isSafeInteger(omitted) || omitted < 0) {
+    throw new Error(`${what}: omitted must be a non-negative byte count`);
+  }
+}
+function buildCiLiveLogTail(input, createdAt = now()) {
+  if (input.runId === "") throw new Error("a live log tail needs a run id");
+  assertExpiration(createdAt, input.expiresAt, CI_MAX_LIVE_LOG_TAIL_TTL);
+  const seen = /* @__PURE__ */ new Set();
+  for (const job of input.jobs) {
+    if (job.job === "") throw new Error("a live log tail job needs a job id");
+    if (job.job === CI_RUNNER_CHANNEL_KEY) {
+      throw new Error(
+        `the runner channel is not a job: ${CI_RUNNER_CHANNEL_KEY} may not appear in jobs`
+      );
+    }
+    if (seen.has(job.job)) {
+      throw new Error(`job ${job.job} appears twice in one live log tail`);
+    }
+    seen.add(job.job);
+    assertOmitted(job.omitted, `job ${job.job}`);
+  }
+  if (input.runner) assertOmitted(input.runner.omitted, "runner channel");
+  const content = {
+    jobs: input.jobs.map((j) => ({
+      job: j.job,
+      tail: j.tail,
+      omitted: j.omitted
+    }))
+  };
+  if (input.runner) {
+    content.runner = {
+      tail: input.runner.tail,
+      omitted: input.runner.omitted
+    };
+  }
+  return {
+    kind: CI_LIVE_LOG_TAIL_KIND,
+    content: JSON.stringify(content),
+    tags: [
+      ...commonTriggerTags(input.trigger),
+      ["d", input.runId],
+      ["expiration", String(input.expiresAt)]
+    ],
+    created_at: createdAt
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOmitted(value) {
+  if (value === void 0) return 0;
+  if (!Number.isSafeInteger(value) || value < 0) return null;
+  return value;
+}
+function parseTailChannel(value) {
+  if (!isRecord(value)) return null;
+  const omitted = parseOmitted(value["omitted"]);
+  const tail = value["tail"];
+  if (typeof tail !== "string" || omitted === null) return null;
+  return { tail, omitted };
+}
+function parseCiLiveLogTail(ev) {
+  if (ev.kind !== CI_LIVE_LOG_TAIL_KIND) return null;
+  const { tags } = ev;
+  const trigger = parseCiTriggerContext(tags);
+  if (!trigger) return null;
+  const d = single(tags, "d");
+  const exp = single(tags, "expiration");
+  if (!d || !d[1] || !exp) return null;
+  const expiresAt = Number(exp[1]);
+  if (!Number.isInteger(expiresAt) || expiresAt <= ev.created_at || expiresAt - ev.created_at > CI_MAX_LIVE_LOG_TAIL_TTL) {
+    return null;
+  }
+  let content;
+  try {
+    content = JSON.parse(ev.content);
+  } catch {
+    return null;
+  }
+  if (!isRecord(content) || !Array.isArray(content["jobs"])) return null;
+  const jobs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of content["jobs"]) {
+    if (!isRecord(entry)) return null;
+    const job = entry["job"];
+    if (typeof job !== "string" || job === "") return null;
+    if (job === CI_RUNNER_CHANNEL_KEY || seen.has(job)) return null;
+    const channel = parseTailChannel(entry);
+    if (!channel) return null;
+    seen.add(job);
+    jobs.push({ job, tail: channel.tail, omitted: channel.omitted });
+  }
+  let runner;
+  if (content["runner"] !== void 0) {
+    const parsed = parseTailChannel(content["runner"]);
+    if (!parsed) return null;
+    runner = parsed;
+  }
+  const result = {
+    eventId: ev.id,
+    pubkey: ev.pubkey.toLowerCase(),
+    createdAt: ev.created_at,
+    trigger,
+    runId: d[1],
+    jobs,
+    expiresAt
+  };
+  if (runner) result.runner = runner;
+  return result;
+}
 
 // src/ci/secrets.ts
 import { v2 as nip44 } from "nostr-tools/nip44";
@@ -2244,7 +2789,7 @@ var WORKFLOW_FILE_RE = /\.ya?ml$/i;
 function sha256Hex(bytes) {
   return createHash2("sha256").update(bytes).digest("hex");
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringList(value) {
@@ -2255,7 +2800,7 @@ function stringList(value) {
   return void 0;
 }
 function refFilters(value) {
-  if (!isRecord(value)) return {};
+  if (!isRecord2(value)) return {};
   const out = {};
   const branches = stringList(value["branches"]);
   const tags = stringList(value["tags"]);
@@ -2273,17 +2818,17 @@ function parseTriggers(on) {
   };
   if (typeof on === "string") enable(on, void 0);
   else if (Array.isArray(on)) for (const name of on) enable(name, void 0);
-  else if (isRecord(on)) {
+  else if (isRecord2(on)) {
     for (const [name, options] of Object.entries(on)) enable(name, options);
   }
   return triggers;
 }
 function parseJobs(jobs) {
-  if (!isRecord(jobs)) return [];
+  if (!isRecord2(jobs)) return [];
   const out = [];
   for (const [id, spec] of Object.entries(jobs)) {
     const job = { id };
-    if (isRecord(spec)) {
+    if (isRecord2(spec)) {
       if (typeof spec["name"] === "string") job.name = spec["name"];
       const runsOn = stringList(spec["runs-on"]);
       if (runsOn) job.runsOn = runsOn;
@@ -2309,7 +2854,7 @@ function parseWorkflow(path, content) {
       parseError: err instanceof Error ? err.message : String(err)
     };
   }
-  if (!isRecord(doc)) {
+  if (!isRecord2(doc)) {
     return { ...base, parseError: "workflow is not a YAML mapping" };
   }
   const on = doc["on"] ?? doc["true"];
@@ -2886,7 +3431,7 @@ function emitCliError(io, json, command, err) {
 
 // src/cli/ci-status.ts
 import { parseArgs as parseArgs2 } from "util";
-import { REPOSITORY_ANNOUNCEMENT_KIND } from "@toon-protocol/core/nip34";
+import { REPOSITORY_ANNOUNCEMENT_KIND as REPOSITORY_ANNOUNCEMENT_KIND2 } from "@toon-protocol/core/nip34";
 
 // src/cli/git-config.ts
 import { execFile as execFile3 } from "child_process";
@@ -3541,7 +4086,7 @@ async function runCiStatus(args, deps) {
           "#a": [repoAddr]
         },
         {
-          kinds: [REPOSITORY_ANNOUNCEMENT_KIND],
+          kinds: [REPOSITORY_ANNOUNCEMENT_KIND2],
           authors: [owner],
           "#d": [repoId]
         }
@@ -3550,7 +4095,7 @@ async function runCiStatus(args, deps) {
     );
     let announce = null;
     for (const ev of events) {
-      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND || ev.pubkey.toLowerCase() !== owner)
+      if (ev.kind !== REPOSITORY_ANNOUNCEMENT_KIND2 || ev.pubkey.toLowerCase() !== owner)
         continue;
       if (!ev.tags.some((t) => t[0] === "d" && t[1] === repoId)) continue;
       if (announce === null || ev.created_at > announce.created_at || ev.created_at === announce.created_at && ev.id < announce.id) {
@@ -3646,6 +4191,14 @@ export {
   createGitTree,
   createGitCommit,
   createGitTag,
+  RELAYS_TAG,
+  WEB_TAG,
+  EARLIEST_UNIQUE_COMMIT_MARKER,
+  amendRepoAnnouncement,
+  buildRepoAnnouncement,
+  earliestUniqueCommit,
+  conformanceEdits,
+  diffAnnouncementTags,
   GitError,
   GitRepoReader,
   DEFAULT_CONCURRENCY,
@@ -3683,10 +4236,16 @@ export {
   CI_JOB_RESULT_KIND,
   CI_WORKFLOW_RESULT_KIND,
   CI_WORKFLOW_PROGRESS_KIND,
+  CI_LIVE_LOG_TAIL_KIND,
   CI_RUNNER_FAMILY,
   CI_SOFTWARE,
   CI_MAX_ADVERTISEMENT_TTL,
   CI_MAX_PROGRESS_TTL,
+  CI_MAX_LIVE_LOG_TAIL_TTL,
+  CI_LIVE_LOG_TAIL_INTERVAL_MS,
+  CI_LIVE_LOG_TAIL_JOB_BYTES,
+  CI_LIVE_LOG_TAIL_MAX_BYTES,
+  CI_RUNNER_CHANNEL_KEY,
   isCiConclusion,
   repoAddress,
   parseRepoAddress,
@@ -3709,6 +4268,11 @@ export {
   parseCiWorkflowResult,
   buildCiWorkflowProgress,
   parseCiWorkflowProgress,
+  liveLogTailBudget,
+  liveLogTailEventBudget,
+  sliceLogTail,
+  buildCiLiveLogTail,
+  parseCiLiveLogTail,
   SECRET_NAME_RE,
   RESERVED_SECRET_NAMES,
   MAX_SECRET_NAMES,
@@ -3759,4 +4323,4 @@ export {
   assembleCiStatus,
   runCiStatus
 };
-//# sourceMappingURL=chunk-S2BMLXAD.js.map
+//# sourceMappingURL=chunk-3IVO2MSZ.js.map