six-degrees 0.4.11 → 0.5.0

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,
+  };
+}

package/.next/standalone/lib/settings-effects.js

@@ -5,28 +5,37 @@
 
 import { rescoreAll } from './rpc.js';
 import { sameFocus, NO_FOCUS, tierMoves } from './sector-focus.js';
+import { rankingFingerprint } from './title-ranking.js';
 
 // Each entry: `changed(before, after)` says whether a change matters (by
 // default, any change to the stored value), and `run(db, after, before)` does
 // the work and returns what to tell the page.
+// Rescore everyone and count who changed tier, from the stored tiers before and after.
+function rescoreCountingMoves(db) {
+  const rows = () => db.prepare('SELECT id, degree, profile_url, tier FROM linkedin_connections').all();
+  try {
+    const before = new Map(rows().map((r) => [r.id, r.tier]));
+    const { scored } = rescoreAll();
+    const { people, up, down } = tierMoves(rows(), (r) => before.get(r.id), (r) => r.tier, { examples: 0 });
+    return { scored, people, moved: up + down, up, down };
+  } catch (err) {
+    throw new Error(`Saved, but rescoring your network failed (${err.message}). It will try again the next time the map loads.`);
+  }
+}
+
 const EFFECTS = {
+  // Title points are part of everyone's score, so a new ranking rescores everyone, as a new tier scale does.
+  titleRanking: {
+    changed: (before, after) => rankingFingerprint(before) !== rankingFingerprint(after),
+    run: (db) => rescoreCountingMoves(db),
+  },
   tierScale: {
     // Tiers are graded when everyone is scored, so a new scale rescores
     // everyone. The answer counts who changed tier, from the stored tiers
     // before and after, with the sector focus's own counter (tierMoves): a
     // person reachable through two bridges is two rows but one person, counted
     // once at their closest degree.
-    run(db) {
-      const rows = () => db.prepare('SELECT id, degree, profile_url, tier FROM linkedin_connections').all();
-      try {
-        const before = new Map(rows().map((r) => [r.id, r.tier]));
-        const { scored } = rescoreAll();
-        const { people, up, down } = tierMoves(rows(), (r) => before.get(r.id), (r) => r.tier, { examples: 0 });
-        return { scored, people, moved: up + down, up, down };
-      } catch (err) {
-        throw new Error(`Saved, but rescoring your network failed (${err.message}). It will try again the next time the map loads.`);
-      }
-    },
+    run: (db) => rescoreCountingMoves(db),
   },
   sectorFocus: {
     // Only a change to what scoring uses: a strength with no sectors picked

package/.next/standalone/lib/settings.js

@@ -12,6 +12,7 @@
 
 import { SECTOR_FOCUS_SETTING, FIELD_ASKED_SETTING } from './sector-focus.js';
 import { TIER_SCALE_SETTING } from './scoring.js';
+import { TITLE_RANKING_SETTING } from './title-ranking.js';
 
 export const SETTINGS = {
   // Scores → Your sector: industries whose companies count for more (lib/sector-focus.js).
@@ -20,6 +21,8 @@ export const SETTINGS = {
   fieldAsked: FIELD_ASKED_SETTING,
   // Scores → Tiers: graded on your network's curve, or on the fixed scale (lib/scoring.js).
   tierScale: TIER_SCALE_SETTING,
+  // Scores → Titles: how much each kind of title counts, and roles you're looking for (lib/title-ranking.js).
+  titleRanking: TITLE_RANKING_SETTING,
 };
 
 const KEY = 'settings';

package/.next/standalone/lib/tier-grid.js

@@ -0,0 +1,99 @@
+// The Filters panel's grid: five tiers down, six degrees across, the same in
+// Network Circle and in Degrees.
+//
+// Blake, 2026-10-02: "keeping the tiers as is but enlarging them and having 6
+// dots to let the user tap on to toggle or not if they want specific degrees
+// showing for whatever tier … it will be universal for both".
+//
+// A grid is { hidden: [tiers switched off], degrees: { S: [1, 2], … } }: a tier
+// row switches on and off as it always did, and remembers which degrees it
+// shows while it's off. Counts are { S: { 1: n, 2: n, … }, … }: how many people
+// there are at each tier and degree, so a dot with nobody behind it can't be
+// tapped, and the last people on screen can't be switched off.
+
+export const TIERS = ['S', 'A', 'B', 'C', 'D'];
+export const GRID_DEGREES = [1, 2, 3, 4, 5, 6];
+
+const tierOf = (tier) => (TIERS.includes(tier) ? tier : 'D');   // no tier: with D, as the views draw it
+
+export const makeGrid = (degrees = GRID_DEGREES) => ({
+  hidden: [],
+  degrees: Object.fromEntries(TIERS.map((t) => [t, degrees.slice()])),
+});
+
+/** Network Circle starts with your own connections; you pick the rest. */
+export const NETWORK_GRID = Object.freeze(makeGrid([1]));
+/** Degrees starts with everything it has. */
+export const DEGREES_GRID = Object.freeze(makeGrid());
+
+/** Is someone of this tier, at this degree, on screen? */
+export function shows(grid, tier, degree) {
+  const t = tierOf(tier);
+  return !grid.hidden.includes(t) && grid.degrees[t].includes(degree);
+}
+
+const countAt = (counts, tier, degree) => counts?.[tier]?.[degree] || 0;
+
+/** How many people one tier is showing. */
+export function showingIn(grid, counts, tier) {
+  if (grid.hidden.includes(tier)) return 0;
+  return grid.degrees[tier].reduce((n, d) => n + countAt(counts, tier, d), 0);
+}
+
+/** How many people the whole grid is showing. */
+export const showing = (grid, counts) => TIERS.reduce((n, t) => n + showingIn(grid, counts, t), 0);
+
+// A change that would leave nobody on screen isn't made.
+const keep = (grid, next, counts) => (counts && showing(next, counts) === 0 ? grid : next);
+
+/** One dot: that degree, for that tier. Tapping a dot in a tier that's off switches the tier on with it. */
+export function toggleCell(grid, tier, degree, counts) {
+  const has = grid.degrees[tier].includes(degree);
+  const off = grid.hidden.includes(tier);
+  const degrees = off || !has
+    ? [...new Set([...grid.degrees[tier], degree])].sort((a, b) => a - b)
+    : grid.degrees[tier].filter((d) => d !== degree);
+  return keep(grid, {
+    hidden: off ? grid.hidden.filter((t) => t !== tier) : grid.hidden,
+    degrees: { ...grid.degrees, [tier]: degrees },
+  }, counts);
+}
+
+/** A whole tier, off or back on with the degrees it had. */
+export function toggleTier(grid, tier, counts) {
+  if (!grid.hidden.includes(tier)) return keep(grid, { ...grid, hidden: [...grid.hidden, tier] }, counts);
+  // Back on with nothing to show would look broken: give it what the others show.
+  const own = grid.degrees[tier];
+  const others = [...new Set(TIERS.flatMap((t) => (t === tier ? [] : grid.degrees[t])))].sort((a, b) => a - b);
+  return {
+    hidden: grid.hidden.filter((t) => t !== tier),
+    degrees: own.length ? grid.degrees : { ...grid.degrees, [tier]: others.length ? others : [1] },
+  };
+}
+
+/** A whole degree: off if every tier with people there is showing it, otherwise on for all of them. */
+export function toggleDegree(grid, degree, counts) {
+  const tiers = TIERS.filter((t) => !grid.hidden.includes(t) && (!counts || countAt(counts, t, degree) > 0));
+  if (!tiers.length) return grid;
+  const allOn = tiers.every((t) => grid.degrees[t].includes(degree));
+  const degrees = { ...grid.degrees };
+  for (const t of tiers) {
+    degrees[t] = allOn ? degrees[t].filter((d) => d !== degree) : [...new Set([...degrees[t], degree])].sort((a, b) => a - b);
+  }
+  return keep(grid, { ...grid, degrees }, counts);
+}
+
+/** Every tier back on, each with the degrees it had. */
+export const showAllTiers = (grid) => (grid.hidden.length ? { ...grid, hidden: [] } : grid);
+
+/** People by tier and degree, for the dots: `byDegree` is { 1: rows, 2: rows, … }. */
+export function gridCounts(byDegree = {}) {
+  const counts = Object.fromEntries(TIERS.map((t) => [t, {}]));
+  for (const [degree, rows] of Object.entries(byDegree)) {
+    for (const row of rows || []) {
+      const t = tierOf(row?.tier);
+      counts[t][degree] = (counts[t][degree] || 0) + 1;
+    }
+  }
+  return counts;
+}

package/.next/standalone/lib/title-ranking.js

@@ -0,0 +1,83 @@
+// Settings → Scores → Titles: how much each kind of title counts, your way
+// (Blake, 2026-10-02: "let the user change the rankings of titles as well …
+// incase they value certain people or is using this for outreaching new
+// founders", and people who "find more in that role" for outbound or hiring).
+//
+// Two parts, both in title points (the 0–10 a title is worth before the
+// company weighs it, lib/scoring.js LEVELS):
+//   points  a level's points, yours: Owner / Entrepreneur at 10, say, to put
+//           founders of small companies level with CEOs
+//   roles   words in a title, and what anyone whose title has them counts:
+//           "account executive" at 10 puts every AE you can reach in S
+// Nothing set scores exactly as before. The model applies it (scorePerson);
+// this file is the setting and its presets.
+
+import { LEVELS } from './scoring.js';
+
+/** The ladder shown in Settings, top to bottom (the main kinds of title). */
+export const RANKED_LEVELS = ['csuite', 'owner', 'vp', 'director', 'manager', 'senior', 'ic', 'unknown', 'intern', 'student'];
+export const NO_RANKING = Object.freeze({ points: Object.freeze({}), roles: Object.freeze([]) });
+export const MAX_ROLES = 20;
+const MAX_ROLE_TEXT = 60;
+
+const clampPoints = (v) => {
+  const n = Number(v);
+  if (!Number.isFinite(n) || n < 0 || n > 10) throw new Error('Title points go from 0 to 10.');
+  return Math.round(n * 2) / 2;
+};
+
+export const TITLE_RANKING_SETTING = {
+  default: NO_RANKING,
+  parse(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('A title ranking is { points, roles }.');
+    const points = {};
+    for (const [key, v] of Object.entries(value.points || {})) {
+      if (!Object.hasOwn(LEVELS, key)) throw new Error(`There is no kind of title called '${key}'.`);
+      const p = clampPoints(v);
+      if (p !== LEVELS[key].points) points[key] = p;   // the default needn't be stored
+    }
+    const roles = [];
+    const seen = new Set();
+    for (const r of Array.isArray(value.roles) ? value.roles : []) {
+      const text = String(r?.text ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+      if (text.length < 2) throw new Error('A role needs at least two letters.');
+      if (text.length > MAX_ROLE_TEXT) throw new Error(`Keep a role under ${MAX_ROLE_TEXT} letters.`);
+      if (seen.has(text)) continue;
+      seen.add(text);
+      roles.push({ text, points: clampPoints(r.points) });
+    }
+    if (roles.length > MAX_ROLES) throw new Error(`Up to ${MAX_ROLES} roles.`);
+    return { points, roles };
+  },
+};
+
+/** The same ranking always gives the same text, so the stored scores can say which they were made with. */
+export function rankingFingerprint(r = NO_RANKING) {
+  const points = Object.keys(r.points || {}).sort().map((k) => `${k}=${r.points[k]}`).join(',');
+  const roles = (r.roles || []).map((x) => `${x.text}=${x.points}`).sort().join(',');
+  return points || roles ? `${points}|${roles}` : 'none';
+}
+
+export const isDefaultRanking = (r) => rankingFingerprint(r) === 'none';
+
+/** Starting points for the common reasons to change it. Each replaces the whole ranking; you can adjust from there. */
+export const RANKING_PRESETS = [
+  { key: 'default', label: 'As the app ranks them', ranking: NO_RANKING, note: 'C-suite and founders first, then VPs, directors, managers.' },
+  {
+    key: 'founders', label: 'Founders first',
+    note: 'Owners and entrepreneurs count like CEOs, and anyone who says founder counts as much: for meeting founders, or selling to them.',
+    ranking: { points: { owner: 10 }, roles: [{ text: 'founder', points: 10 }, { text: 'co-founder', points: 10 }] },
+  },
+  {
+    key: 'investors', label: 'Investors',
+    note: 'Anyone who invests for a living rises to the top: for raising money.',
+    ranking: { points: {}, roles: ['investor', 'venture', 'angel', 'general partner', 'managing partner', 'principal at', 'vc'].map((text) => ({ text, points: 10 })) },
+  },
+  {
+    key: 'role', label: 'A role I’m looking for',
+    note: 'For outbound or hiring: add the role below, and everyone in it rises, whatever their level.',
+    ranking: null,   // keeps what you have and opens the role box
+  },
+];
+
+export { titleHas } from './scoring.js';

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "six-degrees",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.4.11",
+      "version": "0.5.0",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",