@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/mining/runtime-artifacts.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 import { dirname } from "node:path";
 import { writeRuntimeStatusFile } from "../fs/status-file.js";
-import { normalizeMiningFamilyStatus, normalizeMiningPublishState } from "./state.js";
+import { normalizeMiningLifecycleStatus, normalizeMiningPublishState } from "./state.js";
 const MAX_EVENT_LOG_BYTES = 10 * 1024 * 1024;
 const MAX_EVENT_LOG_ROTATIONS = 4;
 export function resolveRotatedMiningEventsPath(eventsPath) {
@@ -11,14 +11,31 @@ export function resolveRotatedMiningEventsPath(eventsPath) {
 function resolveIndexedRotatedMiningEventsPath(eventsPath, index) {
     return `${eventsPath}.${index}`;
 }
+function normalizeLegacyMiningProviderState(raw) {
+    switch (raw) {
+        case "ready":
+        case "backoff":
+        case "unavailable":
+        case "rate-limited":
+        case "auth-error":
+            return raw;
+        case "hook-error":
+        case "n/a":
+            return "unavailable";
+        default:
+            return null;
+    }
+}
 export async function loadMiningRuntimeStatus(statusPath) {
     try {
         const raw = await readFile(statusPath, "utf8");
         const parsed = JSON.parse(raw);
         return {
             ...parsed,
-            miningState: normalizeMiningFamilyStatus(parsed.miningState),
+            miningState: normalizeMiningLifecycleStatus(parsed.miningState),
+            providerState: normalizeLegacyMiningProviderState(parsed.providerState),
             currentPublishState: normalizeMiningPublishState(parsed.currentPublishState),
+            livePublishInMempool: parsed.livePublishInMempool ?? parsed.liveMiningFamilyInMempool ?? null,
             indexerReorgDepth: parsed.indexerReorgDepth ?? null,
             sameDomainCompetitorSuppressed: parsed.sameDomainCompetitorSuppressed ?? null,
             dedupedCompetitorDomainCount: parsed.dedupedCompetitorDomainCount ?? null,
@@ -34,7 +51,10 @@ export async function loadMiningRuntimeStatus(statusPath) {
     }
 }
 export async function saveMiningRuntimeStatus(statusPath, snapshot) {
-    await writeRuntimeStatusFile(statusPath, snapshot);
+    await writeRuntimeStatusFile(statusPath, {
+        ...snapshot,
+        providerState: normalizeLegacyMiningProviderState(snapshot.providerState),
+    });
 }
 async function rotateMiningEventsIfNeeded(eventsPath, nextEntryBytes) {
     try {

package/dist/wallet/mining/sentence-protocol.d.ts

@@ -0,0 +1,44 @@
+import { MINING_SENTENCE_SCHEMA_VERSION } from "./constants.js";
+export interface MiningSentenceGenerationRequestV1 {
+    schemaVersion: typeof MINING_SENTENCE_SCHEMA_VERSION;
+    requestId: string;
+    targetBlockHeight: number;
+    referencedBlockHashDisplay: string;
+    generatedAtUnixMs: number;
+    extraPrompt: string | null;
+    limits: {
+        maxCandidatesPerRootDomain: number;
+        maxCandidatesTotal: number;
+        timeoutMs: number;
+        maxCandidateSentenceUtf8Bytes: number;
+    };
+    rootDomains: Array<{
+        domainId: number;
+        domainName: string;
+        requiredWords: [string, string, string, string, string];
+    }>;
+}
+export interface MiningSentenceCandidateV1 {
+    domainId: number;
+    sentence: string;
+    attribution?: {
+        provider?: string;
+        model?: string;
+        promptLabel?: string;
+    };
+}
+export interface MiningSentenceGenerationResponseV1 {
+    schemaVersion: typeof MINING_SENTENCE_SCHEMA_VERSION;
+    requestId: string;
+    candidates: MiningSentenceCandidateV1[];
+}
+export declare function createMiningSentenceRequestLimits(): MiningSentenceGenerationRequestV1["limits"];
+export declare function parseStrictJsonValue(raw: string, invalidMessage: string): unknown;
+export declare function stripMarkdownCodeFence(raw: string): string;
+export declare function normalizeMiningSentenceResponse(options: {
+    request: MiningSentenceGenerationRequestV1;
+    response: unknown;
+}): {
+    response: MiningSentenceGenerationResponseV1;
+    candidates: MiningSentenceCandidateV1[];
+};

package/dist/wallet/mining/sentence-protocol.js

@@ -0,0 +1,123 @@
+import { MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN, MINING_SENTENCE_MAX_CANDIDATES_TOTAL, MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES, MINING_SENTENCE_SCHEMA_VERSION, MINING_SENTENCE_TIMEOUT_MS, } from "./constants.js";
+export function createMiningSentenceRequestLimits() {
+    return {
+        maxCandidateSentenceUtf8Bytes: MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES,
+        maxCandidatesPerRootDomain: MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN,
+        maxCandidatesTotal: MINING_SENTENCE_MAX_CANDIDATES_TOTAL,
+        timeoutMs: MINING_SENTENCE_TIMEOUT_MS,
+    };
+}
+function normalizeAttribution(raw) {
+    if (raw === null || typeof raw !== "object") {
+        return undefined;
+    }
+    const attribution = raw;
+    const normalized = {};
+    for (const key of ["provider", "model", "promptLabel"]) {
+        const value = attribution[key];
+        if (typeof value === "string" && value.length > 0) {
+            normalized[key] = value;
+        }
+    }
+    return Object.keys(normalized).length === 0
+        ? undefined
+        : normalized;
+}
+export function parseStrictJsonValue(raw, invalidMessage) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new Error(invalidMessage);
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        throw new Error(invalidMessage);
+    }
+}
+export function stripMarkdownCodeFence(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("```")) {
+        return raw;
+    }
+    const lines = trimmed.split(/\r?\n/);
+    if (lines.length < 3) {
+        return raw;
+    }
+    const first = lines[0].trim();
+    const last = lines.at(-1)?.trim();
+    if (!first.startsWith("```") || last !== "```") {
+        return raw;
+    }
+    return lines.slice(1, -1).join("\n");
+}
+export function normalizeMiningSentenceResponse(options) {
+    const raw = options.response;
+    if (raw === null || typeof raw !== "object") {
+        throw new Error("Mining sentence generation returned an invalid JSON response.");
+    }
+    const response = raw;
+    if (response.schemaVersion !== MINING_SENTENCE_SCHEMA_VERSION) {
+        throw new Error("Mining sentence generation returned an unsupported schema version.");
+    }
+    if (response.requestId !== options.request.requestId) {
+        throw new Error("Mining sentence generation returned a mismatched requestId.");
+    }
+    if (!Array.isArray(response.candidates)) {
+        throw new Error("Mining sentence generation response must include a candidates array.");
+    }
+    if (response.candidates.length > options.request.limits.maxCandidatesTotal) {
+        throw new Error("Mining sentence generation returned too many total candidates.");
+    }
+    const allowedDomainIds = new Set(options.request.rootDomains.map((domain) => domain.domainId));
+    const perDomainCounts = new Map();
+    const dedupe = new Set();
+    const candidates = [];
+    for (const rawCandidate of response.candidates) {
+        if (rawCandidate === null || typeof rawCandidate !== "object") {
+            throw new Error("Mining sentence generation returned an invalid candidate entry.");
+        }
+        const candidate = rawCandidate;
+        const domainId = candidate.domainId;
+        const sentence = candidate.sentence;
+        if (!Number.isInteger(domainId)) {
+            throw new Error("Mining sentence generation candidate is missing a valid domainId.");
+        }
+        if (!allowedDomainIds.has(domainId)) {
+            throw new Error("Mining sentence generation candidate referenced an unknown domainId.");
+        }
+        if (typeof sentence !== "string") {
+            throw new Error("Mining sentence generation candidate is missing a valid sentence.");
+        }
+        const trimmedSentence = sentence.trim();
+        if (trimmedSentence.length === 0) {
+            throw new Error("Mining sentence generation candidate sentence was empty after trimming.");
+        }
+        if (Buffer.byteLength(trimmedSentence, "utf8") > options.request.limits.maxCandidateSentenceUtf8Bytes) {
+            throw new Error("Mining sentence generation candidate sentence exceeded the UTF-8 byte limit.");
+        }
+        const nextCount = (perDomainCounts.get(domainId) ?? 0) + 1;
+        perDomainCounts.set(domainId, nextCount);
+        if (nextCount > options.request.limits.maxCandidatesPerRootDomain) {
+            throw new Error("Mining sentence generation returned too many candidates for one domain.");
+        }
+        const dedupeKey = `${domainId}:${trimmedSentence}`;
+        if (dedupe.has(dedupeKey)) {
+            continue;
+        }
+        dedupe.add(dedupeKey);
+        candidates.push({
+            domainId: domainId,
+            sentence: trimmedSentence,
+            attribution: normalizeAttribution(candidate.attribution),
+        });
+    }
+    return {
+        response: {
+            schemaVersion: MINING_SENTENCE_SCHEMA_VERSION,
+            requestId: options.request.requestId,
+            candidates,
+        },
+        candidates,
+    };
+}

package/dist/wallet/mining/sentences.d.ts

@@ -1,13 +1,11 @@
-import type { GenerateSentencesHookCandidateV1, GenerateSentencesHookRequestV1 } from "./hook-protocol.js";
+import type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1 } from "./sentence-protocol.js";
 import type { WalletRuntimePaths } from "../runtime.js";
-import type { HookClientStateRecord } from "../types.js";
 import type { WalletSecretProvider } from "../state/provider.js";
-export type MiningSentenceGenerationRequest = GenerateSentencesHookRequestV1;
-export type MiningSentenceGenerationCandidate = GenerateSentencesHookCandidateV1;
+export type MiningSentenceGenerationRequest = MiningSentenceGenerationRequestV1;
+export type MiningSentenceGenerationCandidate = MiningSentenceCandidateV1;
 export interface MiningSentenceSourceOptions {
     paths: WalletRuntimePaths;
     provider: WalletSecretProvider;
-    hookState: HookClientStateRecord | null;
     signal?: AbortSignal;
     fetchImpl?: typeof fetch;
 }
@@ -16,8 +14,6 @@ declare class MiningProviderRequestError extends Error {
     constructor(providerState: "unavailable" | "rate-limited" | "auth-error", message: string);
 }
 export declare function generateMiningSentences(request: MiningSentenceGenerationRequest, options: MiningSentenceSourceOptions): Promise<{
-    hookMode: "builtin" | "custom";
-    candidates: GenerateSentencesHookCandidateV1[];
-    providerState: "ready" | "n/a";
+    candidates: MiningSentenceCandidateV1[];
 }>;
 export { MiningProviderRequestError, };

package/dist/wallet/mining/sentences.js

@@ -1,7 +1,6 @@
 import { loadClientConfig } from "./config.js";
-import { inspectMiningHookState, runGenerateSentencesHookRequest } from "./hooks.js";
 import { MINING_BUILTIN_TIMEOUT_MS, } from "./constants.js";
-import { normalizeHookResponse, parseStrictJsonValue, stripMarkdownCodeFence, } from "./hook-protocol.js";
+import { normalizeMiningSentenceResponse, parseStrictJsonValue, stripMarkdownCodeFence, } from "./sentence-protocol.js";
 class MiningProviderRequestError extends Error {
     providerState;
     constructor(providerState, message) {
@@ -48,15 +47,13 @@ function annotateProviderCandidates(options) {
 function parseProviderJsonResponse(options) {
     const response = parseStrictJsonValue(stripMarkdownCodeFence(options.raw), `${options.providerLabel} returned invalid JSON.`);
     try {
-        return normalizeHookResponse({
+        return normalizeMiningSentenceResponse({
             request: options.request,
             response,
         }).candidates;
     }
     catch (error) {
-        throw new Error(error instanceof Error
-            ? error.message.replace(/^Custom mining hook /, `${options.providerLabel} `)
-            : `${options.providerLabel} returned an invalid response.`);
+        throw new Error(error instanceof Error ? error.message : `${options.providerLabel} returned an invalid response.`);
     }
 }
 function createProviderSignal(signal, timeoutMs) {
@@ -211,51 +208,7 @@ function extractAnthropicText(payload) {
     }
     throw new Error("The built-in Anthropic mining provider returned an empty response.");
 }
-async function requestCustomHookSentences(options) {
-    const inspection = await inspectMiningHookState({
-        hookRootPath: options.paths.hooksMiningDir,
-        entrypointPath: options.paths.hooksMiningEntrypointPath,
-        packagePath: options.paths.hooksMiningPackageJsonPath,
-        localState: options.hookState,
-        verify: false,
-        nowUnixMs: Date.now(),
-    });
-    if (inspection.mode !== "custom") {
-        throw new Error("Custom mining hooks are not enabled.");
-    }
-    if (inspection.cooldownActive) {
-        throw new Error("Custom mining hook is cooling down after repeated failures. Wait for the cooldown to expire or rerun `cogcoin hooks enable mining`.");
-    }
-    if (inspection.operatorValidationState === "failed"
-        || inspection.operatorValidationState === "stale"
-        || inspection.operatorValidationState === "never") {
-        throw new Error("Custom mining hook validation is stale or failed. Rerun `cogcoin hooks enable mining`.");
-    }
-    if (inspection.trustStatus !== "trusted") {
-        throw new Error(inspection.trustMessage ?? "Custom mining hook trust checks failed.");
-    }
-    return runGenerateSentencesHookRequest({
-        hookRootPath: options.paths.hooksMiningDir,
-        entrypointPath: options.paths.hooksMiningEntrypointPath,
-        request: options.request,
-        signal: options.signal,
-        timeoutMs: options.request.limits.timeoutMs,
-    }).then((result) => result.candidates);
-}
 export async function generateMiningSentences(request, options) {
-    const hookMode = options.hookState?.mode === "custom" ? "custom" : "builtin";
-    if (hookMode === "custom") {
-        return {
-            hookMode,
-            candidates: await requestCustomHookSentences({
-                paths: options.paths,
-                hookState: options.hookState,
-                request,
-                signal: options.signal,
-            }),
-            providerState: "n/a",
-        };
-    }
     const config = await loadClientConfig({
         path: options.paths.clientConfigPath,
         provider: options.provider,
@@ -265,7 +218,6 @@ export async function generateMiningSentences(request, options) {
         throw new MiningProviderRequestError("unavailable", "Mining is not configured. Run `cogcoin mine setup`.");
     }
     return {
-        hookMode,
         candidates: await requestBuiltInSentences({
             provider: builtIn.provider,
             apiKey: builtIn.apiKey,
@@ -275,7 +227,6 @@ export async function generateMiningSentences(request, options) {
             fetchImpl: options.fetchImpl,
             signal: options.signal,
         }),
-        providerState: "ready",
     };
 }
 export { MiningProviderRequestError, };

package/dist/wallet/mining/state.d.ts

@@ -1,9 +1,14 @@
 import type { MiningStateRecord } from "../types.js";
-export type MiningFamilyStatus = MiningStateRecord["state"];
+type LegacyMiningStateRecord = MiningStateRecord & {
+    livePublishInMempool?: boolean | null;
+    liveMiningFamilyInMempool?: boolean | null;
+};
+export type MiningLifecycleStatus = MiningStateRecord["state"];
 export type MiningPublishState = MiningStateRecord["currentPublishState"];
-export declare function normalizeMiningFamilyStatus(raw: string | null | undefined): MiningFamilyStatus;
+export declare function normalizeMiningLifecycleStatus(raw: string | null | undefined): MiningLifecycleStatus;
 export declare function normalizeMiningPublishState(raw: string | null | undefined): MiningPublishState;
-export declare function normalizeMiningStateRecord(state: MiningStateRecord): MiningStateRecord;
-export declare function clearMiningFamilyState(state: MiningStateRecord): MiningStateRecord;
-export declare function miningFamilyMayStillExist(state: MiningStateRecord): boolean;
-export declare function miningFamilyIsInMempool(state: MiningStateRecord): boolean;
+export declare function normalizeMiningStateRecord(state: LegacyMiningStateRecord): MiningStateRecord;
+export declare function clearMiningPublishState(state: MiningStateRecord): MiningStateRecord;
+export declare function miningPublishMayStillExist(state: MiningStateRecord): boolean;
+export declare function miningPublishIsInMempool(state: MiningStateRecord): boolean;
+export {};

package/dist/wallet/mining/state.js

@@ -1,4 +1,4 @@
-export function normalizeMiningFamilyStatus(raw) {
+export function normalizeMiningLifecycleStatus(raw) {
     switch (raw) {
         case "live":
         case "paused":
@@ -33,11 +33,12 @@ export function normalizeMiningPublishState(raw) {
 export function normalizeMiningStateRecord(state) {
     return {
         ...state,
-        state: normalizeMiningFamilyStatus(state.state),
+        state: normalizeMiningLifecycleStatus(state.state),
         currentPublishState: normalizeMiningPublishState(state.currentPublishState),
+        livePublishInMempool: state.livePublishInMempool ?? state.liveMiningFamilyInMempool ?? false,
     };
 }
-export function clearMiningFamilyState(state) {
+export function clearMiningPublishState(state) {
     return {
         ...normalizeMiningStateRecord(state),
         state: "idle",
@@ -59,17 +60,17 @@ export function clearMiningFamilyState(state) {
         currentBlockTargetHeight: null,
         currentReferencedBlockHashDisplay: null,
         currentIntentFingerprintHex: null,
-        liveMiningFamilyInMempool: false,
+        livePublishInMempool: false,
         currentPublishDecision: null,
         replacementCount: 0,
         sharedMiningConflictOutpoint: null,
     };
 }
-export function miningFamilyMayStillExist(state) {
+export function miningPublishMayStillExist(state) {
     const normalized = normalizeMiningStateRecord(state);
     return normalized.currentTxid !== null
         && normalized.currentPublishState !== "none";
 }
-export function miningFamilyIsInMempool(state) {
+export function miningPublishIsInMempool(state) {
     return normalizeMiningStateRecord(state).currentPublishState === "in-mempool";
 }

package/dist/wallet/mining/types.d.ts

@@ -1,5 +1,4 @@
 import type { ManagedBitcoindHealth, ManagedIndexerTruthSource } from "../../bitcoind/types.js";
-import type { MiningHookOperatorValidationState } from "./hook-protocol.js";
 export type MiningServiceHealth = "synced" | "catching-up" | "reorging" | "starting" | "stale-heartbeat" | "failed" | "schema-mismatch" | "service-version-mismatch" | "wallet-root-mismatch" | "unavailable";
 export type MiningProviderKind = "openai" | "anthropic";
 export interface MiningProviderConfigRecord {
@@ -57,7 +56,7 @@ export interface MiningRuntimeStatusV1 {
     indexerReorgDepth: number | null;
     indexerTipAligned: boolean | null;
     corePublishState: "unknown" | "network-inactive" | "no-outbound-peers" | "ibd" | "mempool-loading" | "healthy" | null;
-    providerState: "n/a" | "ready" | "backoff" | "unavailable" | "rate-limited" | "auth-error" | "hook-error" | null;
+    providerState: "ready" | "backoff" | "unavailable" | "rate-limited" | "auth-error" | null;
     lastSuspendDetectedAtUnixMs: number | null;
     reconnectSettledUntilUnixMs: number | null;
     tipSettledUntilUnixMs: number | null;
@@ -72,7 +71,7 @@ export interface MiningRuntimeStatusV1 {
     currentCanonicalBlend: string | null;
     currentTxid: string | null;
     currentWtxid: string | null;
-    liveMiningFamilyInMempool: boolean | null;
+    livePublishInMempool: boolean | null;
     currentFeeRateSatVb: number | null;
     currentAbsoluteFeeSats: number | null;
     currentBlockFeeSpentSats: string;
@@ -87,7 +86,6 @@ export interface MiningRuntimeStatusV1 {
     lastMempoolSequence: string | null;
     lastCompetitivenessGateAtUnixMs: number | null;
     pauseReason: string | null;
-    hookMode: "builtin" | "custom";
     providerConfigured: boolean;
     providerKind: MiningProviderKind | null;
     bitcoindHealth: ManagedBitcoindHealth;
@@ -96,35 +94,10 @@ export interface MiningRuntimeStatusV1 {
     nodeHealth: MiningServiceHealth;
     indexerHealth: MiningServiceHealth;
     tipsAligned: boolean | null;
-    lastValidationState: "unknown" | "validated" | "stale" | "failed" | null;
-    lastOperatorValidationState: MiningHookOperatorValidationState | null;
-    lastValidationAtUnixMs: number | null;
     lastEventAtUnixMs: number | null;
     lastError: string | null;
     note: string | null;
 }
-export interface MiningHookInspection {
-    mode: "builtin" | "custom" | "disabled" | "unavailable";
-    entrypointPath: string;
-    packagePath: string;
-    entrypointExists: boolean;
-    packageStatus: "valid" | "missing" | "invalid";
-    packageMessage: string | null;
-    trustStatus: "trusted" | "untrusted" | "missing";
-    trustMessage: string | null;
-    validationState: "unknown" | "validated" | "stale" | "failed" | "unavailable";
-    operatorValidationState: MiningHookOperatorValidationState;
-    validationError: string | null;
-    validatedAtUnixMs: number | null;
-    validatedLaunchFingerprint: string | null;
-    validatedFullFingerprint: string | null;
-    currentLaunchFingerprint: string | null;
-    currentFullFingerprint: string | null;
-    verifyUsed: boolean;
-    cooldownUntilUnixMs: number | null;
-    cooldownActive: boolean;
-    consecutiveFailureCount: number;
-}
 export interface MiningProviderInspection {
     configured: boolean;
     provider: MiningProviderKind | null;
@@ -135,7 +108,6 @@ export interface MiningProviderInspection {
 }
 export interface MiningControlPlaneView {
     runtime: MiningRuntimeStatusV1;
-    hook: MiningHookInspection;
     provider: MiningProviderInspection;
     lastEventAtUnixMs: number | null;
 }

package/dist/wallet/mining/visualizer.d.ts

@@ -1,12 +1,40 @@
 import type { BootstrapProgress, ProgressOutputMode } from "../../bitcoind/types.js";
 import { createFollowSceneState } from "../../bitcoind/progress/follow-scene.js";
 import { type RenderClock, type TtyRenderStream } from "../../bitcoind/progress/render-policy.js";
+import { type FollowSceneRenderOptions } from "../../bitcoind/progress/tty-renderer.js";
 import type { MiningRuntimeStatusV1 } from "./types.js";
 interface VisualizerRendererLike {
-    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: ReturnType<typeof createFollowSceneState>, statusFieldText?: string): void;
+    renderFollowScene(progress: BootstrapProgress, cogcoinSyncHeight: number | null, cogcoinSyncTargetHeight: number | null, followScene: ReturnType<typeof createFollowSceneState>, statusFieldText?: string, renderOptions?: FollowSceneRenderOptions): void;
     close(): void;
 }
-export declare function describeMiningVisualizerStatus(snapshot: MiningRuntimeStatusV1): string;
+export interface MiningSentenceBoardEntry {
+    rank: number;
+    domainName: string;
+    sentence: string;
+}
+export interface MiningProvisionalSentenceEntry {
+    domainName: string | null;
+    sentence: string | null;
+}
+export interface MiningRecentWinSummary {
+    rank: number;
+    rewardCogtoshi: bigint;
+    blockHeight: number;
+}
+export interface MiningFollowVisualizerState {
+    balanceCogtoshi: bigint | null;
+    balanceSats: bigint | null;
+    visibleBlockTimesByHeight: Record<number, number>;
+    settledBlockHeight: number | null;
+    settledBoardEntries: MiningSentenceBoardEntry[];
+    provisionalRequiredWords: readonly string[];
+    provisionalEntry: MiningProvisionalSentenceEntry;
+    latestSentence: string | null;
+    latestTxid: string | null;
+    recentWin: MiningRecentWinSummary | null;
+}
+export declare function createEmptyMiningFollowVisualizerState(): MiningFollowVisualizerState;
+export declare function describeMiningVisualizerStatus(snapshot: MiningRuntimeStatusV1, ui?: MiningFollowVisualizerState): string;
 export declare function describeMiningVisualizerProgress(snapshot: MiningRuntimeStatusV1): string;
 export declare class MiningFollowVisualizer {
     #private;
@@ -18,7 +46,7 @@ export declare class MiningFollowVisualizer {
         clock?: RenderClock;
         rendererFactory?: (stream: TtyRenderStream) => VisualizerRendererLike;
     });
-    update(snapshot: MiningRuntimeStatusV1): void;
+    update(snapshot: MiningRuntimeStatusV1, uiState?: MiningFollowVisualizerState): void;
     close(): void;
 }
 export {};