explico 0.1.0

package/dist/curriculum/validation.d.ts

@@ -0,0 +1,76 @@
+interface CompetencyDefinition {
+    readonly id: string;
+    readonly title: string;
+    readonly prerequisites: readonly string[];
+    readonly evidence: {
+        readonly minimumIndependentItems: number;
+        readonly requiresTransfer: boolean;
+        readonly requiresUnassistedPass: boolean;
+    };
+}
+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';
+}
+interface NumericAssessmentItem extends AssessmentItemBase {
+    readonly type: 'numeric';
+    readonly answer: {
+        readonly value: number;
+        readonly tolerance: number;
+    };
+}
+interface ChoiceAssessmentItem extends AssessmentItemBase {
+    readonly type: 'single-choice';
+    readonly options: readonly {
+        readonly id: string;
+        readonly label: string;
+    }[];
+    readonly correctOptionId: string;
+}
+interface AssessmentDefinition {
+    readonly id: string;
+    readonly items: readonly (NumericAssessmentItem | ChoiceAssessmentItem)[];
+}
+interface SourceDefinition {
+    readonly id: string;
+    readonly editorialStatus: 'draft' | 'in-review' | 'reviewed';
+}
+interface TrackDefinition {
+    readonly id: string;
+    readonly lessons: readonly string[];
+}
+interface CurriculumCatalog {
+    readonly competencies: readonly CompetencyDefinition[];
+    readonly lessons: readonly LessonDefinition[];
+    readonly assessments: readonly AssessmentDefinition[];
+    readonly sources: readonly SourceDefinition[];
+    readonly tracks: readonly TrackDefinition[];
+}
+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';
+}
+declare function validateCurriculum(catalog: CurriculumCatalog): readonly CurriculumIssue[];
+/** Issues that block the build (everything except `severity: 'warning'`). */
+declare function curriculumErrors(issues: readonly CurriculumIssue[]): readonly CurriculumIssue[];
+declare function assertValidCurriculum(catalog: CurriculumCatalog): void;
+
+export { type AssessmentDefinition, type ChoiceAssessmentItem, type CompetencyDefinition, type CurriculumCatalog, type CurriculumIssue, type LessonDefinition, type NumericAssessmentItem, type SourceDefinition, type TrackDefinition, assertValidCurriculum, curriculumErrors, validateCurriculum };

package/dist/curriculum/validation.js

@@ -0,0 +1,320 @@
+const VALID_ID = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+function buildIndex(kind, entries, issues) {
+  const index = /* @__PURE__ */ new Map();
+  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;
+}
+function citedSourceIds(body) {
+  if (!body) return /* @__PURE__ */ new Set();
+  const withoutCode = body.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]*`/g, "");
+  const ids = /* @__PURE__ */ new Set();
+  for (const match of withoutCode.matchAll(
+    /\[@([a-z0-9][a-z0-9.-]*)(?:;[^\]]*)?\]/g
+  )) {
+    ids.add((match[1] ?? "").trim());
+  }
+  return ids;
+}
+function findDuplicates(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates];
+}
+function validateCompetencyGraph(competencies, issues) {
+  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 = /* @__PURE__ */ new Map();
+  const stack = [];
+  const reportedCycles = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    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 === void 0) {
+        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) === void 0) visit(id);
+  }
+}
+const WORKED_INSTANCE = /<CompactExample\b|^#{1,6}\s+.*\b(?:worked|example)\b|=\s*-?\d|\d\.\d{3,}/im;
+function validateTeachesSupport(lessons, evidenceByCompetency, issues) {
+  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`
+      });
+    }
+  }
+}
+function validateCurriculum(catalog) {
+  const issues = [];
+  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"]) {
+      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 !== void 0 && !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 = /* @__PURE__ */ new Set();
+  const evidenceByCompetency = /* @__PURE__ */ new Map();
+  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 = /* @__PURE__ */ new Set();
+    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;
+}
+function curriculumErrors(issues) {
+  return issues.filter((issue) => issue.severity !== "warning");
+}
+function assertValidCurriculum(catalog) {
+  const errors = curriculumErrors(validateCurriculum(catalog));
+  if (errors.length > 0) {
+    throw new Error(
+      `Invalid curriculum:
+${errors.map(({ message }) => `- ${message}`).join("\n")}`
+    );
+  }
+}
+export {
+  assertValidCurriculum,
+  curriculumErrors,
+  validateCurriculum
+};

package/dist/progress/ProgressRepository.d.ts

@@ -0,0 +1,53 @@
+import { SessionUser } from '../session/user.js';
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+type CompetencyProgressState = 'unseen' | 'exposed' | 'practicing' | 'demonstrated' | 'refresh_due';
+/** One recorded answer to one assessment item. */
+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;
+}
+interface ProgressSnapshot {
+    readonly attempts: readonly AssessmentAttempt[];
+    readonly states: Readonly<Record<string, CompetencyProgressState>>;
+}
+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>;
+}
+declare const EMPTY_PROGRESS: ProgressSnapshot;
+/** The only implementation in the static build. */
+declare const noopProgressRepository: ProgressRepository;
+
+export { type AssessmentAttempt, type CompetencyProgressState, EMPTY_PROGRESS, type ProgressRepository, type ProgressSnapshot, noopProgressRepository };

package/dist/progress/ProgressRepository.js

@@ -0,0 +1,12 @@
+const EMPTY_PROGRESS = { attempts: [], states: {} };
+const noopProgressRepository = {
+  load: () => EMPTY_PROGRESS,
+  recordAttempt: () => {
+  },
+  reset: () => {
+  }
+};
+export {
+  EMPTY_PROGRESS,
+  noopProgressRepository
+};

package/dist/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/dist/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(', ');
+}

package/dist/reference/consistency.d.ts

@@ -0,0 +1,64 @@
+import { CourseConventions } from '../compiler/course-config.js';
+import { CurriculumCatalog } from '../curriculum/validation.js';
+import { NotationSpec } from '../compiler/collections.js';
+import { LintIgnore } from './lint-ignore.js';
+import { NotationRegistry, NotationRegistryInput } from './types.js';
+
+/**
+ * Corpus consistency checks (Step D6) — the Tier 1–2 checks from the cleanup
+ * plan's "Enforced checks" section that no earlier step covers.
+ *
+ * Every check here enters as a **Tier-3 warning**: `pnpm validate:content`
+ * surfaces the counts, `manifest.diagnostics.consistency` records the detail,
+ * and `resolution/consistency-report.json` is the committed, diff-checkable
+ * snapshot. Nothing here changes content — each finding is an open item for a
+ * separate human-quantitative-reviewed pass. A finding is silenced only by a
+ * reviewed line in `lint-ignore.yml` (see `./lint-ignore`).
+ *
+ *   (a) glyph-unique-in-corpus       one rendered glyph → one meaning corpus-wide
+ *   (b) notation-units / units-vocab  every entry has units or `dimensionless`,
+ *                                     unit strings drawn from a controlled vocab
+ *   (c) convention-single-definition  a sign / cash-flow-perspective convention a
+ *                                     lesson uses resolves to one declaration
+ *   (e) numerals-tagged              numerals in `$…$` / result tables are tagged
+ *                                     to a `src/domain/` call or a source locator
+ *   (f) weak-local                   a `notation.local` symbol used only in its
+ *                                     own defining equation and prose
+ *   (g) notation-source-locator      every notation `sources` entry has a locator
+ *
+ * Check (d) — the committed per-lesson resolution report — lives in
+ * `src/content/resolution-report.ts`.
+ */
+
+type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'convention-single-definition' | 'numerals-tagged' | 'weak-local' | 'notation-source-locator';
+interface ConsistencyDiagnostic {
+    readonly code: ConsistencyCode;
+    /** Tier 3 — every finding here is a warning until content is brought clean. */
+    readonly severity: 'warning';
+    readonly message: string;
+    readonly file?: string;
+    readonly lessonId?: string;
+    readonly key?: string;
+    readonly glyph?: string;
+    /** For the aggregate numeral check. */
+    readonly count?: number;
+}
+interface ConsistencyInput {
+    readonly registry: NotationRegistry;
+    readonly notationInput: NotationRegistryInput;
+    readonly specs: readonly NotationSpec[];
+    readonly catalog: CurriculumCatalog;
+    readonly lintIgnore: LintIgnore;
+    /** Convention keys this course anchors on (from `content/course.config.ts`). */
+    readonly conventions: CourseConventions;
+}
+/**
+ * Run every consistency check. The result is sorted deterministically (code,
+ * then lesson / key / glyph, then message) so it is byte-stable in the manifest
+ * and the committed report.
+ */
+declare function runConsistencyChecks(input: ConsistencyInput): ConsistencyDiagnostic[];
+/** `{ code: count }` for the CLI summary and the report header. */
+declare function consistencyCounts(diagnostics: readonly ConsistencyDiagnostic[]): Record<ConsistencyCode, number>;
+
+export { type ConsistencyCode, type ConsistencyDiagnostic, type ConsistencyInput, consistencyCounts, runConsistencyChecks };