six-degrees 0.6.0 → 0.7.0

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

@@ -89,7 +89,7 @@ export function refreshNotifications({ added = [], checked = 0, tierOf = () => n
   if (!added.length) {
     return [{
       user_id, type: 'refresh_summary', title: 'Network up to date',
-      message: `Checked ${checked} connections — no new additions`, icon: '✓',
+      message: `Checked ${checked} connections: no new additions`, icon: '✓',
     }];
   }
   const out = [{

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

@@ -4,6 +4,10 @@
 // reads them with the same rules, and writes only the two things a person
 // changes here — the budget, and lifting a cooldown.
 //
+// Settings → LinkedIn usage reads the same record more closely (linkedinUsage):
+// the last hour and the last 7 days, when the next search frees up, and the
+// last time LinkedIn pushed back. lib/usage.js says what the numbers mean.
+//
 // The budget is searches (a day and a month) and profile views (a day). Profile
 // 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
@@ -11,10 +15,13 @@
 //
 // 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 {
+  readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, lstatSync, readdirSync, openSync, readSync, closeSync,
+} from 'node:fs';
 import path from 'node:path';
 import { durable } from './durable.js';
 import { PACES, DEFAULT_PACE } from './scan-pace.js';
+import { countAfter } from './usage.js';
 
 export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50, pace: DEFAULT_PACE };
 export const DAILY_CHOICES = [25, 50, 100, 200, 500];
@@ -94,6 +101,20 @@ export function writeLimits(dir, { daily, monthly, profiles, pace } = {}) {
   return next;
 }
 
+/**
+ * The scanner's record as two lists of times (epoch seconds), or null when it
+ * can't be read. No record at all is nothing done yet.
+ */
+function readActivity(dir) {
+  const file = path.join(dir, 'linkedin-activity.json');
+  const data = existsSync(file) ? readJson(file) : { searches: [], profiles: [] };
+  if (!data || typeof data !== 'object') return null;
+  return {
+    searches: (Array.isArray(data.searches) ? data.searches : []).map(Number),
+    profiles: (Array.isArray(data.profiles) ? data.profiles : []).map(Number),
+  };
+}
+
 /**
  * Searches in the last 24 hours and since LinkedIn's month began, and profile
  * views in the last 24 hours. An unreadable record reads as the day used up,
@@ -101,11 +122,9 @@ export function writeLimits(dir, { daily, monthly, profiles, pace } = {}) {
  * 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: Infinity, unreadable: true };
-  const s = (Array.isArray(data.searches) ? data.searches : []).map(Number);
-  const p = (Array.isArray(data.profiles) ? data.profiles : []).map(Number);
+  const rec = readActivity(dir);
+  if (!rec) return { searchesToday: Infinity, searchesMonth: 0, profilesToday: Infinity, unreadable: true };
+  const { searches: s, profiles: p } = rec;
   const dayAgo = now / 1000 - DAY;
   const month0 = monthStartPacific(now) / 1000;
   return {
@@ -115,17 +134,42 @@ export function usage(dir, now = Date.now()) {
   };
 }
 
-/** The active cooldown { until (ms), reason, setAt }, or null. */
+/** The active cooldown { until (ms), reason, setAt }, or null. A lifted one (liftCooldown) is none. */
 export function readCooldown(dir, now = Date.now()) {
   const raw = readJson(path.join(dir, 'linkedin-cooldown.json'));
   const until = Number(raw?.until) * 1000;
-  if (!raw || !Number.isFinite(until) || until <= now) return null;
+  if (!raw || raw.lifted_at !== undefined || !Number.isFinite(until) || until <= now) return null;
   return { until, reason: String(raw.reason || 'LinkedIn pushed back'), setAt: Number(raw.set_at) * 1000 || null };
 }
 
-/** Lift it: the person says LinkedIn works for them again. */
-export function liftCooldown(dir) {
-  try { unlinkSync(path.join(dir, 'linkedin-cooldown.json')); } catch { /* none to lift */ }
+/**
+ * Lift it: the person says LinkedIn works for them again. The record is kept,
+ * marked lifted, so Settings → LinkedIn usage can still say when LinkedIn last
+ * pushed back; deleting it forgot that. Its `until` becomes the moment it was
+ * lifted and the old end moves to `was_until`, so everything that reads the
+ * file sees a pause that has simply ended, with no change of its own: here
+ * (readCooldown, the import's merge) and in the scanner (read_cooldown and
+ * set_cooldown in scripts/scrape.py ask only whether `until` is still ahead),
+ * so the scanner's pacing is exactly what it was. A pause already over is
+ * left alone; a record that can't be read is removed, as before.
+ */
+export function liftCooldown(dir, now = Date.now()) {
+  const file = path.join(dir, COOLDOWN);
+  const raw = readJson(file);
+  const until = Number(raw?.until);
+  if (!isObject(raw) || !Number.isFinite(until)) {
+    try { unlinkSync(file); } catch { /* none to lift */ }
+    return;
+  }
+  const at = now / 1000;
+  if (until <= at) return;
+  writeJsonAtomic(file, {
+    until: at,
+    reason: typeof raw.reason === 'string' ? raw.reason : 'LinkedIn pushed back',
+    set_at: isTime(raw.set_at) ? raw.set_at : null,
+    lifted_at: at,
+    was_until: until,
+  });
 }
 
 /** Everything the Scan page shows, in one object. */
@@ -144,6 +188,155 @@ export function linkedinState(dir, now = Date.now()) {
   };
 }
 
+// ── Settings → LinkedIn usage ────────────────────────────────────────────────
+// The same record, read more closely. Windows count a time strictly inside
+// them (t > now - window), as usage() and the scanner's linkedin_usage do, so a
+// search exactly 24 hours old has stopped counting.
+
+/** How many of `times` (epoch s) fall in the last `seconds` before `now` (ms). */
+export function countWithin(times, now, seconds) {
+  const from = now / 1000 - seconds;
+  return times.filter((t) => t > from).length;
+}
+
+/**
+ * When the count in the window next drops under `cap`, in ms: the moment a
+ * search (or profile view) is free again. null when one is free now, or with
+ * no cap. The scanner says the same for profile views (scrape.py
+ * budget_message: the one that stops counting soonest frees the next).
+ */
+export function freesAt(times, now, cap, seconds = DAY) {
+  if (!cap) return null;
+  const live = times.filter((t) => t > now / 1000 - seconds).sort((a, b) => a - b);
+  if (live.length < cap) return null;
+  return (live[live.length - cap] + seconds) * 1000;
+}
+
+/** When the window holds nothing at all again (the newest time turns `seconds` old), in ms; null if it's empty. */
+export function clearAt(times, now, seconds = DAY) {
+  const live = times.filter((t) => t > now / 1000 - seconds);
+  return live.length ? (Math.max(...live) + seconds) * 1000 : null;
+}
+
+// The scanner keeps what the page showed when LinkedIn pushed back as
+// pushback/<local date>_<time>.txt: "reason: …", then "url: …", then the page's
+// text (scrape.py _keep_pushback_evidence). Only the name's time and the first
+// line are read here: the page's address and its text are LinkedIn's page about
+// this account and stay in the file.
+const PUSHBACK_FILE = /^(\d{4})-(\d{2})-(\d{2})_(\d{2})(\d{2})(\d{2})\.txt$/;
+const FIRST_LINE_BYTES = 256;
+
+/** The reason on a pushback file's first line, or null. Never more of the file. */
+function pushbackReason(file) {
+  let fd;
+  try {
+    fd = openSync(file, 'r');
+    const buf = Buffer.alloc(FIRST_LINE_BYTES);
+    const n = readSync(fd, buf, 0, FIRST_LINE_BYTES, 0);
+    const line = buf.subarray(0, n).toString('utf8').split(/\r?\n/)[0];
+    const m = line.match(/^reason: (.+)$/);
+    const reason = m && m[1].replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 120);
+    // The scanner's reasons are its own short phrases; anything shaped like an address isn't one.
+    return reason && !/:\/\/|www\.|linkedin\.com|\/in\//i.test(reason) ? reason : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+/** The newest pushback file: { at (ms, from its name), reason }, or null. */
+export function newestPushback(dir) {
+  let names;
+  try {
+    // Plain files only: a link or a folder by that name is not the scanner's.
+    names = readdirSync(path.join(dir, 'pushback'), { withFileTypes: true })
+      .filter((e) => e.isFile() && PUSHBACK_FILE.test(e.name)).map((e) => e.name);
+  } catch {
+    return null;
+  }
+  // Newest first by name, which is by time; a name that isn't a real time is passed over.
+  for (const name of names.sort().reverse()) {
+    const [, y, mo, d, h, mi, s] = name.match(PUSHBACK_FILE).map(Number);
+    // The scanner names it by this computer's clock (datetime.now()), as this reads it.
+    const when = new Date(y, mo - 1, d, h, mi, s);
+    if (when.getMonth() !== mo - 1 || when.getDate() !== d || h > 23 || mi > 59 || s > 59) continue;
+    return { at: when.getTime(), reason: pushbackReason(path.join(dir, 'pushback', name)) };
+  }
+  return null;
+}
+
+// One pushback usually leaves both: the page kept, then the pause set, moments
+// (at most the rest of that person's read) apart.
+const SAME_EVENT_MS = 10 * 60 * 1000;
+
+/**
+ * The last time LinkedIn pushed back, from the cooldown file (active, ended or
+ * lifted) and the newest pushback file: { at (ms or null), reason, pausedUntil,
+ * liftedAt, active }, or null when there's no sign of one. Times and the
+ * reason only.
+ */
+export function lastPushback(dir, now = Date.now()) {
+  const file = newestPushback(dir);
+  const raw = readJson(path.join(dir, COOLDOWN));
+  const until = Number(raw?.until);
+  const pause = isObject(raw) && Number.isFinite(until) ? {
+    at: isTime(raw.set_at) ? raw.set_at * 1000 : null,
+    reason: typeof raw.reason === 'string' && raw.reason.trim() ? raw.reason.trim().slice(0, 160) : 'LinkedIn pushed back',
+    pausedUntil: (isTime(raw.was_until) ? raw.was_until : until) * 1000,
+    liftedAt: isTime(raw.lifted_at) ? raw.lifted_at * 1000 : null,
+  } : null;
+  const fromFile = file && {
+    at: file.at,
+    reason: file.reason ? `LinkedIn pushed back: ${file.reason}` : 'LinkedIn pushed back',
+    pausedUntil: null,
+    liftedAt: null,
+  };
+  let last;
+  if (pause && fromFile && pause.at != null && Math.abs(pause.at - fromFile.at) <= SAME_EVENT_MS) {
+    last = { ...pause, at: Math.min(pause.at, fromFile.at) };
+  } else if (pause && fromFile) {
+    last = (pause.at ?? -Infinity) >= fromFile.at ? pause : fromFile;
+  } else {
+    last = pause || fromFile;
+  }
+  if (!last) return null;
+  return { ...last, active: !last.liftedAt && last.pausedUntil != null && last.pausedUntil > now };
+}
+
+/**
+ * Everything Settings → LinkedIn usage shows (GET /api/scraper?usage): the
+ * Scan page's state, plus
+ *   searchesLastHour, searchesWeek   counted like searchesToday
+ *   dayFreesAt                       when the daily budget has a search free again (null: one is free now)
+ *   dayClearAt                       when the last 24 hours hold no searches at all
+ *   profilesFreeAt                   when a profile view is free again
+ *   lastPushback                     lastPushback() above
+ *   searchesSincePushback            searches made after it (lib/usage.js countAfter)
+ * An unreadable record gives nulls, never zeros: it isn't "nothing searched".
+ */
+export function linkedinUsage(dir, now = Date.now()) {
+  const state = linkedinState(dir, now);
+  const rec = readActivity(dir);
+  const pushback = lastPushback(dir, now);
+  const known = (fn) => (rec ? fn(rec) : null);
+  return {
+    ...state,
+    now,
+    searchesToday: rec ? state.searchesToday : null,
+    profilesToday: rec ? state.profilesToday : null,
+    searchesMonth: rec ? state.searchesMonth : null,
+    leftMonth: rec ? state.leftMonth : null,
+    searchesLastHour: known((r) => countWithin(r.searches, now, 3600)),
+    searchesWeek: known((r) => countWithin(r.searches, now, 7 * DAY)),
+    dayFreesAt: known((r) => freesAt(r.searches, now, state.limits.daily)),
+    dayClearAt: known((r) => clearAt(r.searches, now)),
+    profilesFreeAt: known((r) => freesAt(r.profiles, now, state.limits.profiles)),
+    lastPushback: pushback,
+    searchesSincePushback: known((r) => countAfter(r.searches, pushback?.at)),
+  };
+}
+
 // ── another computer's budget (Settings → Your data → Import) ───────────────
 // An import carries these three files from the other computer. They describe
 // the same LinkedIn account, so they are merged with the ones here, never put
@@ -175,6 +368,10 @@ export function budgetFileProblem(name, data) {
     if (!isTime(data.until)) return 'its pause has no end time';
     if (data.reason !== undefined && typeof data.reason !== 'string') return 'its pause has a reason that is not text';
     if (data.set_at !== undefined && !isTime(data.set_at)) return 'its pause has a start time that is not a time';
+    // A pause lifted by hand (liftCooldown) says when, and when it would have ended.
+    for (const key of ['lifted_at', 'was_until']) {
+      if (data[key] !== undefined && !isTime(data[key])) return 'its lifted pause has a time that is not a time';
+    }
   } else if (name === LIMITS) {
     if (data.daily !== undefined && !DAILY_CHOICES.includes(data.daily)) {
       return `its daily limit (${String(data.daily).slice(0, 20)}) is not one Six Degrees offers`;
@@ -252,11 +449,15 @@ export function mergeBudgetFiles({ dir, from }) {
   if (cooldown) {
     const mine = readJson(here(COOLDOWN));
     const mineEnds = Number.isFinite(Number(mine?.until)) ? Number(mine.until) : -Infinity;
+    // A pause lifted here ends when it was lifted (liftCooldown), so one still
+    // on in the copy comes back, as it did when lifting deleted the file.
     if (cooldown.until > mineEnds) {
       durable.writeJsonDurably(here(COOLDOWN), {
         until: cooldown.until,
         reason: cooldown.reason ?? 'LinkedIn pushed back',
         set_at: cooldown.set_at ?? null,
+        // Lifted in the copy: still lifted here, and still the last pushback on record.
+        ...(cooldown.lifted_at !== undefined && { lifted_at: cooldown.lifted_at, was_until: cooldown.was_until ?? cooldown.until }),
       });
     }
   }

package/.next/standalone/lib/liquid-glass.js

@@ -0,0 +1,59 @@
+// Liquid Glass's lensing (Apple, WWDC25 "Meet Liquid Glass"; HIG → Materials):
+// the edge of a pane of glass bends what's behind it, where frosted glass only
+// blurs it. Done the way the good web versions do it in Chromium: a
+// displacement map, drawn here for a panel's exact size, used by an SVG
+// feDisplacementMap that the panel's backdrop-filter runs
+// (app/components/LiquidGlass.js).
+//
+// The map's red channel shifts a pixel across, green up and down; 128 is no
+// shift. Only a band along the edge (the bezel) moves, and it always pulls
+// inward, since a backdrop is clipped to the panel and anything pulled from
+// outside it would come back empty.
+
+/**
+ * How far, and which way, each pixel of a rounded rectangle w×h (corner r)
+ * bends: [dx, dy] in -1…1 for (x, y), strongest at the edge and fading to
+ * nothing `bezel` pixels in.
+ */
+export function lensAt(x, y, w, h, r, bezel) {
+  const px = x + 0.5 - w / 2;
+  const py = y + 0.5 - h / 2;
+  const qx = Math.abs(px) - (w / 2 - r);
+  const qy = Math.abs(py) - (h / 2 - r);
+  const ox = Math.max(qx, 0);
+  const oy = Math.max(qy, 0);
+  const o = Math.hypot(ox, oy);
+  const dist = r - (o + Math.min(Math.max(qx, qy), 0));   // pixels in from the edge
+  let nx = 0;
+  let ny = 0;
+  if (o > 0) { nx = ox / o; ny = oy / o; } else if (qx > qy) nx = 1; else ny = 1;
+  nx *= -Math.sign(px) || 0;
+  ny *= -Math.sign(py) || 0;
+  const t = Math.max(0, 1 - dist / bezel);
+  const m = t * t;
+  return [nx * m, ny * m];
+}
+
+/** The displacement map for a w×h panel, as a PNG data URL (needs a canvas: the browser only). */
+export function lensMap(w, h, r, bezel) {
+  const c = document.createElement('canvas');
+  c.width = w;
+  c.height = h;
+  const ctx = c.getContext('2d');
+  const img = ctx.createImageData(w, h);
+  const d = img.data;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = (y * w + x) * 4;
+      // Most of a big panel is its middle, which never moves.
+      const nearEdge = x < bezel + r || y < bezel + r || x >= w - bezel - r || y >= h - bezel - r;
+      const [dx, dy] = nearEdge ? lensAt(x, y, w, h, r, bezel) : [0, 0];
+      d[i] = 128 + 127 * dx;
+      d[i + 1] = 128 + 127 * dy;
+      d[i + 2] = 128;
+      d[i + 3] = 255;
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+  return c.toDataURL();
+}

package/.next/standalone/lib/notifications.js

@@ -94,6 +94,19 @@ const NAME_IN_TITLE = [
  * `via` is who you met them through: the notification's own, else the person's
  * recorded introducer. `people` are everyone it names (a top-company list).
  */
+/**
+ * Which circle a notification is about, as a connection's id (a string), or
+ * null: whoever someone came through for "added you back" and "top companies",
+ * and whose circle it was for "Scan done". Read from what the note saved, so it
+ * needs nothing loaded.
+ */
+export function noteCircle(note) {
+  const data = typeof note?.data === 'string' ? safeJson(note.data) : note?.data || {};
+  if (data.viaId != null) return String(data.viaId);
+  if (data.action && data.personId != null) return String(data.personId);
+  return null;
+}
+
 export function noteSubject(note, connections = [], degree2 = []) {
   const all = [...(connections || []), ...(degree2 || [])];
   const byId = new Map(all.map((r) => [r.id, r]));

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

@@ -29,6 +29,17 @@ export function paceSeconds(name, searches) {
   return n * (WORK_SECONDS + p.pagePause) + Math.floor(n / EVERY) * p.chunkCooldown;
 }
 
+/**
+ * About how long a circle scan takes to show its first people on the map. The
+ * scanner saves after its first ten pages (scrape.py SAVE_EVERY_PAGES), so it's
+ * those ten at this speed; the longer rest counted after them stands in for
+ * opening Chrome and the person's profile first. About 5 minutes at Fast: the
+ * Scan page's honest "first circle" (the rest of a network takes days).
+ */
+export function firstCircleSeconds(name) {
+  return paceSeconds(name, EVERY);
+}
+
 /** About how many searches an hour a speed makes. */
 export function searchesPerHour(name) {
   const p = paceOf(name);

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

@@ -70,6 +70,26 @@ export function scanProgress(log, action) {
   return null;
 }
 
+// "[3/10] Ada Park (A-tier, score 6.2)", with ", carrying on from page 11"
+// after it when a read goes on: the name is everything before the last
+// "(…-tier, score …)".
+const BRIDGE_PERSON = /^\[\d+\/\d+\] (.+) \([^()]*-tier, score [^()]*\)/;
+
+/**
+ * Whose circle a batch (Map 2nd degree, every paused list) is reading now,
+ * by name, from the line it printed as that person started; null for any
+ * other job, or before the first. The Scan page's "Watch it fill in" link
+ * (app/api/scraper/route.js turns the name into one of your connections).
+ */
+export function mappingNow(log, action) {
+  if (!Array.isArray(log) || !action || !(action.startsWith('auto-bridge') || action === 'resume-all')) return null;
+  for (let i = log.length - 1; i >= 0; i--) {
+    const m = String(log[i]).match(BRIDGE_PERSON);
+    if (m) return m[1];
+  }
+  return null;
+}
+
 function walk(done, total) {
   if (!total) return null;
   return { done: Math.min(done, total), total, kind: 'walk' };

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

@@ -0,0 +1,44 @@
+// Saying yes to the scanner's risk, once, before it first touches LinkedIn.
+//
+// The Scan page used to carry the risk as a grey line at the bottom. Now the
+// first scan waits for an explicit "I understand" to three plain points, kept
+// as a setting (app_meta, lib/settings.js) so it travels with a copy of the
+// data. The server checks it too, so no button anywhere (the header's Check for
+// new, a Scan button in a panel) can start a first scan without it.
+//
+// Someone who scanned before this existed has seen the risk and chosen it: the
+// scanner's own Chrome profile in the data folder is the sign, since only the
+// scanner makes one, and it never travels in a copy. They aren't asked again.
+//
+// No Node imports: the Scan page reads the points from here too.
+
+export const RISK_POINTS = [
+  'It runs your own LinkedIn account automatically, in a Chrome window on this computer.',
+  'LinkedIn’s User Agreement doesn’t allow automated tools, and LinkedIn may restrict accounts that use them. The safe limits, 50 searches a day and 250 a month, stay on unless you change them.',
+  'Nothing leaves your computer. There is no account with us and nothing is uploaded.',
+];
+
+export const RISK_REFUSAL = 'Before the first scan, open the Scan page and confirm you understand what scanning risks.';
+
+// The scanner's actions that never open LinkedIn: installing its Python and
+// packages, and saving photos already linked from it (no browser, no search).
+const OFF_LINKEDIN = new Set(['install', 'setup', 'photos']);
+
+export const touchesLinkedIn = (action) => !OFF_LINKEDIN.has(String(action));
+
+/** When the risk was accepted (ISO time), or null; set from the Scan page. */
+export const SCAN_RISK_SETTING = {
+  default: null,
+  parse(value) {
+    if (value === null) return null;
+    if (typeof value !== 'string' || Number.isNaN(Date.parse(value))) {
+      throw new Error('When the scanning risk was accepted is a date and time.');
+    }
+    return new Date(value).toISOString();
+  },
+};
+
+/** @param {{ acceptedAt?: string | null, scannedBefore?: boolean }} state */
+export function riskAccepted({ acceptedAt = null, scannedBefore = false } = {}) {
+  return Boolean(acceptedAt) || scannedBefore;
+}

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

@@ -1,12 +1,71 @@
 // 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), and
-// whether it asks for your field before that (askForField).
+// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js),
+// whether it asks for your field once your connections are in (askForField),
+// and two answers the server gives that step: is Google Chrome here
+// (chromeInstalled), and are you signed in to LinkedIn (signedInFrom).
 // 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.
 
 const MB = 1024 * 1024;
 
+// The scanner drives Google Chrome (scripts/scrape.py, channel "chrome"), so a
+// computer without it can set up the scanner's Python and still never scan.
+// It used to be a red box above the steps while step 1 said Ready; now step 1
+// isn't done without it, and the server refuses anything that opens LinkedIn
+// with the same words (app/api/scraper/route.js).
+export const CHROME_DOWNLOAD = 'https://www.google.com/chrome/';
+export const CHROME_MISSING = 'The scanner works in Google Chrome, and Chrome isn’t on this computer.';
+export const CHROME_BUTTON = 'Install Google Chrome, then come back';
+export const CHROME_REFUSAL = `${CHROME_MISSING} ${CHROME_BUTTON}.`;
+
+/**
+ * Is Google Chrome where Playwright's "chrome" channel looks for it (Chromium
+ * doesn't count)? `exists` is the file check (existsSync on the server), so
+ * this runs in a test with no Chrome at all.
+ *
+ * SIX_DEGREES_TEST_CHROME=found or =missing answers for the computer, for
+ * tests and for checking the Scan page's states by eye: the route's tests then
+ * don't depend on whether the machine running them has Chrome. Nothing in the
+ * app sets it; any other value is ignored.
+ */
+export function chromeInstalled({ platform, env = {}, exists }) {
+  const forced = env.SIX_DEGREES_TEST_CHROME;
+  if (forced === 'found') return true;
+  if (forced === 'missing') return false;
+  if (platform === 'darwin') return exists('/Applications/Google Chrome.app');
+  if (platform === 'linux') return exists('/opt/google/chrome/chrome');
+  // On Windows, for this user, then for everyone.
+  if (platform === 'win32') {
+    return [env.LOCALAPPDATA, env.PROGRAMFILES, env['PROGRAMFILES(X86)']]
+      .filter(Boolean)
+      .some((root) => exists(`${String(root).replace(/[\\/]+$/, '')}\\Google\\Chrome\\Application\\chrome.exe`));
+  }
+  return true; // elsewhere Playwright resolves the channel itself
+}
+
+// The scanner's note that LinkedIn's session was confirmed (scripts/scrape.py
+// SIGNED_IN_FILE): { signedIn, at }, written when the li_at cookie is seen past
+// any sign-in wall, and set to false while it waits for you to sign in.
+export const SIGNED_IN_FILE = 'signed-in.json';
+
+/**
+ * Step 2's "Signed in". It used to be "Chrome's cookie file exists", which is
+ * true the moment the scanner's window first opens, so opening LinkedIn and
+ * closing the window without signing in ticked the step. Now the scanner's own
+ * note says it (`note`, the parsed SIGNED_IN_FILE, or null when there is none
+ * or it can't be read), and only while its Chrome profile is still there
+ * (`profile`): deleting that signs you out.
+ *
+ * A data folder from before the note existed has none, and there the old
+ * check stands (`cookies`), so nobody already signed in is told they're signed
+ * out; the next scan writes the note.
+ */
+export function signedInFrom({ note, profile, cookies }) {
+  if (note && typeof note === 'object' && typeof note.signedIn === 'boolean') return note.signedIn && Boolean(profile);
+  return Boolean(cookies);
+}
+
 /** "Python 3.9.6 is too old…": why a Python this computer has won't do, or ''. */
 function whyNotThisPython(found) {
   if (!found?.version) return 'This computer has no Python the scanner can use.';
@@ -40,10 +99,11 @@ function ownPythonNote(own, { done, button }) {
 }
 
 /**
- * Step 1, "Set up the scanner": { done, text, button, note }, where button is
- * { action: 'install'|'setup', label } or null (nothing to press), and note is
- * a line to show above the step when the Python inside the app didn't work
- * (ownPythonNote), or null.
+ * Step 1, "Set up the scanner": { done, text, button, note, chrome }, where
+ * button is { action: 'install'|'setup', label } or null (nothing to press),
+ * note is a line to show above the step when the Python inside the app didn't
+ * work (ownPythonNote), or null, and chrome is { label, href } when Google
+ * Chrome isn't on this computer (the way to get it), or null.
  *
  *   ready        the app's own Python (nothing to install), one named by
  *                SIX_DEGREES_PYTHON, or the scanner's environment / a Python
@@ -53,10 +113,24 @@ function ownPythonNote(own, { done, button }) {
  *   setup        none, but a standalone Python for this computer is pinned:
  *                "Set up the scanner" downloads it, then installs
  *   neither      no Python and nothing to download for this computer
+ *
+ * Any of them without Chrome isn't done: the Python's part is said first if
+ * there is one, then Chrome's. Only a definite "no Chrome" counts; a status
+ * that couldn't say (none yet, or an older server's) leaves it out.
  */
 export function setupStep(status) {
   const step = stepOnly(status);
-  return { ...step, note: ownPythonNote(status?.checks?.ownPython, step) };
+  const note = ownPythonNote(status?.checks?.ownPython, step);
+  if (status?.checks?.chrome !== false) return { ...step, note, chrome: null };
+  return {
+    ...step,
+    done: false,
+    // "Ready" or "Installed." would read as finished: with the Python done,
+    // Chrome is all the step says.
+    text: step.done ? CHROME_MISSING : `${step.text} ${CHROME_MISSING}`,
+    note,
+    chrome: { label: CHROME_BUTTON, href: CHROME_DOWNLOAD },
+  };
 }
 
 function stepOnly(status) {
@@ -105,19 +179,27 @@ function stepOnly(status) {
 }
 
 /**
- * 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.
+ * Whether the Scan page asks for your field (app/components/FieldStep.js):
+ * once, when your own connections are in (step 3) and before who they know is
+ * mapped, under "Your galaxy is ready". It used to stand in front of step 1,
+ * one more thing between someone new and their first scan; asked here, it
+ * rescores people they can already see.
+ *
+ * Never before step 3, never once a 2nd-degree or company scan is in (that
+ * network's owner is past onboarding), never while a scan runs, and never to
+ * someone who has picked a sector (Scores → Your sector) or answered or
+ * skipped it before (`fieldAsked`, saved either way). So whoever has only
+ * their 1st degree mapped, someone from before this moved included, is asked
+ * once. `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 leaves the question
+ * out until it is, rather than show it and take it away.
  */
 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 (!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);
 }