explico 0.1.0

package/src/curriculum/validation.ts

@@ -0,0 +1,481 @@
+export interface CompetencyDefinition {
+  readonly id: string;
+  readonly title: string;
+  readonly prerequisites: readonly string[];
+  readonly evidence: {
+    readonly minimumIndependentItems: number;
+    readonly requiresTransfer: boolean;
+    readonly requiresUnassistedPass: boolean;
+  };
+}
+
+export interface LessonDefinition {
+  readonly id: string;
+  readonly status: 'draft' | 'in-review' | 'reviewed';
+  readonly requires: readonly string[];
+  readonly teaches: readonly string[];
+  readonly assessments: readonly string[];
+  readonly sources: readonly string[];
+  readonly assumptions: readonly string[];
+  /** Raw Markdown body, used to keep inline `[@…]` citations in sync with `sources`. */
+  readonly body?: string;
+}
+
+interface AssessmentItemBase {
+  readonly id: string;
+  readonly competencyId: string;
+  readonly evidenceKind: 'direct' | 'transfer';
+}
+
+export interface NumericAssessmentItem extends AssessmentItemBase {
+  readonly type: 'numeric';
+  readonly answer: { readonly value: number; readonly tolerance: number };
+}
+
+export interface ChoiceAssessmentItem extends AssessmentItemBase {
+  readonly type: 'single-choice';
+  readonly options: readonly { readonly id: string; readonly label: string }[];
+  readonly correctOptionId: string;
+}
+
+export interface AssessmentDefinition {
+  readonly id: string;
+  readonly items: readonly (NumericAssessmentItem | ChoiceAssessmentItem)[];
+}
+
+export interface SourceDefinition {
+  readonly id: string;
+  readonly editorialStatus: 'draft' | 'in-review' | 'reviewed';
+}
+
+export interface TrackDefinition {
+  readonly id: string;
+  readonly lessons: readonly string[];
+}
+
+export interface CurriculumCatalog {
+  readonly competencies: readonly CompetencyDefinition[];
+  readonly lessons: readonly LessonDefinition[];
+  readonly assessments: readonly AssessmentDefinition[];
+  readonly sources: readonly SourceDefinition[];
+  readonly tracks: readonly TrackDefinition[];
+}
+
+export interface CurriculumIssue {
+  readonly kind:
+    | 'invalid-id'
+    | 'duplicate-id'
+    | 'unknown-reference'
+    | 'duplicate-reference'
+    | 'self-prerequisite'
+    | 'cycle'
+    | 'lesson-order'
+    | 'track-order'
+    | 'assessment-coverage'
+    | 'invalid-assessment'
+    | 'review-state'
+    | 'teaches-support';
+  readonly message: string;
+  /**
+   * `error` (default) blocks the build; `warning` is reported but non-blocking.
+   * New checks enter as warnings and are promoted once they run clean on real
+   * content.
+   */
+  readonly severity?: 'error' | 'warning';
+}
+
+const VALID_ID = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+
+function buildIndex<T extends { readonly id: string }>(
+  kind: string,
+  entries: readonly T[],
+  issues: CurriculumIssue[],
+): Map<string, T> {
+  const index = new Map<string, T>();
+  for (const entry of entries) {
+    if (!VALID_ID.test(entry.id)) {
+      issues.push({
+        kind: 'invalid-id',
+        message: `${kind} has invalid id ${JSON.stringify(entry.id)}`,
+      });
+      continue;
+    }
+    if (index.has(entry.id)) {
+      issues.push({
+        kind: 'duplicate-id',
+        message: `duplicate ${kind} id ${entry.id}`,
+      });
+      continue;
+    }
+    index.set(entry.id, entry);
+  }
+  return index;
+}
+
+/**
+ * Source ids referenced by `[@id]` (optionally `[@id; locator]`) in a lesson
+ * body, with fenced and inline code removed first so an example of the syntax
+ * does not count as a real citation.
+ */
+function citedSourceIds(body: string | undefined): Set<string> {
+  if (!body) return new Set();
+  const withoutCode = body
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`\n]*`/g, '');
+  const ids = new Set<string>();
+  for (const match of withoutCode.matchAll(
+    /\[@([a-z0-9][a-z0-9.-]*)(?:;[^\]]*)?\]/g,
+  )) {
+    ids.add((match[1] ?? '').trim());
+  }
+  return ids;
+}
+
+function findDuplicates(values: readonly string[]): readonly string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates];
+}
+
+function validateCompetencyGraph(
+  competencies: ReadonlyMap<string, CompetencyDefinition>,
+  issues: CurriculumIssue[],
+): void {
+  for (const competency of competencies.values()) {
+    for (const prerequisiteId of findDuplicates(competency.prerequisites)) {
+      issues.push({
+        kind: 'duplicate-reference',
+        message: `${competency.id} repeats prerequisite ${prerequisiteId}`,
+      });
+    }
+    for (const prerequisiteId of competency.prerequisites) {
+      if (prerequisiteId === competency.id) {
+        issues.push({
+          kind: 'self-prerequisite',
+          message: `${competency.id} requires itself`,
+        });
+      } else if (!competencies.has(prerequisiteId)) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${competency.id} requires unknown competency ${prerequisiteId}`,
+        });
+      }
+    }
+  }
+
+  const state = new Map<string, 'visiting' | 'visited'>();
+  const stack: string[] = [];
+  const reportedCycles = new Set<string>();
+
+  const visit = (id: string): void => {
+    state.set(id, 'visiting');
+    stack.push(id);
+
+    for (const prerequisiteId of competencies.get(id)?.prerequisites ?? []) {
+      if (prerequisiteId === id || !competencies.has(prerequisiteId)) continue;
+      const prerequisiteState = state.get(prerequisiteId);
+      if (prerequisiteState === undefined) {
+        visit(prerequisiteId);
+      } else if (prerequisiteState === 'visiting') {
+        const start = stack.lastIndexOf(prerequisiteId);
+        const path = [...stack.slice(start), prerequisiteId];
+        const key = [...new Set(path)].sort().join('|');
+        if (!reportedCycles.has(key)) {
+          reportedCycles.add(key);
+          issues.push({
+            kind: 'cycle',
+            message: `prerequisite cycle: ${path.join(' -> ')}`,
+          });
+        }
+      }
+    }
+
+    stack.pop();
+    state.set(id, 'visited');
+  };
+
+  for (const id of competencies.keys()) {
+    if (state.get(id) === undefined) visit(id);
+  }
+}
+
+/**
+ * Provisional signal that a lesson body instantiates its content with numbers:
+ * a worked-example component or section, or an equation that evaluates to a
+ * numeral (`… = 6.`). Deliberately broad — this gates a warning, and the
+ * heuristic is expected to tighten (or be replaced by `equation-instantiated`)
+ * as content is reviewed.
+ */
+const WORKED_INSTANCE =
+  /<CompactExample\b|^#{1,6}\s+.*\b(?:worked|example)\b|=\s*-?\d|\d\.\d{3,}/im;
+
+/**
+ * `teaches`-support lint (Phase C1, warning tier): every competency a lesson
+ * `teaches` needs both a worked instance in the body and at least one
+ * assessment item measuring it. Enters as a warning; promoted once real
+ * content runs clean. Owns nothing the stricter Tier-1 checks
+ * (`assessment-measures-taught`, `equation-instantiated`) will later cover.
+ */
+function validateTeachesSupport(
+  lessons: ReadonlyMap<string, LessonDefinition>,
+  evidenceByCompetency: ReadonlyMap<string, { count: number }>,
+  issues: CurriculumIssue[],
+): void {
+  for (const lesson of lessons.values()) {
+    if (lesson.teaches.length === 0) continue;
+
+    if (!WORKED_INSTANCE.test(lesson.body ?? '')) {
+      issues.push({
+        kind: 'teaches-support',
+        severity: 'warning',
+        message: `${lesson.id} teaches ${lesson.teaches.join(', ')} but the body has no worked instance (CompactExample or a worked-example section)`,
+      });
+    }
+
+    const unmeasured = lesson.teaches.filter(
+      (competencyId) =>
+        (evidenceByCompetency.get(competencyId)?.count ?? 0) === 0,
+    );
+    if (unmeasured.length > 0) {
+      issues.push({
+        kind: 'teaches-support',
+        severity: 'warning',
+        message: `${lesson.id} teaches ${unmeasured.join(', ')} with no assessment item measuring it`,
+      });
+    }
+  }
+}
+
+export function validateCurriculum(
+  catalog: CurriculumCatalog,
+): readonly CurriculumIssue[] {
+  const issues: CurriculumIssue[] = [];
+  const competencies = buildIndex('competency', catalog.competencies, issues);
+  const lessons = buildIndex('lesson', catalog.lessons, issues);
+  const assessments = buildIndex('assessment', catalog.assessments, issues);
+  const sources = buildIndex('source', catalog.sources, issues);
+  const tracks = buildIndex('track', catalog.tracks, issues);
+
+  validateCompetencyGraph(competencies, issues);
+
+  for (const lesson of lessons.values()) {
+    for (const field of ['requires', 'teaches'] as const) {
+      for (const duplicate of findDuplicates(lesson[field])) {
+        issues.push({
+          kind: 'duplicate-reference',
+          message: `${lesson.id} repeats ${field} competency ${duplicate}`,
+        });
+      }
+      for (const competencyId of lesson[field]) {
+        if (!competencies.has(competencyId)) {
+          issues.push({
+            kind: 'unknown-reference',
+            message: `${lesson.id} ${field} unknown competency ${competencyId}`,
+          });
+        }
+      }
+    }
+
+    for (const competencyId of lesson.requires) {
+      if (lesson.teaches.includes(competencyId)) {
+        issues.push({
+          kind: 'lesson-order',
+          message: `${lesson.id} both requires and teaches ${competencyId}`,
+        });
+      }
+    }
+
+    const available = new Set(lesson.requires);
+    for (const competencyId of lesson.teaches) {
+      const competency = competencies.get(competencyId);
+      if (competency) {
+        for (const prerequisiteId of competency.prerequisites) {
+          if (!available.has(prerequisiteId)) {
+            issues.push({
+              kind: 'lesson-order',
+              message: `${lesson.id} teaches ${competencyId} before prerequisite ${prerequisiteId} is available`,
+            });
+          }
+        }
+      }
+      available.add(competencyId);
+    }
+
+    for (const assessmentId of lesson.assessments) {
+      if (!assessments.has(assessmentId)) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${lesson.id} references unknown assessment ${assessmentId}`,
+        });
+      }
+    }
+    const cited = citedSourceIds(lesson.body);
+    for (const sourceId of lesson.sources) {
+      const source = sources.get(sourceId);
+      if (!source) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${lesson.id} references unknown source ${sourceId}`,
+        });
+      } else if (
+        lesson.status === 'reviewed' &&
+        source.editorialStatus !== 'reviewed'
+      ) {
+        issues.push({
+          kind: 'review-state',
+          message: `${lesson.id} is reviewed but source ${sourceId} is ${source.editorialStatus}`,
+        });
+      }
+      if (lesson.body !== undefined && !cited.has(sourceId)) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${lesson.id} declares source ${sourceId} but never cites it with [@${sourceId}]`,
+        });
+      }
+    }
+    for (const sourceId of cited) {
+      if (!lesson.sources.includes(sourceId)) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${lesson.id} cites ${sourceId} in prose but does not list it in frontmatter sources`,
+        });
+      }
+    }
+    if (lesson.teaches.length > 0 && lesson.assumptions.length === 0) {
+      issues.push({
+        kind: 'review-state',
+        message: `${lesson.id} teaches quantitative content but declares no assumptions`,
+      });
+    }
+  }
+
+  const itemIds = new Set<string>();
+  const evidenceByCompetency = new Map<
+    string,
+    { count: number; hasTransfer: boolean }
+  >();
+
+  for (const assessment of assessments.values()) {
+    for (const item of assessment.items) {
+      if (itemIds.has(item.id)) {
+        issues.push({
+          kind: 'duplicate-id',
+          message: `duplicate assessment item id ${item.id}`,
+        });
+      }
+      itemIds.add(item.id);
+
+      if (!competencies.has(item.competencyId)) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${assessment.id}/${item.id} measures unknown competency ${item.competencyId}`,
+        });
+      }
+
+      if (item.type === 'single-choice') {
+        if (
+          !item.options.some((option) => option.id === item.correctOptionId)
+        ) {
+          issues.push({
+            kind: 'invalid-assessment',
+            message: `${assessment.id}/${item.id} has unknown correct option ${item.correctOptionId}`,
+          });
+        }
+      } else if (
+        !Number.isFinite(item.answer.value) ||
+        !Number.isFinite(item.answer.tolerance) ||
+        item.answer.tolerance <= 0
+      ) {
+        issues.push({
+          kind: 'invalid-assessment',
+          message: `${assessment.id}/${item.id} has an invalid numeric answer or tolerance`,
+        });
+      }
+
+      const evidence = evidenceByCompetency.get(item.competencyId) ?? {
+        count: 0,
+        hasTransfer: false,
+      };
+      evidence.count += 1;
+      evidence.hasTransfer ||= item.evidenceKind === 'transfer';
+      evidenceByCompetency.set(item.competencyId, evidence);
+    }
+  }
+
+  const taughtCompetencies = new Set(
+    [...lessons.values()].flatMap((lesson) => [...lesson.teaches]),
+  );
+  for (const competencyId of taughtCompetencies) {
+    const competency = competencies.get(competencyId);
+    if (!competency) continue;
+    const evidence = evidenceByCompetency.get(competencyId) ?? {
+      count: 0,
+      hasTransfer: false,
+    };
+    if (evidence.count < competency.evidence.minimumIndependentItems) {
+      issues.push({
+        kind: 'assessment-coverage',
+        message: `${competencyId} has ${evidence.count} assessment item(s), fewer than required ${competency.evidence.minimumIndependentItems}`,
+      });
+    }
+    if (competency.evidence.requiresTransfer && !evidence.hasTransfer) {
+      issues.push({
+        kind: 'assessment-coverage',
+        message: `${competencyId} requires a transfer assessment item`,
+      });
+    }
+  }
+
+  validateTeachesSupport(lessons, evidenceByCompetency, issues);
+
+  for (const track of tracks.values()) {
+    const available = new Set<string>();
+    for (const duplicate of findDuplicates(track.lessons)) {
+      issues.push({
+        kind: 'duplicate-reference',
+        message: `${track.id} repeats lesson ${duplicate}`,
+      });
+    }
+    for (const lessonId of track.lessons) {
+      const lesson = lessons.get(lessonId);
+      if (!lesson) {
+        issues.push({
+          kind: 'unknown-reference',
+          message: `${track.id} references unknown lesson ${lessonId}`,
+        });
+        continue;
+      }
+      for (const competencyId of lesson.requires) {
+        if (!available.has(competencyId)) {
+          issues.push({
+            kind: 'track-order',
+            message: `${track.id} reaches ${lessonId} before required competency ${competencyId} is taught`,
+          });
+        }
+      }
+      for (const competencyId of lesson.teaches) available.add(competencyId);
+    }
+  }
+
+  return issues;
+}
+
+/** Issues that block the build (everything except `severity: 'warning'`). */
+export function curriculumErrors(
+  issues: readonly CurriculumIssue[],
+): readonly CurriculumIssue[] {
+  return issues.filter((issue) => issue.severity !== 'warning');
+}
+
+export function assertValidCurriculum(catalog: CurriculumCatalog): void {
+  const errors = curriculumErrors(validateCurriculum(catalog));
+  if (errors.length > 0) {
+    throw new Error(
+      `Invalid curriculum:\n${errors.map(({ message }) => `- ${message}`).join('\n')}`,
+    );
+  }
+}

package/src/progress/ProgressRepository.ts

@@ -0,0 +1,64 @@
+/**
+ * The learning-progress seam (Phase H1).
+ *
+ * Nothing is implemented behind this interface. `noopProgressRepository` is the
+ * only implementation the static site ships: `load` returns an empty snapshot,
+ * `recordAttempt` / `reset` do nothing. Assessment components call it on every
+ * result so a future host — an SSR app, an LMS importer, or the MCP server that
+ * already consumes `.generated/manifest.json` (see `docs/architecture.md`
+ * §15) — can supply a real repository (a versioned browser-storage adapter
+ * first, a server store later) without changing a single component.
+ *
+ * This module is framework-free: it imports no React, Astro, content, or
+ * browser API, and it reads no browser storage. The first real adapter is the
+ * only place a storage call will live.
+ */
+
+import type { SessionUser } from '../session/user';
+
+/**
+ * The per-competency progress ladder from `docs/architecture.md` §3. Unused by
+ * the no-op impl; part of the contract a real repository fills in.
+ */
+export type CompetencyProgressState =
+  'unseen' | 'exposed' | 'practicing' | 'demonstrated' | 'refresh_due';
+
+/** One recorded answer to one assessment item. */
+export interface AssessmentAttempt {
+  readonly assessmentId: string;
+  readonly itemId: string;
+  readonly competencyId?: string;
+  readonly evidenceKind: 'direct' | 'transfer';
+  readonly outcome: 'correct' | 'incorrect';
+  /** Epoch milliseconds; the caller supplies it so this stays side-effect-free. */
+  readonly at: number;
+}
+
+export interface ProgressSnapshot {
+  readonly attempts: readonly AssessmentAttempt[];
+  readonly states: Readonly<Record<string, CompetencyProgressState>>;
+}
+
+export interface ProgressRepository {
+  /** Everything known for this viewer. The no-op impl returns {@link EMPTY_PROGRESS}. */
+  load(user: SessionUser): ProgressSnapshot | Promise<ProgressSnapshot>;
+  /** Persist one attempt. The no-op impl discards it. */
+  recordAttempt(
+    user: SessionUser,
+    attempt: AssessmentAttempt,
+  ): void | Promise<void>;
+  /** Clear stored attempts, optionally scoped to one assessment or item. */
+  reset(
+    user: SessionUser,
+    scope?: { readonly assessmentId?: string; readonly itemId?: string },
+  ): void | Promise<void>;
+}
+
+export const EMPTY_PROGRESS: ProgressSnapshot = { attempts: [], states: {} };
+
+/** The only implementation in the static build. */
+export const noopProgressRepository: ProgressRepository = {
+  load: () => EMPTY_PROGRESS,
+  recordAttempt: () => {},
+  reset: () => {},
+};

package/src/reference/base-library.mjs

@@ -0,0 +1,27 @@
+/**
+ * The base notation library: a small, fixed set of universal identifier atoms
+ * that the page-level glyph map never asks an author to declare.
+ *
+ * Rationale (cleanup plan, "Decide once"): keep a base library so the
+ * completeness gate does not choke on mathematical constants and the
+ * differential operator. It is deliberately tiny and greppable — anything a
+ * lesson uses with a domain meaning (rates, indices, prices) still resolves to
+ * a semantic key or fails at `file:line:token`.
+ *
+ * Function names (`\ln`, `\exp`, `\log`, `\sin`, `\max`, `\sum`, `\prod`, …)
+ * are not listed here: KaTeX parses them as operator nodes, not identifier
+ * atoms, so the tokenizer never treats them as bindable symbols.
+ */
+export const BASE_LIBRARY = Object.freeze(
+  new Set([
+    'd', // differential operator: dt, dx
+    'e', // Euler's number
+    'i', // imaginary unit
+    '\\pi',
+  ]),
+);
+
+/** True when `token` is a base-library atom and needs no semantic key. */
+export function isBaseLibraryAtom(token) {
+  return BASE_LIBRARY.has(token);
+}

package/src/reference/citation-format.mjs

@@ -0,0 +1,133 @@
+/**
+ * Pure helpers for turning a source record plus a per-citation locator into
+ * the strings shown in the inline panel and the end-of-page reference list.
+ *
+ * Imported by both the remark adapter (build-time list rendering) and the
+ * `CitationLayer` island (hover panel), so it must not touch the DOM, the
+ * file system, or Astro APIs.
+ */
+
+export const SOURCE_ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+
+const ORDINAL_SUFFIX = (value) => {
+  const number = Number.parseInt(value, 10);
+  if (!Number.isFinite(number)) return String(value);
+  const tens = number % 100;
+  if (tens >= 11 && tens <= 13) return `${number}th`;
+  switch (number % 10) {
+    case 1:
+      return `${number}st`;
+    case 2:
+      return `${number}nd`;
+    case 3:
+      return `${number}rd`;
+    default:
+      return `${number}th`;
+  }
+};
+
+/**
+ * Short author label: one surname, "A & B" for two, "A et al." for more.
+ * Falls back to the publishing organization for official guidance.
+ *
+ * @param {Record<string, unknown>} record
+ * @returns {string}
+ */
+export function formatAuthors(record) {
+  const authors = Array.isArray(record.authors) ? record.authors : [];
+  const surnames = authors
+    .map((name) => String(name).trim().split(/\s+/).at(-1) ?? '')
+    .filter(Boolean);
+
+  if (surnames.length === 1) return surnames[0];
+  if (surnames.length === 2) return `${surnames[0]} & ${surnames[1]}`;
+  if (surnames.length > 2) return `${surnames[0]} et al.`;
+
+  return typeof record.organization === 'string' ? record.organization : '';
+}
+
+/**
+ * The "(4th ed., 2022)" tail, omitting whichever parts are absent.
+ *
+ * @param {Record<string, unknown>} record
+ * @returns {string}
+ */
+export function formatEditionYear(record) {
+  const parts = [];
+  if (record.edition !== undefined && record.edition !== '') {
+    parts.push(`${ORDINAL_SUFFIX(record.edition)} ed.`);
+  }
+  if (typeof record.year === 'number') parts.push(String(record.year));
+  return parts.length > 0 ? ` (${parts.join(', ')})` : '';
+}
+
+const stripTrailingPeriod = (value) => value.replace(/\s*\.\s*$/, '');
+
+/**
+ * One reference-list line: "Authors, Title (edition, year). Locator."
+ * `locator` is the text an author passed after the `;` in `[@id; locator]` and is
+ * optional. The source record's own catalog `locator` is not used here.
+ *
+ * @param {Record<string, unknown>} record
+ * @param {string | undefined} locator
+ * @returns {string}
+ */
+export function formatReferenceText(record, locator) {
+  const authors = formatAuthors(record);
+  const title =
+    typeof record.title === 'string' && record.title.length > 0
+      ? record.title
+      : String(record.id ?? '');
+
+  const head = [authors, `${title}${formatEditionYear(record)}`]
+    .filter(Boolean)
+    .join(', ');
+
+  const trimmedLocator = stripTrailingPeriod(String(locator ?? '').trim());
+  return trimmedLocator.length > 0
+    ? `${stripTrailingPeriod(head)}. ${trimmedLocator}.`
+    : `${stripTrailingPeriod(head)}.`;
+}
+
+/**
+ * Recover the source label (authors + title, no locator) from a rendered
+ * reference-list line — the inverse of the ". <locator>." tail
+ * `formatReferenceText` appends. Lets the citation hover panel read its
+ * heading off the page's own "References" list instead of a second serialized
+ * copy of the source database. Falls back to the whole line if the tail is
+ * not where it is expected.
+ *
+ * @param {string} referenceText  text of the `#cite-n` list item
+ * @param {string | undefined} locator  the marker's `data-citation-locator`
+ * @returns {string}
+ */
+export function referenceLabelFromText(referenceText, locator) {
+  const text = String(referenceText ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const trimmedLocator = stripTrailingPeriod(String(locator ?? '').trim());
+  if (trimmedLocator.length === 0) return stripTrailingPeriod(text);
+
+  const tail = `. ${trimmedLocator}.`;
+  return stripTrailingPeriod(
+    text.endsWith(tail) ? text.slice(0, -tail.length) : text,
+  );
+}
+
+/**
+ * The compact "Tuckman & Serrat, Fixed Income Securities (4th ed., 2022)"
+ * shown as the panel heading, without the locator.
+ *
+ * @param {Record<string, unknown>} record
+ * @returns {string}
+ */
+export function formatSourceLabel(record) {
+  const authors = formatAuthors(record);
+  const title =
+    typeof record.title === 'string' && record.title.length > 0
+      ? record.title
+      : String(record.id ?? '');
+  return [authors, `${title}${formatEditionYear(record)}`]
+    .filter(Boolean)
+    .join(', ');
+}