Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
feat(fade): rank every pump.fun launch by how much of its buy side has never won
nirholas585f9a968272
diff --git a/STRUCTURE.md b/STRUCTURE.mdindex 26ce7fad7..31f6a0056 100644--- a/STRUCTURE.md+++ b/STRUCTURE.md@@ -240,6 +240,7 @@ bottom.| Oracle conviction model (three heads, learned on a clock) | Fitter [api/_lib/oracle/fit.js](api/_lib/oracle/fit.js), scorer [api/_lib/oracle/conviction.js](api/_lib/oracle/conviction.js), DB-backed weights [api/_lib/oracle/model-store.js](api/_lib/oracle/model-store.js), learning loop [api/cron/oracle-refit.js](api/cron/oracle-refit.js) (every 6h), CLI [scripts/oracle-fit.mjs](scripts/oracle-fit.mjs) | Live, v3 | v2 ranked "spikes 3x or graduates", so a coin that ran 3x and went to zero counted as a hit: Prime-tier coins hit that target 58.2% of the time and rugged 53.0% of the time. v3 fits three heads over one design matrix (`win` = ran and the holder kept it, `rug` = holder down more than half, `moon` = ran at all) and anchors the public score on `win`, publishing `giveBackRisk = 1 - P(win)/P(moon)` beside it: given it runs, how often a coin like this hands the run straight back. Weights moved out of the container image into `oracle_model_versions`, so the refit cron can promote a better model between deploys; it was frozen at its 2026-08-09 fit for nineteen days because nothing but a human could refit it. Every candidate faces a promotion gate (complete fit, absolute AUC floor, every tier band still earning its claim, no feature-set collapse, a material gain over the incumbent, no regression on the other heads) and is stored either way with the reason. Thin buckets are shrunk toward zero by `n/(n+200)` so 34 samples cannot reverse a verdict. Docs: [docs/oracle-model.md](docs/oracle-model.md) || Price-independent outcome labels | [workers/agent-sniper/intel/learn.js](workers/agent-sniper/intel/learn.js) `deriveOutcome`, migrations [20260828170000](api/_lib/migrations/20260828170000_oracle_price_independent_labels.sql) + [20260828190000](api/_lib/migrations/20260828190000_oracle_recompute_rug_flag.sql) | Live | The rug flag was a readout of the SOL price. It was decided by "market cap under $3,000", and an empty pump.fun bonding curve is worth a fixed `30 * 1e9 / 1073000191 = 27.958993 SOL`, so the test amounted to asking whether SOL was above about $107.30 that day: of 206,428 coins labeled rugged, 206,419 were under $3,000; of 25,180 labeled survivors, the cheapest was exactly $3,000. Same dead curves, sorted by a price feed. Labels now use `retained = last_mc/ath_mc` and `hold_multiple = ath_multiple * retained`, both taken from the same reading so the price cancels; the real rug rate is 11.4%, not 91%, and it holds within two points from 60 minutes to three days. `label_version` marks which rule judged a row and the fitter trains on version 2 only. The training-set upsert also stopped being `do nothing`, which had made a written label permanently uncorrectable. || Coin Intelligence (the read the sniper trades on) | [pages/coin-intel.html](pages/coin-intel.html) `→ /coin-intel` (self-contained page: markup, styles and module script in one file), read API [api/pump/intel.js](api/pump/intel.js) `→ /api/pump/intel`, serverless firehose [api/cron/coin-intel-observe.js](api/cron/coin-intel-observe.js), shared finalize path [workers/agent-sniper/intel/finalize.js](workers/agent-sniper/intel/finalize.js) | Live | The public dashboard over the Coin Intelligence engine: every pump.fun launch observed for its first ~90 seconds, classified, scored 0..100, and labeled by outcome after the fact. Four views off one endpoint (`view=feed` live radar with category/verdict/quality/search filters, `view=leaderboard` best of 24h plus confirmed graduated/pumped winners, `view=traders` cross-coin wallet reputation with real win-rates, `view=learning` the per-signal weights the model learned). A coin's card opens a drawer with its launch signals, trade footprint, risk flags, a funder-cluster bubble map, the classified order book, and Oracle conviction fetched in parallel from [api/oracle/coin.js](api/oracle/coin.js). Reads `pump_coin_intel` / `pump_coin_wallets` / `pump_coin_outcomes` / `pump_intel_weights`, all written by the engine; the endpoint never writes and degrades to a designed "engine warming up" state (200 with `degraded:true`) when those tables are absent. `traders` and `learning` are whole-history aggregates and are edge-cached for minutes; the radar stays on a 5s cache and auto-refreshes every 15s. Watchlist stars share the `ld_watchlist` key with `/oracle`, `/launches` and `/watchlist`. |+| Fade Radar (the inverse of smart money) | page [pages/fade.html](pages/fade.html) `→ /fade`, client [src/fade-radar.js](src/fade-radar.js), read layer [api/_lib/fade-radar.js](api/_lib/fade-radar.js), API [api/pump/fade.js](api/pump/fade.js) `→ /api/pump/fade`, tests [tests/fade-radar.test.js](tests/fade-radar.test.js) | Live | The question the Smart Money Radar cannot ask: how much of a coin's buy side has never once been right. A reverse indicator is a wallet the graph has watched buy 5+ coins whose outcome is known with zero winners among them, read live from the same `smart_wallet_reputation` graph the firewall and the sniper scorer use, so the fade side needs no job of its own. Three boards off one endpoint (live coins ranked by fade score, the reverse-indicator wallets themselves, and the calibration), plus a per-mint read agents can gate on. The verdict bands carry a measured, out-of-sample number rather than a claim: the cohort is rebuilt from coins labelled in the earlier half of the history and graded on the later half, where `avoid` coins won 1.8% against a 22.1% baseline over 26,626 labelled coins, recomputed at most every 12 hours into `app_settings`. Never a short and never a trade: on a bonding curve the only tradeable fade is not buying. Docs: [docs/fade-radar.md](docs/fade-radar.md) || Recording Pipeline (is the data loop actually running?) | [pages/pipeline.html](pages/pipeline.html) `→ /pipeline` (self-contained page: markup, styles and module script in one file), one-call status API [api/pipeline.js](api/pipeline.js) `→ /api/pipeline`, shared derivation [api/_lib/pipeline-summary.js](api/_lib/pipeline-summary.js) | Live | One board for the whole closed loop that turns a pump.fun launch into a trade signal: the always-on recorder ([workers/agent-sniper](workers/agent-sniper)), signal intel, ground-truth outcomes, Oracle conviction, the wallet reputation graph, trained per-signal weights, and the agents trading on the result. Seven stage cards, each linking into the surface that owns it, over one endpoint that queries every stage independently so a cold worker or a table that does not exist yet reports an honest zero rather than failing the whole response. The recorder is network-scoped: `bot_heartbeat` is keyed by worker alone, so asking about devnet while the worker records mainnet answers `offline` with a reason instead of lending one network's liveness to the other. The board polls every 8s and patches its cards in place, so a card the user tabbed to keeps focus and only the one-line health summary is announced. `next_action` is the same machine-readable recommendation the page renders as its call to action, so an agent reading the JSON and a person reading the page get one answer. Docs: [docs/api-reference.md](docs/api-reference.md) (Recording Pipeline API). Tests: [tests/pipeline-summary.test.js](tests/pipeline-summary.test.js) || Agent voice cloning (your voice, on your agent) | Capture + BYOK panel [src/voice/voice-setup.js](src/voice/voice-setup.js) (`VoiceSetup`), mounted as step 5 of the create wizard ([src/create-agent.js](src/create-agent.js) `→ /create-agent`), in the agent editor, and in the talk-mode shell [src/voice/voice-clone-modal.js](src/voice/voice-clone-modal.js); server [api/agents/_id/voice.js](api/agents/_id/voice.js) `→ GET/PUT/DELETE /api/agents/:id/voice` + `POST /api/agents/:id/voice/clone`; credential resolver [api/_lib/agent-voice-key.js](api/_lib/agent-voice-key.js); playback config mapper `agentVoiceConfig` in [src/runtime/speech.js](src/runtime/speech.js), consumed by the hosted embed [pages/agent-embed.html](pages/agent-embed.html) `→ /agent/:id/embed` and the SDK runtime [src/runtime/index.js](src/runtime/index.js) | In-repo · BYOK live, platform lane awaits a key | Record or upload 30+ seconds and the agent speaks in that voice everywhere on three.ws. Three credential lanes, and they are not interchangeable: a clone only exists inside the ElevenLabs account that made it, so the winning lane is recorded on `agent_identities.voice_key_source` and replayed on every synthesis. **BYOK is the activation path today** (no platform `ELEVENLABS_API_KEY` is set on the service), and the panel renders inline key entry rather than a dead "not configured" message; setting that one variable lights up the platform lane, metered to $THREE credits. `/api/tts/eleven` only spends an owner's key when the request names the agent, which is what lets a bound voice speak to signed-out visitors inside a cross-origin embed. Docs: [docs/tutorials/voice-and-lipsync.md](docs/tutorials/voice-and-lipsync.md), [src/voice/README.md](src/voice/README.md). Tests: [tests/api/agents-voice.test.js](tests/api/agents-voice.test.js), [tests/runtime/agent-voice-config.test.js](tests/runtime/agent-voice-config.test.js) || Trading Copilot (conversational) | client [src/agent-copilot.js](src/agent-copilot.js), hub tab [src/agent-wallet-hub/tabs/copilot.js](src/agent-wallet-hub/tabs/copilot.js), server [api/agents/copilot.js](api/agents/copilot.js) `→ POST /api/agents/:id/copilot` (SSE) | In-repo | Owner-only chat over an agent's Solana wallet: text/voice in, markdown replies, live **data cards** (portfolio, firewall, quote, smart-money, intel) and **confirm-before-execute** trade/limits cards. Read-only tools run server-side; state-changing intents return as proposals the browser re-quotes and runs through the existing spend guards + firewall + custody audit. Slash commands, copy/regenerate, localStorage persistence. See [docs/trading-copilot.md](docs/trading-copilot.md) |diff --git a/api/_lib/fade-radar.js b/api/_lib/fade-radar.jsnew file mode 100644index 000000000..0962e1017--- /dev/null+++ b/api/_lib/fade-radar.js@@ -0,0 +1,529 @@+// Fade Radar, the inverse of the Smart Money Radar.+// ---------------------------------------------------------------------------+// Smart Money asks "who reputable is buying this coin". Fade Radar asks the+// question that turns out to be sharper on pump.fun: "how much of this coin's+// buy side is money that has never once been right?"+//+// A REVERSE INDICATOR is a wallet the graph has watched buy at least+// RI_MIN_JUDGED coins whose outcome is already known, and that has zero winners+// among them (a winner is a coin that graduated to an AMM, or peaked at 3x or+// better). Those wallets exist in numbers: they are the exit liquidity every+// dead launch is built on. When they crowd a fresh coin, that coin is+// overwhelmingly a coin nobody else wants.+//+// This is not a short. Nothing on the pump.fun curve can be sold before it is+// bought, so "fading" here is an AVOIDANCE signal, never an inverted position,+// and this module never emits a trade. It scores a coin, ranks the live feed by+// that score, publishes the reverse-indicator board, and reports the measured+// odds behind the score (`getFadeCalibration`) so the number can be checked+// rather than believed.+//+// Reads the same maintained graph the firewall and the sniper scorer read+// (`smart_wallet_reputation`, refreshed by api/cron/smart-money-graph), so the+// fade side stays exactly as fresh as the smart side and needs no new job.+//+// Honest degradation, matching smart-money.js: a missing DATABASE_URL, an+// uncomputed graph or a failed query resolves to a well-formed zero-data result+// with `computed:false`. It never throws and never blocks a caller. A caller can+// always tell "no data" from "clean coin" by that flag.+//+// Derived only from on-chain addresses and observed outcomes. No curated lists,+// no invented names. $THREE is the only coin three.ws promotes; every mint here+// is whatever runtime coin the caller or the live feed hands us.++const NETWORK = 'mainnet';++// Judged coins a wallet must have been observed buying before its record counts.+// Below this, a zero-winner wallet is just a new wallet.+export const RI_MIN_JUDGED = 5;+// Observed buyers a coin needs before a share is a fact rather than noise. The+// footprint table records the observation window's buyers, so a coin with three+// of them can read 66% off a single wallet.+export const MIN_BUYERS = 5;+// Reverse-indicator share of buyers at which the measured win rate collapses.+export const AVOID_SHARE = 0.25;++const CACHE_TTL_MS = 20_000;+const CALIBRATION_TTL_MS = 12 * 60 * 60 * 1000;+const CALIBRATION_KEY = 'fade_radar_calibration';++let _sqlPromise = null;+async function getSql() {+ if (_sqlPromise) return _sqlPromise;+ _sqlPromise = import('./db.js')+ .then((m) => m.sql)+ .catch((err) => {+ console.warn('[fade-radar] db import failed:', err?.message);+ return null;+ });+ return _sqlPromise;+}++const num = (v, d = 0) => (Number.isFinite(Number(v)) ? Number(v) : d);+const lamportsToSol = (v) => {+ try {+ return Math.round((Number(BigInt(v ?? 0)) / 1e9) * 1000) / 1000;+ } catch {+ return Math.round((num(v) / 1e9) * 1000) / 1000;+ }+};+const pct = (part, whole) => (whole > 0 ? Math.min(1, Math.max(0, part / whole)) : 0);+const round1 = (x) => Math.round(x * 10) / 10;++const _mintCache = new Map();+function cacheGet(key) {+ const hit = _mintCache.get(key);+ if (!hit) return undefined;+ if (Date.now() - hit.at > CACHE_TTL_MS) {+ _mintCache.delete(key);+ return undefined;+ }+ return hit.value;+}+function cacheSet(key, value) {+ _mintCache.set(key, { at: Date.now(), value });+ if (_mintCache.size > 3_000) {+ const it = _mintCache.keys();+ for (let i = 0; i < 750; i++) _mintCache.delete(it.next().value);+ }+}++/**+ * The verdict for a reverse-indicator share of the buy side.+ *+ * @param {number} buyerShare 0..1 share of observed buyers that are reverse indicators+ * @param {number} buyers observed buyers behind that share+ * @returns {'clear'|'caution'|'avoid'|'unknown'}+ */+export function fadeVerdict(buyerShare, buyers) {+ if (!Number.isFinite(buyers) || buyers < MIN_BUYERS) return 'unknown';+ if (!Number.isFinite(buyerShare) || buyerShare <= 0) return 'clear';+ return buyerShare >= AVOID_SHARE ? 'avoid' : 'caution';+}++/**+ * Score one coin's buy side. Pure, so the whole scoring contract is unit-tested+ * without a database.+ *+ * 0 is a coin no reverse indicator has touched; 100 is a coin whose entire+ * observed buy side, by wallets and by SOL, is money that has never been right.+ * Buyers and volume are both counted because they fail differently: ten dust+ * wallets are a crowd with no conviction, one large reverse-indicator buy is+ * conviction with no crowd, and a coin wants to be clean of both.+ *+ * @param {{buyers?:number, riBuyers?:number, totalBuySol?:number, riBuySol?:number}} input+ */+export function fadeScore(input = {}) {+ const buyers = Math.max(0, Math.trunc(num(input.buyers)));+ const riBuyers = Math.min(buyers, Math.max(0, Math.trunc(num(input.riBuyers))));+ const totalBuySol = Math.max(0, num(input.totalBuySol));+ const riBuySol = Math.min(totalBuySol, Math.max(0, num(input.riBuySol)));++ const buyerShare = pct(riBuyers, buyers);+ // With no volume recorded, the buyer share carries the whole score rather+ // than being halved by a zero it cannot know anything about.+ const volumeShare = totalBuySol > 0 ? pct(riBuySol, totalBuySol) : buyerShare;+ const score = Math.round(100 * (0.6 * buyerShare + 0.4 * volumeShare));++ return {+ score,+ buyers,+ ri_buyers: riBuyers,+ ri_buyer_share: Math.round(buyerShare * 1000) / 1000,+ ri_volume_share: Math.round(volumeShare * 1000) / 1000,+ ri_buy_sol: Math.round(riBuySol * 1000) / 1000,+ total_buy_sol: Math.round(totalBuySol * 1000) / 1000,+ verdict: fadeVerdict(buyerShare, buyers),+ confidence: buyers >= 10 ? 'high' : buyers >= MIN_BUYERS ? 'medium' : 'low',+ };+}++/** A plain sentence a trader can read in one second. */+export function fadeSummary(shaped) {+ const { verdict, ri_buyers: ri, buyers, score } = shaped;+ if (verdict === 'unknown') {+ return buyers > 0+ ? `Only ${buyers} buyer${buyers === 1 ? '' : 's'} observed so far, too few to read the buy side.`+ : 'No buyers observed yet, so there is nothing to read.';+ }+ if (verdict === 'clear') {+ return `None of the ${buyers} observed buyers is a proven reverse indicator.`;+ }+ const share = Math.round(shaped.ri_buyer_share * 100);+ const volShare = Math.round(shaped.ri_volume_share * 100);+ const lead = verdict === 'avoid' ? 'Heavy reverse-indicator presence' : 'Some reverse-indicator presence';+ return `${lead}: ${ri} of ${buyers} observed buyers (${share}%) and ${volShare}% of the buy volume come from wallets with no winner on record. Fade score ${score}.`;+}++/** The well-formed zero-data shape. */+function emptyMint(mint, network) {+ return {+ mint,+ network,+ ...fadeScore({}),+ notable: [],+ summary: 'No buyers observed yet, so there is nothing to read.',+ computed: false,+ };+}++/**+ * One coin's fade read: how much of its observed buy side is proven-losing money.+ *+ * @param {string} mint+ * @param {'mainnet'|'devnet'} [network]+ */+export async function getFadeForMint(mint, network = NETWORK) {+ const net = network === 'devnet' ? 'devnet' : NETWORK;+ if (!mint || typeof mint !== 'string') return emptyMint(mint, net);++ const key = `${net}:${mint}`;+ const cached = cacheGet(key);+ if (cached !== undefined) return cached;++ const sql = await getSql();+ if (!sql) {+ const empty = emptyMint(mint, net);+ cacheSet(key, empty);+ return empty;+ }++ let rows;+ try {+ // Every observed non-creator buyer of the coin, joined to its record.+ // The creator is excluded: a dev holding its own supply is a different+ // signal (dev_sold / concentration already carry it) and would otherwise+ // count once in every coin it launched.+ rows = await sql`+ SELECT w.wallet,+ w.buy_lamports,+ COALESCE(r.trades_seen, 0) AS trades_seen,+ COALESCE(r.winners, 0) AS winners,+ COALESCE(r.losers, 0) AS losers,+ r.realized_score,+ r.last_seen+ FROM pump_coin_wallets w+ LEFT JOIN smart_wallet_reputation r+ ON r.address = w.wallet AND r.network = ${net}+ WHERE w.mint = ${mint} AND w.buy_lamports > 0 AND NOT w.is_creator+ `;+ } catch (err) {+ console.warn('[fade-radar] mint read failed:', err?.message);+ const empty = emptyMint(mint, net);+ cacheSet(key, empty);+ return empty;+ }++ if (!rows.length) {+ const empty = emptyMint(mint, net);+ cacheSet(key, empty);+ return empty;+ }++ const isRi = (r) => Number(r.trades_seen) >= RI_MIN_JUDGED && Number(r.winners) === 0;+ let totalLam = 0n;+ let riLam = 0n;+ const ri = [];+ for (const r of rows) {+ let lam = 0n;+ try {+ lam = BigInt(r.buy_lamports ?? 0);+ } catch {+ lam = 0n;+ }+ totalLam += lam;+ if (isRi(r)) {+ riLam += lam;+ ri.push({+ wallet: r.wallet,+ buy_sol: lamportsToSol(lam),+ judged_buys: Number(r.trades_seen) || 0,+ winners: 0,+ losers: Number(r.losers) || 0,+ realized_score: num(r.realized_score),+ last_seen: r.last_seen,+ });+ }+ }+ ri.sort((a, b) => b.judged_buys - a.judged_buys || b.buy_sol - a.buy_sol);++ const shaped = fadeScore({+ buyers: rows.length,+ riBuyers: ri.length,+ totalBuySol: lamportsToSol(totalLam),+ riBuySol: lamportsToSol(riLam),+ });+ const result = {+ mint,+ network: net,+ ...shaped,+ notable: ri.slice(0, 8),+ summary: fadeSummary(shaped),+ computed: true,+ };+ cacheSet(key, result);+ return result;+}++/**+ * The live board: recent coins ranked by how much proven-losing money is in them.+ *+ * @param {{hours?:number, limit?:number, minBuyers?:number, network?:string}} [opts]+ */+export async function listFadeFeed(opts = {}) {+ const net = opts.network === 'devnet' ? 'devnet' : NETWORK;+ const hours = Math.min(72, Math.max(1, Math.trunc(num(opts.hours, 6))));+ const limit = Math.min(100, Math.max(1, Math.trunc(num(opts.limit, 40))));+ const minBuyers = Math.min(50, Math.max(1, Math.trunc(num(opts.minBuyers, MIN_BUYERS))));++ const sql = await getSql();+ if (!sql) return { coins: [], window_hours: hours, computed: false };++ let rows;+ try {+ rows = await sql`+ WITH recent AS (+ SELECT i.mint, i.symbol, i.name, i.image_uri, i.category, i.first_seen_at,+ i.quality_score, i.organic_score,+ (g.mint IS NOT NULL) AS graduated+ FROM pump_coin_intel i+ LEFT JOIN pumpfun_graduations g ON g.mint = i.mint+ WHERE i.network = ${net}+ AND i.first_seen_at > now() - make_interval(hours => ${hours}::int)+ )+ SELECT r.mint, r.symbol, r.name, r.image_uri, r.category, r.first_seen_at,+ r.quality_score, r.organic_score, r.graduated,+ count(*)::int AS buyers,+ count(*) FILTER (+ WHERE s.trades_seen >= ${RI_MIN_JUDGED} AND s.winners = 0+ )::int AS ri_buyers,+ sum(w.buy_lamports) AS total_lamports,+ COALESCE(sum(w.buy_lamports) FILTER (+ WHERE s.trades_seen >= ${RI_MIN_JUDGED} AND s.winners = 0+ ), 0) AS ri_lamports+ FROM recent r+ JOIN pump_coin_wallets w+ ON w.mint = r.mint AND w.buy_lamports > 0 AND NOT w.is_creator+ LEFT JOIN smart_wallet_reputation s+ ON s.address = w.wallet AND s.network = ${net}+ GROUP BY r.mint, r.symbol, r.name, r.image_uri, r.category, r.first_seen_at,+ r.quality_score, r.organic_score, r.graduated+ HAVING count(*) >= ${minBuyers}+ AND count(*) FILTER (+ WHERE s.trades_seen >= ${RI_MIN_JUDGED} AND s.winners = 0+ ) > 0+ ORDER BY (count(*) FILTER (+ WHERE s.trades_seen >= ${RI_MIN_JUDGED} AND s.winners = 0+ )::numeric / count(*)) DESC,+ count(*) DESC+ LIMIT ${limit}+ `;+ } catch (err) {+ console.warn('[fade-radar] feed read failed:', err?.message);+ return { coins: [], window_hours: hours, computed: false };+ }++ const coins = rows.map((r) => {+ const shaped = fadeScore({+ buyers: Number(r.buyers),+ riBuyers: Number(r.ri_buyers),+ totalBuySol: lamportsToSol(r.total_lamports),+ riBuySol: lamportsToSol(r.ri_lamports),+ });+ return {+ mint: r.mint,+ symbol: r.symbol,+ name: r.name,+ image_uri: r.image_uri,+ category: r.category,+ first_seen_at: r.first_seen_at,+ graduated: !!r.graduated,+ quality_score: num(r.quality_score),+ organic_score: num(r.organic_score),+ ...shaped,+ summary: fadeSummary(shaped),+ };+ });+ return { coins, window_hours: hours, computed: true };+}++/**+ * The reverse-indicator board: the wallets themselves, worst record first.+ *+ * @param {{limit?:number, minJudged?:number, activeHours?:number, network?:string}} [opts]+ */+export async function listReverseIndicators(opts = {}) {+ const net = opts.network === 'devnet' ? 'devnet' : NETWORK;+ const limit = Math.min(100, Math.max(1, Math.trunc(num(opts.limit, 25))));+ const minJudged = Math.min(500, Math.max(RI_MIN_JUDGED, Math.trunc(num(opts.minJudged, RI_MIN_JUDGED))));+ const activeHours = Math.max(0, Math.trunc(num(opts.activeHours, 0)));++ const sql = await getSql();+ if (!sql) return { wallets: [], computed: false };++ let rows;+ try {+ rows = await sql`+ SELECT address, trades_seen, winners, losers, realized_score, labels,+ first_seen, last_seen+ FROM smart_wallet_reputation+ WHERE network = ${net}+ AND winners = 0+ AND trades_seen >= ${minJudged}+ AND (${activeHours}::int = 0 OR last_seen > now() - make_interval(hours => ${activeHours}::int))+ ORDER BY trades_seen DESC, last_seen DESC NULLS LAST+ LIMIT ${limit}+ `;+ } catch (err) {+ console.warn('[fade-radar] wallet board read failed:', err?.message);+ return { wallets: [], computed: false };+ }++ return {+ computed: true,+ wallets: rows.map((r) => ({+ wallet: r.address,+ judged_buys: Number(r.trades_seen) || 0,+ winners: 0,+ losers: Number(r.losers) || 0,+ realized_score: num(r.realized_score),+ labels: Array.isArray(r.labels) ? r.labels : [],+ first_seen: r.first_seen,+ last_seen: r.last_seen,+ })),+ };+}++/**+ * The measured odds behind the score, computed out of sample.+ *+ * The honesty problem this solves: a wallet's record is built from coin outcomes,+ * so scoring the same coins it was built on would grade the signal on its own+ * answer sheet. So the labelled history is split in half by outcome time, the+ * reverse-indicator cohort is rebuilt using ONLY coins labelled in the earlier+ * half, and the win rate is measured on coins labelled in the later half, which+ * that cohort could not have seen. What comes back is the real thing: how often a+ * coin in each band went on to graduate or 3x, against the baseline for coins+ * with no reverse indicator in them at all.+ *+ * The query walks the full labelled history, so the result is cached in+ * `app_settings` for CALIBRATION_TTL_MS and served stale while a refresh runs.+ *+ * @param {{network?:string, force?:boolean}} [opts]+ */+export async function getFadeCalibration(opts = {}) {+ const net = opts.network === 'devnet' ? 'devnet' : NETWORK;+ const sql = await getSql();+ if (!sql) return { bands: [], computed: false };++ let stored = null;+ try {+ const [row] = await sql`SELECT value FROM app_settings WHERE key = ${CALIBRATION_KEY}`;+ stored = row?.value ?? null;+ } catch {+ stored = null;+ }+ const age = stored?.computed_at ? Date.now() - Date.parse(stored.computed_at) : Infinity;+ if (stored && !opts.force && Number.isFinite(age) && age < CALIBRATION_TTL_MS) return stored;++ let fresh;+ try {+ fresh = await computeCalibration(sql, net);+ } catch (err) {+ console.warn('[fade-radar] calibration failed:', err?.message);+ return stored ?? { bands: [], computed: false };+ }+ try {+ await sql`+ INSERT INTO app_settings (key, value)+ VALUES (${CALIBRATION_KEY}, ${JSON.stringify(fresh)}::jsonb)+ ON CONFLICT (key) DO UPDATE SET value = excluded.value+ `;+ } catch (err) {+ console.warn('[fade-radar] calibration store failed:', err?.message);+ }+ return fresh;+}++async function computeCalibration(sql, net) {+ const rows = await sql`+ WITH judged AS (+ SELECT o.mint, o.outcome, o.labeled_at,+ (o.outcome IN ('graduated', 'pumped')) AS win+ FROM pump_coin_outcomes o+ WHERE o.outcome IN ('graduated', 'pumped', 'flat', 'rugged')+ ),+ span AS (+ SELECT min(labeled_at) AS lo, max(labeled_at) AS hi FROM judged+ ),+ split AS (+ SELECT lo + (hi - lo) / 2 AS at FROM span+ ),+ train AS (+ SELECT w.wallet, count(*)::int AS n, count(*) FILTER (WHERE j.win)::int AS wins+ FROM pump_coin_wallets w+ JOIN judged j ON j.mint = w.mint+ WHERE w.buy_lamports > 0 AND NOT w.is_creator+ AND j.labeled_at < (SELECT at FROM split)+ GROUP BY w.wallet+ ),+ test AS (+ SELECT j.mint, j.outcome, j.win FROM judged j+ WHERE j.labeled_at >= (SELECT at FROM split)+ ),+ per_coin AS (+ SELECT t.mint,+ count(*)::int AS buyers,+ count(*) FILTER (+ WHERE tr.n >= ${RI_MIN_JUDGED} AND tr.wins = 0+ )::int AS ri_buyers+ FROM test t+ JOIN pump_coin_wallets w+ ON w.mint = t.mint AND w.buy_lamports > 0 AND NOT w.is_creator+ LEFT JOIN train tr ON tr.wallet = w.wallet+ GROUP BY t.mint+ )+ SELECT CASE+ WHEN p.ri_buyers::numeric / p.buyers >= ${AVOID_SHARE} THEN 'avoid'+ WHEN p.ri_buyers > 0 THEN 'caution'+ ELSE 'clear'+ END AS band,+ count(*)::int AS coins,+ round(100.0 * avg(CASE WHEN t.win THEN 1 ELSE 0 END), 2) AS win_pct,+ round(100.0 * avg(CASE WHEN t.outcome = 'graduated' THEN 1 ELSE 0 END), 2) AS graduated_pct,+ round(100.0 * avg(CASE WHEN t.outcome = 'rugged' THEN 1 ELSE 0 END), 2) AS rugged_pct+ FROM per_coin p+ JOIN test t ON t.mint = p.mint+ WHERE p.buyers >= ${MIN_BUYERS}+ GROUP BY 1+ `;+ const byBand = new Map(rows.map((r) => [r.band, r]));+ const baseline = byBand.get('clear');+ const baselineWin = baseline ? num(baseline.win_pct) : 0;+ const bands = ['clear', 'caution', 'avoid'].map((band) => {+ const r = byBand.get(band);+ const winPct = r ? num(r.win_pct) : 0;+ return {+ band,+ coins: r ? Number(r.coins) : 0,+ win_pct: round1(winPct),+ graduated_pct: r ? round1(num(r.graduated_pct)) : 0,+ rugged_pct: r ? round1(num(r.rugged_pct)) : 0,+ // How many times likelier a coin in this band is to win than one with+ // no reverse indicator in it. Below 1 is the whole point of the page.+ lift: baselineWin > 0 ? Math.round((winPct / baselineWin) * 100) / 100 : null,+ };+ });+ return {+ computed: true,+ network: net,+ bands,+ baseline_win_pct: round1(baselineWin),+ sample_coins: bands.reduce((a, b) => a + b.coins, 0),+ method: 'out_of_sample_time_split',+ ri_min_judged: RI_MIN_JUDGED,+ min_buyers: MIN_BUYERS,+ avoid_share: AVOID_SHARE,+ computed_at: new Date().toISOString(),+ };+}diff --git a/api/pump/fade.js b/api/pump/fade.jsnew file mode 100644index 000000000..1261025e9--- /dev/null+++ b/api/pump/fade.js@@ -0,0 +1,90 @@+/**+ * Fade Radar, the inverse of the Smart Money Radar, as a public read API.+ *+ * GET /api/pump/fade → live board: recent coins ranked+ * &hours=6&limit=40&min_buyers=5 by how much proven-losing money+ * is in them+ * GET /api/pump/fade?mint=<addr> → one coin's fade read, with the+ * reverse-indicator wallets in it+ * (an unobserved coin resolves+ * 200 + computed:false, matching+ * the intel / smart-money+ * convention, so detail pages+ * never 404)+ * GET /api/pump/fade?wallets=1 → the reverse-indicator board+ * &limit=25&min_judged=5&active_hours=24+ * GET /api/pump/fade?calibration=1 → the measured, out-of-sample odds+ * behind the verdict bands+ *+ * A reverse indicator is a wallet observed buying at least five coins whose+ * outcome is now known, with zero winners among them. This endpoint never emits+ * a trade and never inverts a position: on a bonding curve the only tradeable+ * form of "fade" is not buying. Every number traces to observed on-chain buys+ * and recorded outcomes. Public and IP rate-limited.+ */++import { cors, json, method, error, wrap, rateLimited } from '../_lib/http.js';+import { limits, clientIp } from '../_lib/rate-limit.js';+import {+ getFadeForMint,+ listFadeFeed,+ listReverseIndicators,+ getFadeCalibration,+ RI_MIN_JUDGED,+ MIN_BUYERS,+} from '../_lib/fade-radar.js';++const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;++export default wrap(async (req, res) => {+ if (cors(req, res, { methods: 'GET,OPTIONS', origins: '*' })) return;+ if (!method(req, res, ['GET'])) return;+ const rl = await limits.mcpIp(clientIp(req));+ if (!rl.success) return rateLimited(res, rl);++ const url = new URL(req.url, 'http://x');+ const mint = url.searchParams.get('mint');++ if (mint) {+ const addr = mint.trim();+ if (!BASE58_RE.test(addr)) {+ return error(res, 400, 'invalid_mint', 'mint must be a base58 Solana address');+ }+ const coin = await getFadeForMint(addr);+ return json(res, 200, coin, { 'cache-control': 'public, max-age=15, stale-while-revalidate=30' });+ }++ if (url.searchParams.has('calibration')) {+ const calibration = await getFadeCalibration();+ return json(res, 200, calibration, {+ 'cache-control': 'public, max-age=3600, stale-while-revalidate=21600',+ });+ }++ if (url.searchParams.has('wallets')) {+ const board = await listReverseIndicators({+ limit: clampInt(url.searchParams.get('limit'), 1, 100, 25),+ minJudged: clampInt(url.searchParams.get('min_judged'), RI_MIN_JUDGED, 500, RI_MIN_JUDGED),+ activeHours: clampInt(url.searchParams.get('active_hours'), 0, 24 * 90, 0),+ });+ return json(res, 200, board, { 'cache-control': 'public, max-age=60, stale-while-revalidate=120' });+ }++ const feed = await listFadeFeed({+ hours: clampInt(url.searchParams.get('hours'), 1, 72, 6),+ limit: clampInt(url.searchParams.get('limit'), 1, 100, 40),+ minBuyers: clampInt(url.searchParams.get('min_buyers'), 1, 50, MIN_BUYERS),+ });+ return json(res, 200, feed, { 'cache-control': 'public, max-age=20, stale-while-revalidate=60' });+});++// An absent query param is `null`, and `Number(null)` is 0, which is finite: a+// naive clamp turns "not supplied" into the floor rather than the default, so+// /api/pump/fade with no params answered for one hour instead of six and+// ?limit= unset would have returned a single row. Missing means default here.+function clampInt(v, lo, hi, def) {+ if (v == null || String(v).trim() === '') return def;+ const n = Math.floor(Number(v));+ if (!Number.isFinite(n)) return def;+ return Math.min(hi, Math.max(lo, n));+}diff --git a/api/pump/smart-money.js b/api/pump/smart-money.jsindex 94a630344..a0794756c 100644--- a/api/pump/smart-money.js+++ b/api/pump/smart-money.js@@ -258,12 +258,19 @@ function shapeWallet(r) {};}+// An absent query param is `null`, and `Number(null)` is 0, which is finite: the+// clamp then read "not supplied" as the floor rather than the default, so a bare+// /api/pump/smart-money answered with a single coin instead of the documented 50+// (the page always passed a limit, so only API callers saw it). Missing means+// default; a supplied value that is not a number still means default too.function clampInt(v, lo, hi, def) {+ if (v == null || String(v).trim() === '') return def;const n = Math.floor(Number(v));if (!Number.isFinite(n)) return def;return Math.min(hi, Math.max(lo, n));}function clampNum(v, lo, hi, def) {+ if (v == null || String(v).trim() === '') return def;const n = Number(v);if (!Number.isFinite(n)) return def;return Math.min(hi, Math.max(lo, n));diff --git a/data/changelog.json b/data/changelog.jsonindex 7ff5822b4..034df22ee 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -1,6 +1,15 @@{"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security. `link` is optional and must be a live three.ws path.","entries": [+ {+ "date": "2026-09-09",+ "title": "Fade Radar: the wallets that have never once been right, and the coins they are crowding into",+ "summary": "The Smart Money Radar tells you which proven winners are buying a coin. Fade Radar is the other half of that question, and on pump.fun it turns out to be the sharper one: how much of a coin's buy side is money that has never been right. A wallet joins the reverse-indicator board only after five coins it bought have a known outcome and not one of them won, which is a bar a surprising number of addresses clear. The new page ranks every launch from the last few hours by how much of its observed buy side belongs to those wallets, by wallet count and by SOL, and carries a second board of the wallets themselves with their full record. The number above the board is the part we care most about: it is measured, not asserted. We rebuild the reverse-indicator group using only coins whose outcome was known before the coins it is graded on existed, then check what actually happened. Coins where a quarter or more of the buyers were reverse indicators went on to win 1.8 percent of the time, against 22.1 percent for coins with none, across 26,626 labelled coins. Nothing here is a short and nothing signs anything: on a bonding curve the only tradeable form of a fade is not buying, so every action on the page is a link out to the coin, its intel, or a wallet's track record. Wallet links also now open directly on the Smart Money Radar, so an address cited anywhere on the platform lands on its record instead of a board you have to scan by eye.",+ "tags": [+ "feature"+ ],+ "link": "/fade"+ },{"date": "2026-09-09","title": "Paid 3D services now refuse a job they cannot deliver, instead of charging for it",diff --git a/data/pages.json b/data/pages.jsonindex bc8af9758..af4e54181 100644--- a/data/pages.json+++ b/data/pages.json@@ -1789,6 +1789,14 @@"changefreq": "daily","added": "2026-06-15"},+ {+ "path": "/fade",+ "title": "Fade Radar: the wallets that are never right",+ "description": "The inverse of the Smart Money Radar. Every pump.fun coin ranked by how much of its buy side comes from wallets with a judged on-chain record and not one winner in it, with the measured, out-of-sample odds behind each verdict.",+ "priority": 0.8,+ "changefreq": "daily",+ "added": "2026-09-09"+ },{"path": "/pumpfun","title": "Pump.fun Stream",@@ -3425,6 +3433,14 @@"changefreq": "monthly","added": "2026-07-18"},+ {+ "path": "/docs/fade-radar",+ "title": "Docs · Fade Radar",+ "description": "How the Fade Radar scores a coin's buy side: what makes a wallet a reverse indicator, the 0 to 100 fade score, the verdict bands, and the out-of-sample measurement behind them.",+ "priority": 0.7,+ "changefreq": "monthly",+ "added": "2026-09-09"+ },{"path": "/docs/radar","title": "Docs · Coin Radar",diff --git a/docs/fade-radar.md b/docs/fade-radar.mdnew file mode 100644index 000000000..4ebca0b12--- /dev/null+++ b/docs/fade-radar.md@@ -0,0 +1,134 @@+# Fade Radar: the wallets that are never right++Fade Radar is the inverse of the [Smart Money Radar](./smart-money.md). Smart Money asks who reputable is buying a coin. Fade Radar asks how much of a coin's buy side has never once been right, and answers with a 0 to 100 fade score, a verdict, and the measured odds behind that verdict.++Page: [/fade](https://three.ws/fade)++API: `/api/pump/fade` (live coin board, per-coin read, reverse-indicator wallet board, calibration).++## Why it exists++Most pump.fun launches die quietly, and the wallets that buy them are not random. A large group of addresses has been observed buying dozens of coins with a known outcome and has never held one that graduated or tripled. They are the exit liquidity every dead launch is built on, and they cluster: when several of them show up on the same fresh coin, that coin is overwhelmingly a coin nobody else wants.++That is a signal you cannot read off a chart in the first minutes of a launch, and it is the honest mirror of the smart-money read: instead of asking whether proven winners are here, it asks whether proven losers are all that is here.++**This is not a short.** Nothing on a bonding curve can be sold before it is bought, so the only tradeable form of a fade is not buying. Fade Radar never emits a trade, never inverts a position, and nothing on the page signs anything.++## The definition++A **reverse indicator** is a wallet where both hold:++- the graph has watched it buy at least **5** coins whose outcome is already known (`trades_seen >= 5`), and+- **zero** of those coins won (`winners = 0`).++A **win** is a coin that graduated to an AMM, or peaked at 3x or better on market cap. Both come from `pump_coin_outcomes`, the same labelled ground truth the Coin Intelligence engine learns from. A wallet below the 5-coin bar is simply new, not bad, and never appears here.++Reverse-indicator status is read live from `smart_wallet_reputation`, the wallet graph that `api/cron/smart-money-graph` maintains, so the fade side is exactly as fresh as the smart side and needs no job of its own.++## The score++For one coin, over its observed non-creator buyers (`pump_coin_wallets`):++```+buyerShare = reverse-indicator buyers / observed buyers+volumeShare = reverse-indicator buy lamports / observed buy lamports+fade_score = round(100 * (0.6 * buyerShare + 0.4 * volumeShare))+```++Buyers and volume are both counted because they fail differently: ten dust wallets are a crowd with no conviction, one large reverse-indicator buy is conviction with no crowd, and a coin wants to be clean of both. When no buy volume has been recorded yet, the buyer share carries the whole score rather than being halved by a zero that means nothing.++The verdict follows the buyer share:++| Verdict | Condition |+| --- | --- |+| `unknown` | fewer than 5 observed buyers, too thin to read |+| `clear` | no reverse indicator among the buyers |+| `caution` | some reverse-indicator presence, under 25 percent of buyers |+| `avoid` | 25 percent of buyers or more |++The creator is excluded from every count: a dev holding its own supply is a different signal, already carried by dev-sold and concentration, and would otherwise count once in every coin it launched.++## The calibration, and why it is honest++A wallet's record is built from coin outcomes, so scoring the same coins that record was built on would grade the signal on its own answer sheet. `getFadeCalibration` avoids that with a time split:++1. Take every labelled coin and split the history in half by label time.+2. Rebuild the reverse-indicator cohort using **only** coins labelled in the earlier half.+3. Measure how often coins labelled in the **later** half went on to win, by band.++The later-half coins could not have contributed to the cohort that grades them, so the result is out of sample. On the history as of 2026-09-09, over 26,626 labelled coins:++| Band | Coins | Went on to win |+| --- | --- | --- |+| `clear` | 22,473 | 22.1 percent |+| `caution` | 3,541 | 15.7 percent |+| `avoid` | 612 | 1.8 percent |++A coin in the `avoid` band won at roughly one twelfth the baseline rate. The numbers are recomputed from live history at most every 12 hours and cached in `app_settings` under `fade_radar_calibration`, so the page always shows a measurement rather than a claim.++This is a probabilistic read on a hostile market. It is not a prediction and not advice: a `clear` coin can still go to zero.++## API++```bash+# Live board: coins launched in the last 6 hours with proven-losing money in them+curl 'https://three.ws/api/pump/fade?hours=6&limit=40'++# One coin, with the reverse-indicator wallets inside it+curl 'https://three.ws/api/pump/fade?mint=<mint>'++# The reverse-indicator wallets themselves, worst record first+curl 'https://three.ws/api/pump/fade?wallets=1&min_judged=8&active_hours=24'++# The measured, out-of-sample odds behind the bands+curl 'https://three.ws/api/pump/fade?calibration=1'+```++A coin read returns:++```json+{+ "mint": "<mint>",+ "score": 86,+ "verdict": "avoid",+ "buyers": 5,+ "ri_buyers": 4,+ "ri_buyer_share": 0.8,+ "ri_volume_share": 0.959,+ "confidence": "medium",+ "notable": [{ "wallet": "<address>", "judged_buys": 41, "winners": 0, "losers": 41 }],+ "summary": "Heavy reverse-indicator presence: 4 of 5 observed buyers (80%) and 96% of the buy volume come from wallets with no winner on record. Fade score 86.",+ "computed": true+}+```++A coin the engine has not observed resolves `200` with `computed: false` rather than a 404, matching the intel and smart-money detail endpoints, so a detail page can always render. Every read degrades the same way: a missing database or a failed query returns the well-formed zero-data shape instead of throwing.++## Using it from an agent++```js+import { getFadeForMint } from '../api/_lib/fade-radar.js';++const fade = await getFadeForMint(mint);+if (fade.computed && fade.verdict === 'avoid') {+ // Skip. Coins in this band won 1.8% of the time against a 22% baseline.+ return { decision: 'PASS', why: fade.summary };+}+```++The module is a pure read layer with no side effects, and `fadeScore` / `fadeVerdict` / `fadeSummary` are exported as pure functions so a caller can score a buy side it already has in hand without a database round trip.++## Where it fits++- [Smart Money Radar](./smart-money.md): the same graph read from the winning side. A wallet on the fade board links straight to its full track record there.+- [Coin Intelligence](./trading-surfaces.md): the engine that records every launch, labels its outcome, and produces the ground truth both radars stand on.+- [Coin Radar](./radar.md): what launched in the last 90 seconds, where a fade read is the fastest reason to skip one.++## Files++| Path | What it holds |+| --- | --- |+| `api/_lib/fade-radar.js` | The read layer: scoring, the coin board, the wallet board, the calibration |+| `api/pump/fade.js` | The public HTTP surface |+| `pages/fade.html`, `src/fade-radar.js` | The page |+| `tests/fade-radar.test.js` | The scoring contract |diff --git a/docs/nav.json b/docs/nav.jsonindex 6890aee2f..dd97dfab7 100644--- a/docs/nav.json+++ b/docs/nav.json@@ -397,6 +397,10 @@"label": "Smart Money Radar","path": "smart-money"},+ {+ "label": "Fade Radar",+ "path": "fade-radar"+ },{"label": "Coin Radar","path": "radar"diff --git a/docs/smart-money.md b/docs/smart-money.mdindex 92cd39fef..8f99f24b1 100644--- a/docs/smart-money.md+++ b/docs/smart-money.md@@ -91,10 +91,12 @@ for (const c of conviction.slice(0, 5)) {- **Warm-up window.** A coin is not judged until roughly 6 hours after launch, so a very fresh coin shows "not scored yet." The per-coin read deliberately returns `200 { found: false }` rather than a 404 for an unscored mint.- **Input validation.** A `wallet` or `mint` that is not a base58 Solana address is refused at the boundary with `400 invalid_wallet` / `400 invalid_mint`, so "that is not an address" and "no track record yet" stay different answers. Every error on the route, the wallet 404 included, carries the shared `{ error, error_description }` shape.- **Empty and error states.** The feed, leaderboard, and watchlist each have designed empty copy ("No proven money on a fresh coin yet," "No wallets ranked yet"). A wallet with no history returns 404 and renders "No track record yet." A failed full refresh shows a stale-data reconnecting bar with a Retry button and escalates its message after repeated failures. The watchlist tells a network failure apart from an honest "not on the radar": when every lookup fails to reach the API (or answers 5xx), the grid shows one "Couldn't reach the radar" panel with a Retry and keeps the saved list, and a single unreachable coin gets a "Couldn't load this one" card rather than being labelled unscored.+- **Deep links.** `/smart-money?wallet=<address>` and `/smart-money?mint=<address>` open that drawer on load, so an address cited on another surface (the [Fade Radar](./fade-radar.md) board, a shared link) lands on its record instead of an unfiltered board. A malformed address is ignored rather than opening an empty drawer.- **Two engines, one name.** This page reads `/api/pump/smart-money` (the graduation-outcome rollup). A sibling endpoint, `/api/intel/smart-money`, is a distinct funder-cluster and sybil-detection graph used by other surfaces. They answer related questions from different tables; do not conflate them.## Related+- [Fade Radar](./fade-radar.md) reads the same graph from the losing side: the wallets with a judged record and no winners in it, and the coins they are crowding into. A wallet on that board links back into this page's drawer- [Oracle: the conviction engine](./oracle.md) uses this proven-wallet ledger as its WHO pillar- [The trading surfaces](./trading-surfaces.md) map, including the Coin Intelligence cross-coin trader board- [Coin Radar](./radar.md) and [Mission Control](./terminal.md) surface the same pedigree read inlinediff --git a/docs/trading-surfaces.md b/docs/trading-surfaces.mdindex dd3d00d4b..a7edc1e01 100644--- a/docs/trading-surfaces.md+++ b/docs/trading-surfaces.md@@ -1,6 +1,6 @@-# The trading surfaces: Radar, Mission Control, Live Trade Feed, Watchlist, Coin Intelligence+# The trading surfaces: Radar, Mission Control, Live Trade Feed, Watchlist, Coin Intelligence, Fade Radar-The platform's trading stack is spread across five public pages. Four of them are intelligence surfaces (they exist to answer "what's launching, what's real, who's winning") and one, Mission Control, is the full cockpit where a signed-in user trades from their agent's wallet. The intelligence pages are no longer dead ends: the Coin Radar and the Live Trade Feed (along with the [Smart Money Radar](smart-money.md) and [Ghost-copy](ghost-copy.md)) each carry a [Fork](fork-trade.md) button that opens the real pump.fun trade panel for the coin you are looking at, signed by your own wallet. This doc explains what each surface is, where its numbers come from, and how they fit together.+The platform's trading stack is spread across six public pages. Five of them are intelligence surfaces (they exist to answer "what's launching, what's real, who's winning") and one, Mission Control, is the full cockpit where a signed-in user trades from their agent's wallet. The intelligence pages are no longer dead ends: the Coin Radar and the Live Trade Feed (along with the [Smart Money Radar](smart-money.md) and [Ghost-copy](ghost-copy.md)) each carry a [Fork](fork-trade.md) button that opens the real pump.fun trade panel for the coin you are looking at, signed by your own wallet. This doc explains what each surface is, where its numbers come from, and how they fit together.The one-line map:@@ -8,6 +8,7 @@ The one-line map:| --- | --- | --- | --- || Coin Radar | [/radar](https://three.ws/radar) | What launched in the last 90 seconds, and is it real? | Fork, from your own wallet || Coin Intelligence | [/coin-intel](https://three.ws/coin-intel) | What did the intel engine learn about every launch? | No |+| Fade Radar | [/fade](https://three.ws/fade) | Which coins is the money that is never right crowding into? | No || Live Trade Feed | [/trades](https://three.ws/trades) | Which trades actually won, and what did the winner see? | Fork, from your own wallet || Watchlist | [/watchlist](https://three.ws/watchlist) | What are *my* coins doing right now? | Buy via coin card || Mission Control | [/terminal](https://three.ws/terminal) | Everything, live — and execute. | Yes, from your agent wallet |@@ -16,7 +17,7 @@ Everything below is public and works signed-out except executing trades in Missi## Where the numbers come from-All five surfaces read the same underlying truth: the Coin Intelligence Engine (`workers/agent-sniper/intel`) watches every new pump.fun coin's first ~90 seconds of trading over the live firehose and persists what it saw — bundle patterns, organic demand, wallet concentration, funder clusters — to Postgres (`pump_coin_intel`, `pump_coin_wallets`, `pump_coin_outcomes`, `pump_intel_weights`). Every number on these pages traces to an on-chain trade the engine observed. When a signal wasn't measured for a coin, the UI says "not measured" — it never renders a fake zero.+All six surfaces read the same underlying truth: the Coin Intelligence Engine (`workers/agent-sniper/intel`) watches every new pump.fun coin's first ~90 seconds of trading over the live firehose and persists what it saw (bundle patterns, organic demand, wallet concentration, funder clusters) to Postgres (`pump_coin_intel`, `pump_coin_wallets`, `pump_coin_outcomes`, `pump_intel_weights`). Every number on these pages traces to an on-chain trade the engine observed. When a signal wasn't measured for a coin, the UI says "not measured": it never renders a fake zero.On top of that base layer:@@ -53,6 +54,14 @@ Four tabs:If the engine is still warming up (fresh deploy, empty tables), the page says so honestly instead of rendering blanks. Public, no account, refreshes every 15 seconds. A caller mistake is answered as one, never as an outage: an unknown `view`, a non-base58 `mint`, or a `minQuality` outside 0-100 gets a `400` (`invalid_view`, `invalid_mint`, `invalid_min_quality`) rather than the "warming up" state. The feed's `q` search runs in SQL over the whole observed feed, and a `verdict` filter (derived after the row is shaped) scans up to 600 recent rows before slicing to the requested page, so `?verdict=strong` on a busy feed no longer answers with the one strong coin that happened to sit on page one. The `traders` and `learning` views are whole-history aggregates and are edge-cached for 5 minutes; the feed stays on a 5-second cache.+## Fade Radar: /fade++The inverse read, and the fastest reason to skip a coin. A **reverse indicator** is a wallet the graph has watched buy at least five coins whose outcome is already known, with zero winners among them (a win is a graduation to an AMM, or a 3x peak). Those wallets are the exit liquidity every dead launch is built on, and they cluster. The page ranks recent launches by how much of the observed buy side is theirs, by wallets and by SOL, and carries a second board of the reverse indicators themselves.++What makes the verdict worth reading is that it is measured rather than asserted: the cohort is rebuilt from coins labelled in the earlier half of the recorded history, then graded on the later half it could not have seen. Coins in the `avoid` band (a quarter of observed buyers or more) went on to win 1.8 percent of the time against a 22.1 percent baseline, over 26,626 labelled coins. The page shows that table above the board and recomputes it from live history.++Nothing here is a short. On a bonding curve the only tradeable form of a fade is not buying, so the page emits no trade and signs nothing; a wallet on the board links straight to its full track record on the [Smart Money Radar](smart-money.md). Full detail: [docs/fade-radar.md](fade-radar.md).+## Live Trade Feed — /tradesThe proof stream. The left rail is a public feed of closed positions where a platform agent turned a meaningful profit: realized PnL, hold time, exit reason, transaction signatures, Oracle context, and how many copiers followed the trade. Filter by time window (1h → all-time) and minimum PnL (`min_pnl_pct`, default 10). $THREE is pinned at the top of the rail. Each row's `multiple` is derived from the position's cumulative realized percentage rather than exit over entry, because a position that took initials first rewrites its cost basis and books only the closing leg's proceeds. Pages walk a `cursor` (an ISO 8601 timestamp; anything else is a `400 validation_error`) ordered by close time then position id, so two exits sharing a timestamp cannot reorder between pages.@@ -124,6 +133,11 @@ curl 'https://three.ws/api/pump/intel?mint=<MINT>'# Proven-wallet pedigree for one coin, or one wallet's reputation (both base58-validated)curl 'https://three.ws/api/intel/smart-money?mint=<MINT>'+# The fade side: one coin's reverse-indicator share, the live board, the measured odds+curl 'https://three.ws/api/pump/fade?mint=<MINT>'+curl 'https://three.ws/api/pump/fade?hours=6&limit=20'+curl 'https://three.ws/api/pump/fade?calibration=1'+# Winning-trade feedcurl 'https://three.ws/api/trades/feed'@@ -135,6 +149,7 @@ Agents wanting the same intel over MCP: see [docs/mcp.md](mcp.md) (`@three-ws/in## Related+- [Fade Radar: the wallets that are never right](fade-radar.md): the reverse-indicator read behind the `/fade` board- [Meta-Allocator: the ETF of degens](meta-allocator.md): diversify a budget across the top verified leaders- [Clip Director: every trade becomes content](clip-director.md): turn any closed trade into shareable cards per surface- [The Trading Copilot — talk to your wallet](trading-copilot.md) — conversational trading over these same numbersdiff --git a/pages/fade.html b/pages/fade.htmlnew file mode 100644index 000000000..6760b1f81--- /dev/null+++ b/pages/fade.html@@ -0,0 +1,202 @@+<!doctype html>+<html lang="en">+ <head>+ <script>/* three.ws theme boot */(function(){try{var m=localStorage.getItem('twx_theme');var l=m==='auto'?(window.matchMedia&&window.matchMedia('(prefers-color-scheme: light)').matches):m==='light';document.documentElement.setAttribute('data-theme',l?'light':'dark');}catch(e){document.documentElement.setAttribute('data-theme','dark');}})();</script>+ <meta charset="utf-8" />+ <script src="/referral-capture.js"></script>+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />+ <title>Fade Radar: the wallets that are never right · three.ws</title>+ <meta name="description" content="The inverse of the Smart Money Radar. Every pump.fun coin ranked by how much of its buy side comes from wallets with a judged record and not one winner in it, with the measured, out-of-sample odds behind each verdict." />+ <meta property="og:type" content="website" />+ <meta property="og:site_name" content="three.ws" />+ <meta property="og:url" content="https://three.ws/fade" />+ <meta property="og:title" content="Fade Radar: the wallets that are never right · three.ws" />+ <meta property="og:description" content="Some wallets have bought dozens of coins and never once been right. When they crowd a launch, that launch wins 1.8% of the time against a 22% baseline. Here is where they are right now." />+ <meta property="og:image" content="https://three.ws/api/page-og?s=crypto&t=Fade+Radar%3A+the+wallets+that+are+never+right&d=Every+pump.fun+coin+ranked+by+how+much+of+its+buy+side+is+money+with+a+judged+record+and+not+one+winner+in+it&p=%2Ffade" />+ <meta property="og:image:width" content="1200" />+ <meta property="og:image:height" content="630" />+ <meta name="twitter:card" content="summary_large_image" />+ <meta name="twitter:site" content="@trythreews" />+ <meta name="twitter:title" content="Fade Radar: the wallets that are never right · three.ws" />+ <meta name="twitter:description" content="The inverse of the Smart Money Radar: which coins the proven-losing wallets are crowding into right now, and the measured odds behind the call." />+ <meta name="theme-color" content="#0a0a0a" />+ <link rel="icon" href="/favicon.ico" sizes="any" />+ <link rel="icon" type="image/svg+xml" href="/favicon.svg" />+ <link rel="apple-touch-icon" href="/apple-touch-icon.png" />+ <link rel="manifest" href="/manifest.webmanifest" />+ <link rel="stylesheet" href="/fonts/fonts.css" />+ <link rel="stylesheet" href="/tokens.css" />+ <link rel="stylesheet" href="/nav.css" />+ <link rel="stylesheet" href="/footer.css" />+ <script defer src="/footer-newsletter.js"></script>+ <link rel="canonical" href="https://three.ws/fade" />+ <meta name="robots" content="index, follow, max-image-preview:large, max-snippet:-1" />+ <script type="application/ld+json">{"@context":"https://schema.org","@type":"WebApplication","name":"Fade Radar","applicationCategory":"FinanceApplication","operatingSystem":"Web","description":"The inverse of the Smart Money Radar: pump.fun coins ranked by how much of their buy side comes from wallets with a judged on-chain record and no winners in it, with out-of-sample odds behind every verdict.","url":"https://three.ws/fade","isPartOf":{"@type":"WebSite","name":"three.ws","url":"https://three.ws"}}</script>+ <style>+ :root {+ --fr-bg: #0a0a0b; --fr-panel: #121214; --fr-panel-2: #17171a; --fr-line: #26262b;+ --fr-text: #f5f5f7; --fr-dim: #a1a1aa; --fr-faint: #6b6b74;+ --fr-accent: #fb7185; --fr-accent-2: #22d3ee; --fr-green: #34d399; --fr-amber: var(--warn);+ --fr-chip: #1e1e24;+ }+ :root[data-theme='light'] {+ --fr-bg: #fafafa; --fr-panel: #ffffff; --fr-panel-2: #f4f4f6; --fr-line: #e4e4e8;+ --fr-text: #14141a; --fr-dim: #52525b; --fr-faint: #8a8a93; --fr-chip: #eef0f4;+ }+ * { box-sizing: border-box; }+ body { margin: 0; background: var(--fr-bg); color: var(--fr-text); font-family: 'Inter', system-ui, -apple-system, sans-serif; -webkit-font-smoothing: antialiased; }+ .fr { max-width: 1080px; margin: 0 auto; padding: 28px 20px 80px; }+ .fr-kicker { font-size: 12px; letter-spacing: .12em; text-transform: uppercase; color: var(--fr-accent); font-weight: 600; margin: 8px 0 10px; }+ .fr-title { font-size: clamp(26px, 5vw, 44px); line-height: 1.05; font-weight: 800; margin: 0 0 12px; letter-spacing: -.02em; }+ .fr-sub { font-size: clamp(14px, 2.2vw, 17px); color: var(--fr-dim); max-width: 66ch; line-height: 1.55; margin: 0 0 24px; }+ .fr-sub a { color: var(--fr-accent-2); }++ /* calibration strip */+ .fr-strip { background: var(--fr-panel); border: 1px solid var(--fr-line); border-radius: 16px; padding: 18px; margin-bottom: 22px; }+ .fr-strip-title { font-size: 13px; text-transform: uppercase; letter-spacing: .08em; color: var(--fr-faint); font-weight: 600; margin: 0 0 14px; }+ .fr-bands { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 10px; margin: 0; }+ .fr-band { background: var(--fr-panel-2); border: 1px solid var(--fr-line); border-radius: 12px; padding: 14px; border-left: 3px solid var(--fr-line); }+ .fr-band-clear { border-left-color: var(--fr-green); }+ .fr-band-caution { border-left-color: var(--fr-amber); }+ .fr-band-avoid { border-left-color: var(--fr-accent); }+ .fr-band dt { font-size: 11px; text-transform: uppercase; letter-spacing: .07em; color: var(--fr-faint); font-weight: 700; margin: 0 0 6px; }+ .fr-band dd { margin: 0; font-size: 28px; font-weight: 800; letter-spacing: -.03em; font-variant-numeric: tabular-nums; }+ .fr-band p { margin: 6px 0 8px; font-size: 12.5px; color: var(--fr-dim); line-height: 1.45; }+ .fr-band small { display: block; font-size: 11.5px; color: var(--fr-faint); }+ .fr-strip-foot { margin: 14px 0 0; font-size: 12.5px; color: var(--fr-faint); line-height: 1.6; max-width: 82ch; }+ .fr-strip-note p { margin: 0; font-size: 13px; color: var(--fr-dim); line-height: 1.55; }++ /* controls */+ .fr-controls { display: flex; flex-wrap: wrap; gap: 16px; margin-bottom: 20px; }+ .fr-field .fr-lbl { display: block; font-size: 12px; color: var(--fr-faint); text-transform: uppercase; letter-spacing: .08em; margin-bottom: 8px; font-weight: 600; }+ .fr-seg { display: inline-flex; background: var(--fr-panel-2); border: 1px solid var(--fr-line); border-radius: 10px; padding: 4px; gap: 4px; }+ .fr-seg button { appearance: none; border: none; background: transparent; color: var(--fr-dim); font: inherit; font-weight: 600; font-size: 13px; padding: 9px 14px; border-radius: 7px; cursor: pointer; transition: background var(--duration-fast), color var(--duration-fast); }+ .fr-seg button:hover { color: var(--fr-text); }+ .fr-seg button[aria-pressed='true'] { background: var(--fr-accent); color: #fff; }+ .fr-seg button:focus-visible { outline: 2px solid var(--fr-accent-2); outline-offset: 2px; }++ /* board */+ .fr-caption { font-size: 13px; color: var(--fr-dim); margin: 0 0 10px; line-height: 1.5; }+ .fr-tablewrap { overflow-x: auto; border: 1px solid var(--fr-line); border-radius: 12px; background: var(--fr-panel); /* contain the wide table's overflow to this box: without it the row of columns+ still counts toward the document's own scroll width, and a phone can swipe+ the whole page sideways into empty space beside the board. */ contain: paint; }+ table.fr-table { width: 100%; border-collapse: collapse; font-size: 13px; min-width: 760px; }+ .fr-table th { text-align: left; font-size: 11px; text-transform: uppercase; letter-spacing: .07em; color: var(--fr-faint); font-weight: 600; padding: 10px 12px; border-bottom: 1px solid var(--fr-line); white-space: nowrap; }+ .fr-table td { padding: 10px 12px; border-bottom: 1px solid var(--fr-line); white-space: nowrap; vertical-align: middle; }+ .fr-table tr:last-child td { border-bottom: none; }+ .fr-table tbody tr:hover { background: var(--fr-panel-2); }+ .fr-table td.num { font-variant-numeric: tabular-nums; font-weight: 600; }+ .fr-table a { color: var(--fr-accent-2); text-decoration: none; }+ .fr-table a:hover { text-decoration: underline; }+ .fr-table a:focus-visible { outline: 2px solid var(--fr-accent-2); outline-offset: 2px; border-radius: 4px; }+ .fr-coin { font-weight: 700; }+ .fr-coin small { display: block; font-weight: 500; color: var(--fr-faint); font-size: 11px; max-width: 22ch; overflow: hidden; text-overflow: ellipsis; }+ .fr-addr { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12.5px; }+ .fr-tag { display: inline-block; margin-left: 6px; font-size: 10.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; padding: 2px 7px; border-radius: 999px; background: var(--fr-chip); color: var(--fr-dim); font-family: 'Inter', system-ui, sans-serif; }+ .fr-score { display: flex; align-items: center; gap: 8px; min-width: 108px; }+ .fr-score-bar { flex: 1; height: 6px; border-radius: 999px; background: var(--fr-chip); overflow: hidden; }+ .fr-score-bar span { display: block; height: 100%; background: linear-gradient(90deg, var(--fr-amber), var(--fr-accent)); border-radius: 999px; }+ .fr-score b { font-variant-numeric: tabular-nums; font-size: 13px; min-width: 22px; text-align: right; }+ .fr-pill { font-size: 11px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; padding: 4px 9px; border-radius: 999px; background: var(--fr-chip); color: var(--fr-dim); }+ .fr-pill-avoid { background: color-mix(in srgb, var(--fr-accent) 20%, transparent); color: var(--fr-accent); }+ .fr-pill-caution { background: color-mix(in srgb, var(--fr-amber) 20%, transparent); color: var(--fr-amber); }+ .fr-pill-clear { background: color-mix(in srgb, var(--fr-green) 18%, transparent); color: var(--fr-green); }++ /* states */+ .fr-empty, .fr-error { text-align: center; padding: 48px 20px; border: 1px dashed var(--fr-line); border-radius: 16px; background: var(--fr-panel); }+ .fr-empty h3, .fr-error h3 { margin: 0 0 8px; font-size: 18px; }+ .fr-empty p, .fr-error p { color: var(--fr-dim); margin: 0 auto 16px; max-width: 52ch; font-size: 14px; line-height: 1.55; }+ .fr-empty a, .fr-error button { display: inline-block; background: var(--fr-accent); color: #fff; border: none; text-decoration: none; padding: 10px 18px; border-radius: 10px; font: inherit; font-weight: 600; cursor: pointer; }+ .fr-empty a:focus-visible, .fr-error button:focus-visible { outline: 2px solid var(--fr-accent-2); outline-offset: 2px; }+ .fr-skel { display: grid; gap: 12px; }+ .fr-skel-block { border-radius: 14px; border: 1px solid var(--fr-line); background: linear-gradient(100deg, var(--fr-panel) 30%, var(--fr-panel-2) 50%, var(--fr-panel) 70%); background-size: 200% 100%; animation: fr-sh 1.3s ease-in-out infinite; }+ .fr-skel-block.tall { height: 320px; } .fr-skel-block.short { height: 128px; }+ @keyframes fr-sh { 0% { background-position: 200% 0; } 100% { background-position: -200% 0; } }+ @media (prefers-reduced-motion: reduce) { .fr-skel-block { animation: none; } .fr-seg button { transition: none; } }+ .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0,0,0,0); border: 0; }++ .fr-honesty { background: var(--fr-panel); border: 1px solid var(--fr-line); border-left: 3px solid var(--fr-amber); border-radius: 10px; padding: 14px 16px; margin-top: 28px; }+ .fr-honesty h2 { font-size: 13px; text-transform: uppercase; letter-spacing: .08em; color: var(--fr-amber); margin: 0 0 8px; }+ .fr-honesty ul { margin: 0; padding-left: 18px; display: flex; flex-direction: column; gap: 6px; }+ .fr-honesty li { font-size: 13px; color: var(--fr-dim); line-height: 1.55; }+ .fr-honesty a { color: var(--fr-accent-2); }+ .fr-more { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 20px; }+ .fr-more a { font-size: 13.5px; font-weight: 600; text-decoration: none; color: var(--fr-text); background: var(--fr-panel); border: 1px solid var(--fr-line); border-radius: 10px; padding: 10px 16px; transition: border-color var(--duration-fast), transform var(--duration-fast); }+ .fr-more a:hover { border-color: var(--fr-accent); transform: translateY(-1px); }+ .fr-more a:focus-visible { outline: 2px solid var(--fr-accent-2); outline-offset: 2px; }+ @media (prefers-reduced-motion: reduce) { .fr-more a:hover { transform: none; } }+ </style>+ </head>+ <body>+ <header><div id="nav-container"></div></header>+ <script src="/nav.js"></script>++ <main class="fr" aria-labelledby="fr-title">+ <p class="fr-kicker">Fade Radar · the inverse of smart money</p>+ <h1 id="fr-title" class="fr-title">The wallets that are never right</h1>+ <p class="fr-sub">+ The <a href="/smart-money">Smart Money Radar</a> asks who reputable is buying a coin.+ This asks the sharper question: how much of the buy side has never once been right.+ A reverse indicator here is a wallet the graph has watched buy at least five coins whose+ outcome is now known, with zero winners among them. They are not rare, and when they+ crowd a fresh launch that launch almost never goes anywhere. Nothing on this page is a+ short: on a bonding curve the only tradeable form of a fade is not buying.+ </p>++ <section class="fr-strip" id="frStrip" aria-label="Measured odds behind each verdict"></section>++ <section class="fr-controls" aria-label="Board settings">+ <div class="fr-field">+ <span class="fr-lbl" id="frViewLabel">Board</span>+ <div class="fr-seg" role="group" aria-labelledby="frViewLabel" id="frViewSeg">+ <button type="button" data-view="coins" aria-pressed="true">Coins</button>+ <button type="button" data-view="wallets" aria-pressed="false">Reverse indicators</button>+ </div>+ </div>+ <div class="fr-field" id="frWindowField">+ <span class="fr-lbl" id="frWindowLabel">Launched within</span>+ <div class="fr-seg" role="group" aria-labelledby="frWindowLabel" id="frWindowSeg">+ <button type="button" data-hours="1" aria-pressed="false">1h</button>+ <button type="button" data-hours="6" aria-pressed="true">6h</button>+ <button type="button" data-hours="24" aria-pressed="false">24h</button>+ <button type="button" data-hours="72" aria-pressed="false">3d</button>+ </div>+ </div>+ <div class="fr-field" id="frActiveField" hidden>+ <span class="fr-lbl" id="frActiveLabel">Last active</span>+ <div class="fr-seg" role="group" aria-labelledby="frActiveLabel" id="frActiveSeg">+ <button type="button" data-active="24" aria-pressed="false">24h</button>+ <button type="button" data-active="168" aria-pressed="true">7d</button>+ <button type="button" data-active="0" aria-pressed="false">All time</button>+ </div>+ </div>+ </section>++ <div id="frBoard" aria-live="polite"></div>++ <section class="fr-honesty" aria-labelledby="frHonesty">+ <h2 id="frHonesty">What this is and is not</h2>+ <ul>+ <li>A wallet's record counts only coins whose outcome is already known. A winner is a coin that graduated to an AMM or peaked at 3x or better.</li>+ <li>The odds above are measured out of sample: the cohort is rebuilt from coins labelled in the earlier half of the history, then graded on coins it could not have seen.</li>+ <li>A coin is scored only once at least five of its buyers have been observed. Below that the board says so rather than guessing.</li>+ <li>This is a probabilistic read on a hostile market, never a prediction, and never advice. A clear coin can still go to zero.</li>+ <li>The only coin three.ws promotes is $THREE. Every coin on this board is whatever the live feed handed us.</li>+ </ul>+ </section>++ <nav class="fr-more" aria-label="Related surfaces">+ <a href="/smart-money">Smart Money Radar</a>+ <a href="/radar">Coin Radar</a>+ <a href="/coin-intel">Coin Intelligence</a>+ <a href="/trades">Live Trade Feed</a>+ <a href="/docs/fade-radar">How the score works</a>+ </nav>+ </main>++ <footer id="footer-root"></footer>+ <script type="module" src="/src/fade-radar.js"></script>+ <!-- Runtime i18n: detects locale, swaps annotated copy, mounts <lang-switcher>. -->+ <script type="module" src="/i18n.js"></script>+ </body>+</html>diff --git a/pages/smart-money.html b/pages/smart-money.htmlindex 50110f1ac..75e12c60a 100644--- a/pages/smart-money.html+++ b/pages/smart-money.html@@ -1135,9 +1135,23 @@}$('staleRetry').addEventListener('click', manualRetry);+ function openFromQuery() {+ const params = new URLSearchParams(location.search);+ const wallet = (params.get('wallet') || '').trim();+ const mint = (params.get('mint') || '').trim();+ const BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;+ if (BASE58.test(wallet)) openWallet(wallet);+ else if (BASE58.test(mint)) openCoin(mint);+ }+// bootinitFork();renderWalletHead();+ // Deep link: /smart-money?wallet=<addr> (and ?mint=<addr>) opens that drawer+ // straight away, so a wallet cited anywhere else on the platform, the Fade+ // Radar board included, lands on its track record instead of a board the+ // reader has to search by eye.+ openFromQuery();updateWatchCount();$('feedGrid').innerHTML = Array.from({ length: 6 }, () => '<div class="skel"></div>').join('');refresh();diff --git a/prompts/finish/_context/roadmap-00-README.md b/prompts/finish/_context/roadmap-00-README.mdindex dda2b6f50..36b48745d 100644--- a/prompts/finish/_context/roadmap-00-README.md+++ b/prompts/finish/_context/roadmap-00-README.md@@ -96,7 +96,7 @@ retired; they remain readable in git history|---|---|| [the Fable playbook](../../docs/internal/fable-playbook.md) | The operating strategy above these work orders: what to run next, the revenue ladder, standing routines. Promoted out of this directory into `docs/internal/` on 2026-09-03, since it is durable strategy rather than a one-shot order. || [REUSE-MAP.md](roadmap-REUSE-MAP.md) | License-vetted OSS to integrate instead of reinventing. Check it before building anything here. |-| [pumpfun-trading.md](../917-roadmap-pumpfun-trading.md), [pumpfun-trading-arena.md](../918-roadmap-pumpfun-trading-arena.md) | Two overlapping strategy documents for the trading product. They are plans, not work orders. The wedge delta was retired on 2026-09-03 (readable in git history) once its inventory was checked against the repo: the wedge itself (`/claim-wallet`), the Trader Passport, the meta-allocator, fade-the-influencer (`/ghost-copy`), the Clip Director and the 3D trading floor had all shipped, and the last unshipped, non-owner-gated mechanic (alpha-drip, tiered release of a leader's signal) shipped with it. What the wedge left open is owner-gated, not unbuilt: a per-copy execution fee is a pricing decision, and a house-bankrolled first trade spends real money per new user. Its §6 consolidation (fold the arena draft into the master plan) stays open on purpose: both drafts predate the em-dash ban, so folding them verbatim would add hundreds of lines that `npm run check:rules` rejects, and rewriting a whole plan's prose to move it is the catastrophic diff that rule exists to avoid. Fold it when one of the two is being rewritten anyway. Re-verified 2026-09-09: everything the arena plan describes is built and its migrations are applied in production, so the arena file stays on disk for one reason only, the owner-gated deploy of the `agent-sniper` worker, whose running image predates a month of committed worker code (including the graduated-position AMM exits the plan names as its blocker) and therefore also predates the Risk Officer that needs production shadow rows before anyone arms it. Tracked as row 19 in [production-100-OWNER-ACTIONS.md](production-100-OWNER-ACTIONS.md). |+| [pumpfun-trading.md](../917-roadmap-pumpfun-trading.md), [pumpfun-trading-arena.md](../918-roadmap-pumpfun-trading-arena.md) | Two overlapping strategy documents for the trading product. They are plans, not work orders. The wedge delta was retired on 2026-09-03 (readable in git history) once its inventory was checked against the repo: the wedge itself (`/claim-wallet`), the Trader Passport, the meta-allocator, fade-the-influencer (`/ghost-copy`), the Clip Director and the 3D trading floor had all shipped, and the last unshipped, non-owner-gated mechanic (alpha-drip, tiered release of a leader's signal) shipped with it. What the wedge left open is owner-gated, not unbuilt: a per-copy execution fee is a pricing decision, and a house-bankrolled first trade spends real money per new user. Its §6 consolidation (fold the arena draft into the master plan) stays open on purpose: both drafts predate the em-dash ban, so folding them verbatim would add hundreds of lines that `npm run check:rules` rejects, and rewriting a whole plan's prose to move it is the catastrophic diff that rule exists to avoid. Fold it when one of the two is being rewritten anyway. Re-verified 2026-09-09: everything the arena plan describes is built and its migrations are applied in production, so the arena file stays on disk for one reason only, the owner-gated deploy of the `agent-sniper` worker, whose running image predates a month of committed worker code (including the graduated-position AMM exits the plan names as its blocker) and therefore also predates the Risk Officer that needs production shadow rows before anyone arms it. Tracked as row 19 in [production-100-OWNER-ACTIONS.md](production-100-OWNER-ACTIONS.md). The trading plan's own inventory was re-derived the same day: sections 3, 4, 5, 13 and 15 are live (the Coin Intelligence engine is `pump_coin_intel` / `pump_coin_wallets` / `pump_coin_outcomes` / `pump_intel_weights`, with its learned weights already read by `workers/agent-sniper/scorer.js`), and of the section 12 plays only 12.8 was both unbuilt and unblocked. It shipped as the Fade Radar (`/fade`, `api/_lib/fade-radar.js`, `docs/fade-radar.md`): an avoidance read over the proven-losing side of the same wallet graph, not the inverted position the plan sketched, because nothing on a bonding curve can be sold before it is bought. Still open there: 12.6 (agent prediction markets, which the plan itself flags for regulatory framing), 12.11 (streaks and quests), 12.12 (the embeddable copy-me widget), 12.14 (the auto-rivalry copy engine) and 12.15 (the first-rug softener, flagged rather than committed). |## Key surfaces (from STRUCTURE.md)- Forge: `packages/forge/`, `api/forge*.js`, `api/mcp-3d.js` (free TRELLIS lane + paid tiers + auto-rig, IBM Granite prompt director).diff --git a/src/fade-radar.js b/src/fade-radar.jsnew file mode 100644index 000000000..e96d55834--- /dev/null+++ b/src/fade-radar.js@@ -0,0 +1,355 @@+// Fade Radar page: the coins proven-losing money is crowding into right now.+//+// Reads /api/pump/fade (calibration once, then the coin board or the wallet+// board) and renders every state: loading, empty, error, populated. View and+// window live in the URL (?view&hours) so a board is deep-linkable, and the+// calibration strip is fetched first because it is the reason to believe any+// number under it.+//+// The page spends nothing and signs nothing. On a bonding curve the only+// tradeable form of a fade is not buying, so every action here is a link out:+// the coin's intel page, its pump.fun listing, a wallet's on-chain history.++const stripEl = document.getElementById('frStrip');+const boardEl = document.getElementById('frBoard');+const viewSeg = document.getElementById('frViewSeg');+const windowSeg = document.getElementById('frWindowSeg');+const windowField = document.getElementById('frWindowField');+const activeSeg = document.getElementById('frActiveSeg');+const activeField = document.getElementById('frActiveField');++const WINDOW_LABEL = { 1: 'the last hour', 6: 'the last 6 hours', 24: 'the last day', 72: 'the last 3 days' };+const BAND_LABEL = { clear: 'Clear', caution: 'Caution', avoid: 'Avoid' };+const BAND_BLURB = {+ clear: 'No reverse indicator in the coin',+ caution: 'Some reverse-indicator money',+ avoid: 'A quarter of the buy side or more',+};++const ACTIVE_LABEL = { 24: 'in the last day', 168: 'in the last week', 0: 'at any point on record' };++const state = { view: 'coins', hours: 6, activeHours: 168 };+let runSeq = 0;++function esc(s) {+ return String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));+}+function shortAddr(a) {+ const s = String(a || '');+ return s.length > 12 ? `${s.slice(0, 4)}…${s.slice(-4)}` : s;+}+function shortDate(iso) {+ if (!iso) return 'unknown';+ const d = new Date(iso);+ return Number.isNaN(d.getTime()) ? 'unknown' : d.toLocaleString(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });+}+function ago(iso) {+ if (!iso) return 'unknown';+ const t = Date.parse(iso);+ if (!Number.isFinite(t)) return 'unknown';+ const mins = Math.max(0, Math.round((Date.now() - t) / 60000));+ if (mins < 60) return `${mins}m ago`;+ if (mins < 1440) return `${Math.round(mins / 60)}h ago`;+ return `${Math.round(mins / 1440)}d ago`;+}+function pctText(share) {+ return `${Math.round(Number(share || 0) * 100)}%`;+}++// ── the calibration strip: why any of this is worth reading ─────────────────++function stripSkeleton() {+ stripEl.innerHTML = `<div class="fr-skel-block short" aria-hidden="true"></div>`;+}++function renderStrip(cal) {+ if (!cal || !cal.computed || !Array.isArray(cal.bands) || !cal.bands.length) {+ stripEl.innerHTML = `+ <div class="fr-strip-note">+ <p>The measured odds behind these bands are still being computed. The board below is live either way: it reports what is in each coin, not what will happen to it.</p>+ </div>`;+ return;+ }+ const total = Number(cal.sample_coins || 0).toLocaleString();+ const cards = cal.bands+ .map((b) => {+ const coins = Number(b.coins || 0).toLocaleString();+ const lift = b.lift == null ? '' : `<small>${b.band === 'clear' ? 'the baseline' : `${b.lift}x the baseline`}</small>`;+ return `+ <div class="fr-band fr-band-${esc(b.band)}">+ <dt>${esc(BAND_LABEL[b.band] || b.band)}</dt>+ <dd>${Number(b.win_pct || 0).toFixed(1)}%</dd>+ <p>${esc(BAND_BLURB[b.band] || '')}</p>+ <small>${coins} coins</small>+ ${lift}+ </div>`;+ })+ .join('');+ stripEl.innerHTML = `+ <h2 class="fr-strip-title">How often a coin in each band went on to win</h2>+ <dl class="fr-bands">${cards}</dl>+ <p class="fr-strip-foot">+ A win is a coin that graduated to an AMM or peaked at 3x or better. Measured on+ ${total} labelled coins, out of sample: the reverse-indicator cohort is built only+ from coins whose outcome was known before the coins it is graded on existed.+ Recomputed from live history, last on ${esc(shortDate(cal.computed_at))}.+ </p>`;+}++// ── the boards ──────────────────────────────────────────────────────────────++function boardSkeleton() {+ boardEl.innerHTML = `+ <div class="fr-skel" aria-busy="true" aria-label="Loading the board">+ <div class="fr-skel-block tall"></div>+ </div>`;+}++function boardError(message, retry) {+ boardEl.innerHTML = `+ <div class="fr-error" role="alert">+ <h3>The board could not be loaded</h3>+ <p>${esc(message)}</p>+ <button type="button" id="frRetry">Try again</button>+ </div>`;+ document.getElementById('frRetry').addEventListener('click', retry);+}++function coinsEmpty() {+ boardEl.innerHTML = `+ <div class="fr-empty">+ <h3>Nothing to fade in ${esc(WINDOW_LABEL[state.hours] || 'this window')}</h3>+ <p>+ No coin launched in this window has a proven reverse indicator on its buy side yet.+ That is the good outcome, and it changes minute to minute. Widen the window, or watch+ what the proven winners are buying instead.+ </p>+ <a href="/smart-money">Open the Smart Money Radar</a>+ </div>`;+}++function walletsEmpty() {+ const active = state.activeHours+ ? `No reverse indicator has traded ${ACTIVE_LABEL[state.activeHours]}`+ : 'No reverse indicator has met the bar yet';+ boardEl.innerHTML = `+ <div class="fr-empty">+ <h3>${esc(active)}</h3>+ <p>+ A wallet joins this board only after five coins it bought have a known outcome and not+ one of them won. Until the graph has watched that many, every wallet here is simply new.+ ${state.activeHours ? 'Widen the window to see the ones that have gone quiet.' : ''}+ </p>+ <a href="/smart-money">Open the Smart Money Radar</a>+ </div>`;+}++function coinRow(c) {+ const symbol = c.symbol ? `$${esc(c.symbol)}` : `${esc(String(c.mint).slice(0, 6))}…`;+ const name = c.name ? `<small>${esc(c.name)}</small>` : '';+ return `+ <tr>+ <td class="fr-coin">+ <a href="/oracle/coin/${encodeURIComponent(c.mint)}">${symbol}</a>${name}+ </td>+ <td>+ <div class="fr-score" title="${esc(c.summary || '')}">+ <div class="fr-score-bar"><span style="width:${Math.max(2, Number(c.score) || 0)}%"></span></div>+ <b>${Number(c.score) || 0}</b>+ </div>+ </td>+ <td><span class="fr-pill fr-pill-${esc(c.verdict)}">${esc(BAND_LABEL[c.verdict] || c.verdict)}</span></td>+ <td class="num">${Number(c.ri_buyers) || 0} / ${Number(c.buyers) || 0}</td>+ <td class="num">${pctText(c.ri_volume_share)}</td>+ <td class="num">${Number(c.total_buy_sol || 0).toFixed(2)}</td>+ <td>${esc(ago(c.first_seen_at))}</td>+ <td><a href="https://pump.fun/${esc(c.mint)}" target="_blank" rel="noopener noreferrer">pump.fun</a></td>+ </tr>`;+}++function walletRow(w) {+ const labels = (w.labels || []).slice(0, 2).map((l) => `<span class="fr-tag">${esc(l)}</span>`).join('');+ return `+ <tr>+ <td class="fr-addr">+ <a href="https://solscan.io/account/${esc(w.wallet)}" target="_blank" rel="noopener noreferrer">${esc(shortAddr(w.wallet))}</a>+ ${labels}+ </td>+ <td class="num">${Number(w.judged_buys) || 0}</td>+ <td class="num">0</td>+ <td class="num">${Number(w.losers) || 0}</td>+ <td>${esc(ago(w.last_seen))}</td>+ <td><a href="/smart-money?wallet=${encodeURIComponent(w.wallet)}">Track record</a></td>+ </tr>`;+}++function renderCoins(data) {+ if (!data.coins.length) return coinsEmpty();+ boardEl.innerHTML = `+ <p class="fr-caption">+ ${data.coins.length} coin${data.coins.length === 1 ? '' : 's'} launched in+ ${esc(WINDOW_LABEL[state.hours] || 'this window')} with proven-losing money on the buy side,+ heaviest share first.+ </p>+ <div class="fr-tablewrap">+ <table class="fr-table">+ <thead>+ <tr>+ <th scope="col">Coin</th>+ <th scope="col">Fade score</th>+ <th scope="col">Verdict</th>+ <th scope="col">Reverse / buyers</th>+ <th scope="col">Reverse share of SOL</th>+ <th scope="col">Observed buys</th>+ <th scope="col">Launched</th>+ <th scope="col"><span class="sr-only">Listing</span></th>+ </tr>+ </thead>+ <tbody>${data.coins.map(coinRow).join('')}</tbody>+ </table>+ </div>`;+}++function renderWallets(data) {+ if (!data.wallets.length) return walletsEmpty();+ boardEl.innerHTML = `+ <p class="fr-caption">+ ${data.wallets.length} wallet${data.wallets.length === 1 ? '' : 's'} with a judged record and+ not one winner in it, seen ${esc(ACTIVE_LABEL[state.activeHours] || 'at any point on record')},+ most-watched first.+ </p>+ <div class="fr-tablewrap">+ <table class="fr-table">+ <thead>+ <tr>+ <th scope="col">Wallet</th>+ <th scope="col">Judged buys</th>+ <th scope="col">Winners</th>+ <th scope="col">Losers</th>+ <th scope="col">Last seen</th>+ <th scope="col"><span class="sr-only">Record</span></th>+ </tr>+ </thead>+ <tbody>${data.wallets.map(walletRow).join('')}</tbody>+ </table>+ </div>`;+}++// ── loading ─────────────────────────────────────────────────────────────────++async function getJson(url) {+ const res = await fetch(url, { headers: { accept: 'application/json' } });+ if (!res.ok) {+ let detail = `the server answered ${res.status}`;+ try {+ const body = await res.json();+ if (body && (body.error_description || body.error)) detail = body.error_description || body.error;+ } catch {+ detail = `the server answered ${res.status}`;+ }+ throw new Error(detail);+ }+ return res.json();+}++async function loadStrip() {+ stripSkeleton();+ try {+ renderStrip(await getJson('/api/pump/fade?calibration=1'));+ } catch {+ renderStrip(null);+ }+}++async function loadBoard() {+ const seq = ++runSeq;+ boardSkeleton();+ const url =+ state.view === 'wallets'+ ? `/api/pump/fade?wallets=1&limit=40&min_judged=8&active_hours=${state.activeHours}`+ : `/api/pump/fade?hours=${state.hours}&limit=40`;+ try {+ const data = await getJson(url);+ if (seq !== runSeq) return;+ if (state.view === 'wallets') renderWallets(data);+ else renderCoins(data);+ } catch (err) {+ if (seq !== runSeq) return;+ boardError(err.message || 'the request failed', loadBoard);+ }+}++// ── state in the URL ────────────────────────────────────────────────────────++function syncControls() {+ for (const b of viewSeg.querySelectorAll('button')) {+ b.setAttribute('aria-pressed', String(b.dataset.view === state.view));+ }+ for (const b of windowSeg.querySelectorAll('button')) {+ b.setAttribute('aria-pressed', String(Number(b.dataset.hours) === state.hours));+ }+ for (const b of activeSeg.querySelectorAll('button')) {+ b.setAttribute('aria-pressed', String(Number(b.dataset.active) === state.activeHours));+ }+ windowField.hidden = state.view !== 'coins';+ activeField.hidden = state.view !== 'wallets';+}++function writeUrl() {+ const url = new URL(window.location.href);+ url.searchParams.set('view', state.view);+ if (state.view === 'coins') {+ url.searchParams.set('hours', String(state.hours));+ url.searchParams.delete('active');+ } else {+ url.searchParams.delete('hours');+ url.searchParams.set('active', String(state.activeHours));+ }+ window.history.replaceState(null, '', url);+}++function readUrl() {+ const params = new URLSearchParams(window.location.search);+ const view = params.get('view');+ if (view === 'wallets' || view === 'coins') state.view = view;+ const hours = Number(params.get('hours'));+ if ([1, 6, 24, 72].includes(hours)) state.hours = hours;+ const active = params.get('active');+ if (active != null && [24, 168, 0].includes(Number(active))) state.activeHours = Number(active);+}++viewSeg.addEventListener('click', (e) => {+ const btn = e.target.closest('button[data-view]');+ if (!btn || btn.dataset.view === state.view) return;+ state.view = btn.dataset.view;+ syncControls();+ writeUrl();+ loadBoard();+});++windowSeg.addEventListener('click', (e) => {+ const btn = e.target.closest('button[data-hours]');+ if (!btn) return;+ const hours = Number(btn.dataset.hours);+ if (hours === state.hours) return;+ state.hours = hours;+ syncControls();+ writeUrl();+ loadBoard();+});++activeSeg.addEventListener('click', (e) => {+ const btn = e.target.closest('button[data-active]');+ if (!btn) return;+ const hours = Number(btn.dataset.active);+ if (hours === state.activeHours) return;+ state.activeHours = hours;+ syncControls();+ writeUrl();+ loadBoard();+});++readUrl();+syncControls();+loadStrip();+loadBoard();diff --git a/tests/fade-radar.test.js b/tests/fade-radar.test.jsnew file mode 100644index 000000000..d403d29e4--- /dev/null+++ b/tests/fade-radar.test.js@@ -0,0 +1,119 @@+/**+ * Fade Radar, pure scoring tests.+ *+ * The score decides whether a visitor is told to walk away from a coin, so the+ * whole contract is pinned here: the share arithmetic, the sample floor that+ * separates "clean" from "we cannot tell yet", the band thresholds the measured+ * calibration is computed against, and the sentence a trader actually reads.+ * A score that reads clean on a coin full of proven-losing money is the one+ * failure this page cannot have.+ */++import { describe, it, expect } from 'vitest';+import {+ fadeScore,+ fadeVerdict,+ fadeSummary,+ RI_MIN_JUDGED,+ MIN_BUYERS,+ AVOID_SHARE,+} from '../api/_lib/fade-radar.js';++describe('fadeScore', () => {+ it('scores a clean coin at zero and calls it clear', () => {+ const s = fadeScore({ buyers: 12, riBuyers: 0, totalBuySol: 40, riBuySol: 0 });+ expect(s.score).toBe(0);+ expect(s.verdict).toBe('clear');+ expect(s.ri_buyer_share).toBe(0);+ expect(s.confidence).toBe('high');+ });++ it('scores a coin whose whole buy side is reverse indicators at 100', () => {+ const s = fadeScore({ buyers: 10, riBuyers: 10, totalBuySol: 8, riBuySol: 8 });+ expect(s.score).toBe(100);+ expect(s.verdict).toBe('avoid');+ });++ it('weights buyers 60 / volume 40', () => {+ // Half the buyers, all of the volume: 0.6*0.5 + 0.4*1 = 0.7+ const s = fadeScore({ buyers: 10, riBuyers: 5, totalBuySol: 10, riBuySol: 10 });+ expect(s.score).toBe(70);+ });++ it('falls back to the buyer share when no volume was recorded', () => {+ const s = fadeScore({ buyers: 10, riBuyers: 4, totalBuySol: 0, riBuySol: 0 });+ expect(s.ri_volume_share).toBe(0.4);+ expect(s.score).toBe(40);+ });++ it('refuses to read a buy side below the sample floor', () => {+ const s = fadeScore({ buyers: MIN_BUYERS - 1, riBuyers: 2, totalBuySol: 3, riBuySol: 3 });+ expect(s.verdict).toBe('unknown');+ expect(s.confidence).toBe('low');+ });++ it('never lets a reverse indicator count outrun the buyers or the volume', () => {+ const s = fadeScore({ buyers: 5, riBuyers: 9, totalBuySol: 2, riBuySol: 40 });+ expect(s.ri_buyers).toBe(5);+ expect(s.ri_buy_sol).toBe(2);+ expect(s.score).toBe(100);+ });++ it('treats missing, negative and non-numeric input as no data', () => {+ for (const bad of [{}, { buyers: -4, riBuyers: -2 }, { buyers: 'x', riBuyers: null }]) {+ const s = fadeScore(bad);+ expect(s.score).toBe(0);+ expect(s.buyers).toBe(0);+ expect(s.verdict).toBe('unknown');+ }+ });+});++describe('fadeVerdict', () => {+ it('needs the sample floor before it will call anything', () => {+ expect(fadeVerdict(1, MIN_BUYERS - 1)).toBe('unknown');+ expect(fadeVerdict(0, 0)).toBe('unknown');+ });++ it('splits caution from avoid exactly at the calibrated share', () => {+ expect(fadeVerdict(AVOID_SHARE - 0.001, 20)).toBe('caution');+ expect(fadeVerdict(AVOID_SHARE, 20)).toBe('avoid');+ });++ it('calls a coin with no reverse indicator clear', () => {+ expect(fadeVerdict(0, 20)).toBe('clear');+ });+});++describe('fadeSummary', () => {+ it('says how thin the sample is instead of guessing', () => {+ const s = fadeScore({ buyers: 2, riBuyers: 1 });+ expect(fadeSummary(s)).toContain('too few');+ });++ it('says nothing was observed when nothing was', () => {+ expect(fadeSummary(fadeScore({}))).toContain('nothing to read');+ });++ it('quotes the real counts on a heavy coin', () => {+ const s = fadeScore({ buyers: 8, riBuyers: 6, totalBuySol: 10, riBuySol: 9 });+ const line = fadeSummary(s);+ expect(line).toContain('6 of 8');+ expect(line).toContain('75%');+ expect(line).toContain('90%');+ });++ it('states the clean case in full', () => {+ expect(fadeSummary(fadeScore({ buyers: 11, riBuyers: 0 }))).toBe(+ 'None of the 11 observed buyers is a proven reverse indicator.',+ );+ });+});++describe('thresholds', () => {+ it('holds the constants the calibration query is computed against', () => {+ expect(RI_MIN_JUDGED).toBe(5);+ expect(MIN_BUYERS).toBe(5);+ expect(AVOID_SHARE).toBe(0.25);+ });+});diff --git a/vercel.json b/vercel.jsonindex 34c632484..8f0c7de6c 100644--- a/vercel.json+++ b/vercel.json@@ -1167,6 +1167,10 @@"src": "/ghost-copy/?","dest": "/ghost-copy.html"},+ {+ "src": "/fade/?",+ "dest": "/fade.html"+ },{"src": "/clip-director/?","dest": "/clip-director.html"@@ -3391,6 +3395,10 @@"src": "/api/pump/ghost-copy","dest": "/api/pump/ghost-copy.js"},+ {+ "src": "/api/pump/fade",+ "dest": "/api/pump/fade.js"+ },{"src": "/api/pump/wrapped","dest": "/api/pump/wrapped.js"diff --git a/vite.config.js b/vite.config.jsindex 099c7122e..a6e395ae6 100644--- a/vite.config.js+++ b/vite.config.js@@ -795,6 +795,7 @@ const appConfig = {'claim-wallet': resolve(__dirname, 'pages/claim-wallet.html'),'meta-allocator': resolve(__dirname, 'pages/meta-allocator.html'),'ghost-copy': resolve(__dirname, 'pages/ghost-copy.html'),+ fade: resolve(__dirname, 'pages/fade.html'),wrapped: resolve(__dirname, 'pages/wrapped.html'),'clip-director': resolve(__dirname, 'pages/clip-director.html'),'avatar-embed': resolve(__dirname, 'pages/avatar-embed.html'),