six-degrees 0.4.0-beta.1 → 0.4.0

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

@@ -9,7 +9,7 @@
 // Every statement is CREATE ... IF NOT EXISTS, so applying it is both
 // first-run setup and a no-op on every later boot.
 
-export const SCHEMA_SQL = `-- 6 Degrees — local SQLite schema.
+export const SCHEMA_SQL = `-- Six Degrees — local SQLite schema.
 --
 -- Ported from the Postgres schema this project ran on before it went
 -- local-first. Type mapping: uuid -> TEXT (generated in JS), jsonb and

package/.next/standalone/eslint.config.mjs

@@ -23,9 +23,9 @@ const eslintConfig = defineConfig([
       // surface in review.
       "react-hooks/set-state-in-effect": "warn",
 
-      // Avatars are user-supplied remote URLs (or local files captured by the
-      // scraper) with graceful initial-letter fallbacks. next/image would add a
-      // loader and per-request cost for no benefit here.
+      // Avatars are small local files the scanner saved (lib/photos.js), with
+      // graceful initial-letter fallbacks. next/image would add a loader and
+      // per-request cost for no benefit here.
       "@next/next/no-img-element": "off",
     },
   },

package/.next/standalone/install.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Install 6 Degrees on a Mac with one line:
+# Install Six Degrees on a Mac with one line:
 #
 #   curl -fsSL https://raw.githubusercontent.com/blakeb056/six-degrees/main/install.sh | bash
 #
@@ -108,7 +108,7 @@ stop_running_copy() {
 }
 
 main() {
-  printf '\n  6 Degrees — installer\n\n'
+  printf '\n  Six Degrees — installer\n\n'
 
   [ "$(uname -s)" = "Darwin" ] || fail "This installer is for macOS. On Linux, run: npx six-degrees (needs Node 22.13 or later). Windows isn't supported yet."
 
@@ -182,7 +182,7 @@ main() {
 
   if [ -z "${SIX_DEGREES_NO_OPEN:-}" ]; then
     open "$target"
-    printf '\n  ✓ Opening 6 Degrees. Next time, open it from Applications or Spotlight.\n'
+    printf '\n  ✓ Opening Six Degrees. Next time, open it from Applications or Spotlight.\n'
   else
     printf '\n  ✓ Done.\n'
   fi

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

@@ -0,0 +1,139 @@
+// Where Bridge Chains puts a circle's dots.
+//
+// Blake, 2026-09-28: "when i scan someone and have a lot of 2nd degree its
+// almost a solid line and needs to expand more". Every dot sat on one ring, so
+// 200 people round one circle were a band and 800 were a solid line. Here a
+// circle fills rings from the inside out instead, as many as its count needs:
+// a small circle is one ring, a big one spreads into more, and neighbours keep
+// their distance. Plain maths, no React; tests/chain-layout.test.mjs.
+
+const TAU = Math.PI * 2;
+
+/** How many dots fit on a ring of `radius` across `sweep` radians, `spacing` apart. */
+function capacity(radius, spacing, sweep) {
+  if (radius <= 0) return 1;
+  const arc = sweep * radius;
+  // A whole circle closes on itself; an arc has a dot at each end.
+  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) {
+  const radii = [];
+  let room = 0;
+  for (let r = inner; room < n; r += spacing) {
+    radii.push(r);
+    room += capacity(r, spacing, sweep);
+  }
+  return radii;
+}
+
+const outerOf = (n, inner, spacing, sweep) => {
+  const radii = ringsFor(n, inner, spacing, sweep);
+  return radii[radii.length - 1];
+};
+
+/**
+ * Places `n` dots in rings round a centre at (0, 0).
+ *
+ * The first ring sits at `inner`, and each next one `spacing` further out.
+ * When that would run past `outer`, the rings first start further in (down to
+ * `innerMin`), then close up (down to `minSpacing`); past that they carry on
+ * beyond `outer` rather than overlap, and zooming out shows them. The dots on
+ * each ring share it evenly, in proportion to its length, so every ring is
+ * about as full as the rest; the first `n` of a list sorted best-first land
+ * nearest the centre. Every other ring is turned by half a step, so dots on
+ * 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.
+ *
+ * @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,
+} = {}) {
+  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) {
+    // Start further in, as far as innerMin, before closing anything up.
+    if (outerOf(count, innerMin, s, sweep) <= 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;
+      }
+      r0 = lo;
+    } else {
+      r0 = innerMin;
+      let lo = minSpacing, hi = spacing;
+      if (outerOf(count, r0, lo, sweep) <= 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;
+        }
+      }
+      s = lo;
+    }
+  }
+
+  const radii = ringsFor(count, r0, s, sweep);
+  const caps = radii.map((r) => capacity(r, s, sweep));
+  const room = caps.reduce((a, b) => a + b, 0);
+
+  // Share the dots in proportion to each ring's room, never over it; what the
+  // rounding leaves goes to the rings with the most room left.
+  const counts = caps.map((c) => Math.min(c, Math.floor((count * c) / room)));
+  let left = count - counts.reduce((a, b) => a + b, 0);
+  while (left > 0) {
+    let best = -1;
+    for (let k = 0; k < caps.length; k++) {
+      if (counts[k] < caps[k] && (best < 0 || caps[k] - counts[k] > caps[best] - counts[best])) best = k;
+    }
+    counts[best]++;
+    left--;
+  }
+
+  const whole = sweep >= TAU - 1e-9;
+  const points = [];
+  const rings = [];
+  radii.forEach((radius, k) => {
+    const m = counts[k];
+    if (!m) return;
+    rings.push({ radius, count: m });
+    // Round a whole circle evenly; across an arc from one edge to the other, a
+    // lone dot in the middle of it. An arc fills from its middle outwards, so
+    // the first in the list sit nearest whatever the arc fans out from.
+    const step = whole ? TAU / m : m > 1 ? sweep / (m - 1) : 0;
+    const from = whole ? start + (k % 2 ? step / 2 : 0) : m > 1 ? start : start + sweep / 2;
+    const slots = whole ? null : middleOut(m);
+    for (let j = 0; j < m; j++) {
+      const angle = from + (slots ? slots[j] : j) * step;
+      points.push({ x: radius * Math.cos(angle), y: radius * Math.sin(angle), angle, ring: rings.length - 1 });
+    }
+  });
+  return { spacing: s, inner: r0, rings, points };
+}
+
+/** 0 … m-1 from the middle outwards: for 5, 2 3 1 4 0. */
+function middleOut(m) {
+  let lo = Math.floor((m - 1) / 2);
+  let hi = lo + 1;
+  const out = [lo--];
+  while (out.length < m) {
+    if (hi < m) out.push(hi++);
+    if (out.length < m && lo >= 0) out.push(lo--);
+  }
+  return out;
+}
+
+/** A dot's radius for a layout's spacing: bigger for higher tiers, never touching a neighbour. */
+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));
+}

package/.next/standalone/lib/csv.js

@@ -1,4 +1,5 @@
 import { scorePerson, curveCutoffs, curvedTier } from './scoring.js';
+import { toIsoDate } from './ingest.js';
 // LinkedIn Connections.csv import — parsed ENTIRELY in the browser.
 //
 // Nothing is uploaded and nothing is written to the database: an imported
@@ -136,12 +137,9 @@ export function parseConnectionsCsv(text) {
     if (seen.has(id)) { skipped++; continue; }
     seen.add(id);
 
-    let connected_date = null;
-    const raw = cell(iConnected);
-    if (raw) {
-      const d = new Date(raw);
-      if (!isNaN(d.getTime())) connected_date = d.toISOString().split('T')[0];
-    }
+    // "28 Sep 2026", read as the calendar date it is. new Date(raw).toISOString()
+    // made it local midnight in UTC, a day early anywhere east of London.
+    const connected_date = toIsoDate(cell(iConnected));
 
     connections.push(connectionFrom({ id, name, role, company, profileUrl, connected_date }));
   }

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

@@ -111,7 +111,8 @@ export function buildExport(db, { dir, outFile, includePhotos = true, appVersion
     // file the other computer doesn't have: some views draw an empty circle
     // for it. With no photo, they show initials, and the next scan of that
     // person saves a new one. A photo not saved yet (LinkedIn's own link,
-    // which expires in a few weeks) is left as it is, as it is here.
+    // which expires in a few weeks) is left as it is, as it is here: neither
+    // computer shows it, and either saves it once (lib/photos.js).
     if (!includePhotos) {
       out.exec("UPDATE linkedin_connections SET profile_image_url = NULL WHERE profile_image_url LIKE '/avatars/%'");
     }

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

@@ -11,9 +11,11 @@
 import { readdirSync, lstatSync, existsSync, rmSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+import { AVATAR_FILE } from './photos.js';
 
-/** A photo the /avatars route serves: a plain file name, no folders. The route uses this same pattern. */
-export const AVATAR_FILE = /^[A-Za-z0-9_-]+\.(webp|jpg|jpeg|png)$/;
+// A photo the /avatars route serves (lib/photos.js). An export carries and an
+// import accepts exactly those names.
+export { AVATAR_FILE };
 
 /**
  * The scanner's notes about the network itself: without them, people whose

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

@@ -0,0 +1,12 @@
+// The Galaxy's view, as numbers, kept apart from the drawing so it can be tested
+// (app/components/ForceGraph.js).
+
+/**
+ * The same view in a box of a new size. It moves by half the change, at the
+ * same zoom, so whatever was in the middle of the box is in the middle still.
+ * Opening a 320-pixel panel slides the view 160 pixels left, and closing it
+ * slides the view back to exactly where it was.
+ */
+export function recentre({ x, y, k }, from, to) {
+  return { x: x + (to.width - from.width) / 2, y: y + (to.height - from.height) / 2, k };
+}

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

@@ -43,22 +43,29 @@ const MONTHS = ['january', 'february', 'march', 'april', 'may', 'june', 'july',
   'august', 'september', 'october', 'november', 'december'];
 
 /**
- * "September 22, 2026" (as LinkedIn prints "Connected on …") → "2026-09-22".
+ * A date as LinkedIn writes it → "2026-09-22": "September 22, 2026" (a profile's
+ * "Connected on …", read by the scanner) or "22 Sep 2026" (the "Connected On"
+ * column of the Connections.csv export, read by lib/csv.js).
  *
  * Parsed by hand rather than with new Date(text).toISOString(): that reads the
  * text as local midnight and converts to UTC, which moves the date back a day
  * anywhere east of Greenwich — and throws outright on text it cannot read.
- * Returns null for anything it does not recognise.
+ * A calendar date has no time zone, so nothing here uses one.
+ * Returns null for anything it does not recognise, or a day the month doesn't have.
  */
 export function toIsoDate(text) {
   const t = String(text || '').trim();
   if (/^\d{4}-\d{2}-\d{2}$/.test(t)) return t;
-  const m = t.match(/^([A-Za-z]+)\.?\s+(\d{1,2}),?\s+(\d{4})$/);
-  if (!m) return null;
-  const month = MONTHS.findIndex((name) => name.startsWith(m[1].toLowerCase()) && m[1].length >= 3);
-  const day = Number(m[2]);
-  if (month < 0 || day < 1 || day > 31) return null;
-  return `${m[3]}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  let name, day, year;
+  let m = t.match(/^([A-Za-z]+)\.?\s+(\d{1,2}),?\s+(\d{4})$/);   // September 22, 2026
+  if (m) [, name, day, year] = m;
+  else if ((m = t.match(/^(\d{1,2})\s+([A-Za-z]+)\.?\s+(\d{4})$/))) [, day, name, year] = m;   // 22 Sep 2026
+  else return null;
+  const month = MONTHS.findIndex((full) => full.startsWith(name.toLowerCase()) && name.length >= 3);
+  day = Number(day);
+  // Day 0 of the next month is this month's last, counted in UTC so no zone moves it.
+  if (month < 0 || day < 1 || day > new Date(Date.UTC(Number(year), month + 1, 0)).getUTCDate()) return null;
+  return `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
 }
 
 // Tiers that make a new connection worth a notification of its own.

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

@@ -4,15 +4,20 @@
 // reads them with the same rules, and writes only the two things a person
 // 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.
+//
 // They belong to the LinkedIn account, not to a profile in the app. TRAPS §35.
 
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, lstatSync } from 'node:fs';
 import path from 'node:path';
 import { durable } from './durable.js';
 
-export const DEFAULT_LIMITS = { daily: 50, monthly: 250 };
+export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50 };
 export const DAILY_CHOICES = [25, 50, 100, 200, 500];
 export const MONTHLY_CHOICES = [100, 250, 500, 1000, 0];   // 0 = no monthly cap (Premium)
+export const PROFILE_CHOICES = [10, 25, 50, 100];           // profile views a day; never unlimited
 const DAY = 24 * 3600;
 const PACIFIC = 'America/Los_Angeles';
 
@@ -56,15 +61,25 @@ export function nextMonthStartPacific(ms = Date.now()) {
 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) };
+  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,
+  };
 }
 
-/** Only the offered choices are accepted, like everything else that reaches the scanner. */
-export function writeLimits(dir, { daily, monthly }) {
+/**
+ * Only the offered choices are accepted, like everything else that reaches the
+ * scanner. A value not given keeps what is saved: every key is written back,
+ * or saving one would drop the others to their defaults.
+ */
+export function writeLimits(dir, { daily, monthly, profiles } = {}) {
   const cur = readLimits(dir);
   const next = {
     daily: DAILY_CHOICES.includes(daily) ? daily : cur.daily,
     monthly: MONTHLY_CHOICES.includes(monthly) ? monthly : cur.monthly,
+    profiles: PROFILE_CHOICES.includes(profiles) ? profiles : cur.profiles,
   };
   writeJsonAtomic(path.join(dir, 'scan-limits.json'), next);
   return next;
@@ -72,13 +87,14 @@ export function writeLimits(dir, { daily, monthly }) {
 
 /**
  * Searches in the last 24 hours and since LinkedIn's month began, and profile
- * views today. An unreadable record reads as the day used up, as the scanner
- * treats it — failing open would say nothing had been searched.
+ * views in the last 24 hours. An unreadable record reads as the day used up,
+ * searches and profile views both, as the scanner treats it — failing open
+ * would say nothing had been searched.
  */
 export function usage(dir, now = Date.now()) {
   const file = path.join(dir, 'linkedin-activity.json');
   const data = existsSync(file) ? readJson(file) : { searches: [], profiles: [] };
-  if (!data || typeof data !== 'object') return { searchesToday: Infinity, searchesMonth: 0, profilesToday: 0, unreadable: true };
+  if (!data || typeof data !== 'object') return { searchesToday: Infinity, searchesMonth: 0, profilesToday: Infinity, unreadable: true };
   const s = (Array.isArray(data.searches) ? data.searches : []).map(Number);
   const p = (Array.isArray(data.profiles) ? data.profiles : []).map(Number);
   const dayAgo = now / 1000 - DAY;
@@ -113,6 +129,7 @@ export function linkedinState(dir, now = Date.now()) {
     limits,
     leftToday: left(limits.daily, use.searchesToday),
     leftMonth: left(limits.monthly, use.searchesMonth),
+    profilesLeftToday: left(limits.profiles, use.profilesToday),
     monthResets: nextMonthStartPacific(now),
     cooldown: readCooldown(dir, now),
   };
@@ -138,7 +155,8 @@ const isTime = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
  * Why one of these files from another computer can't be used here, in words
  * for the page, or null when it can. The limits follow writeLimits: only the
  * menu's own choices. A value the app never offers is refused rather than
- * passed to the scanner, which reads a daily limit of 0 as "no limit at all".
+ * passed to the scanner, which reads a daily limit of 0 as "no limit at all"
+ * (and 1000 profile views a day would be as good as none).
  */
 export function budgetFileProblem(name, data) {
   if (!isObject(data)) return 'it is not a JSON object';
@@ -155,6 +173,9 @@ export function budgetFileProblem(name, data) {
     if (data.monthly !== undefined && !MONTHLY_CHOICES.includes(data.monthly)) {
       return `its monthly limit (${String(data.monthly).slice(0, 20)}) is not one Six Degrees offers`;
     }
+    if (data.profiles !== undefined && !PROFILE_CHOICES.includes(data.profiles)) {
+      return `its limit on profile views (${String(data.profiles).slice(0, 20)}) is not one Six Degrees offers`;
+    }
   }
   return null;
 }
@@ -236,6 +257,7 @@ export function mergeBudgetFiles({ dir, from }) {
     durable.writeJsonDurably(here(LIMITS), {
       daily: limits.daily ?? DEFAULT_LIMITS.daily,
       monthly: limits.monthly ?? DEFAULT_LIMITS.monthly,
+      profiles: limits.profiles ?? DEFAULT_LIMITS.profiles,
     });
   }
 }

package/.next/standalone/lib/photos.js

@@ -0,0 +1,47 @@
+// Profile photos are shown from this computer only.
+//
+// The scanner saves each photo into the data folder as it reads it
+// (scripts/image_store.py), and the row points at the saved file,
+// `/avatars/<name>`, which app/avatars/[file] serves. A row can also hold a
+// link: LinkedIn's own, which older versions stored until the scanner replaced
+// it, and which a copy of a network made by one carries too. A page never loads
+// a link: it would contact LinkedIn while someone is only looking at their map,
+// and the app goes online only when you act. That person shows initials until
+// the photo is saved, at the next scan or with Save photos on the Scan page.
+// The Content-Security-Policy in next.config.mjs holds the same line in the
+// browser.
+//
+// No imports, so the views and the server share it: every view and the routes
+// that store photos check with localPhoto, and the /avatars route serves the
+// names AVATAR_FILE allows.
+
+/** A photo the /avatars route serves: a plain file name, no folders. The route uses this same pattern. */
+export const AVATAR_FILE = /^[A-Za-z0-9_-]+\.(webp|jpg|jpeg|png)$/;
+
+const PREFIX = '/avatars/';
+
+/** The photo to show for a row's `profile_image_url`: its saved file's path, or null. */
+export function localPhoto(url) {
+  if (typeof url !== 'string' || !url.startsWith(PREFIX)) return null;
+  return AVATAR_FILE.test(url.slice(PREFIX.length)) ? url : null;
+}
+
+/**
+ * The photos still kept as links, one per person and link:
+ * [{ profileUrl, imageUrl }]. `db` is an open node:sqlite database. The
+ * scanner saves each (`GET /api/update-images`), or forgets the link on a
+ * definite no, so a link is tried until there's an answer.
+ */
+export function waitingPhotos(db) {
+  return db.prepare(`SELECT DISTINCT profile_url AS profileUrl, profile_image_url AS imageUrl
+      FROM linkedin_connections
+     WHERE profile_image_url IS NOT NULL AND profile_image_url <> ''
+       AND substr(profile_image_url, 1, 9) <> '/avatars/'
+     ORDER BY profile_url`).all()
+    .filter((r) => r.profileUrl && !localPhoto(r.imageUrl));
+}
+
+/** How many people have a photo waiting to be saved. */
+export function waitingPhotoCount(db) {
+  return new Set(waitingPhotos(db).map((r) => r.profileUrl)).size;
+}

package/.next/standalone/lib/quest.js

@@ -9,6 +9,8 @@
 // sent, people who actually joined your network), never from browsing.
 // Plain functions; tests/quest.test.mjs.
 
+import { circleState } from './reach.js';
+
 export const STAGE_SIZE = 5;
 export const XP_SEND = { S: 25, A: 15, B: 10, C: 5, D: 2 };
 export const XP_ADDED = { S: 100, A: 60, B: 35, C: 15, D: 5 };
@@ -26,8 +28,9 @@ export function levelFor(points) {
  * @param sentIds ids marked "invite sent"
  * @param added   1st-degree people who came through a cluster (unlocked_from_bridge_id set)
  * @param mappedIds ids of 1st-degree people whose own circle is mapped
+ * @param reach   lib/reach.js reachIndex(), which also knows hidden lists; mappedIds stands in without it
  */
-export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set() }) {
+export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set(), reach = null }) {
   const byBridge = new Map();
   const seen = new Set();
   for (const r of [...recs].sort((a, b) => (b.priority || 0) - (a.priority || 0))) {
@@ -112,8 +115,10 @@ export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedI
     level: levelFor(points),
     sentTotal,
     addedTotal,
-    // People you've added whose own circle isn't mapped yet: the next degree.
-    newDoors: added.filter((a) => a.unlocked_from_bridge_id && !mappedIds.has(a.id)),
+    // People you've added whose own circle can be scanned: the next degree.
+    // Hidden lists aren't doors (lib/reach.js, the rule Bridge Chains uses).
+    newDoors: added.filter((a) => a.unlocked_from_bridge_id
+      && circleState(a, reach || { scanned: mappedIds, hidden: new Set() }) === 'todo'),
     clearedStages: clusters.reduce((s, c) => s + (c.stage - 1) + (c.complete ? 1 : 0), 0),
   };
 }

package/.next/standalone/lib/reach.js

@@ -0,0 +1,113 @@
+// Who you reached through a circle, and whether their own circle is next.
+//
+// Blake, 2026-09-25: "i would like to sigingy if a orb in the 2nd degree is
+// added already so it shows they are ready for a 2nd degree scan to get the 3rd
+// degree so it needs to be intuitive with the orb glowing".
+//
+// "Ready" is one rule, kept here once. It used to live in three slightly
+// different copies (Outlink's new doors, the profile page's mapping bar and the
+// Degrees panel's Auto-Bridge Next), and only one of them knew about hidden
+// lists. Someone is ready for a circle scan when all of these are true:
+//   - they're your connection now (degree 1);
+//   - they came to you through a circle: unlocked_from_bridge_id, which
+//     lib/promote.js keeps when it clears source_connection_id, and which a
+//     request sent from the app sets to the circle you asked through;
+//   - their own circle hasn't been scanned: nobody in it is saved, and the
+//     scanner has no note of reading it (bridge-progress.json);
+//   - their list isn't known to be hidden (bridge-skips.json).
+// A glow that fired on hidden lists would teach you to ignore it, so a hidden
+// list is its own state, never "ready".
+//
+// Plain functions, no React; tests/reach.test.mjs.
+
+import { keyFor, compareBridges } from './separation.js';
+
+/**
+ * What the rules read, built once per load.
+ *
+ * @param connections 1st-degree rows
+ * @param degree2     2nd-degree rows: whose circle each sits in
+ * @param notes       what the scanner noted, from /api/scraper?reach=1:
+ *                    { skips: [{ profileUrl }] (hidden lists), read: [profileUrl] (lists it has read) }
+ * @returns {{ scanned: Set, read: Set, hidden: Set, reachedFrom: Map }}
+ *   `reachedFrom` is circle id → the connections you reached through it.
+ */
+export function reachIndex(connections = [], degree2 = [], notes = {}) {
+  const scanned = new Set();
+  for (const row of degree2 || []) {
+    if (row?.source_connection_id != null) scanned.add(row.source_connection_id);
+  }
+  const hidden = new Set();
+  for (const s of notes?.skips || []) {
+    if (s?.profileUrl) hidden.add(keyFor({ profile_url: s.profileUrl }));
+  }
+  const read = new Set();
+  for (const url of notes?.read || []) {
+    if (url) read.add(keyFor({ profile_url: url }));
+  }
+  const reachedFrom = new Map();
+  for (const row of connections || []) {
+    const from = row?.unlocked_from_bridge_id;
+    if (from == null || row.degree !== 1) continue;
+    let list = reachedFrom.get(from);
+    if (!list) reachedFrom.set(from, (list = []));
+    list.push(row);
+  }
+  return { scanned, read, hidden, reachedFrom };
+}
+
+/**
+ * Their own circle: 'scanned' (someone in it is saved, or the scanner read
+ * their list and everyone on it was already yours), 'hidden' (they keep their
+ * connections private) or 'todo'.
+ */
+export function circleState(person, reach) {
+  if (!person) return 'todo';
+  if (reach.scanned.has(person.id)) return 'scanned';
+  if (person.profile_url && reach.read?.has(keyFor(person))) return 'scanned';
+  if (person.profile_url && reach.hidden.has(keyFor(person))) return 'hidden';
+  return 'todo';
+}
+
+/**
+ * For someone you reached through a circle: 'ready' (their circle can be
+ * scanned next), 'hidden' or 'scanned'. Null for anyone else: people who were
+ * always your connections, and 2nd-degree rows (a request sent from the app
+ * marks those with the circle it asked through, but they aren't yours yet).
+ */
+export function reachState(person, reach) {
+  if (!person || person.degree !== 1 || person.unlocked_from_bridge_id == null) return null;
+  const state = circleState(person, reach);
+  return state === 'todo' ? 'ready' : state;
+}
+
+/** Everyone ready for a circle scan, strongest first. */
+export function readyToScan(connections, reach) {
+  return (connections || []).filter((c) => reachState(c, reach) === 'ready').sort(compareBridges);
+}
+
+/** How many people you reached through each circle are ready, by circle id. */
+export function readyByCircle(reach) {
+  const out = new Map();
+  for (const [from, people] of reach.reachedFrom) {
+    const n = people.filter((p) => reachState(p, reach) === 'ready').length;
+    if (n) out.set(from, n);
+  }
+  return out;
+}
+
+/**
+ * What scanning one circle asks of LinkedIn: one profile view to find their
+ * list, then a search for every page of it, `pages` at most (LinkedIn shows
+ * 100). About 0.55 minutes a page with the scanner's rests (20 s before each
+ * page, a minute more after every 10), so about 55 minutes for a whole list.
+ * The Scan page and the Degrees panel both say it from here.
+ */
+export function circleScanCost(pages = 100) {
+  const searches = Math.max(1, Math.min(100, Math.round(pages) || 100));
+  return {
+    profileViews: 1,
+    searches,
+    minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
+  };
+}

package/.next/standalone/lib/scan-state.js

@@ -40,6 +40,7 @@ export function runningNow(job) {
     case 'install': return 'The scanner\'s packages are being installed';
     case 'setup': return 'The scanner is being set up';
     case 'login': return 'The LinkedIn sign-in window is open';
+    case 'photos': return 'Profile photos are being saved';
     default: return 'A scan is running';
   }
 }

package/.next/standalone/lib/scanner-setup.js

@@ -1,5 +1,6 @@
 // What the Scan page's first step says and offers, from the checks GET
-// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js).
+// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js), and
+// whether it asks for your field before that (askForField).
 // Plain data in, plain data out: the page draws it, and
 // tests/scanner-setup.test.mjs checks every state without a browser. No Node
 // imports here; the page runs in the browser.
@@ -102,3 +103,21 @@ function stepOnly(status) {
     button: null,
   };
 }
+
+/**
+ * Whether the Scan page asks for your field first (app/components/FieldStep.js):
+ * once, before the first scan. Never to someone who already has a network, has
+ * picked a sector (Scores → Your sector), or answered or skipped the question
+ * before (`fieldAsked`). `status` is GET /api/scraper's answer (null while it
+ * loads), `settings` GET /api/settings' `settings` (undefined while it loads,
+ * null when it couldn't be read). null means not known yet: the page waits,
+ * rather than show the steps and then swap them for the question.
+ */
+export function askForField(status, settings) {
+  if (!status) return null;
+  const n = status.network;
+  // No counts means the app couldn't be asked; a scan running is past asking.
+  if (!n || n.first || n.second || n.third || status.running) return false;
+  if (settings === undefined) return null;
+  return Boolean(settings && !settings.fieldAsked && !settings.sectorFocus?.sectors?.length);
+}