six-degrees 0.7.0 → 1.0.0

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

@@ -13,6 +13,9 @@
 // and the scanner also keeps any two a minute apart. Searches did too, at 373 in
 // 24 hours: the page asks before a risky search budget (lib/search-risk.js).
 //
+// Auto's connection requests (lib/auto-connect.js) are a third list in the same
+// record, "invites", with caps of their own: 15 in any 24 hours, 80 in any 7 days.
+//
 // They belong to the LinkedIn account, not to a profile in the app. TRAPS §35.
 
 import {
@@ -22,12 +25,14 @@ import path from 'node:path';
 import { durable } from './durable.js';
 import { PACES, DEFAULT_PACE } from './scan-pace.js';
 import { countAfter } from './usage.js';
+import { INVITE_CAPS } from './auto-connect.js';
 
 export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50, pace: DEFAULT_PACE };
 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 WEEK = 7 * DAY;
 const PACIFIC = 'America/Los_Angeles';
 
 function readJson(file) {
@@ -102,17 +107,16 @@ export function writeLimits(dir, { daily, monthly, profiles, pace } = {}) {
 }
 
 /**
- * The scanner's record as two lists of times (epoch seconds), or null when it
- * can't be read. No record at all is nothing done yet.
+ * The scanner's record as three lists of times (epoch seconds): searches,
+ * profile views and Auto's connection requests. null when it can't be read. No
+ * record at all is nothing done yet.
  */
 function readActivity(dir) {
   const file = path.join(dir, 'linkedin-activity.json');
   const data = existsSync(file) ? readJson(file) : { searches: [], profiles: [] };
   if (!data || typeof data !== 'object') return null;
-  return {
-    searches: (Array.isArray(data.searches) ? data.searches : []).map(Number),
-    profiles: (Array.isArray(data.profiles) ? data.profiles : []).map(Number),
-  };
+  const times = (v) => (Array.isArray(v) ? v : []).map(Number);
+  return { searches: times(data.searches), profiles: times(data.profiles), invites: times(data.invites) };
 }
 
 /**
@@ -123,14 +127,19 @@ function readActivity(dir) {
  */
 export function usage(dir, now = Date.now()) {
   const rec = readActivity(dir);
-  if (!rec) return { searchesToday: Infinity, searchesMonth: 0, profilesToday: Infinity, unreadable: true };
-  const { searches: s, profiles: p } = rec;
+  if (!rec) {
+    return { searchesToday: Infinity, searchesMonth: 0, profilesToday: Infinity, invitesToday: Infinity, invitesWeek: Infinity, unreadable: true };
+  }
+  const { searches: s, profiles: p, invites: i } = rec;
   const dayAgo = now / 1000 - DAY;
   const month0 = monthStartPacific(now) / 1000;
   return {
     searchesToday: s.filter((t) => t > dayAgo).length,
     searchesMonth: s.filter((t) => t >= month0).length,
     profilesToday: p.filter((t) => t > dayAgo).length,
+    // Auto's connection requests (lib/auto-connect.js), against their own caps.
+    invitesToday: i.filter((t) => t > dayAgo).length,
+    invitesWeek: i.filter((t) => t > now / 1000 - WEEK).length,
   };
 }
 
@@ -177,12 +186,18 @@ export function linkedinState(dir, now = Date.now()) {
   const limits = readLimits(dir);
   const use = usage(dir, now);
   const left = (limit, used) => (limit ? Math.max(0, limit - used) : null);
+  // When Auto may send again once a cap is reached: the request that stops
+  // counting soonest frees the next (freesAt below).
+  const invites = use.unreadable ? null : readActivity(dir)?.invites || [];
   return {
     ...use,
     limits,
     leftToday: left(limits.daily, use.searchesToday),
     leftMonth: left(limits.monthly, use.searchesMonth),
     profilesLeftToday: left(limits.profiles, use.profilesToday),
+    inviteCaps: INVITE_CAPS,
+    invitesFreeAt: invites ? freesAt(invites, now, INVITE_CAPS.day) : null,
+    invitesWeekFreeAt: invites ? freesAt(invites, now, INVITE_CAPS.week, WEEK) : null,
     monthResets: nextMonthStartPacific(now),
     cooldown: readCooldown(dir, now),
   };
@@ -325,6 +340,9 @@ export function linkedinUsage(dir, now = Date.now()) {
     now,
     searchesToday: rec ? state.searchesToday : null,
     profilesToday: rec ? state.profilesToday : null,
+    // Auto's connection requests: the last 24 hours and the last 7 days, against INVITE_CAPS.
+    invitesToday: rec ? state.invitesToday : null,
+    invitesWeek: rec ? state.invitesWeek : null,
     searchesMonth: rec ? state.searchesMonth : null,
     leftMonth: rec ? state.leftMonth : null,
     searchesLastHour: known((r) => countWithin(r.searches, now, 3600)),
@@ -363,7 +381,7 @@ const isTime = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
 export function budgetFileProblem(name, data) {
   if (!isObject(data)) return 'it is not a JSON object';
   if (name === ACTIVITY) {
-    if (!isTimeList(data.searches) || !isTimeList(data.profiles)) return 'its record of searches is not a list of times';
+    if (!isTimeList(data.searches) || !isTimeList(data.profiles) || !isTimeList(data.invites)) return 'its record of searches is not a list of times';
   } else if (name === COOLDOWN) {
     if (!isTime(data.until)) return 'its pause has no end time';
     if (data.reason !== undefined && typeof data.reason !== 'string') return 'its pause has a reason that is not text';
@@ -415,7 +433,8 @@ const hasFile = (p) => {
 /**
  * Merge the budget files in `from` (an import's, already checked with
  * budgetFileProblem) into the data folder `dir`:
- *   linkedin-activity.json  both computers' searches and profile views (mergeTimes)
+ *   linkedin-activity.json  both computers' searches, profile views and Auto's
+ *                           connection requests (mergeTimes)
  *   linkedin-cooldown.json  whichever pause ends later
  *   scan-limits.json        this computer's, if it has one; the copy's otherwise.
  *                           The limits are a choice someone made here, and an
@@ -437,10 +456,16 @@ export function mergeBudgetFiles({ dir, from }) {
     const mine = hasFile(here(ACTIVITY)) ? readJson(here(ACTIVITY)) : {};
     const searches = isObject(mine) ? readableTimes(mine.searches) : null;
     const profiles = isObject(mine) ? readableTimes(mine.profiles) : null;
-    if (searches && profiles) {
+    const invites = isObject(mine) ? readableTimes(mine.invites) : null;
+    if (searches && profiles && invites) {
+      // Auto's requests too, or a copy brought in would forget the ones sent here
+      // (and Auto's caps would start again from nothing). Written only when
+      // either side has any, so a record from before Auto keeps its old layout.
+      const sent = mergeTimes(invites, activity.invites);
       durable.writeJsonDurably(here(ACTIVITY), {
         searches: mergeTimes(searches, activity.searches),
         profiles: mergeTimes(profiles, activity.profiles),
+        ...(sent.length ? { invites: sent } : {}),
       });
     }
   }

package/.next/standalone/lib/requests-client.js

@@ -96,6 +96,16 @@ export async function markRequested(row, { bridgeId } = {}) {
   }
 }
 
+/**
+ * A request the app has already saved, shown everywhere at once with nothing
+ * posted: Auto's, which the server marks itself once LinkedIn shows it pending
+ * (app/api/scraper/route.js, lib/requests.js).
+ */
+export function sawRequested(row) {
+  mine.set(keyFor(row), true);
+  publish();
+}
+
 /** Take a request back, everywhere. */
 export async function undoRequest(row) {
   const key = keyFor(row);

package/.next/standalone/lib/requests.js

@@ -0,0 +1,124 @@
+// Requests you've sent, kept per PERSON: the server side of
+// lib/requests-client.js.
+//
+// A person has one row per bridge whose circle holds them (the table's key is
+// profile + bridge + user), and a request used to mark only the copy that was
+// clicked. The other copies still offered "Add", the Pending count counted
+// copies, and every click awarded XP again. Now a request marks every copy of
+// the person, in both columns, the bridge you asked through is kept (so once
+// they accept, their card and circle say who introduced you: lib/promote.js
+// keeps it), XP comes once per person, and Undo takes back all of it.
+//
+// Two callers: POST /api/outreach (a Connect pressed on a page), and the
+// scanner's route once Auto has sent a request and LinkedIn showed it pending
+// (app/api/scraper/route.js; Blake, 2026-10-03). Both go through markSent here,
+// so a request sent by Auto is the same request everywhere as one sent by hand.
+
+import { db as supabase } from './db.js';
+import { resolveProfile } from './profile.js';
+
+// XP rewards by tier
+export const XP_SEND = { S: 25, A: 15, B: 10, C: 5, D: 2 };
+export const XP_ACCEPT = { S: 100, A: 60, B: 35, C: 15, D: 5 };
+const TIER_ORDER = ['S', 'A', 'B', 'C', 'D'];
+
+export async function awardXP(userId, amount) {
+  if (!userId || !amount) return;
+  // Upsert: create if not exists, change if exists. Never below zero: an Undo
+  // takes back what a send gave, including sends from before sends gave any.
+  const { data: existing } = await supabase.from('user_stats').select('xp').eq('id', userId).single();
+  if (existing) {
+    await supabase.from('user_stats').update({ xp: Math.max(0, (existing.xp || 0) + amount) }).eq('id', userId);
+  } else if (amount > 0) {
+    await supabase.from('user_stats').insert([{ id: userId, xp: amount, level: 1 }]).catch(() => {});
+  }
+}
+
+/** The profile a request belongs to: the one sent, else this machine's. */
+export function whose(userId) {
+  if (userId) return String(userId);
+  try { return resolveProfile({ create: false })?.id || null; } catch { return null; }
+}
+
+/** Every copy of one person: by the clicked row's profile URL, or the URL given. */
+export function copiesOf(db, { connectionId, profileUrl, userId }) {
+  let url = profileUrl ? String(profileUrl) : null;
+  let user = userId ? String(userId) : null;
+  let clicked = null;
+  if (connectionId != null) {
+    clicked = db.prepare('SELECT id, profile_url, user_id FROM linkedin_connections WHERE id = ?').get(String(connectionId)) || null;
+    if (clicked) {
+      url = clicked.profile_url || url;
+      user = user || clicked.user_id || null;
+    }
+  }
+  const cols = 'id, degree, tier, outreach_status, unlock_status, unlocked_from_bridge_id';
+  let rows = [];
+  if (url) {
+    rows = user
+      ? db.prepare(`SELECT ${cols} FROM linkedin_connections WHERE profile_url = ? AND user_id = ?`).all(url, user)
+      : db.prepare(`SELECT ${cols} FROM linkedin_connections WHERE profile_url = ?`).all(url);
+  } else if (clicked) {
+    rows = db.prepare(`SELECT ${cols} FROM linkedin_connections WHERE id = ?`).all(clicked.id);
+  }
+  return { url, user, rows };
+}
+
+export const inList = (ids) => ids.map(() => '?').join(', ');
+export const bestTier = (rows) => TIER_ORDER.find((t) => rows.some((r) => r.tier === t)) || 'D';
+
+/**
+ * Mark a request to this person as sent, on every copy of them, through
+ * `bridgeId` (one of your own connections) when given: the rows only, at once.
+ * Returns { saved, xp, already, user }: `saved` is how many rows (0 when nobody
+ * is on file, as for the sample network, which lives in the browser), `xp` what
+ * the send is worth (once per person), for markSent or the caller to award.
+ */
+export function markSentRows(db, { connectionId, profileUrl, userId, bridgeId } = {}) {
+  const { user, rows } = copiesOf(db, { connectionId, profileUrl, userId });
+  if (!rows.length) return { saved: 0, xp: 0, already: false, user };
+  const ids = rows.map((r) => r.id);
+  const now = new Date().toISOString();
+  const already = rows.some((r) => r.outreach_status === 'sent' || r.outreach_status === 'accepted');
+  db.prepare(`UPDATE linkedin_connections SET outreach_status = 'sent', updated_at = ?
+    WHERE id IN (${inList(ids)}) AND (outreach_status IS NULL OR outreach_status NOT IN ('sent', 'accepted'))`).run(now, ...ids);
+  db.prepare(`UPDATE linkedin_connections SET unlock_status = 'pending', updated_at = ?
+    WHERE id IN (${inList(ids)}) AND (unlock_status IS NULL OR unlock_status = 'locked')`).run(now, ...ids);
+  // Who you asked through: one of your own connections, or nothing.
+  if (bridgeId != null) {
+    const bridge = db.prepare(
+      `SELECT id, name FROM linkedin_connections WHERE id = ? AND degree = 1${user ? ' AND user_id = ?' : ''}`,
+    ).get(...[String(bridgeId), ...(user ? [user] : [])]);
+    if (bridge) {
+      db.prepare(`UPDATE linkedin_connections SET unlocked_from_bridge_id = ?, unlocked_from_name = ?, updated_at = ?
+        WHERE id IN (${inList(ids)}) AND degree = 2 AND unlocked_from_bridge_id IS NULL`).run(bridge.id, bridge.name, now, ...ids);
+    }
+  }
+  const xp = already ? 0 : XP_SEND[bestTier(rows)] || 2;
+  return { saved: ids.length, xp, already, user };
+}
+
+/** markSentRows, and its XP awarded: { saved, xp, already }. */
+export async function markSent(db, request = {}) {
+  const { saved, xp, already, user } = markSentRows(db, request);
+  if (saved) await awardXP(whose(user), xp);
+  return { saved, xp, already };
+}
+
+/**
+ * Where this person stands for a new request, over every copy of them:
+ * { connected, requested, accepted }. `connected`: a copy of them is one of
+ * your own connections; `requested`: a request is out (sent or pending);
+ * `accepted`: one was accepted (or their path is unlocked).
+ */
+export function requestStanding(db, { profileUrl, userId }) {
+  if (!profileUrl) return { connected: false, requested: false, accepted: false };
+  const rows = userId
+    ? db.prepare('SELECT degree, outreach_status, unlock_status FROM linkedin_connections WHERE profile_url = ? AND user_id = ?').all(String(profileUrl), String(userId))
+    : db.prepare('SELECT degree, outreach_status, unlock_status FROM linkedin_connections WHERE profile_url = ?').all(String(profileUrl));
+  return {
+    connected: rows.some((r) => r.degree === 1),
+    requested: rows.some((r) => r.outreach_status === 'sent' || r.unlock_status === 'pending'),
+    accepted: rows.some((r) => r.outreach_status === 'accepted' || r.unlock_status === 'unlocked'),
+  };
+}

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

@@ -41,6 +41,7 @@ export function runningNow(job) {
     case 'setup': return 'The scanner is being set up';
     case 'login': return 'The LinkedIn sign-in window is open';
     case 'photos': return 'Profile photos are being saved';
+    case 'connect': return 'A connection request is being sent';
     default: return 'A scan is running';
   }
 }

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

@@ -1,8 +1,9 @@
 // What the Scan page's first step says and offers, from the checks GET
 // /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js),
-// whether it asks for your field once your connections are in (askForField),
-// and two answers the server gives that step: is Google Chrome here
-// (chromeInstalled), and are you signed in to LinkedIn (signedInFrom).
+// its optional item on a Mac about macOS's App Management question
+// (appManagementStep), whether it asks for your field once your connections
+// are in (askForField), and two answers the server gives that step: is Google
+// Chrome here (chromeInstalled), and are you signed in to LinkedIn (signedInFrom).
 // Plain data in, plain data out: the page draws it, and
 // tests/scanner-setup.test.mjs checks every state without a browser. No Node
 // imports here; the page runs in the browser.
@@ -178,6 +179,84 @@ function stepOnly(status) {
   };
 }
 
+// ── macOS's App Management question ─────────────────────────────────────────
+// The scanner starts Google Chrome, and Chrome's own updater may then try to
+// update /Applications/Google Chrome.app. macOS puts that down to the app that
+// started Chrome and asks whether Six Degrees may manage apps (System Settings
+// → Privacy & Security → App Management). Saying no is harmless: Chrome updates
+// itself the next time you open it, and scanning works either way. Now that
+// the Mac app is signed, a yes lasts across updates (unsigned copies lost it
+// every update). "shouldnt we have in the onboarding for scan … a button where
+// the user is basically brought to the app management and enables it like
+// Flow does" (Blake, 2026-10-04). So step 1 offers the pane, once, and never
+// waits for it: the app can't read whether it was allowed, and it's optional.
+
+// The pane's address, as macOS 26 has it (checked on 26.5.1; macOS 15 knows it
+// too), and as macOS 13 and 14 have it. desktop/lib.mjs SETTINGS_URLS lets
+// exactly these two out of the Mac app; tests/desktop.test.mjs keeps them equal.
+export const APP_MANAGEMENT_URL = 'x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension?Privacy_AppBundles';
+export const APP_MANAGEMENT_URL_OLDER = 'x-apple.systempreferences:com.apple.preference.security?Privacy_AppBundles';
+export const APP_MANAGEMENT_URLS = Object.freeze([APP_MANAGEMENT_URL, APP_MANAGEMENT_URL_OLDER]);
+export const APP_MANAGEMENT_TITLE = 'Let Six Degrees open Chrome without macOS asking';
+export const APP_MANAGEMENT_WHERE = 'System Settings → Privacy & Security → App Management';
+
+/** The Scan page's App Management item, once answered: 'done' or 'skipped' (null: not yet). */
+export const APP_MANAGEMENT_SETTING = {
+  default: null,
+  parse(value) {
+    if (value === null || value === 'done' || value === 'skipped') return value;
+    throw new Error('The App Management answer is done, skipped or null.');
+  },
+};
+
+/**
+ * macOS's major version from the Darwin kernel's (os.release() on the
+ * server): Darwin 25 is macOS 26, when the numbers jumped to the year, and 20
+ * to 24 are macOS 11 to 15. null off a Mac, or when it can't be read.
+ */
+export function macosVersion(platform, release) {
+  if (platform !== 'darwin') return null;
+  const darwin = Number.parseInt(String(release ?? ''), 10);
+  if (!Number.isInteger(darwin) || darwin < 1) return null;
+  if (darwin >= 25) return darwin + 1;
+  if (darwin >= 20) return darwin - 9;
+  return 10; // Catalina and before were all 10.x
+}
+
+/**
+ * Step 1's optional item about App Management: { title, text, href, where }
+ * to show it, false not to, null while that isn't known yet (the page leaves
+ * it out until it is, as with askForField).
+ *
+ * Only on a Mac (`status.checks.mac`: { version, app }, null elsewhere and
+ * from an older server), and from macOS 13, which brought App Management.
+ * Never once answered, Done or Skip (`settings.appManagement`), and not when
+ * settings couldn't be read, since the answer couldn't be kept either. The
+ * button opens the pane for that macOS (an unknown version gets the newest
+ * address), and `where` says where it is by hand.
+ *
+ * In the Mac app macOS asks about Six Degrees. Started with npx, Chrome's
+ * starter is the app Six Degrees was started from (Terminal, for example), and
+ * that is the one macOS names.
+ */
+export function appManagementStep(status, settings) {
+  if (!status) return null;
+  const mac = status.checks?.mac;
+  if (!mac || (mac.version != null && mac.version < 13)) return false;
+  if (settings === undefined) return null;
+  if (!settings || settings.appManagement) return false;
+  const asked = mac.app ? 'Six Degrees' : 'the app you started Six Degrees from (Terminal, for example)';
+  const allow = mac.app ? 'Allow Six Degrees' : 'Allow that app';
+  return {
+    title: APP_MANAGEMENT_TITLE,
+    text: `When the scanner starts Google Chrome, macOS may ask whether ${asked} can manage apps. `
+      + 'That’s Chrome updating itself while the scanner uses it. '
+      + `${allow} once in App Management and macOS won’t ask again. Scanning works either way.`,
+    href: mac.version != null && mac.version < 15 ? APP_MANAGEMENT_URL_OLDER : APP_MANAGEMENT_URL,
+    where: APP_MANAGEMENT_WHERE,
+  };
+}
+
 /**
  * Whether the Scan page asks for your field (app/components/FieldStep.js):
  * once, when your own connections are in (step 3) and before who they know is

package/.next/standalone/lib/scraper-client.js

@@ -39,7 +39,13 @@ export async function startScrape(action, name, extra = {}) {
     body: JSON.stringify(scanRequest(action, { ...(name ? { name } : {}), ...extra })),
   });
   const d = await r.json().catch(() => ({}));
-  if (!r.ok) throw new Error(d.error || 'Could not start the scanner.');
+  if (!r.ok) {
+    // The answer's flags travel with the error (needsAutoAcceptance, say), so a
+    // button can tell a question to ask from a reason to show.
+    const err = new Error(d.error || 'Could not start the scanner.');
+    err.details = d;
+    throw err;
+  }
   return d;
 }
 
@@ -55,12 +61,13 @@ export async function resumePoint(id) {
 }
 
 /** Nothing noted: before the first answer, and for the sample or a CSV. */
-export const NO_SCAN_NOTES = Object.freeze({ skips: [], read: [] });
+export const NO_SCAN_NOTES = Object.freeze({ skips: [], read: [], lists: {} });
 
 /**
  * What the scanner noted, for lib/reach.js: `skips`, the hidden lists
- * ([{ profileUrl, … }]), and `read`, the profile URLs of every list it has
- * read. Never throws: with no answer (the app restarting, say) nothing is
+ * ([{ profileUrl, … }]), `read`, the profile URLs of every list it has
+ * read, and `lists`, how far each was read ({ url: { pages, more, total } }).
+ * Never throws: with no answer (the app restarting, say) nothing is
  * noted, so a hidden list shows as ready rather than anyone going missing.
  */
 export async function loadScanNotes() {
@@ -68,7 +75,11 @@ export async function loadScanNotes() {
     const r = await fetch('/api/scraper?reach=1');
     if (!r.ok) return NO_SCAN_NOTES;
     const d = await r.json();
-    return { skips: Array.isArray(d.skips) ? d.skips : [], read: Array.isArray(d.read) ? d.read : [] };
+    // `lists` is how far each list was read, for the rings round a dot
+    // (lib/reach.js scanBars). Dropped here until 10/3, every scanned
+    // connection drew 2 of 5 bars, "partly read", even with the whole list in.
+    const lists = d.lists && typeof d.lists === 'object' && !Array.isArray(d.lists) ? d.lists : {};
+    return { skips: Array.isArray(d.skips) ? d.skips : [], read: Array.isArray(d.read) ? d.read : [], lists };
   } catch {
     return NO_SCAN_NOTES;
   }
@@ -314,6 +325,8 @@ export function busyReason(job = now) {
     case 'full':
     case 'refresh':
       return 'Your own connections are being scanned';
+    case 'connect':
+      return who ? `A request to ${who} is being sent` : 'A connection request is being sent';
     default:
       return runningNow(job.action);
   }

package/.next/standalone/lib/settings.js

@@ -14,8 +14,10 @@ import { SECTOR_FOCUS_SETTING, FIELD_ASKED_SETTING } from './sector-focus.js';
 import { TIER_SCALE_SETTING } from './scoring.js';
 import { TITLE_RANKING_SETTING } from './title-ranking.js';
 import { SCAN_RISK_SETTING } from './scan-risk.js';
+import { AUTO_ACCEPTED_SETTING } from './auto-connect.js';
 import { THEME_SETTING } from './themes.js';
 import { GALAXY_LAYOUTS_SETTING } from './galaxy-layouts.js';
+import { APP_MANAGEMENT_SETTING } from './scanner-setup.js';
 
 export const SETTINGS = {
   // Scores → Your sector: industries whose companies count for more (lib/sector-focus.js).
@@ -28,6 +30,10 @@ export const SETTINGS = {
   titleRanking: TITLE_RANKING_SETTING,
   // The Scan page's "I understand" before the first scan: when it was given (lib/scan-risk.js).
   scanRiskAccepted: SCAN_RISK_SETTING,
+  // The Scan page's optional App Management item on a Mac: Done or Skip, so it's offered once (lib/scanner-setup.js).
+  appManagement: APP_MANAGEMENT_SETTING,
+  // Auto's one-time question before its first connection request: when it was answered yes (lib/auto-connect.js).
+  autoConnectAccepted: AUTO_ACCEPTED_SETTING,
   // Settings → Appearance: the look (lib/themes.js). Here so it travels with a
   // backup or a restore; the browser keeps a copy to paint with first (lib/theme-store.js).
   theme: THEME_SETTING,

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

@@ -193,3 +193,8 @@ 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.7.0",
+  "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.7.0",
+      "version": "1.0.0",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.7.0",
+  "version": "1.0.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",