six-degrees 0.3.0 → 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
@@ -60,6 +60,7 @@ CREATE TABLE IF NOT EXISTS linkedin_connections (
   unlocked_from_bridge_id TEXT,
   unlocked_from_name      TEXT,
   outreach_status         TEXT,
+  mutual_count            INTEGER,            -- LinkedIn's count of mutual connections (2nd degree), when a scan read one
   scanned_company         TEXT,
   score_why               TEXT,
   user_id                 TEXT,

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

@@ -0,0 +1,169 @@
+// Someone's circle as rings, for the top of their profile card.
+//
+// Blake, 2026-09-28: "for every profile card we can see their network circle
+// … all of their current connections scraped and graded but then outside of
+// that sits the connections all from d2 that we added and scanned coming from
+// that person as the provider of the cluster … and then for d3,d4,d5,d6".
+//
+// Two facts the app already keeps make the whole chain, with nothing new stored:
+//   source_connection_id     whose circle a row sits in: a scan of that person found it
+//   unlocked_from_bridge_id  who introduced someone you connected with, kept
+//                            after they became your connection (lib/promote.js)
+// So from a person P: P's circle (D2, through P) → the people in it you
+// connected with or asked → their circles (D3) → who you added from those →
+// their circles (D4) … to six degrees. Everyone appears once, in the nearest
+// ring they reach.
+
+import { keyFor, score1 } from './separation.js';
+
+export const MAX_DEGREE = 6;
+
+/** A request is out to them and they haven't accepted (Sidebar's "Connect to Unlock Path"). */
+export const requestedByDefault = (row) => row?.unlock_status === 'pending';
+
+/**
+ * Rows grouped two ways: `circles`, id → the rows a scan of that person found;
+ * `introduced`, id → your connections you met through them.
+ */
+export function circleIndex(connections = [], degree2 = []) {
+  const circles = new Map();
+  for (const row of degree2 || []) {
+    const id = row?.source_connection_id;
+    if (id == null) continue;
+    let list = circles.get(id);
+    if (!list) circles.set(id, (list = []));
+    list.push(row);
+  }
+  const introduced = new Map();
+  for (const row of connections || []) {
+    const id = row?.unlocked_from_bridge_id;
+    if (id == null || row.degree !== 1) continue;
+    let list = introduced.get(id);
+    if (!list) introduced.set(id, (list = []));
+    list.push(row);
+  }
+  return { circles, introduced };
+}
+
+const STATE_ORDER = { connected: 0, requested: 1 };
+const byStateThenPower = (a, b) => (STATE_ORDER[a.state] ?? 2) - (STATE_ORDER[b.state] ?? 2)
+  || score1(b.row) - score1(a.row)
+  || String(a.row.name || '').localeCompare(String(b.row.name || ''));
+
+/**
+ * The rings around `person`: [{ degree, people: [{ row, key, parentId, state }] }],
+ * degree 2 first. `state` is 'connected' (you added them, so their own circle
+ * is the next ring out), 'requested' (a request is out: drawn dotted) or null.
+ * Also the totals: { people, connected, requested }.
+ */
+export function circleRings(person, index, { maxDegree = MAX_DEGREE, isRequested = requestedByDefault } = {}) {
+  const rings = [];
+  const totals = { people: 0, connected: 0, requested: 0 };
+  if (!person || !index) return { rings, totals };
+  const seen = new Set([keyFor(person)]);
+  let frontier = [person];
+  for (let degree = 2; degree <= maxDegree && frontier.length; degree++) {
+    const ring = [];
+    const next = [];
+    for (const parent of frontier) {
+      const kids = [];
+      // The people you connected with first: they have circles of their own.
+      for (const row of index.introduced.get(parent.id) || []) {
+        const key = keyFor(row);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        kids.push({ row, key, parentId: parent.id, state: 'connected' });
+        next.push(row);
+      }
+      for (const row of index.circles.get(parent.id) || []) {
+        const key = keyFor(row);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        kids.push({ row, key, parentId: parent.id, state: isRequested(row) ? 'requested' : null });
+      }
+      kids.sort(byStateThenPower);
+      ring.push(...kids);
+    }
+    if (!ring.length) break;
+    for (const p of ring) {
+      totals.people++;
+      if (p.state === 'connected') totals.connected++;
+      else if (p.state === 'requested') totals.requested++;
+    }
+    rings.push({ degree, people: ring });
+    frontier = next;
+  }
+  return { rings, totals };
+}
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/**
+ * Where every dot goes, in a square `size` wide: a radial tree. Each person
+ * gets a slice of the circle in proportion to how much of the next rings
+ * hangs off them, so whoever opened the most reach shows it at a glance, and
+ * their circle fans out behind them.
+ * Returns { size, center, rings: [{ degree, radius, dotR, items }], spokes }.
+ */
+export function circleLayout(rings = [], size = 240) {
+  const half = size / 2;
+  const R = rings.length;
+  const radiusOf = (k) => half * (R === 1 ? 0.78 : 0.4 + 0.52 * (k / (R - 1)));
+
+  // Each ring's people by who they hang off, in the ring's order.
+  const byParent = rings.map((ring) => {
+    const m = new Map();
+    for (const p of ring.people) {
+      if (!m.has(p.parentId)) m.set(p.parentId, []);
+      m.get(p.parentId).push(p);
+    }
+    return m;
+  });
+  const kidsOf = (k, id) => byParent[k + 1]?.get(id) || [];
+
+  // Weights, outermost ring first: at least 1, else what hangs off them.
+  const weight = new Map();
+  for (let k = R - 1; k >= 0; k--) {
+    for (const p of rings[k].people) {
+      const w = p.state === 'connected' ? kidsOf(k, p.row.id).reduce((s, c) => s + weight.get(c), 0) : 0;
+      weight.set(p, Math.max(1, w));
+    }
+  }
+
+  const out = [];
+  const spokes = [];
+  const span = new Map();   // row id → [start, end] angle for its children
+  const START = -Math.PI / 2;
+  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);
+    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);
+      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);
+        items.push({ ...p, angle, x, y });
+        if (p.state === 'connected') span.set(p.row.id, [a, a + w]);
+        a += w;
+      }
+    }
+    // A line from each person you added out to the middle of their own circle.
+    if (k + 1 < R) {
+      const nextR = radiusOf(k + 1);
+      for (const it of items) {
+        if (it.state !== 'connected' || !kidsOf(k, it.row.id).length) continue;
+        const [s, e] = span.get(it.row.id);
+        const mid = (s + e) / 2;
+        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 });
+  }
+  return { size, center: { x: half, y: half }, rings: out, spokes };
+}

package/.next/standalone/lib/companies.js

@@ -85,7 +85,7 @@ export const isSenior = (headline) => getSeniority(headline).level >= 4;
  * A company's industry is the one scoring uses (lib/scoring.js
  * networkCompanies over the same rows): the curated list's, else the name's,
  * else what most of its people say. So a company's colour here is the sector
- * Settings → Your sector leans on, and each company is the one scoring
+ * Scores → Your sector leans on, and each company is the one scoring
  * scores: both name it with cleanCompany().
  */
 export function buildCompanyIndex(rows = []) {

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

@@ -1,4 +1,5 @@
-import { scorePerson } from './scoring.js';
+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
@@ -49,6 +50,20 @@ export function scoreRecord(headline, company) {
   return { seniority_score: s.title.points, company_prestige_score: s.companyScore, power_score: s.power, tier: s.tier };
 }
 
+/**
+ * Tiers for a whole import, graded on its own curve (lib/scoring.js CURVE):
+ * a CSV import uses the app's defaults, never your settings (no company
+ * scores, no sector), and the curve is the default, so the first look at any
+ * export has a top. Scores → Tiers says so while one is open. Run on the
+ * parse (the import page's counts) and on every load (the tab keeps only
+ * what the export says, packConnections), so the two always agree.
+ */
+function gradeOnCurve(connections) {
+  const cut = curveCutoffs(connections.map((c) => c.power_score));
+  for (const c of connections) c.tier = curvedTier(c.power_score, cut);
+  return connections;
+}
+
 // Stable id from the profile URL so re-importing keeps node identity.
 function hashId(input) {
   let h = 5381;
@@ -122,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 }));
   }
@@ -138,7 +150,7 @@ export function parseConnectionsCsv(text) {
     );
   }
 
-  connections.sort((a, b) => b.power_score - a.power_score);
+  gradeOnCurve(connections).sort((a, b) => b.power_score - a.power_score);
   return { connections, skipped, total: connections.length + skipped };
 }
 
@@ -161,8 +173,7 @@ export function packConnections(connections) {
 }
 
 export function unpackConnections(rows = []) {
-  return rows
-    .map(([id, name, role, company, profileUrl, connected_date]) => connectionFrom({ id, name, role, company, profileUrl, connected_date }))
+  return gradeOnCurve(rows.map(([id, name, role, company, profileUrl, connected_date]) => connectionFrom({ id, name, role, company, profileUrl, connected_date })))
     .sort((a, b) => b.power_score - a.power_score);
 }
 

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/db-client.js

@@ -108,6 +108,7 @@ export function applySchema(db) {
 // exists, so columns added after first release are added here, once.
 const ADDED_COLUMNS = [
   ['linkedin_connections', 'score_why', 'TEXT'],
+  ['linkedin_connections', 'mutual_count', 'INTEGER'],
 ];
 
 function addMissingColumns(db) {

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.
@@ -100,3 +107,15 @@ export function refreshNotifications({ added = [], checked = 0, tierOf = () => n
   }
   return out;
 }
+
+/**
+ * LinkedIn's own count of the mutual connections you share with someone, as
+ * the scanner read it off their result card (scripts/scrape.py
+ * BRIDGE_RESULTS_JS), or null. A whole number from 1 (the bridge is always
+ * one) to 30,000 (LinkedIn's cap on connections); anything else is a misread
+ * and is dropped, never stored.
+ */
+export function mutualCountOf(value) {
+  const n = typeof value === 'string' && /^\d[\d,]*$/.test(value.trim()) ? Number(value.replace(/,/g, '')) : value;
+  return Number.isInteger(n) && n >= 1 && n <= 30000 ? n : null;
+}

package/.next/standalone/lib/legacy-offer.js

@@ -1,4 +1,4 @@
-// Paths → Scores: the one-time offer to keep the curated list's old scores as
+// The Scores tab: the one-time offer to keep the curated list's old scores as
 // your own, after the list was made neutral (lib/legacy-scores.js has the old
 // scores and why each changed).
 //
@@ -10,7 +10,7 @@
 // scored on the server, so the page doesn't ask while one is open.
 //
 // Keeping writes the old score under every name scoring uses for the entry's
-// companies, as Paths → Scores sets a score (setCompanyScores), then rescores
+// companies, as the Scores tab sets a score (setCompanyScores), then rescores
 // everyone once for the whole batch. Keep or No thanks, it is never offered
 // again, and an offer whose first look finds nothing to offer closes itself.
 
@@ -62,14 +62,14 @@ export function legacyOfferState(db = getDb()) {
 }
 
 /**
- * What Paths → Scores offers, or null: nothing when the offer isn't open
+ * What the Scores tab offers, or null: nothing when the offer isn't open
  * (never was, or was answered) or no company in the network lost an old score
  * that you haven't replaced with one of your own. That last closes it for
  * good ('none'): the network the old list scored is the one read here, so
- * nothing could turn up later, and every visit to Paths → Scores would
+ * nothing could turn up later, and every visit to the Scores tab would
  * otherwise read the whole network again to find nothing.
  *
- * The companies are the ones Paths → Scores lists, those someone works at now,
+ * The companies are the ones the Scores tab lists, those someone works at now,
  * so a kept score shows there as yours and Auto can hand it back. (A name only
  * in former roles would be a score nothing lists; its people's former role
  * counts at 70% and moves them little.) Each is compared by its built-in score
@@ -116,7 +116,8 @@ export function legacyOffer(db = getDb()) {
       name: o.name,
       was: o.was,
       now: main.now.score,
-      estimated: main.now.source !== 'known',
+      // A score from the curated list or the public dataset is a fact, not an estimate.
+      estimated: !['known', 'data'].includes(main.now.source),
       people: o.people.size,
       names: o.names.map((n) => n.name).sort(),
     };

package/.next/standalone/lib/legacy-scores.js

@@ -1,5 +1,5 @@
 // The curated company list's scores from before it was made neutral, kept for
-// one thing only: the one-time offer on Paths → Scores to keep them as your
+// one thing only: the one-time offer on the Scores tab to keep them as your
 // own (lib/legacy-offer.js). Nothing scores with these. lib/scoring.js never
 // imports this file, and the model must never read it.
 //
@@ -24,7 +24,7 @@
 
 export const LEGACY_SCORES = [
   // Rescored: scored like its peers Pinterest, Reddit and X.
-  ['Snap', 9, /^(snap|snapchat)( inc)?$/, 'media'],
+  ['Snap', 9, /^(snap|snapchat)( inc)?( (specs|spectacles|(mena|emea|apac|latam|north america)( region)?))?$/, 'media'],
   // Removed: private companies that are neither household names nor Fortune
   // 500-sized, and small startups.
   ['Anduril', 9, /^anduril( industries)?$/, 'defense'],