six-degrees 0.4.10 → 0.5.0

package/.next/standalone/lib/people-map.js

@@ -0,0 +1,82 @@
+// Paths → People: the Paths map with people instead of companies (Blake,
+// 2026-10-02: "basically going to look like map but people based and the
+// bigger circle is their cluster with value"). One bubble per connection of
+// yours, sized by the cluster behind them; a line joins two connections whose
+// clusters share people.
+//
+// Plain functions over the rows the app already has, no React, so
+// tests/people-map.test.mjs runs them as they are.
+
+import { keyFor } from './separation.js';
+
+/** What a cluster is worth: S tier counts 3, A tier 2, everyone else 1. */
+export const clusterValue = ({ size = 0, S = 0, A = 0 } = {}) => size + 2 * S + A;
+
+/**
+ * One entry per connection: { person, id, key, size, S, A, value, only, share }.
+ * `size` is the people in their cluster (each once), `only` how many of those
+ * none of your other connections' clusters hold, `share` = only / size.
+ * Also `links`: [{ a, b, shared }] for every two connections whose clusters
+ * share people, most shared first, and `rank(id)`: the share of your scanned
+ * connections whose cluster is worth less.
+ */
+export function peopleMap(d1 = [], d2 = [], { maxLinks = 400 } = {}) {
+  const ids = new Set((d1 || []).map((c) => c.id));
+  // Each person once per connection whose scan found them.
+  const byConnection = new Map();   // id -> Map(key -> row)
+  const holders = new Map();        // key -> Set(connection id)
+  for (const row of d2 || []) {
+    const from = row?.source_connection_id;
+    if (from == null || !ids.has(from)) continue;
+    const key = keyFor(row);
+    let circle = byConnection.get(from);
+    if (!circle) byConnection.set(from, (circle = new Map()));
+    if (!circle.has(key)) circle.set(key, row);
+    let who = holders.get(key);
+    if (!who) holders.set(key, (who = new Set()));
+    who.add(from);
+  }
+
+  const people = (d1 || []).map((c) => {
+    const circle = byConnection.get(c.id);
+    let S = 0, A = 0, only = 0;
+    if (circle) {
+      for (const [key, row] of circle) {
+        if (row.tier === 'S') S++;
+        else if (row.tier === 'A') A++;
+        if (holders.get(key)?.size === 1) only++;
+      }
+    }
+    const size = circle ? circle.size : 0;
+    return { person: c, id: c.id, key: keyFor(c), size, S, A, value: clusterValue({ size, S, A }), only, share: size ? only / size : 0 };
+  });
+
+  // Two connections whose clusters share people. A person known to many of
+  // your connections would make a line between every two of them, so past
+  // eight holders they are left out of the lines (they still count in `only`).
+  const pairs = new Map();
+  for (const who of holders.values()) {
+    if (who.size < 2 || who.size > 8) continue;
+    const list = [...who].sort();
+    for (let i = 0; i < list.length; i++) {
+      for (let j = i + 1; j < list.length; j++) {
+        const k = `${list[i]}\u0000${list[j]}`;
+        pairs.set(k, (pairs.get(k) || 0) + 1);
+      }
+    }
+  }
+  const links = [...pairs].map(([k, shared]) => {
+    const [a, b] = k.split('\u0000');
+    return { a, b, shared };
+  }).sort((x, y) => y.shared - x.shared || (x.a < y.a ? -1 : 1)).slice(0, maxLinks);
+
+  const values = people.filter((p) => p.size > 0).map((p) => p.value).sort((x, y) => x - y);
+  const rank = (id) => {
+    const p = people.find((x) => x.id === id);
+    if (!p || !p.size || values.length < 2) return null;
+    let below = 0;
+    while (below < values.length && values[below] < p.value) below++;
+    return below / (values.length - 1);
+  };
+  return { people, links, rank };
+}

package/.next/standalone/lib/rarity.js

@@ -39,12 +39,15 @@ export function rarityInfo(key) {
 /**
  * How many mutual connections you share with someone, and where that number
  * came from: { count, from: 'linkedin' | 'scans' }. `waysIn` is how many of
- * your scanned connections know them (lib/separation.js).
+ * your scanned connections know them (lib/separation.js): never fewer than that.
  */
 export function mutualsOf(row, waysIn = 1) {
   const saved = Number(row?.mutual_count);
-  if (Number.isFinite(saved) && saved >= 1) return { count: Math.floor(saved), from: 'linkedin' };
-  return { count: Math.max(1, Math.floor(Number(waysIn) || 1)), from: 'scans' };
+  const seen = Math.max(1, Math.floor(Number(waysIn) || 1));
+  // Everyone the app found them through is a mutual connection, so a saved
+  // count lower than that is out of date: "only way in" with two ways drawn.
+  if (Number.isFinite(saved) && saved >= seen) return { count: Math.floor(saved), from: 'linkedin' };
+  return { count: seen, from: 'scans' };
 }
 
 /** Someone's rarity: { key, count, from }. */
@@ -78,3 +81,42 @@ export function toggle(set, key) {
   else next.add(key);
   return next;
 }
+
+// ── The Separation slider ──────────────────────────────────────────────────
+// Blake, 2026-10-01: the rare person reachable through one door at one end,
+// the easier, well-connected ones at the other, "so it's seamless"; 2026-10-02:
+// "i want it to be slider ajusted and can be dynmaic". One number, 0 to 100:
+// 0 puts the rarest ways in first, 100 the easiest, and 50 is each person's own
+// score alone, as the list has always been. It reorders; it never changes a
+// score, a tier or a rank. No odds are claimed: the app hasn't measured how
+// often anyone accepts.
+
+export const SLIDER_MIDDLE = 50;
+
+/** How easy the way in is: 0 with one mutual connection, 1 with 31 or more, on a log scale (1→3 counts like 10→30). */
+export function easeOf(count) {
+  const n = Math.max(1, Math.floor(Number(count) || 1));
+  return Math.min(1, Math.log(n) / Math.log(31));
+}
+
+/**
+ * Where someone sorts with the slider at `at`: their score, weighted by how
+ * well their way in fits the end the slider leans to. At 50 it is the score.
+ */
+export function slideValue(score, count, at = SLIDER_MIDDLE) {
+  const lean = (Math.max(0, Math.min(100, Number(at) || 0)) - SLIDER_MIDDLE) / SLIDER_MIDDLE;   // -1 rare … +1 easy
+  if (!lean) return score;
+  const ease = easeOf(count);
+  const pull = Math.abs(lean);
+  return score * (1 - pull + pull * (lean < 0 ? 1 - ease : ease));
+}
+
+/** What the slider is doing at `at`, in words: { name, detail }. */
+export function slideLabel(at = SLIDER_MIDDLE) {
+  const v = Math.max(0, Math.min(100, Math.round(Number(at) || 0)));
+  if (v <= 10) return { name: 'Rarest first', detail: 'Strong people with one way in: the connection who knows them is the only door you have.' };
+  if (v < 45) return { name: 'Leaning rare', detail: 'Strong people with few mutual connections move up; the ones everybody knows move down.' };
+  if (v <= 55) return { name: 'By power', detail: 'Each person’s own score alone. How many of your connections know them doesn’t change the order.' };
+  if (v < 90) return { name: 'Leaning easy', detail: 'Strong people you share more mutual connections with move up: more people who could introduce you.' };
+  return { name: 'Easiest first', detail: 'Strong people you share the most mutual connections with: the warmest introductions. All the way right, the map aims at whoever you share the most with, with the ones in circles you haven’t scanned yet as grey dots.' };
+}

package/.next/standalone/lib/reach.js

@@ -20,6 +20,7 @@
 //
 // Plain functions, no React; tests/reach.test.mjs.
 
+import { paceSeconds } from './scan-pace.js';
 import { keyFor, compareBridges } from './separation.js';
 
 /**
@@ -107,13 +108,13 @@ export function readyByCircle(reach) {
  * page, a minute more after every 10), so about 55 minutes for a whole list.
  * The Scan page and the Degrees panel both say it from here.
  */
-export function circleScanCost(pages = 100) {
+export function circleScanCost(pages = 100, pace = 'fast') {
   const searches = Math.max(1, Math.min(100, Math.round(pages) || 100));
-  return {
-    profileViews: 1,
-    searches,
-    minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
-  };
+  // At Fast, as it has always been said; slower speeds add their waits (lib/scan-pace.js).
+  const minutes = !pace || pace === 'fast'
+    ? (searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)))
+    : Math.max(5, Math.round(paceSeconds(pace, searches) / 60));
+  return { profileViews: 1, searches, minutes };
 }
 
 /**

package/.next/standalone/lib/rpc.js

@@ -7,6 +7,7 @@ import { getDb, newId, nowIso } from './db-client.js';
 // for the routes that call it; it rescores with lib/scoring.js like the rest.
 
 import { readNetwork, scoreNetwork, explainScore, SCORING_VERSION, KNOWN_COMPANIES, COMPANY_DATA, RULE_TABLES, TIER_SCALE_SETTING } from './scoring.js';
+import { TITLE_RANKING_SETTING, isDefaultRanking, rankingFingerprint } from './title-ranking.js';
 import { industryKeyOf, INDUSTRIES } from './companies.js';
 import { readSettings } from './settings.js';
 import { SECTOR_FOCUS_SETTING, focusFingerprint, previewSectorFocus } from './sector-focus.js';
@@ -69,6 +70,12 @@ export function tierScaleOf(db = getDb()) {
   return readSettings(db, { tierScale: TIER_SCALE_SETTING }).tierScale;
 }
 
+/** Your title ranking (Settings → Scores → Titles), or null when you haven't changed one. */
+export function titleRankingOf(db = getDb()) {
+  const r = readSettings(db, { titleRanking: TITLE_RANKING_SETTING }).titleRanking;
+  return isDefaultRanking(r) ? null : r;
+}
+
 /**
  * What rescoring reads: every row, as scoring needs it. `withPeople` adds each
  * row's name, for naming who a change would move.
@@ -111,12 +118,13 @@ export function rescoreAll({ compareWith } = {}) {
   const overrides = companyOverrides(db);
   const focus = sectorFocusOf(db);
   const tierScale = tierScaleOf(db);
+  const titles = titleRankingOf(db);
   // Every headline is read once, however many ways the rows are then scored.
   const read = readForScoring(rows);
-  const { scores } = scoreNetwork(rows, { overrides, focus, tierScale, read });
+  const { scores } = scoreNetwork(rows, { overrides, focus, tierScale, titles, read });
   // Worked out before anything is written, so a failure leaves nothing half done.
   const change = compareWith === undefined ? null
-    : previewSectorFocus(rows, { overrides, read, from: compareWith, to: focus, tierScale, examples: 0 });
+    : previewSectorFocus(rows, { overrides, read, from: compareWith, to: focus, tierScale, titles, examples: 0 });
   const update = db.prepare(`UPDATE linkedin_connections SET seniority_score = ?, company_prestige_score = ?, power_score = ?, tier = ?,
     score_why = ?, circle_power = ?, circle_s_count = ?, circle_a_count = ?, circle_elite_pct = ?, is_catalyst = ?, catalyst_score = ?, updated_at = ?
     WHERE id = ?`);
@@ -144,6 +152,7 @@ export function rescoreAll({ compareWith } = {}) {
     meta.run('scoring_list', KNOWN_LIST_STAMP);
     meta.run('scoring_focus', focusFingerprint(focus));
     meta.run('scoring_tiers', tierScale);
+    meta.run('scoring_titles', rankingFingerprint(titles || undefined));
     db.exec('COMMIT');
   } catch (err) {
     db.exec('ROLLBACK');
@@ -154,7 +163,7 @@ export function rescoreAll({ compareWith } = {}) {
 
 /**
  * Rescore once if the stored scores came from an older scoring model or
- * curated list, or from a sector focus or tier scale other than the one saved
+ * curated list, or from a sector focus, tier scale or title ranking other than the one saved
  * now: an update, a database restored or brought from another computer, or a
  * Settings save whose rescore never finished.
  */
@@ -164,7 +173,9 @@ export function rescoreIfStale() {
   const fresh = meta('scoring_version') === String(SCORING_VERSION)
     && meta('scoring_list') === KNOWN_LIST_STAMP
     && meta('scoring_focus') === focusFingerprint(sectorFocusOf(db))
-    && meta('scoring_tiers') === tierScaleOf(db);
+    && meta('scoring_tiers') === tierScaleOf(db)
+    // Scores from before title rankings existed have no stamp, and none is the same as no ranking.
+    && (meta('scoring_titles') ?? 'none') === rankingFingerprint(titleRankingOf(db) || undefined);
   return fresh ? { scored: 0 } : rescoreAll();
 }
 

package/.next/standalone/lib/scan-pace.js

@@ -0,0 +1,46 @@
+// The Scan page's speed: Fast, Medium or Slow (Blake, 2026-09-30: "a bar that
+// will adjust the scanner from slow, medium and fast… the current is
+// considered fast, and then we lower to medium and slow, bogging it down,
+// making it less likely to get caught, and estimated time for each").
+//
+// Fast is today's pacing and nothing is faster; Medium and Slow only add
+// waiting. Speed changes searches an hour, never searches a day: the daily
+// budget is still the volume cap. scripts/scrape.py SCAN_PACES holds the same
+// numbers (tests/scan-pace.test.mjs checks they agree). Fixed waits, never
+// random "human" timing: the point is fewer searches an hour, not disguise.
+
+export const PACES = {
+  fast: { label: 'Fast', pagePause: 20, chunkCooldown: 60, profileGap: 60 },
+  medium: { label: 'Medium', pagePause: 45, chunkCooldown: 180, profileGap: 90 },
+  slow: { label: 'Slow', pagePause: 90, chunkCooldown: 300, profileGap: 120 },
+};
+export const PACE_NAMES = ['slow', 'medium', 'fast'];
+export const DEFAULT_PACE = 'fast';
+// About how long reading one page of results takes, measured in 0.1.6.
+export const WORK_SECONDS = 6;
+const EVERY = 10;   // the longer rest comes after every 10 pages (scrape.py SAVE_EVERY_PAGES)
+
+export const paceOf = (name) => PACES[name] || PACES[DEFAULT_PACE];
+
+/** Seconds to run `searches` searches at a speed: the work, the rest before each, the longer rest every 10. */
+export function paceSeconds(name, searches) {
+  const p = paceOf(name);
+  const n = Math.max(0, Math.floor(Number(searches) || 0));
+  return n * (WORK_SECONDS + p.pagePause) + Math.floor(n / EVERY) * p.chunkCooldown;
+}
+
+/** About how many searches an hour a speed makes. */
+export function searchesPerHour(name) {
+  const p = paceOf(name);
+  return Math.round(3600 / (WORK_SECONDS + p.pagePause + p.chunkCooldown / EVERY));
+}
+
+/** "about 1 h 7 min", "about 27 min", "under a minute" */
+export function durationText(seconds) {
+  if (!(seconds >= 60)) return 'under a minute';
+  const m = Math.round(seconds / 60);
+  if (m < 60) return `about ${m} min`;
+  const h = Math.floor(m / 60);
+  const rest = m % 60;
+  return `about ${h} h${rest ? ` ${rest} min` : ''}`;
+}

package/.next/standalone/lib/scoring.js

@@ -2512,18 +2512,47 @@ export function readPerson(row) {
  * points whatever else they list. `companyFor(name)` returns companyScore();
  * `read` is the row's readPerson(), when it has been read already.
  */
-/** A role's title points as they count: 70% for a former role, capped for a student. */
-function rolePoints(role, student) {
-  const points = role.title.points * (role.former ? FORMER_WEIGHT : 1);
+/** Does this title text have the words? Whole words only: "vc" isn't in "dvc", "cto" isn't in "doctor". */
+const titlePatterns = new Map();
+export function titleHas(text, words) {
+  let re = titlePatterns.get(words);
+  if (!re) {
+    const esc = words.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    re = new RegExp(`(^|[^a-z0-9])${esc}($|[^a-z0-9])`);
+    if (titlePatterns.size > 500) titlePatterns.clear();
+    titlePatterns.set(words, re);
+  }
+  return re.test(String(text || '').toLowerCase());
+}
+
+/**
+ * A title's points under your title ranking (Settings → Scores → Titles,
+ * lib/title-ranking.js): a role whose words are in it counts what you gave
+ * that role (the highest, if several match), else the level counts your
+ * points for it, else the model's. No ranking: the model's.
+ */
+export function rankedPoints(role, titles) {
+  if (!titles) return role.title.points;
+  let match = null;
+  for (const r of titles.roles || []) {
+    if (titleHas(role.part, r.text) && (match == null || r.points > match)) match = r.points;
+  }
+  if (match != null) return match;
+  return titles.points?.[role.title.key] ?? role.title.points;
+}
+
+/** A role's title points as they count: yours where you ranked them, 70% for a former role, capped for a student. */
+function rolePoints(role, student, titles) {
+  const points = rankedPoints(role, titles) * (role.former ? FORMER_WEIGHT : 1);
   return student ? Math.min(points, STUDENT_CAP) : points;
 }
 
-export function scorePerson(row, companyFor = (name) => companyScore(name), read = readPerson(row)) {
+export function scorePerson(row, companyFor = (name) => companyScore(name), read = readPerson(row), titles = null) {
   const { roles, student, reach } = read;
   let best = null;
   for (const role of roles) {
     const co = companyFor(role.company);
-    const points = rolePoints(role, student);
+    const points = rolePoints(role, student, titles);
     const core = points * (0.45 + 0.055 * co.score);
     if (!best || core > best.core) best = { role, co, points, core };
   }
@@ -2535,6 +2564,8 @@ export function scorePerson(row, companyFor = (name) => companyScore(name), read
   const bonus = reachBonus(row?.headline, unknown ? 4 : best.co.base ?? best.co.score, reach);
   const power = round1(best.core + bonus.points);
   const title = { ...best.role.title, former: best.role.former, student, points: round1(best.points) };
+  // Your ranking moved it: the card's "why" says so.
+  if (titles && rankedPoints(best.role, titles) !== best.role.title.points) title.ranked = true;
   if (best.role.former) title.label = `Former ${title.label}`;
   if (student && best.role.title.level > 0) title.label = `Student · ${title.label}`;
   const out = { title, company: best.role.company, companyScore: best.co.score, companySource: best.co.source, bonus, power, tier: tierFor(power) };
@@ -2652,7 +2683,7 @@ export function explainScore(s, boost = 0, { sectorLabel } = {}) {
   const co = s.companySector
     ? `${s.company} (${s.companyScore}/10: ${s.companySector.base} + ${s.companySector.bonus} your sector${which ? `: ${which}` : ''})`
     : `${s.company || 'no company found'} (${s.companyScore}/10${s.companySource === 'yours' ? ', your score' : ''})`;
-  const bits = [`${s.title.label} (${s.title.points})`, co];
+  const bits = [`${s.title.label} (${s.title.points}${s.title.ranked ? ', your ranking' : ''})`, co];
   if (s.bonus.points) bits.push(`+${s.bonus.points} ${s.bonus.reasons.join(', ')}`);
   if (boost) bits.push(`+${boost} strong circle`);
   return bits.join(' · ');
@@ -2716,7 +2747,7 @@ export function readNetwork(rows = [], { industryOf, sectorsOf, groupOf } = {})
  * (companyScore(), by name) and the curve's cut-offs (null on the fixed scale).
  */
 export function scoreNetwork(rows = [], {
-  overrides = new Map(), industryOf, sectorsOf, groupOf, focus, tierScale = 'fixed',
+  overrides = new Map(), industryOf, sectorsOf, groupOf, focus, tierScale = 'fixed', titles = null,
   read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
 } = {}) {
   // Each company is scored once; everyone there shares the answer.
@@ -2726,7 +2757,7 @@ export function scoreNetwork(rows = [], {
     return companyScores.get(name);
   };
   const out = new Map();
-  for (const r of rows) out.set(r.id, { ...scorePerson(r, companyFor, read.people.get(r)), boost: 0 });
+  for (const r of rows) out.set(r.id, { ...scorePerson(r, companyFor, read.people.get(r), titles), boost: 0 });
   // The curve's cut-offs come from your 1st-degree people before any circle
   // boost, so a boost (which reads the graded tiers) can't move its own cut-off.
   const cutoffs = tierScale === 'fixed' ? null

package/.next/standalone/lib/scraper-client.js

@@ -15,11 +15,27 @@ export async function scraperStatus() {
   return r.json();
 }
 
+/**
+ * Scan page → "Hide the Chrome window while scanning", remembered in this
+ * browser. Every way a scan starts asks here: the Scan page's own buttons used
+ * to post straight to the scanner without it, so the switch did nothing for
+ * the scans started from the very page it sits on.
+ */
+export const HIDE_CHROME_KEY = 'six-degrees-hide-chrome';
+export function hideChromeOn(storage = typeof localStorage !== 'undefined' ? localStorage : null) {
+  try { return JSON.parse(storage?.getItem(HIDE_CHROME_KEY) || 'false') === true; } catch { return false; }
+}
+
+/** What a scan start sends: the action, its details, and `headless` when Chrome is to stay hidden. */
+export function scanRequest(action, extra = {}, hidden = hideChromeOn()) {
+  return { action, ...extra, ...(hidden ? { headless: true } : {}) };
+}
+
 export async function startScrape(action, name, extra = {}) {
   const r = await fetch('/api/scraper', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ action, ...(name ? { name } : {}), ...extra }),
+    body: JSON.stringify(scanRequest(action, { ...(name ? { name } : {}), ...extra })),
   });
   const d = await r.json().catch(() => ({}));
   if (!r.ok) throw new Error(d.error || 'Could not start the scanner.');
@@ -211,11 +227,8 @@ export async function beginScrape(action, { name, id, onLog, ...extra } = {}) {
   });
   let started;
   try {
-    // Scan page → "Hide the Chrome window while scanning", remembered in this
-    // browser, applies to every scan however it was started.
-    let hidden = false;
-    try { hidden = JSON.parse(localStorage.getItem('six-degrees-hide-chrome') || 'false') === true; } catch {}
-    started = await startScrape(action, name, { ...(id ? { id } : {}), ...(hidden ? { headless: true } : {}), ...extra });
+    // startScrape adds "Hide the Chrome window" itself (scanRequest), however the scan was started.
+    started = await startScrape(action, name, { ...(id ? { id } : {}), ...extra });
   } catch (err) {
     // Refused, often because something else runs: ask what, straight away.
     // Until the answer comes, only our own claim is taken back.

package/.next/standalone/lib/sector-focus.js

@@ -141,11 +141,11 @@ export function tierMoves(rows, tierBefore, tierAfter, { examples = 5, companyOf
  */
 export function previewSectorFocus(rows = [], {
   overrides = new Map(), industryOf, sectorsOf = sectorMatcher(), groupOf = sectorGroup, from = NO_FOCUS, to = NO_FOCUS, examples = 5,
-  tierScale, read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
+  tierScale, titles = null, read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
 } = {}) {
-  // Both on the tier scale saved now (Scores → Tiers), as rescoring grades them.
-  const before = scoreNetwork(rows, { overrides, focus: from, tierScale, read });
-  const after = scoreNetwork(rows, { overrides, focus: to, tierScale, read });
+  // Both on the tier scale and title ranking saved now (Scores → Tiers, Titles), as rescoring grades them.
+  const before = scoreNetwork(rows, { overrides, focus: from, tierScale, titles, read });
+  const after = scoreNetwork(rows, { overrides, focus: to, tierScale, titles, read });
 
   // Companies whose score moves, biggest first (by your people there now).
   // Every company anyone names counts, a former employer too: its score moves

package/.next/standalone/lib/separation.js

@@ -86,11 +86,6 @@ export function comparePower(a, b) {
 }
 const NO_ROUTE = { id: null, bridge: null };
 
-/** "Ways in" order: most ways in first, then the power order. The rank shown stays the power rank. */
-export function compareWaysIn(a, b) {
-  return b.waysIn - a.waysIn || comparePower(a, b);
-}
-
 /**
  * @param {object[]} degree2      2nd-degree rows (one per bridge per person)
  * @param {object[]} connections  1st-degree rows, the bridges
@@ -236,6 +231,10 @@ export function dotRadius(waysIn) {
 
 export const MIN_BRIDGE_GAP = 18;
 const TOP_PAD = 16;
+/** Grey dots for mutual connections in circles not scanned yet, at most this many drawn. */
+export const GHOST_MAX = 60;
+const GHOST_LABEL = 40;   // room under the last connection for the line that counts them
+const PILL_W_LAYOUT = 236;   // SeparationView's PILL_W: the connection pills' width as cards
 
 /**
  * The summit map: You → the bridges → the top of the list, every route drawn.
@@ -249,10 +248,13 @@ const TOP_PAD = 16;
  *
  * @param {object[]} top    the first K people of whatever the list shows
  * @param {number}   width  map width in px
+ * @param {{ cards?: boolean }} opts  cards: people drawn as cards and
+ *   connections as pills (Blake, 2026-10-02), which need more room per row
  * @returns {{ width, height, you, people, bridges, links, spokes }}
  */
-export function summitLayout(top = [], width = 800, isMobile = false) {
-  const gap = isMobile ? 36 : 26;
+export function summitLayout(top = [], width = 800, isMobile = false, { cards = false } = {}) {
+  const gap = cards ? 50 : isMobile ? 36 : 26;
+  const bridgeGap = cards ? 36 : MIN_BRIDGE_GAP;
   const youX = 20;
   const bx = Math.round(width * 0.42);
   const px = Math.round(width * 0.58);
@@ -262,7 +264,7 @@ export function summitLayout(top = [], width = 800, isMobile = false) {
     p,
     x: px,
     y: TOP_PAD + i * gap,
-    r: dotRadius(p.waysIn),
+    r: cards ? 0 : dotRadius(p.waysIn),
     label: fit(`#${p.rank}${p.tied ? '=' : ''} ${p.person.name || ''}`, Math.floor((width - px - 60) / 6.2)),
   }));
 
@@ -288,11 +290,16 @@ export function summitLayout(top = [], width = 800, isMobile = false) {
 
   const y0 = TOP_PAD;
   const y1 = people.length ? people[people.length - 1].y : TOP_PAD;
-  const step = bridges.length > 1 ? Math.max(MIN_BRIDGE_GAP, (y1 - y0) / (bridges.length - 1)) : 0;
+  // Each connection sits level with the people they lead to (the middle of
+  // them), moved no more than it takes to keep `bridgeGap` from the next one,
+  // so a connection with one person sits on that person's row and the line
+  // between them runs straight (Blake, 2026-10-02: "the lines should line up
+  // with every box").
+  const ys = stackColumn(bridges.map((b) => b.bary), bridgeGap, y0);
   const nameBudget = Math.max(4, Math.floor((bx - 10 - (youX + 22)) / 6));
   bridges.forEach((b, j) => {
     b.x = bx;
-    b.y = bridges.length === 1 ? (y0 + y1) / 2 : y0 + j * step;
+    b.y = ys[j];
     b.r = 5;
     if (b.unresolved) b.label = fit(`can't be named (${b.count})`, nameBudget);
     else {
@@ -302,6 +309,15 @@ export function summitLayout(top = [], width = 800, isMobile = false) {
     delete b.ys;
   });
   const nodeFor = new Map(bridges.map((b) => [b.unresolved ? UNRESOLVED : b.id, b]));
+  // What each connection is to the people on the map: the only door to some,
+  // the best way in to others, or only another way in.
+  for (const b of bridges) { b.onlyFor = 0; b.bestFor = 0; }
+  for (const pp of people) {
+    const first = pp.p.routes[0];
+    const bestNode = first ? nodeFor.get(first.bridge ? first.id : UNRESOLVED) : null;
+    if (bestNode) bestNode.bestFor++;
+    if (pp.p.waysIn === 1 && bestNode) bestNode.onlyFor++;
+  }
 
   // Routes, per person: routes[0] is the top-scored bridge. Two unnamed routes
   // for one person are one line to the one grey node.
@@ -326,3 +342,114 @@ export function summitLayout(top = [], width = 800, isMobile = false) {
   const spokes = bridges.map((b) => ({ id: b.id, x1: you.x, y1: you.y, x2: b.x, y2: b.y }));
   return { width, height, you, people, bridges, links, spokes };
 }
+
+/**
+ * Heights as near the ones asked for as they can be while staying `gap`
+ * apart, in the order given (already sorted), never above `top`: neighbours
+ * that would overlap move apart by the same amount each way.
+ */
+export function stackColumn(wanted = [], gap = MIN_BRIDGE_GAP, top = 0) {
+  const blocks = [];
+  wanted.forEach((y, k) => {
+    blocks.push({ sum: y - k * gap, count: 1 });
+    while (blocks.length > 1 && blocks[blocks.length - 2].sum / blocks[blocks.length - 2].count > blocks[blocks.length - 1].sum / blocks[blocks.length - 1].count) {
+      const last = blocks.pop();
+      blocks[blocks.length - 1].sum += last.sum;
+      blocks[blocks.length - 1].count += last.count;
+    }
+  });
+  const out = blocks.flatMap((b) => new Array(b.count).fill(b.sum / b.count)).map((q, k) => q + k * gap);
+  const lift = out.length && out[0] < top ? top - out[0] : 0;
+  return out.map((y) => y + lift);
+}
+
+/**
+ * Who the map aims at with the slider all the way to easy: whoever you share the
+ * most mutual connections with, scanned or not (Blake, 2026-10-02: "if we have
+ * mutuals but not scanned thats still a high probability … i dont want to hinder
+ * the algorithm since we havent scanned that person"). `mutualsOf` is LinkedIn's
+ * count where a scan saved one, never less than the ways in the app has drawn
+ * (lib/rarity.js). Then the most drawn, then the stronger person. Narrowing the
+ * tiers first (S only, say) keeps it to the people worth it.
+ */
+export function mostMutuals(people = [], mutualsOf = () => 0, limit = 7) {
+  return [...people].sort((a, b) => (Math.max(mutualsOf(b) || 0, b.waysIn) - Math.max(mutualsOf(a) || 0, a.waysIn))
+    || b.waysIn - a.waysIn
+    || comparePower(a, b)).slice(0, limit);
+}
+
+/**
+ * How many people the map draws with the slider at `at` (lib/rarity.js): all
+ * `k` from the rare end to the middle, then fewer and fewer, down to the one
+ * person you're aiming at with the slider all the way to easy. Blake,
+ * 2026-10-02: at the rare end "it will show that one door"; at the other "all
+ * the connections going into that one person".
+ */
+export function mapCount(at, k = 10) {
+  const v = Math.max(0, Math.min(100, Number(at) || 0));
+  if (v <= 50) return k;
+  return Math.max(1, Math.round((k * (100 - v)) / 50));
+}
+
+/**
+ * The map for one person: You → every connection of yours who leads to them →
+ * them, with rings round them. Routes the map can't name share one grey node,
+ * as in summitLayout, and it comes back in summitLayout's shape (`people` holds
+ * the one person, marked `big`), so one map draws both and can glide from one
+ * to the other. Pure, so it is tested without a browser.
+ *
+ * @returns {{ width, height, you, target, people, bridges, links, spokes }}
+ */
+export function convergeLayout(p, width = 800, isMobile = false, { cards = false, mutuals = 0 } = {}) {
+  const gap = cards ? 46 : isMobile ? 40 : 34;
+  const youX = 20;
+  const bx = Math.round(width * (isMobile ? 0.44 : 0.36));
+  const tx = Math.round(width * (isMobile ? 0.8 : cards ? 0.6 : 0.62));
+  const nodes = [];
+  let unnamed = null;
+  for (const r of p?.routes || []) {
+    if (r.bridge) nodes.push({ id: r.id, bridge: r.bridge, unresolved: false, count: 1 });
+    else if (unnamed) unnamed.count++;
+    else nodes.push((unnamed = { id: null, bridge: null, unresolved: true, count: 1 }));
+  }
+  // Mutual connections the app can't draw yet: they're in circles you haven't
+  // scanned. Grey dots under the connections who do lead there, each with a faint
+  // line in, so the count reads at a glance (GHOST_MAX at most, then "+N").
+  const unscanned = Math.max(0, Math.floor(Number(mutuals) || 0) - (p?.waysIn || 0));
+  const ghostCount = Math.min(GHOST_MAX, unscanned);
+  const ghostStep = cards ? 12 : 11;
+  const ghostW = cards ? PILL_W_LAYOUT - 16 : isMobile ? 96 : 120;
+  const perRow = Math.max(1, Math.floor(ghostW / ghostStep) + 1);
+  const ghostRows = Math.ceil(ghostCount / perRow);
+  const ghostH = ghostCount ? GHOST_LABEL + ghostRows * ghostStep : 0;
+  const block = Math.max(0, nodes.length - 1) * gap + ghostH;
+  const height = Math.max(isMobile ? 190 : cards ? 250 : 220, TOP_PAD * 2 + block + 48);
+  const mid = height / 2;
+  const top = mid - block / 2;
+  const nameBudget = Math.max(4, Math.floor((bx - 10 - (youX + 22)) / 6));
+  const bridges = nodes.map((n, j) => {
+    const full = n.unresolved ? `can't be named (${n.count})` : n.bridge.name || '';
+    return {
+      ...n, x: bx, y: top + j * gap, r: 6,
+      primary: j === 0 && !n.unresolved,
+      label: full.length <= nameBudget ? full : fit(n.unresolved ? full : shortName(full), nameBudget),
+    };
+  });
+  const target = { x: tx, y: mid, r: cards ? 0 : 17, rings: cards ? [] : [32, 50, 70].filter((r) => r <= mid - 4) };
+  const links = bridges.map((b) => ({
+    key: p?.key, bridgeId: b.id, primary: b.primary, unresolved: b.unresolved, tier: b.bridge?.tier ?? null,
+    x1: b.x, y1: b.y, x2: target.x, y2: target.y,
+  }));
+  const you = { x: youX, y: mid, r: 14 };
+  const spokes = bridges.map((b) => ({ id: b.id, x1: you.x, y1: you.y, x2: b.x, y2: b.y }));
+  const people = p ? [{ key: p.key, p, x: target.x, y: target.y, r: target.r, rings: target.rings, big: true, label: '' }] : [];
+  const gy = top + Math.max(0, nodes.length - 1) * gap + GHOST_LABEL;
+  const gx = cards ? bx - PILL_W_LAYOUT + 8 : bx - ghostW;
+  const ghosts = Array.from({ length: ghostCount }, (_, i) => ({ x: gx + (i % perRow) * ghostStep, y: gy + Math.floor(i / perRow) * ghostStep }));
+  // How bright the person is: the share of your mutual connections with them that the map can draw.
+  const drawn = p?.waysIn ? p.waysIn / (p.waysIn + unscanned) : 1;
+  return {
+    width, height, you, target, people, bridges, links, spokes,
+    ghosts, unscanned, ghostLabel: ghostCount ? { x: gx, y: gy - 13 } : null, drawn,
+  };
+}