six-degrees 0.4.0 → 0.4.2

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

@@ -8,6 +8,7 @@ import useRequests from './components/useRequests';
 import { requestCount } from '../lib/requests-client';
 import { loadNetwork } from '../lib/network';
 import { VIEWS, resolveView } from './components/views';
+import { peopleByDegree, tierCountsOf } from '../lib/degrees';
 import Sidebar from './components/Sidebar';
 import FilterPanel from './components/FilterPanel';
 import OnboardingGate from './components/OnboardingGate';
@@ -68,6 +69,10 @@ function HomeInner() {
   const isMobile = useIsMobile();
   const [degree1, setDegree1] = useState([]);
   const [degree2, setDegree2] = useState([]);
+  // People found only by company scans: 3rd degree in Network Circle's filter.
+  const [degree3, setDegree3] = useState([]);
+  // Which degrees Network Circle draws: your connections alone until you pick more.
+  const [degrees, setDegrees] = useState([1]);
   const [selected, setSelected] = useState(null);
   const focusNodeRef = useRef(null);
   const [filter, setFilter] = useState('all');
@@ -102,7 +107,7 @@ function HomeInner() {
       // imported in this tab (1st-degree only, never persisted), or Supabase.
       const csv = hasCsvNetwork() ? loadCsvNetwork() : null;
       if (csv) { setCsvMode(true); setCsvSource(csv.source || 'csv'); }
-      const { degree1: d1, degree2: d2 } = IS_DEMO
+      const { degree1: d1, degree2: d2, degree3: d3 = [] } = IS_DEMO
         ? await loadDemoNetwork()
         : csv
         ? csv
@@ -112,6 +117,7 @@ function HomeInner() {
 
       setDegree1(d1);
       setDegree2(d2);
+      setDegree3(d3 || []);
       shapeRef.current = networkShape(d1, d2);
       setStats(statsFor(d1, d2));
       setLoading(false);
@@ -131,8 +137,9 @@ function HomeInner() {
   const reload = useCallback(async () => {
     if (IS_DEMO || hasCsvNetwork() || !userId) return;
     try {
-      const [{ degree1: d1, degree2: d2 }, notes] = await Promise.all([loadNetwork(userId), loadScanNotes()]);
+      const [{ degree1: d1, degree2: d2, degree3: d3 = [] }, notes] = await Promise.all([loadNetwork(userId), loadScanNotes()]);
       setScanNotes((prev) => (JSON.stringify(prev) === JSON.stringify(notes) ? prev : notes));
+      setDegree3((prev) => (prev.length === (d3 || []).length ? prev : d3 || []));
       const shape = networkShape(d1, d2);
       if (shape === shapeRef.current) return;
       shapeRef.current = shape;
@@ -156,9 +163,16 @@ function HomeInner() {
   // scene when these change identity: computed inline, every re-render — a click,
   // the sidebar opening, notifications arriving — reset the galaxy's layout. The
   // empty list in network mode was a new [] each time, which was enough on its own.
+  // Network Circle draws the degrees picked in the Filter panel, each person
+  // once, at the nearest degree they're found (lib/degrees.js).
+  const byDegree = useMemo(() => peopleByDegree(degree1, degree2, degree3), [degree1, degree2, degree3]);
+  const networkRows = useMemo(
+    () => (isDegreesMode ? connections : degrees.flatMap((d) => byDegree[d] || [])),
+    [isDegreesMode, connections, degrees, byDegree],
+  );
   const filtered = useMemo(
-    () => (filter === 'all' ? connections : connections.filter(c => c.tier === filter)),
-    [connections, filter],
+    () => (filter === 'all' ? networkRows : networkRows.filter(c => c.tier === filter)),
+    [networkRows, filter],
   );
   // Lookups built once per load. Every click re-renders this component, and the
   // three places below used to scan one list inside another — degree1.find per
@@ -218,7 +232,7 @@ function HomeInner() {
               {isMobile ? 'Circle' : 'Network Circle'}
             </button>
             <button
-              onClick={() => { setMode('degrees'); setSelected(null); setFilter('all'); setVisualMode('separation'); }}
+              onClick={() => { setMode('degrees'); setSelected(null); setFilter('all'); setVisualMode('chain'); }}
               style={{
                 padding: isMobile ? '6px 10px' : '8px 16px', borderRadius: 6, border: 'none', fontSize: isMobile ? 11 : 13, fontWeight: 600, cursor: 'pointer',
                 background: mode === 'degrees' ? 'linear-gradient(135deg, #FFD700, #FF6B35)' : 'rgba(255,255,255,0.12)',
@@ -419,9 +433,12 @@ function HomeInner() {
           mode={mode}
           filter={filter}
           onFilterChange={setFilter}
-          visualMode={visualMode}
+          visualMode={view.key}
           onVisualModeChange={setVisualMode}
-          tierCounts={stats?.tiers || {}}
+          tierCounts={isDegreesMode ? stats?.tiers || {} : tierCountsOf(networkRows)}
+          degrees={degrees}
+          onDegreesChange={setDegrees}
+          degreeCounts={{ 1: byDegree[1].length, 2: byDegree[2].length, 3: byDegree[3].length }}
           bridgeTierCounts={bridgeTierCounts}
         />
         {/* Visualization — switches based on visualMode */}

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

@@ -43,6 +43,8 @@ function PathsInner() {
   useEffect(() => { if (asked === 'scores') router.replace('/scores#companies'); }, [asked, router]);
   // Bumped when company scores change, so the network reloads with new tiers.
   const [reloadKey, setReloadKey] = useState(0);
+  // The sample or a CSV import: they live only in this tab, so a company scan could only fail.
+  const [localOnly, setLocalOnly] = useState(false);
 
   useEffect(() => {
     if (IS_DEMO) return;
@@ -52,6 +54,7 @@ function PathsInner() {
       // in this tab, not the database. Keep the sample's 2nd degree: without it
       // the company map has no links and nobody is "reachable".
       const csv = hasCsvNetwork() ? loadCsvNetwork() : null;
+      setLocalOnly(Boolean(csv));
       let d1 = [], d2 = [], d3 = [];
       if (csv) {
         d1 = csv.degree1;
@@ -118,7 +121,7 @@ function PathsInner() {
   }
 
   async function scanFullCompany() {
-    if (IS_DEMO) return;
+    if (IS_DEMO || localOnly) return;
     if (!selectedCompany) return;
     // Company scans shipped in 0.1.0 without ever having been run against live
     // LinkedIn (docs/brain/PHASES.md). Say so once per browser before the first
@@ -262,6 +265,9 @@ function PathsInner() {
               <span style={{ fontSize: 11, color: '#888' }}>
                 {connectedCount}/{companyPeople.length} connected
               </span>
+              {localOnly ? (
+                <span style={{ marginLeft: 'auto', fontSize: 11, color: '#888' }}>Scanning needs your own network</span>
+              ) : (
               <button onClick={scanFullCompany} disabled={scanning || Boolean(busy)}
                 title={busy ? `${busy}. One scan at a time.` : undefined}
                 style={{
@@ -271,6 +277,7 @@ function PathsInner() {
                 }}>
                 {scanning ? 'Scanning...' : busy ? 'Scanner busy' : '+ Scan Full Company'}
               </button>
+              )}
               <span
                 title="Not yet tested against live LinkedIn. Results may be incomplete."
                 style={{

package/.next/standalone/db/schema.js

@@ -134,6 +134,20 @@ CREATE TABLE IF NOT EXISTS company_scores (
 
 -- Small key/value facts about this install, e.g. which scoring model the
 -- stored scores were computed with.
+-- Two of your own connections who know each other, seen when a circle scan
+-- found one of them in the other's list (they're dropped from that circle,
+-- being yours already). By profile URL, the smaller first, so a pair is one
+-- row whichever circle showed it. No extra LinkedIn traffic: the scan read
+-- them anyway. For clustering and communities later (lib/ties.js).
+CREATE TABLE IF NOT EXISTS connection_ties (
+  id       TEXT,                 -- lib/db.js gives every row one
+  user_id  TEXT NOT NULL,
+  a_url    TEXT NOT NULL,
+  b_url    TEXT NOT NULL,
+  seen_at  TEXT DEFAULT (datetime('now')),
+  PRIMARY KEY (user_id, a_url, b_url)
+);
+
 CREATE TABLE IF NOT EXISTS app_meta (
   key    TEXT PRIMARY KEY,
   value  TEXT

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/dot-rings.js

@@ -0,0 +1,21 @@
+// The thin ring of five bars round a person's dot: how much of their circle is
+// scanned (lib/reach.js scanBars). Blake's pick, design C: thin bars, a
+// catalyst's green outline on the dot itself, a small count badge.
+//
+// Plain path strings, so the Galaxy (d3) and Bridge Chains (React) draw the
+// same shape. Bars run clockwise from the top.
+
+const GAP = 0.32;     // radians between bars
+
+/** Five arcs of radius r around (0, 0): [{ d, i }] */
+export function ringSegments(r) {
+  const span = (2 * Math.PI - 5 * GAP) / 5;
+  return Array.from({ length: 5 }, (_, i) => {
+    const a0 = -Math.PI / 2 + GAP / 2 + i * (span + GAP);
+    const a1 = a0 + span;
+    const p = (a) => `${(r * Math.cos(a)).toFixed(2)} ${(r * Math.sin(a)).toFixed(2)}`;
+    return { i, d: `M${p(a0)} A${r} ${r} 0 0 1 ${p(a1)}` };
+  });
+}
+
+export const RING = { filled: '#1abc9c', empty: 'rgba(255,255,255,0.16)', badge: '#7F77DD' };

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/reach.js

@@ -45,6 +45,10 @@ export function reachIndex(connections = [], degree2 = [], notes = {}) {
   for (const url of notes?.read || []) {
     if (url) read.add(keyFor({ profile_url: url }));
   }
+  const lists = new Map();
+  for (const [url, list] of Object.entries(notes?.lists || {})) {
+    if (url && list) lists.set(keyFor({ profile_url: url }), list);
+  }
   const reachedFrom = new Map();
   for (const row of connections || []) {
     const from = row?.unlocked_from_bridge_id;
@@ -53,7 +57,7 @@ export function reachIndex(connections = [], degree2 = [], notes = {}) {
     if (!list) reachedFrom.set(from, (list = []));
     list.push(row);
   }
-  return { scanned, read, hidden, reachedFrom };
+  return { scanned, read, hidden, reachedFrom, lists };
 }
 
 /**
@@ -111,3 +115,20 @@ export function circleScanCost(pages = 100) {
     minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
   };
 }
+
+/**
+ * How much of someone's circle is scanned, as 0–5 bars for the ring round
+ * their dot; null for no ring (not scanned, or their list is hidden).
+ * A list read to the end is 5. Part-read, it's the pages read against
+ * LinkedIn's own count of the list (about 10 a page), 1 to 4; with no count
+ * (read before the scanner kept one), 2.
+ */
+export function scanBars(person, reach) {
+  const state = circleState(person, reach);
+  const list = person?.profile_url ? reach.lists?.get(keyFor(person)) : null;
+  if (state === 'hidden') return null;
+  if (!list) return state === 'scanned' ? 2 : null;
+  if (!list.more) return 5;
+  if (!list.total) return 2;
+  return Math.max(1, Math.min(4, Math.round((5 * Math.min(1, (list.pages * 10) / list.total)))));
+}

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.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.4.0",
+      "version": "0.4.2",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

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