six-degrees 0.6.0 → 0.8.0

package/.next/standalone/lib/themes.js

@@ -10,8 +10,18 @@
 // (app/globals.css, html[data-backdrop]), and the dot colours the map draws with
 // (TIER_COLORS, a live object every view reads).
 //
-// Every theme is dark underneath, so the text, which is light everywhere, reads
-// on all of them: a theme changes what's behind it, not the words.
+// Dark or light is the background's own: a look whose background is light
+// (Daylight, Paper, or any colour you pick) turns the words, borders and
+// raised surfaces dark (lightTokens). The app's colours are CSS variables
+// whose fallbacks are the dark values they always had, so a dark look sets
+// none of them and draws exactly as before (Blake, 2026-10-03: "id like a
+// light mode").
+//
+// A look also has a way of drawing buttons (`buttons`, app/globals.css
+// html[data-buttons]) and the map's dots (`dots`, app/components/ForceGraph.js):
+// soft, flat, square, frosted, neon or bold; solid, droplet, flat, glow or plain
+// (Blake: "buttons look the same … like apple glass it will look like blurred
+// droplets and then for the obsidian it looks like obsidian with the nodes").
 //
 // What arrives from storage or a pasted theme code is untrusted: cleanTheme
 // keeps only #rrggbb colours, the listed choices and numbers in range, so
@@ -25,6 +35,8 @@ export const FONTS = {
   serif: 'ui-serif, "New York", Georgia, "Times New Roman", serif',
 };
 export const LINE_MODES = ['tier', 'one'];
+export const BUTTONS = ['soft', 'flat', 'square', 'frosted', 'neon', 'bold'];
+export const DOTS = ['solid', 'droplet', 'flat', 'glow', 'plain'];
 
 /**
  * A theme. `bg` is the colour behind everything, `bg2` the second colour of its
@@ -37,46 +49,68 @@ export const STANDARD = Object.freeze({
   id: 'standard', name: 'Standard', blurb: 'The original: deep navy, gold, purple and blue.',
   bg: '#0a0a1a', bg2: '#1a1440', backdrop: 'none', panel: '#0a0f1e', glass: 0.35, accent: '#3498db',
   tiers: Object.freeze({ S: '#ffd700', A: '#9b59b6', B: '#3498db', C: '#95a5a6', D: '#bdc3c7' }),
-  you: '#ffffff', lines: 'tier', line: '#5a6274', font: 'system',
+  you: '#ffffff', lines: 'tier', line: '#5a6274', font: 'system', buttons: 'soft', dots: 'solid',
 });
 
 export const THEMES = Object.freeze([
   STANDARD,
+  Object.freeze({
+    id: 'daylight', name: 'Daylight', blurb: 'Light, designed for it: white panels, ink text, deeper dots that read on white.',
+    bg: '#f4f6fb', bg2: '#dfe5f2', backdrop: 'none', panel: '#ffffff', glass: 0.25, accent: '#2563eb',
+    tiers: Object.freeze({ S: '#d99a00', A: '#8e44ad', B: '#2f80ed', C: '#6b7a86', D: '#a4afba' }),
+    you: '#111827', lines: 'tier', line: '#c5cbd8', font: 'system', buttons: 'soft', dots: 'solid',
+  }),
+  Object.freeze({
+    id: 'paper', name: 'Paper', blurb: 'Warm off-white and ink, like a printed chart. Flat, quiet, easy on the eyes.',
+    bg: '#f6f1e7', bg2: '#e6dcc8', backdrop: 'grid', panel: '#fbf8f1', glass: 0, accent: '#b4532a',
+    tiers: Object.freeze({ S: '#b7791f', A: '#7b4fa0', B: '#2c6e9b', C: '#7d8a80', D: '#b0a99a' }),
+    you: '#2b2118', lines: 'one', line: '#cbbfa8', font: 'serif', buttons: 'flat', dots: 'flat',
+  }),
   Object.freeze({
     id: 'contrast', name: 'High contrast', blurb: 'Pure black, the brightest dots, solid panels. Easiest to read.',
     bg: '#000000', bg2: '#000000', backdrop: 'none', panel: '#000000', glass: 0, accent: '#4cc9f0',
     tiers: Object.freeze({ S: '#ffe500', A: '#d08bff', B: '#4cc9f0', C: '#e6e6e6', D: '#ffffff' }),
-    you: '#ffffff', lines: 'tier', line: '#8a8a8a', font: 'system',
+    you: '#ffffff', lines: 'tier', line: '#8a8a8a', font: 'system', buttons: 'bold', dots: 'solid',
+    fg: Object.freeze(['#ffffff', '#f2f2f2', '#d9d9d9', '#bdbdbd', '#a0a0a0']), ink: '255, 255, 255',
   }),
   Object.freeze({
     id: 'obsidian', name: 'Obsidian', blurb: 'Graphite and violet, grey links: the note-taking app’s graph.',
     bg: '#1e1e1e', bg2: '#262626', backdrop: 'none', panel: '#262626', glass: 0.1, accent: '#8a7cf7',
     tiers: Object.freeze({ S: '#e0c25a', A: '#a88bfa', B: '#7aa2f7', C: '#9aa0a6', D: '#c7c7c7' }),
-    you: '#a88bfa', lines: 'one', line: '#5c5c5c', font: 'system',
+    you: '#a88bfa', lines: 'one', line: '#5c5c5c', font: 'system', buttons: 'flat', dots: 'flat',
+    fg: Object.freeze(['#dcddde', '#bababa', '#999999', '#777777', '#5c5c5c']), ink: '220, 221, 222',
   }),
   Object.freeze({
     id: 'glass', name: 'Glass', blurb: 'Frosted panels over slow colour: a heads-up display, see-through.',
-    bg: '#0b1020', bg2: '#5b21b6', backdrop: 'glow', panel: '#ffffff', glass: 0.9, accent: '#7dd3fc',
+    bg: '#0b1020', bg2: '#5b21b6', backdrop: 'glow', panel: '#12121e', glass: 0.9, accent: '#7dd3fc',
     tiers: Object.freeze({ S: '#fde68a', A: '#f0abfc', B: '#7dd3fc', C: '#cbd5e1', D: '#e2e8f0' }),
-    you: '#ffffff', lines: 'tier', line: '#94a3b8', font: 'rounded',
+    you: '#ffffff', lines: 'tier', line: '#94a3b8', font: 'rounded', buttons: 'frosted', dots: 'droplet',
+    fg: Object.freeze(['#ffffff', '#f1f4ff', '#cdd3e6', '#adb4cb', '#929ab2']), ink: '255, 255, 255',
   }),
   Object.freeze({
-    id: 'analyst', name: 'Analyst', blurb: 'A data terminal: a grid, monospace, colour-blind-safe dots.',
-    bg: '#0d1117', bg2: '#161b22', backdrop: 'grid', panel: '#161b22', glass: 0, accent: '#58a6ff',
-    tiers: Object.freeze({ S: '#e69f00', A: '#cc79a7', B: '#56b4e9', C: '#009e73', D: '#8b949e' }),
-    you: '#f0f6fc', lines: 'one', line: '#30363d', font: 'mono',
+    // An analysis tool's look (Blake, 2026-10-03: "the bare white background
+    // with the flat purely data based look that makes it feel less cluttered
+    // and more about the numbers"): a white canvas, flat grey panels, plain
+    // outlined dots in a colour-blind-safe palette (Okabe–Ito), black labels,
+    // thin grey lines, and nothing decorative (app/globals.css html[data-theme="analyst"]).
+    id: 'analyst', name: 'Analyst', blurb: 'A bare white canvas and flat panels: plain dots, black labels, just the network and its numbers.',
+    bg: '#ffffff', bg2: '#e8e8e8', backdrop: 'none', panel: '#f4f4f4', glass: 0, accent: '#2b6cb0',
+    tiers: Object.freeze({ S: '#d55e00', A: '#0072b2', B: '#009e73', C: '#cc79a7', D: '#8c8c8c' }),
+    you: '#111111', lines: 'one', line: '#9a9a9a', font: 'system', buttons: 'square', dots: 'plain',
   }),
   Object.freeze({
     id: 'space', name: 'Space', blurb: 'Your network as a star chart: deep black, a nebula, stars behind it all.',
     bg: '#04050d', bg2: '#2b1055', backdrop: 'stars', panel: '#0b0d1f', glass: 0.5, accent: '#a78bfa',
     tiers: Object.freeze({ S: '#ffd166', A: '#c77dff', B: '#4cc9f0', C: '#adb5bd', D: '#6c757d' }),
-    you: '#ffffff', lines: 'tier', line: '#3a3f5c', font: 'system',
+    you: '#ffffff', lines: 'tier', line: '#3a3f5c', font: 'system', buttons: 'soft', dots: 'glow',
+    fg: Object.freeze(['#eef2ff', '#cdd5f0', '#9aa5c4', '#76809e', '#565f7c']), ink: '205, 218, 255',
   }),
   Object.freeze({
     id: 'synthwave', name: 'Synthwave', blurb: 'Neon on a purple horizon. For the larpers.',
     bg: '#1a0b2e', bg2: '#ff2a6d', backdrop: 'horizon', panel: '#24103f', glass: 0.4, accent: '#ff2a6d',
     tiers: Object.freeze({ S: '#ffe66d', A: '#ff2a6d', B: '#05d9e8', C: '#d1f7ff', D: '#8c7aa9' }),
-    you: '#ffffff', lines: 'tier', line: '#7a3b9e', font: 'rounded',
+    you: '#ffffff', lines: 'tier', line: '#7a3b9e', font: 'rounded', buttons: 'neon', dots: 'glow',
+    fg: Object.freeze(['#fff5ff', '#ecdcff', '#c6aae4', '#9e83c2', '#7b649f']), ink: '255, 220, 255',
   }),
 ]);
 
@@ -110,11 +144,27 @@ export function cleanTheme(raw) {
   if (BACKDROPS.includes(c.backdrop)) custom.backdrop = c.backdrop;
   if (Object.hasOwn(FONTS, c.font ?? '')) custom.font = c.font;
   if (LINE_MODES.includes(c.lines)) custom.lines = c.lines;
+  if (BUTTONS.includes(c.buttons)) custom.buttons = c.buttons;
+  if (DOTS.includes(c.dots)) custom.dots = c.dots;
   const glass = Number(c.glass);
   if (c.glass != null && Number.isFinite(glass)) custom.glass = Math.round(Math.min(1, Math.max(0, glass)) * 100) / 100;
   return { base, custom };
 }
 
+/**
+ * In lib/settings.js, so the look travels with a backup, an export and a
+ * restore. null until a look is saved on this network: the browser's own
+ * choice then stands and is saved once (lib/theme-store.js).
+ */
+export const THEME_SETTING = {
+  default: null,
+  parse(value) {
+    if (value === null) return null;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('A look is a preset with your own changes on top.');
+    return cleanTheme(value);
+  },
+};
+
 /** The theme a choice comes to: its preset with your changes on top. */
 export function resolveTheme(choice) {
   const { base, custom } = cleanTheme(choice);
@@ -131,6 +181,34 @@ export function resolveTheme(choice) {
 const rgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
 const rgba = (hex, a) => `rgba(${rgb(hex).join(', ')}, ${a})`;
 
+/** a, moved t of the way to b. */
+const mix = (a, b, t) => `#${rgb(a).map((v, i) => Math.round(v + (rgb(b)[i] - v) * t).toString(16).padStart(2, '0')).join('')}`;
+
+/** How light a colour is, 0 to 1 (relative luminance). */
+export function luminance(hex) {
+  const lin = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+  const [r, g, b] = rgb(hex).map((v) => lin(v / 255));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+/** A light look: its background is light, whatever it's called. */
+export const isLight = (theme) => luminance(theme.bg) > 0.45;
+
+/**
+ * What a light look puts on top of the dark defaults: the overlays that raise a
+ * surface or draw a border turn to ink, the panels' dark wash to white, the
+ * words to five steps of ink, and the app's own colours to deeper shades that
+ * read as words on a light page (gold text on white disappears).
+ */
+function lightTokens() {
+  return {
+    '--sd-ink': '18, 22, 40',
+    '--sd-shade': '255, 255, 255',
+    '--sd-fg-1': '#11141c', '--sd-fg-2': '#2e3442', '--sd-fg-3': '#545b6b', '--sd-fg-4': '#747b8b', '--sd-fg-5': '#9aa0ad',
+    '--sd-gold': '#9a6b00', '--sd-blue': '#1f63b3', '--sd-orange': '#c2410c', '--sd-green': '#0b7a47',
+    '--sd-purple': '#6d3fa8', '--sd-cyan': '#0e7490', '--sd-coral': '#c2410c', '--sd-red': '#c0392b',
+  };
+}
+
 /**
  * The CSS variables a choice sets on the page. Every value is built here from
  * cleaned colours and numbers, never copied from what was saved.
@@ -138,25 +216,37 @@ const rgba = (hex, a) => `rgba(${rgb(hex).join(', ')}, ${a})`;
 export function themeVars(choice) {
   const t = resolveTheme(choice);
   const glass = Math.min(1, Math.max(0, Number(t.glass) || 0));
+  const preset = presetOf(t.id);
   return {
     '--sd-bg': t.bg,
     '--sd-bg2': t.bg2,
     '--sd-accent': t.accent,
-    // The side panels: the theme's tint, more see-through and more blurred the more glass.
-    '--sd-panel': rgba(t.panel, Math.round((0.92 - 0.82 * glass) * 100) / 100),
-    '--sd-panel-blur': `blur(${Math.round(8 + 28 * glass)}px) saturate(${(1 + 0.6 * glass).toFixed(2)})`,
-    // The header: clear, or frosted on a glass theme.
-    '--sd-header': glass >= 0.6 ? rgba(t.panel, 0.06) : 'transparent',
-    '--sd-header-blur': glass >= 0.6 ? 'blur(18px) saturate(1.4)' : 'none',
+    // The side panels: the theme's tint, more see-through and more blurred the
+    // more glass. Never clearer than about 40%: a panel full of words is
+    // Apple's "regular" glass, which keeps them readable, not the clear kind.
+    '--sd-panel': rgba(t.panel, Math.round((0.92 - 0.55 * glass) * 100) / 100),
+    '--sd-panel-blur': `blur(${Math.round(8 + 18 * glass)}px) saturate(${(1 + 0.9 * glass).toFixed(2)})`,
+    // The header: clear, or glass on a glass theme.
+    '--sd-header': glass >= 0.6 ? rgba(t.panel, 0.22) : 'transparent',
+    '--sd-header-blur': glass >= 0.6 ? 'blur(20px) saturate(1.8)' : 'none',
+    // A dark look's own words and overlays: Obsidian's greys, GitHub's for
+    // Analyst, brighter "vibrant" ones on Glass (lib/themes.js presets).
+    ...(!isLight(t) && preset.fg ? Object.fromEntries(preset.fg.map((c, i) => [`--sd-fg-${i + 1}`, c])) : {}),
+    ...(!isLight(t) && preset.ink ? { '--sd-ink': preset.ink } : {}),
     '--sd-font': FONTS[t.font] || FONTS.system,
     '--sd-tier-s': t.tiers.S, '--sd-tier-a': t.tiers.A, '--sd-tier-b': t.tiers.B, '--sd-tier-c': t.tiers.C, '--sd-tier-d': t.tiers.D,
+    ...(isLight(t) ? lightTokens() : {}),
+    // Cards, pickers, tooltips and the notch, in the look's own colour (Standard keeps the navy they always had).
+    ...(t.id === 'standard' && !t.customised ? {} : isLight(t)
+      ? { '--sd-surface': 'rgba(255, 255, 255, 0.97)', '--sd-card': '#ffffff' }
+      : { '--sd-surface': rgba(mix(t.bg, '#ffffff', 0.06), glass >= 0.6 ? 0.82 : 0.96), '--sd-card': mix(t.bg, '#ffffff', 0.08) }),
   };
 }
 
 /** What the html element carries for the stylesheet: the theme and its backdrop. */
 export function themeAttrs(choice) {
   const t = resolveTheme(choice);
-  return { theme: t.id, backdrop: t.backdrop };
+  return { theme: t.id, backdrop: t.backdrop, mode: isLight(t) ? 'light' : 'dark', buttons: t.buttons, dots: t.dots };
 }
 
 // A theme code to share: the choice as base64 JSON, behind a short prefix.
@@ -183,4 +273,4 @@ export function decodeTheme(code) {
 // it stay as they are. On the server it holds Standard's.
 export const TIER_COLORS = { ...STANDARD.tiers };
 // The rest of what the map draws from a theme: your dot, and its lines.
-export const MAP_LOOK = { you: STANDARD.you, lines: STANDARD.lines, line: STANDARD.line, bg: STANDARD.bg };
+export const MAP_LOOK = { you: STANDARD.you, lines: STANDARD.lines, line: STANDARD.line, bg: STANDARD.bg, dots: STANDARD.dots, light: false, text: '#ffffff' };

package/.next/standalone/lib/usage.js

@@ -0,0 +1,200 @@
+// Settings → LinkedIn usage: how close this account is to the line, in one
+// look, the way Claude's own usage page shows a plan's limits. No Node
+// imports, so the page and the tests share it; the counting itself is in
+// lib/linkedin-limits.js (linkedinUsage), from the files the scanner writes.
+//
+// Why it exists: on 2026-09-28 a real account was restricted after 373
+// searches in 24 hours (TRAPS §16), and the only budget view was a box folded
+// away on the Scan page. Every number here is either counted from the
+// scanner's own record or is a rule with a stated source; nothing is a guess
+// presented as a fact.
+
+import { RESTRICTED_AT, RISKY_DAILY, SAFE_LIMITS, limitNote } from './search-risk.js';
+
+const HOUR_MS = 3600 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+
+// Auto scan's own ceilings (scripts/scrape.py AUTO_DAY_CAP, AUTO_WEEK_CAP,
+// DRIP_HOURS, SESSION_PAGES, SESSION_REST, AUTO_PUSHBACK_REST). They hold
+// however high the budget is set. tests/usage.test.mjs reads the scanner's
+// numbers and checks these match, so the page can't describe rules the
+// scanner doesn't keep.
+export const AUTO = {
+  day: 40,                       // searches in any 24 hours
+  week: 200,                     // searches in any 7 days
+  hours: [9, 18],                // searches only from 09:00 to 18:00, this computer's clock
+  sitting: 8,                    // searches in one sitting
+  sittingRest: 60 * 60,          // seconds of rest after each sitting
+  pushbackRest: 2 * 24 * 3600,   // seconds off after any check from LinkedIn (scrape.py AUTO_PUSHBACK_REST)
+};
+
+// About how many people one search finds. A page of LinkedIn's people search
+// shows up to 10 (scripts/scrape.py, "10 results per page"); 9 allows for the
+// last page of each list, which is usually short. An estimate, and the page
+// says so (neo's handoff, 2026-10-03).
+export const PEOPLE_PER_SEARCH = 9;
+
+// Searches in 24 hours that count as too close: 60% of the 373 that got an
+// account restricted. A margin on a number seen once, not a known safe line.
+export const DANGER_AT = Math.ceil(0.6 * RESTRICTED_AT);
+
+// LinkedIn doesn't publish a free account's monthly limit. People report
+// somewhere around 250 to 350 searches (TRAPS §35); shown as a range people
+// report, never as LinkedIn's number.
+export const REPORTED_MONTH = [250, 350];
+
+// A search within this long after a pushback is the same search that met it,
+// not a new one: the evidence file's name is only to the second.
+const PUSHBACK_GRACE_MS = 60 * 1000;
+
+export const LEVELS = {
+  ok: { label: 'Well within', color: '#00ff88' },
+  'above-default': { label: 'Above the default', color: '#FFD700' },
+  risky: { label: 'Risky', color: '#FF8C42' },
+  danger: { label: 'Too close', color: '#ff6b6b' },
+  paused: { label: 'Paused', color: '#ff6b6b' },
+  unknown: { label: 'Can’t tell', color: '#8b9a9a' },
+};
+
+/**
+ * Where this account stands, worst first:
+ *   paused         a cooldown is on: nothing searches until it ends
+ *   danger         60% of 373 or more in 24 hours, or searching again within
+ *                  a day of LinkedIn pushing back
+ *   risky          over 100 in 24 hours (what the budget picker asks about)
+ *   above-default  over the default 50 in 24 hours
+ *   ok             within the default
+ *   unknown        the record can't be read (the scanner then counts the day as used)
+ */
+export function usageLevel({ cooldown, searchesDay, lastPushback, searchesSincePushback, now = Date.now() } = {}) {
+  if (cooldown) return 'paused';
+  if (!Number.isFinite(searchesDay)) return 'unknown';
+  if (searchesDay >= DANGER_AT) return 'danger';
+  if (searchedAfterPushback({ lastPushback, searchesSincePushback, now })) return 'danger';
+  if (searchesDay > RISKY_DAILY) return 'risky';
+  if (searchesDay > SAFE_LIMITS.daily) return 'above-default';
+  return 'ok';
+}
+
+/** LinkedIn pushed back less than a day ago and searching has carried on since. */
+export function searchedAfterPushback({ lastPushback, searchesSincePushback, now = Date.now() } = {}) {
+  const at = lastPushback?.at;
+  return Number.isFinite(at) && now - at < DAY_MS && now >= at && searchesSincePushback > 0;
+}
+
+/** Searches made after a pushback, from the record's times (epoch seconds). */
+export function countAfter(times, atMs) {
+  if (!Number.isFinite(atMs) || !Array.isArray(times)) return 0;
+  const from = (atMs + PUSHBACK_GRACE_MS) / 1000;
+  return times.filter((t) => t > from).length;
+}
+
+/**
+ * What's left, as searches and about how many people they'd find: the daily
+ * or monthly budget, whichever runs out first (null for one with no cap).
+ * Nothing while scanning is paused. null when neither has a cap.
+ */
+export function estimate({ leftDay, leftMonth, paused = false } = {}) {
+  const lefts = [leftDay, leftMonth].filter((n) => Number.isFinite(n));
+  if (!lefts.length) return null;
+  const searches = paused ? 0 : Math.max(0, Math.min(...lefts));
+  const by = leftDay != null && leftMonth != null ? (leftDay <= leftMonth ? 'day' : 'month') : leftDay != null ? 'day' : 'month';
+  return { searches, people: searches * PEOPLE_PER_SEARCH, by };
+}
+
+/** The plain-word warning for a level, or null when there's nothing to warn about. */
+export function levelWarning(level, { searchesDay, cooldown, lastPushback, now = Date.now() } = {}) {
+  if (level === 'paused') {
+    // As the Scan page's banner says it (app/components/LinkedInLimits.js CooldownBanner).
+    const why = String(cooldown?.reason || 'LinkedIn pushed back');
+    return `Scanning is paused${cooldown?.until ? ` until ${whenText(cooldown.until)}` : ''}. `
+      + `${why.charAt(0).toUpperCase()}${why.slice(1)}. Nothing that searches LinkedIn runs until then, so the account can recover.`;
+  }
+  if (level === 'danger') {
+    if (searchesDay >= DANGER_AT) {
+      return `${searchesDay} searches in the last 24 hours. A real account was restricted after ${RESTRICTED_AT}. `
+        + 'Stop scanning until this comes down: each search stops counting 24 hours after it was made.';
+    }
+    return `LinkedIn pushed back ${agoText(lastPushback?.at, now)}, and searching has carried on since. `
+      + 'Carrying on after a warning is what LinkedIn says turns it into a restriction. Leave it at least a day.';
+  }
+  if (level === 'risky') {
+    return `More than ${RISKY_DAILY} searches in the last 24 hours. That is past what Six Degrees asks you to confirm, `
+      + `and a free account's whole month may be ${REPORTED_MONTH[0]} to ${REPORTED_MONTH[1]}.`;
+  }
+  if (level === 'above-default') {
+    return `More than the default ${SAFE_LIMITS.daily} searches in the last 24 hours. `
+      + 'The default leaves room under limits LinkedIn doesn’t publish.';
+  }
+  if (level === 'unknown') {
+    return 'The record of searches on this computer couldn’t be read, so the scanner counts today’s budget as used until it can.';
+  }
+  return null;
+}
+
+/**
+ * The warning box's paragraphs, in order: the level's warning, then the Scan
+ * page's note on a risky budget (lib/search-risk.js limitNote). The 373 is
+ * said once: when the level's warning names it, the note leaves its own 373
+ * sentence out. The Scan page's budget box still says the note whole.
+ */
+export function warningParts(level, facts = {}, limits = {}) {
+  const warning = levelWarning(level, facts);
+  const namesRestriction = level === 'danger' && facts.searchesDay >= DANGER_AT;
+  const note = limitNote(limits, { restriction: !namesRestriction });
+  return [warning, note].filter(Boolean);
+}
+
+/** A bar's scale: past its last tick, and past what's been used. */
+export function barMax(used, ticks = []) {
+  const top = Math.max(0, ...ticks.filter(Number.isFinite));
+  return Math.max(Math.ceil(top * 1.08), Math.ceil((Number(used) || 0) * 1.05), 1);
+}
+
+/** Midnight Pacific as LinkedIn's month turns over: "Nov 1, 12:00 AM Pacific". */
+export function pacificText(ms) {
+  const s = new Intl.DateTimeFormat('en-US', {
+    timeZone: 'America/Los_Angeles', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit',
+  }).format(new Date(ms));
+  return `${s.replace(/ /g, ' ')} Pacific`;
+}
+
+/** A time on this computer's clock: "Sat, Oct 3, 3:12 PM". */
+export function whenText(ms) {
+  return new Date(ms).toLocaleString(undefined, { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' })
+    .replace(/ /g, ' ');
+}
+
+/** "in 3 h 12 min", "in 40 min", "in under a minute", or "now". */
+export function untilText(ms, now = Date.now()) {
+  const left = ms - now;
+  if (!(left > 0)) return 'now';
+  if (left < 60 * 1000) return 'in under a minute';
+  const m = Math.round(left / 60000);
+  if (m < 60) return `in ${m} min`;
+  const h = Math.floor(m / 60);
+  if (h >= 48) return `in ${Math.round(h / 24)} days`;
+  return `in ${h} h${m % 60 ? ` ${m % 60} min` : ''}`;
+}
+
+/** "3 h ago", "40 min ago", "just now". */
+export function agoText(ms, now = Date.now()) {
+  if (!Number.isFinite(ms)) return 'recently';
+  const m = Math.round((now - ms) / 60000);
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h} h ago`;
+  return `${Math.round(h / 24)} days ago`;
+}
+
+/** "9 AM to 6 PM" from AUTO.hours. */
+export function hoursText([from, to] = AUTO.hours) {
+  const h = (n) => `${n % 12 || 12} ${n < 12 ? 'AM' : 'PM'}`;
+  return `${h(from)} to ${h(to)}`;
+}
+
+// Auto's connection requests have caps of their own, in the same record
+// (lib/auto-connect.js, scripts/scrape.py INVITE_DAY_CAP and INVITE_WEEK_CAP):
+// the usage page shows them beside the searches and profile views.
+export { INVITE_CAPS, REPORTED_WEEKLY_INVITES } from './auto-connect.js';

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "six-degrees",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.6.0",
+      "version": "0.8.0",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",