@intent-systems/nexus 2026.1.5-3

package/dist/infra/system-presence.js

@@ -0,0 +1,217 @@
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+const entries = new Map();
+const TTL_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_ENTRIES = 200;
+function normalizePresenceKey(key) {
+    if (!key)
+        return undefined;
+    const trimmed = key.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase();
+}
+function resolvePrimaryIPv4() {
+    const nets = os.networkInterfaces();
+    const prefer = ["en0", "eth0"];
+    const pick = (names) => {
+        for (const name of names) {
+            const list = nets[name];
+            const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+            if (entry?.address)
+                return entry.address;
+        }
+        for (const list of Object.values(nets)) {
+            const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+            if (entry?.address)
+                return entry.address;
+        }
+        return undefined;
+    };
+    return pick(prefer) ?? os.hostname();
+}
+function initSelfPresence() {
+    const host = os.hostname();
+    const ip = resolvePrimaryIPv4() ?? undefined;
+    const version = process.env.NEXUS_VERSION ??
+        process.env.NEXUS_VERSION ??
+        process.env.npm_package_version ??
+        "unknown";
+    const modelIdentifier = (() => {
+        const p = os.platform();
+        if (p === "darwin") {
+            const res = spawnSync("sysctl", ["-n", "hw.model"], {
+                encoding: "utf-8",
+            });
+            const out = typeof res.stdout === "string" ? res.stdout.trim() : "";
+            return out.length > 0 ? out : undefined;
+        }
+        return os.arch();
+    })();
+    const macOSVersion = () => {
+        const res = spawnSync("sw_vers", ["-productVersion"], {
+            encoding: "utf-8",
+        });
+        const out = typeof res.stdout === "string" ? res.stdout.trim() : "";
+        return out.length > 0 ? out : os.release();
+    };
+    const platform = (() => {
+        const p = os.platform();
+        const rel = os.release();
+        if (p === "darwin")
+            return `macos ${macOSVersion()}`;
+        if (p === "win32")
+            return `windows ${rel}`;
+        return `${p} ${rel}`;
+    })();
+    const deviceFamily = (() => {
+        const p = os.platform();
+        if (p === "darwin")
+            return "Mac";
+        if (p === "win32")
+            return "Windows";
+        if (p === "linux")
+            return "Linux";
+        return p;
+    })();
+    const text = `Gateway: ${host}${ip ? ` (${ip})` : ""} · app ${version} · mode gateway · reason self`;
+    const selfEntry = {
+        host,
+        ip,
+        version,
+        platform,
+        deviceFamily,
+        modelIdentifier,
+        mode: "gateway",
+        reason: "self",
+        text,
+        ts: Date.now(),
+    };
+    const key = host.toLowerCase();
+    entries.set(key, selfEntry);
+}
+function ensureSelfPresence() {
+    // If the map was somehow cleared (e.g., hot reload or a new worker spawn that
+    // skipped module evaluation), re-seed with a local entry so UIs always show
+    // at least the current gateway.
+    if (entries.size === 0) {
+        initSelfPresence();
+    }
+}
+function touchSelfPresence() {
+    const host = os.hostname();
+    const key = host.toLowerCase();
+    const existing = entries.get(key);
+    if (existing) {
+        entries.set(key, { ...existing, ts: Date.now() });
+    }
+    else {
+        initSelfPresence();
+    }
+}
+initSelfPresence();
+function parsePresence(text) {
+    const trimmed = text.trim();
+    const pattern = /Node:\s*([^ (]+)\s*\(([^)]+)\)\s*·\s*app\s*([^·]+?)\s*·\s*last input\s*([0-9]+)s ago\s*·\s*mode\s*([^·]+?)\s*·\s*reason\s*(.+)$/i;
+    const match = trimmed.match(pattern);
+    if (!match) {
+        return { text: trimmed, ts: Date.now() };
+    }
+    const [, host, ip, version, lastInputStr, mode, reasonRaw] = match;
+    const lastInputSeconds = Number.parseInt(lastInputStr, 10);
+    const reason = reasonRaw.trim();
+    return {
+        host: host.trim(),
+        ip: ip.trim(),
+        version: version.trim(),
+        lastInputSeconds: Number.isFinite(lastInputSeconds)
+            ? lastInputSeconds
+            : undefined,
+        mode: mode.trim(),
+        reason,
+        text: trimmed,
+        ts: Date.now(),
+    };
+}
+export function updateSystemPresence(payload) {
+    ensureSelfPresence();
+    const parsed = parsePresence(payload.text);
+    const key = normalizePresenceKey(payload.instanceId) ||
+        normalizePresenceKey(parsed.instanceId) ||
+        normalizePresenceKey(parsed.host) ||
+        parsed.ip ||
+        parsed.text.slice(0, 64) ||
+        os.hostname().toLowerCase();
+    const hadExisting = entries.has(key);
+    const existing = entries.get(key) ?? {};
+    const merged = {
+        ...existing,
+        ...parsed,
+        host: payload.host ?? parsed.host ?? existing.host,
+        ip: payload.ip ?? parsed.ip ?? existing.ip,
+        version: payload.version ?? parsed.version ?? existing.version,
+        platform: payload.platform ?? existing.platform,
+        deviceFamily: payload.deviceFamily ?? existing.deviceFamily,
+        modelIdentifier: payload.modelIdentifier ?? existing.modelIdentifier,
+        mode: payload.mode ?? parsed.mode ?? existing.mode,
+        lastInputSeconds: payload.lastInputSeconds ??
+            parsed.lastInputSeconds ??
+            existing.lastInputSeconds,
+        reason: payload.reason ?? parsed.reason ?? existing.reason,
+        instanceId: payload.instanceId ?? parsed.instanceId ?? existing.instanceId,
+        text: payload.text || parsed.text || existing.text,
+        ts: Date.now(),
+    };
+    entries.set(key, merged);
+    const trackKeys = ["host", "ip", "version", "mode", "reason"];
+    const changes = {};
+    const changedKeys = [];
+    for (const k of trackKeys) {
+        const prev = existing[k];
+        const next = merged[k];
+        if (prev !== next) {
+            changes[k] = next;
+            changedKeys.push(k);
+        }
+    }
+    return {
+        key,
+        previous: hadExisting ? existing : undefined,
+        next: merged,
+        changes,
+        changedKeys,
+    };
+}
+export function upsertPresence(key, presence) {
+    ensureSelfPresence();
+    const normalizedKey = normalizePresenceKey(key) ?? os.hostname().toLowerCase();
+    const existing = entries.get(normalizedKey) ?? {};
+    const merged = {
+        ...existing,
+        ...presence,
+        ts: Date.now(),
+        text: presence.text ||
+            existing.text ||
+            `Node: ${presence.host ?? existing.host ?? "unknown"} · mode ${presence.mode ?? existing.mode ?? "unknown"}`,
+    };
+    entries.set(normalizedKey, merged);
+}
+export function listSystemPresence() {
+    ensureSelfPresence();
+    // prune expired
+    const now = Date.now();
+    for (const [k, v] of entries) {
+        if (now - v.ts > TTL_MS)
+            entries.delete(k);
+    }
+    // enforce max size (LRU by ts)
+    if (entries.size > MAX_ENTRIES) {
+        const sorted = [...entries.entries()].sort((a, b) => a[1].ts - b[1].ts);
+        const toDrop = entries.size - MAX_ENTRIES;
+        for (let i = 0; i < toDrop; i++) {
+            entries.delete(sorted[i][0]);
+        }
+    }
+    touchSelfPresence();
+    return [...entries.values()].sort((a, b) => b.ts - a.ts);
+}

package/dist/infra/tailnet.js

@@ -0,0 +1,46 @@
+import os from "node:os";
+function isTailnetIPv4(address) {
+    const parts = address.split(".");
+    if (parts.length !== 4)
+        return false;
+    const octets = parts.map((p) => Number.parseInt(p, 10));
+    if (octets.some((n) => !Number.isFinite(n) || n < 0 || n > 255))
+        return false;
+    // Tailscale IPv4 range: 100.64.0.0/10
+    // https://tailscale.com/kb/1015/100.x-addresses
+    const [a, b] = octets;
+    return a === 100 && b >= 64 && b <= 127;
+}
+function isTailnetIPv6(address) {
+    // Tailscale IPv6 ULA prefix: fd7a:115c:a1e0::/48
+    // (stable across tailnets; nodes get per-device suffixes)
+    const normalized = address.trim().toLowerCase();
+    return normalized.startsWith("fd7a:115c:a1e0:");
+}
+export function listTailnetAddresses() {
+    const ipv4 = [];
+    const ipv6 = [];
+    const ifaces = os.networkInterfaces();
+    for (const entries of Object.values(ifaces)) {
+        if (!entries)
+            continue;
+        for (const e of entries) {
+            if (!e || e.internal)
+                continue;
+            const address = e.address?.trim();
+            if (!address)
+                continue;
+            if (isTailnetIPv4(address))
+                ipv4.push(address);
+            if (isTailnetIPv6(address))
+                ipv6.push(address);
+        }
+    }
+    return { ipv4: [...new Set(ipv4)], ipv6: [...new Set(ipv6)] };
+}
+export function pickPrimaryTailnetIPv4() {
+    return listTailnetAddresses().ipv4[0];
+}
+export function pickPrimaryTailnetIPv6() {
+    return listTailnetAddresses().ipv6[0];
+}

package/dist/infra/tailscale.js

@@ -0,0 +1,149 @@
+import { existsSync } from "node:fs";
+import chalk from "chalk";
+import { promptYesNo } from "../cli/prompt.js";
+import { danger, info, logVerbose, shouldLogVerbose, warn, } from "../globals.js";
+import { runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+import { ensureBinary } from "./binaries.js";
+export async function getTailnetHostname(exec = runExec) {
+    // Derive tailnet hostname (or IP fallback) from tailscale status JSON.
+    const candidates = [
+        "tailscale",
+        "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
+    ];
+    let lastError;
+    for (const candidate of candidates) {
+        if (candidate.startsWith("/") && !existsSync(candidate))
+            continue;
+        try {
+            const { stdout } = await exec(candidate, ["status", "--json"]);
+            const parsed = stdout
+                ? JSON.parse(stdout)
+                : {};
+            const self = typeof parsed.Self === "object" && parsed.Self !== null
+                ? parsed.Self
+                : undefined;
+            const dns = typeof self?.DNSName === "string"
+                ? self.DNSName
+                : undefined;
+            const ips = Array.isArray(self?.TailscaleIPs)
+                ? self.TailscaleIPs
+                : [];
+            if (dns && dns.length > 0)
+                return dns.replace(/\.$/, "");
+            if (ips.length > 0)
+                return ips[0];
+            throw new Error("Could not determine Tailscale DNS or IP");
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw lastError ?? new Error("Could not determine Tailscale DNS or IP");
+}
+export async function ensureGoInstalled(exec = runExec, prompt = promptYesNo, runtime = defaultRuntime) {
+    // Ensure Go toolchain is present; offer Homebrew install if missing.
+    const hasGo = await exec("go", ["version"]).then(() => true, () => false);
+    if (hasGo)
+        return;
+    const install = await prompt("Go is not installed. Install via Homebrew (brew install go)?", true);
+    if (!install) {
+        runtime.error("Go is required to build tailscaled from source. Aborting.");
+        runtime.exit(1);
+    }
+    logVerbose("Installing Go via Homebrew…");
+    await exec("brew", ["install", "go"]);
+}
+export async function ensureTailscaledInstalled(exec = runExec, prompt = promptYesNo, runtime = defaultRuntime) {
+    // Ensure tailscaled binary exists; install via Homebrew tailscale if missing.
+    const hasTailscaled = await exec("tailscaled", ["--version"]).then(() => true, () => false);
+    if (hasTailscaled)
+        return;
+    const install = await prompt("tailscaled not found. Install via Homebrew (tailscale package)?", true);
+    if (!install) {
+        runtime.error("tailscaled is required for user-space funnel. Aborting.");
+        runtime.exit(1);
+    }
+    logVerbose("Installing tailscaled via Homebrew…");
+    await exec("brew", ["install", "tailscale"]);
+}
+export async function ensureFunnel(port, exec = runExec, runtime = defaultRuntime, prompt = promptYesNo) {
+    // Ensure Funnel is enabled and publish the webhook port.
+    try {
+        const statusOut = (await exec("tailscale", ["funnel", "status", "--json"])).stdout.trim();
+        const parsed = statusOut
+            ? JSON.parse(statusOut)
+            : {};
+        if (!parsed || Object.keys(parsed).length === 0) {
+            runtime.error(danger("Tailscale Funnel is not enabled on this tailnet/device."));
+            runtime.error(info("Enable in admin console: https://login.tailscale.com/admin (see https://tailscale.com/kb/1223/funnel)"));
+            runtime.error(info("macOS user-space tailscaled docs: https://github.com/tailscale/tailscale/wiki/Tailscaled-on-macOS"));
+            const proceed = await prompt("Attempt local setup with user-space tailscaled?", true);
+            if (!proceed)
+                runtime.exit(1);
+            await ensureBinary("brew", exec, runtime);
+            await ensureGoInstalled(exec, prompt, runtime);
+            await ensureTailscaledInstalled(exec, prompt, runtime);
+        }
+        logVerbose(`Enabling funnel on port ${port}…`);
+        const { stdout } = await exec("tailscale", ["funnel", "--yes", "--bg", `${port}`], {
+            maxBuffer: 200_000,
+            timeoutMs: 15_000,
+        });
+        if (stdout.trim())
+            console.log(stdout.trim());
+    }
+    catch (err) {
+        const errOutput = err;
+        const stdout = typeof errOutput.stdout === "string" ? errOutput.stdout : "";
+        const stderr = typeof errOutput.stderr === "string" ? errOutput.stderr : "";
+        if (stdout.includes("Funnel is not enabled")) {
+            console.error(danger("Funnel is not enabled on this tailnet/device."));
+            const linkMatch = stdout.match(/https?:\/\/\S+/);
+            if (linkMatch) {
+                console.error(info(`Enable it here: ${linkMatch[0]}`));
+            }
+            else {
+                console.error(info("Enable in admin console: https://login.tailscale.com/admin (see https://tailscale.com/kb/1223/funnel)"));
+            }
+        }
+        if (stderr.includes("client version") ||
+            stdout.includes("client version")) {
+            console.error(warn("Tailscale client/server version mismatch detected; try updating tailscale/tailscaled."));
+        }
+        runtime.error("Failed to enable Tailscale Funnel. Is it allowed on your tailnet?");
+        runtime.error(info("Tip: Funnel is optional for NEXUS. You can keep running the web gateway without it: `nexus gateway`"));
+        if (shouldLogVerbose()) {
+            if (stdout.trim())
+                runtime.error(chalk.gray(`stdout: ${stdout.trim()}`));
+            if (stderr.trim())
+                runtime.error(chalk.gray(`stderr: ${stderr.trim()}`));
+            runtime.error(err);
+        }
+        runtime.exit(1);
+    }
+}
+export async function enableTailscaleServe(port, exec = runExec) {
+    await exec("tailscale", ["serve", "--bg", "--yes", `${port}`], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function disableTailscaleServe(exec = runExec) {
+    await exec("tailscale", ["serve", "reset"], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function enableTailscaleFunnel(port, exec = runExec) {
+    await exec("tailscale", ["funnel", "--bg", "--yes", `${port}`], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}
+export async function disableTailscaleFunnel(exec = runExec) {
+    await exec("tailscale", ["funnel", "reset"], {
+        maxBuffer: 200_000,
+        timeoutMs: 15_000,
+    });
+}

package/dist/infra/unhandled-rejections.js

@@ -0,0 +1,19 @@
+const handlers = new Set();
+export function registerUnhandledRejectionHandler(handler) {
+    handlers.add(handler);
+    return () => {
+        handlers.delete(handler);
+    };
+}
+export function isUnhandledRejectionHandled(reason) {
+    for (const handler of handlers) {
+        try {
+            if (handler(reason))
+                return true;
+        }
+        catch (err) {
+            console.error("[nexus] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+        }
+    }
+    return false;
+}

package/dist/infra/usage-suggestions.js

@@ -0,0 +1,241 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { resolveEventLogDir } from "./event-log.js";
+export async function buildUsageSuggestions(opts = {}) {
+    const events = await loadUsageEvents({
+        sinceMs: undefined,
+        sources: opts.sources,
+    });
+    const { sessionEvents, globalEvents, keyIndex, totalEvents, globalCounts } = indexEvents(events, opts.kinds);
+    const scope = opts.scope ?? "global";
+    const historyCount = opts.history ?? 1;
+    const limit = opts.limit ?? 5;
+    let historyKeys = [];
+    let transitions = new Map();
+    if (scope === "global") {
+        const ordered = orderKeyEvents(globalEvents);
+        historyKeys = resolveHistoryFromSequence(ordered, keyIndex, historyCount);
+        transitions = buildTransitionTableFromSequence(ordered);
+    }
+    else {
+        const seq = resolveSessionSequence(sessionEvents, opts.sessionId);
+        historyKeys = resolveHistoryFromSequence(seq, keyIndex, historyCount);
+        transitions = buildTransitionTableFromSequence(seq);
+    }
+    const lastKey = historyKeys.length > 0 ? historyKeys[historyKeys.length - 1].key : null;
+    let suggestions = rankSuggestions(transitions, keyIndex, lastKey, limit);
+    if (suggestions.length === 0) {
+        suggestions = rankGlobalSuggestions(globalCounts, keyIndex, limit);
+    }
+    return {
+        history: historyKeys,
+        suggestions,
+        totalEvents,
+    };
+}
+export async function loadUsageEvents(opts = {}) {
+    const dir = resolveEventLogDir();
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs
+        .readdirSync(dir)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => path.join(dir, name))
+        .sort();
+    const out = [];
+    for (const file of files) {
+        const stream = fs.createReadStream(file);
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const sessionId = String(raw.session_id ?? "");
+            const seq = Number(raw.seq ?? 0);
+            const ts = Number(raw.ts ?? 0);
+            const source = String(raw.source ?? "");
+            if (!sessionId || !Number.isFinite(seq) || !Number.isFinite(ts) || !source) {
+                continue;
+            }
+            if (opts.sinceMs && ts < opts.sinceMs) {
+                continue;
+            }
+            if (opts.sources && opts.sources.length > 0 && !opts.sources.includes(source)) {
+                continue;
+            }
+            const evt = {
+                sessionId,
+                seq,
+                ts,
+                source,
+                eventType: String(raw.event_type ?? ""),
+                commandPath: typeof raw.command_path === "string" ? raw.command_path : undefined,
+                stream: typeof raw.stream === "string" ? raw.stream : undefined,
+                data: raw.data && typeof raw.data === "object"
+                    ? raw.data
+                    : undefined,
+            };
+            out.push(evt);
+            if (opts.limit && out.length >= opts.limit) {
+                rl.close();
+                break;
+            }
+        }
+    }
+    return out;
+}
+function indexEvents(events, kinds) {
+    const sessionEvents = new Map();
+    const globalEvents = [];
+    const keyIndex = new Map();
+    const globalCounts = new Map();
+    let totalEvents = 0;
+    const includeCli = !kinds || kinds.includes("cli");
+    const includeTool = !kinds || kinds.includes("tool");
+    for (const evt of events) {
+        const key = eventToKey(evt, includeCli, includeTool);
+        if (!key)
+            continue;
+        keyIndex.set(key.key, key);
+        totalEvents++;
+        globalCounts.set(key.key, (globalCounts.get(key.key) ?? 0) + 1);
+        const item = {
+            key: key.key,
+            ts: evt.ts,
+            seq: evt.seq,
+            sessionId: evt.sessionId,
+        };
+        globalEvents.push(item);
+        if (!sessionEvents.has(evt.sessionId))
+            sessionEvents.set(evt.sessionId, []);
+        sessionEvents.get(evt.sessionId)?.push(item);
+    }
+    return { sessionEvents, globalEvents, keyIndex, totalEvents, globalCounts };
+}
+function eventToKey(evt, includeCli, includeTool) {
+    if (includeCli && evt.eventType === "command_finished" && evt.commandPath) {
+        const key = `${evt.source}:cli:${evt.commandPath}`;
+        return {
+            key,
+            source: evt.source,
+            kind: "cli",
+            name: evt.commandPath,
+        };
+    }
+    if (includeTool &&
+        evt.eventType === "agent_event" &&
+        evt.stream === "tool" &&
+        evt.data &&
+        evt.data.phase === "start") {
+        const name = typeof evt.data.name === "string" ? evt.data.name : "unknown_tool";
+        const key = `${evt.source}:tool:${name}`;
+        return {
+            key,
+            source: evt.source,
+            kind: "tool",
+            name,
+        };
+    }
+    return null;
+}
+function orderKeyEvents(events) {
+    return [...events].sort((a, b) => a.ts - b.ts || a.seq - b.seq);
+}
+function resolveSessionSequence(sessionEvents, sessionId) {
+    if (sessionEvents.size === 0)
+        return [];
+    if (sessionId && sessionEvents.has(sessionId)) {
+        return orderKeyEvents(sessionEvents.get(sessionId) ?? []);
+    }
+    let latest = [];
+    let latestTs = 0;
+    for (const keys of sessionEvents.values()) {
+        const ordered = orderKeyEvents(keys);
+        const last = ordered[ordered.length - 1];
+        if (last && last.ts >= latestTs) {
+            latest = ordered;
+            latestTs = last.ts;
+        }
+    }
+    return latest;
+}
+function resolveHistoryFromSequence(events, keyIndex, historyCount) {
+    if (events.length === 0)
+        return [];
+    const slice = events.slice(-historyCount);
+    const out = [];
+    for (const item of slice) {
+        const info = keyIndex.get(item.key);
+        if (info)
+            out.push(info);
+    }
+    return out;
+}
+function buildTransitionTableFromSequence(events) {
+    const transitions = new Map();
+    for (let i = 0; i < events.length - 1; i += 1) {
+        const from = events[i].key;
+        const to = events[i + 1].key;
+        if (!transitions.has(from))
+            transitions.set(from, new Map());
+        const row = transitions.get(from);
+        row?.set(to, (row.get(to) ?? 0) + 1);
+    }
+    return transitions;
+}
+function rankSuggestions(transitions, keyIndex, lastKey, limit) {
+    if (!lastKey || !transitions.has(lastKey)) {
+        return [];
+    }
+    const row = transitions.get(lastKey);
+    if (!row)
+        return [];
+    const total = Array.from(row.values()).reduce((sum, v) => sum + v, 0);
+    const entries = Array.from(row.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit);
+    const out = [];
+    for (const [key, count] of entries) {
+        const info = keyIndex.get(key);
+        if (!info)
+            continue;
+        out.push({
+            key,
+            source: info.source,
+            kind: info.kind,
+            name: info.name,
+            count,
+            score: total > 0 ? count / total : 0,
+        });
+    }
+    return out;
+}
+function rankGlobalSuggestions(counts, keyIndex, limit) {
+    const entries = Array.from(counts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit);
+    const total = entries.reduce((sum, [, count]) => sum + count, 0);
+    const out = [];
+    for (const [key, count] of entries) {
+        const info = keyIndex.get(key);
+        if (!info)
+            continue;
+        out.push({
+            key,
+            source: info.source,
+            kind: info.kind,
+            name: info.name,
+            count,
+            score: total > 0 ? count / total : 0,
+        });
+    }
+    return out;
+}