six-degrees 0.4.0 → 0.4.1

package/.next/standalone/lib/brokerage.js

@@ -0,0 +1,94 @@
+// Who is irreplaceable among your bridges.
+//
+// A bridge's exclusive reach: for each person in their circle, 1 ÷ how many of
+// your bridges reach that person, added up. Someone only Maya reaches counts 1
+// to her; someone three bridges reach counts a third to each. It's ego
+// betweenness (Everett & Borgatti 2005), which on this network's shape (you →
+// your connections → their circles) gives Brandes' betweenness, in one pass.
+// `only` is how many nobody else reaches: "212 of your people only through
+// Maya". People who are your connections already need no bridge, so they
+// don't count.
+//
+// Plain functions, no React; tests/brokerage.test.mjs.
+
+import { keyFor } from './separation.js';
+
+/** Map of bridge id → { reach, only, total }, from the rows the views already have. */
+export function exclusiveReach(degree2 = [], connections = []) {
+  const yours = new Set((connections || []).map(keyFor));
+  const bridgesOf = new Map();          // person → the bridges who reach them
+  for (const row of degree2 || []) {
+    const bridge = row?.source_connection_id;
+    if (bridge == null) continue;
+    const key = keyFor(row);
+    if (yours.has(key)) continue;
+    let set = bridgesOf.get(key);
+    if (!set) bridgesOf.set(key, (set = new Set()));
+    set.add(bridge);
+  }
+  const out = new Map();
+  for (const set of bridgesOf.values()) {
+    for (const bridge of set) {
+      const r = out.get(bridge) || { reach: 0, only: 0, total: 0 };
+      r.reach += 1 / set.size;
+      r.total += 1;
+      if (set.size === 1) r.only += 1;
+      out.set(bridge, r);
+    }
+  }
+  return out;
+}
+
+/**
+ * Which of your connections open the same doors: for each, the one whose
+ * circle overlaps theirs most, as the share of people either reaches that both
+ * do (Jaccard). "Maya and Tom open the same doors (62%)". Pairs are counted
+ * from the people reached two or more ways, so it stays quick.
+ *
+ * @returns Map of bridge id → { with, share, shared }
+ */
+export function bridgeOverlap(degree2 = [], connections = []) {
+  const reach = exclusiveReach(degree2, connections);
+  const yours = new Set((connections || []).map(keyFor));
+  const bridgesOf = new Map();
+  for (const row of degree2 || []) {
+    const bridge = row?.source_connection_id;
+    if (bridge == null) continue;
+    const key = keyFor(row);
+    if (yours.has(key)) continue;
+    let set = bridgesOf.get(key);
+    if (!set) bridgesOf.set(key, (set = new Set()));
+    set.add(bridge);
+  }
+  const shared = new Map();                // "a|b" → people both reach
+  for (const set of bridgesOf.values()) {
+    if (set.size < 2) continue;
+    const list = [...set];
+    for (let i = 0; i < list.length; i++) {
+      for (let j = i + 1; j < list.length; j++) {
+        const k = list[i] < list[j] ? `${list[i]}|${list[j]}` : `${list[j]}|${list[i]}`;
+        shared.set(k, (shared.get(k) || 0) + 1);
+      }
+    }
+  }
+  const best = new Map();
+  for (const [k, both] of shared) {
+    const [a, b] = k.split('|');
+    const union = reach.get(a).total + reach.get(b).total - both;
+    const share = union ? both / union : 0;
+    for (const [me, other] of [[a, b], [b, a]]) {
+      const cur = best.get(me);
+      if (!cur || share > cur.share) best.set(me, { with: other, share, shared: both });
+    }
+  }
+  return best;
+}
+
+/** Of everyone you reach through a circle, the share you reach two or more ways. */
+export function redundancy(degree2 = [], connections = []) {
+  const reach = exclusiveReach(degree2, connections);
+  let people = 0;
+  let only = 0;
+  for (const r of reach.values()) { people += r.reach; only += r.only; }
+  return people ? 1 - only / people : 0;
+}

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

@@ -137,3 +137,92 @@ export function dotRadius(spacing, tier) {
   const scale = tier === 'S' ? 1 : tier === 'A' ? 0.86 : tier === 'B' ? 0.72 : 0.6;
   return Math.max(1.4, Math.min(7, spacing * 0.42 * scale));
 }
+
+/**
+ * Where a bridge's circle is previewed on hover: a band beyond every ring of
+ * bridges. With many bridges the overview grows extra rings, past where the
+ * preview used to start, and it drew over them. `clear` leaves room for a
+ * hovered bridge's dot (20) and its name under it.
+ */
+export function previewBand(maxR, bridgeRings = [], clear = 34) {
+  const edge = Math.max(0, ...bridgeRings.map((r) => r.radius));
+  const inner = Math.max(maxR * 0.66, edge ? edge + clear : 0);
+  return { inner, outer: Math.max(maxR * 0.8, inner + maxR * 0.14) };
+}
+
+const TIER_BANDS = ['S', 'A', 'B', 'C', 'D'];
+
+/**
+ * An opened circle's people in tier bands round the person: S nearest, then A,
+ * B, C and D, with a gap between bands like Network Circle's tier orbits, so a
+ * big circle reads as layers instead of one clump. Points come back in the
+ * order of `rows`, each with `slot`: the angle its ring gives each dot. The
+ * spacing closes up, down to `minSpacing`, until every band fits inside
+ * `outer`; past that the bands carry on outwards and zooming out shows them.
+ *
+ * @returns {{ spacing: number, edge: number, bands: { tier: string, inner: number, outer: number }[],
+ *   points: { x: number, y: number, angle: number, slot: number }[] }}
+ */
+export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing }) {
+  const groups = TIER_BANDS.map((tier) => ({ tier, idx: [] }));
+  rows.forEach((row, i) => {
+    const t = TIER_BANDS.indexOf(row?.tier);
+    groups[t < 0 ? 4 : t].idx.push(i);              // no tier: with D
+  });
+  const used = groups.filter((g) => g.idx.length);
+  const place = (s) => {
+    const points = new Array(rows.length);
+    const bands = [];
+    let r = inner;
+    for (const g of used) {
+      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s });
+      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 };
+      });
+      const edge = Math.max(r, ...l.rings.map((x) => x.radius));
+      bands.push({ tier: g.tier, inner: r, outer: edge });
+      r = edge + gap * (s / spacing);
+    }
+    return { spacing: s, points, bands, edge: bands.length ? bands[bands.length - 1].outer : inner };
+  };
+  let best = place(spacing);
+  if (best.edge <= outer) return best;
+  let lo = minSpacing;
+  let hi = spacing;
+  best = place(lo);
+  if (best.edge > outer) return best;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const tryMid = place(mid);
+    if (tryMid.edge <= outer) { lo = mid; best = tryMid; } else hi = mid;
+  }
+  return best;
+}
+
+/**
+ * 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.
+ *
+ * @param {{ angle: number, slot: number, count: number }[]} anchors
+ * @returns {({ points: { x: number, y: number }[], more: number } | null)[]}
+ */
+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,
+    });
+    return { points: l.points.map(({ x, y }) => ({ x, y })), more: a.count - n };
+  });
+}

package/.next/standalone/lib/circle.js

@@ -137,17 +137,34 @@ export function circleLayout(rings = [], size = 240) {
   for (let k = 0; k < R; k++) {
     const radius = radiusOf(k);
     const people = rings[k].people;
-    const dotR = clamp((2 * Math.PI * radius) / Math.max(1, people.length) * 0.32, 0.8, size / 60);
+    // More than their slice holds without the dots touching: rows, neighbours
+    // alternating between them, so a big circle never draws as a solid line.
+    // Each keeps its angle behind who they hang off. Rows go out towards the
+    // next ring, or for the outermost, in towards the one before (less than
+    // half way either side, so two rings' rows never meet).
+    const gap = Math.max(2.4, size / 100);
+    const inward = k === R - 1 && R > 1;
+    const band = (inward ? radius - radiusOf(k - 1) : (k + 1 < R ? radiusOf(k + 1) : half * 0.97) - radius) * 0.45;
+    const maxRows = Math.max(1, Math.floor(band / gap) + 1);
+    const rowGap = maxRows > 1 ? (inward ? -1 : 1) * Math.min(gap * 1.2, band / (maxRows - 1)) : 0;
+    const rowsFor = (count, arc) => clamp(Math.ceil((count * gap) / Math.max(1e-9, radius * arc)), 1, maxRows);
+    let rows = 1;
+    let room = Infinity;      // the least room any one dot gets along its row
     const items = [];
     for (const [parentId, group] of byParent[k]) {
       const [a0, a1] = k === 0 ? [START, START + 2 * Math.PI] : span.get(parentId) || [START, START + 2 * Math.PI];
       const total = group.reduce((s, p) => s + weight.get(p), 0);
+      const groupRows = rowsFor(group.length, a1 - a0);
+      rows = Math.max(rows, groupRows);
+      room = Math.min(room, (radius * (a1 - a0) * groupRows) / Math.max(1, group.length));
+      let n = 0;
       let a = a0;
       for (const p of group) {
         const w = ((a1 - a0) * weight.get(p)) / total;
         const angle = a + w / 2;
-        const x = half + radius * Math.cos(angle);
-        const y = half + radius * Math.sin(angle);
+        const r = radius + (n++ % groupRows) * rowGap;
+        const x = half + r * Math.cos(angle);
+        const y = half + r * Math.sin(angle);
         items.push({ ...p, angle, x, y });
         if (p.state === 'connected') span.set(p.row.id, [a, a + w]);
         a += w;
@@ -163,7 +180,9 @@ export function circleLayout(rings = [], size = 240) {
         spokes.push({ x1: it.x, y1: it.y, x2: half + nextR * Math.cos(mid), y2: half + nextR * Math.sin(mid) });
       }
     }
-    out.push({ degree: rings[k].degree, radius, dotR, items });
+    // Sized by the most crowded slice, and never wider than the gap between rows.
+    const dotR = clamp(Math.min(room * 0.32, rows > 1 ? Math.abs(rowGap) * 0.42 : Infinity), 0.8, size / 60);
+    out.push({ degree: rings[k].degree, radius, dotR, rows, items });
   }
   return { size, center: { x: half, y: half }, rings: out, spokes };
 }

package/.next/standalone/lib/degrees.js

@@ -0,0 +1,30 @@
+// Everyone the app knows, by degree, for Network Circle's degree filter.
+//
+// 1st: your connections. 2nd: anyone in a scanned circle, including the people
+// behind someone you added, since you're connected to them now. 3rd: anyone a
+// company scan found who is neither. Each person counts once, at the nearest
+// degree they're found (by profile, lib/separation.js keyFor), whichever
+// circle or scan found them first.
+
+import { keyFor } from './separation.js';
+
+export function peopleByDegree(degree1 = [], degree2 = [], degree3 = []) {
+  const seen = new Set();
+  const take = (rows, degree) => {
+    const out = [];
+    for (const row of rows || []) {
+      const key = keyFor(row);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(row.degree === degree ? row : { ...row, degree });
+    }
+    return out;
+  };
+  return { 1: take(degree1, 1), 2: take(degree2, 2), 3: take(degree3, 3) };
+}
+
+export function tierCountsOf(rows = []) {
+  const counts = {};
+  for (const row of rows) counts[row.tier] = (counts[row.tier] || 0) + 1;
+  return counts;
+}

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

@@ -31,12 +31,12 @@ export function uniqueByProfile(records) {
  */
 export function splitAlreadyConnected(records, firstDegreeUrls) {
   const keep = [];
-  let alreadyConnected = 0;
+  const connected = [];      // their profile URLs: ties between your connections (lib/ties.js)
   for (const r of records) {
-    if (firstDegreeUrls.has(r.profile_url)) alreadyConnected += 1;
+    if (firstDegreeUrls.has(r.profile_url)) connected.push(r.profile_url);
     else keep.push(r);
   }
-  return { keep, alreadyConnected };
+  return { keep, alreadyConnected: connected.length, connected };
 }
 
 const MONTHS = ['january', 'february', 'march', 'april', 'may', 'june', 'july',

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

@@ -5,8 +5,9 @@
 // changes here — the budget, and lifting a cooldown.
 //
 // The budget is searches (a day and a month) and profile views (a day). Profile
-// views are what got an account restricted (TRAPS §16), so their cap has no
-// "no limit", and the scanner also keeps any two a minute apart.
+// views got an account restricted (TRAPS §16), so their cap has no "no limit",
+// and the scanner also keeps any two a minute apart. Searches did too, at 373 in
+// 24 hours: the page asks before a risky search budget (lib/search-risk.js).
 //
 // They belong to the LinkedIn account, not to a profile in the app. TRAPS §35.
 
@@ -58,14 +59,18 @@ export function nextMonthStartPacific(ms = Date.now()) {
   return monthStartPacific(start + 40 * DAY * 1000);
 }
 
+const profileChoice = (n) => PROFILE_CHOICES.filter((c) => c <= n).pop() ?? PROFILE_CHOICES[0];
+
 export function readLimits(dir) {
   const raw = readJson(path.join(dir, 'scan-limits.json')) || {};
   const num = (v, d) => (Number.isInteger(v) && v >= 0 ? v : d);
   return {
     daily: num(raw.daily, DEFAULT_LIMITS.daily),
     monthly: num(raw.monthly, DEFAULT_LIMITS.monthly),
-    // 0 is "no limit" for searches; for profile views the scanner reads it as the default.
-    profiles: num(raw.profiles, 0) || DEFAULT_LIMITS.profiles,
+    // 0 is "no limit" for searches; for profile views the scanner reads it as the
+    // default. A number typed in by hand counts as the largest choice under it,
+    // as the scanner reads it (scrape.py search_limits).
+    profiles: profileChoice(num(raw.profiles, 0) || DEFAULT_LIMITS.profiles),
   };
 }
 

package/.next/standalone/lib/search-risk.js

@@ -0,0 +1,38 @@
+// How much searching is asking for trouble, for the Scan page's budget picker.
+// No Node imports, so the page and the tests share it (lib/linkedin-limits.js
+// reads files and can't load in the browser).
+//
+// The number behind it (TRAPS §16): on 2026-09-28 a real account was restricted
+// after 373 searches in 24 hours, run back to back, with the daily budget raised
+// to 500 and no monthly cap. It opened 7 profiles that day, so searches alone
+// were enough.
+
+export const RISKY_DAILY = 100;       // above this, the picker asks first
+export const RESTRICTED_AT = 373;     // searches in 24 hours when that account was restricted
+export const SAFE_LIMITS = { daily: 50, monthly: 250 };
+
+export const riskyDaily = (n) => Number(n) > RISKY_DAILY;
+export const riskyLimits = ({ daily, monthly } = {}) => riskyDaily(daily) || monthly === 0;
+
+/** What the picker asks before a change that raises the risk; null when there's nothing to ask. */
+export function limitQuestion(from = {}, to = {}) {
+  if (riskyDaily(to.daily) && Number(to.daily) > Number(from.daily)) {
+    return `${to.daily} searches a day is more than LinkedIn has put up with. A real account was `
+      + `restricted after ${RESTRICTED_AT} searches in 24 hours, run back to back. The default is `
+      + `${SAFE_LIMITS.daily} a day.\n\nSet ${to.daily} a day anyway?`;
+  }
+  if (to.monthly === 0 && from.monthly !== 0) {
+    return 'With no monthly cap, only the daily budget stops a scan. A real account was restricted '
+      + `after ${RESTRICTED_AT} searches in 24 hours with no monthly cap set.\n\nTurn the monthly cap off anyway?`;
+  }
+  return null;
+}
+
+/** The note under the picker while the budget is risky; null when it isn't. */
+export function limitNote({ daily, monthly } = {}) {
+  if (!riskyLimits({ daily, monthly })) return null;
+  const parts = [`A real account was restricted after ${RESTRICTED_AT} searches in 24 hours.`];
+  if (riskyDaily(daily)) parts.push(`${daily} a day can use up a free account's month in a day or two.`);
+  if (monthly === 0) parts.push('With no monthly cap, nothing but the daily budget stops a long run.');
+  return parts.join(' ');
+}

package/.next/standalone/lib/ties.js

@@ -0,0 +1,23 @@
+// Ties between your own connections: two people you know who know each other.
+//
+// A circle scan reads everyone in someone's list, your own connections among
+// them, and the app sets those aside rather than saving them as 2nd degree
+// (lib/ingest.js splitAlreadyConnected). Each one is a tie between that
+// person and the one whose circle it is. Kept in connection_ties (db/schema.js),
+// for clustering and communities later; nothing reads them yet.
+
+/** The pairs to keep: the circle's person with each of your connections in it, each pair once, smaller URL first. */
+export function tiePairs(ownerUrl, urls = []) {
+  const seen = new Set();
+  const out = [];
+  if (!ownerUrl) return out;
+  for (const url of urls) {
+    if (!url || url === ownerUrl) continue;
+    const [a, b] = url < ownerUrl ? [url, ownerUrl] : [ownerUrl, url];
+    const key = `${a} ${b}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ a_url: a, b_url: b });
+  }
+  return out;
+}

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

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

package/.next/standalone/package.json

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

package/.next/standalone/scripts/scrape.py

@@ -1504,16 +1504,29 @@ def take_profile_view(now=None):
     with _Locked("linkedin-activity"):
         now = now if now is not None else time.time()
         data = _read_activity()
-        views = [t for t in data["profiles"] if t > now - DAY_SECONDS]
-        if len(views) >= search_limits()["profiles"]:
-            return None
-        # A time ahead of this clock (another computer's, imported) is left
-        # out of the gap: waiting for it could never end.
-        last = max((t for t in views if t <= now), default=None)
-        if last is not None and now - last < PROFILE_GAP:
-            return int(last + PROFILE_GAP - now) + 1
-        _charge(data, "profiles", 1, now)
-        return 0
+        wait = _profile_wait(data, now)
+        if wait == 0:
+            _charge(data, "profiles", 1, now)
+        return wait
+
+
+def profile_wait(now=None):
+    """take_profile_view's answer, writing nothing down: 0, seconds to wait, or None."""
+    with _Locked("linkedin-activity"):
+        now = now if now is not None else time.time()
+        return _profile_wait(_read_activity(), now)
+
+
+def _profile_wait(data, now):
+    views = [t for t in data["profiles"] if t > now - DAY_SECONDS]
+    if len(views) >= search_limits()["profiles"]:
+        return None
+    # A time ahead of this clock (another computer's, imported) is left
+    # out of the gap: waiting for it could never end.
+    last = max((t for t in views if t <= now), default=None)
+    if last is not None and now - last < PROFILE_GAP:
+        return int(last + PROFILE_GAP - now) + 1
+    return 0
 
 
 def search_limits():
@@ -1529,8 +1542,12 @@ def search_limits():
             return default
     return {"daily": num(data.get("daily"), DEFAULT_DAILY_SEARCHES),
             "monthly": num(data.get("monthly"), DEFAULT_MONTHLY_SEARCHES),
-            # 0 is no cap for searches, never for profile views.
-            "profiles": num(data.get("profiles"), DEFAULT_DAILY_PROFILES) or DEFAULT_DAILY_PROFILES}
+            # 0 is no cap for searches, never for profile views. A number typed
+            # in by hand counts as the largest choice under it: never past 100,
+            # and the Scan page shows the same one.
+            "profiles": max((c for c in (10, 25, 50, 100)
+                             if c <= (num(data.get("profiles"), DEFAULT_DAILY_PROFILES) or DEFAULT_DAILY_PROFILES)),
+                            default=10)}
 
 
 def linkedin_usage(now=None):
@@ -3475,6 +3492,17 @@ def rescrape_bridge(bridge_name, headless=False, max_pages=LINKEDIN_MAX_PAGES):
         raise BudgetReached(0, searches_left()[1])
     if profiles_left() <= 0:              # a fresh read opens their profile
         raise BudgetReached(0, "profiles")
+    # The minute between profile views is waited out before anything is
+    # deleted: a Stop during it would otherwise leave the circle deleted and unread.
+    wait = profile_wait()
+    if wait is None:
+        raise BudgetReached(0, "profiles")
+    if wait:
+        print(f"  Waiting {wait}s before re-mapping: at least {PROFILE_GAP}s pass between any "
+              f"two profile views.", flush=True)
+        if not interruptible_sleep(wait, on_tick=lambda left: print(f"    {left}s to go", flush=True), step=10):
+            print("  Stopped before anything was deleted.")
+            return
 
     print(f"Deleting old cluster data...")
     bridge_id = delete_bridge_cluster(bridge_name)