six-degrees 0.4.3 → 0.4.5

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

@@ -0,0 +1,296 @@
+// The Galaxy's physics lab (experimental): Obsidian-style sliders for the forces
+// that lay the Galaxy out, and a replay of your network growing by the date you
+// connected. The Filter panel writes here (GalaxyLab.js); the Galaxy reads it
+// (ForceGraph.js) and changes the running layout in place, never rebuilding.
+//
+// Two stores: the sliders, remembered in this browser, and the replay's clock,
+// which isn't. Both follow useSyncExternalStore's rules: a snapshot only changes
+// when something in it does.
+
+import { keyFor } from './separation.js';
+import { warmthOf } from './linkedin-export.js';
+
+const KEY = 'six-degrees-galaxy-lab';
+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
+  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
+  pull: 1,          // how hard each person pulls the people who came through them
+  distance: 1,      // how far out those people sit
+  dotSize: 1,
+  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)
+  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
+});
+
+/** The slider settings a saved layout keeps (not whether the lab is on, nor the names switch). */
+const LAYOUT_KEYS = ['gravity', 'rings', 'push', 'pull', 'distance', 'dotSize', 'lines', 'sizeBy', 'names', 'branch', 'colourBy', 'speed', 'loop'];
+
+/** 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' });
+
+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;
+  } catch { return LAB_DEFAULTS; }
+}
+
+export function labNow() {
+  if (!cache) cache = read();
+  return cache;
+}
+
+export function setLab(patch) {
+  cache = patch === null ? { ...LAB_DEFAULTS, on: labNow().on, labels: labNow().labels } : { ...labNow(), ...patch };
+  try { localStorage.setItem(KEY, JSON.stringify(cache)); } catch {}
+  listeners.forEach((f) => f());
+}
+
+export function watchLab(f) {
+  listeners.add(f);
+  const other = (e) => { if (e.key === KEY) { cache = null; f(); } };
+  window.addEventListener('storage', other);
+  return () => { listeners.delete(f); window.removeEventListener('storage', other); };
+}
+
+/** What the Galaxy should use: the sliders while the lab is on, today's layout otherwise (with the names switch). */
+export const effectiveLab = (lab) => (lab.on ? lab : lab.labels === LAB_DEFAULTS.labels ? LAB_DEFAULTS : { ...LAB_DEFAULTS, labels: lab.labels });
+
+// Saved layouts: your own named slider settings, in this browser.
+let layoutsCache = null;
+const layoutListeners = new Set();
+export function layoutsNow() {
+  if (!layoutsCache) {
+    try { layoutsCache = JSON.parse(localStorage.getItem(LAYOUTS_KEY) || '[]'); } catch { layoutsCache = []; }
+    if (!Array.isArray(layoutsCache)) layoutsCache = [];
+  }
+  return layoutsCache;
+}
+function writeLayouts(list) {
+  layoutsCache = list;
+  try { localStorage.setItem(LAYOUTS_KEY, JSON.stringify(list)); } catch {}
+  layoutListeners.forEach((f) => f());
+}
+export function watchLayouts(f) { layoutListeners.add(f); return () => layoutListeners.delete(f); }
+export function saveLayout(name) {
+  const label = String(name || '').trim().slice(0, 40);
+  if (!label) return;
+  const lab = labNow();
+  const settings = Object.fromEntries(LAYOUT_KEYS.map((k) => [k, lab[k]]));
+  writeLayouts([...layoutsNow().filter((l) => l.name !== label), { name: label, settings }]);
+}
+export function applyLayout(name) {
+  const found = layoutsNow().find((l) => l.name === name);
+  if (found) setLab(Object.fromEntries(LAYOUT_KEYS.filter((k) => k in found.settings).map((k) => [k, found.settings[k]])));
+}
+export function forgetLayout(name) { writeLayouts(layoutsNow().filter((l) => l.name !== name)); }
+
+// The replay's clock. `at` is a time in ms (null: everything shows); `min` and
+// `max` are the first and last dates in the network on screen, set by the Galaxy
+// (both null when it has no dates, as in the sample network).
+// The same store holds the lab's other passing state: what Find is looking
+// for (and a count that asks the Galaxy to fly to the first match), and the
+// Social tab's data once it's loaded.
+const clockListeners = new Set();
+let clock = { at: null, playing: false, min: null, max: null, of: 0, find: '', fly: 0, found: 0, social: undefined };
+let raf = null;
+
+export const clockNow = () => clock;
+
+export function watchClock(f) {
+  clockListeners.add(f);
+  return () => clockListeners.delete(f);
+}
+
+export function setClock(patch) {
+  const next = { ...clock, ...patch };
+  if (Object.keys(patch).every((k) => Object.is(next[k], clock[k]))) return;
+  clock = next;
+  clockListeners.forEach((f) => f());
+}
+
+/** Play from where the slider is (or the start) to the last date, over the lab's replay length. */
+export function play() {
+  if (clock.min == null || clock.max == null || clock.max <= clock.min) return;
+  const span = clock.max - clock.min;
+  const REPLAY_MS = Math.max(1, Number(labNow().speed) || 15) * 1000;
+  const from = clock.at == null || clock.at >= clock.max ? clock.min : clock.at;
+  const started = performance.now() - ((from - clock.min) / span) * REPLAY_MS;
+  setClock({ at: from, playing: true });
+  const step = (now) => {
+    const at = Math.min(clock.max, clock.min + ((now - started) / REPLAY_MS) * span);
+    setClock({ at });
+    if (at >= clock.max) {
+      raf = null;
+      setClock({ playing: false });
+      if (labNow().loop) setTimeout(() => { if (!raf && clock.at === clock.max) { setClock({ at: clock.min }); play(); } }, 1200);
+      return;
+    }
+    raf = requestAnimationFrame(step);
+  };
+  cancelAnimationFrame(raf);
+  raf = requestAnimationFrame(step);
+}
+
+export function pause() {
+  cancelAnimationFrame(raf);
+  raf = null;
+  setClock({ playing: false });
+}
+
+/** Back to everything showing. */
+export function stopReplay() {
+  pause();
+  setClock({ at: null });
+}
+
+/**
+ * When each dot appears in the replay: your connections on the day you
+ * connected, and everyone in a circle with the connection whose circle it is
+ * (they came with them). Undated connections are there from the start.
+ * `parentOf` maps an id to the id it hangs off, as the Galaxy draws it.
+ */
+export function bornTimes(nodes, parentOf) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const memo = new Map();
+  const bornOf = (n, depth = 0) => {
+    if (memo.has(n.id)) return memo.get(n.id);
+    let t = -Infinity;
+    const p = parentOf.get(n.id);
+    if (n.degree === 1 || p == null || depth > 6) {
+      const own = n.connected_date ? Date.parse(n.connected_date) : NaN;
+      t = Number.isNaN(own) ? -Infinity : own;
+    }
+    if (p != null && byId.has(p) && depth <= 6) t = Math.max(t, bornOf(byId.get(p), depth + 1));
+    memo.set(n.id, t);
+    return t;
+  };
+  return nodes.map((n) => bornOf(n));
+}
+
+/** How many hang off each dot, all the way down (not counting itself). */
+export function reachCounts(nodes, parentOf) {
+  const out = new Map(nodes.map((n) => [n.id, 0]));
+  for (const n of nodes) {
+    let p = parentOf.get(n.id);
+    for (let hops = 0; p != null && hops < 7; hops++) {
+      out.set(p, (out.get(p) || 0) + 1);
+      p = parentOf.get(p);
+    }
+  }
+  return out;
+}
+
+/** The Social tab's data, loaded once: messages merged per profile, your jobs and your posts. */
+let socialLoad = null;
+export function loadSocial() {
+  if (!socialLoad) {
+    socialLoad = fetch('/api/social').then((r) => (r.ok ? r.json() : {})).then((d) => {
+      setClock({ social: d.social ? mergeSocial(d.social) : null });
+    }).catch(() => setClock({ social: null }));
+  }
+  return socialLoad;
+}
+
+/**
+ * The export and the live sync together, per profile key, and the "now" warmth
+ * is judged at: the newest thing the data knows, so an older export reads as it was.
+ */
+export function mergeSocial(social) {
+  const merged = new Map();
+  for (const [url, v] of Object.entries(social?.people || {})) merged.set(keyFor({ profile_url: url }), { ...v });
+  for (const [url, v] of Object.entries(social?.live || {})) {
+    const k = keyFor({ profile_url: url });
+    const cur = merged.get(k) || { total: 0, recent: 0 };
+    if (v.last && (!cur.last || v.last > cur.last)) cur.last = v.last;
+    cur.unread = v.unread;
+    cur.total = Math.max(cur.total || 0, 1);
+    merged.set(k, cur);
+  }
+  let asOf = Math.max(social?.asOf || 0, social?.liveAt ? Date.parse(social.liveAt) || 0 : 0);
+  for (const v of merged.values()) if ((v.last || 0) > asOf) asOf = v.last;
+  return { merged, asOf, chapters: social?.chapters || [], posts: social?.posts?.posts || [] };
+}
+
+/** Your job starts and posts, oldest first, for the replay's timeline. */
+export function milestones(social) {
+  const out = [];
+  for (const c of social?.chapters || []) if (Number.isFinite(c.from)) out.push({ t: c.from, kind: 'job', label: c.company });
+  for (const p of social?.posts || []) if (Number.isFinite(p.t)) out.push({ t: p.t, kind: 'post', label: 'You posted' });
+  return out.sort((a, b) => a.t - b.t);
+}
+
+/** Where you worked at a moment: the latest job started by then. */
+export function chapterAt(social, t) {
+  let at = null;
+  for (const c of social?.chapters || []) if (Number.isFinite(c.from) && c.from <= t && (!at || c.from > at.from)) at = c;
+  return at && (!Number.isFinite(at.to) || at.to > t) ? at : null;
+}
+
+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';
+const companyKey = (c) => String(c || '').trim().toLowerCase();
+
+/**
+ * How to colour the Galaxy's dots, like Obsidian's groups: by tier (as it
+ * always has), degree, company (the eight most common, the rest grey) or, with
+ * the Social tab's data, how warm you are with each of your connections.
+ * Returns { of(person) -> colour, legend: [[label, colour]] }.
+ */
+export function colourScheme(mode, people, tierColors, social) {
+  if (mode === 'degree') {
+    return {
+      of: (d) => DEGREE_COLOURS[Math.min(d.degree || 1, 3)],
+      legend: [['1st', DEGREE_COLOURS[1]], ['2nd', DEGREE_COLOURS[2]], ['3rd+', DEGREE_COLOURS[3]]],
+    };
+  }
+  if (mode === 'company') {
+    const counts = new Map();
+    for (const p of people) {
+      const k = companyKey(p.company);
+      if (!k) continue;
+      const c = counts.get(k) || { name: String(p.company).trim(), n: 0 };
+      c.n += 1;
+      counts.set(k, c);
+    }
+    const top = [...counts.entries()].filter(([, c]) => c.n > 1).sort((a, b) => b[1].n - a[1].n).slice(0, COMPANY_COLOURS.length);
+    const colour = new Map(top.map(([k], i) => [k, COMPANY_COLOURS[i]]));
+    return {
+      of: (d) => colour.get(companyKey(d.company)) || OTHER,
+      legend: [...top.map(([, c], i) => [c.name, COMPANY_COLOURS[i]]), ['Other', OTHER]],
+    };
+  }
+  if (mode === 'warmth' && social) {
+    return {
+      of: (d) => ((d.degree || 1) === 1 ? WARMTH_COLOURS[warmthOf(social.merged.get(keyFor(d)), social.asOf)] : '#2d3748'),
+      legend: [['Warm', WARMTH_COLOURS.warm], ['Cool', WARMTH_COLOURS.cool], ['Dormant', WARMTH_COLOURS.dormant], ['Never messaged', WARMTH_COLOURS.never]],
+    };
+  }
+  return { of: (d) => tierColors[d.tier] || '#666', legend: Object.entries(tierColors) };
+}
+
+/** Who Find matches: name, company, role or headline containing the text (2 letters or more). */
+export function findMatches(nodes, query) {
+  const q = String(query || '').trim().toLowerCase();
+  if (q.length < 2) return null;
+  const hit = new Set();
+  for (const n of nodes) {
+    if ([n.name, n.company, n.role, n.headline].some((v) => v && String(v).toLowerCase().includes(q))) hit.add(n.id);
+  }
+  return hit;
+}

package/.next/standalone/lib/insights.js

@@ -0,0 +1,54 @@
+// Insights on a connection's card (Graph Study §10, items 16 and 19): six plain
+// numbers from what the app already keeps, no new scanning. For one of your
+// connections; null for a 2nd-degree person.
+//
+//   circle    how many people are in their scanned circle
+//   only      how many of them none of your other connections reach (lib/brokerage.js)
+//   twin      whose circle overlaps theirs most, when it's real (15%+, 3+ people)
+//   mix       their circle by tier
+//   bars      how much of their circle is scanned, 0–5 (lib/reach.js scanBars)
+//   rank      where they stand among your connections by who only they reach
+//   companies where the most people in their circle work, the top two
+//
+// Plain functions, no React; tests/insights.test.mjs.
+
+import { keyFor } from './separation.js';
+import { scanBars } from './reach.js';
+
+const TIERS = ['S', 'A', 'B', 'C', 'D'];
+
+export function profileInsights(person, { degree2 = [], exclusive, overlap, reach } = {}) {
+  if (!person || person.degree === 2) return null;
+  const seen = new Set();
+  const mix = { S: 0, A: 0, B: 0, C: 0, D: 0 };
+  const at = new Map();
+  for (const row of degree2) {
+    if (row?.source_connection_id !== person.id) continue;
+    const key = keyFor(row);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    mix[TIERS.includes(row.tier) ? row.tier : 'D'] += 1;
+    const company = String(row.company || '').trim();
+    if (company) at.set(company, (at.get(company) || 0) + 1);
+  }
+  const companies = [...at.entries()].filter(([, n]) => n >= 2)
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 2).map(([name, count]) => ({ name, count }));
+  const circle = seen.size;
+  const ex = exclusive?.get(person.id) || { reach: 0, only: 0, total: 0 };
+  const ov = overlap?.get(person.id);
+  const twin = ov && ov.share >= 0.15 && ov.shared >= 3 ? { id: ov.with, share: ov.share, shared: ov.shared } : null;
+  const ranked = [...(exclusive?.entries() || [])]
+    .sort((a, b) => b[1].reach - a[1].reach || String(a[0]).localeCompare(String(b[0])));
+  const place = ranked.findIndex(([id]) => id === person.id);
+  return {
+    circle,
+    only: ex.only,
+    onlyShare: circle ? ex.only / circle : 0,
+    twin,
+    mix,
+    bars: reach ? scanBars(person, reach) : null,
+    rank: place >= 0 ? place + 1 : null,
+    of: ranked.length,
+    companies,
+  };
+}

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

@@ -0,0 +1,156 @@
+// The Social tab (experimental): what your own LinkedIn data export says about
+// your relationships. The export is the folder LinkedIn emails you from
+// Settings → Data privacy → Get a copy of your data; nothing here talks to
+// LinkedIn. It runs in the browser on the files you pick, and what it keeps is
+// numbers and dates only:
+//
+//   people     per profile: when you last messaged, who wrote last, how many
+//              messages (1:1 conversations only). Never a message's text.
+//   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
+//
+// Plain functions, no React; tests/linkedin-export.test.mjs.
+
+import { parseCsv } from './csv.js';
+import { keyFor } from './separation.js';
+
+const DAY = 86400000;
+
+/** The rows of a CSV as objects, from the first line that has `mustHave` among its columns (exports put notes above the header). */
+export function readTable(text, mustHave) {
+  const rows = parseCsv(String(text || ''));
+  const at = rows.findIndex((r) => r.some((c) => c.trim().toLowerCase() === mustHave.toLowerCase()));
+  if (at < 0) return [];
+  const head = rows[at].map((c) => c.trim().toLowerCase());
+  return rows.slice(at + 1)
+    .filter((r) => r.some((c) => c.trim()))
+    .map((r) => Object.fromEntries(head.map((h, i) => [h, (r[i] ?? '').trim()])));
+}
+
+/** A date in any of the export's formats, as ms; null when it can't be read. */
+export function exportDate(s) {
+  const v = String(s || '').trim();
+  if (!v) return null;
+  let m = v.match(/^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::(\d{2}))?(?:\s*UTC)?$/);
+  if (m) return Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +(m[6] || 0));
+  m = v.match(/^(\d{1,2})\/(\d{1,2})\/(\d{2,4}),?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?$/i);
+  if (m) {
+    const y = +m[3] < 100 ? 2000 + +m[3] : +m[3];
+    let h = +m[4] % 12;
+    if ((m[6] || '').toUpperCase() === 'PM') h += 12;
+    return Date.UTC(y, +m[1] - 1, +m[2], h, +m[5]);
+  }
+  m = v.match(/^([A-Za-z]{3,9})\s+(\d{4})$/);                    // "Jan 2020"
+  if (m) { const t = Date.parse(`1 ${m[1]} ${m[2]} UTC`); return Number.isNaN(t) ? null : t; }
+  const t = Date.parse(/\d{4}$/.test(v) ? `${v} UTC` : v);       // "01 May 2024"
+  return Number.isNaN(t) ? null : t;
+}
+
+const urlKey = (u) => keyFor({ profile_url: u });
+
+/**
+ * From messages.csv, per person (by profile): { last, lastFromThem, total, recent }.
+ * `self` is you: the sender in the most conversations. Only 1:1 conversations
+ * count; group threads say little about one relationship. No text is read.
+ */
+export function messageStats(rows = []) {
+  const convos = new Map();
+  const senders = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    const to = String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).map(urlKey);
+    const t = exportDate(r.date);
+    if (t == null) continue;
+    if (!convos.has(id)) convos.set(id, { people: new Set(), msgs: [] });
+    const c = convos.get(id);
+    c.people.add(from);
+    to.forEach((p) => c.people.add(p));
+    c.msgs.push({ from, t });
+    if (!senders.has(from)) senders.set(from, new Set());
+    senders.get(from).add(id);
+  }
+  let self = null;
+  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
+  let asOf = 0;
+  const people = new Map();
+  for (const c of convos.values()) {
+    const others = [...c.people].filter((p) => p !== self);
+    if (others.length !== 1 || !c.people.has(self)) continue;
+    const other = others[0];
+    const s = people.get(other) || { last: 0, lastFromThem: false, total: 0, times: [] };
+    for (const m of c.msgs) {
+      s.total += 1;
+      s.times.push(m.t);
+      if (m.t >= s.last) { s.last = m.t; s.lastFromThem = m.from !== self; }
+      if (m.t > asOf) asOf = m.t;
+    }
+    people.set(other, s);
+  }
+  for (const s of people.values()) {
+    s.recent = s.times.filter((t) => t > asOf - 90 * DAY).length;
+    delete s.times;
+  }
+  return { self, asOf: asOf || null, people };
+}
+
+/** Warm (in the last 30 days, or 3+ in 90), cool (within a year), dormant (longer ago), or never. */
+export function warmthOf(stat, asOf) {
+  if (!stat || !stat.total) return 'never';
+  const age = asOf - stat.last;
+  if (age <= 30 * DAY || stat.recent >= 3) return 'warm';
+  return age <= 365 * DAY ? 'cool' : 'dormant';
+}
+
+/** People who wrote last, 3 to 30 days before the export: replies you might owe. */
+export function repliesWaiting(stats) {
+  const out = [];
+  for (const [url, s] of stats.people) {
+    const age = stats.asOf - s.last;
+    if (s.lastFromThem && age >= 3 * DAY && age <= 30 * DAY) out.push({ url, days: Math.round(age / DAY), total: s.total });
+  }
+  return out.sort((a, b) => a.days - b.days);
+}
+
+/** Your jobs, oldest first, each with the connections made while you were there. */
+export function careerChapters(positions = [], connections = [], asOf = Date.now()) {
+  const jobs = positions
+    .map((p) => ({ company: p['company name'] || '', title: p.title || '', from: exportDate(p['started on']), to: exportDate(p['finished on']) }))
+    .filter((j) => j.company && j.from != null)
+    .sort((a, b) => a.from - b.from);
+  const made = connections.map((c) => ({ url: urlKey(c.url || c.profile_url), t: exportDate(c['connected on'] || c.connected_on) })).filter((c) => c.t != null);
+  return jobs.map((j) => {
+    const end = j.to ?? asOf;
+    const inside = made.filter((c) => c.t >= j.from && c.t < end);
+    return { ...j, to: j.to, made: inside.length, people: inside.map((c) => c.url) };
+  });
+}
+
+/**
+ * Your posts and the connections made in the 7 days after each, against your
+ * usual week. Something that happened after a post, not proof it came from it.
+ */
+export function postingEffect(shares = [], connections = []) {
+  const posts = shares.map((s) => ({ t: exportDate(s.date), link: s.sharelink || s['share link'] || '' })).filter((p) => p.t != null).sort((a, b) => a.t - b.t);
+  const made = connections.map((c) => exportDate(c['connected on'] || c.connected_on)).filter((t) => t != null).sort((a, b) => a - b);
+  if (!made.length) return { posts: [], usualWeek: 0, afterPosts: 0 };
+  const span = Math.max(DAY * 7, made[made.length - 1] - made[0]);
+  const usualWeek = (made.length / span) * 7 * DAY;
+  const counted = posts.map((p) => ({ ...p, week: made.filter((t) => t >= p.t && t < p.t + 7 * DAY).length }));
+  const afterPosts = counted.length ? counted.reduce((n, p) => n + p.week, 0) / counted.length : 0;
+  return { posts: counted, usualWeek, afterPosts };
+}
+
+/** Requests to and from you, when the export has them. */
+export function invitationSplit(rows = []) {
+  let incoming = 0;
+  let outgoing = 0;
+  for (const r of rows) {
+    const d = String(r.direction || '').toUpperCase();
+    if (d === 'INCOMING') incoming += 1;
+    else if (d === 'OUTGOING') outgoing += 1;
+  }
+  return { incoming, outgoing, total: incoming + outgoing };
+}

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

@@ -0,0 +1,42 @@
+// Network health for the Scores tab (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.
+//
+//   circles     how many of your connections have a scanned circle
+//   early       fewer than 5: say the numbers are an early estimate
+//   twoWays     of everyone you reach through a circle, the share reached two or
+//               more ways (lib/brokerage.js redundancy)
+//   effective   Burt's effective size of your own network, N − 2t/N, with t the ties
+//               between your connections that scans have kept (lib/ties.js), and
+//               efficiency ES/N. Honest only as far as those ties go.
+//   top         your five connections by who only they reach
+//
+// Plain functions, no React; tests/network-health.test.mjs.
+
+import { exclusiveReach, redundancy } from './brokerage.js';
+
+export function networkHealth({ degree1 = [], degree2 = [], ties = 0 } = {}) {
+  const circleOf = new Map();
+  for (const row of degree2) {
+    if (row?.source_connection_id != null) circleOf.set(row.source_connection_id, (circleOf.get(row.source_connection_id) || 0) + 1);
+  }
+  const only = exclusiveReach(degree2, degree1);
+  const n = degree1.length;
+  const t = Math.max(0, Number(ties) || 0);
+  const es = n ? n - (2 * t) / n : 0;
+  const byId = new Map(degree1.map((c) => [c.id, c]));
+  const top = [...only.entries()]
+    .sort((a, b) => b[1].reach - a[1].reach || String(a[0]).localeCompare(String(b[0])))
+    .slice(0, 5)
+    .map(([id, r]) => {
+      const c = byId.get(id) || {};
+      return { id, name: c.name || '', company: c.company || '', tier: c.tier || '', circle: circleOf.get(id) || 0, only: r.only, share: r.total ? r.only / r.total : 0 };
+    });
+  return {
+    circles: circleOf.size,
+    early: circleOf.size < 5,
+    twoWays: redundancy(degree2, degree1),
+    effective: { n, ties: t, size: es, efficiency: n ? es / n : 0 },
+    top,
+  };
+}

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

@@ -9,5 +9,6 @@ export async function loadNetwork(userId) {
     degree1: data.degree1 || [],
     degree2: data.degree2 || [],
     degree3: data.degree3 || [],
+    ties: Number(data.ties) || 0,
   };
 }

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

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

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "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",