feat(math): implement m:limLow and m:limUpp limit converters (#2771)

* feat(math): implement m:limLow and m:limUpp limit converters (SD-2377, SD-2378)

Add lower limit (m:limLow → <munder>) and upper limit (m:limUpp → <mover>)
OMML-to-MathML converters per ECMA-376 §22.1.2.54 and §22.1.2.56.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat(math): handle m:sty and m:scr in convertMathRun (SD-2377/2378)

ECMA-376 §22.1.2 defines m:sty (style: p/b/i/bi) and m:scr (script: roman,
script, fraktur, double-struck, sans-serif, monospace) on math run
properties. Word emits m:sty="p" on function names like "lim", "max",
"sup" — without this handling those names rendered italic instead of
upright when they appear outside an m:func wrapper.

Precedence: m:sty > m:scr > m:nor. m:nor stays as the legacy normal
flag, equivalent to m:sty="p" when no explicit style or script is set.

* test(math): expand limLow/limUpp unit coverage (SD-2377/2378)

- Tighten "handles missing m:e/m:lim gracefully" tests: assert arity-2
  <munder>/<mover> with an empty <mrow> on the missing side (was only
  checking the present side).
- Add multi-run base tests for both converters — existing tests only
  exercised multi-run m:lim, leaving the m:e base-wrapping path
  untested.
- Add nested-math tests (fraction inside m:lim) for both converters.
- Add m:func-wrapped tests (m:func > m:fName > m:limLow/m:limUpp) —
  the shape Word actually emits when the base is a function keyword.
- Add full coverage for m:sty (p/b/i/bi), m:scr (6 variants), and
  m:sty > m:scr precedence per ECMA-376 §22.1.2.

* test(math): add behavior fixture and tests for limLow/limUpp (SD-2377/2378)

New fixture math-limit-tests.docx contains 8 Word-native limit shapes:
m:limLow in m:func, bare m:limUpp, m:limLow with fraction in m:lim,
bare m:limLow, m:limUpp in m:func, multi-char non-lim function bases
(max, sup), and m:limLow with a nested m:sSub in the limit expression.

Seven new it blocks assert:
- arity of <munder> (6) and <mover> (2)
- nested <mfrac> inside <munder> (case 3)
- nested <msub> inside <munder> (case 8)
- mathvariant=normal on function keywords via m:sty val=p
- bare identifiers keep italic default (no stray mathvariant)
- property elements (m:limLowPr/m:limUppPr/m:ctrlPr) don't leak to DOM

The same fixture is uploaded to the shared R2 corpus as
sd-2377-limlow-limupp-showcase-all-cases.docx so test:layout and
test:visual cover these shapes automatically.

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Caio Pizzol <caiopizzol@icloud.com>

Author: 3 people

packages/layout-engine/painters/dom/src/features/math/converters/index.ts

@@ -15,3 +15,5 @@ export { convertSubscript } from './subscript.js';
 export { convertSuperscript } from './superscript.js';
 export { convertSubSuperscript } from './sub-superscript.js';
 export { convertRadical } from './radical.js';
+export { convertLowerLimit } from './lower-limit.js';
+export { convertUpperLimit } from './upper-limit.js';

packages/layout-engine/painters/dom/src/features/math/converters/lower-limit.ts

@@ -0,0 +1,32 @@
+import type { MathObjectConverter } from '../types.js';
+
+const MATHML_NS = 'http://www.w3.org/1998/Math/MathML';
+
+/**
+ * Convert m:limLow (lower limit) to MathML <munder>.
+ *
+ * OMML structure:
+ *   m:limLow → m:limLowPr (optional), m:e (base, e.g. "lim"), m:lim (limit expression)
+ *
+ * MathML output:
+ *   <munder> <mrow>base</mrow> <mrow>lim</mrow> </munder>
+ *
+ * @spec ECMA-376 §22.1.2.54
+ */
+export const convertLowerLimit: MathObjectConverter = (node, doc, convertChildren) => {
+  const elements = node.elements ?? [];
+  const base = elements.find((e) => e.name === 'm:e');
+  const lim = elements.find((e) => e.name === 'm:lim');
+
+  const munder = doc.createElementNS(MATHML_NS, 'munder');
+
+  const baseRow = doc.createElementNS(MATHML_NS, 'mrow');
+  baseRow.appendChild(convertChildren(base?.elements ?? []));
+  munder.appendChild(baseRow);
+
+  const limRow = doc.createElementNS(MATHML_NS, 'mrow');
+  limRow.appendChild(convertChildren(lim?.elements ?? []));
+  munder.appendChild(limRow);
+
+  return munder;
+};

packages/layout-engine/painters/dom/src/features/math/converters/math-run.ts

@@ -77,6 +77,44 @@ function classifyMathText(text: string): 'mn' | 'mo' | 'mi' {
   return 'mi';
 }
 
+/** ECMA-376 m:sty → MathML mathvariant (§22.1.2 math run properties). */
+const STY_TO_VARIANT: Record<string, string> = {
+  p: 'normal',
+  b: 'bold',
+  i: 'italic',
+  bi: 'bold-italic',
+};
+
+/** ECMA-376 m:scr → MathML mathvariant (§22.1.2 math run properties). */
+const SCR_TO_VARIANT: Record<string, string> = {
+  roman: 'normal',
+  script: 'script',
+  fraktur: 'fraktur',
+  'double-struck': 'double-struck',
+  'sans-serif': 'sans-serif',
+  monospace: 'monospace',
+};
+
+/**
+ * Resolve the effective MathML mathvariant from OMML m:rPr.
+ *
+ * Precedence (highest first): m:sty > m:scr > m:nor.
+ * m:nor is the legacy "normal text" flag (ECMA-376 §22.1.2); it is treated as
+ * equivalent to m:sty="p" when neither m:sty nor m:scr is present.
+ */
+function resolveMathVariant(rPr: OmmlJsonNode | undefined): string | null {
+  const elements = rPr?.elements ?? [];
+  const sty = elements.find((el) => el.name === 'm:sty')?.attributes?.['m:val'];
+  if (sty && STY_TO_VARIANT[sty]) return STY_TO_VARIANT[sty]!;
+
+  const scr = elements.find((el) => el.name === 'm:scr')?.attributes?.['m:val'];
+  if (scr && SCR_TO_VARIANT[scr]) return SCR_TO_VARIANT[scr]!;
+
+  if (elements.some((el) => el.name === 'm:nor')) return 'normal';
+
+  return null;
+}
+
 /**
  * Convert an m:r (math run) element to MathML.
  *
@@ -105,18 +143,18 @@ export const convertMathRun: MathObjectConverter = (node, doc) => {
 
   if (!text) return null;
 
-  // Check m:rPr for normal text flag (m:nor) which disables math italics
   const rPr = elements.find((el) => el.name === 'm:rPr');
-  const isNormalText = rPr?.elements?.some((el) => el.name === 'm:nor') ?? false;
-
+  const variant = resolveMathVariant(rPr);
   const tag = classifyMathText(text);
+
   const el = doc.createElementNS(MATHML_NS, tag);
   el.textContent = text;
 
-  // MathML <mi> with single-char content is italic by default (spec).
-  // Multi-char <mi> is normal by default. The m:nor flag forces normal.
-  if (tag === 'mi' && isNormalText) {
-    el.setAttribute('mathvariant', 'normal');
+  // Apply mathvariant when the spec properties resolve to one. The default
+  // for single-char <mi> is italic and for multi-char <mi>/<mo>/<mn> is
+  // normal — we only set an attribute when m:rPr explicitly specifies it.
+  if (variant) {
+    el.setAttribute('mathvariant', variant);
   }
 
   return el;

packages/layout-engine/painters/dom/src/features/math/converters/upper-limit.ts

@@ -0,0 +1,32 @@
+import type { MathObjectConverter } from '../types.js';
+
+const MATHML_NS = 'http://www.w3.org/1998/Math/MathML';
+
+/**
+ * Convert m:limUpp (upper limit) to MathML <mover>.
+ *
+ * OMML structure:
+ *   m:limUpp → m:limUppPr (optional), m:e (base), m:lim (limit expression placed above)
+ *
+ * MathML output:
+ *   <mover> <mrow>base</mrow> <mrow>lim</mrow> </mover>
+ *
+ * @spec ECMA-376 §22.1.2.56
+ */
+export const convertUpperLimit: MathObjectConverter = (node, doc, convertChildren) => {
+  const elements = node.elements ?? [];
+  const base = elements.find((e) => e.name === 'm:e');
+  const lim = elements.find((e) => e.name === 'm:lim');
+
+  const mover = doc.createElementNS(MATHML_NS, 'mover');
+
+  const baseRow = doc.createElementNS(MATHML_NS, 'mrow');
+  baseRow.appendChild(convertChildren(base?.elements ?? []));
+  mover.appendChild(baseRow);
+
+  const limRow = doc.createElementNS(MATHML_NS, 'mrow');
+  limRow.appendChild(convertChildren(lim?.elements ?? []));
+  mover.appendChild(limRow);
+
+  return mover;
+};