six-degrees 0.4.10 → 0.5.0

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

@@ -1,360 +1,19 @@
 '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, and the messages
-// themselves only if you turn on Keep my messages (Conversations.js), in a file
-// of their own that switching it off deletes.
+// Social is part of Outlink now (Blake, 2026-10-02): the CRM, your LinkedIn
+// export and the messages sit under Outlink → Messages & follow-ups
+// (app/social/SocialHub.js). Old links land there.
 
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect } 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, buildConversations, conversationSummary,
-} from '../../lib/linkedin-export';
-import { mergeSocial } from '../../lib/galaxy-lab';
-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';
-import Conversations from './Conversations';
-
-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();
-// Messages go to the server in parts of about this many characters: a request
-// here can carry 10 MB, and a character can take up to 3 bytes.
-const PART_CHARS = 2_500_000;
-
-/** An import's messages, in parts that each fit in one request. */
-async function sendMessages(conversations) {
-  const parts = [];
-  let cur = {};
-  let size = 0;
-  for (const c of conversations) {
-    for (const m of c.messages) {
-      const n = JSON.stringify(m).length + 2;
-      if (size + n > PART_CHARS && size > 0) { parts.push(cur); cur = {}; size = 0; }
-      if (!cur[c.id]) { cur[c.id] = { title: c.title || '', messages: [] }; size += c.id.length + (c.title || '').length + 40; }
-      cur[c.id].messages.push(m);
-      size += n;
-    }
-  }
-  parts.push(cur);
-  for (let i = 0; i < parts.length; i++) {
-    const r = await fetch('/api/social/messages', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ part: i, parts: parts.length, threads: parts[i] }) });
-    if (!r.ok) throw new Error((await r.json().catch(() => ({}))).error || 'The messages couldn’t be saved.');
-  }
-}
-
-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 [switching, setSwitching] = useState(false);
-  const [listToken, setListToken] = useState(0);
-  // The last export's messages.csv, in this window only, so turning Keep my
-  // messages on right after an import needn't ask for the folder again.
-  const lastMessages = useRef(null);
-  const keep = social?.keepMessages === true;
-
-  // The Conversations list reads again whenever this does (listToken).
-  const reload = () => fetch('/api/social').then((r) => r.json()).then((d) => setSocial(d.social || null)).catch(() => setSocial(null))
-    .finally(() => setListToken((n) => n + 1));
-  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]);
-  const connected = useMemo(() => new Set((net?.degree1 || []).map(keyFor)), [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() };
-      // The words are read out of messages.csv only when Keep my messages is on.
-      const built = found['messages.csv'] ? buildConversations(found['messages.csv'], { keepText: keep }) : null;
-      lastMessages.current = found['messages.csv'] || null;
-      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,
-        conversations: built ? built.conversations.map(conversationSummary) : [],
-        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.');
-      if (built && keep) await sendMessages(built.conversations);
-      setNote({
-        good: true,
-        text: `Read ${Object.keys(found).length} of LinkedIn’s files: ${stats.people.size.toLocaleString()} people you’ve messaged one to one`
-          + (built ? `, ${built.conversations.length.toLocaleString()} conversations${keep ? ', their messages kept on this computer' : ''}.` : '.'),
-      });
-      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();
-  }
-
-  // Keep my messages. On: from now on the export's and the sync's words are
-  // kept, and if an export was read in this window, its messages are kept now.
-  // Off, once you've said so: the kept messages are deleted.
-  async function setKeep(on) {
-    if (!on && !window.confirm('Delete the messages kept on this computer? The list of conversations stays; the messages themselves are deleted.')) return;
-    setSwitching(true);
-    setNote(null);
-    try {
-      if (!on) await fetch('/api/social/messages', { method: 'DELETE' });
-      const r = await fetch('/api/social', { method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ keepMessages: on }) });
-      if (!r.ok) throw new Error('The switch couldn’t be saved.');
-      if (on && lastMessages.current) {
-        await sendMessages(buildConversations(lastMessages.current, { keepText: true }).conversations);
-        setNote({ good: true, text: 'Your messages are kept on this computer now.' });
-      } else if (on) {
-        setNote({ good: true, text: 'On. Choose your export folder again, or sync your messages, to bring the messages in.' });
-      } else {
-        setNote({ good: true, text: 'Off. The kept messages are deleted.' });
-      }
-    } catch (e) {
-      setNote({ good: false, text: e.message });
-    } finally {
-      setSwitching(false);
-      reload();
-    }
-  }
-
-  async function forget() {
-    await fetch('/api/social', { method: 'DELETE' });
-    lastMessages.current = null;
-    setNote({ good: true, text: 'Forgotten. Nothing from your export or messages is kept here now, the messages themselves included.' });
-    reload();
-  }
-
-  // What each person's messages say, the export and the live sync together, and
-  // "now" for warmth: the newest thing the data knows, so an older export reads as it was.
-  const { merged, asOf } = useMemo(() => mergeSocial(social), [social]);
-
-  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' };
+import { useRouter } from 'next/navigation';
 
+export default function SocialMoved() {
+  const router = useRouter();
+  useEffect(() => { router.replace('/queue?view=messages'); }, [router]);
   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, and what
-          messages say only if you turn on <i>Keep my messages</i> under Conversations.
-        </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, whether it&rsquo;s unread and who wrote last. It uses no search budget and opens no conversation. The
-            newest message&rsquo;s words are kept only if <i>Keep my messages</i> is on.
-          </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>}
-
-        <h2 style={h2}>Conversations</h2>
-        <Conversations byKey={byKey} connected={connected} ready={!!net} keep={keep} onKeep={setKeep} switching={switching || busy} token={listToken} />
-
-        {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 style={{ minHeight: '100vh', background: '#0a0a1a', color: '#aab', display: 'flex', alignItems: 'center', justifyContent: 'center', fontSize: 13 }}>
+      Social is part of <Link href="/queue?view=messages" style={{ color: '#FF6B35', marginLeft: 4 }}>Outlink</Link> now.
     </div>
   );
 }

package/.next/standalone/lib/chain-layout.js

@@ -17,19 +17,19 @@ function capacity(radius, spacing, sweep) {
   return Math.max(1, sweep >= TAU - 1e-9 ? Math.floor(arc / spacing) : Math.floor(arc / spacing) + 1);
 }
 
-/** The rings from `inner` outwards, `spacing` apart, until `n` dots fit. */
-function ringsFor(n, inner, spacing, sweep) {
+/** The rings from `inner` outwards, `gap` apart (at least `spacing`), until `n` dots fit. */
+function ringsFor(n, inner, spacing, sweep, gap = spacing) {
   const radii = [];
   let room = 0;
-  for (let r = inner; room < n; r += spacing) {
+  for (let r = inner; room < n; r += Math.max(spacing, gap)) {
     radii.push(r);
     room += capacity(r, spacing, sweep);
   }
   return radii;
 }
 
-const outerOf = (n, inner, spacing, sweep) => {
-  const radii = ringsFor(n, inner, spacing, sweep);
+const outerOf = (n, inner, spacing, sweep, gap) => {
+  const radii = ringsFor(n, inner, spacing, sweep, gap);
   return radii[radii.length - 1];
 };
 
@@ -46,43 +46,44 @@ const outerOf = (n, inner, spacing, sweep) => {
  * neighbouring rings don't line up in spokes.
  *
  * `start` and `sweep` fill an arc instead of the whole circle, each ring from
- * its middle outwards.
+ * its middle outwards. `ringGap` keeps the rings at least that far apart, for
+ * dots that carry a name under them and need the room.
  *
  * @returns {{ spacing: number, inner: number, rings: { radius: number, count: number }[],
  *   points: { x: number, y: number, angle: number, ring: number }[] }}
  */
 export function ringLayout(n, {
   inner, outer, spacing, minSpacing = spacing / 3, innerMin = inner,
-  start = -Math.PI / 2, sweep = TAU,
+  start = -Math.PI / 2, sweep = TAU, ringGap = 0,
 } = {}) {
   const count = Math.max(0, Math.floor(n) || 0);
   if (!count) return { spacing, inner, rings: [], points: [] };
 
   let s = spacing;
   let r0 = inner;
-  if (outerOf(count, r0, s, sweep) > outer) {
+  if (outerOf(count, r0, s, sweep, ringGap) > outer) {
     // Start further in, as far as innerMin, before closing anything up.
-    if (outerOf(count, innerMin, s, sweep) <= outer) {
+    if (outerOf(count, innerMin, s, sweep, ringGap) <= outer) {
       let lo = innerMin, hi = inner;
       for (let i = 0; i < 24; i++) {
         const mid = (lo + hi) / 2;
-        if (outerOf(count, mid, s, sweep) <= outer) lo = mid; else hi = mid;
+        if (outerOf(count, mid, s, sweep, ringGap) <= outer) lo = mid; else hi = mid;
       }
       r0 = lo;
     } else {
       r0 = innerMin;
       let lo = minSpacing, hi = spacing;
-      if (outerOf(count, r0, lo, sweep) <= outer) {
+      if (outerOf(count, r0, lo, sweep, ringGap) <= outer) {
         for (let i = 0; i < 24; i++) {
           const mid = (lo + hi) / 2;
-          if (outerOf(count, r0, mid, sweep) <= outer) lo = mid; else hi = mid;
+          if (outerOf(count, r0, mid, sweep, ringGap) <= outer) lo = mid; else hi = mid;
         }
       }
       s = lo;
     }
   }
 
-  const radii = ringsFor(count, r0, s, sweep);
+  const radii = ringsFor(count, r0, s, sweep, ringGap);
   const caps = radii.map((r) => capacity(r, s, sweep));
   const room = caps.reduce((a, b) => a + b, 0);
 
@@ -162,8 +163,9 @@ const TIER_BANDS = ['S', 'A', 'B', 'C', 'D'];
  *
  * @returns {{ spacing: number, edge: number, bands: { tier: string, inner: number, outer: number }[],
  *   points: { x: number, y: number, angle: number, slot: number }[] }}
+ * `start` is the angle each ring's first dot sits at (the top, unless told).
  */
-export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing }) {
+export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing, start = -Math.PI / 2 }) {
   const groups = TIER_BANDS.map((tier) => ({ tier, idx: [] }));
   rows.forEach((row, i) => {
     const t = TIER_BANDS.indexOf(row?.tier);
@@ -175,7 +177,7 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
     const bands = [];
     let r = inner;
     for (const g of used) {
-      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s });
+      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s, start });
       g.idx.forEach((rowIndex, j) => {
         const p = l.points[j];
         points[rowIndex] = { x: p.x, y: p.y, angle: p.angle, slot: TAU / l.rings[p.ring].count };
@@ -201,28 +203,96 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
 }
 
 /**
- * The people behind each person in an opened circle: their own circle, drawn
- * as a fan of small dots beyond `from`, centred on that person's angle and no
- * wider than their slot (at most a sixth of the circle), so each fan sits
- * behind its own person. At most `cap` dots a fan and about `total` in all, so
- * a big network stays quick; `more` is how many weren't drawn.
+ * The chains that lead on from an opened circle (Blake, 2026-10-02: "once they
+ * are clicked on and can view the cluster i want any scanned d2,3,4 or whatever
+ * to be show inside with lines out of the d1 leading to the d2s").
  *
- * @param {{ angle: number, slot: number, count: number }[]} anchors
- * @returns {({ points: { x: number, y: number }[], more: number } | null)[]}
+ * `parents[i]` is the index of the link that introduced link i, or -1 when the
+ * person in the middle did. The links one step on sit on a ring at `from`, each
+ * as near its own angle in `angles` as it can get (where that person's dot is
+ * in the circle), or fanned about `toward` without one; each later step sits `hop` further out,
+ * as near the angle of the link it came from as it can get without touching a
+ * neighbour on its own ring (`spacing` apart). So a chain reads outwards from
+ * the middle: the bridge, someone met through them, someone met through *them*.
+ *
+ * @param {number[]} parents
+ * @returns {{ rings: { radius: number, count: number, depth: number }[],
+ *   points: { x: number, y: number, angle: number, radius: number, depth: number, parent: number }[] }}
  */
-export function outerFans(anchors, { from, spacing = 7, cap = 40, total = 1200 } = {}) {
-  const fans = anchors.filter((a) => a?.count > 0).length;
-  const each = Math.max(6, Math.min(cap, Math.floor(total / Math.max(1, fans))));
-  return anchors.map((a) => {
-    if (!(a?.count > 0)) return null;
-    const n = Math.min(a.count, each);
-    // Only as wide as the dots need at `spacing`, never wider than their slot:
-    // more rows once it's full, so a small fan stays a tight cluster.
-    const room = Math.min(a.slot || TAU, TAU / 6);
-    const width = Math.min(room, Math.max((spacing * 3) / from, (n * spacing) / from));
-    const l = ringLayout(n, {
-      inner: from, outer: Infinity, spacing, minSpacing: spacing, start: a.angle - width / 2, sweep: width,
+export function chainTree(parents = [], { from = 0, hop = 60, spacing = 46, toward = 0, angles = [] } = {}) {
+  const n = parents.length;
+  const parent = parents.map((p, i) => (Number.isInteger(p) && p >= 0 && p < n && p !== i ? p : -1));
+
+  // How many steps out each one is. A loop (it shouldn't happen) is cut where
+  // it closes, so everyone still gets a place.
+  const depth = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    const trail = [];
+    let k = i;
+    while (k >= 0 && !depth[k] && !trail.includes(k)) { trail.push(k); k = parent[k]; }
+    if (k >= 0 && !depth[k]) { parent[trail[trail.length - 1]] = -1; k = -1; }
+    let d = k >= 0 ? depth[k] + 1 : 1;
+    for (let j = trail.length - 1; j >= 0; j--) depth[trail[j]] = d++;
+  }
+
+  const points = new Array(n);
+  const rings = [];
+  for (let d = 1; d <= Math.max(0, ...depth); d++) {
+    const here = [];
+    for (let i = 0; i < n; i++) if (depth[i] === d) here.push(i);
+    const radius = from + (d - 1) * hop;
+    const placed = spread(here.map((i) => (parent[i] < 0 ? (Number.isFinite(angles[i]) ? angles[i] : toward) : points[parent[i]].angle)),
+      Math.min(spacing / Math.max(1, radius), TAU / here.length));
+    here.forEach((i, j) => {
+      const angle = placed[j];
+      points[i] = { x: radius * Math.cos(angle), y: radius * Math.sin(angle), angle, radius, depth: d, parent: parent[i] };
     });
-    return { points: l.points.map(({ x, y }) => ({ x, y })), more: a.count - n };
+    rings.push({ radius, count: here.length, depth: d });
+  }
+  return { rings, points };
+}
+
+/**
+ * Angles as near the ones asked for as they can be while staying `sep` apart:
+ * neighbours that would touch move apart by the same amount each way, so two
+ * people met through the same person sit either side of them. Comes back in
+ * the order given.
+ */
+function spread(wanted, sep) {
+  const m = wanted.length;
+  if (m < 2) return wanted.slice();
+  const turn = (a) => ((a % TAU) + TAU) % TAU;
+  const order = wanted.map((a, i) => i).sort((i, j) => turn(wanted[i]) - turn(wanted[j]) || i - j);
+  // Start counting just after the widest empty stretch, so no group straddles the join.
+  let cut = 0;
+  let widest = -1;
+  order.forEach((i, k) => {
+    const next = order[(k + 1) % m];
+    const gap = turn(turn(wanted[next]) - turn(wanted[i])) || (m > 1 && k === m - 1 ? TAU : 0);
+    if (gap > widest) { widest = gap; cut = (k + 1) % m; }
   });
+  const seq = order.slice(cut).concat(order.slice(0, cut));
+  const first = turn(wanted[seq[0]]);
+  const at = seq.map((i) => first + turn(turn(wanted[i]) - first));
+
+  // Least movement that keeps them `sep` apart: take the spacing out, pool any
+  // neighbours left out of order to their average, put the spacing back.
+  const blocks = [];
+  at.forEach((a, k) => {
+    blocks.push({ sum: a - k * sep, count: 1 });
+    while (blocks.length > 1 && blocks[blocks.length - 2].sum / blocks[blocks.length - 2].count > blocks[blocks.length - 1].sum / blocks[blocks.length - 1].count) {
+      const last = blocks.pop();
+      blocks[blocks.length - 1].sum += last.sum;
+      blocks[blocks.length - 1].count += last.count;
+    }
+  });
+  let placed = blocks.flatMap((b) => new Array(b.count).fill(b.sum / b.count)).map((q, k) => q + k * sep);
+  // Round the join too: if the last has come back round onto the first, share the ring evenly.
+  if (placed[m - 1] - placed[0] > TAU - sep) {
+    const mid = (placed[0] + placed[m - 1]) / 2;
+    placed = placed.map((_, k) => mid + (k - (m - 1) / 2) * (TAU / m));
+  }
+  const out = new Array(m);
+  seq.forEach((i, k) => { out[i] = placed[k]; });
+  return out;
 }

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

@@ -14,7 +14,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { readFileSync, lstatSync, statSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
-import { AVATAR_FILE, TRAVELLING_FILES, namesInFolder } from './data-folder.js';
+import { AVATAR_FILE, TRAVELLING_FILES, SOCIAL_FILE, namesInFolder } from './data-folder.js';
 
 /** Bump when the file's layout changes in a way an older import can't read. */
 export const EXPORT_FORMAT = 1;
@@ -72,7 +72,7 @@ export function referencedPhotos(db) {
  * plain files are taken, never a link, and avatars/ is read only if it is a
  * real folder, so nothing outside the data folder can be pulled in through one.
  */
-export function travellingFiles(dir, { includePhotos = true, photos = null } = {}) {
+export function travellingFiles(dir, { includePhotos = true, photos = null, includeSocial = true } = {}) {
   const plain = (p) => {
     try { return lstatSync(p).isFile(); } catch { return false; }
   };
@@ -81,6 +81,12 @@ export function travellingFiles(dir, { includePhotos = true, photos = null } = {
     const abs = path.join(dir, name);
     if (plain(abs)) out.push({ rel: name, abs });
   }
+  if (includeSocial) {
+    for (const name of namesInFolder(dir).sort()) {
+      const abs = path.join(dir, name);
+      if (SOCIAL_FILE.test(name) && plain(abs)) out.push({ rel: name, abs });
+    }
+  }
   if (includePhotos) {
     for (const name of namesInFolder(path.join(dir, 'avatars')).sort()) {
       if (!AVATAR_FILE.test(name) || (photos && !photos.has(name))) continue;
@@ -96,7 +102,7 @@ export function travellingFiles(dir, { includePhotos = true, photos = null } = {
  * `outFile`, which must not exist yet.
  * @returns {{ bytes, people, photos, files, counts }}
  */
-export function buildExport(db, { dir, outFile, includePhotos = true, appVersion, schemaSql, now = new Date() }) {
+export function buildExport(db, { dir, outFile, includePhotos = true, includeSocial = true, appVersion, schemaSql, now = new Date() }) {
   db.exec(`VACUUM INTO ${sqlString(outFile)}`);
 
   const out = new DatabaseSync(outFile);
@@ -127,7 +133,7 @@ export function buildExport(db, { dir, outFile, includePhotos = true, appVersion
     // photo of someone whose circle was deleted since; the copy has no row
     // for them, so their face has no reason to travel.
     const inNetwork = includePhotos ? referencedPhotos(out) : null;
-    for (const f of travellingFiles(dir, { includePhotos, photos: inNetwork })) {
+    for (const f of travellingFiles(dir, { includePhotos, photos: inNetwork, includeSocial })) {
       let bytes;
       try { bytes = readFileSync(f.abs); } catch { continue; } // replaced since the listing
       put.run(f.rel, bytes, sha256(bytes));

package/.next/standalone/lib/data-folder.js

@@ -44,6 +44,15 @@ export const BUDGET_FILES = [
   'linkedin-cooldown.json',
 ];
 
+/**
+ * The Social tab's files, one set per profile: its findings, the messages kept
+ * with "Keep my messages on this computer", and the CRM's stages, tags and
+ * notes (lib/social-store.js). A copy carries them when asked (Blake,
+ * 2026-09-29: everything goes with the network), and an import puts them back
+ * in place of this computer's, which are kept beside the old network.
+ */
+export const SOCIAL_FILE = /^(?:social|social-messages|crm)-[\w-]+\.json$/;
+
 /** Everything of the scanner's that an export carries. */
 export const TRAVELLING_FILES = [...NETWORK_FILES, ...BUDGET_FILES];