explico 0.12.0 → 0.13.0

package/dist/reference/derived-entries.js

@@ -0,0 +1,50 @@
+import { composeDerivedEntry } from "./derived-notation.mjs";
+import { scopeEntry } from "./gate-math.js";
+import { formulaExplainKeys } from "./gloss.js";
+import { baseSymbolLatex, derivedNotationLatex } from "./math-glyphs.mjs";
+function derivedNotationEntries(uses, records, cardsByKey) {
+  const derived = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    if (derived.has(use.key)) continue;
+    const base = records.get(use.base);
+    const index = records.get(use.index);
+    if (!base || !index) continue;
+    const notation = derivedNotationLatex(base.notation, index.notation);
+    const entry = composeDerivedEntry({
+      key: use.key,
+      notation,
+      baseLatex: baseSymbolLatex(base.notation),
+      base,
+      index: {
+        ...index,
+        ...index.formulaTemplate === void 0 ? {} : { formula: index.formulaTemplate }
+      }
+    });
+    const formulaScope = [
+      { key: use.key, notation },
+      ...index.glosses.map((gloss) => ({ key: gloss.key, notation: gloss.notation })),
+      scopeEntry(base)
+    ];
+    for (const key of formulaExplainKeys(entry.formula ?? "")) {
+      if (formulaScope.some((row) => row.key === key)) continue;
+      const card = records.get(key) ?? cardsByKey.get(key);
+      if (card) formulaScope.push(scopeEntry(card));
+    }
+    derived.set(use.key, {
+      key: entry.key,
+      base: entry.base,
+      index: entry.index,
+      notation: entry.notation,
+      label: entry.label,
+      summary: entry.summary,
+      glosses: [...index.glosses],
+      formulaScope,
+      ...entry.units === void 0 ? {} : { units: entry.units },
+      ...entry.formula === void 0 ? {} : { formula: entry.formula }
+    });
+  }
+  return [...derived.values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+export {
+  derivedNotationEntries
+};

package/dist/reference/derived-notation.d.mts

@@ -0,0 +1,125 @@
+/**
+ * A label as it reads inside a sentence: its first letter lowercased unless
+ * the first word is an acronym (`OLS estimate`) — the same rule
+ * `composeHeaderLabel` applies to an operator's operand.
+ *
+ * @param {string} label
+ * @returns {string}
+ */
+export function inSentence(label: string): string;
+/**
+ * A derived card's title: the index entry's `reads` with `{base}` replaced by
+ * the base's label (lowercased in mid-sentence), or `"<index label> of
+ * <base label>"` when the index entry gives no `reads`.
+ *
+ * @param {{ label: string, reads?: string }} index
+ * @param {string} baseLabel
+ * @returns {string}
+ */
+export function derivedLabel(index: {
+    label: string;
+    reads?: string;
+}, baseLabel: string): string;
+/**
+ * An index entry's formula with `{base}` bound: to the base symbol under its
+ * own `\explain`, for a derived card, so the reader opens the base's card
+ * from it.
+ *
+ * @param {string} formula
+ * @param {string} baseKey
+ * @param {string} baseLatex
+ * @returns {string}
+ */
+export function derivedFormula(formula: string, baseKey: string, baseLatex: string): string;
+/**
+ * An index entry's own formula, shown on the index entry's card and checked
+ * by the formula gate: `{base}` becomes a placeholder square bound to the
+ * entry itself, as an operator entry is shown over a square.
+ *
+ * @param {string} formula
+ * @param {string} ownKey
+ * @returns {string}
+ */
+export function indexEntryFormula(formula: string, ownKey: string): string;
+/**
+ * @typedef {object} DerivedSource
+ * @property {string} key
+ * @property {string} notation
+ * @property {string} label
+ * @property {string} [summary]
+ * @property {string} [units]
+ * @property {string} [reads]
+ * @property {string} [formula]
+ * @property {readonly { key: string, notation: string, label: string, units?: string, ownerKey: string }[]} [glosses]
+ */
+/**
+ * The derived entry for one (base, index) pair. `notation` is the indexed
+ * symbol, from `derivedNotationLatex`.
+ *
+ * @param {{ key: string, notation: string, baseLatex: string, base: DerivedSource, index: DerivedSource }} input
+ */
+export function composeDerivedEntry({ key, notation, baseLatex, base, index }: {
+    key: string;
+    notation: string;
+    baseLatex: string;
+    base: DerivedSource;
+    index: DerivedSource;
+}): {
+    formula?: string | undefined;
+    units?: string | undefined;
+    key: string;
+    notation: string;
+    base: string;
+    index: string;
+    label: string;
+    summary: string;
+    glosses: {
+        key: string;
+        notation: string;
+        label: string;
+        units?: string;
+        ownerKey: string;
+    }[];
+};
+/**
+ * Derived notation entries (rule N23): the card for a symbol with a subscript
+ * that an **index entry** explains — `\mathbf{v}_0` from the base entry
+ * `velocity-vector` (`\mathbf{v}`) and the index entry `motion.initial`
+ * (`{}_0`, "Initial value").
+ *
+ * The resolver writes one `\explain` around the whole indexed symbol, with
+ * the key `derivedNotationKey(base, index)` (`math-glyphs.mjs`); the build
+ * materializes the entry from the two, here, so that everything downstream
+ * treats it as one more card. What the reader sees first is about the
+ * indexed symbol; the base's own card is one level deeper, through the base
+ * symbol on the card's formula line:
+ *
+ * | Field   | From                                        |
+ * | ------- | ------------------------------------------- |
+ * | symbol  | the base's symbol plus the index            |
+ * | title   | the index entry's `reads`, the base's label |
+ * | summary | the index entry's `meaning`, never the base's |
+ * | formula | the index entry's `formula`, `{base}` bound |
+ * | units   | the base entry                              |
+ *
+ * Plain JavaScript with no parser, so the remark pass and the manifest share
+ * it; `derivedNotationLatex` in `math-glyphs.mjs` builds the symbol.
+ */
+/** The indexed symbol, in an index entry's `reads` and `formula`. */
+export const BASE_PLACEHOLDER: "{base}";
+export type DerivedSource = {
+    key: string;
+    notation: string;
+    label: string;
+    summary?: string | undefined;
+    units?: string | undefined;
+    reads?: string | undefined;
+    formula?: string | undefined;
+    glosses?: readonly {
+        key: string;
+        notation: string;
+        label: string;
+        units?: string;
+        ownerKey: string;
+    }[] | undefined;
+};

package/dist/reference/derived-notation.mjs

@@ -0,0 +1,121 @@
+/**
+ * Derived notation entries (rule N23): the card for a symbol with a subscript
+ * that an **index entry** explains — `\mathbf{v}_0` from the base entry
+ * `velocity-vector` (`\mathbf{v}`) and the index entry `motion.initial`
+ * (`{}_0`, "Initial value").
+ *
+ * The resolver writes one `\explain` around the whole indexed symbol, with
+ * the key `derivedNotationKey(base, index)` (`math-glyphs.mjs`); the build
+ * materializes the entry from the two, here, so that everything downstream
+ * treats it as one more card. What the reader sees first is about the
+ * indexed symbol; the base's own card is one level deeper, through the base
+ * symbol on the card's formula line:
+ *
+ * | Field   | From                                        |
+ * | ------- | ------------------------------------------- |
+ * | symbol  | the base's symbol plus the index            |
+ * | title   | the index entry's `reads`, the base's label |
+ * | summary | the index entry's `meaning`, never the base's |
+ * | formula | the index entry's `formula`, `{base}` bound |
+ * | units   | the base entry                              |
+ *
+ * Plain JavaScript with no parser, so the remark pass and the manifest share
+ * it; `derivedNotationLatex` in `math-glyphs.mjs` builds the symbol.
+ */
+
+/** The indexed symbol, in an index entry's `reads` and `formula`. */
+export const BASE_PLACEHOLDER = '{base}';
+
+/**
+ * A label as it reads inside a sentence: its first letter lowercased unless
+ * the first word is an acronym (`OLS estimate`) — the same rule
+ * `composeHeaderLabel` applies to an operator's operand.
+ *
+ * @param {string} label
+ * @returns {string}
+ */
+export function inSentence(label) {
+  const [first = ''] = label.split(/\s+/u);
+  if (first.length > 1 && first === first.toUpperCase()) return label;
+  return label.charAt(0).toLowerCase() + label.slice(1);
+}
+
+/**
+ * A derived card's title: the index entry's `reads` with `{base}` replaced by
+ * the base's label (lowercased in mid-sentence), or `"<index label> of
+ * <base label>"` when the index entry gives no `reads`.
+ *
+ * @param {{ label: string, reads?: string }} index
+ * @param {string} baseLabel
+ * @returns {string}
+ */
+export function derivedLabel(index, baseLabel) {
+  const reads = index.reads ?? `${index.label} of ${BASE_PLACEHOLDER}`;
+  const at = reads.indexOf(BASE_PLACEHOLDER);
+  const filled = reads
+    .split(BASE_PLACEHOLDER)
+    .join(at === 0 ? baseLabel : inSentence(baseLabel));
+  // `{base}` first in a later position, or a `reads` that starts lowercase.
+  return filled.charAt(0).toUpperCase() + filled.slice(1);
+}
+
+/**
+ * An index entry's formula with `{base}` bound: to the base symbol under its
+ * own `\explain`, for a derived card, so the reader opens the base's card
+ * from it.
+ *
+ * @param {string} formula
+ * @param {string} baseKey
+ * @param {string} baseLatex
+ * @returns {string}
+ */
+export function derivedFormula(formula, baseKey, baseLatex) {
+  return formula.split(BASE_PLACEHOLDER).join(`\\explain{${baseKey}}{${baseLatex}}`);
+}
+
+/**
+ * An index entry's own formula, shown on the index entry's card and checked
+ * by the formula gate: `{base}` becomes a placeholder square bound to the
+ * entry itself, as an operator entry is shown over a square.
+ *
+ * @param {string} formula
+ * @param {string} ownKey
+ * @returns {string}
+ */
+export function indexEntryFormula(formula, ownKey) {
+  return formula.split(BASE_PLACEHOLDER).join(`\\explain{${ownKey}}{\\square}`);
+}
+
+/**
+ * @typedef {object} DerivedSource
+ * @property {string} key
+ * @property {string} notation
+ * @property {string} label
+ * @property {string} [summary]
+ * @property {string} [units]
+ * @property {string} [reads]
+ * @property {string} [formula]
+ * @property {readonly { key: string, notation: string, label: string, units?: string, ownerKey: string }[]} [glosses]
+ */
+
+/**
+ * The derived entry for one (base, index) pair. `notation` is the indexed
+ * symbol, from `derivedNotationLatex`.
+ *
+ * @param {{ key: string, notation: string, baseLatex: string, base: DerivedSource, index: DerivedSource }} input
+ */
+export function composeDerivedEntry({ key, notation, baseLatex, base, index }) {
+  return {
+    key,
+    notation,
+    base: base.key,
+    index: index.key,
+    label: derivedLabel(index, base.label),
+    summary: index.summary ?? '',
+    glosses: [...(index.glosses ?? [])],
+    ...(base.units === undefined ? {} : { units: base.units }),
+    ...(index.formula === undefined
+      ? {}
+      : { formula: derivedFormula(index.formula, base.key, baseLatex) }),
+  };
+}

package/dist/reference/diagram-fit.d.ts

@@ -0,0 +1,45 @@
+import { M as ManifestRules } from '../course-config-rRtME5UV.js';
+import '../rules/catalog.js';
+import '../rules/course-rules.js';
+
+/**
+ * Rule V8: a diagram is no wider than the lesson column.
+ *
+ * `Diagram.astro` lays a diagram out at build time and so knows its width, but
+ * not the page it is on or what the course allows, and a diagram drawn by a
+ * wrapper component (`<CourseDiagram kind="…">`) never shows its nodes to the
+ * manifest walk. So the check runs on what was rendered: the component marks
+ * a diagram wider than {@link diagramWidthLimit} with `data-diagram-too-wide`,
+ * `compiler/astro.ts` finds each mark with {@link oversizedDiagrams} on every
+ * built page and reports a `dia-too-wide` warning with the lesson file and the
+ * diagram id, and `content warnings` lists what the last build reported
+ * (`compiler/render-diagnostics.ts`). Under `astro dev` the component prints
+ * the same message as it renders.
+ */
+
+/**
+ * The lesson column at a 1366px-wide window, the most common laptop screen
+ * (632px at 1280, 832px at 1920), unless the course sets
+ * `rules.V8.columnWidth`.
+ */
+declare const DEFAULT_COLUMN_WIDTH = 707;
+/**
+ * The widest a diagram may lay out, or `undefined` when nothing checks it: rule
+ * V8 is off, or the diagram says `warnAboveWidth={false}`. A number in
+ * `warnAboveWidth` replaces the course's column width for that diagram.
+ */
+declare function diagramWidthLimit(warnAboveWidth: number | false | undefined, rules: Pick<ManifestRules, 'disabled' | 'settings'> | undefined): number | undefined;
+/** What to tell the author about one diagram wider than its limit. */
+declare function diagramTooWideMessage(id: string, width: number, limit: number): string;
+/** A diagram on a built page that is wider than its limit. */
+interface OversizedDiagram {
+    readonly code: 'dia-too-wide';
+    /** The diagram's `id`. */
+    readonly key: string;
+    readonly width: number;
+    readonly limit: number;
+}
+/** The diagrams `Diagram.astro` marked too wide in `html`. */
+declare function oversizedDiagrams(html: string): OversizedDiagram[];
+
+export { DEFAULT_COLUMN_WIDTH, type OversizedDiagram, diagramTooWideMessage, diagramWidthLimit, oversizedDiagrams };

package/dist/reference/diagram-fit.js

@@ -0,0 +1,54 @@
+import { parse } from "parse5";
+const DEFAULT_COLUMN_WIDTH = 707;
+function diagramWidthLimit(warnAboveWidth, rules) {
+  if (warnAboveWidth === false || rules?.disabled.includes("V8")) return void 0;
+  if (warnAboveWidth !== void 0) return warnAboveWidth;
+  const columnWidth = rules?.settings.V8?.columnWidth;
+  return typeof columnWidth === "number" ? columnWidth : DEFAULT_COLUMN_WIDTH;
+}
+function diagramTooWideMessage(id, width, limit) {
+  return `Diagram "${id}" lays out ${Math.round(width)}px wide, wider than the ${limit}px it may take (rule V8), so a reader has to scroll it or widen it to see it whole. Try direction="TB", a shorter label, or a narrower node \`width\` (its label wraps inside it); set warnAboveWidth={false} only when the diagram is meant to scroll.`;
+}
+function isElement(node) {
+  return "tagName" in node;
+}
+function attribute(node, name) {
+  return node.attrs.find((attr) => attr.name === name)?.value;
+}
+function viewportKey(node) {
+  for (const child of "childNodes" in node ? node.childNodes : []) {
+    if (!isElement(child)) continue;
+    const match = /^diagram-(.+)-viewport$/.exec(attribute(child, "id") ?? "");
+    if (match) return match[1];
+    const inner = viewportKey(child);
+    if (inner) return inner;
+  }
+  return void 0;
+}
+function oversizedDiagrams(html) {
+  if (!html.includes("data-diagram-too-wide")) return [];
+  const found = [];
+  const visit = (node) => {
+    for (const child of "childNodes" in node ? node.childNodes : []) {
+      if (!isElement(child)) continue;
+      const limit = attribute(child, "data-diagram-too-wide");
+      if (limit !== void 0) {
+        found.push({
+          code: "dia-too-wide",
+          key: viewportKey(child) ?? attribute(child, "id") ?? "",
+          width: Number(attribute(child, "data-diagram-width")),
+          limit: Number(limit)
+        });
+      }
+      visit(child);
+    }
+  };
+  visit(parse(html));
+  return found;
+}
+export {
+  DEFAULT_COLUMN_WIDTH,
+  diagramTooWideMessage,
+  diagramWidthLimit,
+  oversizedDiagrams
+};

package/dist/reference/diagram-layout.d.ts

@@ -45,19 +45,68 @@ interface DiagramLayout {
  * would otherwise create a phantom zero-size node).
  */
 declare function layoutDiagram(nodes: readonly DiagramNodeInput[], edges: readonly DiagramEdgeInput[], options?: DiagramLayoutOptions): DiagramLayout;
-interface BoxSizeEstimate {
+/** A node's text font size, in px. */
+declare const NODE_FONT_PX = 13.6;
+/**
+ * A node's formula font size, in px: KaTeX's own `.katex { font-size: 1.21em }`
+ * of the node's text. `katex.css` is unlayered, so no rule in the component's
+ * `@layer` can shrink it, and at that size KaTeX_Main's x-height matches the
+ * label's.
+ */
+declare const FORMULA_FONT_PX: number;
+/** What a node holds, measured: its label, and its formula's box in px. */
+interface NodeBoxContent {
+    readonly text?: string;
+    /** `measureFormula(latex, FORMULA_FONT_PX)`. */
+    readonly formula?: {
+        readonly width: number;
+        readonly height: number;
+        readonly depth: number;
+    };
+}
+interface NodeBoxOptions {
+    /** The author's width: the label wraps inside it and the height follows. */
+    readonly width?: number;
+    /** The author's height. */
+    readonly height?: number;
+    /** The widest box a label is wrapped to fit before it takes a second line. */
+    readonly maxWidth?: number;
+}
+interface NodeBox {
     readonly width: number;
     readonly height: number;
+    /** The label as it is wrapped in DejaVu Sans. */
+    readonly lines: readonly string[];
 }
 /**
- * Estimate a diagram node's box from its label text (or raw, pre-resolution
- * LaTeX for a formula node). Deliberately generous: it is meant to avoid
- * clipping, not to match a real render pixel-for-pixel. Pass an explicit
- * `width`/`height` on the node to override for a label this estimate gets
- * badly wrong.
+ * Size a node's box from its measured content: as wide as its widest line of
+ * text or its formula, whichever is wider, plus the inset, and as tall as its
+ * lines of text, the gap and its formula's line. A label wider than `maxWidth`
+ * wraps; a formula never does, so a wide formula widens the box instead and the
+ * label wraps to it. An author's `width` or `height` makes the box larger,
+ * never too small for its formula or its lines.
  */
-declare function estimateBoxSize(content: string, kind: 'text' | 'formula', options?: {
-    readonly maxWidth?: number;
-}): BoxSizeEstimate;
+declare function nodeBoxSize(content: NodeBoxContent, options?: NodeBoxOptions): NodeBox;
+/** One node to fit: what it holds, and the author's size if any. */
+interface FitNodeInput {
+    readonly id: string;
+    readonly content: NodeBoxContent;
+    readonly width?: number;
+    readonly height?: number;
+}
+interface FitOptions extends DiagramLayoutOptions {
+    /** The widest the diagram should lay out (rule V8's column); omit to skip fitting. */
+    readonly fitWidth?: number;
+}
+/**
+ * Size every node from its content and lay the diagram out. When `fitWidth`
+ * is set and the diagram comes out wider, wrap the labels of the nodes without
+ * an author's `width` narrower, step by step, until it fits; a diagram that
+ * still does not fit keeps its narrowest layout, and the caller warns.
+ */
+declare function fitDiagramLayout(nodes: readonly FitNodeInput[], edges: readonly DiagramEdgeInput[], options?: FitOptions): {
+    readonly layout: DiagramLayout;
+    readonly boxes: ReadonlyMap<string, NodeBox>;
+};
 
-export { type BoxSizeEstimate, type DiagramEdgeInput, type DiagramLayout, type DiagramLayoutOptions, type DiagramNodeInput, type LaidOutEdge, type LaidOutNode, type Point, estimateBoxSize, layoutDiagram };
+export { type DiagramEdgeInput, type DiagramLayout, type DiagramLayoutOptions, type DiagramNodeInput, FORMULA_FONT_PX, type FitNodeInput, type FitOptions, type LaidOutEdge, type LaidOutNode, NODE_FONT_PX, type NodeBox, type NodeBoxContent, type NodeBoxOptions, type Point, fitDiagramLayout, layoutDiagram, nodeBoxSize };

package/dist/reference/diagram-layout.js

@@ -1,4 +1,5 @@
 import dagre from "@dagrejs/dagre";
+import { textWidth, wrapText } from "./text-measure.js";
 function layoutDiagram(nodes, edges, options = {}) {
   const ids = /* @__PURE__ */ new Set();
   for (const node of nodes) {
@@ -19,6 +20,11 @@ function layoutDiagram(nodes, edges, options = {}) {
     if (!ids.has(edge.to)) {
       throw new Error(`Diagram edge references unknown node "${edge.to}".`);
     }
+    if (edge.from === edge.to) {
+      throw new Error(
+        `Diagram edge from "${edge.from}" to itself: a diagram draws no loop on one node. Name the repetition in the label ("Repeat until it converges"), or draw the step it returns to as its own node.`
+      );
+    }
   }
   const graph = new dagre.graphlib.Graph();
   graph.setGraph({
@@ -91,32 +97,87 @@ function layoutDiagram(nodes, edges, options = {}) {
     height: maxY - minY + padding * 2
   };
 }
-const DEFAULT_MAX_WIDTH = 220;
+const NODE_FONT_PX = 13.6;
+const FORMULA_FONT_PX = NODE_FONT_PX * 1.21;
+const LINE_PX = 17;
+const CSS_PADDING_X = 8;
+const INSET_X = 16;
+const INSET_Y = 14;
+const GAP_PX = 2.4;
+const FORMULA_ASCENT_PX = 14;
+const FORMULA_DESCENT_PX = 5.5;
 const MIN_WIDTH = 90;
-const PADDING_X = 20;
-const PADDING_Y = 16;
-const LINE_HEIGHT = 22;
-const CHAR_WIDTH = {
-  text: 7.2,
-  formula: 11
-};
-function formulaVisibleLength(latex) {
-  const collapsed = latex.replace(/\\[a-zA-Z]+/g, "x").replace(/[{}$]/g, "").trim();
-  return Math.max(1, collapsed.length);
+const DEFAULT_MAX_WIDTH = 220;
+function balancedLines(text, maxWidth) {
+  const greedy = wrapText(text, maxWidth, NODE_FONT_PX);
+  if (greedy.length <= 1) return greedy;
+  let low = 1;
+  let high = Math.ceil(maxWidth);
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (wrapText(text, middle, NODE_FONT_PX).length <= greedy.length) high = middle;
+    else low = middle + 1;
+  }
+  return wrapText(text, high, NODE_FONT_PX);
+}
+function nodeBoxSize(content, options = {}) {
+  const text = content.text?.trim() ?? "";
+  const formula = content.formula;
+  const formulaWidth = formula?.width ?? 0;
+  let width;
+  let lines;
+  if (options.width !== void 0) {
+    width = Math.max(options.width, Math.ceil(formulaWidth + 2 * CSS_PADDING_X));
+    lines = text ? wrapText(text, width - 2 * CSS_PADDING_X, NODE_FONT_PX) : [];
+  } else {
+    const maxContent = Math.max(
+      (options.maxWidth ?? DEFAULT_MAX_WIDTH) - 2 * INSET_X,
+      formulaWidth
+    );
+    lines = text ? balancedLines(text, maxContent) : [];
+    const contentWidth = Math.max(
+      formulaWidth,
+      ...lines.map((line) => textWidth(line, NODE_FONT_PX))
+    );
+    width = Math.max(MIN_WIDTH, Math.ceil(contentWidth + 2 * INSET_X));
+  }
+  const formulaHeight = formula ? Math.max(FORMULA_ASCENT_PX, formula.height) + Math.max(FORMULA_DESCENT_PX, formula.depth) : 0;
+  const gap = lines.length > 0 && formula ? GAP_PX : 0;
+  const contentHeight = Math.ceil(lines.length * LINE_PX + gap + formulaHeight + 2 * INSET_Y);
+  const height = Math.max(options.height ?? 0, contentHeight);
+  return { width, height, lines };
+}
+const FIT_MAX_WIDTHS = [DEFAULT_MAX_WIDTH, 200, 180, 160, 140, 120];
+function fitDiagramLayout(nodes, edges, options = {}) {
+  let result;
+  for (const maxWidth of FIT_MAX_WIDTHS) {
+    const boxes = new Map(
+      nodes.map((node) => [
+        node.id,
+        nodeBoxSize(node.content, {
+          maxWidth,
+          ...node.width !== void 0 ? { width: node.width } : {},
+          ...node.height !== void 0 ? { height: node.height } : {}
+        })
+      ])
+    );
+    const layout = layoutDiagram(
+      nodes.map((node) => ({ id: node.id, ...sizeOf(boxes.get(node.id)) })),
+      edges,
+      options
+    );
+    result = { layout, boxes };
+    if (options.fitWidth === void 0 || layout.width <= options.fitWidth) break;
+  }
+  return result;
 }
-function estimateBoxSize(content, kind, options = {}) {
-  const maxWidth = options.maxWidth ?? DEFAULT_MAX_WIDTH;
-  const visibleLength = kind === "formula" ? formulaVisibleLength(content) : content.trim().length || 1;
-  const charWidth = CHAR_WIDTH[kind];
-  const naturalWidth = visibleLength * charWidth + PADDING_X * 2;
-  const width = Math.min(maxWidth, Math.max(MIN_WIDTH, naturalWidth));
-  const usableWidth = width - PADDING_X * 2;
-  const charsPerLine = Math.max(1, Math.floor(usableWidth / charWidth));
-  const lines = Math.max(1, Math.ceil(visibleLength / charsPerLine));
-  const height = lines * LINE_HEIGHT + PADDING_Y * 2;
-  return { width: Math.round(width), height: Math.round(height) };
+function sizeOf(box) {
+  return { width: box.width, height: box.height };
 }
 export {
-  estimateBoxSize,
-  layoutDiagram
+  FORMULA_FONT_PX,
+  NODE_FONT_PX,
+  fitDiagramLayout,
+  layoutDiagram,
+  nodeBoxSize
 };

package/dist/reference/diagrams-validate.d.ts

@@ -2,7 +2,7 @@ import { KeyedFloatLabelRecord, KeyedFloatLessonInput, KeyedFloatValidation } fr
 
 /** `validateKeyedFloats` for `<Diagram>` — see `keyed-float-validate.ts`. */
 
-type DiagramDiagnosticCode = 'dia-invalid-key' | 'dia-duplicate-key' | 'dia-ref-resolves' | 'dia-key-unused' | 'dia-removed-prop';
+type DiagramDiagnosticCode = 'dia-invalid-key' | 'dia-duplicate-key' | 'dia-ref-resolves' | 'dia-key-unused' | 'dia-removed-prop' | 'dia-unread-prop';
 interface DiagramDiagnostic {
     readonly code: DiagramDiagnosticCode;
     readonly severity: 'error' | 'warning' | 'info';

package/dist/reference/equations-validate.d.ts

@@ -25,7 +25,7 @@ interface EquationRefRecord {
     /** Target lesson slug for a cross-page reference; `undefined` = same page. */
     readonly targetSlug?: string;
 }
-type EquationDiagnosticCode = 'eq-duplicate-key' | 'eq-ref-resolves' | 'eq-key-unused';
+type EquationDiagnosticCode = 'eq-duplicate-key' | 'eq-ref-resolves' | 'eq-key-unused' | 'eq-label-repeated' | 'eq-latex-ref';
 interface EquationDiagnostic {
     readonly code: EquationDiagnosticCode;
     readonly severity: 'error' | 'warning' | 'info';

package/dist/reference/equations-validate.js

@@ -1,4 +1,5 @@
-import { parseEquationRef, scanEquationLabels } from "./equations.mjs";
+import { parseEquationRef, repeatedEquationLabels, scanEquationLabels } from "./equations.mjs";
+import { proseOnly } from "./gate-prose-notation.js";
 const BRACKET_REF = /\[\[\s*([^\][]+?)\s*\]\]/g;
 function stripCode(text) {
   return text.replace(/```[\s\S]*?```/g, " ").replace(/~~~[\s\S]*?~~~/g, " ").replace(/`[^`\n]*`/g, " ");
@@ -16,6 +17,7 @@ function bodyEquationRefs(lesson) {
   }
   return refs;
 }
+const LATEX_REFERENCE = /\\(eqref|ref|autoref|cref|Cref)\s*\{([^{}\n]*)\}/g;
 function validateEquations(lessons) {
   const labels = [];
   const diagnostics = [];
@@ -50,6 +52,29 @@ function validateEquations(lessons) {
       });
     }
     numbersBySlug[lesson.slug] = table;
+    for (const match of proseOnly(lesson.body).matchAll(LATEX_REFERENCE)) {
+      const [, command, target = ""] = match;
+      const [prefix, key] = target.includes(":") ? target.split(":", 2) : ["eq", target];
+      diagnostics.push({
+        code: "eq-latex-ref",
+        severity: "error",
+        message: `${lesson.lessonId} writes \\${command}{${target}}, LaTeX's reference: MDX reads its {\u2026} as JavaScript, and the page fails to build. Write [[${prefix}-${key}]].`,
+        file: lesson.file,
+        lessonId: lesson.lessonId,
+        key: key ?? target
+      });
+    }
+    for (const keys of repeatedEquationLabels(lesson.body)) {
+      const [first, ...rest] = keys;
+      diagnostics.push({
+        code: "eq-label-repeated",
+        severity: "error",
+        message: `${lesson.lessonId} puts ${keys.map((key) => `\\label{eq:${key}}`).join(" and ")} in one display block, which is one numbered equation: eq:${first} names it, and ${rest.map((key) => `[[eq-${key}]]`).join(", ")} would point at nothing. Split the block into one $$\u2026$$ block per equation you refer to.`,
+        file: lesson.file,
+        lessonId: lesson.lessonId,
+        key: rest[0]
+      });
+    }
   }
   const referenced = /* @__PURE__ */ new Set();
   for (const lesson of lessons) {