@cogcoin/client 1.1.9 → 1.1.11

package/dist/cli/mining-format.js

@@ -1,3 +1,4 @@
+import { resolveWaitingProviderNote } from "../wallet/mining/projection.js";
 function formatMaybeIso(unixMs) {
     return unixMs === null ? "none" : new Date(unixMs).toISOString();
 }
@@ -33,7 +34,11 @@ function resolveInsufficientFundsNextStep() {
 function resolveMiningRuntimeNote(mining) {
     return mining.runtime.currentPublishDecision === "publish-paused-insufficient-funds"
         ? "Insufficient BTC to mine."
-        : mining.runtime.note;
+        : mining.runtime.note !== null
+            ? mining.runtime.note
+            : mining.runtime.currentPhase === "waiting-provider"
+                ? resolveWaitingProviderNote(mining.runtime.providerState)
+                : null;
 }
 export function formatMiningSummaryLine(mining) {
     const provider = mining.provider.configured

package/dist/cli/wallet-format/balance.js

@@ -34,7 +34,7 @@ function renderBalanceArtCard(context) {
             return renderBalanceArtLine(line, "Funding address:", ` ${fundingAddress}`);
         }
         if (line.includes("Bitcoin Balance:")) {
-            return renderBalanceArtLine(line, "Bitcoin Balance:", ` ${formatBitcoinAmount(context.fundingSpendableSats ?? null)}`);
+            return renderBalanceArtLine(line, "Bitcoin Balance:", ` ${formatBitcoinAmount(context.fundingDisplaySats ?? null)}`);
         }
         if (line.includes("Cogcoin Balance:")) {
             return renderBalanceArtLine(line, "Cogcoin Balance:", ` ${formatCogAmount(spendableCog)}`);

package/dist/client/default-client.d.ts

@@ -1,10 +1,12 @@
 import type { BitcoinBlock, GenesisParameters, IndexerState } from "@cogcoin/indexer/types";
-import type { ApplyBlockResult, Client, ClientCheckpoint, ClientStoreAdapter, ClientTip } from "../types.js";
+import type { ApplyBlockResult, Client, ClientCheckpoint, ClientMirrorDelta, ClientMirrorSnapshot, ClientStoreAdapter, ClientTip } from "../types.js";
 export declare class DefaultClient implements Client {
     #private;
     constructor(store: ClientStoreAdapter, genesisParameters: GenesisParameters, state: IndexerState, tip: ClientTip | null, snapshotInterval: number, blockRecordRetention: number);
     getTip(): Promise<ClientTip | null>;
     getState(): Promise<IndexerState>;
+    readMirrorSnapshot(): Promise<ClientMirrorSnapshot>;
+    readMirrorDelta(afterHeight: number): Promise<ClientMirrorDelta>;
     applyBlock(block: BitcoinBlock): Promise<ApplyBlockResult>;
     rewindToHeight(height: number): Promise<ClientTip | null>;
     restoreCheckpoint(checkpoint: ClientCheckpoint): Promise<ClientTip>;

package/dist/client/default-client.js

@@ -26,6 +26,28 @@ export class DefaultClient {
         await this.#queue;
         return this.#state;
     }
+    async readMirrorSnapshot() {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            return {
+                tip: this.#tip === null ? null : { ...this.#tip },
+                stateBytes: serializeIndexerState(this.#state),
+            };
+        });
+    }
+    async readMirrorDelta(afterHeight) {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            const blockRecords = await this.#store.loadBlockRecordsAfter(afterHeight);
+            return {
+                tip: this.#tip === null ? null : { ...this.#tip },
+                blockRecords: blockRecords.map((record) => ({
+                    ...record,
+                    recordBytes: new Uint8Array(record.recordBytes),
+                })),
+            };
+        });
+    }
     async applyBlock(block) {
         return this.#enqueue(async () => {
             this.#assertOpen();

package/dist/types.d.ts

@@ -19,6 +19,18 @@ export interface StoredBlockRecord {
     recordBytes: Uint8Array;
     createdAt: number;
 }
+export interface ClientMirrorSnapshot {
+    tip: ClientTip | null;
+    stateBytes: Uint8Array;
+}
+export interface ClientMirrorDelta {
+    tip: ClientTip | null;
+    blockRecords: StoredBlockRecord[];
+}
+export interface ClientMirrorReader {
+    readMirrorSnapshot(): Promise<ClientMirrorSnapshot>;
+    readMirrorDelta(afterHeight: number): Promise<ClientMirrorDelta>;
+}
 export interface WriteAppliedBlockEntry {
     tip: ClientTip | null;
     stateBytes: Uint8Array | null;
@@ -48,7 +60,7 @@ export interface ApplyBlockResult {
     checkpoint: ClientCheckpoint | null;
     applied: AppliedBlock;
 }
-export interface Client {
+export interface Client extends ClientMirrorReader {
     getTip(): Promise<ClientTip | null>;
     getState(): Promise<IndexerState>;
     applyBlock(block: BitcoinBlock): Promise<ApplyBlockResult>;

package/dist/wallet/fs/atomic.d.ts

@@ -1,6 +1,15 @@
+import { rename, rm } from "node:fs/promises";
 export interface AtomicWriteOptions {
     mode?: number;
     encoding?: BufferEncoding;
 }
-export declare function writeFileAtomic(filePath: string, data: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;
-export declare function writeJsonFileAtomic(filePath: string, value: unknown, options?: AtomicWriteOptions): Promise<void>;
+export interface AtomicWriteDependencies {
+    platform?: NodeJS.Platform;
+    rename?: typeof rename;
+    rm?: typeof rm;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+export declare function replaceFileAtomicWithRetryForTesting(tempPath: string, filePath: string, dependencies?: AtomicWriteDependencies): Promise<void>;
+export declare function writeFileAtomic(filePath: string, data: string | Uint8Array, options?: AtomicWriteOptions, dependencies?: AtomicWriteDependencies): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown, options?: AtomicWriteOptions, dependencies?: AtomicWriteDependencies): Promise<void>;

package/dist/wallet/fs/atomic.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, open, rename } from "node:fs/promises";
+import { mkdir, open, rename, rm } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+const WINDOWS_REPLACE_RETRY_DELAY_MS = 25;
+const WINDOWS_REPLACE_RETRY_TIMEOUT_MS = 1_000;
 async function fsyncDirectory(directoryPath) {
     try {
         const directoryHandle = await open(directoryPath, "r");
@@ -21,7 +23,39 @@ async function fsyncDirectory(directoryPath) {
         throw error;
     }
 }
-export async function writeFileAtomic(filePath, data, options = {}) {
+function isRetryableWindowsReplaceError(error) {
+    if (!(error instanceof Error) || !("code" in error)) {
+        return false;
+    }
+    const code = error.code;
+    return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function replaceFileAtomicWithRetryForTesting(tempPath, filePath, dependencies = {}) {
+    const renameImpl = dependencies.rename ?? rename;
+    if ((dependencies.platform ?? process.platform) !== "win32") {
+        await renameImpl(tempPath, filePath);
+        return;
+    }
+    const nowImpl = dependencies.now ?? Date.now;
+    const sleepImpl = dependencies.sleep ?? sleep;
+    const deadline = nowImpl() + WINDOWS_REPLACE_RETRY_TIMEOUT_MS;
+    while (true) {
+        try {
+            await renameImpl(tempPath, filePath);
+            return;
+        }
+        catch (error) {
+            if (!isRetryableWindowsReplaceError(error) || nowImpl() >= deadline) {
+                throw error;
+            }
+            await sleepImpl(WINDOWS_REPLACE_RETRY_DELAY_MS);
+        }
+    }
+}
+export async function writeFileAtomic(filePath, data, options = {}, dependencies = {}) {
     const directoryPath = dirname(filePath);
     const tempPath = join(directoryPath, `${basename(filePath)}.tmp-${randomUUID()}`);
     await mkdir(directoryPath, { recursive: true });
@@ -38,9 +72,15 @@ export async function writeFileAtomic(filePath, data, options = {}) {
     finally {
         await handle.close();
     }
-    await rename(tempPath, filePath);
+    try {
+        await replaceFileAtomicWithRetryForTesting(tempPath, filePath, dependencies);
+    }
+    catch (error) {
+        await (dependencies.rm ?? rm)(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
     await fsyncDirectory(directoryPath);
 }
-export async function writeJsonFileAtomic(filePath, value, options = {}) {
-    await writeFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
+export async function writeJsonFileAtomic(filePath, value, options = {}, dependencies = {}) {
+    await writeFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options, dependencies);
 }

package/dist/wallet/mining/cycle.js

@@ -10,7 +10,7 @@ import { MiningProviderRequestError } from "./sentences.js";
 import { isInsufficientFundsError } from "../tx/common.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
-import { buildPrePublishStatusOverrides, } from "./projection.js";
+import { buildPrePublishStatusOverrides, resolveWaitingProviderNote, } from "./projection.js";
 function createInitialState(options) {
     return {
         phase: "idle",
@@ -149,7 +149,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState,
                             lastError: options.loopState.providerWaitLastError,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState),
                         });
                         return;
                     }
@@ -162,7 +162,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState,
                             lastError: options.loopState.providerWaitLastError,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState),
                         });
                         return;
                     }
@@ -231,7 +231,7 @@ export async function runMiningPhaseMachine(options) {
                             currentPublishDecision: null,
                             providerState: options.loopState.providerWaitState ?? error.providerState,
                             lastError: error.message,
-                            note: "Mining is waiting for the sentence provider to recover.",
+                            note: resolveWaitingProviderNote(options.loopState.providerWaitState ?? error.providerState),
                         });
                         await options.appendEvent(createMiningEventRecord("publish-paused-provider", error.message, {
                             level: "warn",

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

@@ -88,6 +88,7 @@ export type ReadyMiningReadContext = WalletReadContext & {
     snapshot: NonNullable<WalletReadContext["snapshot"]>;
     model: NonNullable<WalletReadContext["model"]>;
 };
+export declare function resolveReadyMiningReadContext(readContext: WalletReadContext): ReadyMiningReadContext | null;
 export interface MiningPublishSkipResult {
     state: WalletStateV1;
     txid: null;

package/dist/wallet/mining/engine-types.js

@@ -1 +1,9 @@
-export {};
+export function resolveReadyMiningReadContext(readContext) {
+    if (readContext.localState.availability !== "ready"
+        || readContext.localState.state === null
+        || readContext.snapshot === null
+        || readContext.model === null) {
+        return null;
+    }
+    return readContext;
+}

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

@@ -37,6 +37,7 @@ export interface MiningRuntimeStatusOverrides {
     note?: string | null;
     livePublishInMempool?: boolean | null;
 }
+export declare function resolveWaitingProviderNote(providerState: MiningRuntimeStatusV1["providerState"] | null): string;
 export declare function buildPrePublishStatusOverrides(options: {
     state: WalletStateV1;
     candidate: MiningCandidate;

package/dist/wallet/mining/projection.js

@@ -1,6 +1,20 @@
 import { livePublishTargetsCandidateTip } from "./engine-state.js";
 import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
+export function resolveWaitingProviderNote(providerState) {
+    switch (providerState) {
+        case "backoff":
+            return "Mining is waiting because the sentence provider had a transient failure and will be retried automatically.";
+        case "rate-limited":
+            return "Mining is waiting because the sentence provider is rate limited and will be retried automatically.";
+        case "auth-error":
+            return "Mining is waiting because the sentence provider rejected the configured API key.";
+        case "not-found":
+            return "Mining is waiting because the configured sentence-provider model was not found.";
+        default:
+            return "Mining is waiting for the sentence provider to recover.";
+    }
+}
 export function buildPrePublishStatusOverrides(options) {
     const replacing = options.state.miningState.currentTxid !== null;
     const replacingAcrossTips = replacing && !livePublishTargetsCandidateTip({
@@ -249,7 +263,7 @@ export async function buildMiningRuntimeStatusSnapshot(options) {
             : existing?.currentPhase === "resuming"
                 ? "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health."
                 : reuseExistingProviderWait
-                    ? "Mining is waiting for the sentence provider to recover."
+                    ? resolveWaitingProviderNote(existing?.providerState ?? providerState)
                     : existing?.currentPhase === "waiting-indexer"
                         ? "Mining is waiting for Bitcoin Core and the indexer to align."
                         : existing?.currentPhase === "waiting-bitcoin-network"

package/dist/wallet/mining/publish.js

@@ -6,7 +6,7 @@ import { serializeMine } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
 import { assertFixedInputPrefixMatches, buildWalletMutationTransaction, fundAndValidateWalletMutationDraft, isAlreadyAcceptedError, isBroadcastUnknownError, isInsufficientFundsError, outpointKey as walletMutationOutpointKey, reconcilePersistentPolicyLocks, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { createMiningEventRecord } from "./events.js";
-import {} from "./engine-types.js";
+import { resolveReadyMiningReadContext, } from "./engine-types.js";
 import { cloneMiningState, defaultMiningStatePatch, livePublishTargetsCandidateTip, miningCandidateIsCurrent, resolveSharedMiningConflictOutpoint, } from "./engine-state.js";
 import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { clearMiningPublishState, miningPublishMayStillExist, } from "./state.js";
@@ -576,13 +576,10 @@ export async function publishCandidate(options) {
     });
     try {
         options.throwIfStopping?.();
-        if (lockedReadContext.localState.availability !== "ready"
-            || lockedReadContext.localState.state === null
-            || lockedReadContext.snapshot === null
-            || lockedReadContext.model === null) {
+        const readyReadContext = resolveReadyMiningReadContext(lockedReadContext);
+        if (readyReadContext === null) {
             return await createStaleCandidateSkipResult(options.fallbackState);
         }
-        const readyReadContext = lockedReadContext;
         const refreshedCandidate = refreshMiningCandidateFromCurrentState(readyReadContext, options.candidate);
         if (refreshedCandidate === null) {
             return await createStaleCandidateSkipResult(readyReadContext.localState.state);

package/dist/wallet/mining/runner.js

@@ -27,6 +27,7 @@ import { createInsufficientFundsMiningPublishErrorMessage as createInsufficientF
 import { runMiningPhaseMachine } from "./cycle.js";
 import { attemptSaveMempool, handleDetectedMiningRuntimeResume, handleRecoverableMiningBitcoindFailure, isRecoverableMiningBitcoindError, refreshAndSaveMiningRuntimeStatus, resetMiningBitcoindRecoveryState, saveStopSnapshot, } from "./lifecycle.js";
 import { compareLexicographically, deriveMiningWordIndices, getBlockRewardCogtoshi, numberToSats, resolveBip39WordsFromIndices, rootDomain, tieBreakHash, } from "./engine-utils.js";
+import { resolveReadyMiningReadContext } from "./engine-types.js";
 import { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 import { clearMiningPublishState, miningPublishIsInMempool, miningPublishMayStillExist, normalizeMiningPublishState, normalizeMiningStateRecord, } from "./state.js";
 import { runForegroundMining as runForegroundMiningSupervisor, } from "./supervisor.js";
@@ -292,9 +293,20 @@ async function performMiningCycle(options) {
         }
         const displaySats = await resolveFundingDisplaySats(effectiveReadContext.localState.state, rpc).catch(() => null);
         syncMiningVisualizerBalances(options.loopState, effectiveReadContext, displaySats);
-        if (effectiveReadContext.localState.state.miningState.state === "repair-required") {
+        const readyReadContext = resolveReadyMiningReadContext(effectiveReadContext);
+        if (readyReadContext === null) {
             clearMiningProviderWait(options.loopState);
             await saveCycleStatus(effectiveReadContext, {
+                runMode: options.runMode,
+                currentPhase: "waiting-indexer",
+                lastError: null,
+                note: "Mining is waiting for Bitcoin Core and the indexer to align.",
+            });
+            return;
+        }
+        if (readyReadContext.localState.state.miningState.state === "repair-required") {
+            clearMiningProviderWait(options.loopState);
+            await saveCycleStatus(readyReadContext, {
                 runMode: options.runMode,
                 currentPhase: "waiting",
                 lastError: null,
@@ -302,9 +314,9 @@ async function performMiningCycle(options) {
             });
             return;
         }
-        if (hasBlockingMutation(effectiveReadContext.localState.state)) {
+        if (hasBlockingMutation(readyReadContext.localState.state)) {
             clearMiningProviderWait(options.loopState);
-            const nextState = defaultMiningStatePatch(effectiveReadContext.localState.state, {
+            const nextState = defaultMiningStatePatch(readyReadContext.localState.state, {
                 state: "paused",
                 pauseReason: "wallet-busy",
             });
@@ -313,15 +325,15 @@ async function performMiningCycle(options) {
                 provider: options.provider,
                 paths: options.paths,
             });
-            effectiveReadContext = {
-                ...effectiveReadContext,
+            const blockedReadContext = {
+                ...readyReadContext,
                 localState: {
-                    ...effectiveReadContext.localState,
+                    ...readyReadContext.localState,
                     availability: "ready",
                     state: nextState,
                 },
             };
-            await saveCycleStatus(effectiveReadContext, {
+            await saveCycleStatus(blockedReadContext, {
                 runMode: options.runMode,
                 currentPhase: "waiting",
                 lastError: null,
@@ -332,9 +344,9 @@ async function performMiningCycle(options) {
         const preemptionRequest = await readMiningPreemptionRequest(options.paths);
         if (preemptionRequest !== null) {
             clearMiningProviderWait(options.loopState);
-            const nextState = defaultMiningStatePatch(effectiveReadContext.localState.state, {
-                state: effectiveReadContext.localState.state.miningState.livePublishInMempool
-                    && effectiveReadContext.localState.state.miningState.state === "paused-stale"
+            const nextState = defaultMiningStatePatch(readyReadContext.localState.state, {
+                state: readyReadContext.localState.state.miningState.livePublishInMempool
+                    && readyReadContext.localState.state.miningState.state === "paused-stale"
                     ? "paused-stale"
                     : "paused",
                 pauseReason: preemptionRequest.reason,
@@ -345,9 +357,9 @@ async function performMiningCycle(options) {
                 paths: options.paths,
             });
             await saveCycleStatus({
-                ...effectiveReadContext,
+                ...readyReadContext,
                 localState: {
-                    ...effectiveReadContext.localState,
+                    ...readyReadContext.localState,
                     state: nextState,
                 },
             }, {
@@ -370,10 +382,10 @@ async function performMiningCycle(options) {
             network: networkInfo,
             mempool: mempoolInfo,
         });
-        clearRecoveredBitcoindError = resetMiningBitcoindRecoveryState(options.loopState, effectiveReadContext.nodeStatus?.serviceStatus ?? { pid: service.pid });
+        clearRecoveredBitcoindError = resetMiningBitcoindRecoveryState(options.loopState, readyReadContext.nodeStatus?.serviceStatus ?? { pid: service.pid });
         if (targetBlockHeight !== null && getBlockRewardCogtoshi(targetBlockHeight) === 0n) {
             clearMiningProviderWait(options.loopState);
-            const nextState = defaultMiningStatePatch(effectiveReadContext.localState.state, {
+            const nextState = defaultMiningStatePatch(readyReadContext.localState.state, {
                 state: "paused",
                 pauseReason: "zero-reward",
             });
@@ -383,9 +395,9 @@ async function performMiningCycle(options) {
                 paths: options.paths,
             });
             await saveCycleStatus({
-                ...effectiveReadContext,
+                ...readyReadContext,
                 localState: {
-                    ...effectiveReadContext.localState,
+                    ...readyReadContext.localState,
                     state: nextState,
                 },
             }, {
@@ -397,7 +409,7 @@ async function performMiningCycle(options) {
             });
             await appendEvent(options.paths, createEvent("publish-skipped-zero-reward", "Skipped mining because the target block reward is zero.", {
                 targetBlockHeight,
-                referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                referencedBlockHashDisplay: readyReadContext.nodeStatus?.nodeBestHashHex ?? null,
                 runId: options.backgroundWorkerRunId,
             }));
             return;
@@ -409,7 +421,7 @@ async function performMiningCycle(options) {
             paths: options.paths,
             runMode: options.runMode,
             backgroundWorkerRunId: options.backgroundWorkerRunId,
-            readContext: effectiveReadContext,
+            readContext: readyReadContext,
             rpc,
             targetBlockHeight,
             tipKey,

package/dist/wallet/mining/visualizer-sync.js

@@ -1,8 +1,9 @@
 import { getBalance, getBlockWinners, lookupDomainById, } from "@cogcoin/indexer/queries";
 import { displayToInternalBlockhash } from "@cogcoin/scoring";
 import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-times.js";
+import { readFundingBalanceSummary } from "../read/local-state.js";
 import { buildMiningTipKey, resetMiningUiForTip } from "./engine-state.js";
-import { deriveMiningWordIndices, numberToSats, resolveBip39WordsFromIndices, } from "./engine-utils.js";
+import { deriveMiningWordIndices, resolveBip39WordsFromIndices, } from "./engine-utils.js";
 import { createEmptyMiningFollowVisualizerState } from "./visualizer.js";
 function cloneSettledBoardEntries(entries) {
     return entries.map((entry) => ({
@@ -156,14 +157,11 @@ export function syncMiningUiForCurrentTip(options) {
     };
 }
 export async function resolveFundingDisplaySats(state, rpc) {
-    const utxos = await rpc.listUnspent(state.managedCoreWallet.walletName, 0);
-    return utxos.reduce((sum, entry) => {
-        if (entry.scriptPubKey !== state.funding.scriptPubKeyHex
-            || entry.spendable === false) {
-            return sum;
-        }
-        return sum + numberToSats(entry.amount);
-    }, 0n);
+    const summary = await readFundingBalanceSummary({
+        state,
+        rpc,
+    });
+    return summary.fundingDisplaySats ?? 0n;
 }
 export async function loadMiningVisibleFollowBlockTimes(options) {
     if (options.indexedTipHeight === null || options.indexedTipHashHex === null) {

package/dist/wallet/mining/visualizer.js

@@ -3,6 +3,7 @@ import { centerLine, normalizeInlineText, truncateLine } from "../../bitcoind/pr
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "../../bitcoind/progress/render-policy.js";
 import { TtyProgressRenderer } from "../../bitcoind/progress/tty-renderer.js";
+import { resolveWaitingProviderNote } from "./projection.js";
 const MINING_ARTWORK_COG_WIDTH = 22;
 const MINING_SENTENCE_BOARD_SIZE = 5;
 const MINING_SENTENCE_BOARD_WRAP_WIDTH = 80;
@@ -64,9 +65,6 @@ function formatRewardCogAmount(value) {
         minFractionDigits: 1,
     })} COG`;
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function consumeWrappedLine(text, capacity) {
     const remaining = text.trimStart();
     if (remaining.length <= capacity) {
@@ -91,12 +89,16 @@ function consumeWrappedLine(text, capacity) {
 function highlightRequiredWords(sentence, requiredWords) {
     const uniqueWords = [...new Set(requiredWords
             .map((word) => word.trim().toLowerCase())
-            .filter((word) => word.length > 0))].sort((left, right) => right.length - left.length);
+            .filter((word) => word.length > 0))];
     if (uniqueWords.length === 0) {
         return sentence;
     }
-    const pattern = new RegExp(`\\b(?:${uniqueWords.map(escapeRegExp).join("|")})\\b`, "gi");
-    return sentence.replace(pattern, (match) => match.toUpperCase());
+    return sentence.replace(/[A-Za-z]+/g, (match) => {
+        const normalizedToken = match.toLowerCase();
+        return uniqueWords.some((word) => normalizedToken.includes(word))
+            ? match.toUpperCase()
+            : match;
+    });
 }
 function formatSentenceSlot(prefix, sentence, requiredWords, lineCount) {
     if (sentence === null) {
@@ -281,7 +283,7 @@ export function describeMiningVisualizerProgress(snapshot) {
         case "resuming":
             return "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health.";
         case "waiting-provider":
-            return "Mining is waiting for the sentence provider to recover.";
+            return resolveWaitingProviderNote(snapshot.providerState);
         case "waiting-indexer":
             return "Mining is waiting for Bitcoin Core and the indexer to align.";
         case "waiting-bitcoin-network":

package/dist/wallet/read/context.d.ts

@@ -1,14 +1,8 @@
-import { readSnapshotWithRetry } from "../../bitcoind/indexer-daemon.js";
+export { readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { WalletLocalStateStatus, WalletReadContext } from "./types.js";
+import { inspectWalletLocalState } from "./local-state.js";
+import type { WalletReadContext } from "./types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
-declare function inspectWalletLocalState(options?: {
-    dataDir?: string;
-    secretProvider?: WalletSecretProvider;
-    now?: number;
-    paths?: WalletRuntimePaths;
-    walletControlLockHeld?: boolean;
-}): Promise<WalletLocalStateStatus>;
 export declare function openWalletReadContext(options: {
     dataDir: string;
     databasePath: string;
@@ -19,4 +13,4 @@ export declare function openWalletReadContext(options: {
     now?: number;
     paths?: WalletRuntimePaths;
 }): Promise<WalletReadContext>;
-export { inspectWalletLocalState, readSnapshotWithRetry, };
+export { inspectWalletLocalState, };