rapier-math 1.0.2 → 1.1.1

package/{rapier-math-1.0.2.js → dist/rapier-math.js}

@@ -2311,7 +2311,7 @@ function mathLayout(n,c) {
     case 'smash': {const b=mathLayout(n.body,c);return {...b,h:n.mode==='b'?b.h:0,d:n.mode==='t'?b.d:0};}
     case 'raise': {const b=mathLayout(n.body,c),s=mathScale(c);return mathCompose([[b,0,-n.amount*s]],b.w,{class:b.class,...(n.height===undefined?{}:{h:n.height*s}),...(n.depth===undefined?{}:{d:n.depth*s})});}
     case 'rule': {const s=mathScale(c);return mathRule(n.width*s,(n.height+n.depth)*s,-n.height*s);}
-    case 'link': {const b=mathLayout(n.body,c);const url=new URL(n.href);if(!['http:','https:'].includes(url.protocol))throw Object.assign(new Error('Unsupported equation link'),{code:'unsafe-url'});b.svg='<a href="'+mathEscape(n.href)+'" target="_blank" rel="noopener noreferrer">'+b.svg+'</a>';return b;}
+    case 'link': {const b=mathLayout(n.body,c);const url=new URL(n.href);if(!['http:','https:'].includes(url.protocol))throw Object.assign(new Error('Unsupported equation link'),{code:'unsafe-url'});b.svg='<a href="'+mathEscape(n.href)+'" aria-label="'+mathEscape(n.href)+'" tabindex="0" target="_blank" rel="noopener noreferrer">'+b.svg+'</a>';return b;}
     default: throw Object.assign(new Error('Unsupported maths construct: '+n.type),{code:'unsupported-construct'});
   }
 }
@@ -2770,12 +2770,18 @@ function mathFitElement(svg, printing = false) {
   if(screenKey!==state.screen || (target===null)!==(state.width===null) || target!==null && Math.abs(target-state.width)>.005) {
     const rendered=renderMath(source,{displayMode:display,maxWidth:(screenKey!==state.screen?width:target) || undefined,screen});
     if(!rendered.errors.length) {
+      const active=doc.activeElement,links=active && svg.contains(active)?[...svg.querySelectorAll('a')]:[];
+      const focusIndex=links.indexOf(active),focusHref=focusIndex<0?null:active.getAttribute('href');
       const replacement=new view.DOMParser().parseFromString(rendered.svg,'image/svg+xml').documentElement;
-      for(const name of ['width','height','viewBox','data-math-natural-width','data-math-max-width','data-math-lines','data-math-screen']) {
+      for(const name of ['role','width','height','viewBox','data-math-natural-width','data-math-max-width','data-math-lines','data-math-screen']) {
         if(replacement.hasAttribute(name))svg.setAttribute(name,replacement.getAttribute(name));else svg.removeAttribute(name);
       }
       svg.style.verticalAlign=replacement.style.verticalAlign;
       svg.replaceChildren(...Array.from(replacement.childNodes,node=>doc.importNode(node,true)));
+      if(focusIndex>=0 && (!doc.activeElement || doc.activeElement===doc.body)) {
+        const link=svg.querySelectorAll('a')[focusIndex];
+        if(link?.getAttribute('href')===focusHref)link.focus({preventScroll:true});
+      }
       state.natural=Number(svg.getAttribute('data-math-natural-width'));state.screen=screenKey;
       state.width=state.natural>width?width:null;
       if(state.width===null)svg.removeAttribute('data-math-max-width');
@@ -2871,23 +2877,27 @@ function mathSvg(box,source,error,utf16,options={}) {
   const opacity=options.screen?.dark ? .94 : 1;
   if (![width,height,depth,left,...viewBox].every(Number.isFinite)) throw new Error('Mathematical dimensions are not finite');
   const escapedSource=mathEscape(source);
-  const svg='<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="'+escapedSource+'"'+
+  // A group exposes authored links to accessibility APIs; an image would hide them.
+  const svg='<svg xmlns="http://www.w3.org/2000/svg" role="'+(box.svg.includes('<a ')?'group':'img')+'" aria-label="'+escapedSource+'"'+
     ' data-rapier-math="'+(options.displayMode?'display':'inline')+'" data-math-lines="'+(box.lines || 1)+'"'+
     ' data-math-natural-width="'+mathNumber(options.naturalWidth ?? width)+'"'+
     (options.screen?' data-math-screen="'+mathNumber(options.screen.fontSize)+'|'+mathNumber(options.screen.pixelRatio)+'|'+options.screen.dark+'"':'')+
     (options.maxWidth?' data-math-max-width="'+mathNumber(options.maxWidth)+'"':'')+
     (utf16?' data-tex-utf16="'+utf16+'"':'')+
+    (error?.sourceOmitted?' data-math-source-omitted="true"':'')+
     (error?' data-math-error="'+mathEscape(error.code)+'"':'')+' width="'+mathNumber(width)+'em" height="'+mathNumber(height+depth)+'em"'+
     ' viewBox="'+viewBox.map(mathNumber).join(' ')+'"'+
     ' style="font-size:'+mathNumber(mathFontRatio)+'em;max-width:100%;height:auto;vertical-align:-'+mathNumber(depth)+'em;'+
     'fill-opacity:'+opacity+';stroke-opacity:'+opacity+'" fill="currentColor">'+
     '<title>'+escapedSource+'</title>'+(error?'<desc>'+mathEscape(error.message)+'</desc>':'')+
     '<g transform="scale(1000)">'+box.svg+'</g></svg>';
+  if(svg.length>24*1024*1024)throw Object.assign(new Error('The complete formula markup exceeds its output budget.'),{code:'resource-limit'});
   return {svg,width,height,depth,lines:box.lines || 1,fitted:!!box.fitted,errors:error?[error]:[]};
 }
 
 function mathSourceAlternative(source) {
-  let alternative='',first=-1,kept=0;
+  const alternatives=[],parts=[];
+  let first=-1,kept=0;
   for(let i=0;i<source.length;i++) {
     const code=source.charCodeAt(i);
     if(code>=0xd800 && code<=0xdbff && i+1<source.length) {
@@ -2896,19 +2906,32 @@ function mathSourceAlternative(source) {
     }
     if((code>=0x20 && code<=0xd7ff) || (code>=0xe000 && code<=0xfffd) || code===9 || code===10 || code===13)continue;
     if(first<0)first=i;
-    alternative+=source.slice(kept,i)+'\\u'+code.toString(16).toUpperCase().padStart(4,'0');kept=i+1;
+    if(i>kept)parts.push(source.slice(kept,i));
+    parts.push('\\u'+code.toString(16).toUpperCase().padStart(4,'0'));kept=i+1;
+    // Flatten small batches instead of retaining one rope node per bad code unit.
+    if(parts.length>=1024) {alternatives.push(parts.join(''));parts.length=0;}
   }
   if(first<0)return {alternative:source};
-  alternative+=source.slice(kept);
+  parts.push(source.slice(kept));alternatives.push(parts.join(''));
   // Only malformed XML text needs a separate carrier; each four hex digits keep one original code unit.
-  let utf16='';
-  for(let i=0;i<source.length;i++)utf16+=source.charCodeAt(i).toString(16).padStart(4,'0');
-  return {alternative,utf16,error:{code:'invalid-source-character',offset:first,
+  const encoded=[];parts.length=0;
+  for(let i=0;i<source.length;i++) {
+    parts.push(source.charCodeAt(i).toString(16).padStart(4,'0'));
+    if(parts.length===1024) {encoded.push(parts.join(''));parts.length=0;}
+  }
+  encoded.push(parts.join(''));
+  return {alternative:alternatives.join(''),utf16:encoded.join(''),error:{code:'invalid-source-character',offset:first,
     message:'A source character cannot be embedded in SVG. The text alternative shows Unicode escapes; data-tex-utf16 keeps the original source.'}};
 }
 
 function renderMath(source,options={}) {
-  const text=String(source ?? ''),safe=mathSourceAlternative(text),context={size:1,level:0,variant:'normal',cramped:false,display:!!options?.displayMode,cache:new WeakMap(),budget:{nodes:0,outlineBytes:0}};
+  const text=String(source ?? '');
+  // Reject before scanning, escaping or parsing. Keep the diagnostic-return
+  // contract, but explicitly omit refused source instead of expanding it.
+  const safe=text.length>1000000?{alternative:'Formula source omitted: source limit exceeded.',error:{
+    code:'resource-limit',offset:0,sourceOmitted:true,
+    message:'This formula is too long to render safely. Its source was not embedded; retain the original input.'
+  }}:mathSourceAlternative(text),context={size:1,level:0,variant:'normal',cramped:false,display:!!options?.displayMode,cache:new WeakMap(),budget:{nodes:0,outlineBytes:0}};
   try {
     if(safe.error)throw safe.error;
     if(options?.screen!==undefined) {
@@ -2925,11 +2948,16 @@ function renderMath(source,options={}) {
     return mathSvg(box,safe.alternative,undefined,undefined,{displayMode:context.display,maxWidth,naturalWidth:mathInkWidth(natural)+.05,screen:context.screen});
   }
   catch (cause) {
-    const error={code:cause.code || 'invalid-tex',message:String(cause.message || cause),offset:Number.isFinite(cause.offset)?cause.offset:0};
-    if(cause.command)error.command=cause.command;
+    const message=String(cause.message || cause);
+    const error={code:cause.code || 'invalid-tex',message:message.length>1024?message.slice(0,1024).replace(/[\ud800-\udbff]$/,'')+'…':message,offset:Number.isFinite(cause.offset)?cause.offset:0};
+    if(message.length>1024)error.messageTruncated=true;
+    if(cause.sourceOmitted)error.sourceOmitted=true;
+    if(cause.command) {
+      error.command=String(cause.command).slice(0,128);
+      if(cause.command.length>128)error.commandTruncated=true;
+    }
     // A diagnostic is visible, but remains distinct from a successfully typeset formula.
-    // A hostile command can have a very long name. Keep its full diagnostic in desc/errors,
-    // while the visible notice stays finite and can render after the formula exhausted its budget.
+    // Diagnostics have an explicit bound. Exact input stays in the source alternative.
     const label=error.message.length>240?'This formula could not be rendered. The complete diagnostic is in its text description.':error.message.replace(/[^\x20-\x7e]/g,'?');
     const diagnostic={...context,variant:'roman',size:0.8,budget:{nodes:0,outlineBytes:0}};
     try {
@@ -2942,7 +2970,7 @@ function renderMath(source,options={}) {
 }
 
 globalThis.RapierMath=Object.freeze({
-  version:'1.0.2',
+  version:'1.1.1',
   parse:parseMathTex,
   render:renderMath,
   fit:mathFit,

package/dist/rehype.d.ts

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+import type {Root} from 'hast';
+import type {VFile} from 'vfile';
+import type {IntegrationOptions} from './integration.js';
+/** Install after sanitization. Recognizes remark-rehype math code nodes. */
+export default function rehypeRapierMath(options?: IntegrationOptions): (tree: Root, file: VFile) => void;

package/dist/rehype.mjs

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+import {fromHtml} from 'hast-util-from-html';
+import {createFormulaRenderer} from './integration.mjs';
+
+// Run AFTER the host sanitizer. Only known math code nodes are replaced, using
+// fresh renderer output parsed into HAST. Authored raw nodes never become HTML here.
+export default function rehypeRapierMath(options = {}) {
+  return (tree, file) => {
+    const render = createFormulaRenderer(options);
+    function math(node) {
+      const names = node?.properties?.className;
+      if (node?.type !== 'element' || node.tagName !== 'code' || !Array.isArray(names) ||
+          !names.includes('language-math') || !names.some(name => name === 'math-inline' || name === 'math-display') ||
+          !Array.isArray(node.children) || !node.children.every(child => child.type === 'text' && typeof child.value === 'string')) return null;
+      return {source: node.children.map(child => child.value).join(''), display: names.includes('math-display')};
+    }
+    function visit(parent) {
+      for (let index = 0; index < (parent.children?.length || 0); index++) {
+        const node = parent.children[index];
+        const code = node.type === 'element' && node.tagName === 'pre' && node.children?.length === 1 ? node.children[0] : node;
+        const input = math(code);
+        if (!input) { visit(node); continue; }
+        const result = render(input.source, input.display);
+        if (result.errors.length) {
+          for (const error of result.errors) {
+            const message = file?.message(error.message, {place: code.position, source: 'rapier-math', ruleId: error.code});
+            if (message) { message.mathSource = input.source; message.mathOffset = error.offset; }
+          }
+          continue;
+        }
+        const svg = fromHtml(result.svg, {fragment: true}).children[0];
+        parent.children[index] = input.display ? {type: 'element', tagName: 'div', properties: {className: ['math-display']}, children: [svg]} : svg;
+      }
+    }
+    visit(tree);
+  };
+}

package/dist/stream.d.ts

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+export interface MarkdownSnapshot {source: string; html: string; revision: number; final: boolean}
+export interface MarkdownStream {
+  /** null means keep the previous preview; the chunk was still accepted. */
+  write(chunk: string): MarkdownSnapshot | null;
+  finish(): MarkdownSnapshot;
+  abort(): void;
+  /** Replace a message by resetting, then writing the replacement source. */
+  reset(): number;
+  readonly revision: number;
+}
+export function createMarkdownStream(renderMarkdown: (source: string) => string, options?: {
+  maxSourceLength?: number; previewEvery?: number;
+}): MarkdownStream;

package/dist/stream.mjs

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+// Full Markdown previews have no append-only promise. Geometric admission bounds
+// the total source passed to a synchronous host, including the final batch pass.
+export function createMarkdownStream(renderMarkdown, {maxSourceLength = 1_000_000, previewEvery = 256} = {}) {
+  if (typeof renderMarkdown !== 'function') throw new TypeError('Supply a synchronous Markdown renderer.');
+  for (const value of [maxSourceLength, previewEvery])
+    if (!Number.isSafeInteger(value) || value < 1) throw new RangeError('Stream limits must be positive finite integers.');
+  let chunks = [], length = 0, threshold = previewEvery, closed = false, revision = 0, rendering = false;
+  function open() {
+    if (closed || rendering) throw new Error(closed ? 'This stream is closed; reset it before writing.' : 'A stream renderer cannot reenter its stream.');
+  }
+  function snapshot(final) {
+    const source = chunks.join('');
+    chunks = source ? [source] : [];
+    // Failed previews consumed work too. Further chunks must still wait for the
+    // next geometric threshold; only an explicit finish retries immediately.
+    threshold = Math.max(previewEvery, length * 2);
+    rendering = true;
+    let html;
+    try {
+      html = renderMarkdown(source);
+      if (typeof html !== 'string') throw new TypeError('The Markdown renderer must return a string synchronously.');
+    } finally { rendering = false; }
+    if (final) { closed = true; chunks = []; length = 0; }
+    return {source, html, revision, final};
+  }
+  return {
+    write(chunk) {
+      open();
+      if (typeof chunk !== 'string') throw new TypeError('Decode transport bytes to strings before writing.');
+      if (chunk.length > maxSourceLength - length)
+        throw Object.assign(new RangeError('The message exceeds its source budget; this chunk was not accepted.'), {code: 'resource-limit'});
+      if (!chunk.length) return null;
+      chunks.push(chunk); length += chunk.length; revision++;
+      return length >= threshold ? snapshot(false) : null;
+    },
+    finish() { open(); revision++; return snapshot(true); },
+    abort() {
+      if (rendering) throw new Error('A stream renderer cannot abort its stream.');
+      if (closed) return;
+      chunks = []; length = 0; closed = true; revision++;
+    },
+    reset() { if (rendering) throw new Error('A stream renderer cannot reset its stream.'); chunks = []; length = 0; threshold = previewEvery; closed = false; return ++revision; },
+    get revision() { return revision; },
+  };
+}

package/docs/api.md

@@ -0,0 +1,210 @@
+# Rapier Math
+
+Self-contained TeX-to-SVG maths with embedded Latin Modern outlines. Rendering is synchronous and offline,
+with no core runtime dependencies, DOM, global installation or remote font request. Optional integrations
+keep the host's Markdown parser in charge.
+
+## Start with a formula
+
+```sh
+npm install rapier-math
+```
+
+```js
+import {render} from 'rapier-math';
+const source = String.raw`\frac{-b\pm\sqrt{b^2-4ac}}{2a}`;
+const result = render(source, {displayMode: true});
+if (result.errors.length) console.error(result.errors);
+else console.log(result.svg);
+```
+
+Keep `source` for editing and copying. A formula API accepts TeX without Markdown delimiters.
+`String.raw` helps with JavaScript literals; JSON and transport decoding are separate layers. Never unescape
+the TeX a second time. Native ESM works in Node 22+, current browsers and module workers; no CommonJS wrapper
+is provided. Server output needs no client renderer unless fitting or further rendering is wanted.
+
+## Markdown
+
+```sh
+npm install markdown-it
+```
+
+```js
+import MarkdownIt from 'markdown-it';
+import rapierMath from 'rapier-math/markdown-it';
+const md = new MarkdownIt({html: false}).use(rapierMath);
+const env = {};
+const html = md.render('Price $5. Code: `$$x$$`. Formula: \\(x^2\\).', env);
+console.log(env.rapierMathErrors || []);
+```
+
+Default delimiters are `\(...\)` (inline), `\[...\]` and `$$...$$` (display). Single `$...$` is opt-in:
+`.use(rapierMath, {singleDollar: true})`. It cannot distinguish all currency from mathematics.
+
+| Boundary rule | Contract |
+| --- | --- |
+| Escapes | An odd run of preceding backslashes escapes a delimiter; an even run does not. The body is never unescaped. |
+| Dollar runs | Only complete runs of one or two dollars are delimiters. Three or more are literal. `\$$` is an escaped pair. |
+| Single dollars | Nonempty body, no leading/trailing whitespace or CR/LF; a closer followed by an ASCII digit is rejected. |
+| Other pairs | Whitespace and newlines are allowed. The first unescaped matching closer wins. No delimiter nesting. |
+| Blocks | A display opener at the host's block start and a closer followed only by line whitespace makes a block. Otherwise it is inline content. |
+| Incomplete input | No math node is emitted until a matching closer exists. Surrounding text stays under host control. |
+| Protected source | Code spans, fences, indented code, link destinations, autolinks and HTML tags remain host syntax. Math in link labels is disabled. Math in image descriptions is retained as literal source in alt text. |
+
+Use `html: false` for untrusted Markdown. If your application enables raw HTML, retain its sanitizer and
+HTML policy. Inline HTML element contents follow the host grammar; the math adapter is not an HTML parser.
+The `rapier-math/delimiters` export offers `createMathMatcher(source, options)(start, limit?)` for authors of
+other host adapters. It indexes boundaries in a raw text region, returns exact UTF-16 offsets, and knows
+nothing about Markdown structure. Do not scan rendered HTML with it.
+
+The Rapier app explicitly keeps its established dollar-only dialect, including math in link labels.
+The shared owner corrects escaped display closers and retains outer formula whitespace. No public
+adapter or renderer imports the app's AGPL Markdown implementation.
+
+## unified / remark / rehype
+
+Use `remark-math`, `remark-rehype`, then `rehype-sanitize`, then `rapier-math/rehype`, then `rehype-stringify`.
+The complete [unified example](../examples/unified.mjs) grants only the math classes on sanitized code nodes.
+The adapter replaces supported `language-math` + `math-inline`/`math-display` nodes with HAST parsed from
+fresh renderer SVG. It does not turn authored raw HTML into trusted markup or loosen the global SVG sanitizer.
+The optional `hast-util-from-html` peer is used only by this entrypoint.
+
+Choose `remarkMath({singleDollarTextMath: false})` to avoid single-dollar ambiguity. Remark owns delimiter,
+whitespace and code rules in this pipeline; its grammar is different from the markdown-it adapter and does
+not enable backslash delimiters. Unsupported formulas remain copyable code and produce VFile messages
+with `ruleId`, `mathOffset` and `mathSource`.
+
+Both rendering adapters accept `renderOptions`, `maxFormulas` (default 1024) and `maxOutputLength` (default
+16 Mi UTF-16 code units of successful SVG per document render). Rendering a cached markdown-it token tree
+again starts a fresh budget; inline children share their enclosing document's budget. Exhaustion leaves subsequent source literal with
+diagnostics. The host owns its own source, tree, prose and final HTML budgets. These are synchronous adapters.
+
+## Streaming
+
+```js
+import {createMarkdownStream} from 'rapier-math/stream';
+const stream = createMarkdownStream(source => md.render(source, {}));
+const preview = stream.write('The answer is \\(x'); // may return null
+stream.write('^2\\).');
+const completed = stream.finish(); // {source, html, revision, final: true}
+```
+
+Use one stream per message. `write` accepts decoded strings and returns either a whole preview or `null`;
+`finish` always runs the same batch renderer on the complete exact source. `abort` releases pending text.
+`reset` starts a replacement and advances the revision. Cancel the old producer before reset, or reject its
+chunks using your conversation generation. No callbacks, timers, DOM mutations or shared conversation state
+are installed. See the [stream example](../examples/stream.mjs).
+
+Markdown references, setext headings and fences can change earlier interpretation, so previews are
+replaceable, not committed prefixes. An open formula remains literal. Defaults: at most 1,000,000 retained
+source code units; first preview at 256 units, then only after the source has at least doubled. Including
+one `finish`, the total source sent to the host is less than three times final length, even if previews fail.
+Explicit retries of `finish` are additional host calls. There is no full-prefix
+render on every token. Late previews are consequently less frequent; show incoming chunks as text for
+immediate progress. `previewEvery` sets the first threshold, not a fixed per-chunk interval.
+
+Retained state is O(message length), not a claimed constant-memory Markdown parser. Stream chunks can split
+delimiters, CRLF, escapes or surrogate pairs. Final interpretation is batch-equivalent; interim previews
+may show an incomplete code unit. A rejected oversized chunk is not accepted or silently truncated; the
+caller still owns it. A failed renderer leaves accumulated source available for retry or reset.
+
+## Formula API and browser lifetime
+
+| Export | Result |
+| --- | --- |
+| `render(tex, options?)` | `{svg, width, height, depth, lines, fitted, errors}`; dimensions in mathematical ems. |
+| `renderToString(tex, options?)` | SVG, including diagnostic SVG for admitted malformed or unsupported syntax. |
+| `parse(tex)` | Inspectable AST; throws structured errors. Internal node vocabulary can grow. |
+| `fit(container)` | One synchronous DOM fitting pass, returning selected formula count. |
+| `observe(container)` | Observe current formulas; returns idempotent cleanup. |
+| `version` | The package version. Default export provides the same API. |
+
+`displayMode`, `maxWidth` in mathematical ems, and optional `screen: {fontSize, pixelRatio, dark}` configure
+rendering. Screen numbers must be positive finite values; `dark` must be boolean. Omit screen options for
+SSR and the initial hydration render. Long rows break at available relations/operators; indivisible
+oversized groups scale to fit. Fit after hydration, stop observation before replacement, then observe the
+new formulas. Stop on unmount. [Browser](../examples/browser.html), [worker](../examples/worker.mjs) and
+[React/SSR](../examples/react.tsx) examples demonstrate these boundaries. React is not a package dependency.
+
+## Errors, source and accessibility
+
+Check `errors` before treating a formula as successful. Errors include `code`, `message`, UTF-16 `offset`
+and sometimes `command`. Render-result messages are limited to 1024 code units plus an ellipsis and command
+names to 128, with explicit `messageTruncated`/`commandTruncated` flags. Exact admitted source is retained
+independently. `parse` throws the parser's details, bounded by its source admission limit. Do not use a
+diagnostic message as a source archive.
+
+Valid XML source is kept exactly in SVG `aria-label` and `title`, including BOM, tabs and CRLF (escaped as
+character references). Invalid XML characters have visible Unicode escapes and a `data-tex-utf16` carrier:
+each four hex digits represents one original UTF-16 code unit. This includes isolated surrogates. The
+Markdown host may normalize its syntax-node content; retain the original Markdown separately. Streams
+return the exact concatenated source, including malformed UTF-16, without normalization.
+
+Source longer than 1,000,000 code units returns a bounded `resource-limit` diagnostic before source
+scanning, escaping or parsing. Its error has `sourceOmitted: true` and its SVG has
+`data-math-source-omitted="true"`; neither embeds or truncates the refused source. `renderToString` returns
+the same diagnostic SVG. Keep the original input for editing or copying. Admitted source alternatives
+remain exact. Other limits include 100,000 tokens, 50,000 parser nodes, depth 192, 4096 macro expansions, 100,000 layout
+visits, 4 Mi outline characters and 8 Mi composed SVG characters. Complete returned SVG, including source
+alternatives and diagnostics, is capped at 24 Mi UTF-16 code units. These are output/work bounds, not peak
+heap or device-memory claims. A later good render has a fresh budget.
+
+SVG labels contain raw TeX, not semantic MathML or mathematical speech. Ordinary equations are images in
+the accessibility tree. Equations containing authored HTTP(S) links use a group so the links remain exposed;
+each link is keyboard-focusable and labelled with its destination. Keep the editable source or a separate
+copy-source affordance in your host. Full semantic navigation, speech and screen-reader parity are not
+provided. A future semantic serializer needs an explicit AST-to-MathML mapping and assistive-technology
+evaluation; adding a raw TeX label does not satisfy that requirement.
+
+## Security and deployment
+
+The renderer emits local SVG outlines, never executable HTML, remote font/image fetches or loaded TeX
+extensions. Authored links permit only HTTP(S) and use `noopener noreferrer`. Insert only the returned
+SVG, never concatenate TeX or arbitrary HTML into the sink. On failure, use a text node or the framework's
+escaped text rendering. Formula safety does not sanitize surrounding Markdown.
+
+The native ESM path needs no `eval` or `unsafe-eval`. Generated SVG does contain style attributes:
+`script-src 'self'; style-src-attr 'unsafe-inline'; style-src-elem 'none'` permits same-origin external
+modules and those attributes in browsers implementing CSP3. It does **not** work under a policy forbidding
+all inline styles. `examples/browser.html` carries that policy; older browsers need their own reviewed
+style policy. No network access is needed after local module loading; use `connect-src 'none'` if suitable.
+
+With `require-trusted-types-for 'script'`, string HTML sinks and the DOMParser used by `fit`/`observe`
+require TrustedHTML. The core does not create a policy, return TrustedHTML or claim fitting support under
+that policy. Prefer server-rendered output or the structured rehype path in such applications. If the host
+uses a policy for initial insertion, narrowly scope it to freshly generated renderer output; never use a
+blanket identity policy for arbitrary strings. The browser/React examples assume string sinks are permitted.
+
+## Syntax and limits
+
+Supported: fractions, roots, scripts, limits, matrices/arrays/alignment, delimiters, accents, operators,
+Greek and mathematical alphabets, text/color/size/spacing, local macros, and selected chemistry/physics.
+Existing supported package names select built-in syntax; there is no external package/file loader.
+This is not a complete TeX document engine. No automatic numbering or cross-formula reference guarantee.
+Unsupported commands give diagnostics. Lowercase script/bold-script requests use ordinary-letter fallbacks
+where Latin Modern lacks those alphabets. All embedded licensed outlines remain present.
+
+## Package and proof
+
+Declarations accompany every public entry. Formula imports do not pull in Markdown, unified or React.
+For TypeScript, markdown-it 15 provides its own types; markdown-it 14 projects also install
+`@types/markdown-it@14`. Use the declarations for your host version.
+For a classic script, use `dist/rapier-math.js` and `globalThis.RapierMath`.
+The payload includes the font: it is not a few-kilobyte renderer. Payload counts below describe this
+build, not npm tarball size or a comparison against another library.
+
+Run `node tests/verify.mjs` and `node tests/check.mjs` from this checkout. The carried source rebuilds the exact
+classic payload and ESM module; receipts also cover the adapters, declarations and examples. Follow
+`docs/font-source.md` to regenerate font data. License and font provenance are carried with every build.
+
+Verified-claim scope: synchronous self-contained formula rendering; opt-in Markdown integrations; bounded
+replaceable previews with exact final source; structured diagnostics and explicit source fallback. This
+does not establish all-device behavior, full TeX compatibility, semantic accessibility or universal
+size/speed superiority. Test your host's sanitizer, CSP, browser lifetime and supported formula corpus.
+
+## Licenses
+
+The renderer and neutral adapters are MIT. Latin Modern Math 1.959 outlines/metrics retain the GUST Font
+License, an instance of LPPL. `LICENSE` contains both complete grants. `src/math/LICENSE-MIT`,
+`src/math/FONT-LICENSE.txt` and the SPDX 2.3 `docs/math-components.json` retain renderer and font notices. Both payloads
+retain complete licenses. App-specific AGPL source is not included in this package.

package/{math-components.json → docs/math-components.json}

@@ -2,10 +2,10 @@
   "spdxVersion": "SPDX-2.3",
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
-  "name": "rapier-math-1.0.2",
-  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.0.2-55c326429ed51564670c67fb4e35eddbe4115fb077440146e4fbb5f81a247f9a",
+  "name": "rapier-math-1.1.1",
+  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.1.1-050f4ebfb7c78beaefb01c9d6aa62192fd03757fc677134850bdb1f090033b81",
   "creationInfo": {
-    "created": "2026-10-12T10:57:51.103Z",
+    "created": "2026-10-12T17:29:00Z",
     "creators": [
       "Tool: rapier-math-components",
       "Organization: rapier.website"
@@ -15,8 +15,8 @@
     {
       "name": "rapier-math",
       "SPDXID": "SPDXRef-rapier-math",
-      "versionInfo": "1.0.2",
-      "downloadLocation": "https://cdn.jsdelivr.net/gh/jackskip22/rapier-plugins@main/math/rapier-math-1.0.2.js",
+      "versionInfo": "1.1.1",
+      "downloadLocation": "NOASSERTION",
       "filesAnalyzed": false,
       "licenseConcluded": "MIT AND LicenseRef-GUST-Font-License",
       "licenseDeclared": "MIT AND LicenseRef-GUST-Font-License",
@@ -24,7 +24,7 @@
       "checksums": [
         {
           "algorithm": "SHA256",
-          "checksumValue": "55c326429ed51564670c67fb4e35eddbe4115fb077440146e4fbb5f81a247f9a"
+          "checksumValue": "050f4ebfb7c78beaefb01c9d6aa62192fd03757fc677134850bdb1f090033b81"
         }
       ]
     },
@@ -43,7 +43,7 @@
           "checksumValue": "6075562b771f8b82f0c179e363389684f2dd09de30038269e2628e504bd7be0f"
         }
       ],
-      "comment": "SVG outlines and OpenType MATH metrics; complete license in math-font-LICENSE.txt"
+      "comment": "SVG outlines and OpenType MATH metrics; complete license in src/math/FONT-LICENSE.txt"
     }
   ],
   "hasExtractedLicensingInfos": [