@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/arena/providers/index.js

@@ -1,132 +0,0 @@
-/**
- * Provider registry — evidence collectors for Arena.
- */
-import { gitProvider } from "./git.js";
-import { repoProvider } from "./repo.js";
-import { docsProvider } from "./docs.js";
-import { noneProvider } from "./none.js";
-import { logger } from "../../logging/logger.js";
-export { gitProvider } from "./git.js";
-export { repoProvider } from "./repo.js";
-export { docsProvider } from "./docs.js";
-export { noneProvider } from "./none.js";
-const PROVIDER_MAP = {
-    git: gitProvider,
-    repo: repoProvider,
-    docs: docsProvider,
-    web: noneProvider, // web deferred to Phase 4 — falls back to none for now
-    none: noneProvider,
-};
-// Hard ceiling for any single provider. The repo provider can fan
-// out 5+ recursive greps; without this, one slow grep on a large
-// tree would freeze the entire arena startup. Tuned to be generous
-// for normal cases but tight enough that the user doesn't sit
-// staring at "Arena {}" for a minute.
-const PROVIDER_TIMEOUT_MS = 8_000;
-/**
- * Collect all evidence according to the plan's sources.
- * Returns unified ArenaArtifact[] and quickFacts.
- *
- * Providers run in parallel (independent of one another) with a
- * per-provider timeout, so a single slow source can't stall the
- * whole arena. Heartbeats are emitted around each provider so the
- * UI can show "collecting from repo..." instead of a blank pause.
- */
-export async function collectEvidence(plan, topic, options = {}) {
-    const artifacts = [];
-    const quickFacts = [];
-    const seenSources = new Set();
-    const { onProgress, signal } = options;
-    const tasks = [];
-    for (const sourceSpec of plan.sources) {
-        if (seenSources.has(sourceSpec.kind))
-            continue;
-        seenSources.add(sourceSpec.kind);
-        const provider = PROVIDER_MAP[sourceSpec.kind];
-        if (!provider)
-            continue;
-        onProgress?.({ type: "evidence_started", source: sourceSpec.kind });
-        tasks.push(runProviderWithTimeout(provider, plan, topic, signal));
-    }
-    const results = await Promise.all(tasks);
-    for (const r of results) {
-        artifacts.push(...r.artifacts);
-        logger.info("arena.evidence_collected", {
-            source: r.kind,
-            count: r.artifacts.length,
-            durationMs: r.durationMs,
-            timedOut: r.timedOut || undefined,
-        });
-        onProgress?.({
-            type: "evidence_collected",
-            source: r.kind,
-            count: r.artifacts.length,
-            durationMs: r.durationMs,
-            timedOut: r.timedOut,
-        });
-    }
-    // Build quick facts from artifacts
-    const branchArtifact = artifacts.find((a) => a.id === "git-branch");
-    if (branchArtifact)
-        quickFacts.push({ label: "Branch", value: branchArtifact.preview });
-    const changedFilesArtifact = artifacts.find((a) => a.id === "git-changed-files");
-    if (changedFilesArtifact?.metadata?.totalCount) {
-        quickFacts.push({ label: "Changed Files", value: String(changedFilesArtifact.metadata.totalCount) });
-    }
-    const docCount = artifacts.filter((a) => a.source === "docs").length;
-    if (docCount > 0)
-        quickFacts.push({ label: "Documents", value: String(docCount) });
-    quickFacts.push({ label: "Sources", value: [...seenSources].join(", ") });
-    quickFacts.push({ label: "Lenses", value: plan.lenses.map((l) => l.name).join(", ") });
-    return { artifacts, quickFacts };
-}
-async function runProviderWithTimeout(provider, plan, topic, signal) {
-    const started = Date.now();
-    let timedOut = false;
-    // Hold the timer outside the timeout Promise so the work-winner
-    // branch can clear it. Previously the timer kept ticking after
-    // work resolved and fired a spurious "timeout" warn 8s later.
-    let timer;
-    let abortHandler;
-    const cleanup = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-        if (abortHandler) {
-            signal?.removeEventListener("abort", abortHandler);
-            abortHandler = undefined;
-        }
-    };
-    const work = Promise.resolve().then(() => provider.collect(plan, topic));
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => {
-            timedOut = true;
-            logger.warn("arena.provider.timeout", { source: provider.kind, ms: PROVIDER_TIMEOUT_MS });
-            resolve([]);
-        }, PROVIDER_TIMEOUT_MS);
-        if (typeof timer.unref === "function")
-            timer.unref();
-        if (signal) {
-            abortHandler = () => resolve([]);
-            signal.addEventListener("abort", abortHandler, { once: true });
-        }
-    });
-    let artifacts;
-    try {
-        artifacts = await Promise.race([work, timeout]);
-    }
-    catch (err) {
-        logger.warn("arena.provider.error", { source: provider.kind, error: err.message });
-        artifacts = [];
-    }
-    finally {
-        cleanup();
-    }
-    return {
-        kind: provider.kind,
-        artifacts,
-        durationMs: Date.now() - started,
-        timedOut,
-    };
-}

package/dist/arena/providers/none.d.ts

@@ -1,7 +0,0 @@
-/**
- * NoneProvider — returns no external evidence.
- * Used for pure topic discussions, brainstorming, or debates
- * where no external context is needed.
- */
-import type { ArenaContextProvider } from "../types.js";
-export declare const noneProvider: ArenaContextProvider;

package/dist/arena/providers/none.js

@@ -1,11 +0,0 @@
-/**
- * NoneProvider — returns no external evidence.
- * Used for pure topic discussions, brainstorming, or debates
- * where no external context is needed.
- */
-export const noneProvider = {
-    kind: "none",
-    collect(_plan, _topic) {
-        return [];
-    },
-};

package/dist/arena/providers/repo.d.ts

@@ -1,7 +0,0 @@
-/**
- * RepoProvider — collects evidence from the code repository:
- * directory trees, key files, grep results.
- */
-import type { ArenaContextProvider } from "../types.js";
-export declare const repoProvider: ArenaContextProvider;
-export declare function truncate(content: string): string;

package/dist/arena/providers/repo.js

@@ -1,258 +0,0 @@
-/**
- * RepoProvider — collects evidence from the code repository:
- * directory trees, key files, grep results.
- */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { readdir, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { logger } from "../../logging/logger.js";
-const MAX_FILE_CHARS = 8_000;
-// Per-grep ceiling. We run up to 5 hints in parallel, so the worst-case
-// wall time is ~3s rather than the previous 5×10s = 50s in series.
-const GREP_TIMEOUT_MS = 3_000;
-// Hard cap on tree-walk work — large monorepos (or recursive symlinks)
-// could otherwise blow up readdirSync/statSync time.
-const MAX_TREE_NODES = 400;
-const execFileAsync = promisify(execFile);
-export const repoProvider = {
-    kind: "repo",
-    async collect(plan, topic) {
-        const artifacts = [];
-        const targets = plan.sources.find((s) => s.kind === "repo")?.targets ?? [];
-        // Project tree overview
-        const tree = await buildTree(".", 2);
-        if (tree) {
-            artifacts.push({
-                id: "repo-tree",
-                kind: "tree",
-                source: "repo",
-                title: "Project Structure",
-                preview: tree,
-            });
-        }
-        // If specific targets provided, read them
-        for (const target of targets) {
-            if (!existsSync(target))
-                continue;
-            const st = statSync(target);
-            if (st.isDirectory()) {
-                const dirTree = await buildTree(target, 3);
-                if (dirTree) {
-                    artifacts.push({
-                        id: `repo-tree-${target}`,
-                        kind: "tree",
-                        source: "repo",
-                        title: `Directory: ${target}`,
-                        preview: dirTree,
-                    });
-                }
-                // Read entry files
-                for (const file of (await collectEntryFiles(target)).slice(0, 3)) {
-                    const content = safeReadFile(file);
-                    if (content) {
-                        artifacts.push({
-                            id: `repo-file-${file}`,
-                            kind: "file",
-                            source: "repo",
-                            title: file,
-                            ref: file,
-                            preview: truncate(content),
-                        });
-                    }
-                }
-            }
-            else {
-                const content = safeReadFile(target);
-                if (content) {
-                    artifacts.push({
-                        id: `repo-file-${target}`,
-                        kind: "file",
-                        source: "repo",
-                        title: target,
-                        ref: target,
-                        preview: truncate(content),
-                    });
-                }
-            }
-        }
-        // Search for topic-related files if no specific targets.
-        // Fan out hints in parallel — the previous serial loop was the
-        // single biggest contributor to Arena's startup latency.
-        if (targets.length === 0) {
-            const hints = extractSearchHints(topic).slice(0, 5);
-            const grepResults = await Promise.all(hints.map((h) => safeGrep(h)));
-            for (let i = 0; i < hints.length; i++) {
-                const hint = hints[i];
-                const result = grepResults[i] ?? "";
-                if (!result)
-                    continue;
-                const files = result.split("\n").filter(Boolean).slice(0, 10);
-                for (const file of files) {
-                    if (!artifacts.some((a) => a.ref === file)) {
-                        artifacts.push({
-                            id: `repo-grep-${hint}-${file}`,
-                            kind: "grep",
-                            source: "repo",
-                            title: `Match: ${hint} → ${file}`,
-                            ref: file,
-                            preview: file,
-                        });
-                    }
-                }
-            }
-        }
-        // Recent git activity — only if git source is not already active (avoids duplicate)
-        const hasGitSource = plan.sources.some((s) => s.kind === "git");
-        if (!hasGitSource) {
-            const recentLog = await gitLog();
-            if (recentLog) {
-                artifacts.push({
-                    id: "repo-recent-activity",
-                    kind: "doc",
-                    source: "repo",
-                    title: "Recent Git Activity",
-                    preview: recentLog,
-                });
-            }
-        }
-        logger.info("arena.provider.repo", { artifactCount: artifacts.length });
-        return artifacts;
-    },
-};
-async function buildTree(dir, maxDepth) {
-    // Async + node-capped walk. The previous *Sync variant blocked the
-    // event loop while the new collectEvidence runs providers in
-    // parallel, partially defeating the parallelism win.
-    const lines = [];
-    const counter = { n: 0 };
-    await walkTree(dir, maxDepth, 0, "", lines, counter);
-    return lines.filter(Boolean).join("\n");
-}
-async function walkTree(dir, maxDepth, depth, prefix, out, counter) {
-    if (depth >= maxDepth)
-        return;
-    if (counter.n >= MAX_TREE_NODES)
-        return;
-    let entries;
-    try {
-        entries = (await readdir(dir)).filter((e) => !e.startsWith(".") && e !== "node_modules" && e !== "dist" && e !== "__pycache__");
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries.slice(0, 30)) {
-        if (counter.n >= MAX_TREE_NODES)
-            return;
-        counter.n++;
-        const fullPath = join(dir, entry);
-        let isDir = false;
-        try {
-            isDir = (await stat(fullPath)).isDirectory();
-        }
-        catch {
-            continue;
-        }
-        out.push(`${prefix}${isDir ? "/" : ""} ${entry}`);
-        if (isDir && depth < maxDepth - 1) {
-            await walkTree(fullPath, maxDepth, depth + 1, prefix + "  ", out, counter);
-        }
-    }
-}
-async function collectEntryFiles(dir) {
-    const files = [];
-    try {
-        const entries = await readdir(dir);
-        const priority = ["index.ts", "index.js", "main.ts", "main.js", "mod.ts", "__init__.py"];
-        for (const p of priority) {
-            if (entries.includes(p))
-                files.push(join(dir, p));
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry);
-            if (/\.(ts|js|tsx|jsx|py)$/.test(entry) && !files.includes(full)) {
-                files.push(full);
-            }
-        }
-    }
-    catch { /* ignore */ }
-    return files;
-}
-function safeReadFile(filePath) {
-    try {
-        if (!existsSync(filePath))
-            return null;
-        const st = statSync(filePath);
-        if (st.size > 500_000)
-            return null;
-        return readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return null;
-    }
-}
-export function truncate(content) {
-    if (content.length <= MAX_FILE_CHARS)
-        return content;
-    const t = content.slice(0, MAX_FILE_CHARS);
-    const lastNl = t.lastIndexOf("\n");
-    // No newline in the window (e.g. a minified file) → lastNl is -1 and
-    // slice(0,-1) would drop just the last char; cut at MAX_FILE_CHARS instead.
-    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
-    return body + `\n... (truncated, ${content.length} chars total)`;
-}
-async function safeGrep(pattern) {
-    try {
-        const { stdout } = await execFileAsync("grep", [
-            "-rl",
-            "--include=*.ts", "--include=*.js", "--include=*.py", "--include=*.md",
-            "-i", pattern, ".",
-        ], { encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: GREP_TIMEOUT_MS });
-        return stdout.trim();
-    }
-    catch (err) {
-        // grep exits 1 when there are no matches — that's the expected
-        // "no hits" path. Anything else (signal kill on timeout, ENOENT
-        // because grep isn't installed, permission denied, etc.) is a
-        // real failure that the caller should know about, otherwise
-        // Arena silently degrades with zero artifacts.
-        const e = err;
-        if (e?.code === 1)
-            return "";
-        logger.warn("arena.provider.grep_failed", {
-            pattern,
-            code: e?.code,
-            killed: e?.killed,
-            signal: e?.signal,
-        });
-        return "";
-    }
-}
-async function gitLog() {
-    try {
-        const { stdout } = await execFileAsync("git", ["log", "--oneline", "-10"], {
-            encoding: "utf-8",
-            maxBuffer: 1024 * 1024,
-            timeout: 10_000,
-        });
-        return stdout.trim();
-    }
-    catch {
-        return "";
-    }
-}
-function extractSearchHints(topic) {
-    const stopWords = new Set([
-        "the", "a", "an", "is", "are", "was", "were", "be", "been", "have", "has",
-        "do", "does", "did", "will", "would", "could", "should", "may", "might",
-        "to", "of", "in", "for", "on", "with", "at", "by", "from", "about",
-        "and", "but", "or", "not", "this", "that", "my", "your", "what", "how",
-        "review", "discuss", "plan", "help", "please", "look", "check",
-        "一下", "看看", "帮", "我", "的", "是否", "怎么", "如何", "讨论", "规划", "审查",
-    ]);
-    return topic
-        .split(/[\s,;:]+/)
-        .map((w) => w.toLowerCase().replace(/[^a-z0-9_\-/]/g, ""))
-        .filter((w) => w.length > 2 && !stopWords.has(w));
-}

package/dist/arena/render/session.d.ts

@@ -1,17 +0,0 @@
-/**
- * Session renderer — formats ArenaResultV2 into markdown suitable for
- * displaying as assistant_text and as context for follow-up LLM turns.
- *
- * Scene-aware output order:
- *   1. Subject Summary — factual framing / what changed / current scope
- *   2. Overall assessment
- *   3. Roadmap (planning-first when present)
- *   4. Consensus sections ordered by output emphasis
- *   5. Next Actions
- *   6. Per-participant findings (collapsed)
- */
-import type { ArenaResultV2 } from "../types.js";
-/**
- * Format an ArenaResultV2 into markdown text.
- */
-export declare function formatArenaResultForSession(result: ArenaResultV2): string;

package/dist/arena/render/session.js

@@ -1,190 +0,0 @@
-/**
- * Session renderer — formats ArenaResultV2 into markdown suitable for
- * displaying as assistant_text and as context for follow-up LLM turns.
- *
- * Scene-aware output order:
- *   1. Subject Summary — factual framing / what changed / current scope
- *   2. Overall assessment
- *   3. Roadmap (planning-first when present)
- *   4. Consensus sections ordered by output emphasis
- *   5. Next Actions
- *   6. Per-participant findings (collapsed)
- */
-/**
- * Format an ArenaResultV2 into markdown text.
- */
-export function formatArenaResultForSession(result) {
-    const lines = [];
-    const modeLabel = result.mode.charAt(0).toUpperCase() + result.mode.slice(1);
-    lines.push(`## Arena ${modeLabel} Result`);
-    lines.push(`**Topic:** ${result.topic}`);
-    lines.push(`**Models:** ${result.participants.join(" vs ")}`);
-    lines.push("");
-    const c = result.consensus;
-    // 1. Subject Summary — factual overview (adapts label per mode)
-    if (c.subjectSummary) {
-        const overviewLabel = result.plan.outputShape.overviewLabel
-            ?? (result.mode === "review" ? "What Changed"
-                : result.mode === "planning" ? "Current Scope"
-                    : "Problem Framing");
-        lines.push(`### ${overviewLabel}`);
-        lines.push(c.subjectSummary);
-        lines.push("");
-    }
-    // 2. Overall assessment
-    if (c.summary) {
-        lines.push("### Overall Assessment");
-        lines.push(c.summary);
-        lines.push("");
-    }
-    // 3. Roadmap — surfaced early for planning scenes
-    if (result.mode === "planning" && c.roadmap.length > 0) {
-        lines.push("### Roadmap");
-        for (const [index, phase] of c.roadmap.entries()) {
-            lines.push(...formatRoadmapPhase(index, phase));
-        }
-        lines.push("");
-        // 3b. Implementation Details — expanded phase details
-        if (c.roadmapDetails && c.roadmapDetails.length > 0) {
-            lines.push("### Implementation Details");
-            for (const detail of c.roadmapDetails) {
-                lines.push(...formatPhaseDetail(detail));
-            }
-            lines.push("");
-        }
-    }
-    // 4. Consensus sections ordered by output emphasis
-    for (const section of getOrderedConsensusSections(result)) {
-        lines.push(`### ${section.title}`);
-        for (const item of section.items) {
-            lines.push(`- **${item.title}**: ${item.summary}`);
-        }
-        lines.push("");
-    }
-    // 5. Roadmap for non-planning scenes
-    if (result.mode !== "planning" && c.roadmap.length > 0) {
-        lines.push("### Roadmap");
-        for (const [index, phase] of c.roadmap.entries()) {
-            lines.push(...formatRoadmapPhase(index, phase));
-        }
-        lines.push("");
-    }
-    // 6. Next Actions
-    if (c.nextActions.length > 0) {
-        lines.push("### Next Actions");
-        for (const action of c.nextActions) {
-            const pri = action.priority === "high" ? "🔴" : action.priority === "medium" ? "🟡" : "⚪";
-            lines.push(`- ${pri} **${action.title}**: ${action.rationale}`);
-        }
-        lines.push("");
-    }
-    // 7. Per-participant findings (detail section)
-    if (result.reports.some((r) => r.findings.length > 0)) {
-        lines.push("---");
-        lines.push("### Participant Findings");
-        for (const report of result.reports) {
-            if (report.findings.length === 0) {
-                lines.push(`\n**${report.participant}**: ${report.contextSummary || "(no findings)"}`);
-                continue;
-            }
-            lines.push(`\n**${report.participant}** (${report.findings.length} findings)`);
-            if (report.contextSummary) {
-                lines.push(`> ${report.contextSummary}`);
-            }
-            for (const f of report.findings) {
-                const severity = f.severity ? `/${f.severity}` : "";
-                lines.push(`- [${f.kind}${severity}] **${f.title}**: ${f.summary}`);
-            }
-        }
-    }
-    return lines.join("\n");
-}
-function formatRoadmapPhase(index, phase) {
-    const pri = phase.priority === "high" ? "High" : phase.priority === "medium" ? "Medium" : "Low";
-    const lines = [`#### Phase ${index + 1}: ${phase.title} (${pri} priority)`];
-    if (phase.goal) {
-        lines.push(`Goal: ${phase.goal}`);
-    }
-    if (phase.scope.length > 0) {
-        lines.push(`Scope: ${phase.scope.join("; ")}`);
-    }
-    if (phase.deliverables.length > 0) {
-        lines.push(`Deliverables: ${phase.deliverables.join("; ")}`);
-    }
-    if (phase.dependencies.length > 0) {
-        lines.push(`Dependencies: ${phase.dependencies.join("; ")}`);
-    }
-    if (phase.risks.length > 0) {
-        lines.push(`Risks: ${phase.risks.join("; ")}`);
-    }
-    if (phase.successCriteria.length > 0) {
-        lines.push(`Success Criteria: ${phase.successCriteria.join("; ")}`);
-    }
-    lines.push("");
-    return lines;
-}
-function formatPhaseDetail(detail) {
-    const effort = detail.effort === "large" ? "Large" : detail.effort === "small" ? "Small" : "Medium";
-    const lines = [`#### ${detail.phaseTitle} (${effort} effort)`];
-    if (detail.objective) {
-        lines.push(detail.objective);
-    }
-    if (detail.targetFiles.length > 0) {
-        lines.push(`**Target files:** ${detail.targetFiles.map((f) => "`" + f + "`").join(", ")}`);
-    }
-    if (detail.codeChanges.length > 0) {
-        lines.push("**Code changes:**");
-        for (const change of detail.codeChanges) {
-            lines.push(`- ${change}`);
-        }
-    }
-    if (detail.interfaces.length > 0) {
-        lines.push(`**Interfaces:** ${detail.interfaces.join("; ")}`);
-    }
-    if (detail.migrationSteps.length > 0) {
-        lines.push("**Migration steps:**");
-        for (const [i, step] of detail.migrationSteps.entries()) {
-            lines.push(`${i + 1}. ${step}`);
-        }
-    }
-    if (detail.validation.length > 0) {
-        lines.push(`**Validation:** ${detail.validation.join("; ")}`);
-    }
-    if (detail.blockers.length > 0) {
-        lines.push(`**Blockers:** ${detail.blockers.join("; ")}`);
-    }
-    lines.push("");
-    return lines;
-}
-function getOrderedConsensusSections(result) {
-    const VALID_KINDS = new Set(["strength", "improvement", "risk", "question"]);
-    const defaultOrder = ["risk", "improvement", "strength", "question"];
-    const emphasize = (result.plan?.outputShape?.emphasize ?? []).filter((k) => VALID_KINDS.has(k));
-    const orderedKinds = dedupeFindingKinds([...emphasize, ...defaultOrder]);
-    const sections = orderedKinds.map((kind) => {
-        switch (kind) {
-            case "strength":
-                return { kind, title: "✓ Strengths", items: result.consensus.strengths };
-            case "improvement":
-                return { kind, title: "→ Improvements", items: result.consensus.improvements };
-            case "risk":
-                return { kind, title: "⚠ Risks", items: result.consensus.risks };
-            case "question":
-                return { kind, title: "? Open Questions", items: result.consensus.openQuestions };
-        }
-    });
-    return sections
-        .filter((section) => section != null)
-        .filter((section) => section.items.length > 0);
-}
-function dedupeFindingKinds(kinds) {
-    const seen = new Set();
-    const result = [];
-    for (const kind of kinds) {
-        if (!seen.has(kind)) {
-            seen.add(kind);
-            result.push(kind);
-        }
-    }
-    return result;
-}

package/dist/arena/render/terminal.d.ts

@@ -1,34 +0,0 @@
-/**
- * Terminal renderer — renders ArenaConsensus and ArenaResultV2.
- *
- * All render functions return strings instead of printing directly,
- * so callers can decide where to display (ctx.addStatus vs console.log).
- *
- * Output sections:
- * 1. Summary
- * 2. Roadmap (surfaced early for planning scenes)
- * 3. Consensus sections ordered by output emphasis
- * 4. Next Actions
- */
-import { type Colorizer } from "../../colorizer.js";
-import type { ArenaResultV2, ArenaProgressEvent } from "../types.js";
-/** Output sink — callers provide this to control where text goes. */
-export type OutputSink = (text: string) => void;
-/**
- * Format the full arena result as a styled string.
- */
-export declare function formatArenaResult(result: ArenaResultV2, c?: Colorizer): string;
-/**
- * Print the full arena result directly to stdout.
- * Used by the CLI `code-shell arena` command (non-REPL).
- */
-export declare function printArenaResult(result: ArenaResultV2, c?: Colorizer): void;
-/**
- * Create a progress renderer that sends output to a sink.
- * For REPL: pass ctx.addStatus. For CLI: pass console.log.
- */
-export declare function createProgressRenderer(sink: OutputSink, c?: Colorizer): (event: ArenaProgressEvent) => void;
-/**
- * Legacy: direct console.log progress renderer for CLI mode.
- */
-export declare function renderProgress(event: ArenaProgressEvent, c?: Colorizer): void;