@fibscope/agent 0.1.0

package/lib/pulse/engine.mjs

@@ -0,0 +1,21 @@
+import { analyzeFiberState, calculatePaymentReadiness } from "./intelligence.mjs";
+import { collectFiberSnapshot } from "./snapshot.mjs";
+
+export * from "./snapshot.mjs";
+export * from "./intelligence.mjs";
+
+export async function collectFiberStateReport(providerOrOptions, maybeOptions = {}) {
+  const provider = isProvider(providerOrOptions) ? providerOrOptions : undefined;
+  const options = isProvider(providerOrOptions) ? maybeOptions : (providerOrOptions ?? maybeOptions);
+  const snapshot = await collectFiberSnapshot(provider ?? options, provider ? options : undefined);
+  return analyzeFiberState(snapshot, options);
+}
+
+export async function getPaymentReadiness(amount, providerOrOptions, maybeOptions = {}) {
+  const report = await collectFiberStateReport(providerOrOptions, maybeOptions);
+  return calculatePaymentReadiness(amount, report);
+}
+
+function isProvider(value) {
+  return Boolean(value && typeof value === "object" && "getNodeInfo" in value && "getPeers" in value && "getChannels" in value);
+}

package/lib/pulse/index.mjs

@@ -0,0 +1,6 @@
+export { collectFiberStateReport, getPaymentReadiness } from "./engine.mjs";
+export { collectChannels, collectFiberSnapshot, collectNode, collectPayments, collectPeers, buildProviderCandidates, offlineSnapshot, selectActiveFiberProvider } from "./snapshot.mjs";
+export { FiberReadinessError, analyzeFiberState, calculateChannelHealth, calculateHealth, calculateLiquidity, calculateNodeHealth, calculatePaymentReadiness, calculatePeerHealth, generateDiagnostics } from "./intelligence.mjs";
+export { FiberCliProvider, FiberProviderError, FiberRpcProvider, normalizeChannels, normalizeNodeInfo, normalizePayments, normalizePeers, } from "./providers.mjs";
+export { createFiberApiServer, startFiberApiServer, } from "./server.mjs";
+//# sourceMappingURL=index.js.map

package/lib/pulse/intelligence.mjs

@@ -0,0 +1,154 @@
+export class FiberReadinessError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "FiberReadinessError";
+  }
+}
+
+export function analyzeFiberState(snapshot, options = {}) {
+  const liquidity = calculateLiquidity(snapshot.channels);
+  const report = {
+    timestamp: snapshot.timestamp,
+    provider: snapshot.provider,
+    node: snapshot.node,
+    peers: snapshot.peers,
+    channels: snapshot.channels,
+    payments: snapshot.payments ?? [],
+    liquidity,
+    health: calculateHealth(snapshot, liquidity),
+    diagnostics: [],
+  };
+  if (options.readinessAmount !== undefined) {
+    report.paymentReadiness = calculatePaymentReadiness(options.readinessAmount, report);
+  }
+  report.diagnostics = generateDiagnostics(report, {
+    ...options,
+    collectionErrors: snapshot.collectionErrors ?? [],
+  });
+  report.health = calculateHealth(snapshot, liquidity, report.diagnostics);
+  return report;
+}
+
+export function calculateLiquidity(channels) {
+  const open = channels.filter((channel) => channel.status === "open");
+  return {
+    totalOutbound: open.reduce((sum, channel) => sum + channel.localBalance, 0n),
+    totalInbound: open.reduce((sum, channel) => sum + channel.remoteBalance, 0n),
+    channelCount: open.length,
+  };
+}
+
+export function calculatePaymentReadiness(amount, reportOrLiquidity) {
+  const requested = parseAmount(amount);
+  const liquidity = "liquidity" in reportOrLiquidity ? reportOrLiquidity.liquidity : reportOrLiquidity;
+  const diagnostics = "diagnostics" in reportOrLiquidity ? reportOrLiquidity.diagnostics : [];
+  const critical = diagnostics.find((item) => item.severity === "critical" && ["NODE_OFFLINE", "NO_PEERS", "NO_CHANNELS"].includes(item.code));
+  if (critical) {
+    return { canSend: false, maxSendable: liquidity.totalOutbound, reason: critical.code };
+  }
+  if (requested > liquidity.totalOutbound) {
+    return { canSend: false, maxSendable: liquidity.totalOutbound, reason: "INSUFFICIENT_OUTBOUND_LIQUIDITY" };
+  }
+  return { canSend: true, maxSendable: liquidity.totalOutbound };
+}
+
+export function calculateHealth(snapshot, liquidity = calculateLiquidity(snapshot.channels ?? []), diagnostics = []) {
+  const node = calculateNodeHealth(snapshot.node);
+  const peers = calculatePeerHealth(snapshot.peers ?? []);
+  const channels = calculateChannelHealth(snapshot.channels ?? [], liquidity);
+  const diagnosticPenalty = diagnostics.some((item) => item.severity === "critical") ? 30 : diagnostics.some((item) => item.severity === "warning") ? 10 : 0;
+  const score = clamp(Math.round((node.score + peers.score + channels.score) / 3) - diagnosticPenalty);
+  return {
+    overall: healthScore(score),
+    node,
+    peers,
+    channels,
+  };
+}
+
+export function calculateNodeHealth(node = {}) {
+  return healthScore(node.online ? 100 : 0);
+}
+
+export function calculatePeerHealth(peers = []) {
+  if (peers.length === 0) {
+    return { ...healthScore(0), totalPeers: 0, connectedPeers: 0, offlinePeers: 0 };
+  }
+  const connectedPeers = peers.filter((peer) => peer.connected).length;
+  const score = Math.round((connectedPeers / peers.length) * 100);
+  return {
+    ...healthScore(score),
+    totalPeers: peers.length,
+    connectedPeers,
+    offlinePeers: peers.length - connectedPeers,
+  };
+}
+
+export function calculateChannelHealth(channels = [], liquidity = calculateLiquidity(channels)) {
+  if (channels.length === 0) {
+    return { ...healthScore(0), totalChannels: 0, openChannels: 0 };
+  }
+  const openChannels = channels.filter((channel) => channel.status === "open").length;
+  const openScore = Math.round((openChannels / channels.length) * 100);
+  const liquidityScore = liquidity.totalOutbound > 0n ? 100 : 30;
+  return {
+    ...healthScore(Math.round((openScore + liquidityScore) / 2)),
+    totalChannels: channels.length,
+    openChannels,
+  };
+}
+
+export function generateDiagnostics(report, options = {}) {
+  const diagnostics = [];
+  if (!report.node.online) {
+    diagnostics.push(diagnostic("NODE_OFFLINE", "critical", "FNN is not reachable", "The agent could not confirm that the local Fiber node is running or reachable through the configured RPC provider.", "Start FNN and confirm the configured Fiber RPC URL is reachable."));
+  }
+  if (report.peers.length === 0) {
+    diagnostics.push(diagnostic("NO_PEERS", "critical", "No Fiber peers", "The node has no known peers.", "Connect to a Fiber peer."));
+  } else if (report.peers.every((peer) => !peer.connected)) {
+    diagnostics.push(diagnostic("NO_CONNECTED_PEERS", "warning", "No connected Fiber peers", "Peers exist, but none are currently connected.", "Check peer addresses and network reachability."));
+  }
+  if (report.channels.length === 0) {
+    diagnostics.push(diagnostic("NO_CHANNELS", "critical", "No Fiber channels", "No channels were discovered.", "Open a channel."));
+  }
+  const threshold = options.lowOutboundThreshold === undefined ? 1n : parseAmount(options.lowOutboundThreshold);
+  if (report.channels.length > 0 && report.liquidity.totalOutbound <= threshold) {
+    diagnostics.push(diagnostic("LOW_OUTBOUND_LIQUIDITY", "warning", "Low outbound liquidity", "The node has little or no outbound liquidity available for sending payments.", "Add liquidity or rebalance."));
+  }
+  for (const failure of options.collectionErrors ?? []) {
+    diagnostics.push(diagnostic("PROVIDER_UNAVAILABLE", "warning", "Provider collection issue", `${failure.provider ?? "provider"}: ${failure.message}`, "Start FNN, expose Fiber RPC, or install/configure fnn-cli."));
+  }
+  if (diagnostics.length === 0) {
+    diagnostics.push(diagnostic("FIBER_READY", "info", "Fiber node appears payment-ready", "Peers, channels, and outbound liquidity are available."));
+  }
+  return diagnostics;
+}
+
+function healthScore(score) {
+  const normalized = clamp(score);
+  return {
+    score: normalized,
+    status: normalized >= 80 ? "healthy" : normalized >= 50 ? "warning" : "critical",
+  };
+}
+
+function clamp(value) {
+  return Math.max(0, Math.min(100, Number.isFinite(value) ? value : 0));
+}
+
+function diagnostic(code, severity, title, description, recommendation) {
+  return { code, severity, title, description, recommendation };
+}
+
+function parseAmount(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) throw new FiberReadinessError("Amount must be a non-negative finite number.", "INVALID_AMOUNT");
+    return BigInt(Math.trunc(value));
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(value)) return BigInt(value);
+  if (/^[0-9]+$/.test(value)) return BigInt(value);
+  throw new FiberReadinessError("Amount must be a decimal or 0x-prefixed integer.", "INVALID_AMOUNT", { amount: value });
+}

package/lib/pulse/providers.mjs

@@ -0,0 +1,321 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export class FiberProviderError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "FiberProviderError";
+    }
+}
+export class FiberCliProvider {
+    options;
+    kind = "cli";
+    label;
+    bin;
+    baseArgs;
+    constructor(options = {}) {
+        this.options = options;
+        this.bin = options.bin ?? "fnn-cli";
+        this.baseArgs = options.baseArgs ?? [];
+        this.label = `cli:${this.bin}`;
+    }
+    async getNodeInfo() {
+        return normalizeNodeInfo(await this.run(["info"]));
+    }
+    async getPeers() {
+        return normalizePeers(await this.run(["peer", "list_peers"]));
+    }
+    async getChannels() {
+        return normalizeChannels(await this.run(["channel", "list_channels"]));
+    }
+    async getPayments() {
+        return normalizePayments(await this.run(["payment", "list_payments"]));
+    }
+    async run(args) {
+        try {
+            const result = await execFileAsync(this.bin, [...this.baseArgs, ...args], {
+                cwd: this.options.cwd,
+                env: this.options.env ? { ...process.env, ...this.options.env } : process.env,
+                timeout: this.options.timeoutMs ?? 10_000,
+                maxBuffer: this.options.maxBuffer ?? 1024 * 1024,
+            });
+            return parseCliOutput(result.stdout);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new FiberProviderError(`Fiber CLI command failed: ${message}`, "FIBER_CLI_FAILED", { args });
+        }
+    }
+}
+export class FiberRpcProvider {
+    options;
+    kind = "rpc";
+    label;
+    methods;
+    constructor(options) {
+        this.options = options;
+        this.label = `rpc:${options.rpcUrl}`;
+        this.methods = {
+            info: options.methods?.info ?? "node_info",
+            listPeers: options.methods?.listPeers ?? "list_peers",
+            listChannels: options.methods?.listChannels ?? "list_channels",
+            listPayments: options.methods?.listPayments ?? "list_payments",
+        };
+    }
+    async getNodeInfo() {
+        return normalizeNodeInfo(await this.call(this.methods.info));
+    }
+    async getPeers() {
+        return normalizePeers(await this.call(this.methods.listPeers));
+    }
+    async getChannels() {
+        return normalizeChannels(await this.call(this.methods.listChannels, [{}]));
+    }
+    async getPayments() {
+        return normalizePayments(await this.call(this.methods.listPayments, [{}]));
+    }
+    async call(method, params = []) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 10_000);
+        try {
+            const response = await fetch(this.options.rpcUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(this.options.headers ?? {}),
+                },
+                body: JSON.stringify({ id: 1, jsonrpc: "2.0", method, params }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new FiberProviderError(`Fiber RPC HTTP ${response.status}`, "FIBER_RPC_HTTP_ERROR", { method, status: response.status });
+            }
+            const payload = await response.json();
+            if (payload.error) {
+                throw new FiberProviderError(payload.error.message ?? "Fiber RPC error", "FIBER_RPC_ERROR", { method, error: payload.error });
+            }
+            return payload.result;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+export function normalizeNodeInfo(raw) {
+    const value = unwrap(raw);
+    const now = Date.now();
+    return {
+        nodeId: stringFrom(value, ["nodeId", "node_id", "peerId", "peer_id", "id", "pubkey", "public_key"]) ?? "",
+        version: stringFrom(value, ["version", "commit", "buildVersion", "build_version"]) ?? "",
+        addresses: stringsFrom(value, ["addresses", "announcedAddrs", "announced_addrs", "listenAddresses", "listen_addresses"]),
+        online: true,
+        peerCount: numberFrom(value, ["peerCount", "peer_count", "peers_count", "num_peers"]) ?? 0,
+        channelCount: numberFrom(value, ["channelCount", "channel_count", "channels_count", "num_channels"]) ?? 0,
+        lastUpdated: now,
+    };
+}
+export function normalizePeers(raw) {
+    const now = Date.now();
+    return extractList(raw, ["peers", "peer_states", "items", "list"]).map((peer) => {
+        const status = valueFrom(peer, ["status", "state", "connection_state"]);
+        const connected = booleanFrom(peer, ["connected", "is_connected", "online"]) ?? (status === undefined ? true : statusConnected(status));
+        return {
+            peerId: stringFrom(peer, ["peerId", "peer_id", "nodeId", "node_id", "id", "pubkey", "public_key"]) ?? "",
+            connected,
+            address: stringFrom(peer, ["address", "addr", "multiaddr", "multi_addr"]) ?? firstString(valueFrom(peer, ["addresses"])),
+            lastSeen: timeFrom(peer, ["lastSeen", "last_seen", "updatedAt", "updated_at"]) ?? (connected ? now : undefined),
+        };
+    });
+}
+export function normalizeChannels(raw) {
+    return extractList(raw, ["channels", "channel_states", "items", "list"]).map((channel) => {
+        const localBalance = amountLike(valueFrom(channel, ["localBalance", "local_balance", "outboundLiquidity", "outbound_liquidity"])) ?? 0n;
+        const remoteBalance = amountLike(valueFrom(channel, ["remoteBalance", "remote_balance", "inboundLiquidity", "inbound_liquidity"])) ?? 0n;
+        const offeredTlcBalance = amountLike(valueFrom(channel, ["offeredTlcBalance", "offered_tlc_balance"])) ?? 0n;
+        const receivedTlcBalance = amountLike(valueFrom(channel, ["receivedTlcBalance", "received_tlc_balance"])) ?? 0n;
+        return {
+            channelId: stringFrom(channel, ["channelId", "channel_id", "id", "outpoint", "funding_outpoint"]) ?? "",
+            peerId: stringFrom(channel, ["peerId", "peer_id", "pubkey", "counterparty", "counterparty_node_id"]) ?? "",
+            status: normalizeChannelStatus(channelStatusValue(channel)),
+            capacity: amountLike(valueFrom(channel, ["capacity", "totalCapacity", "total_capacity"])) ?? (localBalance + remoteBalance + offeredTlcBalance + receivedTlcBalance),
+            localBalance,
+            remoteBalance,
+            assetType: assetTypeFrom(channel),
+        };
+    });
+}
+export function normalizePayments(raw) {
+    return extractList(raw, ["payments", "payment_states", "items", "list"]).map((payment) => ({
+        paymentId: stringFrom(payment, ["paymentId", "payment_id", "id", "hash"]) ?? "unknown",
+        status: stringFrom(payment, ["status", "state"]) ?? "unknown",
+        amount: amountLike(valueFrom(payment, ["amount", "value"])) ?? 0n,
+        assetType: stringFrom(payment, ["assetType", "asset_type", "asset"]) ?? "CKB",
+        direction: stringFrom(payment, ["direction"]),
+        route: valueFrom(payment, ["route", "hops"]) ?? [],
+        fee: amountLike(valueFrom(payment, ["fee", "routingFee", "routing_fee", "totalFee", "total_fee"])),
+        latencyMs: numberFrom(payment, ["latencyMs", "latency_ms", "durationMs", "duration_ms"]),
+        error: valueFrom(payment, ["error", "failure_reason"]),
+        timestamp: timeFrom(payment, ["timestamp", "created_at", "updated_at"]) ?? Date.now(),
+    }));
+}
+function parseCliOutput(stdout) {
+    const text = stdout.trim();
+    if (!text)
+        return {};
+    const whole = tryJson(text);
+    if (whole.ok)
+        return whole.value;
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const jsonLines = lines.map((line) => tryJson(line));
+    if (jsonLines.length > 0 && jsonLines.every((line) => line.ok))
+        return jsonLines.map((line) => line.value);
+    const object = {};
+    for (const line of lines) {
+        const match = line.match(/^([^:=]+)\s*[:=]\s*(.+)$/);
+        if (match)
+            object[toCamel(match[1].trim())] = parseScalar(match[2].trim());
+    }
+    return Object.keys(object).length > 0 ? object : { text };
+}
+function unwrap(raw) {
+    if (raw && typeof raw === "object" && "result" in raw)
+        return unwrap(raw.result);
+    return raw && typeof raw === "object" ? raw : {};
+}
+function extractList(raw, keys) {
+    const value = raw && typeof raw === "object" && "result" in raw ? raw.result : raw;
+    if (Array.isArray(value))
+        return value.filter((item) => Boolean(item && typeof item === "object"));
+    if (!value || typeof value !== "object")
+        return [];
+    for (const key of keys) {
+        const item = value[key];
+        if (Array.isArray(item))
+            return item.filter((entry) => Boolean(entry && typeof entry === "object"));
+    }
+    return [];
+}
+function valueFrom(object, keys) {
+    if (!object || typeof object !== "object")
+        return undefined;
+    for (const key of keys) {
+        const value = object[key];
+        if (value !== undefined && value !== null && value !== "")
+            return value;
+    }
+    return undefined;
+}
+function stringFrom(object, keys) {
+    const value = valueFrom(object, keys);
+    return value === undefined ? undefined : String(value);
+}
+function numberFrom(object, keys) {
+    const value = valueFrom(object, keys);
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+function booleanFrom(object, keys) {
+    const value = valueFrom(object, keys);
+    return typeof value === "boolean" ? value : undefined;
+}
+function amountLike(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return BigInt(Math.trunc(value));
+    if (typeof value === "string" && /^0x[0-9a-fA-F]+$/.test(value))
+        return BigInt(value);
+    if (typeof value === "string" && /^[0-9]+$/.test(value))
+        return BigInt(value);
+    return undefined;
+}
+function timeFrom(object, keys) {
+    const value = stringFrom(object, keys);
+    if (!value)
+        return undefined;
+    if (/^\d+$/.test(value)) {
+        const number = Number(value);
+        return number < 10_000_000_000 ? number * 1000 : number;
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function normalizeChannelStatus(value) {
+    const status = String(value ?? "").toLowerCase();
+    const compact = status.replace(/[^a-z0-9]/g, "");
+    if (["open", "active", "ready", "normal", "usable", "channelready", "opened"].includes(compact))
+        return "open";
+    if (["pending", "pendingopen", "opening", "funding", "waitingforfunding", "negotiating", "collaboratingfundingtx", "signing", "awaitingtxsignatures", "awaitingchannelready"].includes(compact))
+        return "pending";
+    if (["closing", "shuttingdown", "shutdown", "pendingclose"].includes(compact))
+        return "closing";
+    return "closed";
+}
+function channelStatusValue(channel) {
+    const direct = valueFrom(channel, ["status", "state_name", "channel_state"]);
+    if (direct !== undefined)
+        return direct;
+    const state = valueFrom(channel, ["state"]);
+    const nested = valueFrom(state, ["state_name", "status", "name"]);
+    if (nested !== undefined)
+        return nested;
+    if (state && typeof state === "object") {
+        const [variant] = Object.keys(state).filter((key) => key !== "flags");
+        return variant;
+    }
+    return state;
+}
+function assetTypeFrom(channel) {
+    const explicit = stringFrom(channel, ["assetType", "asset_type", "asset", "currency"]);
+    if (explicit)
+        return explicit;
+    const udt = valueFrom(channel, ["funding_udt_type_script", "udt_type_script"]);
+    if (!udt)
+        return "CKB";
+    if (typeof udt === "object") {
+        const codeHash = stringFrom(udt, ["code_hash", "codeHash"]);
+        return codeHash ? `UDT:${codeHash}` : "UDT";
+    }
+    return String(udt);
+}
+function statusConnected(value) {
+    return ["connected", "online", "active", "established", "ready"].includes(String(value ?? "").toLowerCase());
+}
+function firstString(value) {
+    return Array.isArray(value) ? value.find((item) => typeof item === "string") : undefined;
+}
+function stringsFrom(object, keys) {
+    const value = valueFrom(object, keys);
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim());
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+}
+function tryJson(text) {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function parseScalar(value) {
+    if (/^(true|false)$/i.test(value))
+        return value.toLowerCase() === "true";
+    if (/^-?\d+$/.test(value))
+        return Number(value);
+    return value;
+}
+function toCamel(value) {
+    return value.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "");
+}
+//# sourceMappingURL=providers.js.map

package/lib/pulse/server.mjs

@@ -0,0 +1,54 @@
+import { createServer } from "node:http";
+import { calculatePaymentReadiness, collectFiberStateReport } from "./engine.mjs";
+export function createFiberApiServer(options = {}) {
+    return createServer(async (request, response) => {
+        try {
+            await handleRequest(request, response, options);
+        }
+        catch (error) {
+            json(response, 500, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+}
+export async function startFiberApiServer(options = {}) {
+    const server = createFiberApiServer(options);
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 8787;
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    return server;
+}
+async function handleRequest(request, response, options) {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
+    if (request.method !== "GET") {
+        json(response, 405, { error: "Only GET is supported." });
+        return;
+    }
+    if (url.pathname === "/state") {
+        json(response, 200, await collectFiberStateReport(options));
+        return;
+    }
+    if (url.pathname === "/readiness") {
+        const amount = url.searchParams.get("amount");
+        if (!amount) {
+            json(response, 400, { error: "Missing amount query parameter." });
+            return;
+        }
+        const report = await collectFiberStateReport(options);
+        json(response, 200, calculatePaymentReadiness(amount, report));
+        return;
+    }
+    json(response, 404, { error: "Not found.", endpoints: ["/state", "/readiness?amount=100"] });
+}
+function json(response, status, value) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(value, (_, nested) => typeof nested === "bigint" ? nested.toString() : nested, 2));
+}
+//# sourceMappingURL=server.js.map