six-degrees 0.4.2 → 0.4.4

package/.next/standalone/app/social/page.js

@@ -0,0 +1,293 @@
+'use client';
+
+// Social (experimental): what your own LinkedIn data says about your
+// relationships (lib/linkedin-export.js). Two sources, both yours:
+//   - the export LinkedIn emails you (Settings → Data privacy → Get a copy of
+//     your data), read here in the browser: full history, no traffic to LinkedIn;
+//   - an experimental live sync (the scanner's --messages): your messages list,
+//     read once in your own Chrome, by hand or once a day.
+// Kept on this computer: dates, who wrote last and counts. Never message text.
+
+import { useEffect, useMemo, useState } from 'react';
+import Link from 'next/link';
+import OnboardingGate from '../components/OnboardingGate';
+import { useUser } from '../components/UserProvider';
+import { loadNetwork } from '../../lib/network';
+import { readTable, messageStats, careerChapters, postingEffect, invitationSplit, warmthOf, repliesWaiting } from '../../lib/linkedin-export';
+import { keyFor } from '../../lib/separation';
+import { runScrape, watchScanner, scannerNow } from '../../lib/scraper-client';
+import { Body, LINE, FONT } from '../components/ui';
+import { IS_DEMO } from '../../lib/demo';
+
+const TIER = { S: '#FFD700', A: '#9B59B6', B: '#3498DB', C: '#95A5A6', D: '#BDC3C7' };
+const WARMTH = { warm: ['Warm', '#ff9f43'], cool: ['Cool', '#3498DB'], dormant: ['Dormant', '#8899aa'], never: ['Never messaged', '#556'] };
+const FILES = { 'connections.csv': 'first name', 'messages.csv': 'conversation id', 'invitations.csv': 'direction', 'positions.csv': 'company name', 'shares.csv': 'date' };
+const day = (t) => (t ? new Date(t).toLocaleDateString(undefined, { day: 'numeric', month: 'short', year: 'numeric' }) : '');
+const slug = (u) => String(u || '').replace(/\/+$/, '').split('/').pop();
+
+export default function SocialPage() {
+  return <OnboardingGate><SocialInner /></OnboardingGate>;
+}
+
+function SocialInner() {
+  const { userId } = useUser();
+  const [social, setSocial] = useState(undefined);
+  const [net, setNet] = useState(null);
+  const [keepEmails, setKeepEmails] = useState(false);
+  const [note, setNote] = useState(null);
+  const [busy, setBusy] = useState(false);
+  const [job, setJob] = useState(() => scannerNow());
+
+  const reload = () => fetch('/api/social').then((r) => r.json()).then((d) => setSocial(d.social || null)).catch(() => setSocial(null));
+  useEffect(() => { reload(); }, []);
+  useEffect(() => watchScanner(() => setJob(scannerNow())), []);
+  useEffect(() => {
+    if (!userId) return undefined;
+    let live = true;
+    loadNetwork(userId).then((n) => { if (live) setNet(n); }).catch(() => {});
+    return () => { live = false; };
+  }, [userId]);
+
+  // Everyone you know, by profile: name and tier for the lists below.
+  const byKey = useMemo(() => {
+    const m = new Map();
+    for (const r of [...(net?.degree1 || []), ...(net?.degree2 || [])]) if (!m.has(keyFor(r))) m.set(keyFor(r), r);
+    return m;
+  }, [net]);
+
+  async function importFolder(list) {
+    setBusy(true);
+    setNote(null);
+    try {
+      const found = {};
+      for (const f of Array.from(list || [])) {
+        const name = f.name.toLowerCase();
+        if (FILES[name] && !found[name]) found[name] = readTable(await f.text(), FILES[name]);
+      }
+      if (!Object.keys(found).length) throw new Error('That folder doesn’t have LinkedIn’s export files in it (Connections.csv, messages.csv and so on).');
+      const conns = found['connections.csv'] || [];
+      const stats = found['messages.csv'] ? messageStats(found['messages.csv']) : { asOf: null, people: new Map() };
+      const people = {};
+      for (const [url, v] of stats.people) people[url] = { last: v.last, lastFromThem: v.lastFromThem, total: v.total, recent: v.recent };
+      if (keepEmails) {
+        for (const c of conns) {
+          const e = c['email address'];
+          if (!e) continue;
+          const k = keyFor({ profile_url: c.url });
+          people[k] = { ...(people[k] || {}), email: e };
+        }
+      }
+      const asOf = stats.asOf || Date.now();
+      const body = {
+        asOf,
+        people,
+        chapters: careerChapters(found['positions.csv'] || [], conns, asOf),
+        posts: found['shares.csv'] ? postingEffect(found['shares.csv'], conns) : null,
+        invites: found['invitations.csv'] ? invitationSplit(found['invitations.csv']) : null,
+        emails: keepEmails,
+      };
+      const r = await fetch('/api/social', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+      if (!r.ok) throw new Error((await r.json().catch(() => ({}))).error || 'It couldn’t be saved.');
+      setNote({ good: true, text: `Read ${Object.keys(found).length} of LinkedIn’s files: ${stats.people.size.toLocaleString()} people you’ve messaged one to one.` });
+      await reload();
+    } catch (e) {
+      setNote({ good: false, text: e.message });
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function syncNow() {
+    setNote(null);
+    try {
+      const end = await runScrape('messages');
+      setNote(end?.exitCode === 0 ? { good: true, text: 'Your messages list is read.' } : { good: false, text: 'The sync stopped before it finished. The Scan page has the log.' });
+      await reload();
+    } catch (e) {
+      setNote({ good: false, text: e.message });
+    }
+  }
+
+  async function setAuto(on) {
+    await fetch('/api/social', { method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ autoSync: on }) });
+    reload();
+  }
+
+  async function forget() {
+    await fetch('/api/social', { method: 'DELETE' });
+    setNote({ good: true, text: 'Forgotten. Nothing from your export or messages is kept here now.' });
+    reload();
+  }
+
+  // What each person's messages say, the export and the live sync together.
+  const merged = useMemo(() => {
+    const out = new Map();
+    for (const [url, v] of Object.entries(social?.people || {})) out.set(keyFor({ profile_url: url }), { ...v });
+    for (const [url, v] of Object.entries(social?.live || {})) {
+      const k = keyFor({ profile_url: url });
+      const cur = out.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);
+      out.set(k, cur);
+    }
+    return out;
+  }, [social]);
+  // "Now" for warmth is the newest thing the data knows, not the clock: an older export reads as it was.
+  const asOf = Math.max(social?.asOf || 0, social?.liveAt ? Date.parse(social.liveAt) : 0, ...[...merged.values()].map((v) => v.last || 0));
+
+  const warmth = useMemo(() => {
+    const counts = { warm: 0, cool: 0, dormant: 0, never: 0 };
+    for (const c of net?.degree1 || []) counts[warmthOf(merged.get(keyFor(c)), asOf)] += 1;
+    return counts;
+  }, [net, merged, asOf]);
+
+  const waiting = useMemo(() => {
+    const stats = { asOf, people: new Map([...merged].filter(([, v]) => v.lastFromThem != null)) };
+    const list = repliesWaiting(stats).map((w) => ({ ...w, person: byKey.get(w.url) }));
+    for (const [k, v] of merged) {
+      if (v.unread > 0 && !list.some((w) => w.url === k)) list.push({ url: k, unread: v.unread, person: byKey.get(k) });
+    }
+    const rank = (w) => ({ S: 0, A: 1 }[w.person?.tier] ?? 2);
+    return list.sort((a, b) => rank(a) - rank(b) || (a.days ?? 0) - (b.days ?? 0)).slice(0, 15);
+  }, [merged, asOf, byKey]);
+
+  if (IS_DEMO) return <div style={{ minHeight: '100vh', background: '#0a0a1a', color: '#aaa', padding: 40, fontFamily: FONT }}>Not part of the demo.</div>;
+  const running = job?.running;
+  const box = { padding: '12px 14px', borderRadius: 8, border: LINE, background: 'rgba(255,255,255,0.03)', marginTop: 10 };
+  const h2 = { fontSize: 16, margin: '24px 0 6px' };
+
+  return (
+    <div style={{ minHeight: '100vh', background: '#0a0a1a', color: '#fff', fontFamily: FONT }}>
+      <header style={{ padding: '16px 24px', borderBottom: LINE, display: 'flex', alignItems: 'center', gap: 16 }}>
+        <Link href="/" style={{ color: '#888', textDecoration: 'none', fontSize: 13, fontWeight: 600, padding: '6px 14px', borderRadius: 6, background: 'rgba(255,255,255,0.06)', border: LINE }}>← Back to Map</Link>
+        <h1 style={{ fontSize: 22, fontWeight: 700, margin: 0, color: '#FFD700' }}>Social <span style={{ fontSize: 12, color: '#8b9a9a', fontWeight: 600 }}>experimental</span></h1>
+      </header>
+      <main style={{ maxWidth: 980, margin: '0 auto', padding: '8px 24px 64px' }}>
+        <Body style={{ marginTop: 16 }}>
+          Who you&rsquo;re warm with, who&rsquo;s waiting on a reply, and how each chapter of your career built your network,
+          from your own LinkedIn data. Only dates, who wrote last and counts are kept on this computer, never what a
+          message says.
+        </Body>
+
+        <h2 style={h2}>Your LinkedIn export</h2>
+        <div style={box}>
+          <Body style={{ margin: 0 }}>
+            On LinkedIn: <i>Settings → Data privacy → Get a copy of your data</i>, pick the larger archive, and unzip the
+            file it emails you. Then choose that folder here. It&rsquo;s read in this window; nothing goes to LinkedIn.
+          </Body>
+          <label style={{ display: 'flex', gap: 8, alignItems: 'flex-start', fontSize: 12.5, color: '#b8c4c4', marginTop: 10 }}>
+            <input type="checkbox" checked={keepEmails} onChange={(e) => setKeepEmails(e.target.checked)} style={{ marginTop: 3 }} />
+            <span>Also keep email addresses from it, on this computer only, for one-click email.</span>
+          </label>
+          <div style={{ marginTop: 10, display: 'flex', gap: 10, alignItems: 'center', flexWrap: 'wrap' }}>
+            <label style={{ padding: '7px 14px', borderRadius: 8, background: 'rgba(52,152,219,0.18)', color: '#cfe6f7', cursor: busy ? 'default' : 'pointer', fontSize: 13 }}>
+              {busy ? 'Reading…' : social ? 'Choose a newer export' : 'Choose the export folder'}
+              <input type="file" webkitdirectory="" directory="" multiple disabled={busy} style={{ display: 'none' }} onChange={(e) => importFolder(e.target.files)} />
+            </label>
+            {social && <span style={{ fontSize: 12, color: '#8b9a9a' }}>From an export up to {day(social.asOf)}{social.liveAt ? ` · messages synced ${day(Date.parse(social.liveAt))}` : ''}</span>}
+            {social && <button onClick={forget} style={{ background: 'none', border: 'none', color: '#ff9b9b', cursor: 'pointer', fontSize: 12 }}>Forget it</button>}
+          </div>
+        </div>
+
+        <h2 style={h2}>Live messages sync <span style={{ fontSize: 11, color: '#FFD700' }}>experimental</span></h2>
+        <div style={box}>
+          <Body style={{ margin: 0 }}>
+            Reads your messages list once, in your own Chrome: who each one-to-one conversation is with, when it was last
+            active and whether it&rsquo;s unread. It uses no search budget and never opens or keeps a message&rsquo;s text.
+          </Body>
+          <div style={{ marginTop: 10, display: 'flex', gap: 12, alignItems: 'center', flexWrap: 'wrap' }}>
+            <button onClick={syncNow} disabled={running} style={{ padding: '7px 14px', borderRadius: 8, border: 'none', background: running ? '#333' : 'rgba(0,255,136,0.15)', color: running ? '#777' : '#00ff88', cursor: running ? 'default' : 'pointer', fontSize: 13 }}>
+              {running ? 'The scanner is busy' : 'Sync messages now'}
+            </button>
+            <label style={{ display: 'flex', gap: 6, alignItems: 'center', fontSize: 12.5, color: '#b8c4c4' }}>
+              <input type="checkbox" checked={social?.autoSync === true} onChange={(e) => setAuto(e.target.checked)} />
+              Once a day while the app is open (daytime only)
+            </label>
+          </div>
+        </div>
+        {note && <div style={{ marginTop: 10, fontSize: 13, color: note.good ? '#00ff88' : '#ff9b9b' }}>{note.text}</div>}
+
+        {social && (
+          <>
+            <h2 style={h2}>Warmth</h2>
+            <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(160px, 1fr))', gap: 10 }}>
+              {Object.entries(WARMTH).map(([k, [label, color]]) => (
+                <div key={k} style={{ ...box, marginTop: 0 }}>
+                  <div style={{ fontSize: 22, fontWeight: 700, color }}>{(warmth[k] || 0).toLocaleString()}</div>
+                  <div style={{ fontSize: 12.5, color: '#b8c4c4' }}>{label}</div>
+                </div>
+              ))}
+            </div>
+            <div style={{ fontSize: 11.5, color: '#778', marginTop: 6 }}>
+              Of your connections. Warm: messaged in the last 30 days, or 3+ messages in 90. Cool: within a year. Dormant: longer ago.
+            </div>
+
+            <h2 style={h2}>Waiting on you</h2>
+            <div style={{ ...box, padding: 0 }}>
+              {waiting.length === 0 && <div style={{ padding: 12, fontSize: 13, color: '#8b9a9a' }}>No one is waiting on a reply.</div>}
+              {waiting.map((w) => (
+                <div key={w.url} style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '8px 14px', borderBottom: '1px solid rgba(255,255,255,0.04)', fontSize: 13 }}>
+                  <span style={{ width: 8, height: 8, borderRadius: '50%', background: TIER[w.person?.tier] || '#556', flexShrink: 0 }} />
+                  <span style={{ flex: 1, minWidth: 0 }}>
+                    <b>{w.person?.name || slug(w.url)}</b>
+                    {w.person?.company ? <span style={{ color: '#8b9a9a' }}> · {w.person.company}</span> : null}
+                  </span>
+                  <span style={{ color: '#b8c4c4' }}>{w.unread ? `${w.unread} unread` : `wrote ${w.days} days before your export`}</span>
+                  <a href={w.url} target="_blank" rel="noreferrer" style={{ color: '#3498DB', textDecoration: 'none' }}>Open ↗</a>
+                </div>
+              ))}
+            </div>
+
+            {social.chapters?.length > 0 && (
+              <>
+                <h2 style={h2}>Career chapters</h2>
+                <div style={{ ...box, padding: 0 }}>
+                  {social.chapters.map((c) => {
+                    const warm = (c.people || []).filter((u) => ['warm', 'cool'].includes(warmthOf(merged.get(keyFor({ profile_url: u })), asOf))).length;
+                    return (
+                      <div key={`${c.company}-${c.from}`} style={{ display: 'flex', gap: 10, padding: '8px 14px', borderBottom: '1px solid rgba(255,255,255,0.04)', fontSize: 13, alignItems: 'baseline' }}>
+                        <span style={{ flex: 1 }}><b>{c.company}</b> <span style={{ color: '#8b9a9a' }}>{c.title} · {new Date(c.from).getFullYear()}–{c.to ? new Date(c.to).getFullYear() : 'now'}</span></span>
+                        <span style={{ color: '#b8c4c4' }}>{c.made.toLocaleString()} connections made</span>
+                        <span style={{ color: '#ff9f43', minWidth: 90, textAlign: 'right' }}>{c.made ? `${Math.round((100 * warm) / c.made)}% still in touch` : ''}</span>
+                      </div>
+                    );
+                  })}
+                </div>
+              </>
+            )}
+
+            {social.posts?.posts?.length > 0 && (
+              <>
+                <h2 style={h2}>Does posting work?</h2>
+                <div style={box}>
+                  <div style={{ fontSize: 13 }}>
+                    In the week after a post you made <b>{social.posts.afterPosts.toFixed(1)}</b> new connections on average; a usual week, <b>{social.posts.usualWeek.toFixed(1)}</b>.
+                  </div>
+                  <div style={{ fontSize: 11.5, color: '#778', marginTop: 4 }}>What came after a post, not proof it came from it.</div>
+                  {[...social.posts.posts].sort((a, b) => b.week - a.week).slice(0, 3).map((p) => (
+                    <div key={p.t} style={{ fontSize: 12.5, color: '#b8c4c4', marginTop: 6 }}>
+                      {day(p.t)}: {p.week} new connections that week {p.link ? <a href={p.link} target="_blank" rel="noreferrer" style={{ color: '#3498DB', textDecoration: 'none' }}>Post ↗</a> : null}
+                    </div>
+                  ))}
+                </div>
+              </>
+            )}
+
+            {social.invites?.total > 0 && (
+              <>
+                <h2 style={h2}>Who reaches out</h2>
+                <div style={box}>
+                  <span style={{ fontSize: 13 }}>
+                    {social.invites.incoming.toLocaleString()} requests came to you and you sent {social.invites.outgoing.toLocaleString()}
+                    {' '}({Math.round((100 * social.invites.incoming) / social.invites.total)}% came to you), as far as your export shows.
+                  </span>
+                </div>
+              </>
+            )}
+          </>
+        )}
+      </main>
+    </div>
+  );
+}

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

@@ -0,0 +1,38 @@
+// The experimental all-day Auto-Bridge (Auto scan), as the header button and
+// the status bar see it. The switch is the Scan page's checkbox, kept in this
+// browser (its useRemembered: JSON under six-degrees-experimental-auto); the page
+// announces a change with the 'six-degrees:experimental' event.
+
+import { beginScrape } from './scraper-client';
+
+const KEY = 'six-degrees-experimental-auto';
+
+export function watchAllDay(change) {
+  window.addEventListener('storage', change);
+  window.addEventListener('six-degrees:experimental', change);
+  return () => {
+    window.removeEventListener('storage', change);
+    window.removeEventListener('six-degrees:experimental', change);
+  };
+}
+
+export function allDayNow() {
+  try { return localStorage.getItem(KEY) === 'true'; } catch { return false; }
+}
+
+const remembered = (key, fallback) => {
+  try { const v = localStorage.getItem(key); return v === null ? fallback : JSON.parse(v); } catch { return fallback; }
+};
+
+/** Start Auto scan with the Scan page's remembered choices (order, pages, finish), 10 people, S and A first. */
+export function startAutoScan() {
+  const order = remembered('six-degrees-bridge-order', 'newest');
+  return beginScrape('auto-bridge', {
+    experimental: true,
+    maxBridges: 10,
+    order,
+    tiers: order === 'score' ? ['S', 'A'] : [],
+    maxPages: remembered('six-degrees-bridge-pages-v2', 100),
+    deeper: remembered('six-degrees-bridge-finish', true),
+  });
+}

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/lib/scraper-client.js

@@ -148,6 +148,7 @@ function take(s) {
     target: running ? s.target ?? null : starting ? now.target : null,
     startedAt: running ? s.startedAt ?? null : null,
     progress: running ? s.progress ?? null : null,
+    budget: running ? s.budget ?? null : null,
     log: running && Array.isArray(s.log) ? s.log : [],
     finished,
   });

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

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

package/.next/standalone/package.json

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