brainblast 0.6.4 → 0.7.1

package/dist/chunk-QC27GNQ7.js

@@ -0,0 +1,101 @@
+import {
+  analyzeToken
+} from "./chunk-FQA5BYWW.js";
+import {
+  verifyTokenIdentity
+} from "./chunk-VI2JBH2T.js";
+
+// src/batchScan.ts
+async function mapPool(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) break;
+      results[idx] = await fn(items[idx], idx);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function scanOne(mint, opts) {
+  const failOn = opts.failOnRisk ?? 70;
+  try {
+    const identity = await verifyTokenIdentity(mint, { baseUrl: opts.jupBaseUrl, offline: opts.offline });
+    const row = {
+      mint,
+      identityStatus: identity.status,
+      impersonation: identity.impersonation,
+      symbol: identity.symbol,
+      rank: 0
+    };
+    if (!opts.offline) {
+      const outcome = await analyzeToken(mint, { apiKey: opts.apiKey, baseUrl: opts.ricoBaseUrl });
+      if (outcome.ok) {
+        const q = outcome.result;
+        row.riskScore = q.riskScore;
+        row.snipers = q.snipersDetected;
+        row.bundleClusters = q.bundleClustersDetected;
+        row.deployerFlags = q.deployerFlags;
+        if (!row.symbol) row.symbol = q.symbol;
+      }
+    }
+    row.rank = (row.impersonation ? 1e3 : 0) + (row.riskScore ?? -1);
+    return row;
+  } catch (e) {
+    return { mint, identityStatus: "error", impersonation: false, error: e?.message ?? String(e), rank: -2 };
+  }
+}
+async function batchScan(mints, opts = {}) {
+  const failOn = opts.failOnRisk ?? 70;
+  const unique = [...new Set(mints.map((m) => m.trim()).filter(Boolean))];
+  const rows = await mapPool(unique, opts.concurrency ?? 5, (m) => scanOne(m, opts));
+  rows.sort((a, b) => b.rank - a.rank);
+  const summary = {
+    total: rows.length,
+    impersonators: rows.filter((r) => r.impersonation).length,
+    highRisk: rows.filter((r) => (r.riskScore ?? -1) >= failOn).length,
+    errored: rows.filter((r) => r.identityStatus === "error").length
+  };
+  return { rows, summary };
+}
+function parseMintList(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("[")) {
+    const arr = JSON.parse(trimmed);
+    if (!Array.isArray(arr)) throw new Error("JSON mint list must be an array of strings");
+    return arr.map((x) => String(x));
+  }
+  return trimmed.split(/\r?\n/).map((l) => l.replace(/#.*$/, "").trim()).filter(Boolean);
+}
+function pad(s, n) {
+  return s.length >= n ? s.slice(0, n) : s + " ".repeat(n - s.length);
+}
+function renderBatchText(result) {
+  const lines = [];
+  lines.push(`Batch token scan \u2014 ${result.summary.total} token(s)`);
+  lines.push(
+    `  ${result.summary.impersonators} impersonator(s), ${result.summary.highRisk} high-risk, ${result.summary.errored} error(s)`
+  );
+  lines.push("");
+  lines.push(`  ${pad("MINT", 14)} ${pad("SYMBOL", 8)} ${pad("IDENTITY", 18)} ${pad("RISK", 5)} FLAGS`);
+  for (const r of result.rows) {
+    const mintShort = r.mint.length > 12 ? r.mint.slice(0, 6) + ".." + r.mint.slice(-4) : r.mint;
+    const flags = [];
+    if (r.impersonation) flags.push("IMPERSONATION");
+    if (r.snipers) flags.push("snipers");
+    if (r.bundleClusters) flags.push("bundle");
+    if (r.error) flags.push(`error:${r.error}`);
+    lines.push(
+      `  ${pad(mintShort, 14)} ${pad(r.symbol ?? "-", 8)} ${pad(r.identityStatus, 18)} ${pad(r.riskScore != null ? String(r.riskScore) : "-", 5)} ${flags.join(", ")}`
+    );
+  }
+  return lines.join("\n");
+}
+
+export {
+  batchScan,
+  parseMintList,
+  renderBatchText
+};

package/dist/chunk-SVSVVW6U.js

@@ -0,0 +1,187 @@
+import {
+  probeUpgradeAuthority
+} from "./chunk-XSVQSK53.js";
+
+// src/trustGraph/directory.ts
+import { readFileSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { join } from "path";
+import { parse } from "yaml";
+var cache = null;
+function bundledPath() {
+  const here = fileURLToPath(new URL(".", import.meta.url));
+  const candidates = [
+    join(here, "programs", "directory.yaml"),
+    // dist/programs/directory.yaml
+    join(here, "..", "..", "programs", "directory.yaml"),
+    // src/../../programs/
+    join(here, "..", "programs", "directory.yaml")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function loadDirectory(path = bundledPath()) {
+  if (cache && path === bundledPath()) return cache;
+  const raw = parse(readFileSync(path, "utf8"));
+  if (!raw || !Array.isArray(raw.programs)) {
+    throw new Error(`invalid program directory at ${path}: missing 'programs' array`);
+  }
+  const m = /* @__PURE__ */ new Map();
+  for (const p of raw.programs) {
+    if (!p.programId || !p.name) throw new Error(`directory entry missing programId/name: ${JSON.stringify(p)}`);
+    if (m.has(p.programId)) throw new Error(`directory has duplicate programId ${p.programId}`);
+    m.set(p.programId, { ...p, provenance: { ...p.provenance ?? {}, directoryFile: path } });
+  }
+  if (path === bundledPath()) cache = m;
+  return m;
+}
+
+// src/trustGraph/programCache.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir } from "os";
+var DEFAULT_TTL_HOURS = 168;
+var SCHEMA_VERSION = "1.0";
+function defaultCachePath() {
+  const envOverride = process.env["BRAINBLAST_CACHE_PATH"];
+  return envOverride ?? join2(homedir(), ".brainblast", "program-cache.json");
+}
+function emptyCache() {
+  return { schemaVersion: SCHEMA_VERSION, entries: {} };
+}
+function loadProgramCache(cachePath) {
+  const path = cachePath ?? defaultCachePath();
+  if (!existsSync2(path)) return emptyCache();
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf8"));
+    if (raw?.schemaVersion !== SCHEMA_VERSION) {
+      return emptyCache();
+    }
+    if (!raw.entries || typeof raw.entries !== "object") return emptyCache();
+    return { schemaVersion: SCHEMA_VERSION, entries: raw.entries };
+  } catch {
+    return emptyCache();
+  }
+}
+function saveProgramCache(cache2, cachePath) {
+  const path = cachePath ?? defaultCachePath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cache2, null, 2), "utf8");
+}
+function getCacheEntry(cache2, programId, ttlHoursOverride) {
+  const entry = cache2.entries[programId];
+  if (!entry) return null;
+  if (isEntryExpired(entry, ttlHoursOverride)) return null;
+  return entry.program;
+}
+function putCacheEntry(cache2, programId, program, sourceRun, ttlHours = DEFAULT_TTL_HOURS) {
+  cache2.entries[programId] = {
+    program,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceRun,
+    ttlHours
+  };
+  return cache2;
+}
+function getCacheEntryMeta(cache2, programId) {
+  return cache2.entries[programId] ?? null;
+}
+function isEntryExpired(entry, ttlHoursOverride) {
+  const ttl = ttlHoursOverride ?? entry.ttlHours ?? DEFAULT_TTL_HOURS;
+  if (ttl <= 0) return true;
+  const cachedMs = Date.parse(entry.cachedAt);
+  if (Number.isNaN(cachedMs)) return true;
+  const ageMs = Date.now() - cachedMs;
+  return ageMs >= ttl * 36e5;
+}
+function cacheSize(cache2, ttlHoursOverride) {
+  return Object.values(cache2.entries).filter((e) => !isEntryExpired(e, ttlHoursOverride)).length;
+}
+
+// src/trustGraph/build.ts
+async function buildTrustGraph(programIds, opts = {}) {
+  const dir = loadDirectory(opts.directoryPath);
+  const programs = [];
+  const unresolved = [];
+  const cacheEnabled = opts.cachePath !== null;
+  const cachePathArg = opts.cachePath === null ? void 0 : opts.cachePath;
+  const cache2 = cacheEnabled ? loadProgramCache(cachePathArg) : null;
+  const newFromRpc = [];
+  const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = programIds.filter((id) => seen.has(id) ? false : (seen.add(id), true));
+  for (const id of ordered) {
+    const directoryHit = dir.get(id);
+    if (directoryHit) {
+      programs.push(directoryHit);
+      continue;
+    }
+    if (cache2) {
+      const cached = getCacheEntry(cache2, id);
+      if (cached) {
+        const meta = getCacheEntryMeta(cache2, id);
+        programs.push({
+          ...cached,
+          provenance: {
+            ...cached.provenance ?? {},
+            notes: [
+              cached.provenance?.notes,
+              `cache-hit: cachedAt=${meta.cachedAt} sourceRun=${meta.sourceRun}`
+            ].filter(Boolean).join("; ")
+          }
+        });
+        continue;
+      }
+    }
+    if (opts.probeRpc === false) {
+      unresolved.push({
+        programId: id,
+        reason: "not_in_directory_or_cache_and_rpc_disabled"
+      });
+      continue;
+    }
+    let authority;
+    try {
+      authority = await probeUpgradeAuthority(id, opts);
+    } catch (e) {
+      unresolved.push({ programId: id, reason: `rpc_error: ${e?.message ?? String(e)}` });
+      continue;
+    }
+    const probed = {
+      programId: id,
+      name: `Unknown program (${id.slice(0, 8)}\u2026)`,
+      kind: "app",
+      upgradeAuthority: authority,
+      verifiedBuild: { state: "unknown" },
+      audits: [],
+      parity: { mainnet: "unknown", devnet: "unknown" },
+      provenance: { rpcUrl: opts.rpcUrl, notes: "live-probed; not in curated directory" }
+    };
+    programs.push(probed);
+    newFromRpc.push(id);
+    if (cache2) {
+      putCacheEntry(cache2, id, probed, runId);
+    }
+  }
+  if (cache2 && newFromRpc.length > 0) {
+    saveProgramCache(cache2, cachePathArg);
+  }
+  return { programs, unresolved, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+export {
+  loadDirectory,
+  DEFAULT_TTL_HOURS,
+  defaultCachePath,
+  loadProgramCache,
+  saveProgramCache,
+  getCacheEntry,
+  putCacheEntry,
+  getCacheEntryMeta,
+  isEntryExpired,
+  cacheSize,
+  buildTrustGraph
+};

package/dist/chunk-UWE6HAGS.js

@@ -0,0 +1,176 @@
+import {
+  buildTrustGraph
+} from "./chunk-SVSVVW6U.js";
+
+// src/score.ts
+var W_AUTHORITY = 35;
+var W_VERIFIED = 25;
+var W_AUDITS = 20;
+var W_CURATION = 10;
+var W_PARITY = 10;
+function scoreAuthority(ua) {
+  let points;
+  let detail;
+  switch (ua.kind) {
+    case "renounced":
+      points = W_AUTHORITY;
+      detail = "Upgrade authority renounced \u2014 program code is frozen forever.";
+      break;
+    case "dao":
+      points = 30;
+      detail = "Upgrade authority held by a governance program (DAO).";
+      break;
+    case "multisig":
+      points = 26;
+      detail = "Upgrade authority held by a multisig.";
+      break;
+    case "unknown":
+      if (ua.address) {
+        points = 12;
+        detail = `Upgrade authority present but unclassified (${ua.address}). Could be a single hot key.`;
+      } else {
+        points = 10;
+        detail = "Upgrade authority could not be determined.";
+      }
+      break;
+    case "single-key":
+    default:
+      points = 8;
+      detail = "Upgrade authority is a single key \u2014 it can replace the program's code at any time.";
+      break;
+  }
+  return { name: "Upgrade authority", weight: W_AUTHORITY, points, detail };
+}
+function scoreVerified(vb) {
+  let points;
+  let detail;
+  switch (vb.state) {
+    case "verified":
+      points = W_VERIFIED;
+      detail = `On-chain bytecode matches a published source build (${vb.registryUrl}).`;
+      break;
+    case "unverified":
+      points = 2;
+      detail = "Not present in any verified-build registry we trust.";
+      break;
+    case "unknown":
+    default:
+      points = 8;
+      detail = "Verified-build status not checked.";
+      break;
+  }
+  return { name: "Verified build", weight: W_VERIFIED, points, detail };
+}
+function scoreAudits(audits) {
+  let points = 0;
+  let detail = "No audits on record.";
+  if (audits.length >= 2) {
+    points = W_AUDITS;
+    detail = `${audits.length} audits on record (${audits.map((a) => a.firm).join(", ")}).`;
+  } else if (audits.length === 1) {
+    points = 16;
+    detail = `One audit on record (${audits[0].firm}, ${audits[0].date}).`;
+  }
+  return { name: "Audits", weight: W_AUDITS, points, detail };
+}
+function scoreCuration(program) {
+  const curated = program.upgradeAuthority.source === "directory" || !!program.provenance?.directoryFile;
+  return {
+    name: "Curation",
+    weight: W_CURATION,
+    points: curated ? W_CURATION : 0,
+    detail: curated ? "Listed in the curated program directory (known entity)." : "Not in the curated directory \u2014 identity is not independently corroborated."
+  };
+}
+function scoreParity(parity) {
+  let points;
+  let detail;
+  switch (parity.mainnet) {
+    case "present":
+      points = W_PARITY;
+      detail = "Deployed on mainnet as expected.";
+      break;
+    case "unknown":
+      points = 5;
+      detail = "Cross-cluster parity not checked.";
+      break;
+    default:
+      points = 0;
+      detail = `Mainnet deployment is '${parity.mainnet}' \u2014 possible devnet-only or address mismatch.`;
+      break;
+  }
+  return { name: "Cluster parity", weight: W_PARITY, points, detail };
+}
+function gradeForScore(score) {
+  if (score >= 90) return "A";
+  if (score >= 75) return "B";
+  if (score >= 60) return "C";
+  if (score >= 40) return "D";
+  return "F";
+}
+function scoreFromProgram(program) {
+  const factors = [
+    scoreAuthority(program.upgradeAuthority),
+    scoreVerified(program.verifiedBuild),
+    scoreAudits(program.audits ?? []),
+    scoreCuration(program),
+    scoreParity(program.parity ?? { mainnet: "unknown", devnet: "unknown" })
+  ];
+  const score = factors.reduce((s, f) => s + f.points, 0);
+  const grade = gradeForScore(score);
+  return {
+    programId: program.programId,
+    resolved: true,
+    score,
+    grade,
+    factors,
+    program,
+    summary: `${program.name} \u2014 grade ${grade} (${score}/100). ` + factors.find((f) => f.name === "Upgrade authority").detail
+  };
+}
+async function scoreProgram(programId, opts = {}) {
+  const graph = await buildTrustGraph([programId], opts);
+  const program = graph.programs.find((p) => p.programId === programId);
+  if (!program) {
+    const reason = graph.unresolved.find((u) => u.programId === programId)?.reason ?? "not resolved";
+    return {
+      programId,
+      resolved: false,
+      score: null,
+      grade: "unrated",
+      factors: [],
+      summary: `Could not resolve program ${programId}: ${reason}`,
+      unresolvedReason: reason
+    };
+  }
+  return scoreFromProgram(program);
+}
+function renderScoreText(s) {
+  if (!s.resolved) {
+    return `Trust score  [unrated]
+  ${s.summary}`;
+  }
+  const lines = [];
+  lines.push(`Trust score  [${s.grade}]  ${s.score}/100`);
+  lines.push(`  Program: ${s.program?.name ?? s.programId}`);
+  lines.push(`  Address: ${s.programId}`);
+  lines.push("");
+  lines.push("  Factors:");
+  for (const f of s.factors) {
+    lines.push(`    ${f.points}/${f.weight}  ${f.name} \u2014 ${f.detail}`);
+  }
+  return lines.join("\n");
+}
+function gradeAtLeast(grade, min) {
+  const order = { F: 0, D: 1, C: 2, B: 3, A: 4 };
+  if (grade === "unrated") return false;
+  return order[grade] >= order[min];
+}
+
+export {
+  gradeForScore,
+  scoreFromProgram,
+  scoreProgram,
+  renderScoreText,
+  gradeAtLeast
+};

package/dist/chunk-VG5FMOLW.js

@@ -0,0 +1,61 @@
+// src/trustGraph/base58.ts
+var ALPHA = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var MAP = {};
+for (let i = 0; i < ALPHA.length; i++) MAP[ALPHA[i]] = i;
+function base58Encode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const buf = Array.from(bytes);
+  const out = [];
+  let start = zeros;
+  while (start < buf.length) {
+    let rem = 0;
+    for (let i = start; i < buf.length; i++) {
+      const acc = rem * 256 + buf[i];
+      buf[i] = Math.floor(acc / 58);
+      rem = acc % 58;
+    }
+    out.push(rem);
+    if (buf[start] === 0) start++;
+  }
+  let s = "";
+  for (let i = 0; i < zeros; i++) s += "1";
+  for (let i = out.length - 1; i >= 0; i--) s += ALPHA[out[i]];
+  return s;
+}
+function base58Decode(s) {
+  let zeros = 0;
+  while (zeros < s.length && s[zeros] === "1") zeros++;
+  const buf = [];
+  for (let i = zeros; i < s.length; i++) {
+    const v = MAP[s[i]];
+    if (v === void 0) throw new Error(`base58: invalid char '${s[i]}' at ${i}`);
+    let carry = v;
+    for (let j = 0; j < buf.length; j++) {
+      const acc = buf[j] * 58 + carry;
+      buf[j] = acc & 255;
+      carry = acc >>> 8;
+    }
+    while (carry > 0) {
+      buf.push(carry & 255);
+      carry >>>= 8;
+    }
+  }
+  const out = new Uint8Array(zeros + buf.length);
+  for (let i = 0; i < buf.length; i++) out[zeros + buf.length - 1 - i] = buf[i];
+  return out;
+}
+function isValidSolanaAddress(s) {
+  if (typeof s !== "string" || s.length < 32 || s.length > 44) return false;
+  try {
+    return base58Decode(s).length === 32;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  base58Encode,
+  base58Decode,
+  isValidSolanaAddress
+};

package/dist/chunk-WX3IR7LK.js

@@ -0,0 +1,148 @@
+import {
+  analyzeToken
+} from "./chunk-FQA5BYWW.js";
+import {
+  verifyTokenIdentity
+} from "./chunk-VI2JBH2T.js";
+import {
+  getAccountInfo
+} from "./chunk-XSVQSK53.js";
+import {
+  base58Encode
+} from "./chunk-VG5FMOLW.js";
+
+// src/pumpCheck.ts
+function readU32LE(d, o) {
+  return d[o] | d[o + 1] << 8 | d[o + 2] << 16 | d[o + 3] << 24;
+}
+function readU64LE(d, o) {
+  let v = 0n;
+  for (let i = 7; i >= 0; i--) v = v << 8n | BigInt(d[o + i]);
+  return v;
+}
+function parseMintAccount(data) {
+  if (data.length < 82) throw new Error(`not an SPL mint account (got ${data.length} bytes, need \u226582)`);
+  const mintAuthOption = readU32LE(data, 0);
+  const freezeAuthOption = readU32LE(data, 46);
+  return {
+    mintAuthorityRevoked: mintAuthOption === 0,
+    freezeAuthorityRevoked: freezeAuthOption === 0,
+    mintAuthority: mintAuthOption === 1 ? base58Encode(data.subarray(4, 36)) : null,
+    freezeAuthority: freezeAuthOption === 1 ? base58Encode(data.subarray(50, 82)) : null,
+    supply: readU64LE(data, 36).toString(),
+    decimals: data[44],
+    isInitialized: data[45] === 1
+  };
+}
+function verdictFrom(checks) {
+  if (checks.some((c) => c.status === "fail")) return "NO-GO";
+  if (checks.some((c) => c.status === "warn")) return "CAUTION";
+  return "GO";
+}
+async function pumpPreflight(mint, opts = {}) {
+  const failOnRisk = opts.failOnRisk ?? 70;
+  const checks = [];
+  const report = { mint, verdict: "GO", checks };
+  try {
+    const acct = await getAccountInfo(mint, opts);
+    if (!acct) {
+      checks.push({ id: "mint-exists", label: "Mint account exists", status: "fail", detail: "No account found at this address on the selected cluster." });
+    } else {
+      const info = parseMintAccount(acct.data);
+      report.mintInfo = info;
+      checks.push({
+        id: "mint-authority-revoked",
+        label: "Mint authority revoked",
+        status: info.mintAuthorityRevoked ? "pass" : "fail",
+        detail: info.mintAuthorityRevoked ? "Mint authority is revoked \u2014 total supply is fixed." : `Mint authority is LIVE (${info.mintAuthority}). The holder can mint unlimited new supply and dilute every holder.`
+      });
+      checks.push({
+        id: "freeze-authority-revoked",
+        label: "Freeze authority revoked",
+        status: info.freezeAuthorityRevoked ? "pass" : "warn",
+        detail: info.freezeAuthorityRevoked ? "Freeze authority is revoked \u2014 token accounts cannot be frozen." : `Freeze authority is LIVE (${info.freezeAuthority}). The holder can freeze any user's token account.`
+      });
+    }
+  } catch (e) {
+    checks.push({ id: "mint-read", label: "Read mint account", status: "skip", detail: `Could not read mint account: ${e?.message ?? String(e)}` });
+  }
+  try {
+    const identity = await verifyTokenIdentity(mint, { baseUrl: opts.jupBaseUrl, offline: opts.offline });
+    report.identity = identity;
+    checks.push({
+      id: "identity",
+      label: "Token identity",
+      status: identity.impersonation ? "fail" : "pass",
+      detail: identity.impersonation ? `Impersonation: claims symbol '${identity.symbol}' but the canonical mint is ${identity.canonicalMint}.` : `Identity: ${identity.status}${identity.symbol ? ` (${identity.symbol})` : ""}.`
+    });
+  } catch (e) {
+    checks.push({ id: "identity", label: "Token identity", status: "skip", detail: `Identity check failed: ${e?.message ?? String(e)}` });
+  }
+  if (!opts.offline) {
+    const outcome = await analyzeToken(mint, { apiKey: opts.apiKey, baseUrl: opts.ricoBaseUrl });
+    if (outcome.ok) {
+      const q = outcome.result;
+      report.quality = q;
+      checks.push({
+        id: "risk-score",
+        label: "Rico risk score",
+        status: q.riskScore >= failOnRisk ? "fail" : q.riskScore >= 40 ? "warn" : "pass",
+        detail: `Rico risk score ${q.riskScore}/100 (threshold ${failOnRisk}).`
+      });
+      checks.push({
+        id: "snipers",
+        label: "Sniper activity",
+        status: q.snipersDetected ? "warn" : "pass",
+        detail: q.snipersDetected ? `Snipers detected (${(q.sniperPct * 100).toFixed(1)}% of holders).` : "No snipers detected."
+      });
+      checks.push({
+        id: "bundle-clusters",
+        label: "Bundle clusters",
+        status: q.bundleClustersDetected ? "warn" : "pass",
+        detail: q.bundleClustersDetected ? "Bundle launch clusters detected." : "No bundle clusters detected."
+      });
+      checks.push({
+        id: "holders",
+        label: "Holder distribution",
+        status: q.totalHolders < 50 ? "warn" : "pass",
+        detail: `${q.totalHolders} holders${q.cabalCount ? `, ${q.cabalCount} cabal wallet(s)` : ""}.`
+      });
+      if (q.deployerFlags.length) {
+        checks.push({
+          id: "deployer-flags",
+          label: "Deployer flags",
+          status: "warn",
+          detail: `Deployer flags: ${q.deployerFlags.join(", ")}.`
+        });
+      }
+    } else {
+      checks.push({
+        id: "rico-scan",
+        label: "Rico Maps scan",
+        status: "skip",
+        detail: `Quality scan skipped (${outcome.kind}): ${outcome.error}.`
+      });
+    }
+  } else {
+    checks.push({ id: "rico-scan", label: "Rico Maps scan", status: "skip", detail: "Offline mode \u2014 quality scan skipped." });
+  }
+  report.verdict = verdictFrom(checks);
+  return report;
+}
+var STATUS_ICON = { pass: "\u2713", warn: "\u26A0", fail: "\u2717", skip: "\xB7" };
+function renderPreflightText(r) {
+  const lines = [];
+  lines.push(`Launch pre-flight  [${r.verdict}]  ${r.mint}`);
+  if (r.mintInfo) lines.push(`  Supply: ${r.mintInfo.supply}  Decimals: ${r.mintInfo.decimals}`);
+  lines.push("");
+  for (const c of r.checks) {
+    lines.push(`  ${STATUS_ICON[c.status]} ${c.label} \u2014 ${c.detail}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  parseMintAccount,
+  pumpPreflight,
+  renderPreflightText
+};