six-degrees 0.4.11 → 0.5.0

package/.next/standalone/lib/galaxy-lab.js

@@ -7,7 +7,7 @@
 // which isn't. Both follow useSyncExternalStore's rules: a snapshot only changes
 // when something in it does.
 
-import { keyFor } from './separation.js';
+import { keyFor, score } from './separation.js';
 import { warmthOf } from './linkedin-export.js';
 
 const KEY = 'six-degrees-galaxy-lab';
@@ -15,7 +15,7 @@ const LAYOUTS_KEY = 'six-degrees-galaxy-layouts';
 
 /** The layout as it has always been. Every slider is a multiple of today's value, or 0 for off. */
 export const LAB_DEFAULTS = Object.freeze({
-  on: false,        // the lab is on: without it, the Galaxy ignores everything below
+  on: true,         // always: the sliders are the Galaxy's own controls now (it was an experimental switch)
   gravity: 0,       // a pull on every dot towards you, in the middle
   rings: 1,         // how hard each tier (or degree) holds its ring; 0 lets it find its own shape
   push: 15,         // how hard dots push each other apart
@@ -25,11 +25,12 @@ export const LAB_DEFAULTS = Object.freeze({
   lines: 1,
   sizeBy: 'power',  // 'power' (power score) or 'reach' (how many hang off them)
   names: 'key',     // 'key' (you, S tier, catalysts) or 'all' (all your connections)
-  branch: true,     // hovering a dot lights up its branch and dims the rest
-  colourBy: 'tier', // 'tier', 'degree', 'company' or 'warmth' (from the Social tab)
+  branch: false,    // hovering a dot lights up its branch and dims the rest: off to start (Blake, 2026-10-02: it glitched)
+  colourBy: 'tier', // 'tier', 'heat' (power as a thermal map), 'degree', 'company' or 'warmth' (from the Social tab)
   speed: 15,        // a replay's length, in seconds
   loop: false,      // start the replay again when it ends
   labels: true,     // names on the Galaxy at all: the Filter panel's switch, honoured with the lab off too
+  v: 2,             // which defaults a saved setting was made under (2: the branch starts off)
 });
 
 /** The slider settings a saved layout keeps (not whether the lab is on, nor the names switch). */
@@ -38,13 +39,33 @@ const LAYOUT_KEYS = ['gravity', 'rings', 'push', 'pull', 'distance', 'dotSize',
 /** Let the layout find its own shape: no rings, each connection's circle bunched round them. */
 export const CLUSTERS = Object.freeze({ gravity: 0.25, rings: 0, push: 25, pull: 2.5, distance: 0.35, sizeBy: 'reach' });
 
+/**
+ * Orbit, the old view, as a layout of the Galaxy (Blake, 2026-10-02: "add that as a
+ * visual option instead so the person can interact with it"): every tier held hard
+ * on its orbit, and each connection's circle drawn in close behind them. It's still
+ * the Galaxy, so dragging and every slider work on it.
+ */
+export const ORBIT = Object.freeze({ gravity: 0, rings: 3, push: 6, pull: 4, distance: 0.22, sizeBy: 'power' });
+
+/** Which layout the sliders are set to: 'rings', 'clusters', 'orbit', or null for your own. */
+export function layoutOf(lab) {
+  const is = (preset) => Object.entries(preset).every(([k, v]) => lab[k] === v);
+  if (['gravity', 'rings', 'push', 'pull', 'distance'].every((k) => lab[k] === LAB_DEFAULTS[k])) return 'rings';
+  if (is(CLUSTERS)) return 'clusters';
+  if (is(ORBIT)) return 'orbit';
+  return null;
+}
+
 const listeners = new Set();
 let cache = null;
 
 function read() {
   try {
     const raw = JSON.parse(localStorage.getItem(KEY) || 'null');
-    return raw && typeof raw === 'object' ? { ...LAB_DEFAULTS, ...raw } : LAB_DEFAULTS;
+    // `on` was a switch once; a setting saved back then mustn't turn the sliders off.
+    // Saved before v2, the branch light-up was on by default; it starts off now.
+    if (!raw || typeof raw !== 'object') return LAB_DEFAULTS;
+    return { ...LAB_DEFAULTS, ...raw, ...(raw.v === LAB_DEFAULTS.v ? {} : { branch: false }), v: LAB_DEFAULTS.v, on: true };
   } catch { return LAB_DEFAULTS; }
 }
 
@@ -54,7 +75,7 @@ export function labNow() {
 }
 
 export function setLab(patch) {
-  cache = patch === null ? { ...LAB_DEFAULTS, on: labNow().on, labels: labNow().labels } : { ...labNow(), ...patch };
+  cache = patch === null ? { ...LAB_DEFAULTS, labels: labNow().labels } : { ...labNow(), ...patch, on: true };
   try { localStorage.setItem(KEY, JSON.stringify(cache)); } catch {}
   listeners.forEach((f) => f());
 }
@@ -249,6 +270,36 @@ const DEGREE_COLOURS = { 1: '#4FC3F7', 2: '#BA68C8', 3: '#FFB74D' };
 const COMPANY_COLOURS = ['#FF6B6B', '#4ECDC4', '#FFD93D', '#A29BFE', '#00B894', '#FD79A8', '#74B9FF', '#E17055'];
 const WARMTH_COLOURS = { warm: '#FF7043', cool: '#4FC3F7', dormant: '#8D6E63', never: '#546E7A' };
 const OTHER = '#4a5568';
+
+// Heat (Blake, 2026-10-02: "a thermal visual of power based on the dots"): a
+// thermal camera's colours, cold violet through red and orange to white hot.
+const HEAT_STOPS = ['#2b1b6b', '#6a1b9a', '#c2185b', '#f4511e', '#ffb300', '#fff3b0'];
+
+/** The thermal colour at `t` (0 cold … 1 hottest). */
+export function heatColour(t) {
+  const x = Math.max(0, Math.min(1, Number(t) || 0)) * (HEAT_STOPS.length - 1);
+  const i = Math.min(HEAT_STOPS.length - 2, Math.floor(x));
+  const f = x - i;
+  const a = HEAT_STOPS[i], b = HEAT_STOPS[i + 1];
+  const mix = (k) => Math.round(parseInt(a.slice(k, k + 2), 16) * (1 - f) + parseInt(b.slice(k, k + 2), 16) * f);
+  return `#${[1, 3, 5].map((k) => mix(k).toString(16).padStart(2, '0')).join('')}`;
+}
+
+/**
+ * Everyone's heat, 0 to 1: where their power score ranks among the people shown,
+ * so the colours spread across whoever is on screen (a network of mostly B tier
+ * still has its hot spots). Equal scores share a heat.
+ */
+export function heatOf(people = []) {
+  return heatBy(people, score);
+}
+
+/** The same for anything with a value: each one's heat, 0 to 1, from where its value ranks. */
+export function heatBy(items = [], valueOf = () => 0) {
+  const values = [...new Set(items.map(valueOf))].sort((a, b) => a - b);
+  const at = new Map(values.map((v, i) => [v, values.length > 1 ? i / (values.length - 1) : 1]));
+  return (d) => at.get(valueOf(d)) ?? 0;
+}
 const companyKey = (c) => String(c || '').trim().toLowerCase();
 
 /**
@@ -280,6 +331,14 @@ export function colourScheme(mode, people, tierColors, social) {
       legend: [...top.map(([, c], i) => [c.name, COMPANY_COLOURS[i]]), ['Other', OTHER]],
     };
   }
+  if (mode === 'heat') {
+    const heat = heatOf(people);
+    return {
+      of: (d) => heatColour(heat(d)),
+      heat,
+      legend: [['Cold', heatColour(0.1)], ['Warm', heatColour(0.45)], ['Hot', heatColour(0.75)], ['Hottest', heatColour(1)]],
+    };
+  }
   if (mode === 'warmth' && social) {
     return {
       of: (d) => ((d.degree || 1) === 1 ? WARMTH_COLOURS[warmthOf(social.merged.get(keyFor(d)), social.asOf)] : '#2d3748'),

package/.next/standalone/lib/ingest.js

@@ -103,6 +103,8 @@ export function refreshNotifications({ added = [], checked = 0, tierOf = () => n
     out.push({
       user_id, type: 'new_elite_connection', title: `High-value connection: ${r.name}`,
       message: r.headline?.substring(0, 60), icon: '👑',
+      // Who it is, so the notification can open them (lib/notifications.js noteSubject).
+      data: { profileUrl: r.profile_url },
     });
   }
   return out;

package/.next/standalone/lib/island.js

@@ -34,3 +34,43 @@ export function clearActivity(id) {
   activities = activities.filter((x) => x.id !== id);
   listeners.forEach((f) => f());
 }
+
+// The notch's buttons: the views of the page you're on (Bridge Chains,
+// Separation…), or any page's own sub-tabs. A page sets them while it's on
+// screen and clears them when it leaves; the notch draws them under the header's
+// tabs (Blake, 2026-10-02: "the notch… under the ui buttons at top so then we
+// can use that for button selection too").
+//
+//   setNotchTabs({ items: [{ key, label, icon?, title? }], current, onPick })
+//   setNotchTabs(null)
+const tabListeners = new Set();
+let notchTabs = null;
+
+export const notchTabsNow = () => notchTabs;
+export const noNotchTabs = () => null;
+
+export function watchNotchTabs(f) {
+  tabListeners.add(f);
+  return () => tabListeners.delete(f);
+}
+
+// Whether the notch is on screen at all (tabs, a scan, or another job), so a
+// page with a heading at the top can leave room for it only when it's there.
+const shownListeners = new Set();
+let notchShown = false;
+export const notchShownNow = () => notchShown;
+export const noNotch = () => false;
+export function watchNotchShown(f) {
+  shownListeners.add(f);
+  return () => shownListeners.delete(f);
+}
+export function setNotchShown(shown) {
+  if (notchShown === Boolean(shown)) return;
+  notchShown = Boolean(shown);
+  shownListeners.forEach((f) => f());
+}
+
+export function setNotchTabs(tabs) {
+  notchTabs = tabs && Array.isArray(tabs.items) && tabs.items.length > 1 ? tabs : null;
+  tabListeners.forEach((f) => f());
+}

package/.next/standalone/lib/linkedin-limits.js

@@ -14,8 +14,9 @@
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, lstatSync } from 'node:fs';
 import path from 'node:path';
 import { durable } from './durable.js';
+import { PACES, DEFAULT_PACE } from './scan-pace.js';
 
-export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50 };
+export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50, pace: DEFAULT_PACE };
 export const DAILY_CHOICES = [25, 50, 100, 200, 500];
 export const MONTHLY_CHOICES = [100, 250, 500, 1000, 0];   // 0 = no monthly cap (Premium)
 export const PROFILE_CHOICES = [10, 25, 50, 100];           // profile views a day; never unlimited
@@ -71,6 +72,8 @@ export function readLimits(dir) {
     // default. A number typed in by hand counts as the largest choice under it,
     // as the scanner reads it (scrape.py search_limits).
     profiles: profileChoice(num(raw.profiles, 0) || DEFAULT_LIMITS.profiles),
+    // The Scan page's speed (lib/scan-pace.js): how fast a budget is used, never how big it is.
+    pace: PACES[raw.pace] ? raw.pace : DEFAULT_PACE,
   };
 }
 
@@ -79,12 +82,13 @@ export function readLimits(dir) {
  * scanner. A value not given keeps what is saved: every key is written back,
  * or saving one would drop the others to their defaults.
  */
-export function writeLimits(dir, { daily, monthly, profiles } = {}) {
+export function writeLimits(dir, { daily, monthly, profiles, pace } = {}) {
   const cur = readLimits(dir);
   const next = {
     daily: DAILY_CHOICES.includes(daily) ? daily : cur.daily,
     monthly: MONTHLY_CHOICES.includes(monthly) ? monthly : cur.monthly,
     profiles: PROFILE_CHOICES.includes(profiles) ? profiles : cur.profiles,
+    pace: PACES[pace] ? pace : cur.pace,
   };
   writeJsonAtomic(path.join(dir, 'scan-limits.json'), next);
   return next;

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

@@ -0,0 +1,20 @@
+// What "hot" means on Paths' two maps (Blake, 2026-10-02: "change color heat
+// mapping" on Paths, as on Network Circle). A bubble's size already says how
+// many; heat says how strong, so the two never repeat each other.
+
+import { score } from './separation.js';
+
+/** A company's strength: the average power score of its five strongest people shown. */
+export function companyStrength(people = []) {
+  const top = people.map(score).sort((a, b) => b - a).slice(0, 5);
+  return top.length ? top.reduce((s, v) => s + v, 0) / top.length : 0;
+}
+
+/**
+ * How strong a connection's cluster is, person for person: S counts 3, A 2,
+ * everyone else 1, over the cluster's size (1 to 3). Not scanned: -1, the coldest.
+ */
+export function clusterStrength({ size = 0, S = 0, A = 0 } = {}) {
+  if (!size) return -1;
+  return (3 * S + 2 * A + Math.max(0, size - S - A)) / size;
+}

package/.next/standalone/lib/network-health.js

@@ -1,4 +1,4 @@
-// Network health for the Scores tab (item 41, Graph Study §8.5/§10.2), from
+// Network health for Profile → Insights (item 41, Graph Study §8.5/§10.2), from
 // what the app already keeps. No percentiles against other people: there is no
 // data to compare with, so every number is about your own network.
 //

package/.next/standalone/lib/notifications.js

@@ -0,0 +1,121 @@
+// Notifications worth opening (Blake, 2026-10-02: "the notifications should be
+// able to be clicked and … take over the right panel and show a more detailed
+// version … what person added back from who and that they are a value person
+// if the score is S … a new person added back, or we got a person from a
+// high-ranking company, or that our scan is done").
+//
+// Each notification carries `data` naming who it is about, so the right panel
+// can show them: { personId?, profileUrl?, viaId?, personIds?, action? }.
+// Older notifications have no data; noteSubject finds their person by the name
+// in the title. Plain functions, no React; tests/notifications.test.mjs.
+
+const HIGH = new Set(['S', 'A']);
+// A company's own score (company_prestige_score, lib/scoring.js) from here up is "a top company".
+export const TOP_COMPANY = 8;
+
+const score1 = (row) => {
+  const n = parseFloat(row?.power_score);
+  return Number.isFinite(n) ? n.toFixed(1) : null;
+};
+
+/** Someone you met through a bridge who is now one of your connections. */
+export function addedBackNotification({ person, via, userId = null }) {
+  if (!person) return null;
+  const tier = person.tier || null;
+  const valued = HIGH.has(tier);
+  return {
+    user_id: userId || null,
+    type: 'added_back',
+    title: `${person.name || 'Someone'} added you back${via?.name ? `, through ${via.name}` : ''}`,
+    message: [tier ? `${tier}-tier${score1(person) ? ` · ${score1(person)}` : ''}` : null, valued ? 'a valuable person to know' : null, person.headline || null]
+      .filter(Boolean).join(' · ').slice(0, 140),
+    icon: valued ? '👑' : '🤝',
+    data: { personId: person.id, viaId: via?.id ?? null, tier },
+  };
+}
+
+/** People a circle scan found at top companies, as one notification. */
+export function topCompanyNotification({ people = [], via = null, userId = null, threshold = TOP_COMPANY }) {
+  const top = people.filter((p) => Number(p?.company_prestige_score) >= threshold)
+    .sort((a, b) => Number(b.company_prestige_score) - Number(a.company_prestige_score) || (parseFloat(b.power_score) || 0) - (parseFloat(a.power_score) || 0));
+  if (!top.length) return null;
+  const companies = [...new Set(top.map((p) => p.company).filter(Boolean))];
+  return {
+    user_id: userId || null,
+    type: 'top_company',
+    title: `${top.length} ${top.length === 1 ? 'person' : 'people'} at top companies${via?.name ? ` in ${via.name}’s circle` : ''}`,
+    message: companies.slice(0, 3).join(', ') + (companies.length > 3 ? ` +${companies.length - 3} more` : ''),
+    icon: '🏢',
+    data: { personIds: top.slice(0, 25).map((p) => p.id), personId: top[0].id, viaId: via?.id ?? null },
+  };
+}
+
+// What each scanner job is called when it's done. Setting up, signing in and
+// saving settings aren't scans, so they leave nothing.
+const SCAN_DONE = {
+  bridge: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  resume: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  rescrape: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  'auto-bridge': () => 'Mapping the 2nd degree: done for now',
+  'auto-bridge-retry': () => 'Retrying hidden lists: done',
+  'resume-all': () => 'Every paused circle: done for now',
+  full: () => 'Your whole network is scanned',
+  refresh: () => 'Check for new: done',
+  company: (t) => `Company scan done${t?.name ? `: ${t.name}` : ''}`,
+  messages: () => 'Messages synced',
+};
+
+/** The notification a finished scan leaves, or null (not a scan, stopped, or it failed). */
+export function scanDoneNotification({ action, target = null, exitCode, stopped = false, log = [], userId = null }) {
+  const name = SCAN_DONE[action];
+  if (!name || stopped || exitCode !== 0) return null;
+  // The last thing the scanner said that sums it up ("Done. 5/5 bridges mapped.").
+  const last = [...log].reverse().map((l) => String(l).trim()).find((l) => l && l !== 'Finished.' && !/^Speed:/.test(l)) || '';
+  return {
+    user_id: userId || null,
+    type: 'scan_done',
+    title: name(target),
+    message: last.slice(0, 140),
+    icon: '📡',
+    data: { action, personId: target?.id ?? null },
+  };
+}
+
+// Older notifications name their person only in the title.
+const NAME_IN_TITLE = [
+  [/^(.+?) accepted!/, 1],
+  [/^High-value connection: (.+)$/, 1],
+  [/^Catalyst discovered: (.+)$/, 1],
+  [/^(.+?) added you back/, 1],
+];
+
+/**
+ * Who a notification is about, from the rows on screen: { person, via, people }.
+ * `via` is who you met them through: the notification's own, else the person's
+ * recorded introducer. `people` are everyone it names (a top-company list).
+ */
+export function noteSubject(note, connections = [], degree2 = []) {
+  const all = [...(connections || []), ...(degree2 || [])];
+  const byId = new Map(all.map((r) => [r.id, r]));
+  const data = typeof note?.data === 'string' ? safeJson(note.data) : note?.data || {};
+  let person = data.personId != null ? byId.get(data.personId) : null;
+  if (!person && data.profileUrl) person = all.find((r) => r.profile_url === data.profileUrl) || null;
+  if (!person) {
+    for (const [re, i] of NAME_IN_TITLE) {
+      const m = String(note?.title || '').match(re);
+      if (!m) continue;
+      const name = m[i].trim().toLowerCase();
+      person = (connections || []).find((r) => String(r.name || '').toLowerCase() === name)
+        || (degree2 || []).find((r) => String(r.name || '').toLowerCase() === name) || null;
+      if (person) break;
+    }
+  }
+  const viaId = data.viaId ?? person?.unlocked_from_bridge_id ?? (person?.degree === 2 ? person.source_connection_id : null);
+  const via = viaId != null ? byId.get(viaId) || null : null;
+  const people = (data.personIds || []).map((id) => byId.get(id)).filter(Boolean);
+  return { person: person || null, via, people, data };
+}
+
+function safeJson(s) {
+  try { return JSON.parse(s); } catch { return {}; }
+}

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` : ''}`;
+}