@umbra-privacy/ceremony 0.1.0

package/dist/index.js

@@ -0,0 +1,1125 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { render } from "ink";
+
+// src/components/App.tsx
+import { useEffect as useEffect4, useState as useState4 } from "react";
+import { Box as Box6, Text as Text6, useApp, useInput as useInput2 } from "ink";
+
+// src/cleanup.ts
+var pendingLeaveQueue = null;
+function setQueueCleanup(fn) {
+  pendingLeaveQueue = fn;
+}
+function clearQueueCleanup() {
+  pendingLeaveQueue = null;
+}
+async function runQueueCleanup() {
+  if (!pendingLeaveQueue) return;
+  pendingLeaveQueue();
+  pendingLeaveQueue = null;
+  await new Promise((resolve) => setTimeout(resolve, 800));
+}
+
+// src/session.ts
+import { readFile as readFile2, unlink as unlink2, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/api.ts
+import { createHash } from "crypto";
+import { createWriteStream } from "fs";
+import { readFile, unlink } from "fs/promises";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+var DEFAULT_API_URL = "http://ceremony.api.umbraprivacy.com";
+var BASE = (process.env["CEREMONY_API_URL"] ?? DEFAULT_API_URL).replace(/\/$/, "");
+async function request(path, options = {}) {
+  const res = await fetch(`${BASE}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    const code = body?.error?.code ?? "UNKNOWN";
+    const message = body?.error?.message ?? `HTTP ${res.status}`;
+    throw Object.assign(new Error(message), { code, status: res.status });
+  }
+  return body;
+}
+function bearer(token) {
+  return { Authorization: `Bearer ${token}` };
+}
+var api = {
+  // Sessions
+  createSession(displayName2) {
+    return request("/api/sessions", {
+      method: "POST",
+      body: JSON.stringify({ display_name: displayName2 })
+    });
+  },
+  // Ceremonies
+  listCeremonies() {
+    return request("/api/ceremonies");
+  },
+  getCeremonyStatus(ceremonyId2) {
+    return request(`/api/ceremonies/${ceremonyId2}/status`);
+  },
+  // Tracks
+  listTracks(ceremonyId2, token) {
+    return request(`/api/ceremonies/${ceremonyId2}/tracks`, {
+      headers: bearer(token)
+    });
+  },
+  // Queue
+  joinQueue(ceremonyId2, trackId, token) {
+    return request(`/api/ceremonies/${ceremonyId2}/tracks/${trackId}/queue`, {
+      method: "POST",
+      headers: bearer(token)
+    });
+  },
+  leaveQueue(ceremonyId2, trackId, token) {
+    return request(`/api/ceremonies/${ceremonyId2}/tracks/${trackId}/queue`, {
+      method: "DELETE",
+      headers: bearer(token)
+    });
+  },
+  // Slot polling
+  myTurn(ceremonyId2, trackId, token) {
+    return request(
+      `/api/ceremonies/${ceremonyId2}/tracks/${trackId}/my-turn`,
+      { headers: bearer(token) }
+    );
+  },
+  // Contribution
+  signalUploaded(ceremonyId2, trackId, contributionId, token) {
+    return request(
+      `/api/ceremonies/${ceremonyId2}/tracks/${trackId}/signal-uploaded`,
+      {
+        method: "POST",
+        headers: bearer(token),
+        body: JSON.stringify({ contribution_id: contributionId })
+      }
+    );
+  },
+  getReceipt(ceremonyId2, contributionId) {
+    return request(
+      `/api/ceremonies/${ceremonyId2}/contributions/${contributionId}/receipt`
+    );
+  },
+  // Admin
+  adminDashboard(ceremonyId2, adminKey) {
+    return request(`/api/admin/ceremonies/${ceremonyId2}/dashboard`, {
+      headers: { "X-Admin-Key": adminKey }
+    });
+  }
+};
+var ChallengeIntegrityError = class extends Error {
+  name = "ChallengeIntegrityError";
+};
+var SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+async function downloadFile(presignedUrl, destPath, onProgress, expectedSha256) {
+  let expected = null;
+  if (expectedSha256 !== void 0 && expectedSha256 !== null) {
+    const candidate = expectedSha256.toLowerCase();
+    if (!SHA256_HEX_RE.test(candidate)) {
+      throw new ChallengeIntegrityError(
+        `server sent malformed challenge_sha256 (${JSON.stringify(expectedSha256)})`
+      );
+    }
+    expected = candidate;
+  }
+  const res = await fetch(presignedUrl);
+  if (!res.ok) throw new Error(`S3 download failed: HTTP ${res.status}`);
+  const contentLength = res.headers.get("content-length");
+  const total = contentLength ? parseInt(contentLength, 10) : null;
+  const hasher = expected ? createHash("sha256") : null;
+  let received = 0;
+  const readable = Readable.fromWeb(res.body);
+  readable.on("data", (chunk) => {
+    received += chunk.length;
+    hasher?.update(chunk);
+    onProgress?.(received, total);
+  });
+  await pipeline(readable, createWriteStream(destPath));
+  if (hasher && expected) {
+    const actual = hasher.digest("hex");
+    if (actual !== expected) {
+      await unlink(destPath).catch(() => void 0);
+      throw new ChallengeIntegrityError(
+        `challenge sha256 mismatch (expected ${expected}, got ${actual})`
+      );
+    }
+  }
+}
+async function uploadFile(presignedUrl, filePath) {
+  const data = await readFile(filePath);
+  const res = await fetch(presignedUrl, {
+    method: "PUT",
+    body: data,
+    headers: { "Content-Type": "application/octet-stream" }
+  });
+  if (!res.ok) {
+    throw new Error(`S3 upload failed: HTTP ${res.status}`);
+  }
+}
+
+// src/session.ts
+var SESSION_FILE = process.env["CEREMONY_SESSION_FILE"] ?? join(homedir(), ".ceremony-session");
+async function loadOrCreateSession(displayName2) {
+  try {
+    const raw = await readFile2(SESSION_FILE, "utf8");
+    const session2 = JSON.parse(raw);
+    if (session2.session_token && session2.contributor_id) {
+      return session2;
+    }
+  } catch {
+  }
+  const response = await api.createSession(displayName2);
+  const session = {
+    session_token: response.session_token,
+    contributor_id: response.contributor_id
+  };
+  await writeFile(SESSION_FILE, JSON.stringify(session, null, 2), {
+    encoding: "utf8",
+    mode: 384
+  });
+  return session;
+}
+async function clearSession() {
+  await unlink2(SESSION_FILE).catch(() => void 0);
+}
+
+// src/store.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var STORE_FILE = process.env["CEREMONY_CONTRIBUTIONS_FILE"] ?? join2(homedir2(), ".ceremony-contributions.json");
+async function load() {
+  try {
+    const raw = await readFile3(STORE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function save(store) {
+  await writeFile2(STORE_FILE, JSON.stringify(store, null, 2), "utf8");
+}
+async function getContributions() {
+  return load();
+}
+async function recordContribution(trackId, contribution) {
+  const store = await load();
+  store[trackId] = contribution;
+  await save(store);
+}
+
+// src/components/Header.tsx
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var STATUS_COLOR = {
+  open: "green",
+  initialized: "yellow",
+  finalizing: "yellow",
+  completed: "cyan"
+};
+function Header({ ceremony, subtitle }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u25C6 CEREMONY TUI" }),
+      ceremony && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \xB7  " }),
+        /* @__PURE__ */ jsx(Text, { bold: true, children: ceremony.name }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  [" }),
+        /* @__PURE__ */ jsx(Text, { color: STATUS_COLOR[ceremony.status] ?? "white", children: ceremony.status }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "]" })
+      ] })
+    ] }),
+    ceremony && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      ceremony.total_tracks,
+      " circuit",
+      ceremony.total_tracks !== 1 ? "s" : "",
+      "  \xB7  ",
+      ceremony.total_contributions,
+      " total contribution",
+      ceremony.total_contributions !== 1 ? "s" : ""
+    ] }),
+    subtitle && /* @__PURE__ */ jsx(Text, { color: "cyan", dimColor: true, children: subtitle }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(56) })
+  ] });
+}
+
+// src/components/QueueView.tsx
+import { useEffect, useRef, useState } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var POLL_FAST_MS = 5e3;
+var POLL_SLOW_MS = 15e3;
+function QueueView({ ceremonyId: ceremonyId2, trackId, token, onReady, onError }) {
+  const [status, setStatus] = useState(null);
+  const [pollErr, setPollErr] = useState(null);
+  const [tick, setTick] = useState(0);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    const id = setInterval(() => setTick((t) => (t + 1) % 4), 500);
+    return () => clearInterval(id);
+  }, []);
+  useEffect(() => {
+    let cancelled = false;
+    async function poll() {
+      try {
+        const s = await api.myTurn(ceremonyId2, trackId, token);
+        if (cancelled) return;
+        setStatus(s);
+        setPollErr(null);
+        if (s.ready) {
+          onReady(s);
+          return;
+        }
+        const interval = s.queue_position <= 2 ? POLL_FAST_MS : POLL_SLOW_MS;
+        timeoutRef.current = setTimeout(poll, interval);
+      } catch (err) {
+        if (cancelled) return;
+        const msg = err instanceof Error ? err.message : String(err);
+        setPollErr(msg);
+        timeoutRef.current = setTimeout(poll, POLL_SLOW_MS);
+      }
+    }
+    poll();
+    return () => {
+      cancelled = true;
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, [ceremonyId2, trackId, token]);
+  const dots = ".".repeat(tick + 1).padEnd(4, " ");
+  if (!status) {
+    return /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Connecting",
+        dots
+      ] })
+    ] });
+  }
+  const waitMins = Math.ceil((status.estimated_wait_secs ?? 0) / 60);
+  const expiresAt = status.slot_expires_at ? new Date(status.slot_expires_at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : null;
+  const fastPoll = status.queue_position <= 2;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Position",
+        " ",
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "yellow", children: status.queue_position }),
+        status.queue_depth > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          " of ",
+          status.queue_depth
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\xB7" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Estimated wait:",
+        " ",
+        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
+          "~",
+          waitMins,
+          " min"
+        ] })
+      ] })
+    ] }),
+    status.status === "exporting" || status.status === "your_turn" || status.status === "ready_to_download" ? /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsx2(Text2, { color: "green", children: status.status === "exporting" ? "Preparing your challenge file \u2014 hang tight..." : "Challenge ready \u2014 loading contribution flow..." }) }) : status.active_since ? /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "Another contributor is active",
+      expiresAt ? ` \xB7 slot expires at ${expiresAt}` : ""
+    ] }) }) : status.queue_position > 1 ? (
+      // Slot is idle but people are ahead — they joined and left without releasing.
+      // timeout_watchdog will clear each stale slot after contribution_timeout_secs.
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Slot is idle \u2014 waiting for positions ahead to respond or time out",
+        " ",
+        "(up to ~5 min each)"
+      ] })
+    ) : (
+      // Position 1, slot idle — advance_queue should fire shortly.
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Slot is idle \u2014 your turn is being prepared..." })
+    ),
+    pollErr ? /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Poll error: ",
+      pollErr,
+      " \u2014 retrying",
+      dots
+    ] }) : /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "Checking every ",
+      fastPoll ? 5 : 15,
+      "s",
+      dots
+    ] })
+  ] });
+}
+
+// src/components/EntropyCollector.tsx
+import { useRef as useRef2, useState as useState2 } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+
+// src/entropy.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+function sha512(buf) {
+  return createHash2("sha512").update(buf).digest();
+}
+function buildEntropyFromKeystrokes(chars, timingsNs) {
+  const charBuf = Buffer.from(chars);
+  const timingBuf = Buffer.alloc(timingsNs.length * 8);
+  timingsNs.forEach((t, i) => timingBuf.writeBigUInt64BE(t, i * 8));
+  const keystrokeHash = sha512(Buffer.concat([charBuf, timingBuf]));
+  const osHash = sha512(randomBytes(64));
+  return createHash2("sha512").update(keystrokeHash).update(osHash).digest("hex");
+}
+
+// src/components/EntropyCollector.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var TARGET = 20;
+function EntropyCollector({ onComplete, onError }) {
+  const [count, setCount] = useState2(0);
+  const [done, setDone] = useState2(false);
+  const charsRef = useRef2([]);
+  const timingsRef = useRef2([]);
+  const lastRef = useRef2(process.hrtime.bigint());
+  const completedRef = useRef2(false);
+  useInput((input) => {
+    if (completedRef.current) return;
+    const now = process.hrtime.bigint();
+    timingsRef.current.push(now - lastRef.current);
+    lastRef.current = now;
+    for (const b of Buffer.from(input ?? "", "utf8")) charsRef.current.push(b);
+    const newCount = timingsRef.current.length;
+    setCount(newCount);
+    if (newCount >= TARGET) {
+      completedRef.current = true;
+      setDone(true);
+      try {
+        const entropy = buildEntropyFromKeystrokes(charsRef.current, timingsRef.current);
+        setTimeout(() => onComplete(entropy), 250);
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+  });
+  const filled = Math.round(count / TARGET * 24);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(24 - filled);
+  const pct = Math.round(count / TARGET * 100);
+  const stars = "*".repeat(Math.min(count, 32));
+  if (done) {
+    return /* @__PURE__ */ jsxs3(Box3, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713" }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "Entropy collected \u2014 [",
+        bar,
+        "] 100%"
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Type anything to generate entropy:" }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Keystroke timing (nanosecond intervals) is the randomness source." }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  > " }),
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: stars }),
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u2588" })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { gap: 2, marginTop: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+        "[",
+        bar,
+        "]"
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: count > 0 ? "green" : "yellow", children: count }),
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          "/",
+          TARGET,
+          " keystrokes  (",
+          pct,
+          "%)"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Shown as * \u2014 your actual input is never revealed." })
+  ] });
+}
+
+// src/components/ContributeFlow.tsx
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import Spinner2 from "ink-spinner";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+
+// src/contribute.ts
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { unlink as unlink3 } from "fs/promises";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var snarkjs = require2("snarkjs");
+async function runBellmanContribution(challengePath, entropy, contributorName = "anonymous") {
+  const responsePath = join3(tmpdir(), `ceremony-response-${Date.now()}.mpcparams`);
+  const curve = await snarkjs.curves.getCurveFromName("bn128");
+  try {
+    await snarkjs.zKey.bellmanContribute(curve, challengePath, responsePath, entropy);
+  } finally {
+    await curve.terminate();
+  }
+  return responsePath;
+}
+async function cleanupTemp(path) {
+  await unlink3(path).catch(() => void 0);
+}
+
+// src/components/ContributeFlow.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var STEP_LABELS = ["downloading", "computing", "uploading", "signalling", "verifying"];
+var STEP_INDEX = {
+  downloading: 0,
+  computing: 1,
+  uploading: 2,
+  signalling: 3,
+  verifying: 4
+};
+function ContributeFlow(props) {
+  const { ceremonyId: ceremonyId2, trackId, token, slotStatus, entropy, displayName: displayName2 } = props;
+  const [step, setStep] = useState3({ name: "downloading", bytesReceived: 0, total: null });
+  useEffect3(() => {
+    let cancelled = false;
+    const challengePath = join4(tmpdir2(), `ceremony-challenge-${Date.now()}.mpcparams`);
+    let responsePath = null;
+    async function run() {
+      try {
+        const DOWNLOAD_RETRIES = 3;
+        let downloadErr = null;
+        for (let attempt = 1; attempt <= DOWNLOAD_RETRIES; attempt++) {
+          if (attempt > 1) {
+            await cleanupTemp(challengePath).catch(() => void 0);
+            const delaySecs = attempt - 1;
+            if (!cancelled) setStep({ name: "downloading", bytesReceived: 0, total: null });
+            await new Promise((r) => setTimeout(r, delaySecs * 1e3));
+          }
+          try {
+            await downloadFile(
+              slotStatus.download_url,
+              challengePath,
+              (received, total) => {
+                if (!cancelled) setStep({ name: "downloading", bytesReceived: received, total });
+              },
+              slotStatus.challenge_sha256 ?? null
+            );
+            downloadErr = null;
+            break;
+          } catch (err) {
+            if (err instanceof ChallengeIntegrityError) throw err;
+            downloadErr = err instanceof Error ? err : new Error(String(err));
+            if (attempt === DOWNLOAD_RETRIES) throw downloadErr;
+          }
+        }
+        if (cancelled) return;
+        setStep({ name: "computing" });
+        responsePath = await runBellmanContribution(challengePath, entropy, displayName2);
+        await cleanupTemp(challengePath);
+        if (cancelled) return;
+        setStep({ name: "uploading" });
+        await uploadFile(slotStatus.upload_url, responsePath);
+        await cleanupTemp(responsePath);
+        responsePath = null;
+        if (cancelled) return;
+        setStep({ name: "signalling" });
+        await api.signalUploaded(ceremonyId2, trackId, slotStatus.contribution_id, token);
+        if (cancelled) return;
+        setStep({ name: "verifying", attempt: 1 });
+        let receipt = null;
+        let lastErr = null;
+        for (let i = 0; i < 30; i++) {
+          if (cancelled) return;
+          setStep({ name: "verifying", attempt: i + 1 });
+          try {
+            receipt = await api.getReceipt(ceremonyId2, slotStatus.contribution_id);
+            lastErr = null;
+            break;
+          } catch (err) {
+            lastErr = err instanceof Error ? err : new Error(String(err));
+            await new Promise((r) => setTimeout(r, 3e3));
+          }
+        }
+        if (cancelled) return;
+        if (!receipt && lastErr) {
+          props.onError(lastErr);
+          return;
+        }
+        await props.onComplete(slotStatus.contribution_id, receipt);
+      } catch (err) {
+        if (responsePath) await cleanupTemp(responsePath).catch(() => void 0);
+        await cleanupTemp(challengePath).catch(() => void 0);
+        if (!cancelled) props.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    run();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const currentIdx = STEP_INDEX[step.name] ?? 0;
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", gap: 1, children: STEP_LABELS.map((label, i) => {
+    const isDone = i < currentIdx;
+    const isActive = i === currentIdx;
+    const isPending = i > currentIdx;
+    let indicator;
+    if (isDone) indicator = /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u2713" });
+    else if (isActive) indicator = /* @__PURE__ */ jsx4(Spinner2, { type: "dots" });
+    else indicator = /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u25CB" });
+    let detail = null;
+    if (isActive && step.name === "downloading" && step.total) {
+      const pct = Math.round(step.bytesReceived / step.total * 100);
+      const filled = Math.round(pct / 5);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(20 - filled);
+      detail = /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "  [",
+        bar,
+        "] ",
+        pct,
+        "%"
+      ] });
+    }
+    if (isActive && step.name === "verifying") {
+      detail = /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "  worker verifying... (",
+        step.attempt,
+        "/30)"
+      ] });
+    }
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Box4, { gap: 2, children: [
+        indicator,
+        /* @__PURE__ */ jsxs4(
+          Text4,
+          {
+            color: isDone ? "green" : isActive ? "white" : void 0,
+            bold: isActive,
+            dimColor: isPending,
+            children: [
+              label.charAt(0).toUpperCase() + label.slice(1),
+              " ",
+              isActive && label === "computing" && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(entropy stays local)" }),
+              isActive && label === "uploading" && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(~544 bytes)" })
+            ]
+          }
+        )
+      ] }),
+      detail
+    ] }, label);
+  }) });
+}
+
+// src/components/Attestation.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function Attestation({ contribution }) {
+  const hashShort = contribution.contributionHash ? `${contribution.contributionHash.slice(0, 16)}...${contribution.contributionHash.slice(-8)}` : "(pending verification)";
+  const verifiedAt = contribution.verifiedAt ? new Date(contribution.verifiedAt).toLocaleString() : null;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "green", children: "\u2713  Contribution verified!" }),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Circuit" }),
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: contribution.circuitName })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Round  " }),
+        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+          "#",
+          contribution.sequenceNumber
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Hash   " }),
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: hashShort })
+      ] }),
+      verifiedAt && /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Time   " }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: verifiedAt })
+      ] })
+    ] }),
+    contribution.contributionHash && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Full hash (share this to prove participation):" }),
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", wrap: "wrap", children: contribution.contributionHash })
+    ] })
+  ] });
+}
+
+// src/components/App.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ ceremonyId: initialCeremonyId, displayName: displayName2 = "anonymous" }) {
+  const { exit } = useApp();
+  const [activeCeremonyId, setActiveCeremonyId] = useState4(initialCeremonyId);
+  const [screen, setScreen] = useState4(
+    initialCeremonyId ? { name: "loading" } : { name: "ceremony-picker", ceremonies: [], loading: true }
+  );
+  const [ceremony, setCeremony] = useState4(null);
+  const [session, setSession] = useState4(null);
+  const [contributed, setContributed] = useState4({});
+  const [selectedIdx, setSelectedIdx] = useState4(0);
+  const [tab, setTab] = useState4(0);
+  useEffect4(() => {
+    if (!initialCeremonyId) {
+      loadCeremonies();
+    } else {
+      boot(initialCeremonyId);
+    }
+  }, []);
+  async function loadCeremonies() {
+    try {
+      const { ceremonies } = await api.listCeremonies();
+      setScreen({ name: "ceremony-picker", ceremonies, loading: false });
+      setSelectedIdx(0);
+    } catch (e) {
+      setScreen({ name: "error", message: e.message ?? "Failed to load ceremonies.", recoverable: false });
+    }
+  }
+  async function boot(cId) {
+    try {
+      const [s, cs, contribs] = await Promise.all([
+        loadOrCreateSession(displayName2),
+        api.getCeremonyStatus(cId).catch(() => null),
+        getContributions()
+      ]);
+      setSession(s);
+      setCeremony(cs);
+      setContributed(contribs);
+      await loadTracks(s, cId);
+    } catch (e) {
+      setScreen({ name: "error", message: e.message, recoverable: false });
+    }
+  }
+  async function loadTracks(s, cId) {
+    try {
+      const { tracks } = await api.listTracks(cId, s.session_token);
+      if (tracks.length === 0) {
+        setScreen({ name: "error", message: "No tracks found in this ceremony.", recoverable: false });
+        return;
+      }
+      setScreen({ name: "tracks", tracks });
+    } catch (e) {
+      if (e.code === "INVALID_SESSION" || e.status === 401) {
+        try {
+          await clearSession();
+          const fresh = await loadOrCreateSession(displayName2);
+          setSession(fresh);
+          const { tracks } = await api.listTracks(cId, fresh.session_token);
+          if (tracks.length === 0) {
+            setScreen({ name: "error", message: "No tracks found in this ceremony.", recoverable: false });
+            return;
+          }
+          setScreen({ name: "tracks", tracks });
+        } catch (e2) {
+          setScreen({ name: "error", message: e2.message ?? "Failed to load tracks.", recoverable: false });
+        }
+        return;
+      }
+      setScreen({ name: "error", message: e.message ?? "Failed to load tracks.", recoverable: false });
+    }
+  }
+  async function joinTrack(track) {
+    if (!session) return;
+    setScreen({ name: "joining" });
+    try {
+      await api.joinQueue(activeCeremonyId, track.id, session.session_token);
+    } catch (e) {
+      if (e.code !== "ALREADY_IN_QUEUE") {
+        setScreen({ name: "error", message: e.message ?? "Failed to join queue.", recoverable: true });
+        return;
+      }
+    }
+    setScreen({ name: "queue", trackId: track.id, circuitName: track.circuit_name });
+  }
+  function goHome() {
+    if (!session) return;
+    setScreen({ name: "loading" });
+    loadTracks(session, activeCeremonyId);
+  }
+  function goCeremonyPicker() {
+    setScreen({ name: "ceremony-picker", ceremonies: [], loading: true });
+    loadCeremonies();
+  }
+  useEffect4(() => {
+    if (screen.name === "queue" && session) {
+      const { trackId } = screen;
+      setQueueCleanup(() => {
+        api.leaveQueue(activeCeremonyId, trackId, session.session_token).catch(() => {
+        });
+      });
+    } else {
+      clearQueueCleanup();
+    }
+  }, [screen.name]);
+  useInput2((input, key) => {
+    const q = input.toLowerCase();
+    if (q === "q" && screen.name !== "entropy") {
+      if (screen.name === "queue" && session) {
+        clearQueueCleanup();
+        api.leaveQueue(activeCeremonyId, screen.trackId, session.session_token).catch(() => {
+        });
+        setTimeout(() => exit(), 500);
+      } else {
+        exit();
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (!initialCeremonyId && (screen.name === "tracks" || screen.name === "error")) {
+        goCeremonyPicker();
+        return;
+      }
+      if (screen.name !== "tracks" && screen.name !== "loading" && screen.name !== "joining" && screen.name !== "entropy" && screen.name !== "ceremony-picker") {
+        goHome();
+      }
+      return;
+    }
+    if (screen.name === "ceremony-picker" && !screen.loading) {
+      const { ceremonies } = screen;
+      if (key.upArrow) {
+        setSelectedIdx((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setSelectedIdx((i) => Math.min(ceremonies.length - 1, i + 1));
+        return;
+      }
+      if (key.return) {
+        const c = ceremonies[selectedIdx];
+        if (!c || c.status !== "open") return;
+        setActiveCeremonyId(c.id);
+        setScreen({ name: "loading" });
+        boot(c.id);
+        return;
+      }
+      return;
+    }
+    if (screen.name === "tracks") {
+      const { tracks } = screen;
+      if (key.tab) {
+        setTab((t) => (t + 1) % 2);
+        return;
+      }
+      if (tab === 0) {
+        if (key.upArrow) {
+          setSelectedIdx((i) => Math.max(0, i - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIdx((i) => Math.min(tracks.length - 1, i + 1));
+          return;
+        }
+        if (key.return) {
+          const t = tracks[selectedIdx];
+          if (t && t.status === "open" && !contributed[t.id]) joinTrack(t);
+          return;
+        }
+      }
+      if (q === "r") {
+        goHome();
+        return;
+      }
+    }
+    if (q === "b" && (screen.name === "error" || screen.name === "done" || screen.name === "queue")) {
+      goHome();
+    }
+  });
+  if (screen.name === "ceremony-picker") {
+    const { ceremonies, loading } = screen;
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony: null }),
+      loading ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading ceremonies..." }) : ceremonies.length === 0 ? /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", gap: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "No ceremonies found." }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "The server may not have any active ceremonies yet." }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Q to quit" })
+      ] }) : /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Select a ceremony:" }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
+        ceremonies.map((c, i) => {
+          const isSelected = i === selectedIdx;
+          const isOpen = c.status === "open";
+          const statusColor = c.status === "open" ? "green" : c.status === "completed" ? "cyan" : "yellow";
+          return /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+            /* @__PURE__ */ jsxs6(Text6, { color: isSelected ? "cyan" : isOpen ? void 0 : "gray", children: [
+              isSelected ? "\u25B6 " : "  ",
+              c.name.padEnd(30)
+            ] }),
+            /* @__PURE__ */ jsxs6(Text6, { color: statusColor, children: [
+              "[",
+              c.status,
+              "]"
+            ] }),
+            /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+              c.track_count,
+              " track",
+              c.track_count !== 1 ? "s" : "",
+              " \xB7 ",
+              String(c.total_contributions),
+              " contribution",
+              Number(c.total_contributions) !== 1 ? "s" : ""
+            ] })
+          ] }, c.id);
+        }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
+        (() => {
+          const c = ceremonies[selectedIdx];
+          if (!c) return null;
+          if (c.status === "initialized") {
+            return /* @__PURE__ */ jsxs6(Text6, { color: "yellow", children: [
+              "  Not open yet \u2014 admin: run  initialize ",
+              "<id>",
+              "  then  open ",
+              "<id>",
+              "  to start contributions."
+            ] });
+          }
+          if (c.status === "finalizing") {
+            return /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "  Contribution phase is closed \u2014 ceremony is applying the final beacon." });
+          }
+          if (c.status === "completed") {
+            return /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "  Ceremony complete \u2014 verification keys are available." });
+          }
+          return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2191/\u2193 select  \xB7  Enter join  \xB7  Q quit" });
+        })()
+      ] })
+    ] });
+  }
+  if (screen.name === "loading") {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading tracks..." })
+    ] });
+  }
+  if (screen.name === "error") {
+    const backHint = !initialCeremonyId ? "\u232B Backspace \u2014 back to ceremony list  \xB7  Q to quit" : screen.recoverable ? "\u232B Backspace / B to go back  \xB7  Q to quit" : "Q to quit";
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony }),
+      /* @__PURE__ */ jsxs6(Text6, { color: "red", bold: true, children: [
+        "\u2717  ",
+        screen.message
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: backHint })
+    ] });
+  }
+  if (screen.name === "tracks") {
+    const { tracks } = screen;
+    const openTracks = tracks.filter((t) => t.status === "open");
+    const myContributions = Object.values(contributed).filter((c) => c.ceremonyId === activeCeremonyId);
+    const TabBar = () => /* @__PURE__ */ jsxs6(Box6, { gap: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: tab === 0, color: tab === 0 ? "cyan" : void 0, dimColor: tab !== 0, children: tab === 0 ? "[ Dashboard ]" : "  Dashboard  " }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "|" }),
+      /* @__PURE__ */ jsx6(Text6, { bold: tab === 1, color: tab === 1 ? "cyan" : void 0, dimColor: tab !== 1, children: tab === 1 ? `[ My Contributions (${myContributions.length}) ]` : `  My Contributions (${myContributions.length})  ` }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  Tab to switch" })
+    ] });
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony }),
+      /* @__PURE__ */ jsx6(TabBar, {}),
+      tab === 0 ? (
+        // ── Dashboard tab ────────────────────────────────────────────────
+        /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            "  CIRCUIT".padEnd(30),
+            "TOTAL".padEnd(10),
+            "QUEUE".padEnd(8),
+            "STATUS".padEnd(14),
+            "MY CONTRIBUTIONS"
+          ] }),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
+          tracks.map((t, i) => {
+            const isSelected = i === selectedIdx;
+            const canContribute = t.status === "open";
+            const nameClipped = t.circuit_name.length > 26 ? t.circuit_name.slice(0, 24) + ".." : t.circuit_name;
+            const statusColor = t.status === "open" ? "green" : t.status === "finalized" ? "cyan" : "yellow";
+            const myContrib = contributed[t.id];
+            return /* @__PURE__ */ jsxs6(Box6, { children: [
+              /* @__PURE__ */ jsxs6(Text6, { color: isSelected ? "cyan" : canContribute ? void 0 : "gray", children: [
+                isSelected ? "\u25B6 " : "  ",
+                nameClipped.padEnd(28),
+                String(t.contribution_count).padEnd(10),
+                String(t.queue_depth).padEnd(8)
+              ] }),
+              /* @__PURE__ */ jsx6(Text6, { color: statusColor, children: t.status.padEnd(14) }),
+              myContrib ? isSelected ? /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+                "\u2713 contributed (round #",
+                myContrib.sequenceNumber,
+                ")  \u2014 already done"
+              ] }) : /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+                "\u2713 contributed  (round #",
+                myContrib.sequenceNumber,
+                ")"
+              ] }) : canContribute ? isSelected ? /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "\u2190 Enter to contribute" }) : /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "not contributed" }) : /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2014" })
+            ] }, t.id);
+          }),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
+          openTracks.length === 0 ? /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "No open tracks \u2014 ceremony may be finalizing or complete." }) : /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            "\u2191/\u2193 select  \xB7  Enter contribute  \xB7  R refresh  \xB7  Q quit",
+            !initialCeremonyId ? "  \xB7  \u232B back to ceremony list" : ""
+          ] })
+        ] })
+      ) : (
+        // ── My Contributions tab ─────────────────────────────────────────
+        /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: myContributions.length === 0 ? /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", gap: 1, children: [
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No contributions yet." }),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Switch to Dashboard tab and press Enter on a circuit to contribute." })
+        ] }) : /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            "  CIRCUIT".padEnd(28),
+            "ROUND".padEnd(8),
+            "HASH".padEnd(20),
+            "TIME"
+          ] }),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
+          myContributions.map((c, i) => /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs6(Box6, { children: [
+              /* @__PURE__ */ jsx6(Text6, { color: "green", children: "  \u2713 " }),
+              /* @__PURE__ */ jsx6(Text6, { bold: true, children: c.circuitName.padEnd(24) }),
+              /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "#" + c.sequenceNumber + " " }),
+              /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: c.contributionHash ? c.contributionHash.slice(0, 16) + "..." : "(pending)" })
+            ] }),
+            /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+              "     ",
+              c.verifiedAt ? new Date(c.verifiedAt).toLocaleString() : ""
+            ] })
+          ] }, i)),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
+          /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+            "Total: ",
+            myContributions.length,
+            " contribution",
+            myContributions.length !== 1 ? "s" : "",
+            "  \xB7  ",
+            "Tab to switch  \xB7  Q to quit"
+          ] })
+        ] }) })
+      )
+    ] });
+  }
+  if (screen.name === "joining") {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Joining queue..." })
+    ] });
+  }
+  if (screen.name === "queue") {
+    const { trackId, circuitName } = screen;
+    const priorContrib = contributed[trackId];
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony, subtitle: `Circuit: ${circuitName}` }),
+      priorContrib && /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, paddingX: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: "yellow", children: [
+        "\u26A0  You already contributed to this circuit (round #",
+        priorContrib.sequenceNumber,
+        ").",
+        " ",
+        "Contributing again is allowed and adds more entropy."
+      ] }) }),
+      /* @__PURE__ */ jsx6(
+        QueueView,
+        {
+          ceremonyId: activeCeremonyId,
+          trackId,
+          token: session.session_token,
+          onReady: (status) => setScreen({ name: "entropy", trackId, circuitName, slotStatus: status }),
+          onError: (e) => setScreen({ name: "error", message: e.message, recoverable: true })
+        }
+      ),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u232B Backspace to go back  \xB7  Q to quit" })
+    ] });
+  }
+  if (screen.name === "entropy") {
+    const { trackId, circuitName, slotStatus } = screen;
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony, subtitle: `Circuit: ${circuitName}  \xB7  Your turn!` }),
+      /* @__PURE__ */ jsx6(
+        EntropyCollector,
+        {
+          onComplete: (entropy) => setScreen({ name: "contribute", trackId, circuitName, slotStatus, entropy }),
+          onError: (e) => setScreen({ name: "error", message: e.message, recoverable: false })
+        }
+      )
+    ] });
+  }
+  if (screen.name === "contribute") {
+    const { trackId, circuitName, slotStatus, entropy } = screen;
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony, subtitle: `Circuit: ${circuitName}  \xB7  Contributing` }),
+      /* @__PURE__ */ jsx6(
+        ContributeFlow,
+        {
+          ceremonyId: activeCeremonyId,
+          trackId,
+          token: session.session_token,
+          slotStatus,
+          entropy,
+          displayName: displayName2,
+          onComplete: async (contributionId, receipt) => {
+            const local = {
+              contributionId,
+              sequenceNumber: receipt?.sequence_number ?? 0,
+              contributionHash: receipt?.contribution_hash ?? "",
+              circuitName,
+              ceremonyId: activeCeremonyId,
+              verifiedAt: receipt?.verified_at ?? (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await recordContribution(trackId, local);
+            setContributed((prev) => ({ ...prev, [trackId]: local }));
+            setScreen({ name: "done", contribution: local });
+          },
+          onError: (e) => setScreen({ name: "error", message: e.message, recoverable: false })
+        }
+      )
+    ] });
+  }
+  if (screen.name === "done") {
+    const { contribution } = screen;
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { ceremony }),
+      /* @__PURE__ */ jsx6(Attestation, { contribution }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u232B Backspace / B = contribute to another circuit  \xB7  Q to quit" }) })
+    ] });
+  }
+  return null;
+}
+
+// src/index.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ceremonyId = process.env["CEREMONY_ID"] ?? "";
+var displayName = process.env["CONTRIBUTOR_NAME"] ?? "anonymous";
+process.stdout.write("\x1B[?1049h\x1B[H");
+function restoreScreen() {
+  process.stdout.write("\x1B[?1049l");
+}
+async function gracefulExit(code = 0) {
+  restoreScreen();
+  await runQueueCleanup();
+  process.exit(code);
+}
+process.on("SIGINT", () => {
+  gracefulExit(0).catch(() => {
+    restoreScreen();
+    process.exit(0);
+  });
+});
+process.on("SIGTERM", () => {
+  gracefulExit(0).catch(() => {
+    restoreScreen();
+    process.exit(0);
+  });
+});
+var { waitUntilExit } = render(
+  /* @__PURE__ */ jsx7(App, { ceremonyId, displayName }),
+  { exitOnCtrlC: false }
+);
+await waitUntilExit();
+restoreScreen();
+process.exit(0);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@umbra-privacy/ceremony",
+  "version": "0.1.0",
+  "description": "Terminal UI for the Umbra Phase 2 trusted setup ceremony",
+  "type": "module",
+  "bin": {
+    "umbra-ceremony": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/umbra-privacy/umbra-core.git",
+    "directory": "ts-apps/ceremony-tui"
+  },
+  "homepage": "https://github.com/umbra-privacy/umbra-core/tree/main/ts-apps/ceremony-tui",
+  "bugs": "https://github.com/umbra-privacy/umbra-core/issues",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^18.3.1",
+    "snarkjs": "^0.7.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.1",
+    "tsx": "^4.21.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "dev": "tsx src/index.tsx",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}