@nstarkman/data-resolver 0.0.0-stage → 20261023.0.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+Versions are dates, `YYYYMMDD.0.N`; the four research-kit packages are released together at one
+version. A breaking change says how to migrate.
+
+## 20261023.0.1
+
+### Fixed
+
+- `collect()` put the co-authors of every item it reached on the paper's collaborator map — its
+  packages' papers' too; it now puts only the paper's own co-authors.
+
+## 20261023.0.0
+
+First release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nathaniel Starkman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @nstarkman/data-resolver
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [@nstarkman/research-kit](https://www.npmjs.com/package/@nstarkman/research-kit), which says how to
+use it; released with it at one version. Developed in
+[nstarman/nstarman.github.io](https://github.com/nstarman/nstarman.github.io) (`packages/data-resolver/`).

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "@nstarkman/data-resolver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "20261023.0.1",
+  "description": "The nstarkman.space data layer as a store, and the collector a paper site snapshots from.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Nathaniel Starkman",
+  "homepage": "https://nstarkman.space",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nstarman/nstarman.github.io.git",
+    "directory": "packages/data-resolver"
+  },
+  "exports": {
+    "./*": "./src/*"
+  },
+  "files": [
+    "src",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/bibtex.js

@@ -0,0 +1,135 @@
+// Renders publication items to BibTeX.
+//
+// This is why the schema stores authors as family/given rather than display
+// strings, requires an explicit `entryType`, and names venue fields after
+// BibTeX's own — the mapping here is direct rather than guessed.
+
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun',
+                'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+
+// TeX spells its own dashes; a literal em dash breaks a pdflatex run that has
+// not been told the input is UTF-8.
+const TEX = {
+  "\\": "\\textbackslash{}",
+  "&": "\\&",
+  "%": "\\%",
+  "$": "\\$",
+  "#": "\\#",
+  "_": "\\_",
+  "{": "\\{",
+  "}": "\\}",
+  "~": "\\textasciitilde{}",
+  "^": "\\textasciicircum{}",
+  "—": "---",
+  "–": "--",
+};
+
+/**
+ * Escape the characters that are syntax in TeX.
+ *
+ * One pass, so every character of the input is replaced exactly once and no
+ * replacement can be re-escaped by a later step. The chained version needed a
+ * sentinel to hold the backslash — otherwise the brace pass escaped
+ * `\textbackslash{}`'s own braces and turned `\star` into
+ * `\textbackslash\{\}star` — and that sentinel was itself a hole: a NUL in the
+ * input came back out as a backslash.
+ */
+function esc(value) {
+  return String(value).replace(/[\\&%$#_{}~^–—]/g, (ch) => TEX[ch]);
+}
+
+/**
+ * Abstracts arrive from arXiv already written in LaTeX — `$M_\star$` and the
+ * like. Escaping them as prose destroys the maths, so only a bare `&` or `%`
+ * is escaped here; everything else is passed through as the author wrote it.
+ */
+function escAbstract(value) {
+  return String(value).replace(/(?<!\\)([&%])/g, "\\$1");
+}
+
+/**
+ * "Family, Given", which is what BibTeX needs to tell the two apart — a plain
+ * "Nathaniel Starkman" would be guessed at, and "van der Waals" guessed wrong.
+ * A `literal` byline is braced so BibTeX treats it as one indivisible name.
+ */
+function bibName(a) {
+  if (a.literal) return `{${esc(a.literal)}}`;
+  const family = [a.family, a.suffix].filter(Boolean).join(' ');
+  return `${esc(family)}, ${esc(a.given)}`;
+}
+
+function names(item) {
+  const list = (item.authors ?? []).map(bibName);
+  // The collaboration leads the byline when it is set.
+  if (item.collaboration) list.unshift(`{${esc(item.collaboration)}}`);
+  return list.join(' and ');
+}
+
+export function toBibtex(item) {
+  if (item.type !== 'publication') return null;
+
+  const v = item.venue ?? {};
+  // The journal's issue date, where it differs from date.start; its month is
+  // never mixed with date.start's year.
+  const [startYear, startMonth] = (item.date?.start ?? '').split('-');
+  const year = v.year ?? startYear;
+  const month = v.year ? v.month : startMonth;
+
+  const fields = [
+    ['author', names(item)],
+    // Doubled braces protect the capitalisation BibTeX would otherwise flatten.
+    ['title', `{${esc(item.title)}}`],
+    ['journal', v.journal && esc(v.journal)],
+    ['booktitle', v.booktitle && esc(v.booktitle)],
+    ['school', v.school && esc(v.school)],
+    ['publisher', v.publisher && esc(v.publisher)],
+    ['series', v.series && esc(v.series)],
+    ['volume', v.volume && esc(v.volume)],
+    ['number', v.number && esc(v.number)],
+    ['pages', v.pages && esc(v.pages)],
+    ['address', v.address && esc(v.address)],
+    ['year', year],
+    ['month', month ? MONTHS[Number(month) - 1] : null],
+    ['doi', item.doi && esc(item.doi)],
+    ['eprint', item.arxiv],
+    ['archivePrefix', item.arxiv ? 'arXiv' : null],
+    ['primaryClass', item.primaryClass],
+    ['adsurl', item.bibcode ? `https://ui.adsabs.harvard.edu/abs/${item.bibcode}` : null],
+    ['abstract', item.abstract && escAbstract(item.abstract)],
+    // `status` is the only place "submitted"/"in prep" is recorded, so it has
+    // to reach the reader somehow; note is where BibTeX puts that.
+    ['note', item.status && item.status !== 'published'
+      ? item.status.replace('-', ' ')
+      : null],
+  ].filter(([, value]) => value !== null && value !== undefined && value !== '');
+
+  const width = Math.max(...fields.map(([k]) => k.length));
+  const body = fields
+    .map(([k, value]) => `  ${k.padEnd(width)} = {${value}}`)
+    .join(',\n');
+
+  return `@${item.entryType}{${citekey(item)},\n${body}\n}`;
+}
+
+const ascii = (s) =>
+  s.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^A-Za-z0-9-]/g, '');
+
+// The key is derived, never stored: [<Collab>+]<Lead>:<year>:<citeslug ?? id>.
+// <Lead> is one family name, two joined by "+", or the first with a trailing "+".
+// See constitution Article VI.
+export function citekey(item) {
+  const names = item.authors.map((a) => ascii(a.family ?? a.literal ?? ''));
+  const lead = names.length > 2 ? `${names[0]}+` : names.slice(0, 2).join('+');
+  const collab = item.collaboration
+    ? `${ascii(item.collaboration.replace(/^the\s+/i, '').replace(/\s+collaboration$/i, ''))}+`
+    : '';
+  return `${collab}${lead}:${item.date.start.slice(0, 4)}:${item.citeslug ?? item.id}`;
+}
+
+export function toBibliography(items) {
+  const entries = items
+    .filter((i) => i.type === 'publication')
+    .map(toBibtex)
+    .filter(Boolean);
+  return `${entries.join('\n\n')}\n`;
+}

package/src/collect.js

@@ -0,0 +1,83 @@
+// What a paper site keeps of the website's data to draw its card, its collaborator
+// map, its funding and its software citations: the item and the items it reaches,
+// as they are in data/ (but `internal`), and the slices of config/ they use.
+// createStore(snapshot) then runs the website's own functions on it.
+
+import { sortItems } from './store.js';
+
+export const SCHEMA = 1;
+const CONFIG = ['collaborators', 'journals', 'stars', 'places'];
+
+/** cards/<id>.json, the item's card choices, where it has one. */
+async function readCard(reader, id) {
+  let text;
+  try {
+    text = await reader.read(`cards/${id}.json`);
+  } catch (e) {
+    if (e.notFound) return null; // none: the default
+    throw e; // a failed read is not "no card"
+  }
+  const { $schema, ...card } = JSON.parse(text);
+  return card;
+}
+
+/** The snapshot for item `id`, read through `reader` (readers.js). */
+export async function collect(id, reader, { card } = {}) {
+  const index = await reader.index();
+  const items = new Map();
+  const get = async (ref, from) => {
+    if (items.has(ref)) return items.get(ref);
+    const path = index.get(ref);
+    if (!path) throw new Error(`no data file for "${ref}"${from ? ` (referenced by ${from})` : ''}`);
+    let item;
+    try {
+      item = JSON.parse(await reader.read(path));
+    } catch (e) {
+      throw new Error(`${path}${from ? ` (referenced by ${from})` : ''}: ${e.message}`);
+    }
+    delete item.internal;
+    delete item.$schema;
+    items.set(ref, item);
+    return item;
+  };
+
+  const root = await get(id);
+  // What it points at: its software (in its order), grants, highlights.
+  for (const ref of root.refs ?? []) {
+    const r = await get(ref, id);
+    // A package's own papers: its card's paper buttons and how to cite it.
+    if (r.type === 'software') for (const p of r.refs ?? []) await get(p, ref);
+  }
+  // My students among its authors, for their marks and profile links.
+  for (const a of root.authors ?? []) if (a.mentee) await get(a.mentee, id);
+
+  const config = Object.fromEntries(await Promise.all(CONFIG.map(async (k) => [k, JSON.parse(await reader.read(`config/${k}.json`))])));
+  const all = [...items.values()];
+  // The map is the paper's own co-authors: not those of the papers it reaches (its packages').
+  const orcids = new Set((root.authors ?? []).map((a) => a.orcid).filter(Boolean));
+  const people = config.collaborators.people.filter((p) => orcids.has(p.orcid));
+  const orgs = new Set([
+    ...people.flatMap((p) => p.affiliations.map((a) => a.organization)),
+    ...all.flatMap((i) => (i.journey ?? []).map((j) => j.organization)),
+  ]);
+  const places = Object.fromEntries(Object.entries(config.places.places).filter(([name]) => orgs.has(name)));
+  // A sameAs entry needs what it points at.
+  for (const p of Object.values(places)) if (p.sameAs) places[p.sameAs] = config.places.places[p.sameAs];
+  const repos = new Set(all.map((i) => i.repo).filter(Boolean));
+  const venues = new Set(all.flatMap((i) => [i.venue?.journal, i.venue?.booktitle]).filter(Boolean));
+
+  return {
+    schema: SCHEMA,
+    root: id,
+    source: reader.source,
+    items: sortItems(all),
+    config: {
+      collaborators: { ...config.collaborators, people },
+      journals: Object.fromEntries(Object.entries(config.journals).filter(([k]) => venues.has(k))),
+      stars: { ...config.stars, stars: Object.fromEntries(Object.entries(config.stars.stars).filter(([k]) => repos.has(k))) },
+      places: { ...config.places, places },
+      acknowledgements: { papers: [] },
+    },
+    card: card ?? (await readCard(reader, id)) ?? { preset: 'paperSite' },
+  };
+}

package/src/inline.js

@@ -0,0 +1,123 @@
+// A deliberately tiny inline-link syntax for `long` and `short`.
+//
+// The CV's detail lines carry links — the NSERC fellowships, a grant call, a
+// conference page — and rendering them as buttons underneath detaches them from
+// the words they belong to. Rather than adding rich text to the schema, `long`
+// may contain `[text](url)` and this splits it into spans.
+//
+// Spans, not HTML: the same model feeds the website and the Typst CV, and only
+// one of those understands markup.
+
+import { dateLabel } from '@nstarkman/research-store';
+import { sortAchievements } from './mentees.js';
+
+// `[text](https://…)` for the web, and `[text](item:some-id)` to point at
+// another entry on the same CV — the CV cross-references itself (a position
+// citing the grants that funded it) and a bare URL cannot express that.
+// `[](item:some-id)`, with no text, is for /research/'s topic introductions:
+// the span carries `item`, and the page fills in that paper's nickTitle.
+const LINK = /\[([^\]]*)\]\((https?:\/\/[^)\s]+|item:[a-z0-9-]+)\)/g;
+
+// `base` is where the cross-referenced entry lives. Empty on the CV, which
+// holds every entry itself; '/cv/' from any other page, so the reference is a
+// link there too rather than being flattened to plain text.
+const href = (target, base = '') =>
+  target.startsWith('item:') ? `${base}#item-${target.slice(5)}` : target;
+
+/**
+ * @param {string|string[]} text
+ * @param {string} [base]  prefix for `item:` targets, e.g. '/cv/'
+ * @returns {{t: string, url?: string, item?: string}[]}
+ */
+export function spans(text, base = '') {
+  if (!text) return [];
+  if (Array.isArray(text)) return text.flatMap((t) => spans(t, base));
+  const out = [];
+  let last = 0;
+  for (const m of text.matchAll(LINK)) {
+    if (m.index > last) out.push({ t: text.slice(last, m.index) });
+    const item = m[2].startsWith('item:') ? m[2].slice(5) : undefined;
+    out.push({ t: m[1], url: href(m[2], base), ...(item && { item }) });
+    last = m.index + m[0].length;
+  }
+  if (last < text.length) out.push({ t: text.slice(last) });
+  return out;
+}
+
+/** "1 talk", "3 talks", "2 entries". */
+export const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+
+/** 1 -> "1st", 2 -> "2nd", 11 -> "11th", 23 -> "23rd". */
+export const ordinal = (n) => {
+  const teen = n % 100 >= 11 && n % 100 <= 13;
+  return `${n}${(!teen && ['th', 'st', 'nd', 'rd'][n % 10]) || 'th'}`;
+};
+
+/** The same text with the link syntax stripped, for places that cannot link. */
+export const plain = (text) => (text ?? '').replace(LINK, '$1');
+
+/** Each line of a `long` as its own span list. A plain string is one line. */
+export function lines(long, base = '') {
+  return (Array.isArray(long) ? long : [long]).filter(Boolean).map((l) => spans(l, base));
+}
+
+/**
+ * An item's elaboration, one span array per line, in the order both renderers
+ * must use. Shared so the page and the PDF cannot disagree about what an
+ * entry's lines are — or, once the builder can tick them individually, about
+ * which line index a tick refers to.
+ *
+ * `complete` adds the lines only the complete CV shows. It is off by default so
+ * every caller that has not thought about it gets the discreet answer: a field
+ * whose whole purpose is to appear in one place should not leak into a fourth
+ * renderer by being forgotten about.
+ *
+ * The extra lines go last, after the thesis and supervisors, so a line index
+ * means the same thing whether or not they are included — the builder ticks
+ * lines by index, and inserting in the middle would silently move its ticks.
+ */
+export function detailLines(item, { complete = false } = {}) {
+  return [
+    ...lines(item.details),
+    ...(item.thesis ? [spans(`Thesis: ${item.thesis}`)] : []),
+    ...(item.supervisors?.length ? [spans(`Supervisors: ${item.supervisors.join(', ')}`)] : []),
+    ...(complete ? lines(item.detailsComplete) : []),
+  ];
+}
+
+/**
+ * A mentee's marked achievements, one span array per line, oldest first so the
+ * entry reads as a progression. They follow everything `detailLines` returns,
+ * so existing line indexes keep their meaning, and are gated by their own
+ * `cvs` rather than by the section's detail level: a short CV that drops
+ * details can still carry the one achievement worth a line. `complete` shows all.
+ */
+export function achievementLines(item, preset, { complete = false } = {}) {
+  return sortAchievements(item.achievements).reverse()
+    .filter((a) => complete || a.cvs?.includes(preset))
+    .map((a) => {
+      const what = a.url ? `[${a.title}](${a.url})` : a.title;
+      const where = a.event ?? a.outlet;
+      return spans(`${what}${where ? ` — ${where}` : ''} (${dateLabel({ date: { start: a.date } })})`);
+    });
+}
+
+/** Each achievement's `cvs`, in the order `achievementLines` prints them. */
+export const achievementCvs = (item) =>
+  sortAchievements(item.achievements).reverse().map((a) => a.cvs ?? []);
+
+/**
+ * Whether an achievement's line starts ticked when the builder is seeded from
+ * `preset`: the complete CV prints them all, any other only those it is marked for.
+ */
+export const achievementTicked = (cvs, preset, unabridged) =>
+  Boolean(unabridged) || (cvs ?? []).includes(preset);
+
+/**
+ * What kind of line index `i` is on an entry whose lines run: `base` detail
+ * lines, then complete-only ones up to `detailCount`, then achievements. The
+ * builder ticks by this — only the complete-only kind starts unticked on a
+ * preset that does not show it; a marked achievement is printed everywhere.
+ */
+export const lineTier = (i, baseCount, detailCount) =>
+  i < baseCount ? 'base' : i < detailCount ? 'complete' : 'achievement';

package/src/mentees.js

@@ -0,0 +1,89 @@
+// Mentees: the mentoring items that are a person, with a profile at /people/<slug>/.
+//
+// A mentee's papers and software are not listed on their record; they are found
+// from the other side, by the `mentee` id on a paper's author. The logic lives in
+// pure functions over arrays so the tests need no data; the wrappers at the
+// bottom hand them the database.
+
+import { byType, resolve, titleOf } from '@nstarkman/research-store';
+import { siteHref } from './urls.js';
+import { spans } from './inline.js';
+
+// Partial dates compare correctly as strings: "2026-04" > "2026" > "2025-07",
+// so the more precise date of two sharing a prefix sorts first, newest first.
+const newestFirst = (key) => (a, b) => (key(a) < key(b) ? 1 : key(a) > key(b) ? -1 : 0);
+const byStart = newestFirst((i) => i.date?.start ?? '');
+
+export const menteeName = (m) => `${m.person.given} ${m.person.family}`;
+/** What the collaborator map calls them: their ORCID, else their slug. */
+export const menteeKey = (m) => m.person.orcid ?? m.slug;
+export const profileHref = (m) => `/people/${m.slug}/`;
+// How a level reads in a sentence. A summer associate is not a student — Reem
+// wrote code with me, not research — so the label says what the role was.
+const LEVELS = { undergraduate: 'Undergraduate', graduate: 'Graduate', postbac: 'Postbac', postdoc: 'Postdoc', 'summer-associate': 'Summer associate' };
+export const levelLabel = (m) => LEVELS[m.person.level];
+
+/** The mentoring items that have a `person`, newest first. */
+export const pickMentees = (all) => all.filter((i) => i.type === 'mentoring' && i.person).sort(byStart);
+
+/** Publications with an author who is this mentee, newest first. */
+export const papersOf = (m, pubs) =>
+  pubs.filter((p) => p.authors?.some((a) => a.mentee === m.id)).sort(byStart);
+
+/** The packages that are theirs: each whose own paper (a package `refs` its
+ *  paper) is one of the mentee's, then any they are an author of, each once.
+ *  Not the packages their papers merely used — a paper refs those too, and a
+ *  student who ran galax did not write it. */
+export function softwareOf(m, papers, software) {
+  const ids = new Set(papers.map((p) => p.id));
+  const theirs = software.filter((s) => s.refs?.some((r) => ids.has(r)));
+  const authored = software.filter((s) => s.authors?.some((a) => a.mentee === m.id));
+  return [...new Set([...theirs, ...authored])];
+}
+
+export const sortAchievements = (list) => [...(list ?? [])].sort(newestFirst((a) => a.date));
+
+/** Awards first, then the rest, each newest first, cut to `n`. */
+export function pickTop(list, n = 3) {
+  const sorted = sortAchievements(list);
+  const isAward = (a) => a.kind === 'award';
+  return [...sorted.filter(isAward), ...sorted.filter((a) => !isAward(a))].slice(0, n);
+}
+
+export const achievements = (m) => sortAchievements(m.achievements);
+export const topAchievements = (m, n = 3) => pickTop(m.achievements, n);
+
+export const mentees = () => pickMentees(byType('mentoring'));
+export const menteeById = (id) => mentees().find((m) => m.id === id);
+export const menteeBySlug = (slug) => mentees().find((m) => m.slug === slug);
+export const menteePapers = (m) => papersOf(m, byType('publication'));
+export const menteeSoftware = (m) => softwareOf(m, menteePapers(m), byType('software'));
+
+/** `research` as spans with a link each: a `[](item:id)` is named by the item's
+ *  nickTitle and points at its place on this site, as /research/'s introductions
+ *  name theirs. An id naming no item throws, so a typo fails the build. */
+export const researchSpans = (text, lookup = resolve) =>
+  spans(text).map((s) => {
+    if (!s.item) return s;
+    const p = lookup(s.item);
+    if (!p) throw new Error(`research: [](item:${s.item}) names no item`);
+    return { ...s, t: s.t || titleOf(p, 'nick'), url: siteHref(p) };
+  });
+
+/** The first sentence of resolved spans, so an item link keeps its name. A stop
+ *  is not the end after "et al.", "e.g.", "i.e." or a lone initial like "J.". */
+export function firstSentenceSpans(list) {
+  const text = list.map((s) => s.t).join('');
+  let end = text.length;
+  for (const m of text.matchAll(/[.!?](?=\s|$)/g)) {
+    if (/(?:\bet al|\be\.g|\bi\.e|(?<![A-Za-z])[A-Z])$/.test(text.slice(0, m.index))) continue;
+    end = m.index + 1;
+    break;
+  }
+  let at = 0;
+  return list.flatMap((s) => {
+    const t = s.t.slice(0, Math.max(0, end - at));
+    at += s.t.length;
+    return t ? [{ ...s, t }] : [];
+  });
+}

package/src/places.js

@@ -0,0 +1,14 @@
+// Where a named place is on Earth.
+//
+// `config/places.json` holds each coordinate once. A name that is the same
+// campus as another — "University of Chicago" and "The University of Chicago",
+// SAO and the CfA — is written `{ "sameAs": "<other name>" }` instead of
+// repeating coordinates, so the two can never drift apart.
+
+import { config } from '@nstarkman/research-store';
+
+/** `{ lat, lon }` for a place name, or undefined when it is not placed. */
+export function locate(name) {
+  const p = config.places.places[name];
+  return p?.sameAs ? config.places.places[p.sameAs] : p;
+}

package/src/readers.js

@@ -0,0 +1,56 @@
+// Where collect() reads the website's files from: a checkout on disk, or GitHub
+// at a ref. A reader is { index(): Map<id, path of data/<date>-<id>.json>, read(path): text }.
+
+const DATA = /^data\/(\d{4}(?:-\d{2}){0,2})-([a-z0-9-]+)\.json$/;
+
+const indexOf = (paths) => new Map(paths.flatMap((p) => {
+  const m = p.match(DATA);
+  return m ? [[m[2], p]] : [];
+}));
+
+/** A file that is not there, told apart from a read that failed. */
+const notFound = (path) => Object.assign(new Error(`${path}: not found`), { notFound: true });
+
+/** The repository checked out at `root`. */
+export function fromDisk(root) {
+  return {
+    source: { root },
+    async index() {
+      const fs = await import('node:fs');
+      return indexOf(fs.readdirSync(`${root}/data`).map((f) => `data/${f}`));
+    },
+    async read(path) {
+      const fs = await import('node:fs');
+      try {
+        return fs.readFileSync(`${root}/${path}`, 'utf8');
+      } catch (e) {
+        throw e.code === 'ENOENT' ? notFound(path) : e;
+      }
+    },
+  };
+}
+
+/** `repo` (owner/name) on GitHub at `ref`: one listing from the tree API, then
+ *  raw files from the commit it resolved to, so every file is of one commit. */
+export function fromGitHub({ repo, ref = 'main', fetch = globalThis.fetch }) {
+  let sha;
+  const get = async (url, as, path) => {
+    const r = await fetch(url);
+    if (r.status === 404 && path) throw notFound(path);
+    if (!r.ok) throw new Error(`GET ${url}: ${r.status}`);
+    return as === 'json' ? r.json() : r.text();
+  };
+  return {
+    source: { repo, ref },
+    async index() {
+      const commit = await get(`https://api.github.com/repos/${repo}/commits/${ref}`, 'json');
+      sha = commit.sha;
+      const tree = await get(`https://api.github.com/repos/${repo}/git/trees/${sha}?recursive=1`, 'json');
+      this.source = { repo, ref, sha };
+      return indexOf(tree.tree.map((t) => t.path));
+    },
+    async read(path) {
+      return get(`https://raw.githubusercontent.com/${repo}/${sha ?? ref}/${path}`, 'text', path);
+    },
+  };
+}

package/src/store.js

@@ -0,0 +1,469 @@
+// The nstarkman.space data layer as a store: the functions every renderer sorts,
+// filters and formats items through, over whatever items and config snapshots it is
+// given — the website's whole data/ (its src/lib/data.js), or the slice of it a paper
+// site keeps (collect.js). Moved here from src/lib/data.js unchanged but for that.
+
+/**
+ * Partial dates (YYYY, YYYY-MM, YYYY-MM-DD) compare correctly as strings, so a
+ * month orders items inside a year even though only the year is ever shown.
+ *
+ * Work in preparation has no date to speak of — the year on the record is a
+ * guess that keeps the filename honest — so it sorts ahead of everything that
+ * has actually happened.
+ */
+const sortKey = (i) => (i.status === 'in-prep' ? '9999' : (i.date?.start ?? ''));
+const byDateDesc = (a, b) => sortKey(b).localeCompare(sortKey(a));
+
+/** Items newest first, as every list on the site has them. */
+export const sortItems = (items) => [...items].sort(byDateDesc);
+
+/**
+ * @param data.items  the items, newest first (sortItems)
+ * @param data.lists  the bare enumerations of data/lists/, by id
+ * @param data.config the config/ snapshots the functions read: collaborators,
+ *   acknowledgements, journals, stars (and places, for places.js)
+ */
+export function createStore({ items: given, lists = new Map(), config }) {
+  // Newest first, as every list has them (a no-op for the website's, already sorted).
+  const items = sortItems(given);
+  const { collaborators, acknowledgements, journals } = config;
+
+  const byId = new Map(items.map((i) => [i.id, i]));
+
+  const byType = (...types) => items.filter((i) => types.includes(i.type));
+  const featured = (...types) => byType(...types).filter((i) => i.featured);
+  const resolve = (id) => byId.get(id);
+
+  /** An item's title at one of three lengths: `full`, `short` (shortTitle) or
+   *  `nick` (nickTitle), each falling back to the next longer one. */
+  function titleOf(item, which = 'full') {
+    if (which === 'nick') return item.nickTitle ?? item.shortTitle ?? item.title;
+    if (which === 'short') return item.shortTitle ?? item.title;
+    return item.title;
+  }
+
+  /** The full title cut around its short title — [before, short, after], the
+   *  short part in the full title's own casing. Where the short title is not part
+   *  of the full one, the text before the first colon stands in; null if there is
+   *  neither. */
+  function splitTitle(item) {
+    let short = item.shortTitle;
+    let i = short ? item.title.toLowerCase().indexOf(short.toLowerCase()) : -1;
+    if (i < 0) {
+      i = 0;
+      short = item.title.split(': ')[0];
+    }
+    if (short === item.title) return null;
+    return [item.title.slice(0, i), item.title.slice(i, i + short.length), item.title.slice(i + short.length)];
+  }
+
+  // Research-highlight topics in the order /research/ shows them; a topic left
+  // out is not shown at all: `software` cards wait here. Anchored there as
+  // `#hl-topic-<key>`, which /publications/ links to.
+  //
+  // The third entry is the topic's introduction, one string per paragraph.
+  // `[](item:<id>)` puts that paper's inline-card into the sentence, named by its
+  // `nickTitle` and linking to its card below.
+  const HIGHLIGHT_TOPICS = [
+    ['extragalactic', 'Extragalactic', [
+      'Weighing a galaxy’s dark matter halo is comparatively easy: its rotation curve tells us how much gravitational mass is present. [](item:maximum-discs) turned decades of by-eye mass modelling into an algorithm for measuring how much of that gravity can be supplied by stars, while [](item:sparc-halo-density) found that haloes have remarkably similar characteristic densities across galaxies spanning five orders of magnitude in brightness. The harder—and more revealing—question is shape. Cold dark matter predicts haloes that are flattened and triaxial; self-interacting dark matter makes them rounder. Stellar streams are ideal probes because their paths trace the gravitational field, preserving a visible record of the halo geometry.',
+      'Our work turns that record into a scalable test of dark matter. [](item:potamides-apj) showed that projected stream tracks around nearby galaxies can constrain halo shape, using 15 systems; [](item:potamides-joss) made that inference run in minutes on a laptop. [](item:euclid-eggs-pilot) then took the method beyond the local Universe: it was the first analysis of stellar streams around more distant galaxies, and the first to combine multiple streams in a single joint halo-shape measurement—13 galaxies in Euclid’s first data. The real payoff is statistical: in a round halo, streams cannot curve away from their host galaxy’s centre in projection, while non-spherical haloes can produce such “wrong-way” curves. [](item:stream-convexity-rate) turns that signature into a population test: across about 10,000 streams, within reach of Euclid, Rubin and Roman, how often those curves appear can distinguish cold dark matter from self-interacting dark matter at up to 5σ.',
+    ]],
+    ['galactic', 'Galactic', [
+      'Galaxies forget. Stars that arrived in the same merger are gradually stirred into the Milky Way’s background, erasing the record of how it was assembled. [](item:galactic-amnesia) measures this loss of memory: radial velocities forget a merger’s mass and timing within about 5 billion years, but orbital energies retain the signal for more than 10—provided we know the Galaxy’s gravitational potential. Stellar streams are the exception. They are stars stripped from one cluster and stretched along nearly a single orbit, so one snapshot reveals a path that would take a single star hundreds of millions of years to trace. [](item:pal5-gaia-dr2) nearly doubled the known length of Palomar 5’s leading tail; [](item:stream-members-only) identifies a stream’s members star by star; and [](item:characterizing-stream-tracks) maps a stream’s path in about a second, without assuming a model for the Milky Way.',
+      'Streams probe dark matter on both large and small scales: the Galaxy-wide gravitational potential that guides their orbits, and the compact dark-matter clumps that perturb them. [](item:streamsculptor) finds that GD-1 may have been struck by up to a hundred subhaloes too small to form stars, leaving its stars moving about three times more randomly than an undisturbed stream would—just what cold dark matter predicts. [](item:pinns-mnras) learns the potential itself from measured accelerations: tested on simulated Milky Ways, it recovers the influence of both the Galactic bar and the Large Magellanic Cloud even when neither is included in the starting model.',
+    ]],
+    ['cmb', 'Cosmic Microwave Background', [
+      'The cosmic microwave background is almost a perfect blackbody, but its tiny spectral distortions contain information that its temperature map cannot provide. In [](item:cmb-spectrum-distortions), we calculate a signal that standard cosmology must produce. As the Universe became transparent, photons diffused out of hotter and colder regions, mixing blackbodies with slightly different temperatures. That mixing created a faint Compton y-distortion that is largest where the temperatures being mixed differ most, so it correlates with the squared temperature map. That correlation should already be detectable with ACT and SPT, at a signal-to-noise of about 12, opening a new observational test of early-Universe physics.',
+    ]],
+    ['dm-direct-detection', 'Dark Matter Direct Detection', [
+      'Direct detection usually means placing a shielded detector underground and waiting for a dark-matter particle to scatter. But if dark matter comes in macroscopic objects—far heavier, and therefore far rarer, than ordinary particle candidates—no laboratory detector is large enough to expect an encounter. In [](item:macro-lightning), we turn the atmosphere into the detector instead. A macro passing through a thunderstorm would leave a long, straight channel of ionized air that could seed a lightning bolt straight as a ruler, unlike the jagged bolts produced by ordinary storms; the odds of ordinary lightning running even ten steps that straight are about 3 in 10 trillion. Searching for straight lightning on Earth, or even on Jupiter, turns thunderstorms into planet-sized dark-matter experiments.',
+    ]],
+  ];
+
+  /**
+   * The areas of /software/, in order: [group, heading, introduction]. A
+   * package's `group` puts it in one; its `tier` sets its card's size there. The
+   * introduction may carry [text](url), as an item's `details` does.
+   */
+  const SOFTWARE_GROUPS = [
+    ['astropy', 'Astropy', 'The community core package for astronomy in Python, and cosmology.api, a standard interface for cosmology libraries.'],
+    ['foundations', 'Foundations: Arrays, Units & Coordinates', 'The layers the rest is built on, in JAX: quax lets custom array types through JAX’s primitives, with plum’s multiple dispatch beneath it; unxt adds units, and coordinax vectors, frames and transformations.'],
+    ['dynamics', 'Galactic Dynamics & Streams', 'Orbits, potentials and the stellar streams that trace them: galax integrates orbits and generates streams, and the rest measure streams and learn potentials — most of it in JAX, on the foundations above.'],
+    ['dark-matter', 'Dark Matter Direct Detection', 'The code behind searching thunderstorms for macroscopic dark matter.'],
+    ['numerics', 'Numerics', 'Numerical pieces JAX was missing: extras for Diffrax, scipy.special, bounded loops and kernel density estimates.'],
+    ['utilities', 'Utilities', 'Small, general-purpose packages that fell out of the work above.'],
+  ];
+
+  /** "Nathaniel" -> "N."; "Adrian M." -> "A. M."  */
+  function initials(given) {
+    return given
+      .split(/\s+/)
+      .filter(Boolean)
+      .map((part) => (part.endsWith('.') ? part : `${part[0].toUpperCase()}.`))
+      .join(' ');
+  }
+
+  /** Display form. BibTeX uses "Family, Given" instead — see lib/bibtex.js. */
+  function displayName(a) {
+    if (a.literal) return a.literal;
+    return [initials(a.given), a.family, a.suffix].filter(Boolean).join(' ');
+  }
+
+  const POSITION_NAMES = { first: 1, second: 2, third: 3, fourth: 4 };
+
+  /**
+   * Which author position the owner holds, 1-based, or null if he is not on it.
+   *
+   * Derived from the index of the author marked `me` rather than stored, so it
+   * cannot drift out of step with the author list. `collaboration` is its own
+   * field and takes no slot, which is why the Euclid paper comes out first-author
+   * even though it prints as "Euclid Collaboration, N. Starkman, …".
+   *
+   * A record can still override with `authorPosition` for the case derivation
+   * cannot see: a byline that understates the credit.
+   */
+  function authorPosition(item) {
+    const explicit = item.authorPosition;
+    if (typeof explicit === 'number') return explicit;
+    if (typeof explicit === 'string') return POSITION_NAMES[explicit] ?? null;
+    const i = (item.authors ?? []).findIndex((a) => a.me);
+    return i === -1 ? null : i + 1;
+  }
+
+  /**
+   * The article's page at the journal, or null.
+   *
+   * Only for published work: a submitted paper has no article page, and pointing
+   * its venue at an arXiv DOI would claim otherwise.
+   *
+   * The record's own `paper` link wins over the DOI because it is the curated
+   * one — often the publisher's own reader rather than the doi.org redirect. The
+   * ADS link that `links()` synthesises from a bibcode is deliberately not used:
+   * ADS is a database record about the paper, not the journal's page for it.
+   */
+  function venueUrl(item) {
+    if (item.status !== 'published') return null;
+    const curated = (item.links ?? []).find((l) => l.rel === 'paper' && l.url);
+    if (curated) return curated.url;
+    // 10.48550 is arXiv's own prefix — a preprint DOI, not a journal article.
+    if (item.doi && !item.doi.startsWith('10.48550/')) return `https://doi.org/${item.doi}`;
+    return null;
+  }
+
+  /**
+   * A package's papers, where the record points at any, oldest first.
+   *
+   * `unxt` refs `unxt-joss`, `astropy` refs the v5 paper, `trackstream` refs the
+   * stream-tracks paper. The software entry itself carries only code and docs
+   * links, so without following the ref a published package looks unpublished.
+   *
+   * `refs` is not a paper field: `coordinax` refs `unxt`, another package. Hence
+   * the type check — it is what stops a package being called published because
+   * it happens to point at a sibling.
+   *
+   * The package's own date is when the repository started; each paper carries
+   * its own year, so a package with a second paper shows two. Nothing is copied
+   * onto the software record, so the dates cannot drift from the papers'.
+   */
+  function softwarePapers(sw) {
+    const out = [];
+    for (const id of sw.refs ?? []) {
+      const ref = resolve(id);
+      if (ref?.type !== 'publication') continue;
+      // In prep has no year to claim — dateLabel says the same.
+      const year = ref.status === 'in-prep' ? null : String(ref.date.start).slice(0, 4);
+      const paper = { rel: 'paper', label: year ? `paper ${year}` : 'paper', id: ref.id, status: ref.status, year };
+      // The article at the journal first. Taking the first citation link instead
+      // sent Astropy to its ADS record and macro_lightning to its arXiv preprint.
+      const article = venueUrl(ref);
+      // Nothing published yet: a preprint or a review thread is what there is.
+      const url = article ?? primaryLink(ref)?.url;
+      if (url) out.push({ ...paper, url });
+    }
+    return out.sort((a, b) => (a.year ?? '9999').localeCompare(b.year ?? '9999'));
+  }
+
+  /**
+   * The packages of mine a set of papers used, most-used first, and otherwise
+   * in the order the papers name them — a paper names its main package first,
+   * so for one paper that leads.
+   *
+   * The other direction from softwarePapers: a paper's `refs` name the packages
+   * it used, read from its software section, so /research/ can list a topic's
+   * software under its papers. A package's own paper refs it too (`unxt-joss`
+   * refs `unxt`), which is the use it was written for.
+   */
+  function softwareUsed(papers) {
+    const n = new Map();
+    for (const p of papers) {
+      for (const id of p.refs ?? []) {
+        const s = resolve(id);
+        if (s?.type === 'software') n.set(s, (n.get(s) ?? 0) + 1);
+      }
+    }
+    // A Map keeps first-seen order and sort is stable, so ties keep it.
+    return [...n].sort((a, b) => b[1] - a[1]).map(([s]) => s);
+  }
+
+  /** Where a co-author's name points. ORCID is the identifier, so it is the link. */
+  const orcidUrl = (orcid) => (orcid ? `https://orcid.org/${orcid}` : null);
+
+  /**
+   * Where a collaborator was working on a given date, from the dated employment
+   * history in config/collaborators.json.
+   *
+   * Returns null rather than a guess in three cases worth keeping separate in the
+   * caller's mind: the person is not in the database, they list no employment on
+   * ORCID, or nothing they list covers that date. A gap in a career is real —
+   * people leave posts before starting the next — and papering over one would be
+   * inventing a fact.
+   *
+   * `date` is "YYYY" or "YYYY-MM"; the comparisons are string comparisons, which
+   * is why the database stores dates in that order.
+   */
+  function affiliationAt(orcid, date) {
+    if (!orcid || !date) return null;
+    const person = collaborators.people.find((p) => p.orcid === orcid);
+    if (!person) return null;
+    const held = person.affiliations.filter((a) => {
+      if (!a.start) return false;        // undated: cannot claim it covered this date
+      if (a.start > date) return false;
+      return !a.end || a.end >= date;
+    });
+    if (held.length === 0) return null;
+    // Concurrent posts happen; the most recently taken up is the one a paper of
+    // that date would most likely have printed.
+    return held.reduce((best, a) => (a.start > best.start ? a : best));
+  }
+
+  const ELLIPSIS = { name: '…', me: false, student: null, url: null, affiliation: null };
+
+  /**
+   * Authors for display, truncated per preset. The data always holds the full
+   * list — truncating there would corrupt the BibTeX — so it happens here.
+   *
+   * `url` is the author's ORCID page, and is null for the owner: this is his own
+   * site, his ORCID is already in the CV header, and a self-link in every byline
+   * would be noise rather than navigation.
+   */
+  function authors(item, max = Infinity, { fill = false } = {}) {
+    const all = item.authors ?? [];
+    // Where they were at the time. The paper's own printed affiliation wins where
+    // there is one — that is what the paper actually claimed — and the employment
+    // history answers for the rest.
+    const at = item.date?.start ?? null;
+    // Cutting at `max` would drop the owner into "et al." — the one name a CV's
+    // reader is looking for. Keep the first author and elide to the owner instead: "J. Nibauer, …, N. Starkman, et al."
+    // At one name, there is room only for mine: "…, N. Starkman, et al." With
+    // `fill`, the cut is exactly `max` names, those before the elision filling
+    // it: at three, "J. Nibauer, A. Bonaca, …, N. Starkman, et al."
+    const meAt = all.findIndex((a) => a.me);
+    const elide = max >= 1 && meAt >= max;
+    const before = fill ? all.slice(0, max - 1) : all.slice(0, Math.min(1, max - 1));
+    const picked = !elide ? all.slice(0, max) : [...before, null, all[meAt]];
+    const shown = picked.map((a) => a === null ? ELLIPSIS : ({
+      name: displayName(a),
+      me: Boolean(a.me),
+      student: a.student ?? null,
+      orcid: a.me ? null : (a.orcid ?? null),
+      url: a.me ? null : orcidUrl(a.orcid),
+      affiliation: a.me ? null : (a.affiliation ?? affiliationAt(a.orcid, at)?.organization ?? null),
+    }));
+    return { shown, etal: all.length > (elide ? meAt + 1 : max), collaboration: item.collaboration };
+  }
+
+  /**
+   * Author-position stops for a "first author / first two / …" filter. A stop
+   * that admits the same papers as the one before it, or as all of them, is a
+   * control that does nothing — with positions 1, 2 and 4 that leaves 1 and 2.
+   * Items with no position (not a publication, or no author marked `me`) are
+   * ignored.
+   */
+  function positionStops(items) {
+    const positions = items.map(authorPosition).filter((n) => n != null);
+    const stops = [];
+    for (let n = 1; n <= 4; n += 1) {
+      const count = positions.filter((p) => p <= n).length;
+      const previous = stops.length ? stops[stops.length - 1].count : 0;
+      if (count > previous && count < positions.length) stops.push({ n, count });
+    }
+    return stops;
+  }
+
+  /** "USD 10,000", "CAD 20,000\u201330,000 p.a.", or null. */
+  function money(a) {
+    if (!a) return null;
+    const n = (v) => v.toLocaleString('en-US');
+    const span = a.valueMax ? `${n(a.value)}\u2013${n(a.valueMax)}` : n(a.value);
+    return `${a.currency} ${span}${a.perAnnum ? ' p.a.' : ''}`;
+  }
+
+  /** "The Astrophysical Journal 979, 155"; short, "ApJ 979, 155", where
+   * config/journals.json has the journal's short name. */
+  function venueLine(item, { short = false } = {}) {
+    const v = item.venue;
+    if (!v) return '';
+    const full = v.journal ?? v.booktitle ?? v.school ?? '';
+    const title = short ? journals[full] ?? full : full;
+    const tail = [v.volume, v.pages].filter(Boolean).join(', ');
+    return [title, tail].filter(Boolean).join(' ');
+  }
+
+  const year = (item) => (item.date?.start ?? '').slice(0, 4);
+
+  /** "2024 –", "2018 – 2024", "2025" */
+  const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+                 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+  /**
+   * @param {object} item
+   * @param {{month?: boolean}} [opts]
+   *   `month` spells a single date as "Feb 2024" where the record has one. Ranges
+   *   stay year-only either way — "Feb 2018 – Jun 2024" is noise, and the CV this
+   *   replaces wrote them as years too.
+   */
+  function dateLabel(item, { month = false } = {}) {
+    // A year on an in-preparation paper would be a claim it cannot support.
+    if (item.status === 'in-prep') return 'In Prep';
+    const { start, end, present } = item.date ?? {};
+    const y = (d) => (d ?? '').slice(0, 4);
+    if (present) return `${y(start)} –`;
+    if (end) return `${y(start)} – ${y(end)}`;
+    const [, mm] = (start ?? '').split('-');
+    return month && mm ? `${MONTHS[Number(mm) - 1]} ${y(start)}` : y(start);
+  }
+
+  // Order links land in. The paper itself leads: the article at the journal,
+  // then the records of it, then everything that is code or data.
+  const REL_ORDER = ['paper', 'doi', 'ads', 'preprint', 'repo', 'code',
+                     'docs', 'data', 'slides', 'event', 'homepage'];
+
+  /**
+   * The vocabulary key for a link. ADS is synthesised as a `paper` rel, so the
+   * label is what distinguishes it — ordering and iconography must agree on that
+   * or the ADS link sorts first and then draws the generic paper glyph.
+   */
+  const relKey = (l) => (l.label === 'ADS' ? 'ads' : l.rel);
+
+  // Real marks where one exists, a drawn glyph otherwise. Keyed by the same
+  // closed vocabulary, so a new rel is a visible gap rather than a silent
+  // fallback everywhere.
+  const REL_ICON = {
+    ads: 'ads', preprint: 'arxiv', paper: 'paper', doi: 'paper', repo: 'repo',
+    code: 'github', stars: 'star', docs: 'docs', data: 'data', slides: 'slides',
+    event: 'link', homepage: 'link',
+  };
+
+  /**
+   * The one link a title points at: the article, else the preprint, else its
+   * ADS record, else null. The ADS link is synthesised as a `paper` rel, so it
+   * is told apart by relKey — taking the first `paper` sent titles to ADS ahead
+   * of arXiv and the DOI. No fallback to code or docs — a paper's title linking
+   * to its repository would be a surprise, and a submitted paper with nothing
+   * public stays a bare title rather than a dead '#'.
+   */
+  function primaryLink(item) {
+    const all = links(item);
+    const by = (k) => all.find((l) => relKey(l) === k);
+    const article = venueUrl(item);
+    return by('paper') ?? (article ? { rel: 'doi', url: article, label: item.doi } : null)
+      ?? by('doi') ?? by('preprint') ?? by('ads') ?? null;
+  }
+
+  /**
+   * Links for rendering, in REL_ORDER. The ADS entry is synthesised from
+   * `bibcode` rather than stored, so a paper can never carry a bibcode and a
+   * contradicting ADS URL.
+   */
+  function links(item) {
+    // Copies: the label set below is the rendering's, not the record's.
+    const out = (item.links ?? []).map((l) => ({ ...l }));
+    if (item.bibcode) {
+      out.push({
+        rel: 'paper',
+        url: `https://ui.adsabs.harvard.edu/abs/${item.bibcode}/abstract`,
+        label: 'ADS',
+      });
+    }
+    if (item.arxiv && !out.some((l) => l.rel === 'preprint')) {
+      out.push({
+        rel: 'preprint',
+        url: `https://arxiv.org/abs/${item.arxiv}`,
+        label: `arXiv:${item.arxiv}`,
+      });
+    }
+    for (const l of out) {
+      if ((l.rel === 'paper' || l.rel === 'doi') && !l.label && item.doi) l.label = item.doi;
+    }
+
+    const rank = (l) => {
+      const i = REL_ORDER.indexOf(relKey(l));
+      return i === -1 ? REL_ORDER.length : i;
+    };
+    return out.sort((a, b) => rank(a) - rank(b));
+  }
+
+  /**
+   * Papers that thank him in their acknowledgements, newest first: the Assists
+   * on /publications/. Not items — he did not write them — but given `links`
+   * so links() and primaryLink() read them like one. arXiv's own DOI prefix is a
+   * preprint, which `arxiv` already links, not a journal article.
+   */
+  const assists = acknowledgements.papers.map((p) => ({
+    ...p,
+    links: p.doi && !p.doi.startsWith('10.48550/') ? [{ rel: 'paper', url: `https://doi.org/${p.doi}` }] : [],
+  }));
+
+  /** An Assist as a card reads a paper: published, dated and placed as an item
+   *  is. Its venue is ADS's short name, set as the journal. */
+  const assistItem = (a) => ({
+    ...a, id: `assist-${a.bibcode ?? a.arxiv}`, type: 'publication', status: 'published',
+    date: { start: a.date }, venue: { journal: a.venue },
+  });
+
+  /** Whether roles at one institution group by default: when every one opts in
+   *  with `groupRoles`. The CV builder may choose otherwise, per institution. */
+  const groupedByDefault = (items) => items.every((i) => i.groupRoles);
+
+  /**
+   * Positions at one institution, grouped where `grouped(items)` says so — by
+   * default where every role opts in with `groupRoles`. Appointments in the same
+   * organization then read as one place with several roles. A group sits where
+   * its earliest member does, as its dates start there; every other item stays
+   * where it is. Returns `[{ items }]` for a group, `[{ item }]` otherwise.
+   */
+  function institutionGroups(list, grouped = groupedByDefault) {
+    const at = new Map();
+    for (const item of list) {
+      if (item.institution) at.set(item.institution, [...(at.get(item.institution) ?? []), item]);
+    }
+    const groups = new Map([...at].filter(([, items]) => items.length > 1 && grouped(items)));
+    const out = [];
+    for (const item of list) {
+      const items = groups.get(item.institution);
+      if (!items) out.push({ item });
+      else if (item === items.at(-1)) out.push({ items });
+    }
+    return out;
+  }
+
+  /** A group's roles joined as one title — "Coordinator (2025 – 2028) & Core
+   *  Developer" — a role's own dates given where they differ from the group's. */
+  function groupTitle(items) {
+    const span = dateLabel({ date: groupDate(items) });
+    const names = items.map((i) => (dateLabel(i) === span ? i.title : `${i.title} (${dateLabel(i)})`));
+    return names.length > 1 ? `${names.slice(0, -1).join(', ')} & ${names.at(-1)}` : names[0];
+  }
+
+  /** The span a group of dated items covers, as one item's `date`: earliest start,
+   *  and open-ended if any member is, else the latest end. */
+  function groupDate(items) {
+    const start = items.map((i) => i.date.start).sort()[0];
+    if (items.some((i) => i.date.present)) return { start, present: true };
+    const end = items.map((i) => i.date.end ?? i.date.start).sort().at(-1);
+    return { start, end };
+  }
+
+  return { items, lists, config, byType, featured, resolve, titleOf, splitTitle, HIGHLIGHT_TOPICS, SOFTWARE_GROUPS, displayName, authorPosition, venueUrl, softwarePapers, softwareUsed, affiliationAt, authors, positionStops, money, venueLine, year, dateLabel, relKey, REL_ICON, primaryLink, links, assists, assistItem, groupedByDefault, institutionGroups, groupTitle, groupDate };
+}

package/src/urls.js

@@ -0,0 +1,9 @@
+// Where an item's entry is on nstarkman.space — site-absolute, so a paper site at
+// nstarkman.space/<repo>/ links back into the website.
+
+/** Where it links with title:…:site — the item's entry on this site, where
+ *  it has one: a paper on /publications/ (an in-prep one is not listed), a
+ *  package on /software/, a synthesis on /research/. */
+export const siteHref = (item) => (item.type === 'publication' ? (item.status !== 'in-prep' ? `/publications/#pub-${item.id}` : null)
+  : item.type === 'software' ? `/software/#sw-${item.id}` : item.type === 'highlight' ? `/research/#hl-${item.id}` : null);
+