six-degrees 0.4.0-beta.1 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,158 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-09-28
+
+### Added
+- **A cap on profile views.** A circle scan opens the person's profile once, and profile
+  views are what LinkedIn restricted an account for. They now have a cap of their own: 50
+  in any 24 hours by default. The Scan page offers 10, 25, 50 or 100, and there is no "no
+  limit".
+  - **A minute apart:** at least 60 seconds pass between any two profile opens. It's timed
+    from the last one written down, so scans started back to back can't open profiles back
+    to back. The log counts down while it waits, and Stop ends the wait.
+  - **Checked before the profile opens:** at the cap, a scan opens nothing and records
+    nothing about that person. Auto-Bridge stops, as it does at the search budget, and the
+    next run starts with the same person.
+  - **On the Scan page:** "3 of 50 profile views today", with a bar and the picker.
+  - **Re-mapping someone** checks it before deleting their circle. A damaged record counts
+    the day's views as used. An import brings the other computer's setting only when this
+    one has none, like the search budget.
+- **The Scan page asks what field you're in, before your first scan.** One optional step,
+  with the same picks as *Scores → Your sector*: tech, government and defense, dental, and
+  the rest. Companies in your field count for more, so your first scores already use it.
+  *Skip for now* carries on without one. Both stay at the bottom of the window while you
+  look through the list. It's asked once, and never if you already have a network or picked
+  a sector. Change it anytime on the Scores tab.
+- **Bridge Chains opens any circle, as far as your scans reach.** Click someone in a
+  bridge's circle and their own circle opens in place: the people found in it once you
+  connected and scanned it (3rd degree, counted along the chain), and on from there. A
+  trail at the top, and Esc, go back. An empty circle says why and what gets it: connect,
+  then scan their circle. While one is being scanned, it fills in as the scan saves.
+  Someone ready for a scan goes to the Scan page with them picked instead, since their
+  circle is empty until then.
+- **A soft glow on people ready for a scan.** In Bridge Chains, someone you added through
+  a circle whose own circle isn't scanned yet has a soft breathing halo, and their bridge
+  says how many are "ready". A hidden list is greyed with a lock instead. The halo stays
+  still with Reduce Motion on. The old rainbow glow is gone: it looked for them inside the
+  circle they came from, which accepting takes them out of, so it never showed.
+- **Ready to scan (N), in the Degrees panel.** It replaces *Auto-Bridge Next*, which
+  started a scan in one click, by name, with no cost shown, and offered hidden lists again
+  and again. The list is everyone you added through a circle whose circle can be scanned,
+  strongest first, with the circle you found them in and what a scan costs. Hidden lists
+  stay in view, greyed with a lock.
+- **Scan one circle, on the Scan page.** A ready person, from the list or Bridge Chains,
+  opens the Scan page with them picked: the cost (a profile view, then a search a page, up
+  to 100), what's left of the day's budget, how deep to read, and a button. Nothing starts
+  until it's pressed.
+- **A release checks the website's version lines.** Before building anything, the release
+  workflow runs `scripts/check-site-version.mjs`: the site's `softwareVersion` and
+  `llms.txt` must name the version, and its `dateModified` and sitemap `lastmod` can't be
+  older than the release's date in the changelog. A stale site stops the release with a
+  line for each thing to change. A pre-release skips it. Anyone can run it before tagging.
+
+### Changed
+- **A big circle spreads out.** A bridge's circle used to sit on one ring, so a few hundred
+  people were almost a solid line. It now fills rings from the inside out, as many as it
+  needs, with the highest tiers nearest the middle; drag to move, scroll or +/− to zoom.
+  Lots of bridges spread the same way, and so does the preview on hover.
+- **The map picks up a finished scan by itself.** No refresh needed.
+- **One rule for "ready".** Bridge Chains, the Degrees panel, Outlink's new doors and the
+  profile page's mapping bar now agree on who can be scanned next, and all leave hidden
+  lists out.
+- **Photos stay on your Mac.** The app shows a profile photo only from the copy saved on
+  your computer, so looking at your network never contacts LinkedIn. It used to load a
+  photo from LinkedIn until a scan had saved it, and a rescan could put LinkedIn's link
+  back in place of a saved photo. Every page now also tells the browser to load pictures
+  from the app alone, and the scanner fetches photos from LinkedIn's image servers only.
+- **Photos an older version kept as links are saved once.** Until then those people show
+  initials. The next scan saves them at its end, or *Save photos* on the Scan page does it
+  now, without opening a browser. A link more than a few weeks old has expired: that
+  person's photo comes back when they're next scanned. Offline, or with LinkedIn's image
+  server busy, nothing is forgotten, and *Save photos* stops and says why.
+- **Government and military titles are read.** A senator, a governor, a mayor and a cabinet
+  secretary score like a C-suite; their deputies, state legislators, commissioners,
+  ambassadors and judges like a VP; a city councilmember or a sheriff like a director.
+  Officers by rank: a 3–4 star general or admiral 10, a 1–2 star 9, a colonel 7.5, a
+  lieutenant colonel 6.5, a major 5, and a commander by their unit. "(Ret.)" and
+  "Retired" make a role former. They count only where a title is written, and only where
+  their own organization is a government's or a service's: a staffer in an Office of the
+  Secretary, a veteran's civilian job, a city manager at Uber, a Rotary district governor,
+  a team captain or a Kentucky colonel isn't one. A title that doesn't say whose it is
+  ("Mayor", "Police Chief", "Ambassador") needs its government named, or stays "Title
+  unclear": a missed official is a neutral 4, a realtor read as a mayor would be an A.
+  Until now all of them were "Title unclear" (a U.S. senator scored 2.9, C).
+- **One name: Six Degrees.** The header, the welcome screen, the loading and launch pages,
+  the side panel and the Terminal installer said "6 Degrees". They now say Six Degrees, as
+  the window title and the app in Applications already did.
+- **Contributor docs and `.gitignore`.** CONTRIBUTING says npm releases go out through
+  trusted publishing, with no token to set, and that `npm run build:desktop` builds the app
+  releases ship (`build:app` is the old launcher). `.gitignore` keeps a LinkedIn export, a
+  database, a saved copy of a network and the scanner's signed-in browser profile out of a
+  commit, wherever they sit in the tree. A local build keeps them out of the app too, and
+  its list of uncommitted files inside the app now names ignored ones as well.
+- **0.4.0-beta.1, promoted: this is now the Mac app and npm package everyone gets.** It adds:
+  - **Their circle, on every card,** with rarity beside the tier and LinkedIn's own mutual count.
+  - **One scan at a time,** and *Resume* beside *Rescan*.
+  - **Tiers on your own network's curve,** with unknown companies at a neutral 5.
+  - **631 public organizations** the built-in list leaves off, and **scoring 6.**
+  - **Scores, a tab of its own.**
+
+  The details are under 0.4.0-beta.1 below.
+- **The download page** says what's new in 0.4.0.
+- **Degrees' corner toggle says Orbit, which is what it shows.** It said "Galaxy", but
+  the Galaxy is a Network Circle view, so Degrees fell back to Orbit. It switches
+  between Orbit and Bridge Chains, and it's on whenever Orbit is showing.
+
+### Removed
+- **About 630 lines of Galaxy code that never ran:** a Degrees drawing from before Orbit
+  and Bridge Chains. Nothing could open it. The Galaxy draws Network Circle only.
+
+### Fixed
+- **A one-person scan notes a hidden list.** A card's Scan or Rescan that found someone's
+  list hidden said so and noted nothing, so they stayed "not scanned yet" and were offered
+  again forever. Only a batch noted it. Now every read from page 1 does.
+- **A scan reads the list of the person you picked.** A card's Scan and Rescan went by
+  name, so with two connections of the same name the scanner could read the other one's
+  list. Every Scan button now goes by that person's profile, as Resume already did.
+- **A company's name after "at" is no longer read as a title.** "Server at President Hotel"
+  scored as a C-suite (7.3, A), and so did an IT specialist in an "Office of the Chief
+  Information Officer". "Executive Assistant to the General Manager" scored as a VP.
+- **↻ asks before it scans.** The round button in the header started *Check for new* the
+  moment it was clicked. It now says what it will do (open Chrome on your connections list
+  and read it until it reaches people already saved) and what it costs (no search budget,
+  but it is LinkedIn traffic from your account), and waits for OK.
+- **No Scan buttons on the sample or a CSV import.** Every card there offered a scan of
+  that person's circle, and Degrees offered *Auto-Bridge Next*, but both networks live
+  only in the window, so the scan could only fail ("Bridge '…' not found in database").
+  In their place a line says scanning needs your own network.
+- **A CSV import's dates are the day LinkedIn says.** Anywhere east of London, each "Connected
+  On" date landed a day early (28 Sep 2026 became 27 Sep). The import now reads it as the
+  calendar date it is, the way a scan already did, and a date it can't read is left blank
+  rather than guessed.
+- **Opening a panel no longer rebuilds the Galaxy.** Opening or closing the side panel or
+  the Filter panel used to draw the Galaxy again from scratch: the layout started over,
+  the selection ring vanished, and a big network stalled the page. Now the view slides
+  over at the same zoom, so what was in the middle stays in the middle.
+- **The selection ring stays on the person you picked.** It is tied to their dot, and it
+  comes back after a tier filter that still shows them. It used to follow the first dot
+  it found near its old spot, which could be someone else, even You. *Back to list*
+  clears it.
+- **The selection ring pulses gently, as it was always meant to.** Its animation had only
+  ever been written in code that never ran. With Reduce Motion on, it holds still.
+- **Hovering a dot eases it up to 1.5 times its size,** instead of jumping. With Reduce
+  Motion on, it still changes at once.
+- **The Galaxy draws faster on a big network.** Colouring its lines searched every person
+  for every line: about 1.4 s at 30,000 people, on every draw. It now takes under a
+  millisecond.
+- **The main screen no longer stalls when nothing is selected on a big network.** The
+  side panel's Power Rankings counted every tier again for each person in the list, even
+  with the panel closed. At 30,000 people that took about 20 s each time the screen
+  redrew, opening the Filter panel included.
+- **On a laptop, the Galaxy keeps its usual layout with a panel open.** Its fixed phone
+  layout used to switch on whenever the graph was under 768 pixels wide, which a tier
+  filter picked with a panel open could do. It now follows the window, as the page does.
+
 ## [0.4.0-beta.1] - 2026-09-28 (beta: a pre-release, never installed automatically)
 
 ### Added

package/README.md

@@ -123,8 +123,7 @@ whose own circles reach the furthest, and the shortest chain from you to a stran
 worth meeting.
 
 It's a Mac app (or `npx six-degrees` on Linux). It runs on your computer, against your own data, with no account and
-no server. (Inside the app the logo reads *6 Degrees*; in Applications it's **Six
-Degrees**.)
+no server.
 
 ## Before you scan LinkedIn
 
@@ -137,8 +136,9 @@ Degrees**.)
 > - Search was blocked after results were read too fast (2026-09-24).
 >
 > The scanner now reads slowly and keeps to a search budget (by default 50 a day and 250
-> a month; you can change it on the Scan page). It locks itself during a cooldown, and
-> stops at the first sign of push-back. The risk is still yours.
+> a month) and a cap on profile views (50 a day, at least a minute apart). You can change
+> both on the Scan page. It locks itself during a cooldown, and stops at the first sign of
+> push-back. The risk is still yours.
 >
 > **The CSV import and the sample network carry no LinkedIn risk at all.** Details:
 > [how scanning works and what it risks](docs/SCRAPING.md).
@@ -147,12 +147,13 @@ Degrees**.)
 
 The app opens on a welcome screen with three ways in, and asks nothing about you:
 
-- **Scan my LinkedIn**: a guided page that ticks each step off as it goes. It sets up
-  the scanner in one click, you sign into LinkedIn yourself in a Chrome window, and then
-  it scans. Needs Google Chrome. The Mac app brings its own Python; with `npx six-degrees`
-  the page uses yours, or sets up a private one with a click. It checks and says what's
-  missing. The app marks this *Recommended* because it's the only way to Degrees and
-  Outlink. Read the warning above first.
+- **Scan my LinkedIn**: a guided page that ticks each step off as it goes. It first asks
+  one optional question, what field you're in (see *Your sector* below), and *Skip for
+  now* is fine. Then it sets up the scanner in one click, you sign into LinkedIn yourself
+  in a Chrome window, and then it scans. Needs Google Chrome. The Mac app brings its own
+  Python; with `npx six-degrees` the page uses yours, or sets up a private one with a
+  click. It checks and says what's missing. The app marks this *Recommended* because
+  it's the only way to Degrees and Outlink. Read the warning above first.
 - **Import my LinkedIn CSV**: LinkedIn's official export, read on your machine. On
   LinkedIn: **Settings & Privacy → Data privacy → Get a copy of your data →
   Connections**. LinkedIn emails a link in about ten minutes; unzip it and drop
@@ -225,7 +226,9 @@ tiers, on the fixed scale:                     S ≥ 7.5   A ≥ 5.5   B ≥ 4.0
 
 - **Title (1–10)** comes from someone's roles in their headline, with former roles at
   70%; current students are capped. Academics have their own ladder (an assistant
-  professor 5 up to a dean 9), an audience of their own counts like a title (100K+
+  professor 5 up to a dean 9), and so do government and the services (a city
+  councilmember or a colonel 7.5 up to a senator or a four-star general 10), read only
+  where a title is written. An audience of their own counts like a title (100K+
   followers 6.5, 1M+ 7.5, 10M+ 9), and a title it can't read counts as an individual
   contributor's (4).
 - **Company score (1–10)** is the one you set (the Scores tab) if there is one. Otherwise
@@ -246,8 +249,9 @@ tiers, on the fixed scale:                     S ≥ 7.5   A ≥ 5.5   B ≥ 4.0
   people you know there, where a job every kind of company has (recruiter, accountant,
   software engineer) doesn't count. An industry includes its sectors, and a company's one
   industry when the known list or the company's name gives it, not when only its people's
-  job titles do. Settings suggests the sectors your network is in and shows what would
-  change before you save.
+  job titles do. Scores suggests the sectors your network is in and shows what would
+  change before you save. The Scan page asks for it once, before your first scan, so your
+  first scores already use it; you can skip it and pick later.
 - Multiplying means seniority counts for more at a bigger company. A VP at a company
   scored 10 gets 9.0; a founder at an unknown company, 7.3.
 - **Reach bonus (up to 1.5)**: investor, YC, an audience in the millions, the top award
@@ -277,8 +281,10 @@ It estimates **network position**, not what anyone is worth as a person.
 - A CSV import is read on your machine and never added to your network. It's held only
   in the app window's own storage, and you import it again next time.
 - The app contacts only these, and only when you act:
-  - **LinkedIn**, while you scan. Also, until a profile photo has been saved to your
-    computer, the app shows it straight from LinkedIn's image server.
+  - **LinkedIn**, while you scan. Each profile photo is saved on your computer as the
+    scan reads it, and the app shows photos only from there, so looking at your network
+    never contacts LinkedIn. (Photos an older version kept as links to LinkedIn show
+    initials until the next scan, or *Save photos* on the Scan page, saves them.)
   - Only without the Mac app (which carries the scanner's Python and add-ons inside it),
     once, when you set the scanner up: **PyPI** (the Python package library) for the
     scanner's add-ons, and, if the computer has no Python the scanner can use, **GitHub**

package/SECURITY.md

@@ -99,6 +99,14 @@ This app is designed to run **on your own machine, against your own network**.
 - Values stored in the database are treated as untrusted text and escaped
   before rendering. Do not reintroduce `innerHTML` (including d3's `.html()`)
   for anything data-bearing.
+- **Profile photos come from this computer only.** A page shows a photo only
+  from a file saved in the data folder (`/avatars/<name>`, `lib/photos.js`),
+  never from a link, and every page carries
+  `Content-Security-Policy: img-src 'self' data: blob:`, so the browser won't
+  load a picture from anywhere else. The scanner fetches photos only from
+  LinkedIn's image servers (`*.licdn.com`, over https): while it scans, and
+  once each for links older versions stored, which a crafted import could also
+  carry.
 - Do not bind this app to `0.0.0.0` or expose it through a tunnel.
 
 ## Your data
@@ -108,6 +116,8 @@ Everything stays local:
 - A CSV import is parsed in the browser and held for that tab only. It is never
   uploaded and never written to a database.
 - Scanned data and cached avatars are written to your machine and are gitignored.
+  The app shows photos only from those files, so looking at your network never
+  contacts LinkedIn.
 - There is no telemetry, no analytics, and no crash reporting.
 
 If you run the scanner, `chrome-profile/` in the data directory holds a live

package/db/schema.js

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

package/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/lib/csv.js

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

package/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/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/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/lib/ingest.js

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

package/lib/linkedin-limits.js

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