rapier-math 1.0.2 → 1.1.1

package/src/math/browser.js

@@ -88,12 +88,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');

package/src/math/layout.js

@@ -574,7 +574,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'});
   }
 }

package/src/math/package-build.mjs

@@ -1,8 +1,5 @@
 // SPDX-License-Identifier: MIT
 // The module has the exact classic renderer body, with module-local exports.
-import {readFile, writeFile} from 'node:fs/promises';
-import {dirname, resolve} from 'node:path';
-import {fileURLToPath} from 'node:url';
 
 export function mathModule(bundle) {
   const text = String(bundle), opening = "(function(){\n'use strict';\n", ending = '\n})();\n';
@@ -15,13 +12,3 @@ export function mathModule(bundle) {
     'const {version, parse, render, fit, observe, renderToString} = RapierMath;\n' +
     'export {version, parse, render, fit, observe, renderToString};\nexport default RapierMath;\n';
 }
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  if (!process.argv[2]) throw new Error('usage: node src/math/package-build.mjs <module-file>');
-  const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-  const {buildMath} = await import('../tools/build-math.mjs');
-  const result = await buildMath({root, updatePins: false});
-  const text = mathModule(await readFile(resolve(root, 'shell/vendor', result.bundle), 'utf8'));
-  await writeFile(resolve(process.argv[2]), text);
-  console.log(JSON.stringify({file: process.argv[2], bytes: Buffer.byteLength(text)}));
-}

package/src/math/package-layout.mjs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+export const MATH_CLASSIC = 'dist/rapier-math.js';
+
+// One public location per authored input. Runtime formats share dist/.
+export function mathPackagePath(file) {
+  const owners = {
+    'math/README.md': 'docs/api.md',
+    'math/FONT-SOURCE.md': 'docs/font-source.md',
+    'math/package-check.mjs': 'tests/check.mjs',
+    'math/package-verify.mjs': 'tests/verify.mjs',
+    'math/adoption-verify.mjs': 'tests/adoption.mjs',
+  };
+  if (owners[file]) return owners[file];
+  if (file.startsWith('math/examples/')) return file.slice(5);
+  if (/^math\/(?!package-).+\.(?:mjs|d\.ts)$/.test(file)) return 'dist/' + file.slice(5);
+  return 'src/' + file;
+}

package/src/math/package-readme.mjs

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+export function mathReadme(resources) {
+  return `# Rapier Math
+
+A self-contained TeX-to-SVG renderer with Latin Modern outlines. Synchronous, no runtime downloads.
+
+## Use
+
+\`\`\`sh
+npm install rapier-math
+\`\`\`
+
+\`\`\`js
+import {renderToString} from 'rapier-math';
+const svg = renderToString(String.raw\`\\frac{a}{b}\`);
+\`\`\`
+
+For a browser script, load [${resources.packageBundle}](${resources.packageBundle}) and use
+\`globalThis.RapierMath\`. The native ESM entry is [dist/index.mjs](dist/index.mjs).
+Both include the font and return synchronously. Type declarations accompany the runtime files.
+
+- [API and integration guide](docs/api.md)
+- [Runnable examples](examples/README.md)
+- [Font source and regeneration](docs/font-source.md)
+
+## Develop
+
+The current runtime formats live in \`dist/\`; editable renderer source and its build tools live in
+\`src/\`. Optional adapters have one source copy in \`dist/\`. Examples, documentation and tests each
+have their own directory. Only the current release is kept in this checkout.
+
+From a repository checkout, run \`node tests/check.mjs\` and \`node tests/verify.mjs\` to check the package and rebuild its exact bytes.
+Run \`node src/tools/build-math.mjs --package .\` to regenerate the classic and ESM files from source.
+Optional host checks run with \`node tests/adoption.mjs\` after installing the example dependencies.
+
+## License
+
+The renderer and adapters are MIT-licensed. Embedded Latin Modern Math outlines and metrics are
+licensed under the GUST Font License. [LICENSE](LICENSE) contains both complete grants.
+[Component provenance](docs/math-components.json) and [source hashes](docs/math-resources.json)
+travel with the package.
+
+Version ${resources.version}. Classic payload: ${resources.bytes} bytes; gzip (level 9): ${resources.gzipBytes} bytes.
+`;
+}

package/src/tools/build-math.mjs

@@ -7,12 +7,20 @@ import {fileURLToPath} from 'node:url';
 import {createHash} from 'node:crypto';
 import {gzipSync} from 'node:zlib';
 import {Script} from 'node:vm';
+import {mathPackagePath, MATH_CLASSIC} from '../math/package-layout.mjs';
+import {mathModule} from '../math/package-build.mjs';
+import {mathReadme} from '../math/package-readme.mjs';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-export const MATH_VERSION = '1.0.2';
+export const MATH_VERSION = '1.1.1';
 export const MATH_BUNDLE = 'rapier-math-' + MATH_VERSION + '.js';
 export const MATH_SOURCES = ['font.js', 'symbols.js', 'parser.js', 'layout.js', 'fallbacks.js', 'responsive.js', 'browser.js', 'api.js'].map(name => 'math/' + name);
-export const MATH_RECIPE = ['math/build-font.py', 'math/FONT-SOURCE.md', 'math/FONT-LICENSE.txt', 'math/package-verify.mjs', 'tools/build-math.mjs', 'math/LICENSE-MIT'];
+export const MATH_RECIPE = ['math/build-font.py', 'math/FONT-SOURCE.md', 'math/FONT-LICENSE.txt', 'math/package-verify.mjs', 'tools/build-math.mjs', 'math/LICENSE-MIT', 'math/adoption-verify.mjs', 'math/package-build.mjs', 'math/package-layout.mjs', 'math/package-check.mjs', 'math/package-readme.mjs', 'math/README.md'];
+export const MATH_ADOPTION = ['delimiters.mjs', 'markdown-rules.mjs', 'integration.mjs', 'markdown-it.mjs', 'rehype.mjs', 'stream.mjs',
+  'index.d.ts', 'classic.d.ts', 'delimiters.d.ts', 'integration.d.ts', 'markdown-it.d.ts', 'rehype.d.ts', 'stream.d.ts',
+  'examples/formula.mjs', 'examples/markdown.mjs', 'examples/stream.mjs', 'examples/unified.mjs',
+  'examples/browser.html', 'examples/browser.mjs', 'examples/react.tsx', 'examples/worker.mjs', 'examples/README.md']
+  .map(file => ({file: 'math/' + file, packageFile: mathPackagePath('math/' + file)}));
 const FONT = {
   name: 'Latin Modern Math', version: '1.959', license: 'LicenseRef-GUST-Font-License',
   licenseName: 'GUST Font License',
@@ -25,8 +33,8 @@ const FONT = {
 };
 const digest = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
 
-async function fontLicense(root) {
-  const bytes = await readFile(resolve(root, FONT.licenseFile));
+async function fontLicense(root, packageLayout = false) {
+  const bytes = await readFile(resolve(root, packageLayout ? mathPackagePath(FONT.licenseFile) : FONT.licenseFile));
   if (digest(bytes) !== FONT.licenseSha256 || !bytes.includes(FONT.copyright))
     throw new Error('The math font license differs from its source pin');
   return bytes;
@@ -39,15 +47,16 @@ export async function fillMathLicense(markup, {root = ROOT} = {}) {
   return markup.replace(marker, () => '<pre class="license-text">' + escaped + '</pre>');
 }
 
-export async function buildMath({root = ROOT, updatePins = true} = {}) {
+export async function assembleMath({root = ROOT, packageLayout = false} = {}) {
+  const read = file => readFile(resolve(root, packageLayout ? mathPackagePath(file) : file));
   const inputs = [];
   for (const file of MATH_SOURCES) {
-    const bytes = await readFile(resolve(root, file));
+    const bytes = await read(file);
     inputs.push({file, bytes, text: bytes.toString('utf8')});
   }
-  const license = await fontLicense(root);
+  const license = await fontLicense(root, packageLayout);
   if (!inputs[0].text.includes(license.toString('utf8').trim())) throw new Error('The embedded math font is missing its complete license');
-  const ownLicense = await readFile(resolve(root, 'math/LICENSE-MIT'), 'utf8');
+  const ownLicense = (await read('math/LICENSE-MIT')).toString('utf8');
   const bytes = Buffer.from('/*!\n' + ownLicense.trim() + '\n*/\n(function(){\n\'use strict\';\n' + inputs.map(input => input.text.trimEnd()).join('\n\n') + '\n})();\n');
   new Script(bytes.toString('utf8'), {filename: MATH_BUNDLE});
   const gzipBytes = gzipSync(bytes, {level: 9}).length;
@@ -55,17 +64,41 @@ export async function buildMath({root = ROOT, updatePins = true} = {}) {
   const sha256 = digest(bytes), sha384 = digest(bytes, 'sha384', 'base64');
   const recipe = [];
   for (const file of MATH_RECIPE) {
-    const content = await readFile(resolve(root, file));
-    recipe.push({file, bytes: content.length, sha256: digest(content)});
+    const content = await read(file);
+    recipe.push({file, packageFile: mathPackagePath(file), bytes: content.length, sha256: digest(content)});
   }
   const resources = {
-    bundle: MATH_BUNDLE, version: MATH_VERSION, license: 'MIT AND ' + FONT.license,
+    bundle: MATH_BUNDLE, packageBundle: MATH_CLASSIC, version: MATH_VERSION, license: 'MIT AND ' + FONT.license,
     bytes: bytes.length, gzipBytes, sha256, sha384,
-    sources: inputs.map(input => ({file: input.file, bytes: input.bytes.length, sha256: digest(input.bytes)})),
+    sources: inputs.map(input => ({file: input.file, packageFile: mathPackagePath(input.file), bytes: input.bytes.length, sha256: digest(input.bytes)})),
     recipe,
     components: [{name: FONT.name, version: FONT.version, license: FONT.license, source: FONT.source, sha256: FONT.sourceSha256}],
     font: {...FONT, licenseBytes: license.length},
   };
+  resources.adoption = [];
+  for (const {file, packageFile} of MATH_ADOPTION) {
+    const content = await read(file);
+    resources.adoption.push({file, packageFile, bytes: content.length, sha256: digest(content)});
+  }
+  return {resources, bytes};
+}
+
+export async function buildMath({root = ROOT, updatePins = true, packageLayout = false} = {}) {
+  const {resources, bytes} = await assembleMath({root, packageLayout});
+  if (packageLayout) {
+    await mkdir(resolve(root, 'dist'), {recursive: true});
+    await writeFile(resolve(root, MATH_CLASSIC), bytes);
+    await writeFile(resolve(root, 'dist/index.mjs'), mathModule(bytes));
+    await writeFile(resolve(root, 'docs/math-resources.json'), JSON.stringify(resources, null, 2) + '\n');
+    await writeFile(resolve(root, 'README.md'), mathReadme(resources));
+    const sbomPath = resolve(root, 'docs/math-components.json');
+    const sbom = JSON.parse(await readFile(sbomPath, 'utf8'));
+    sbom.packages.find(item => item.name === 'rapier-math').checksums = [{algorithm: 'SHA256', checksumValue: resources.sha256}];
+    sbom.documentNamespace = 'https://rapier.website/spdx/rapier-math-' + resources.version + '-' + resources.sha256;
+    await writeFile(sbomPath, JSON.stringify(sbom, null, 2) + '\n');
+    return {bundle: MATH_CLASSIC, bytes: bytes.length, sha256: resources.sha256};
+  }
+  const {sha256, sha384, gzipBytes} = resources;
   const vendor = resolve(root, 'shell/vendor');
   await mkdir(vendor, {recursive: true});
   await writeFile(resolve(vendor, MATH_BUNDLE), bytes);
@@ -91,5 +124,7 @@ export async function buildMath({root = ROOT, updatePins = true} = {}) {
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  console.log(JSON.stringify(await buildMath({root: process.argv[2] ? resolve(process.argv[2]) : ROOT})));
+  const packageLayout = process.argv[2] === '--package';
+  const directory = process.argv[packageLayout ? 3 : 2];
+  console.log(JSON.stringify(await buildMath({root: directory ? resolve(directory) : ROOT, packageLayout})));
 }

package/tests/adoption.mjs

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+// Optional host checks: run from the installed package with the example peers.
+// One source-custody table; no appearance or timing assertions.
+import assert from 'node:assert/strict';
+import MarkdownIt from 'markdown-it';
+import {render} from 'rapier-math';
+import rapierMath from 'rapier-math/markdown-it';
+import {createMathMatcher} from 'rapier-math/delimiters';
+import {createMarkdownStream} from 'rapier-math/stream';
+import {processor} from '../examples/unified.mjs';
+
+const md = new MarkdownIt({html: false}).use(rapierMath);
+const dollar = new MarkdownIt({html: false}).use(rapierMath, {singleDollar: true});
+const mathNodes = (host, source) => host.parse(source, {}).flatMap(token => token.children || [token])
+  .filter(token => token.type === 'math_inline' || token.type === 'math_block');
+const rows = [
+  ['escaped pair incomplete', String.raw`$$x\$$`, 0],
+  ['escaped pair then closer', String.raw`$$x\$$y$$`, 1],
+  ['even escape run', String.raw`$$x\\$$`, 1],
+  ['brackets', String.raw`A \(x+1\) B \[y\]`, 2],
+  ['escaped bracket opener', String.raw`A \\(x\\)`, 0],
+  ['currency', 'It costs $5 and $10.', 0],
+  ['code and fence', '`$$x$$`\n\n```tex\n$$y$$\n```\n\n    $$z$$\n', 0],
+  ['links', String.raw`[\(x\)](https://example.com/$$x$$)`, 0],
+  ['literal backslashes', String.raw`Path C:\\temp. \(\text{a\ b}\)`, 1],
+  ['CRLF BOM Unicode', '\ufeffπ 🐈\r\n\r\n$$\r\nx+1\r\n$$\r\n', 1],
+  ['incomplete', 'Before \\(x+1 and after', 0],
+  ['malformed UTF-16', '\ud800 and \\(x\\) and \udfff', 1],
+];
+for (const [name, source, count] of rows) {
+  assert.equal(mathNodes(md, source).length, count, name);
+  const batch = md.render(source, {});
+  // Every two-piece boundary, including CRLF, escape runs and surrogate pairs.
+  for (let split = 0; split <= source.length; split++) {
+    const stream = createMarkdownStream(text => md.render(text, {}), {previewEvery: 8});
+    stream.write(source.slice(0, split)); stream.write(source.slice(split));
+    const final = stream.finish();
+    assert.equal(final.source, source, name + ': exact transport source');
+    assert.equal(final.html, batch, name + ': final batch agreement');
+  }
+}
+for (const [source, count] of [[String.raw`$x\$y$`, 1], ['$x$5', 0], ['$ x$', 0], ['$x $', 0], ['$$$x$$$', 0]])
+  assert.equal(mathNodes(dollar, source).length, count);
+// Image descriptions are text-only host output: unknown math token types must
+// not disappear from alt text or spend a formula-render budget.
+for (const [source, alt] of [
+  [String.raw`![before $$x$$ after](image.png)`, 'before $$x$$ after'],
+  [String.raw`![before \(x\) after](image.png)`, String.raw`before \(x\) after`],
+  [String.raw`![a ![b $$x$$](inner.png) c](outer.png)`, 'a b $$x$$ c'],
+  [String.raw`![a $$\text{<>&"}$$ b](image.png)`, 'a $$\\text{&lt;&gt;&amp;&quot;}$$ b'],
+]) {
+  const host = new MarkdownIt({html: false}).use(rapierMath, {maxFormulas: 1});
+  const tokens = host.parse(source + String.raw` \(y\)`, {});
+  for (let pass = 0; pass < 2; pass++) {
+    const env = {}, html = host.renderer.render(tokens, host.options, env);
+    assert(html.includes('alt="' + alt + '"'), 'image math remains literal source');
+    assert.equal((html.match(/<svg /g) || []).length, 1, 'alt text does not spend the formula budget');
+    assert.equal(env.rapierMathErrors, undefined);
+  }
+}
+const exact = '\ufeff$$\r\n α+\\text{a\\ b} 🐈\r\n$$';
+const span = createMathMatcher(exact)(1);
+assert.equal(exact.slice(span.bodyStart, span.bodyEnd), '\r\n α+\\text{a\\ b} 🐈\r\n');
+assert.equal(createMathMatcher(String.raw`$$x\$$`)(0), null);
+
+const first = createMarkdownStream(text => text, {maxSourceLength: 8, previewEvery: 2});
+const second = createMarkdownStream(text => text);
+first.write('ab'); second.write('other'); first.abort(); first.abort();
+assert.throws(() => first.write('c'));
+first.reset(); first.write('new');
+assert.throws(() => first.write('123456'), {code: 'resource-limit'});
+assert.equal(first.finish().source, 'new');
+assert.equal(second.finish().source, 'other');
+assert.throws(() => second.finish());
+let failingHost = true, supplied = 0;
+const failing = createMarkdownStream(text => {
+  supplied += text.length;
+  if (failingHost) throw new Error('host failed');
+  return text;
+}, {previewEvery: 2});
+const failedSource = 'x'.repeat(32);
+for (const chunk of failedSource) {
+  try { failing.write(chunk); } catch (error) { assert.equal(error.message, 'host failed'); }
+}
+failingHost = false;
+assert.equal(failing.finish().source, failedSource, 'failed previews retain every accepted chunk');
+assert(supplied < 3 * failedSource.length, 'failed previews keep the repeated-work bound');
+failing.abort(); failing.reset();
+
+const hostile = String.raw`Before \(\text{</title><script>alert(1)</script>}\). <img src=x onerror=alert(1)>`;
+assert(!/<script|<img/i.test(md.render(hostile, {})));
+// Cached syntax can serve multiple outputs. Budgets belong to each render, not
+// to parsing or to an env object; every paragraph still shares one document cap.
+const formulaSource = String.raw`\(x\)`, svgCount = html => (html.match(/<svg /g) || []).length;
+for (const budgets of [{maxFormulas: 1}, {maxOutputLength: render('x').svg.length}]) {
+  const host = new MarkdownIt({html: false}).use(rapierMath, budgets);
+  for (const inline of [false, true]) {
+    const source = formulaSource + (inline ? ' ' : '\n\n') + formulaSource;
+    const tree = host.parse(source, {});
+    const tokens = inline ? tree[1].children : tree;
+    const renderer = inline ? host.renderer.renderInline : host.renderer.render;
+    for (let pass = 0; pass < 2; pass++) {
+      const env = {}, out = renderer.call(host.renderer, tokens, host.options, env);
+      assert.equal(svgCount(out), 1);
+      assert.equal(env.rapierMathErrors.length, 1);
+      assert.equal(env.rapierMathErrors[0].errors[0].code, 'resource-limit');
+      assert(out.includes(formulaSource));
+    }
+  }
+}
+const nestedHost = new MarkdownIt({html: false}).use(rapierMath, {maxFormulas: 1});
+const nestedTree = nestedHost.parse(formulaSource + ' fail', {});
+const textRule = nestedHost.renderer.rules.text;
+nestedHost.renderer.rules.text = (tokens, index, opts, env, self) => {
+  if (tokens[index].content === ' fail') throw new Error('host render failed');
+  if (tokens[index].content.includes('nested')) {
+    for (const inline of [false, true]) {
+      const nestedEnv = {};
+      assert.throws(() => inline
+        ? self.renderInline(nestedTree[1].children, opts, nestedEnv)
+        : self.render(nestedTree, opts, nestedEnv), /host render failed/);
+      assert.equal(nestedEnv.rapierMathErrors, undefined, 'nested render has its own budget');
+    }
+  }
+  return textRule(tokens, index, opts, env, self);
+};
+const outerTree = nestedHost.parse(formulaSource + ' nested ' + formulaSource, {});
+// A custom host can run the same renderer twice; a failed nested render must
+// restore the outer cap and leave subsequent root renders fresh.
+for (let pass = 0; pass < 2; pass++) {
+  const env = {}, out = nestedHost.renderer.render(outerTree, nestedHost.options, env);
+  assert.equal(svgCount(out), 1);
+  assert.equal(env.rapierMathErrors.length, 1);
+  assert.equal(env.rapierMathErrors[0].errors[0].code, 'resource-limit');
+}
+const tiny = new MarkdownIt({html: false}).use(rapierMath, {maxOutputLength: 1});
+assert(!tiny.render(String.raw`\(x\)`).includes('<svg'));
+const bad = {}, fallback = md.render(String.raw`Good \(x\). Bad \(\unknown{x}\).`, bad);
+assert.equal(bad.rapierMathErrors[0].errors[0].code, 'unsupported-command');
+assert(fallback.includes('\\unknown{x}'));
+
+const unified = await processor.process('Code `$$x$$`. Math $$x+1$$.\n\n<script>alert(1)</script>\n\n$$\\unknown{x}$$');
+assert.equal((String(unified).match(/<svg /g) || []).length, 1);
+assert(!String(unified).includes('<script'));
+assert.equal(unified.messages[0].ruleId, 'unsupported-command');
+assert(String(unified).includes('\\unknown{x}'));
+console.log(JSON.stringify({sourceCustodyRows: rows.length, splitAgreement: 'all two-piece boundaries',
+  lifetimes: 'abort, reset, replacement, rejection, interleaved messages', adapters: 'markdown-it and sanitized unified',
+  security: 'hostile source stays inert; document math budgets fall back'}));

package/{check.mjs → tests/check.mjs}

@@ -3,28 +3,31 @@
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {Script, createContext} from 'node:vm';
-import {mathModule} from './src/math/package-build.mjs';
+import {mathModule} from '../src/math/package-build.mjs';
 
-const read = path => readFile(new URL(path, import.meta.url), 'utf8');
+const read = path => readFile(new URL('../' + path, import.meta.url), 'utf8');
 const pkg = JSON.parse(await read('./package.json'));
-const resources = JSON.parse(await read('./src/shell/math-resources.json'));
-const classicSource = await read('./' + resources.bundle);
+const resources = JSON.parse(await read('./docs/math-resources.json'));
+const classicSource = await read('./' + resources.packageBundle);
 assert.equal(pkg.name, 'rapier-math');
 assert.equal(pkg.version, resources.version);
 assert.equal(pkg.type, 'module');
 assert.equal(pkg.license, 'SEE LICENSE IN LICENSE');
 assert.equal(Object.keys(pkg.dependencies || {}).length, 0);
 assert.equal(Object.keys(pkg.scripts || {}).length, 0);
-assert.equal(await read('./index.mjs'), mathModule(classicSource), 'exact generated module');
-const rendererLicense = await read('./LICENSE-MIT'), fontLicense = await read('./math-font-LICENSE.txt');
-for (const name of ['./LICENSE', './index.mjs', './' + resources.bundle]) {
+assert.equal(await read('./dist/index.mjs'), mathModule(classicSource), 'exact generated module');
+const rendererLicense = await read('./src/math/LICENSE-MIT'), fontLicense = await read('./src/math/FONT-LICENSE.txt');
+for (const name of ['./LICENSE', './dist/index.mjs', './' + resources.packageBundle]) {
   const text = await read(name);
   assert(text.includes(rendererLicense.trim()), name + ': renderer license');
   assert(text.includes(fontLicense.trim()), name + ': complete font license');
 }
 
+// Initialize Node's lazy Web API globals before observing module purity. This
+// allocates a local Response only; no network request or renderer evaluation.
+new Response();
 const globals = Object.getOwnPropertyDescriptors(globalThis);
-const module = await import('./index.mjs');
+const module = await import('../dist/index.mjs');
 const afterImport = Object.getOwnPropertyDescriptors(globalThis);
 assert.deepEqual(Reflect.ownKeys(afterImport), Reflect.ownKeys(globals), 'module adds no globals');
 for (const key of Reflect.ownKeys(globals)) for (const field of Object.keys(globals[key]))
@@ -93,5 +96,23 @@ for (const source of hostile) {
   assert.deepEqual(plain(result), plain(classic.render(source)), 'module/classic hostile result');
 }
 for (const source of hostile.slice(1)) assert(module.render(source).errors.length, 'unsafe or exhausted input produces a diagnostic');
+for (const source of ['x'.repeat(1_000_001), '\ud800'.repeat(1_000_001), '&'.repeat(8_000_000)]) {
+  const result = module.render(source);
+  assert.equal(result.errors[0].code, 'resource-limit');
+  assert.equal(result.errors[0].sourceOmitted, true);
+  assert(result.svg.includes('data-math-source-omitted="true"'));
+  assert(!result.svg.includes('data-tex-utf16'), 'refused source never creates a carrier');
+  assert(result.svg.length < 100_000, 'refusal diagnostic is fixed-size');
+  assert.equal(module.renderToString(source), result.svg);
+  assert.deepEqual(plain(result), plain(classic.render(source)), 'module/classic refusal result');
+  inert(result.svg);
+}
+const longCommand = '\\' + 'a'.repeat(10_000), diagnostic = module.render(longCommand);
+assert(diagnostic.errors[0].messageTruncated && diagnostic.errors[0].commandTruncated);
+sourceAlternative(diagnostic, longCommand);
+assert(diagnostic.errors[0].message.length <= 1025 && diagnostic.errors[0].command.length <= 128);
+const unicodeFailure = module.render('\\begin{' + '😀'.repeat(600) + '}x');
+assert(unicodeFailure.errors[0].message.isWellFormed(), 'diagnostic admission cannot split a source surrogate pair');
+assert.equal(module.render('x+1').errors.length, 0, 'refused input cannot poison later rendering');
 console.log(JSON.stringify({name: pkg.name, version: module.version, module: 'native ESM; no global changes',
   rebuild: 'exact module', classicAgreement: examples.length + hostile.length, sourceAlternatives: 'exact', hostileContent: 'inert', licenses: 'complete'}));

package/tests/verify.mjs

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+// Verify each carried owner once and rebuild both current runtime formats.
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {assembleMath} from '../src/tools/build-math.mjs';
+import {mathModule} from '../src/math/package-build.mjs';
+import {mathReadme} from '../src/math/package-readme.mjs';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const read = path => readFile(resolve(root, path));
+const hash = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
+const resources = JSON.parse(await read('docs/math-resources.json'));
+const payload = await read(resources.packageBundle);
+assert.equal(payload.length, resources.bytes, 'payload length');
+assert.equal(hash(payload), resources.sha256, 'payload SHA-256');
+assert.equal(hash(payload, 'sha384', 'base64'), resources.sha384, 'payload SHA-384');
+const paths = new Set();
+for (const input of [...resources.sources, ...resources.recipe, ...resources.adoption]) {
+  assert(!paths.has(input.packageFile), 'one public location per owner');
+  paths.add(input.packageFile);
+  const bytes = await read(input.packageFile);
+  assert.equal(bytes.length, input.bytes, input.file + ': length');
+  assert.equal(hash(bytes), input.sha256, input.file + ': SHA-256');
+}
+const rendererLicense = await read('src/math/LICENSE-MIT');
+const fontLicense = await read('src/math/FONT-LICENSE.txt');
+assert.equal(hash(fontLicense), resources.font.licenseSha256, 'font license SHA-256');
+for (const text of [payload, await read('LICENSE'), await read('dist/index.mjs')]) {
+  assert(text.includes(rendererLicense.toString('utf8').trim()), 'complete renderer license');
+  assert(text.includes(fontLicense.toString('utf8').trim()), 'complete font license');
+}
+const sbom = JSON.parse(await read('docs/math-components.json'));
+const font = sbom.packages.find(item => item.name === resources.font.name);
+assert.equal(font?.copyrightText, resources.font.copyright, 'font copyright');
+assert.equal(font.licenseDeclared, resources.font.license, 'font license identity');
+assert.equal(sbom.hasExtractedLicensingInfos.find(item => item.licenseId === resources.font.license)?.extractedText,
+  fontLicense.toString('utf8'), 'complete extracted font license');
+assert.equal((await read('README.md')).toString('utf8'), mathReadme(resources), 'generated README');
+const rebuilt = await assembleMath({root, packageLayout: true});
+assert.deepEqual(rebuilt.bytes, payload, 'rebuilt classic payload');
+assert.equal((await read('dist/index.mjs')).toString('utf8'), mathModule(rebuilt.bytes), 'rebuilt ESM payload');
+console.log(JSON.stringify({file: resources.packageBundle, bytes: payload.length, sha256: resources.sha256,
+  sourceFiles: paths.size, rebuild: 'exact', licenses: 'complete'}));

package/LICENSE-MIT

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Jack Skipworth
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/math-LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Jack Skipworth
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.