@cogcoin/client 1.1.9 → 1.1.11

package/dist/bitcoind/indexer-daemon-main.js

@@ -1,23 +1,7 @@
-import { randomUUID } from "node:crypto";
-import net from "node:net";
-import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
-import { loadBundledGenesisParameters, serializeIndexerState } from "@cogcoin/indexer";
-import { openManagedBitcoindClientInternal } from "./client.js";
-import { DEFAULT_SNAPSHOT_METADATA } from "./bootstrap.js";
-import { openClient } from "../client.js";
 import { readPackageVersionFromDisk } from "../package-version.js";
-import { openSqliteStore } from "../sqlite/index.js";
-import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
-import { createRpcClient } from "./node.js";
-import { normalizeCogcoinProcessingStartHeight } from "./processing-start-height.js";
-import { createBootstrapProgress } from "./progress/formatting.js";
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
-import { INDEXER_DAEMON_SCHEMA_VERSION, INDEXER_DAEMON_SERVICE_API_VERSION, } from "./types.js";
-const SNAPSHOT_TTL_MS = 30_000;
-const HEARTBEAT_INTERVAL_MS = 1_000;
-const FORCE_RESUME_ERROR_ENV = "COGCOIN_TEST_INDEXER_DAEMON_FORCE_RESUME_ERROR";
-const BACKGROUND_FOLLOW_RESUME_TIMEOUT_MS = 30_000;
-const BACKGROUND_FOLLOW_RESUME_TIMEOUT_ERROR = "indexer_daemon_background_follow_resume_timeout";
+import { createIndexerDaemonRuntime } from "./indexer-daemon/runtime.js";
 function parseArg(name) {
     const prefix = `--${name}=`;
     const value = process.argv.find((entry) => entry.startsWith(prefix));
@@ -26,653 +10,26 @@ function parseArg(name) {
     }
     return value.slice(prefix.length);
 }
-async function readJsonFile(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-async function readManagedBitcoindStatus(paths) {
-    return readJsonFile(paths.bitcoindStatusPath);
-}
-async function withTimeout(promise, timeoutMs, errorCode) {
-    let timeoutId = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timeoutId = setTimeout(() => reject(new Error(errorCode)), timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeoutId !== null) {
-            clearTimeout(timeoutId);
-        }
-    }
-}
-function createSnapshotKey(appliedTip) {
-    return appliedTip === null
-        ? "__null__"
-        : [
-            appliedTip.height,
-            appliedTip.blockHashHex,
-            appliedTip.stateHashHex ?? "",
-        ].join(":");
-}
-function createManagedBitcoindCookieUnavailableMessage(cookieFile) {
-    return `The managed Bitcoin RPC cookie file is unavailable at ${cookieFile} while preparing getblockchaininfo. The managed node is not running or is shutting down.`;
-}
-async function readCoreTipStatus(paths) {
-    const runtimeConfig = await readJsonFile(paths.bitcoindRuntimeConfigPath).catch(() => null);
-    if (runtimeConfig?.rpc === undefined || runtimeConfig.rpc === null) {
-        return {
-            rpcReachable: false,
-            coreBestHeight: null,
-            coreBestHash: null,
-            error: "managed_bitcoind_runtime_config_unavailable",
-            prerequisiteUnavailable: true,
-        };
-    }
-    try {
-        await access(runtimeConfig.rpc.cookieFile, constants.R_OK);
-    }
-    catch {
-        return {
-            rpcReachable: false,
-            coreBestHeight: null,
-            coreBestHash: null,
-            error: createManagedBitcoindCookieUnavailableMessage(runtimeConfig.rpc.cookieFile),
-            prerequisiteUnavailable: true,
-        };
-    }
-    try {
-        const rpc = createRpcClient(runtimeConfig.rpc);
-        const info = await rpc.getBlockchainInfo();
-        return {
-            rpcReachable: true,
-            coreBestHeight: info.blocks,
-            coreBestHash: info.bestblockhash,
-            error: null,
-            prerequisiteUnavailable: false,
-        };
-    }
-    catch (error) {
-        return {
-            rpcReachable: false,
-            coreBestHeight: null,
-            coreBestHash: null,
-            error: error instanceof Error ? error.message : String(error),
-            prerequisiteUnavailable: false,
-        };
-    }
-}
-async function readAppliedTipStatus(databasePath) {
-    try {
-        const store = await openSqliteStore({ filename: databasePath });
-        try {
-            const client = await openClient({ store });
-            try {
-                return {
-                    appliedTip: await client.getTip(),
-                    error: null,
-                    schemaMismatch: false,
-                };
-            }
-            finally {
-                await client.close();
-            }
-        }
-        finally {
-            await store.close().catch(() => undefined);
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            appliedTip: null,
-            error: message,
-            schemaMismatch: message === "sqlite_store_schema_version_unsupported",
-        };
-    }
-}
-async function loadSnapshot(databasePath) {
-    const store = await openSqliteStore({ filename: databasePath });
-    try {
-        const client = await openClient({ store });
-        try {
-            const [tip, state] = await Promise.all([client.getTip(), client.getState()]);
-            return {
-                token: randomUUID(),
-                stateBase64: Buffer.from(serializeIndexerState(state)).toString("base64"),
-                tip,
-                expiresAtUnixMs: Date.now() + SNAPSHOT_TTL_MS,
-            };
-        }
-        finally {
-            await client.close();
-        }
-    }
-    finally {
-        await store.close().catch(() => undefined);
-    }
-}
 async function main() {
     const dataDir = parseArg("data-dir");
     const databasePath = parseArg("database-path");
     const walletRootId = parseArg("wallet-root-id") || UNINITIALIZED_WALLET_ROOT_ID;
     const paths = resolveManagedServicePaths(dataDir, walletRootId);
-    const daemonInstanceId = randomUUID();
-    const binaryVersion = await readPackageVersionFromDisk().catch(() => "0.0.0");
-    const genesisParameters = await loadBundledGenesisParameters();
-    const startedAtUnixMs = Date.now();
-    const snapshots = new Map();
-    let state = "starting";
-    let heartbeatAtUnixMs = startedAtUnixMs;
-    let updatedAtUnixMs = startedAtUnixMs;
-    let rpcReachable = false;
-    let coreBestHeight = null;
-    let coreBestHash = null;
-    let appliedTipHeight = null;
-    let appliedTipHash = null;
-    let snapshotSeqCounter = 0;
-    let snapshotSeq = null;
-    let lastSnapshotKey;
-    let lastAppliedAtUnixMs = null;
-    let lastError = null;
-    let hasSuccessfulCoreTipRefresh = false;
-    let backgroundStore = null;
-    let backgroundClient = null;
-    let backgroundResumePromise = null;
-    let backgroundFollowError = null;
-    let backgroundFollowActive = false;
-    let bootstrapPhase = "paused";
-    let bootstrapProgress = createBootstrapProgress("paused", DEFAULT_SNAPSHOT_METADATA);
-    let cogcoinSyncHeight = null;
-    let cogcoinSyncTargetHeight = null;
-    await mkdir(paths.indexerServiceRoot, { recursive: true });
-    await rm(paths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
-    const observeAppliedTip = (appliedTip, now) => {
-        appliedTipHeight = appliedTip?.height ?? null;
-        appliedTipHash = appliedTip?.blockHashHex ?? null;
-        const snapshotKey = createSnapshotKey(appliedTip);
-        if (lastSnapshotKey !== snapshotKey) {
-            snapshotSeqCounter += 1;
-            snapshotSeq = String(snapshotSeqCounter);
-            lastSnapshotKey = snapshotKey;
-            lastAppliedAtUnixMs = now;
-        }
-    };
-    const deriveLeaseState = (coreStatus, appliedTip) => {
-        if (coreStatus.error !== null) {
-            return {
-                state: coreStatus.prerequisiteUnavailable && !hasSuccessfulCoreTipRefresh ? "starting" : "failed",
-                lastError: coreStatus.error,
-            };
-        }
-        hasSuccessfulCoreTipRefresh = true;
-        if (coreStatus.coreBestHeight !== null
-            && appliedTip?.height !== undefined
-            && coreStatus.coreBestHash !== null
-            && appliedTip?.blockHashHex !== undefined) {
-            return {
-                state: coreStatus.coreBestHeight === appliedTip.height && coreStatus.coreBestHash === appliedTip.blockHashHex
-                    ? "synced"
-                    : "catching-up",
-                lastError: null,
-            };
-        }
-        return {
-            state: "starting",
-            lastError: null,
-        };
-    };
-    const buildStatus = () => ({
-        serviceApiVersion: INDEXER_DAEMON_SERVICE_API_VERSION,
-        binaryVersion,
-        buildId: null,
-        updatedAtUnixMs,
+    const runtime = createIndexerDaemonRuntime({
+        dataDir,
+        databasePath,
         walletRootId,
-        daemonInstanceId,
-        schemaVersion: INDEXER_DAEMON_SCHEMA_VERSION,
-        state,
-        processId: process.pid ?? null,
-        startedAtUnixMs,
-        heartbeatAtUnixMs,
-        ipcReady: true,
-        rpcReachable,
-        coreBestHeight,
-        coreBestHash,
-        appliedTipHeight,
-        appliedTipHash,
-        snapshotSeq,
-        backlogBlocks: coreBestHeight === null || appliedTipHeight === null
-            ? null
-            : Math.max(coreBestHeight - appliedTipHeight, 0),
-        reorgDepth: null,
-        lastAppliedAtUnixMs,
-        activeSnapshotCount: snapshots.size,
-        lastError,
-        backgroundFollowActive,
-        bootstrapPhase,
-        bootstrapProgress: { ...bootstrapProgress },
-        cogcoinSyncHeight,
-        cogcoinSyncTargetHeight,
+        paths,
+        binaryVersion: await readPackageVersionFromDisk().catch(() => "0.0.0"),
+        genesisParameters: await loadBundledGenesisParameters(),
     });
-    const writeStatus = async () => {
-        const status = buildStatus();
-        await writeRuntimeStatusFile(paths.indexerDaemonStatusPath, status);
-        return status;
-    };
-    const recordBackgroundFollowFailure = async (message) => {
-        const now = Date.now();
-        heartbeatAtUnixMs = now;
-        updatedAtUnixMs = now;
-        state = "failed";
-        lastError = message;
-        backgroundFollowError = message;
-        backgroundFollowActive = false;
-        bootstrapPhase = "error";
-        bootstrapProgress = {
-            ...createBootstrapProgress("error", DEFAULT_SNAPSHOT_METADATA),
-            blocks: coreBestHeight,
-            headers: coreBestHeight,
-            targetHeight: coreBestHeight,
-            message,
-            lastError: message,
-            updatedAt: now,
-        };
-        cogcoinSyncHeight = appliedTipHeight;
-        cogcoinSyncTargetHeight = coreBestHeight;
-        await writeStatus();
-    };
-    const refreshStatus = async () => {
-        const now = Date.now();
-        heartbeatAtUnixMs = now;
-        updatedAtUnixMs = now;
-        const [coreStatus, indexedStatus] = await Promise.all([
-            readCoreTipStatus(paths),
-            readAppliedTipStatus(databasePath),
-        ]);
-        const backgroundStatus = await backgroundClient?.getNodeStatus().catch(() => null) ?? null;
-        if (backgroundStatus?.following === true) {
-            backgroundFollowError = null;
-        }
-        rpcReachable = coreStatus.rpcReachable;
-        coreBestHeight = coreStatus.coreBestHeight;
-        coreBestHash = coreStatus.coreBestHash;
-        observeAppliedTip(indexedStatus.appliedTip, now);
-        backgroundFollowActive = backgroundStatus?.following ?? (backgroundClient !== null);
-        bootstrapPhase = backgroundStatus?.bootstrapPhase ?? (backgroundFollowActive ? "follow_tip" : "paused");
-        bootstrapProgress = backgroundStatus?.bootstrapProgress ?? createBootstrapProgress(bootstrapPhase, DEFAULT_SNAPSHOT_METADATA);
-        cogcoinSyncHeight = backgroundStatus?.cogcoinSyncHeight ?? indexedStatus.appliedTip?.height ?? null;
-        cogcoinSyncTargetHeight = backgroundStatus?.cogcoinSyncTargetHeight ?? coreStatus.coreBestHeight;
-        if (backgroundStatus === null && backgroundFollowError !== null) {
-            state = "failed";
-            lastError = backgroundFollowError;
-            backgroundFollowActive = false;
-            bootstrapPhase = "error";
-            bootstrapProgress = {
-                ...createBootstrapProgress("error", DEFAULT_SNAPSHOT_METADATA),
-                blocks: coreStatus.coreBestHeight,
-                headers: coreStatus.coreBestHeight,
-                targetHeight: coreStatus.coreBestHeight,
-                message: backgroundFollowError,
-                lastError: backgroundFollowError,
-                updatedAt: now,
-            };
-            cogcoinSyncHeight = indexedStatus.appliedTip?.height ?? null;
-            cogcoinSyncTargetHeight = coreStatus.coreBestHeight;
-            return writeStatus();
-        }
-        if (indexedStatus.schemaMismatch) {
-            state = "schema-mismatch";
-            lastError = indexedStatus.error;
-            bootstrapPhase = "error";
-            bootstrapProgress = {
-                ...bootstrapProgress,
-                phase: "error",
-                message: indexedStatus.error ?? "Indexer schema mismatch.",
-                lastError: indexedStatus.error,
-                updatedAt: now,
-            };
-            return writeStatus();
-        }
-        if (indexedStatus.error !== null) {
-            state = "failed";
-            lastError = indexedStatus.error;
-            bootstrapPhase = "error";
-            bootstrapProgress = {
-                ...bootstrapProgress,
-                phase: "error",
-                message: indexedStatus.error,
-                lastError: indexedStatus.error,
-                updatedAt: now,
-            };
-            return writeStatus();
-        }
-        const leaseState = deriveLeaseState(coreStatus, indexedStatus.appliedTip);
-        state = leaseState.state;
-        lastError = leaseState.lastError;
-        if (lastError !== null) {
-            bootstrapPhase = leaseState.state === "starting" ? "paused" : "error";
-            bootstrapProgress = {
-                ...bootstrapProgress,
-                phase: bootstrapPhase,
-                message: lastError,
-                lastError,
-                updatedAt: now,
-            };
-        }
-        else if (backgroundStatus === null) {
-            bootstrapPhase = leaseState.state === "synced" ? "follow_tip" : "paused";
-            bootstrapProgress = {
-                ...createBootstrapProgress(bootstrapPhase, DEFAULT_SNAPSHOT_METADATA),
-                blocks: coreStatus.coreBestHeight,
-                headers: coreStatus.coreBestHeight,
-                targetHeight: coreStatus.coreBestHeight,
-                updatedAt: now,
-            };
-            cogcoinSyncHeight = indexedStatus.appliedTip?.height ?? null;
-            cogcoinSyncTargetHeight = coreStatus.coreBestHeight;
-        }
-        return writeStatus();
-    };
-    const pauseBackgroundFollow = async () => {
-        const pendingResume = backgroundResumePromise;
-        backgroundResumePromise = null;
-        await pendingResume?.catch(() => undefined);
-        const client = backgroundClient;
-        const store = backgroundStore;
-        backgroundClient = null;
-        backgroundStore = null;
-        await client?.close().catch(() => undefined);
-        await store?.close().catch(() => undefined);
-        backgroundFollowError = null;
-        backgroundFollowActive = false;
-        bootstrapPhase = "paused";
-        bootstrapProgress = createBootstrapProgress("paused", DEFAULT_SNAPSHOT_METADATA);
-        cogcoinSyncHeight = appliedTipHeight;
-        cogcoinSyncTargetHeight = coreBestHeight;
-    };
-    const resumeBackgroundFollow = async () => {
-        if (backgroundClient !== null) {
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown) {
             return;
         }
-        if (backgroundResumePromise !== null) {
-            return backgroundResumePromise;
-        }
-        backgroundResumePromise = (async () => {
-            let store = null;
-            try {
-                const forcedResumeError = process.env[FORCE_RESUME_ERROR_ENV]?.trim();
-                if (forcedResumeError) {
-                    throw new Error(forcedResumeError);
-                }
-                const bitcoindStatus = await readManagedBitcoindStatus(paths);
-                store = await openSqliteStore({ filename: databasePath });
-                const openedStore = store;
-                const chain = bitcoindStatus?.chain ?? "main";
-                const startHeight = normalizeCogcoinProcessingStartHeight({
-                    chain,
-                    startHeight: bitcoindStatus?.startHeight,
-                    genesisParameters,
-                });
-                const client = await openManagedBitcoindClientInternal({
-                    store: openedStore,
-                    dataDir,
-                    chain,
-                    startHeight,
-                    walletRootId,
-                    progressOutput: "none",
-                });
-                backgroundStore = openedStore;
-                backgroundClient = client;
-                backgroundFollowError = null;
-                backgroundFollowActive = true;
-                void client.startFollowingTip().catch(async (error) => {
-                    if (backgroundClient !== client || backgroundStore !== openedStore) {
-                        return;
-                    }
-                    backgroundClient = null;
-                    backgroundStore = null;
-                    backgroundFollowActive = false;
-                    await client.close().catch(() => undefined);
-                    await openedStore.close().catch(() => undefined);
-                    const message = error instanceof Error ? error.message : String(error);
-                    await recordBackgroundFollowFailure(message).catch(() => undefined);
-                });
-            }
-            catch (error) {
-                await store?.close().catch(() => undefined);
-                const message = error instanceof Error ? error.message : String(error);
-                await recordBackgroundFollowFailure(message).catch(() => undefined);
-                throw error;
-            }
-        })();
-        try {
-            await backgroundResumePromise;
-        }
-        finally {
-            backgroundResumePromise = null;
-        }
-    };
-    const heartbeat = setInterval(() => {
-        void refreshStatus().catch(() => undefined);
-        const now = Date.now();
-        for (const [token, snapshot] of snapshots.entries()) {
-            if (snapshot.expiresAtUnixMs <= now) {
-                snapshots.delete(token);
-                void writeStatus();
-            }
-        }
-    }, HEARTBEAT_INTERVAL_MS);
-    heartbeat.unref();
-    const server = net.createServer((socket) => {
-        let buffer = "";
-        const writeResponse = (response) => {
-            socket.write(`${JSON.stringify(response)}\n`);
-        };
-        socket.on("data", (chunk) => {
-            buffer += chunk.toString("utf8");
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex >= 0) {
-                const line = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
-                if (line.trim().length === 0) {
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                let request;
-                try {
-                    request = JSON.parse(line);
-                }
-                catch (error) {
-                    writeResponse({
-                        id: "invalid",
-                        ok: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                void (async () => {
-                    try {
-                        if (request.method === "GetStatus") {
-                            writeResponse({
-                                id: request.id,
-                                ok: true,
-                                result: buildStatus(),
-                            });
-                            return;
-                        }
-                        if (request.method === "OpenSnapshot") {
-                            const [snapshotMaterial, coreStatus] = await Promise.all([
-                                loadSnapshot(databasePath),
-                                readCoreTipStatus(paths),
-                            ]);
-                            const now = Date.now();
-                            heartbeatAtUnixMs = now;
-                            updatedAtUnixMs = now;
-                            rpcReachable = coreStatus.rpcReachable;
-                            coreBestHeight = coreStatus.coreBestHeight;
-                            coreBestHash = coreStatus.coreBestHash;
-                            observeAppliedTip(snapshotMaterial.tip, now);
-                            const leaseState = deriveLeaseState(coreStatus, snapshotMaterial.tip);
-                            state = leaseState.state;
-                            lastError = leaseState.lastError;
-                            const snapshot = {
-                                ...snapshotMaterial,
-                                serviceApiVersion: INDEXER_DAEMON_SERVICE_API_VERSION,
-                                schemaVersion: INDEXER_DAEMON_SCHEMA_VERSION,
-                                walletRootId,
-                                daemonInstanceId,
-                                processId: process.pid ?? null,
-                                startedAtUnixMs,
-                                snapshotSeq,
-                                tipHeight: snapshotMaterial.tip?.height ?? null,
-                                tipHash: snapshotMaterial.tip?.blockHashHex ?? null,
-                                openedAtUnixMs: now,
-                            };
-                            snapshots.set(snapshot.token, snapshot);
-                            const leaseStatus = await writeStatus();
-                            const result = {
-                                token: snapshot.token,
-                                expiresAtUnixMs: snapshot.expiresAtUnixMs,
-                                serviceApiVersion: snapshot.serviceApiVersion,
-                                binaryVersion,
-                                buildId: null,
-                                walletRootId: snapshot.walletRootId,
-                                daemonInstanceId: snapshot.daemonInstanceId,
-                                schemaVersion: snapshot.schemaVersion,
-                                processId: snapshot.processId,
-                                startedAtUnixMs: snapshot.startedAtUnixMs,
-                                state: leaseStatus.state,
-                                heartbeatAtUnixMs: leaseStatus.heartbeatAtUnixMs,
-                                rpcReachable: leaseStatus.rpcReachable,
-                                coreBestHeight: leaseStatus.coreBestHeight,
-                                coreBestHash: leaseStatus.coreBestHash,
-                                appliedTipHeight: leaseStatus.appliedTipHeight,
-                                appliedTipHash: leaseStatus.appliedTipHash,
-                                snapshotSeq: snapshot.snapshotSeq,
-                                backlogBlocks: leaseStatus.backlogBlocks,
-                                reorgDepth: leaseStatus.reorgDepth,
-                                lastAppliedAtUnixMs: leaseStatus.lastAppliedAtUnixMs,
-                                activeSnapshotCount: leaseStatus.activeSnapshotCount,
-                                lastError: leaseStatus.lastError,
-                                backgroundFollowActive: leaseStatus.backgroundFollowActive ?? false,
-                                bootstrapPhase: leaseStatus.bootstrapPhase ?? null,
-                                bootstrapProgress: leaseStatus.bootstrapProgress ?? null,
-                                cogcoinSyncHeight: leaseStatus.cogcoinSyncHeight ?? null,
-                                cogcoinSyncTargetHeight: leaseStatus.cogcoinSyncTargetHeight ?? null,
-                                tipHeight: snapshot.tipHeight,
-                                tipHash: snapshot.tipHash,
-                                openedAtUnixMs: snapshot.openedAtUnixMs,
-                            };
-                            writeResponse({
-                                id: request.id,
-                                ok: true,
-                                result,
-                            });
-                            return;
-                        }
-                        if (request.method === "ReadSnapshot") {
-                            const snapshot = request.token ? snapshots.get(request.token) : null;
-                            if (!snapshot || snapshot.expiresAtUnixMs <= Date.now()) {
-                                if (request.token) {
-                                    snapshots.delete(request.token);
-                                    await writeStatus();
-                                }
-                                throw new Error("indexer_daemon_snapshot_invalid");
-                            }
-                            if (snapshot.snapshotSeq !== snapshotSeq) {
-                                snapshots.delete(snapshot.token);
-                                await writeStatus();
-                                throw new Error("indexer_daemon_snapshot_rotated");
-                            }
-                            const result = {
-                                token: snapshot.token,
-                                stateBase64: snapshot.stateBase64,
-                                serviceApiVersion: snapshot.serviceApiVersion,
-                                schemaVersion: snapshot.schemaVersion,
-                                walletRootId: snapshot.walletRootId,
-                                daemonInstanceId: snapshot.daemonInstanceId,
-                                processId: snapshot.processId,
-                                startedAtUnixMs: snapshot.startedAtUnixMs,
-                                snapshotSeq: snapshot.snapshotSeq,
-                                tipHeight: snapshot.tipHeight,
-                                tipHash: snapshot.tipHash,
-                                openedAtUnixMs: snapshot.openedAtUnixMs,
-                                tip: snapshot.tip,
-                                expiresAtUnixMs: snapshot.expiresAtUnixMs,
-                            };
-                            writeResponse({
-                                id: request.id,
-                                ok: true,
-                                result,
-                            });
-                            return;
-                        }
-                        if (request.method === "CloseSnapshot") {
-                            if (request.token) {
-                                snapshots.delete(request.token);
-                                await writeStatus();
-                            }
-                            writeResponse({
-                                id: request.id,
-                                ok: true,
-                                result: null,
-                            });
-                            return;
-                        }
-                        if (request.method === "ResumeBackgroundFollow") {
-                            try {
-                                await withTimeout(resumeBackgroundFollow(), BACKGROUND_FOLLOW_RESUME_TIMEOUT_MS, BACKGROUND_FOLLOW_RESUME_TIMEOUT_ERROR);
-                            }
-                            catch (error) {
-                                if (error instanceof Error
-                                    && error.message === BACKGROUND_FOLLOW_RESUME_TIMEOUT_ERROR) {
-                                    await recordBackgroundFollowFailure(error.message).catch(() => undefined);
-                                }
-                                throw error;
-                            }
-                            writeResponse({
-                                id: request.id,
-                                ok: true,
-                                result: null,
-                            });
-                            return;
-                        }
-                        throw new Error(`indexer_daemon_unknown_method_${request.method}`);
-                    }
-                    catch (error) {
-                        writeResponse({
-                            id: request.id,
-                            ok: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                })();
-                newlineIndex = buffer.indexOf("\n");
-            }
-        });
-    });
-    const shutdown = async () => {
-        clearInterval(heartbeat);
-        await pauseBackgroundFollow().catch(() => undefined);
-        state = "stopping";
-        heartbeatAtUnixMs = Date.now();
-        updatedAtUnixMs = heartbeatAtUnixMs;
-        await writeStatus().catch(() => undefined);
-        await new Promise((resolve) => {
-            server.close(() => resolve());
-        });
-        await rm(paths.indexerDaemonSocketPath, { force: true }).catch(() => undefined);
+        shuttingDown = true;
+        await runtime.shutdown().catch(() => undefined);
         process.exit(0);
     };
     process.on("SIGTERM", () => {
@@ -681,14 +38,6 @@ async function main() {
     process.on("SIGINT", () => {
         void shutdown();
     });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(paths.indexerDaemonSocketPath, async () => {
-            server.off("error", reject);
-            await writeStatus();
-            await refreshStatus().catch(() => undefined);
-            resolve();
-        });
-    });
+    await runtime.start();
 }
 await main();