dexterm-cli 0.0.0-stage → 0.1.1

package/dist/packages/cli/src/live/intel.js

@@ -0,0 +1,227 @@
+// dexterm — live binding for WALLET INTEL (task-1340): runs the data layer's WalletIntel scan for the token on
+// screen (light tier) or a watchlist coin (deep tier), keeps the result per mint, and builds the two view models
+// the bubble map is drawn from: the terminal screen's (tui BubbleVM) and the popup's (popup BubbleVM, text-only,
+// no keys). Every state is explicit: loading → ok (possibly degraded: keyless) → unavailable (with the reason and
+// the fix), never a fake picture. Read-only: nothing here trades or signs.
+import { WalletIntel, HIDDEN_LABELS, visibleLabels, EX_POOL_TAGS, BIG_HOLDER_PCT } from '../../../data/src/index.js';
+import { bubbleVM, fmtNum } from '../../../tui/src/index.js';
+/** Delay before an opened token is scanned, so flipping through tokens never spends history credits. */
+export const INTEL_AUTOSCAN_DELAY_MS = 1_500;
+export class IntelLive {
+    intel;
+    now;
+    onChange;
+    isWatched;
+    showHidden;
+    entries = new Map();
+    gen = new Map();
+    autoscan = null;
+    constructor(dl, opts = {}) {
+        this.intel = opts.intel ?? new WalletIntel({ cache: dl.cache, http: dl.http, pool: dl.rpcPool, detail: dl.detail, health: dl.health, credits: dl.credits, clock: dl.clock });
+        this.now = opts.now ?? (() => Date.now());
+        this.onChange = opts.onChange ?? (() => { });
+        this.isWatched = opts.isWatched ?? (() => false);
+        this.showHidden = opts.showHidden ?? false;
+    }
+    /** The depth a mint gets: deep when watched, else light. */
+    depthFor(mint) { return this.isWatched(mint) ? 'deep' : 'light'; }
+    /** Whether the history leg (funders + launch window) can run; the screen prints the reason when not. */
+    historyAvailable() { return this.intel.historyAvailable(); }
+    entry(mint) { return this.entries.get(mint) ?? null; }
+    /** Run (or re-run) the scan for a mint. Resolves when it settles; `view()` is readable throughout. */
+    async scan(seed, opts = {}) {
+        const depth = opts.depth ?? this.depthFor(seed.mint);
+        const my = (this.gen.get(seed.mint) ?? 0) + 1;
+        this.gen.set(seed.mint, my);
+        const prev = this.entries.get(seed.mint);
+        const e = { mint: seed.mint, symbol: seed.symbol, name: seed.name ?? prev?.name ?? '', holderCount: seed.holderCount ?? prev?.holderCount ?? null, state: 'loading', result: prev?.result ?? null, bubbles: prev?.bubbles ?? null, at: this.now(), error: null };
+        this.entries.set(seed.mint, e);
+        this.onChange();
+        try {
+            const r = await this.intel.scan(seed.mint, depth, { force: opts.force });
+            if (this.gen.get(seed.mint) !== my)
+                return this.entries.get(seed.mint) ?? e;
+            e.result = r;
+            e.at = this.now();
+            if (r.state === 'ok') {
+                e.state = 'ok';
+                const a = this.showHidden ? r.analysis : hideLabels(r.analysis);
+                e.bubbles = bubbleVM(a, { symbol: e.symbol, name: e.name, mint: e.mint, holderCount: e.holderCount });
+            }
+            else {
+                e.state = 'unavailable';
+                e.bubbles = null;
+            }
+        }
+        catch (err) {
+            if (this.gen.get(seed.mint) !== my)
+                return this.entries.get(seed.mint) ?? e;
+            e.state = 'unavailable';
+            e.error = err instanceof Error ? err.message : String(err);
+            e.bubbles = null;
+        }
+        finally {
+            if (this.gen.get(seed.mint) === my)
+                this.onChange();
+        }
+        return e;
+    }
+    /** Schedule a light scan for an opened token after INTEL_AUTOSCAN_DELAY_MS (cancelled by the next open). */
+    autoscanLater(seed, delayMs = INTEL_AUTOSCAN_DELAY_MS) {
+        if (this.autoscan)
+            clearTimeout(this.autoscan);
+        const h = setTimeout(() => { this.autoscan = null; void this.scan(seed).catch(() => { }); }, delayMs);
+        h.unref?.();
+        this.autoscan = h;
+    }
+    /**
+     * task-1359: the NEW PAIRS list scans the row the cursor rests on (same delay as a token open, cancelled by
+     * the next move), but only when the history leg can run: without a Helius key a scan cannot read the
+     * launch window, so it would spend public-RPC calls to still print a dash. A mint already scanned or in
+     * flight is left alone. Returns whether a scan was scheduled.
+     */
+    scanSelectedLater(seed, delayMs = INTEL_AUTOSCAN_DELAY_MS) {
+        if (!this.intel.historyAvailable().ok)
+            return false;
+        const e = this.entries.get(seed.mint);
+        if (e && (e.state === 'loading' || e.state === 'ok'))
+            return false;
+        this.autoscanLater(seed, delayMs);
+        return true;
+    }
+    /** Cancel a pending autoscan (token closed). */
+    cancelAutoscan() { if (this.autoscan) {
+        clearTimeout(this.autoscan);
+        this.autoscan = null;
+    } }
+    /** The analysis for a mint when the scan is ok, else null (the token screen's ON-CHAIN rows read this). */
+    analysis(mint) {
+        const e = this.entries.get(mint);
+        return e && e.state === 'ok' && e.result?.state === 'ok' ? e.result.analysis : null;
+    }
+    close() { this.cancelAutoscan(); }
+}
+/** Drop the hidden-by-default labels from every holder (the renderer never sees a cabal-class label). */
+export function hideLabels(a) {
+    return { ...a, holders: a.holders.map((h) => ({ ...h, labels: visibleLabels(h.labels, false) })), clusters: a.clusters.map((c) => ({ ...c, labels: c.labels.filter((l) => !HIDDEN_LABELS.has(l)) })) };
+}
+/**
+ * Snipers / bundled supply for one mint, from the wallet-intel scan only (never a guess). Shared by the token
+ * screen's ON-CHAIN rows and the live NEW PAIRS columns + spotlight. Before a scan has read the launch window
+ * both cells say why (scanning / needs a free Helius key / not scanned yet) and the short form is a dash.
+ */
+export function launchIntelCells(intel, mint, notScanned = 'not scanned yet') {
+    const a = intel?.analysis(mint) ?? null;
+    const I = a && a.insights.coverage.launchTxs > 0 ? a.insights : null;
+    if (I) {
+        const s = I.snipers, b = I.bundle;
+        return {
+            measured: true,
+            snipers: { text: `${s.count} · ${s.launchWindowSharePct.toFixed(1)}% at launch`, short: String(s.count), level: s.launchWindowSharePct > 20 ? 'bad' : s.count > 3 ? 'warn' : 'ok' },
+            bundle: { text: `${b.bundlePctOfTopSample.toFixed(1)}% · ${b.sameSlotCohorts} cohorts`, short: `${b.bundlePctOfTopSample.toFixed(0)}%`, level: b.bundlePctOfTopSample > 15 ? 'bad' : b.bundlePctOfTopSample > 5 ? 'warn' : 'ok' },
+        };
+    }
+    const e = intel?.entry(mint) ?? null;
+    const loading = e?.state === 'loading';
+    const hist = intel ? intel.historyAvailable() : { ok: false, why: 'live mode only' };
+    const r = e?.result?.state === 'ok' ? e.result : null;
+    const why = loading ? 'scanning…' : a && r ? noLaunchWhy(r, hist) : !hist.ok ? historyWhy(hist.why, !intel) : notScanned;
+    const na = { text: why, short: loading ? '…' : '—', level: 'na' };
+    return { measured: false, snipers: na, bundle: { ...na } };
+}
+/**
+ * task-1367: why an ok scan has no launch window. Before, every case printed "needs Helius key" — also with a key
+ * configured, when Helius was rate-limited, the daily credit cap was hit or the history call failed. Now the
+ * reason is the scan's own: only a missing key says "needs Helius key".
+ */
+function noLaunchWhy(r, hist) {
+    if (r.via.history === 'helius')
+        return r.degraded ? 'history failed · r' : 'no launch txs read';
+    return historyWhy(r.degraded ?? (hist.ok ? '' : hist.why), false, hist.ok);
+}
+function historyWhy(why, noBinding, nowOk = false) {
+    if (noBinding || /Helius key/i.test(why))
+        return 'needs Helius key';
+    if (/credit budget/i.test(why))
+        return 'Helius cap today';
+    if (/Helius is/i.test(why))
+        return 'Helius paused · r';
+    return nowOk ? 'not read · r retry' : 'needs Helius key';
+}
+/** Whether `r` on the token screen should re-run this mint's scan (an ok scan whose history leg did not land). */
+export function launchRetryable(intel, mint) {
+    const e = intel?.entry(mint);
+    if (!intel || !e || e.state !== 'ok' || e.result?.state !== 'ok')
+        return false;
+    return e.result.analysis.insights.coverage.launchTxs === 0 && intel.historyAvailable().ok;
+}
+const shortA = (a) => `${a.slice(0, 4)}…${a.slice(-4)}`;
+/** The token screen's holder classes + concentration for a mint (pure over the IntelLive state). */
+export function holderTags(intel, mint) {
+    const a = intel?.analysis(mint) ?? null;
+    const byOwner = new Map();
+    if (!a)
+        return { byOwner, top10: null, note: null };
+    for (const h of a.holders)
+        if (h.cls)
+            byOwner.set(h.owner, h.cls);
+    const T = a.insights.top10;
+    const top10 = typeof T.exPool === 'number' ? { raw: T.byTokenAccount, exPool: T.exPool, dropped: T.exPoolDropped ?? 0, droppedPct: T.exPoolDroppedPct ?? 0 } : null;
+    let note = null;
+    const big = a.insights.bigHolder ?? null;
+    if (big) {
+        note = { text: `main risk: ${big.tag === 'DEV' ? 'CREATOR' : big.tag} ${shortA(big.owner)} holds ${big.pct.toFixed(1)}%`, level: 'bad' };
+    }
+    else {
+        const top = a.holders[0];
+        if (top?.cls && top.pct > BIG_HOLDER_PCT && EX_POOL_TAGS.has(top.cls.tag)) {
+            const c = top.cls;
+            const what = c.lock ? `${c.lock.program} escrow ${shortA(c.lock.escrow)}, ${c.lock.unlock ?? 'unlock not decoded'}` : c.program ?? 'burn address';
+            note = { text: `top holder ${top.pct.toFixed(1)}% is ${c.tag} (${what}): not counted in ex-pool`, level: 'info' };
+        }
+    }
+    return { byOwner, top10, note };
+}
+/** "unavailable: <reason> — <fix>" for the screen / popup banner. */
+export function unavailableText(e) {
+    if (!e)
+        return { reason: 'no scan yet', fix: null };
+    if (e.error)
+        return { reason: e.error, fix: null };
+    if (e.result?.state === 'unavailable')
+        return { reason: e.result.reason, fix: e.result.fix };
+    return { reason: 'no holder source answered', fix: null };
+}
+/** Build the popup's text-only view model from an entry (never a key, never a URL). */
+export function popupBubbleVM(e, seed, selected, image = null) {
+    const base = { symbol: seed.symbol, name: seed.name ?? e?.name ?? '', mint: seed.mint, state: 'loading', reason: null, fix: null, depth: null, degraded: null, holders: [], clusters: [], insights: null, selected, via: null, updatedAt: e?.at ?? null, image };
+    if (!e || e.state === 'loading')
+        return base;
+    if (e.state !== 'ok' || !e.result || e.result.state !== 'ok' || !e.bubbles) {
+        const u = unavailableText(e);
+        return { ...base, state: 'unavailable', reason: u.reason, fix: u.fix };
+    }
+    const r = e.result;
+    const I = r.analysis.insights;
+    const clsOf = new Map(r.analysis.holders.map((h) => [h.owner, h.cls]));
+    const insights = {
+        top10Raw: I.top10.byTokenAccount, top10Adjusted: I.top10.clusterAdjusted, excludedCount: I.top10.excludedCount,
+        top10ExPool: I.top10.exPool ?? null, exPoolDropped: I.top10.exPoolDropped ?? 0,
+        bigHolder: I.bigHolder ? { owner: I.bigHolder.owner, pct: I.bigHolder.pct, tag: I.bigHolder.tag } : null,
+        snipers: I.coverage.launchTxs > 0 ? { count: I.snipers.count, launchSharePct: I.snipers.launchWindowSharePct } : null,
+        bundlePct: I.coverage.launchTxs > 0 ? I.bundle.bundlePctOfTopSample : null,
+        cohorts: I.coverage.launchTxs > 0 ? I.bundle.sameSlotCohorts : null,
+        devPct: I.dev.creatorPctNow, devUpperBoundPct: I.dev.creatorUpperBoundPct,
+        freshPct: I.coverage.fundingLookups > 0 ? I.fresh.freshAtBuyPctOfTopSample : null, freshMeasuredPct: I.coverage.fundingLookups > 0 ? I.fresh.measuredPct : null,
+        sample: `sample top ${I.coverage.topHoldersFetched} accts${e.holderCount ? ` of ${fmtNum(e.holderCount)} holders` : ''} · ${I.coverage.supplyCoveredPct}% supply · funders ${I.coverage.fundingLookups}/${I.coverage.topHoldersFetched} · launch ${I.coverage.launchTxs} txs${I.coverage.launchMorePages ? '+' : ''}`,
+    };
+    return {
+        ...base, state: 'ok', depth: r.depth, degraded: r.degraded, via: r.via.history ? `${r.via.holders} + helius history` : r.via.holders,
+        holders: e.bubbles.holders.map((h) => ({ owner: h.owner, pct: h.pct, kind: h.kind, labels: h.labels.map((l) => ({ label: l.label, rule: l.rule, confidence: l.confidence })), funder: h.funder ? { address: h.funder.address, label: h.funder.label, blockTime: h.funder.blockTime } : null, walletFirstSeen: h.walletFirstSeen, cluster: h.cluster, cls: clsVM(clsOf.get(h.owner)) })),
+        clusters: e.bubbles.clusters.filter((c) => c.members.length > 1).map((c) => ({ name: c.name, kind: c.kind, members: c.members.slice(), pct: c.pct, evidence: c.evidence.map((v) => ({ a: v.a, b: v.b, rule: v.rule, linked: v.linked })) })),
+        insights,
+    };
+}
+function clsVM(c) {
+    return c ? { tag: c.tag, reason: c.reason, lock: c.lock ? { escrow: c.lock.escrow, program: c.lock.program, unlock: c.lock.unlock, note: c.lock.note } : null } : null;
+}

package/dist/packages/cli/src/live/newpairs.js

@@ -0,0 +1,334 @@
+import { SOL_MINT } from "../state.js";
+import { cleanText, deriveFlags, impliedSpark } from "../screener/rows.js";
+export const RECENT_POLL_MS = 15_000;
+export const NEW_TOKENS_POLL_MS = 30_000;
+export const ENRICH_POLL_MS = 10_000;
+export const MAX_ROWS = 200;
+/** pump.fun graduates at ~$69K market cap (SPEC §4.4). */
+export const PUMP_GRADUATION_USD = 69_000;
+export function percentile(xs, p) {
+    if (!xs.length)
+        return null;
+    const s = [...xs].sort((a, b) => a - b);
+    const i = Math.min(s.length - 1, Math.max(0, Math.ceil((p / 100) * s.length) - 1));
+    return s[i];
+}
+export function latencyStats(xs) {
+    return { n: xs.length, p50: percentile(xs, 50), p95: percentile(xs, 95), max: xs.length ? Math.max(...xs) : null };
+}
+export class NewPairsLive {
+    dl;
+    now;
+    onChange;
+    limit;
+    polls;
+    rows = new Map();
+    client = null;
+    mode = 'off';
+    lastRecent = 0;
+    lastNewTokens = 0;
+    lastEnrich = 0;
+    createTimes = [];
+    latencies = [];
+    renderLatencies = [];
+    solPrice = null;
+    errors = {};
+    refreshing = false;
+    /** Creator / authority facts from RugCheck by mint (kept even for mints not yet in `rows`). */
+    fresh = new Map();
+    constructor(dl, opts = {}) {
+        this.dl = dl;
+        this.now = opts.now ?? (() => Date.now());
+        this.onChange = opts.onChange;
+        this.limit = opts.limit ?? MAX_ROWS;
+        this.polls = { recent: true, newTokens: true, enrich: true, ...opts.polls };
+    }
+    /** Seed the SOL price (e.g. from the screener feed) so SOL-denominated market caps show before the first poll. */
+    setSolPrice(price) {
+        if (price && price > 0) {
+            this.solPrice = price;
+            for (const row of this.rows.values())
+                if (row.mcap === null && row.marketCapSol !== null)
+                    row.mcap = row.marketCapSol * price;
+        }
+    }
+    /** Attach a PumpPortal client (live or for replay). The client is started by start(). */
+    attach(client, mode = 'live') {
+        this.client = client;
+        this.mode = mode;
+    }
+    /** Route one stream event (the client's onEvent). */
+    handleEvent(ev) {
+        if (ev.kind === 'create')
+            this.addCreate(ev.create);
+        else if (ev.kind === 'migrate' && ev.mint) {
+            const row = this.rows.get(ev.mint);
+            if (row) {
+                row.migrated = true;
+                row.bonding = 100;
+                this.onChange?.('migrate');
+            }
+        }
+    }
+    start() {
+        if (this.mode === 'live')
+            this.client?.start();
+    }
+    stop() {
+        this.client?.stop();
+    }
+    /** Replay a recorded stream through the same path (tests / --replay). */
+    replay(rec, speed = 0) {
+        if (!this.client)
+            throw new Error('no client attached for replay');
+        this.mode = 'replay';
+        return this.client.replay(rec, speed);
+    }
+    addCreate(c) {
+        const rowAt = this.now();
+        const existing = this.rows.get(c.mint);
+        const fresh = this.fresh.get(c.mint);
+        const mcap = c.marketCapSol !== null && this.solPrice ? c.marketCapSol * this.solPrice : existing?.mcap ?? null;
+        const row = existing ?? {
+            mint: c.mint, symbol: cleanText(c.symbol, 12) || '?', name: cleanText(c.name, 40), launchpad: c.launchpad, creator: c.creator || fresh?.creator || null,
+            createdAt: c.receivedAt, rowAt, receivedAt: c.receivedAt, latencyMs: Math.max(0, rowAt - c.receivedAt), drawnAt: null,
+            bonding: c.bondingPct, migrated: false, marketCapSol: c.marketCapSol, mcap, price: null, liq: null, vol: null, chg: { m5: null, h1: null },
+            holders: null, buys: null, sells: null, dev: null, org: null,
+            mintAuth: fresh?.mintAuthority ?? null, freezeAuth: fresh?.freezeAuthority ?? null,
+            initialBuySol: c.initialBuySol, spark: undefined, flags: [], socials: { x: false, tg: false, web: false }, image: null, via: ['pumpportal'],
+        };
+        if (existing) {
+            existing.bonding = c.bondingPct ?? existing.bonding;
+            existing.marketCapSol = c.marketCapSol ?? existing.marketCapSol;
+            if (!existing.via.includes('pumpportal'))
+                existing.via.push('pumpportal');
+        }
+        else {
+            this.rows.set(c.mint, row);
+            this.latencies.push(row.latencyMs);
+            if (this.latencies.length > 500)
+                this.latencies.shift();
+        }
+        this.createTimes.push(rowAt);
+        this.createTimes = this.createTimes.filter((t) => t > rowAt - 60_000);
+        this.trim();
+        this.onChange?.('create');
+    }
+    trim() {
+        if (this.rows.size <= this.limit)
+            return;
+        const sorted = this.list();
+        for (const r of sorted.slice(this.limit))
+            this.rows.delete(r.mint);
+    }
+    /** Newest first. */
+    list() {
+        return [...this.rows.values()].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /** Mark rows as drawn (called by the UI after a flush) and record receive→draw latency once per row. */
+    markDrawn(at = this.now()) {
+        for (const r of this.rows.values()) {
+            if (r.drawnAt === null && r.receivedAt !== null) {
+                r.drawnAt = at;
+                this.renderLatencies.push(Math.max(0, at - r.receivedAt));
+                if (this.renderLatencies.length > 500)
+                    this.renderLatencies.shift();
+            }
+        }
+    }
+    /** Run whichever polls are due. Never throws; errors land in `errors`. */
+    async refresh(force = false) {
+        if (this.refreshing)
+            return;
+        this.refreshing = true;
+        try {
+            const now = this.now();
+            const jobs = [];
+            const pushDown = !this.dl.health.isAvailable('pumpportal') || (this.mode === 'live' && this.client?.getStatus().state !== 'open');
+            if (this.polls.recent && (force || now - this.lastRecent >= RECENT_POLL_MS || (pushDown && now - this.lastRecent >= RECENT_POLL_MS / 3))) {
+                this.lastRecent = now;
+                jobs.push(this.pollRecent(pushDown));
+            }
+            if (this.polls.newTokens && (force || now - this.lastNewTokens >= NEW_TOKENS_POLL_MS)) {
+                this.lastNewTokens = now;
+                jobs.push(this.pollNewTokens());
+            }
+            if (this.polls.enrich && (force || now - this.lastEnrich >= ENRICH_POLL_MS)) {
+                this.lastEnrich = now;
+                jobs.push(this.pollEnrich());
+            }
+            await Promise.all(jobs);
+            if (jobs.length)
+                this.onChange?.('poll');
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+    async pollRecent(addRows) {
+        try {
+            const views = await this.dl.jupiter.recent();
+            delete this.errors['jupiter-tokens'];
+            const now = this.now();
+            for (const v of views) {
+                let row = this.rows.get(v.token.mint);
+                if (!row) {
+                    if (!addRows)
+                        continue;
+                    const created = v.token.createdAt ?? now;
+                    row = {
+                        mint: v.token.mint, symbol: cleanText(v.token.symbol, 12) || '?', name: cleanText(v.token.name, 40), launchpad: v.token.launchpad, creator: null,
+                        createdAt: created, rowAt: now, receivedAt: null, latencyMs: null, drawnAt: null, bonding: null, migrated: false, marketCapSol: null,
+                        mcap: null, price: null, liq: null, vol: null, chg: { m5: null, h1: null }, holders: null, buys: null, sells: null, dev: null, org: null,
+                        mintAuth: null, freezeAuth: null, initialBuySol: null, spark: undefined, flags: [], socials: { x: false, tg: false, web: false }, image: null, via: [],
+                    };
+                    this.rows.set(row.mint, row);
+                }
+                this.applyJup(row, v);
+            }
+            this.trim();
+        }
+        catch (err) {
+            this.errors['jupiter-tokens'] = msg(err);
+        }
+    }
+    applyJup(row, v) {
+        if (row.launchpad === 'unknown')
+            row.launchpad = v.token.launchpad;
+        row.holders = v.stats.holderCount ?? row.holders;
+        row.org = v.stats.organicScore ?? row.org;
+        row.dev = v.audit.devPct ?? row.dev;
+        if (row.mintAuth === null)
+            row.mintAuth = v.audit.mintAuthority;
+        if (row.freezeAuth === null)
+            row.freezeAuth = v.audit.freezeAuthority;
+        if (v.pair.priceUsd > 0)
+            row.price = v.pair.priceUsd;
+        row.mcap = v.pair.mcap ?? v.pair.fdv ?? row.mcap;
+        row.liq = v.pair.liquidityUsd ?? row.liq;
+        row.vol = v.pair.volume.h24 ?? row.vol;
+        row.buys = v.pair.txns.m5.buys;
+        row.sells = v.pair.txns.m5.sells;
+        row.chg = { m5: v.pair.priceChange.m5 ?? row.chg.m5, h1: v.pair.priceChange.h1 ?? row.chg.h1 };
+        row.socials = { x: !!v.token.socials.x, tg: !!v.token.socials.tg, web: !!v.token.socials.web };
+        if (row.image === null && typeof v.token.image === 'string' && /^https?:\/\//i.test(v.token.image))
+            row.image = v.token.image;
+        row.spark = impliedSpark(row.price, { m5: row.chg.m5, h1: row.chg.h1, h6: null, h24: null }, 12);
+        if (!row.via.includes('jupiter-tokens'))
+            row.via.push('jupiter-tokens');
+        row.flags = deriveFlags({ mintAuth: row.mintAuth, freezeAuth: row.freezeAuth, top10: v.audit.top10Pct, dev: row.dev, bundled: null, lpLocked: row.launchpad === 'pump.fun' ? 100 : null });
+    }
+    async pollNewTokens() {
+        try {
+            const list = await this.dl.rugcheck.newTokens();
+            delete this.errors.rugcheck;
+            for (const t of list) {
+                this.fresh.set(t.mint, t);
+                const row = this.rows.get(t.mint);
+                if (!row)
+                    continue;
+                row.creator = row.creator ?? t.creator;
+                if (t.mintAuthority !== null)
+                    row.mintAuth = t.mintAuthority;
+                if (t.freezeAuthority !== null)
+                    row.freezeAuth = t.freezeAuthority;
+                if (!row.via.includes('rugcheck'))
+                    row.via.push('rugcheck');
+                row.flags = deriveFlags({ mintAuth: row.mintAuth, freezeAuth: row.freezeAuth, top10: null, dev: row.dev, bundled: null, lpLocked: row.launchpad === 'pump.fun' ? 100 : null });
+            }
+            if (this.fresh.size > 500)
+                for (const k of [...this.fresh.keys()].slice(0, this.fresh.size - 500))
+                    this.fresh.delete(k);
+        }
+        catch (err) {
+            this.errors.rugcheck = msg(err);
+        }
+    }
+    async pollEnrich() {
+        const visible = this.list().slice(0, 29).map((r) => r.mint);
+        try {
+            const res = await this.dl.store.enrich([...visible, SOL_MINT], { price: false });
+            delete this.errors.dexscreener;
+            for (const r of res.rows) {
+                if (r.mint === SOL_MINT) {
+                    if (r.pair.priceUsd > 0)
+                        this.solPrice = r.pair.priceUsd;
+                    continue;
+                }
+                const row = this.rows.get(r.mint);
+                if (!row)
+                    continue;
+                const p = r.pair;
+                if (p.priceUsd > 0)
+                    row.price = p.priceUsd;
+                row.liq = p.liquidityUsd ?? row.liq;
+                row.mcap = r.mcap?.value ?? p.mcap ?? p.fdv ?? row.mcap;
+                row.vol = p.volume.h24 ?? row.vol;
+                row.chg = { m5: p.priceChange.m5 ?? row.chg.m5, h1: p.priceChange.h1 ?? row.chg.h1 };
+                row.buys = p.txns.m5.buys;
+                row.sells = p.txns.m5.sells;
+                if (r.stats) {
+                    row.holders = r.stats.holderCount ?? row.holders;
+                    row.org = r.stats.organicScore ?? row.org;
+                }
+                if (r.audit) {
+                    row.dev = r.audit.devPct ?? row.dev;
+                    if (row.mintAuth === null)
+                        row.mintAuth = r.audit.mintAuthority;
+                    if (row.freezeAuth === null)
+                        row.freezeAuth = r.audit.freezeAuthority;
+                }
+                if (row.image === null && typeof r.token.image === 'string' && /^https?:\/\//i.test(r.token.image))
+                    row.image = r.token.image;
+                row.spark = impliedSpark(row.price, { m5: row.chg.m5, h1: row.chg.h1, h6: p.priceChange.h6, h24: p.priceChange.h24 }, 12);
+                for (const s of r.sources)
+                    if (!row.via.includes(s))
+                        row.via.push(s);
+                row.flags = deriveFlags({ mintAuth: row.mintAuth, freezeAuth: row.freezeAuth, top10: r.audit?.top10Pct ?? null, dev: row.dev, bundled: null, lpLocked: row.launchpad === 'pump.fun' ? 100 : null });
+            }
+            Object.assign(this.errors, res.errors);
+            // SOL price arrived: convert the SOL-denominated market caps of rows nobody else priced yet
+            if (this.solPrice)
+                for (const row of this.rows.values())
+                    if (row.mcap === null && row.marketCapSol !== null)
+                        row.mcap = row.marketCapSol * this.solPrice;
+        }
+        catch (err) {
+            this.errors.dexscreener = msg(err);
+        }
+    }
+    status() {
+        const stream = this.client?.getStatus() ?? null;
+        const h = this.dl.health;
+        const perMin = this.createTimes.filter((t) => t > this.now() - 60_000).length;
+        const parts = [];
+        let headerStatus;
+        if (this.mode === 'off')
+            parts.push('push off');
+        else if (this.mode === 'replay')
+            parts.push(`replay: pumpportal ${stream?.creates ?? 0} creates`);
+        else if (stream?.state === 'open')
+            parts.push(`ws: pumpportal ${perMin}/min`);
+        else {
+            const wait = stream?.nextRetryMs ? ` in ${Math.round(stream.nextRetryMs / 1000)}s` : '';
+            parts.push(`pumpportal ${stream?.state ?? 'off'}${wait} · polling jup recent`);
+            headerStatus = '◐ degraded: pumpportal';
+        }
+        if (this.polls.recent)
+            parts.push(h.isAvailable('jupiter-tokens') ? 'jup recent' : 'jup degraded');
+        if (this.polls.newTokens)
+            parts.push(h.isAvailable('rugcheck') ? 'rugcheck' : 'rugcheck degraded');
+        if (this.polls.enrich && !h.isAvailable('dexscreener'))
+            parts.push('dexscreener degraded');
+        const degraded = ['jupiter-tokens', 'rugcheck', 'dexscreener'].filter((s) => !h.isAvailable(s));
+        if (!headerStatus && degraded.length)
+            headerStatus = `◐ degraded: ${degraded.map((s) => (s === 'jupiter-tokens' ? 'jup' : s)).join(', ')}`;
+        return {
+            stream, mode: this.mode, caption: parts.join(' · '), headerStatus, createsPerMin: this.mode === 'live' ? perMin : null,
+            latency: latencyStats(this.latencies), renderLatency: latencyStats(this.renderLatencies), errors: this.errors,
+        };
+    }
+}
+function msg(err) {
+    return err instanceof Error ? err.message : String(err);
+}