six-degrees 0.4.11 → 0.5.0

package/CHANGELOG.md

@@ -6,6 +6,193 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-02
+
+### Added
+- **Rank titles your way** (Settings → Scores → Titles). Set how much each kind of title counts, out
+  of 10, or start from a preset: Founders first, Investors, or A role I'm looking for. Add the roles
+  you're after ("account executive", "head of growth", "recruiter") with their own points, and
+  everyone whose title has those words rises, whatever their level: for outbound to one role, or
+  hiring for it. Saving rescores everyone and says how many people changed tier, and a card's score
+  says "your ranking" where it moved a title. Nothing set scores exactly as before.
+
+### Changed
+- **The Scan page is a launch, not a manual.** It opens with what the scanner is and what it never does
+  (never posts or messages anyone, never sees your password, nothing leaves this Mac, stops when you
+  say), then the four steps on a rail: Get ready, Sign in, Who you know, Who they know. The one
+  you're on pulses, with one big button that does it and how long it takes; any other opens with a
+  tap. While it runs, "Your scanner is working" and Stop sit right under the step. How many people
+  this round and who first are beside the radar; the daily budget, how much of each list, the hidden
+  window, retrying hidden lists and paused lists are in Fine-tune, closed until you want them. The
+  log is one tap away, and opens by itself when a run stops badly. Scan has the same header as every
+  page now.
+- **Paths reads like Network Circle.** Its notch is now Map and Companies: companies count for more
+  than industries, and an industry opens from a company's card (its industry is a link there). Whether
+  the map's bubbles are companies or your connections (what was the People tab) is a switch at the
+  top of the Filters panel. Filters use the same tiers × degrees grid as Network Circle. Colour is by
+  sector or by **Heat**: for companies, how strong your people there are (the average power of the
+  five strongest); for people, how strong their cluster is, person for person; size still says how
+  many. And **Physics**: switch it to Live to drag bubbles (the ones joined to them follow) and change
+  Spread, Pull to their group and Pull along lines. Still, as before, is the default. Old links to
+  the People or Industries tab still land on the map.
+- **Heat: power as a thermal map.** A new Colour by in Network Circle's Physics: every dot coloured
+  from cold violet through red and orange to white hot by where their power score ranks among the
+  people showing, with a soft glow behind the hotter ones that pools where powerful people cluster,
+  like a thermal camera. Works with every layout, the replay and the filter grid.
+- **Separation all the way right counts every mutual, scanned or not.** It aims at whoever you share
+  the most mutual connections with, even when most of them are in circles you haven't scanned: an
+  unscanned mutual is still a likely introduction, so it no longer holds someone back. The ones the
+  app can draw are lines as before; the rest are grey dots, each with a faint line in, with "+37 more
+  mutuals, in circles not scanned yet". The person glows less the less of it is scanned. The Next
+  names are in the same order and say their mutual counts. Narrow the tiers (S only, say) first to
+  aim at the strongest.
+- **The right panel follows the circle you're in.** Open someone's circle in Bridge Chains and the
+  panel is about them: how many people are in their circle, tier chips to see just one tier, a
+  search inside it, the people you added from it (with Scan… for the ones ready), then everyone
+  else in it, strongest first. Click anyone for their card.
+- **Orbit is a layout of the Galaxy now**, in Physics next to Rings and Clusters, not a separate
+  view: every tier held on its own orbit, S nearest you, and each connection's circle tucked in
+  behind them. It's still the Galaxy, so you can drag dots and move every slider on it.
+- **Light up a branch on hover starts off.** It dimmed and relit thousands of dots on every hover,
+  which flickered; it's still in Physics if you want it, and moving from one dot to the next no
+  longer flashes the whole Galaxy in between.
+- **Social is part of Outlink.** Outlink has the same header as every page, and its views sit in
+  the notch: Circles, To add, Pending, and Messages & follow-ups, which is the whole Social tab (your
+  LinkedIn export, the live messages sync, the CRM with its inbox, follow-ups, pipeline, sent and
+  received). Adding people and keeping track of them are now one place. The Social tab is gone from
+  the header, and old links to it land on Messages & follow-ups.
+- **Notifications open.** Click one and it takes over the right panel with the detail: who it is
+  about, their tier and score, who you met them through, and, for an S or A, that they're a
+  valuable person to know; with buttons to open their card, their circle in Bridge Chains, or
+  them in Separation. A notification naming several people lists them all.
+- **New notifications:** someone you met through a bridge added you back ("Ana added you back,
+  through Yuki"); a circle scan found people at top companies (a company score of 8 or more), named
+  in one notification; and a scan finished ("Scan done: Yuki's circle", "Check for new: done").
+  Accepted requests and high-value new connections now say who they are about, and older ones are
+  matched by the name in their title.
+- **Paths has the same header as the map.** The app's tabs stay at the top, with Paths lit, and Map,
+  People, Industries and Companies sit in the notch under them, as the map page's views do; a tab
+  for Network Circle, Degrees or Separation takes you straight to it. Paths' filters moved into a
+  Filters panel on the left, like the map page's, with new ways to read the map: what a bubble's
+  size means (your people there, the S and A among them, or the ones you already know; on People,
+  cluster value, size or S tier) and which names show (the biggest, all, or none).
+- **All the way to easy, Separation aims at whoever the most of your connections lead to**, with
+  every one of those lines drawn, the strongest first among equals; the "Next" names are the
+  runners-up by the same measure. It used to aim at the top of the list, which could be someone
+  with many mutual connections by LinkedIn's count but only one the app could draw.
+- **The Scan page has a radar, and a speed: Slow, Medium or Fast.** Mapping the 2nd degree starts
+  from a round Scan button in the middle of a radar: its sweep turns while a scan runs, and the
+  ring round it fills with today's searches against your budget. Beside it, three speeds. Fast is
+  how the scanner has always run, and nothing is faster; Medium waits 45 seconds before each page
+  of results and 3 minutes after every 10, Slow 90 seconds and 5 minutes, and both keep profiles
+  further apart (90 and 120 seconds). Each says about how many searches an hour it makes and how
+  long the rest of today's budget would take. The daily budget stays the cap at every speed:
+  slower spreads it out, it doesn't shrink it. The speed is saved with the budget and the scanner
+  says which it is using at the start of every run; the Scan page's time estimates follow it.
+- **Scores moved into Settings.** Your field, how tiers are graded and every company's score are a
+  Scores section in Settings (the gear), and the Scores tab is gone from the header. Old links to
+  the Scores tab land in the same place in Settings.
+- **Profile has Insights.** An Insights button beside Profile shows network health: how much of
+  your 2nd degree you reach two or more ways, the effective reach of your connections, and the
+  connections who reach the most people no one else does. It was at the top of the Scores tab.
+- **Paths → People.** A new view beside the company map, drawn the same way but with your
+  connections as the bubbles: each is sized by the value of the cluster behind them (S tier counts
+  3, A tier 2, everyone else 1; or by cluster size, or by S tier inside), coloured by their sector
+  and grouped like the companies. A white centre is the share of their cluster you can only reach
+  through them, a gold ring means S-tier people inside, and a line joins two connections whose
+  clusters share people. Point at someone for their numbers and how their cluster compares to the
+  rest you've scanned; click to open it in Bridge Chains. Shows the connections you've scanned,
+  or all of them, with the ones not scanned yet as small grey dots.
+- **Separation's map draws connections as pills and people as cards** on a computer (a phone keeps
+  the dots). Each connection shows their initials, tier and what they are to the people on the
+  map: the only door to someone, the best way in for some, or only another way in; the ones with
+  a solid line are lit. Each person is a card with rank, role, score and how many ways in. With
+  the slider all the way to easy, the one person becomes a large card with LinkedIn's mutual
+  count and how many of those are drawn. Everything still glides as the slider moves.
+- **Separation's list is a ledger.** A title bar says how many are shown and that the order
+  follows the slider. The way in shows the connection's face with "only way in" or how many more
+  ways there are under it, a new column shows how rare the way in is as a bar (full and cyan for
+  one door, short and orange for the warmest), and the power score sits beside its bar.
+- **Separation is a tab of its own**, beside Degrees in the header, instead of a view inside
+  Degrees. It uses the same Filters grid as Degrees. Degrees keeps Bridge Chains, Pyramid and List.
+- **Separation has a slider.** One slider reorders everyone as you drag it: the rarest ways in
+  at one end (strong people only one of your connections knows), the easiest at the other
+  (strong people you share the most mutual connections with), and each person's own score alone
+  in the middle, as the list has always been. A line under it says in words what it is
+  surfacing. It only reorders: scores, tiers and ranks stay as they are, and it claims no odds.
+  Double-click the slider, or tap 50, to go back to the middle. It replaces the Power / Ways in
+  switch. The tier chips and the rarity chips ("Only show") sit in the same card.
+- **Separation's map follows the slider, and glides.** From the rare end to the middle it fans out
+  to ten people, each with the one or two doors that lead to them. Towards the easy end it
+  closes in on fewer people, and at the end on one: the person you're aiming at, with rings
+  round them and every connection of yours who leads to them drawn in, the top-scored one solid.
+  As the slider moves, people, connections and lines slide to their new places and newcomers
+  fade in (still, with Reduce Motion on). Pick anyone in the list, or one of the "Next" names
+  under the map, to aim at them instead. Beside each name it says how many mutual connections
+  lead to them: "only way in", "3 ways in", or, where LinkedIn's own count is higher than the
+  connections the app can draw, "37 mutuals · 6 mapped".
+- **Path, in Separation.** A Path button beside the tier chips narrows everyone to one sector or
+  one company. The picker opens under the button with the sectors (inferred, as in Paths), the
+  biggest companies and a box to type in, and goes away once you've picked; the button then
+  shows your pick with a × to clear it.
+- **Separation's heading no longer sits under the notch.**
+- **One filter for tiers and degrees, the same in Network Circle and in Degrees.** The Filters
+  panel shows the five tiers as bigger rows, each with six dots, one for each degree. Tap a tier
+  to hide or show it, as before. Tap a dot to show or hide that degree for that tier alone:
+  S tier at 2nd degree without everyone else's, say. Tap a number at the top to switch a degree
+  for every tier at once. A dot with nobody behind it is faint and can't be tapped, each row
+  says how many people it is showing, and the last people on screen can't be switched off.
+  Network Circle starts with your own connections; Degrees starts with everything. In Degrees
+  the rows used to pick one bridge tier at a time; now 1st degree is your bridges and 2nd is
+  the people in their circles, each by their own tier.
+- **The Galaxy's physics is the main thing in Network Circle's Filters panel.** The sliders,
+  layouts, colours, find and replay sit straight in the panel under the tiers, always on, with
+  no switch to turn on first and no "experimental" box. With no slider moved the Galaxy is laid
+  out as before; pointing at a dot now lights up its branch unless you turn that off.
+- **Pyramid and List left Network Circle.** Its views are the Galaxy and Orbit. Pyramid and List
+  stay in Degrees.
+- **An opened circle shows the chains that lead on from it.** Anyone you added from that circle
+  and then scanned keeps their dot in the circle, and the cluster their scan formed sits outside
+  it, joined to that dot by a line, so you can see where each path came from. Inside a cluster,
+  anyone you added and scanned in turn has their own dot marked and a line on to their cluster,
+  for as far as your scans reach. Every dot in a cluster is joined to its middle by a faint line.
+  Each cluster says whose circle it is, how many are in it and which degree that is. Point at
+  one and the way back to the middle lights up; click and it opens with the whole trail. The
+  people you added sit together on the side the chains lead off to, their names taking turns
+  above and below so they don't overlap, and the view zooms to fit when it opens.
+- **Bridge Chains shows the bridges you connected with yourself.** Someone you met through a
+  bridge's circle is a link in that bridge's chain, not a bridge of their own: they're inside its
+  circle.
+- **A bridge's ring now counts the people you added through it.** The ring sits tight on the
+  dot, with one bar for each person: orange once they've been scanned and have a cluster of
+  their own, green while they're ready for a scan. A small green number at the top right says
+  how many are ready, in place of the "ready" label. How much of a bridge's own list is scanned
+  is in its tooltip.
+- **A crowded Bridge Chains is easier to read.** When your bridges need more than one ring, the
+  rings sit further apart, each with its own guide line, and the counts under each name wait
+  until you point at the bridge.
+- **Orbit moved to Network Circle.** It shows the size of every circle at once, which is a
+  picture of the network, not a way to follow a chain. The corner switch in Degrees is gone.
+- **Views are in the notch, under the tabs.** Galaxy, Orbit, Pyramid and List in Network Circle,
+  and Bridge Chains, Separation, Pyramid and List in Degrees, switch from the notch that hangs
+  under the top tabs, instead of a list at the top of the Filters panel. A scan's progress
+  shows in the same notch, beside them. The Filters panel now only filters.
+
+### Fixed
+- The scanner's log, shown on the Scan page, says "scanning" throughout; a few lines still said the
+  old word.
+- The "Scanning…" dot in the right panel pulses again; the animation it named was never defined.
+- **Separation's map lines now meet every box.** Each connection sits level with the people it
+  leads to, so a connection with one person is on that person's row and the line between them runs
+  straight; lines start and end exactly on the pill and the card, with a small dot where they plug in.
+- **"Hide the Chrome window while scanning" did nothing for scans started on the Scan page.**
+  Its own buttons (Scan, Check for new, Auto scan and the rest) sent their request without the
+  setting, so Chrome opened anyway; only scans started from a person's card or Resume were hidden.
+  Every scan start now goes through one place that adds it.
+- **"Only way in" could show beside someone with two ways in drawn.** Rarity trusted the mutual
+  count a scan saved even when the app had since found them through more of your connections
+  than that. It now takes whichever is larger.
+
 ## [0.4.11] - 2026-09-29
 
 ### Added

package/lib/chain-layout.js

@@ -17,19 +17,19 @@ function capacity(radius, spacing, sweep) {
   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) {
+/** The rings from `inner` outwards, `gap` apart (at least `spacing`), until `n` dots fit. */
+function ringsFor(n, inner, spacing, sweep, gap = spacing) {
   const radii = [];
   let room = 0;
-  for (let r = inner; room < n; r += spacing) {
+  for (let r = inner; room < n; r += Math.max(spacing, gap)) {
     radii.push(r);
     room += capacity(r, spacing, sweep);
   }
   return radii;
 }
 
-const outerOf = (n, inner, spacing, sweep) => {
-  const radii = ringsFor(n, inner, spacing, sweep);
+const outerOf = (n, inner, spacing, sweep, gap) => {
+  const radii = ringsFor(n, inner, spacing, sweep, gap);
   return radii[radii.length - 1];
 };
 
@@ -46,43 +46,44 @@ const outerOf = (n, inner, spacing, sweep) => {
  * 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.
+ * its middle outwards. `ringGap` keeps the rings at least that far apart, for
+ * dots that carry a name under them and need the room.
  *
  * @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,
+  start = -Math.PI / 2, sweep = TAU, ringGap = 0,
 } = {}) {
   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) {
+  if (outerOf(count, r0, s, sweep, ringGap) > outer) {
     // Start further in, as far as innerMin, before closing anything up.
-    if (outerOf(count, innerMin, s, sweep) <= outer) {
+    if (outerOf(count, innerMin, s, sweep, ringGap) <= 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;
+        if (outerOf(count, mid, s, sweep, ringGap) <= outer) lo = mid; else hi = mid;
       }
       r0 = lo;
     } else {
       r0 = innerMin;
       let lo = minSpacing, hi = spacing;
-      if (outerOf(count, r0, lo, sweep) <= outer) {
+      if (outerOf(count, r0, lo, sweep, ringGap) <= 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;
+          if (outerOf(count, r0, mid, sweep, ringGap) <= outer) lo = mid; else hi = mid;
         }
       }
       s = lo;
     }
   }
 
-  const radii = ringsFor(count, r0, s, sweep);
+  const radii = ringsFor(count, r0, s, sweep, ringGap);
   const caps = radii.map((r) => capacity(r, s, sweep));
   const room = caps.reduce((a, b) => a + b, 0);
 
@@ -162,8 +163,9 @@ const TIER_BANDS = ['S', 'A', 'B', 'C', 'D'];
  *
  * @returns {{ spacing: number, edge: number, bands: { tier: string, inner: number, outer: number }[],
  *   points: { x: number, y: number, angle: number, slot: number }[] }}
+ * `start` is the angle each ring's first dot sits at (the top, unless told).
  */
-export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing }) {
+export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing, start = -Math.PI / 2 }) {
   const groups = TIER_BANDS.map((tier) => ({ tier, idx: [] }));
   rows.forEach((row, i) => {
     const t = TIER_BANDS.indexOf(row?.tier);
@@ -175,7 +177,7 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
     const bands = [];
     let r = inner;
     for (const g of used) {
-      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s });
+      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s, start });
       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 };
@@ -201,28 +203,96 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
 }
 
 /**
- * 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.
+ * The chains that lead on from an opened circle (Blake, 2026-10-02: "once they
+ * are clicked on and can view the cluster i want any scanned d2,3,4 or whatever
+ * to be show inside with lines out of the d1 leading to the d2s").
  *
- * @param {{ angle: number, slot: number, count: number }[]} anchors
- * @returns {({ points: { x: number, y: number }[], more: number } | null)[]}
+ * `parents[i]` is the index of the link that introduced link i, or -1 when the
+ * person in the middle did. The links one step on sit on a ring at `from`, each
+ * as near its own angle in `angles` as it can get (where that person's dot is
+ * in the circle), or fanned about `toward` without one; each later step sits `hop` further out,
+ * as near the angle of the link it came from as it can get without touching a
+ * neighbour on its own ring (`spacing` apart). So a chain reads outwards from
+ * the middle: the bridge, someone met through them, someone met through *them*.
+ *
+ * @param {number[]} parents
+ * @returns {{ rings: { radius: number, count: number, depth: number }[],
+ *   points: { x: number, y: number, angle: number, radius: number, depth: number, parent: number }[] }}
  */
-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,
+export function chainTree(parents = [], { from = 0, hop = 60, spacing = 46, toward = 0, angles = [] } = {}) {
+  const n = parents.length;
+  const parent = parents.map((p, i) => (Number.isInteger(p) && p >= 0 && p < n && p !== i ? p : -1));
+
+  // How many steps out each one is. A loop (it shouldn't happen) is cut where
+  // it closes, so everyone still gets a place.
+  const depth = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    const trail = [];
+    let k = i;
+    while (k >= 0 && !depth[k] && !trail.includes(k)) { trail.push(k); k = parent[k]; }
+    if (k >= 0 && !depth[k]) { parent[trail[trail.length - 1]] = -1; k = -1; }
+    let d = k >= 0 ? depth[k] + 1 : 1;
+    for (let j = trail.length - 1; j >= 0; j--) depth[trail[j]] = d++;
+  }
+
+  const points = new Array(n);
+  const rings = [];
+  for (let d = 1; d <= Math.max(0, ...depth); d++) {
+    const here = [];
+    for (let i = 0; i < n; i++) if (depth[i] === d) here.push(i);
+    const radius = from + (d - 1) * hop;
+    const placed = spread(here.map((i) => (parent[i] < 0 ? (Number.isFinite(angles[i]) ? angles[i] : toward) : points[parent[i]].angle)),
+      Math.min(spacing / Math.max(1, radius), TAU / here.length));
+    here.forEach((i, j) => {
+      const angle = placed[j];
+      points[i] = { x: radius * Math.cos(angle), y: radius * Math.sin(angle), angle, radius, depth: d, parent: parent[i] };
     });
-    return { points: l.points.map(({ x, y }) => ({ x, y })), more: a.count - n };
+    rings.push({ radius, count: here.length, depth: d });
+  }
+  return { rings, points };
+}
+
+/**
+ * Angles as near the ones asked for as they can be while staying `sep` apart:
+ * neighbours that would touch move apart by the same amount each way, so two
+ * people met through the same person sit either side of them. Comes back in
+ * the order given.
+ */
+function spread(wanted, sep) {
+  const m = wanted.length;
+  if (m < 2) return wanted.slice();
+  const turn = (a) => ((a % TAU) + TAU) % TAU;
+  const order = wanted.map((a, i) => i).sort((i, j) => turn(wanted[i]) - turn(wanted[j]) || i - j);
+  // Start counting just after the widest empty stretch, so no group straddles the join.
+  let cut = 0;
+  let widest = -1;
+  order.forEach((i, k) => {
+    const next = order[(k + 1) % m];
+    const gap = turn(turn(wanted[next]) - turn(wanted[i])) || (m > 1 && k === m - 1 ? TAU : 0);
+    if (gap > widest) { widest = gap; cut = (k + 1) % m; }
   });
+  const seq = order.slice(cut).concat(order.slice(0, cut));
+  const first = turn(wanted[seq[0]]);
+  const at = seq.map((i) => first + turn(turn(wanted[i]) - first));
+
+  // Least movement that keeps them `sep` apart: take the spacing out, pool any
+  // neighbours left out of order to their average, put the spacing back.
+  const blocks = [];
+  at.forEach((a, k) => {
+    blocks.push({ sum: a - k * sep, count: 1 });
+    while (blocks.length > 1 && blocks[blocks.length - 2].sum / blocks[blocks.length - 2].count > blocks[blocks.length - 1].sum / blocks[blocks.length - 1].count) {
+      const last = blocks.pop();
+      blocks[blocks.length - 1].sum += last.sum;
+      blocks[blocks.length - 1].count += last.count;
+    }
+  });
+  let placed = blocks.flatMap((b) => new Array(b.count).fill(b.sum / b.count)).map((q, k) => q + k * sep);
+  // Round the join too: if the last has come back round onto the first, share the ring evenly.
+  if (placed[m - 1] - placed[0] > TAU - sep) {
+    const mid = (placed[0] + placed[m - 1]) / 2;
+    placed = placed.map((_, k) => mid + (k - (m - 1) / 2) * (TAU / m));
+  }
+  const out = new Array(m);
+  seq.forEach((i, k) => { out[i] = placed[k]; });
+  return out;
 }

package/lib/degrees.js

@@ -22,9 +22,3 @@ export function peopleByDegree(degree1 = [], degree2 = [], degree3 = []) {
   };
   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/lib/dot-rings.js

@@ -18,4 +18,29 @@ export function ringSegments(r) {
   });
 }
 
+/**
+ * The ring round a bridge in Bridge Chains (Blake, 2026-10-02: "the bars on the
+ * ring should signify how many dots in the clusters are ready to be scanned
+ * and new clusters formed"). One bar for each person you added through that
+ * circle: the ones scanned since, with a cluster of their own (`formed`),
+ * then the ones waiting for a scan (`ready`). Past `max` bars the two kinds
+ * share them in proportion, each keeping at least one.
+ *
+ * @returns {{ d: string, kind: 'formed' | 'ready' }[]}
+ */
+export function reachSegments(r, { formed = 0, ready = 0 } = {}, max = 12) {
+  const total = Math.max(0, formed) + Math.max(0, ready);
+  if (!total) return [];
+  const n = Math.min(total, max);
+  let nFormed = formed > 0 ? Math.max(1, Math.round((n * formed) / total)) : 0;
+  if (ready > 0 && nFormed >= n) nFormed = n - 1;
+  const gap = n === 1 ? 0.5 : Math.min(GAP, ((2 * Math.PI) / n) * 0.35);
+  const span = (2 * Math.PI) / n - gap;
+  const p = (a) => `${(r * Math.cos(a)).toFixed(2)} ${(r * Math.sin(a)).toFixed(2)}`;
+  return Array.from({ length: n }, (_, i) => {
+    const a0 = -Math.PI / 2 + gap / 2 + i * (span + gap);
+    return { kind: i < nFormed ? 'formed' : 'ready', d: `M${p(a0)} A${r} ${r} 0 ${span > Math.PI ? 1 : 0} 1 ${p(a0 + span)}` };
+  });
+}
+
 export const RING = { filled: '#1abc9c', empty: 'rgba(255,255,255,0.16)', badge: '#7F77DD' };

package/lib/galaxy-lab.js

@@ -7,7 +7,7 @@
 // which isn't. Both follow useSyncExternalStore's rules: a snapshot only changes
 // when something in it does.
 
-import { keyFor } from './separation.js';
+import { keyFor, score } from './separation.js';
 import { warmthOf } from './linkedin-export.js';
 
 const KEY = 'six-degrees-galaxy-lab';
@@ -15,7 +15,7 @@ const LAYOUTS_KEY = 'six-degrees-galaxy-layouts';
 
 /** The layout as it has always been. Every slider is a multiple of today's value, or 0 for off. */
 export const LAB_DEFAULTS = Object.freeze({
-  on: false,        // the lab is on: without it, the Galaxy ignores everything below
+  on: true,         // always: the sliders are the Galaxy's own controls now (it was an experimental switch)
   gravity: 0,       // a pull on every dot towards you, in the middle
   rings: 1,         // how hard each tier (or degree) holds its ring; 0 lets it find its own shape
   push: 15,         // how hard dots push each other apart
@@ -25,11 +25,12 @@ export const LAB_DEFAULTS = Object.freeze({
   lines: 1,
   sizeBy: 'power',  // 'power' (power score) or 'reach' (how many hang off them)
   names: 'key',     // 'key' (you, S tier, catalysts) or 'all' (all your connections)
-  branch: true,     // hovering a dot lights up its branch and dims the rest
-  colourBy: 'tier', // 'tier', 'degree', 'company' or 'warmth' (from the Social tab)
+  branch: false,    // hovering a dot lights up its branch and dims the rest: off to start (Blake, 2026-10-02: it glitched)
+  colourBy: 'tier', // 'tier', 'heat' (power as a thermal map), 'degree', 'company' or 'warmth' (from the Social tab)
   speed: 15,        // a replay's length, in seconds
   loop: false,      // start the replay again when it ends
   labels: true,     // names on the Galaxy at all: the Filter panel's switch, honoured with the lab off too
+  v: 2,             // which defaults a saved setting was made under (2: the branch starts off)
 });
 
 /** The slider settings a saved layout keeps (not whether the lab is on, nor the names switch). */
@@ -38,13 +39,33 @@ const LAYOUT_KEYS = ['gravity', 'rings', 'push', 'pull', 'distance', 'dotSize',
 /** Let the layout find its own shape: no rings, each connection's circle bunched round them. */
 export const CLUSTERS = Object.freeze({ gravity: 0.25, rings: 0, push: 25, pull: 2.5, distance: 0.35, sizeBy: 'reach' });
 
+/**
+ * Orbit, the old view, as a layout of the Galaxy (Blake, 2026-10-02: "add that as a
+ * visual option instead so the person can interact with it"): every tier held hard
+ * on its orbit, and each connection's circle drawn in close behind them. It's still
+ * the Galaxy, so dragging and every slider work on it.
+ */
+export const ORBIT = Object.freeze({ gravity: 0, rings: 3, push: 6, pull: 4, distance: 0.22, sizeBy: 'power' });
+
+/** Which layout the sliders are set to: 'rings', 'clusters', 'orbit', or null for your own. */
+export function layoutOf(lab) {
+  const is = (preset) => Object.entries(preset).every(([k, v]) => lab[k] === v);
+  if (['gravity', 'rings', 'push', 'pull', 'distance'].every((k) => lab[k] === LAB_DEFAULTS[k])) return 'rings';
+  if (is(CLUSTERS)) return 'clusters';
+  if (is(ORBIT)) return 'orbit';
+  return null;
+}
+
 const listeners = new Set();
 let cache = null;
 
 function read() {
   try {
     const raw = JSON.parse(localStorage.getItem(KEY) || 'null');
-    return raw && typeof raw === 'object' ? { ...LAB_DEFAULTS, ...raw } : LAB_DEFAULTS;
+    // `on` was a switch once; a setting saved back then mustn't turn the sliders off.
+    // Saved before v2, the branch light-up was on by default; it starts off now.
+    if (!raw || typeof raw !== 'object') return LAB_DEFAULTS;
+    return { ...LAB_DEFAULTS, ...raw, ...(raw.v === LAB_DEFAULTS.v ? {} : { branch: false }), v: LAB_DEFAULTS.v, on: true };
   } catch { return LAB_DEFAULTS; }
 }
 
@@ -54,7 +75,7 @@ export function labNow() {
 }
 
 export function setLab(patch) {
-  cache = patch === null ? { ...LAB_DEFAULTS, on: labNow().on, labels: labNow().labels } : { ...labNow(), ...patch };
+  cache = patch === null ? { ...LAB_DEFAULTS, labels: labNow().labels } : { ...labNow(), ...patch, on: true };
   try { localStorage.setItem(KEY, JSON.stringify(cache)); } catch {}
   listeners.forEach((f) => f());
 }
@@ -249,6 +270,36 @@ const DEGREE_COLOURS = { 1: '#4FC3F7', 2: '#BA68C8', 3: '#FFB74D' };
 const COMPANY_COLOURS = ['#FF6B6B', '#4ECDC4', '#FFD93D', '#A29BFE', '#00B894', '#FD79A8', '#74B9FF', '#E17055'];
 const WARMTH_COLOURS = { warm: '#FF7043', cool: '#4FC3F7', dormant: '#8D6E63', never: '#546E7A' };
 const OTHER = '#4a5568';
+
+// Heat (Blake, 2026-10-02: "a thermal visual of power based on the dots"): a
+// thermal camera's colours, cold violet through red and orange to white hot.
+const HEAT_STOPS = ['#2b1b6b', '#6a1b9a', '#c2185b', '#f4511e', '#ffb300', '#fff3b0'];
+
+/** The thermal colour at `t` (0 cold … 1 hottest). */
+export function heatColour(t) {
+  const x = Math.max(0, Math.min(1, Number(t) || 0)) * (HEAT_STOPS.length - 1);
+  const i = Math.min(HEAT_STOPS.length - 2, Math.floor(x));
+  const f = x - i;
+  const a = HEAT_STOPS[i], b = HEAT_STOPS[i + 1];
+  const mix = (k) => Math.round(parseInt(a.slice(k, k + 2), 16) * (1 - f) + parseInt(b.slice(k, k + 2), 16) * f);
+  return `#${[1, 3, 5].map((k) => mix(k).toString(16).padStart(2, '0')).join('')}`;
+}
+
+/**
+ * Everyone's heat, 0 to 1: where their power score ranks among the people shown,
+ * so the colours spread across whoever is on screen (a network of mostly B tier
+ * still has its hot spots). Equal scores share a heat.
+ */
+export function heatOf(people = []) {
+  return heatBy(people, score);
+}
+
+/** The same for anything with a value: each one's heat, 0 to 1, from where its value ranks. */
+export function heatBy(items = [], valueOf = () => 0) {
+  const values = [...new Set(items.map(valueOf))].sort((a, b) => a - b);
+  const at = new Map(values.map((v, i) => [v, values.length > 1 ? i / (values.length - 1) : 1]));
+  return (d) => at.get(valueOf(d)) ?? 0;
+}
 const companyKey = (c) => String(c || '').trim().toLowerCase();
 
 /**
@@ -280,6 +331,14 @@ export function colourScheme(mode, people, tierColors, social) {
       legend: [...top.map(([, c], i) => [c.name, COMPANY_COLOURS[i]]), ['Other', OTHER]],
     };
   }
+  if (mode === 'heat') {
+    const heat = heatOf(people);
+    return {
+      of: (d) => heatColour(heat(d)),
+      heat,
+      legend: [['Cold', heatColour(0.1)], ['Warm', heatColour(0.45)], ['Hot', heatColour(0.75)], ['Hottest', heatColour(1)]],
+    };
+  }
   if (mode === 'warmth' && social) {
     return {
       of: (d) => ((d.degree || 1) === 1 ? WARMTH_COLOURS[warmthOf(social.merged.get(keyFor(d)), social.asOf)] : '#2d3748'),

package/lib/ingest.js

@@ -103,6 +103,8 @@ export function refreshNotifications({ added = [], checked = 0, tierOf = () => n
     out.push({
       user_id, type: 'new_elite_connection', title: `High-value connection: ${r.name}`,
       message: r.headline?.substring(0, 60), icon: '👑',
+      // Who it is, so the notification can open them (lib/notifications.js noteSubject).
+      data: { profileUrl: r.profile_url },
     });
   }
   return out;

package/lib/island.js

@@ -34,3 +34,43 @@ export function clearActivity(id) {
   activities = activities.filter((x) => x.id !== id);
   listeners.forEach((f) => f());
 }
+
+// The notch's buttons: the views of the page you're on (Bridge Chains,
+// Separation…), or any page's own sub-tabs. A page sets them while it's on
+// screen and clears them when it leaves; the notch draws them under the header's
+// tabs (Blake, 2026-10-02: "the notch… under the ui buttons at top so then we
+// can use that for button selection too").
+//
+//   setNotchTabs({ items: [{ key, label, icon?, title? }], current, onPick })
+//   setNotchTabs(null)
+const tabListeners = new Set();
+let notchTabs = null;
+
+export const notchTabsNow = () => notchTabs;
+export const noNotchTabs = () => null;
+
+export function watchNotchTabs(f) {
+  tabListeners.add(f);
+  return () => tabListeners.delete(f);
+}
+
+// Whether the notch is on screen at all (tabs, a scan, or another job), so a
+// page with a heading at the top can leave room for it only when it's there.
+const shownListeners = new Set();
+let notchShown = false;
+export const notchShownNow = () => notchShown;
+export const noNotch = () => false;
+export function watchNotchShown(f) {
+  shownListeners.add(f);
+  return () => shownListeners.delete(f);
+}
+export function setNotchShown(shown) {
+  if (notchShown === Boolean(shown)) return;
+  notchShown = Boolean(shown);
+  shownListeners.forEach((f) => f());
+}
+
+export function setNotchTabs(tabs) {
+  notchTabs = tabs && Array.isArray(tabs.items) && tabs.items.length > 1 ? tabs : null;
+  tabListeners.forEach((f) => f());
+}