six-degrees 0.4.10 → 0.5.0

package/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/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/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/lib/linkedin-export.js

@@ -12,7 +12,14 @@
 //              (app/api/social/messages).
 //   chapters   your jobs (Positions.csv) and the connections made in each
 //   posts      your posts (Shares.csv) and the connections that came the week after
-//   invites    requests to and from you (Invitations.csv), when the export has them
+//   invites    requests to and from you (Invitations.csv), when the export has
+//              them: counts, and one record per request (who, which way, when).
+//              The note sent with a request only with Keep my messages.
+//   names      the names the export gives people, so someone who isn't a
+//              connection (and so isn't in the app's network) can be listed
+//
+// Every conversation is kept, whoever it's with and whatever folder it's in;
+// Sponsored Messages and InMails are marked, not dropped (buildConversations).
 //
 // Plain functions, no React; tests/linkedin-export.test.mjs.
 
@@ -111,29 +118,86 @@ export function messageStats(rows = []) {
   return { self, asOf: asOf || null, people };
 }
 
+/** A person with no profile link in the export, by their name: `name:ada quill`. */
+export const nameOnlyKey = (name) => {
+  const n = nameKey(name);
+  return n ? `name:${n}` : null;
+};
+
+const SPONSORED = /sponsored/i;
+const INMAIL = /in\s?mail/i;
+// A company's or a showcase page's link as the sender: an advert, not a person.
+const PAGE_SENDER = /linkedin\.com\/(company|showcase|school)\//i;
+const yes = (v) => /^(yes|true|1)$/i.test(String(v || '').trim());
+
+/**
+ * What LinkedIn's rows say a conversation is: 'sponsored' (a Sponsored
+ * Message, an advert), 'inmail' (an InMail), or null for an ordinary one. The
+ * export marks neither in a column of its own, so it's read from the folder,
+ * the conversation's title, and a sender that's a company page, not a person.
+ */
+function kindOfRow(r) {
+  const folder = String(r.folder || '');
+  const title = String(r['conversation title'] || '');
+  if (SPONSORED.test(folder) || SPONSORED.test(title) || PAGE_SENDER.test(String(r['sender profile url'] || ''))) return 'sponsored';
+  if (INMAIL.test(folder) || INMAIL.test(title)) return 'inmail';
+  return null;
+}
+
 /**
- * Every conversation in messages.csv you're part of, one record each:
- * { id, title, people, group, messages: [{ t, fromMe, text }] }, messages oldest
- * first. `people` is everyone but you, by profile key; more than one makes it a
- * group. You are found the way messageStats finds you. The words (the subject,
+ * Every conversation in messages.csv, one record each:
+ * { id, title, people, group, kind, folder, messages: [{ t, fromMe, text }] },
+ * messages oldest first. `people` is everyone but you, by profile key, or by
+ * name (nameOnlyKey) when the export has no link for them; more than one makes
+ * it a group, none (only you wrote, and to whom isn't said) leaves it empty.
+ * Nothing is left out for being in a folder: INBOX, SENT, ARCHIVE, SPAM and
+ * anything else LinkedIn adds all count; `folder` is the newest message's, in
+ * lower case. `kind` is 'sponsored', 'inmail' or null (kindOfRow). Drafts
+ * weren't sent, so they aren't messages; they're counted in `drafts`, and rows
+ * with no conversation or no readable date in `skipped`.
+ *
+ * You are found the way messageStats finds you, and by your name on rows with
+ * no link. `names` is everyone's name as the export spells it, by key, so a
+ * person who isn't a connection can still be shown. The words (the subject,
  * when there is one, then the message) are read only with keepText: without it
  * a message is a date and who sent it, and the title (a group's name) is left
  * out too.
  */
 export function buildConversations(rows = [], { keepText = false } = {}) {
   const self = selfOf(rows);
+  // Your name as the export spells it, for rows that have no link for you.
+  const selfNames = new Map();
+  for (const r of rows) {
+    if (self && urlKey(r['sender profile url']) === self && r.from) selfNames.set(r.from, (selfNames.get(r.from) || 0) + 1);
+  }
+  const selfName = nameKey([...selfNames].sort((a, b) => b[1] - a[1])[0]?.[0] || '');
+  const isMe = (k) => !!k && (k === self || (!!selfName && k === `name:${selfName}`));
+  const names = {};
   const convos = new Map();
+  let drafts = 0;
+  let skipped = 0;
   for (const r of rows) {
-    const from = urlKey(r['sender profile url']);
     const id = r['conversation id'];
-    if (!id || !from) continue;
     const t = exportDate(r.date);
-    if (t == null) continue;
-    if (!convos.has(id)) convos.set(id, { id, title: '', everyone: new Set(), messages: [] });
+    if (!id || t == null) { skipped += 1; continue; }
+    if (yes(r['is message draft'])) { drafts += 1; continue; }
+    const fromUrl = urlKey(r['sender profile url']);
+    const from = fromUrl || nameOnlyKey(r.from);
+    if (from && r.from && !names[from]) names[from] = String(r.from).trim();
+    const toUrls = String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).map(urlKey);
+    const toNames = String(r.to || '').split(',').map((s) => s.trim()).filter(Boolean);
+    // Names line up with links only when there are as many of each (a name can
+    // hold a comma: "Ben Ode, MBA"); without links, the names are all there is.
+    const to = toUrls.length ? toUrls : toNames.map(nameOnlyKey).filter(Boolean);
+    if (toUrls.length && toUrls.length === toNames.length) toUrls.forEach((u, i) => { if (!names[u]) names[u] = toNames[i]; });
+    if (!toUrls.length) toNames.forEach((n) => { const k = nameOnlyKey(n); if (k && !names[k]) names[k] = n; });
+    if (!convos.has(id)) convos.set(id, { id, title: '', everyone: new Set(), messages: [], kind: null, folder: '', newest: -Infinity });
     const c = convos.get(id);
-    c.everyone.add(from);
-    String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).forEach((u) => c.everyone.add(urlKey(u)));
-    const m = { t, fromMe: from === self };
+    if (from) c.everyone.add(from);
+    to.forEach((p) => c.everyone.add(p));
+    c.kind = c.kind || kindOfRow(r);
+    if (t >= c.newest) { c.newest = t; c.folder = String(r.folder || '').trim().toLowerCase().slice(0, 30); }
+    const m = { t, fromMe: isMe(from) };
     if (keepText) {
       m.text = [r.subject, r.content].map((x) => String(x || '').trim()).filter(Boolean).join('\n\n');
       if (!c.title && r['conversation title']) c.title = String(r['conversation title']).trim();
@@ -142,37 +206,62 @@ export function buildConversations(rows = [], { keepText = false } = {}) {
   }
   const conversations = [];
   for (const c of convos.values()) {
-    if (!c.everyone.has(self)) continue;
-    const people = [...c.everyone].filter((p) => p && p !== self).sort();
-    if (!people.length) continue;
+    const people = [...c.everyone].filter((p) => p && !isMe(p)).sort();
     c.messages.sort((a, b) => a.t - b.t);
-    const out = { id: c.id, people, group: people.length > 1, messages: c.messages };
+    const out = { id: c.id, people, group: people.length > 1, kind: c.kind, folder: c.folder, messages: c.messages };
     if (keepText) out.title = c.title;
     conversations.push(out);
   }
-  return { self, conversations };
+  for (const k of Object.keys(names)) if (isMe(k)) delete names[k];
+  return { self, conversations, names, drafts, skipped };
 }
 
-/** What the Conversations list keeps of one conversation, never any words: { id, people, group, last, lastFromThem, count }. */
+/**
+ * What the Conversations list keeps of one conversation, never any words:
+ * { id, people, group, kind, folder, last, lastFromThem, count, mine }. `mine`
+ * is how many of the messages you wrote; all of them means no one has answered.
+ */
 export function conversationSummary(c) {
   const last = c.messages[c.messages.length - 1];
   return {
     id: c.id,
     people: c.people,
     group: c.group,
+    kind: c.kind || null,
+    folder: c.folder || '',
     last: last ? last.t : null,
     lastFromThem: last ? !last.fromMe : null,
     count: c.messages.length,
+    mine: c.messages.filter((m) => m.fromMe).length,
   };
 }
 
+/** The same people, by their names: a set's signature, or null when a name is missing. */
+function nameSignature(keys, nameOf) {
+  const out = [];
+  for (const k of keys) {
+    const n = nameKey(nameOf(k));
+    if (!n) return null;
+    out.push(n);
+  }
+  return out.sort().join('|');
+}
+
 /**
  * The Conversations list: the export's conversations with what the live sync
  * adds (unread, the thread's link, and a newer last message), plus a
- * conversation for each person the sync found and the export doesn't have yet
- * (id `live:<key>`, count unknown).
+ * conversation for each person or group the sync found and the export doesn't
+ * have yet (id `live:<key>`, count unknown).
+ *
+ *   live    your connections, by their key (matchLive)
+ *   others  people who aren't your connections, by the link messaging gives
+ *           them, with their name: matched to the export's conversation with
+ *           someone of that name when only one has it
+ *   groups  group conversations: { threadUrl, people, names, last, unread },
+ *           matched to the export's group with the same people by name
+ *   names   the export's names, by key
  */
-export function conversationList(list = [], live = {}) {
+export function conversationList(list = [], live = {}, { others = {}, groups = [], names = {} } = {}) {
   const out = (Array.isArray(list) ? list : []).map((c) => ({ ...c, unread: null, threadUrl: null }));
   const oneToOne = new Map();
   for (const c of out) {
@@ -180,20 +269,59 @@ export function conversationList(list = [], live = {}) {
     const had = oneToOne.get(c.people[0]);
     if (!had || (c.last || 0) > (had.last || 0)) oneToOne.set(c.people[0], c);
   }
+  const addLive = (c, v) => {
+    if (v.last && (!c.last || v.last > c.last)) {
+      c.last = v.last;
+      if (typeof v.lastFromThem === 'boolean') c.lastFromThem = v.lastFromThem;
+    }
+    c.unread = Number.isFinite(v.unread) ? v.unread : c.unread;
+    c.threadUrl = v.threadUrl || c.threadUrl;
+  };
+  const fresh = (id, people, group) => ({ id, people, group, kind: null, folder: '', last: null, lastFromThem: null, count: null, mine: null, unread: null, threadUrl: null });
   for (const [key, v] of Object.entries(live || {})) {
     if (!v || typeof v !== 'object') continue;
     let c = oneToOne.get(key);
     if (!c) {
-      c = { id: `live:${key}`, people: [key], group: false, last: null, lastFromThem: null, count: null, unread: null, threadUrl: null };
+      c = fresh(`live:${key}`, [key], false);
       out.push(c);
       oneToOne.set(key, c);
     }
-    if (v.last && (!c.last || v.last > c.last)) {
-      c.last = v.last;
-      if (typeof v.lastFromThem === 'boolean') c.lastFromThem = v.lastFromThem;
+    addLive(c, v);
+  }
+  // Someone who isn't a connection: the export knows them by their /in/name
+  // link, messaging by /in/ACoA…, so only their name can join the two.
+  const byName = new Map();
+  for (const [key, c] of oneToOne) {
+    const n = nameKey(names[key]);
+    if (n) byName.set(n, byName.has(n) ? null : c);
+  }
+  for (const [link, v] of Object.entries(others || {})) {
+    if (!v || typeof v !== 'object') continue;
+    let c = oneToOne.get(link) || byName.get(nameKey(v.name)) || null;
+    if (!c) {
+      c = fresh(`live:${link}`, [link], false);
+      out.push(c);
+      oneToOne.set(link, c);
     }
-    c.unread = Number.isFinite(v.unread) ? v.unread : c.unread;
-    c.threadUrl = v.threadUrl || c.threadUrl;
+    c.liveKey = link;
+    addLive(c, v);
+  }
+  const groupsByNames = new Map();
+  for (const c of out) {
+    if (!c.group) continue;
+    const sig = nameSignature(c.people, (k) => names[k]);
+    if (sig) groupsByNames.set(sig, groupsByNames.has(sig) ? null : c);
+  }
+  for (const g of Array.isArray(groups) ? groups : []) {
+    if (!g || !Array.isArray(g.people) || !g.people.length) continue;
+    const sig = nameSignature(g.people, (k) => g.names?.[k] || names[k]);
+    let c = (sig && groupsByNames.get(sig)) || null;
+    if (!c) {
+      c = fresh(`live:${g.threadUrl || g.people.join(',')}`, g.people, true);
+      out.push(c);
+      if (sig) groupsByNames.set(sig, c);
+    }
+    addLive(c, g);
   }
   return out;
 }
@@ -268,7 +396,32 @@ export function invitationSplit(rows = []) {
   return { incoming, outgoing, total: incoming + outgoing };
 }
 
-const nameKey = (s) => String(s || '').split(',')[0].normalize('NFD').replace(/[̀-ͯ]/g, '')
+/**
+ * Every request in Invitations.csv, one record each, newest first:
+ * { id, dir: 'in' | 'out', key, name, t, note? }. `key` is the other person's
+ * profile link (inviterProfileUrl or inviteeProfileUrl, in newer exports), or
+ * their name (nameOnlyKey) when there's no link. The note sent with a request
+ * is written by a person, like a message, so it's read only with keepText.
+ */
+export function buildInvitations(rows = [], { keepText = false } = {}) {
+  const out = [];
+  for (const r of rows) {
+    const d = String(r.direction || '').toUpperCase();
+    if (d !== 'INCOMING' && d !== 'OUTGOING') continue;
+    const dir = d === 'INCOMING' ? 'in' : 'out';
+    const name = String((dir === 'in' ? r.from : r.to) || '').trim();
+    const url = urlKey(dir === 'in' ? r.inviterprofileurl : r.inviteeprofileurl);
+    const key = (url && /\/in\//.test(url) ? url : null) || nameOnlyKey(name);
+    if (!key) continue;
+    const t = exportDate(r['sent at']);
+    const inv = { id: `${dir}|${key}|${t ?? ''}`, dir, key, name: name.slice(0, 120), t };
+    if (keepText && String(r.message || '').trim()) inv.note = String(r.message).trim().slice(0, 2000);
+    out.push(inv);
+  }
+  return out.sort((a, b) => (b.t || 0) - (a.t || 0));
+}
+
+export const nameKey = (s) => String(s || '').split(',')[0].normalize('NFD').replace(/[̀-ͯ]/g, '')
   .toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
 
 const THREAD_LINK = /^https:\/\/www\.linkedin\.com\/messaging\/[\w\-/%=.]*$/;
@@ -288,16 +441,8 @@ function previewOf(p) {
   return { t, fromMe: p.fromMe === true, text };
 }
 
-/**
- * The live messages sync's people, matched to your connections. LinkedIn's
- * messaging gives a member link (/in/ACoA…) your connections list doesn't have,
- * so a person is matched by their link when it's the same, otherwise by their
- * name when exactly one connection has it. Only the match is kept, never the
- * name. Returns { live: { connectionKey: { last, unread, threadUrl,
- * lastFromThem, preview } }, unmatched }; the caller decides whether the
- * preview's words are kept.
- */
-export function matchLive(incoming = {}, connections = []) {
+/** (link, name) → your connection's key: by link when it's the same, else by a name only one connection has; null otherwise. */
+function connectionMatcher(connections = []) {
   const byUrl = new Map();
   const byName = new Map();
   for (const c of connections) {
@@ -306,21 +451,97 @@ export function matchLive(incoming = {}, connections = []) {
     const n = nameKey(c.name);
     if (n) byName.set(n, byName.has(n) ? null : key);   // null: two people share it
   }
+  return (url, name) => byUrl.get(keyFor({ profile_url: url })) || byName.get(nameKey(name)) || null;
+}
+
+const PROFILE = /^https:\/\/www\.linkedin\.com\/in\/[^/?#\s]+\/?$/;
+const cleanName = (s) => (typeof s === 'string' ? s.replace(/[\u0000-\u001f]/g, ' ').trim().slice(0, 120) : '');
+
+/**
+ * The live messages sync's people, matched to your connections. LinkedIn's
+ * messaging gives a member link (/in/ACoA…) your connections list doesn't have,
+ * so a person is matched by their link when it's the same, otherwise by their
+ * name when exactly one connection has it. For a connection only the match is
+ * kept, never the name: the app has it already. Returns
+ *
+ *   live       { connectionKey: { last, unread, threadUrl, lastFromThem, preview } }
+ *   others     { link: { name, ...the same } }: people who aren't your
+ *              connections. Their name is kept (and nothing else says who they
+ *              are), so the Social tab can list them.
+ *   unmatched  how many are in `others`
+ *
+ * The caller decides whether the previews' words are kept.
+ */
+export function matchLive(incoming = {}, connections = []) {
+  const match = connectionMatcher(connections);
   const live = {};
-  let unmatched = 0;
+  const others = {};
   for (const [url, v] of Object.entries(incoming || {})) {
     if (!v || typeof v !== 'object') continue;
-    const key = byUrl.get(keyFor({ profile_url: url })) || byName.get(nameKey(v.name)) || null;
-    if (!key) { unmatched += 1; continue; }
-    const last = Number(v.last) || null;
-    if (live[key] && (live[key].last || 0) >= (last || 0)) continue;
-    live[key] = {
-      last,
+    const key = match(url, v.name);
+    const entry = {
+      last: Number(v.last) || null,
       unread: Number.isFinite(Number(v.unread)) && v.unread !== null ? Number(v.unread) : null,
       threadUrl: threadLink(v.threadUrl),
       lastFromThem: typeof v.lastFromThem === 'boolean' ? v.lastFromThem : null,
       preview: previewOf(v.preview),
     };
+    if (!key) {
+      const link = keyFor({ profile_url: url });
+      if (PROFILE.test(url) && !others[link]) others[link] = { name: cleanName(v.name), ...entry };
+      continue;
+    }
+    if (live[key] && (live[key].last || 0) >= (entry.last || 0)) continue;
+    live[key] = entry;
+  }
+  return { live, others, unmatched: Object.keys(others).length };
+}
+
+/**
+ * The live sync's group conversations, each member matched to your connections
+ * as matchLive does: { threadUrl, people, names, last, unread }. `people` are
+ * connection keys where matched, else the link messaging gave; `names` keeps
+ * the names of the ones who aren't connections only. No words: a group's
+ * newest message isn't read.
+ */
+export function matchLiveGroups(groups = [], connections = []) {
+  const match = connectionMatcher(connections);
+  const out = [];
+  for (const g of Array.isArray(groups) ? groups.slice(0, 5000) : []) {
+    if (!g || typeof g !== 'object' || !Array.isArray(g.people)) continue;
+    const people = [];
+    const names = {};
+    for (const url of g.people.slice(0, 200)) {
+      if (typeof url !== 'string' || !PROFILE.test(url)) continue;
+      const name = cleanName(g.names?.[url]);
+      const key = match(url, name);
+      if (key) { people.push(key); continue; }
+      const link = keyFor({ profile_url: url });
+      people.push(link);
+      if (name) names[link] = name;
+    }
+    if (people.length < 2) continue;
+    out.push({
+      threadUrl: threadLink(g.threadUrl),
+      people: [...new Set(people)].sort(),
+      names,
+      last: Number(g.last) || null,
+      unread: Number.isFinite(Number(g.unread)) && g.unread !== null ? Number(g.unread) : null,
+      lastFromThem: typeof g.lastFromThem === 'boolean' ? g.lastFromThem : null,
+    });
+  }
+  return out;
+}
+
+/**
+ * A new live sync over what earlier ones found: per person (or group), the
+ * newer of the two. A quick sync reads only the top of the list, so what a
+ * full-history sync found further down stays until something newer replaces it.
+ */
+export function mergeLive(before = {}, after = {}) {
+  const out = { ...(before && typeof before === 'object' ? before : {}) };
+  for (const [k, v] of Object.entries(after || {})) {
+    if (!out[k] || (v.last || 0) >= (out[k].last || 0)) out[k] = v;
   }
-  return { live, unmatched };
+  return out;
 }

package/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/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/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.
 //