rapier-math 1.1.0 → 1.1.1

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "rapier-math",
-  "version": "1.1.0",
-  "description": "Self-contained TeX-to-SVG math renderer with Latin Modern outlines.",
+  "version": "1.1.1",
+  "description": "Self-contained offline LaTeX-to-SVG rendering with Latin Modern outlines, optional Markdown integrations and streaming helpers.",
   "type": "module",
-  "main": "./index.mjs",
-  "types": "./index.d.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "sideEffects": [
-    "./rapier-math-1.1.0.js"
+    "./dist/rapier-math.js"
   ],
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "default": "./index.mjs"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
     },
     "./delimiters": {
-      "types": "./delimiters.d.ts",
-      "default": "./delimiters.mjs"
+      "types": "./dist/delimiters.d.ts",
+      "default": "./dist/delimiters.mjs"
     },
     "./markdown-it": {
-      "types": "./markdown-it.d.ts",
-      "default": "./markdown-it.mjs"
+      "types": "./dist/markdown-it.d.ts",
+      "default": "./dist/markdown-it.mjs"
     },
     "./rehype": {
-      "types": "./rehype.d.ts",
-      "default": "./rehype.mjs"
+      "types": "./dist/rehype.d.ts",
+      "default": "./dist/rehype.mjs"
     },
     "./stream": {
-      "types": "./stream.d.ts",
-      "default": "./stream.mjs"
+      "types": "./dist/stream.d.ts",
+      "default": "./dist/stream.mjs"
     },
-    "./rapier-math-1.1.0.js": {
-      "types": "./classic.d.ts",
-      "default": "./rapier-math-1.1.0.js"
+    "./classic": {
+      "types": "./dist/classic.d.ts",
+      "default": "./dist/rapier-math.js"
     },
     "./package.json": "./package.json"
   },
@@ -60,43 +60,13 @@
     }
   },
   "files": [
-    "index.mjs",
-    "rapier-math-1.1.0.js",
+    "dist",
+    "src",
+    "docs",
+    "examples",
+    "tests",
     "LICENSE",
-    "LICENSE-MIT",
-    "math-LICENSE.txt",
-    "math-font-LICENSE.txt",
-    "math-components.json",
-    "README.md",
-    "verify.mjs",
-    "check.mjs",
-    "adoption-check.mjs",
-    "src/math",
-    "src/tools/build-math.mjs",
-    "src/shell/math-resources.json",
-    "src/package.json",
-    "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"
+    "README.md"
   ],
   "license": "SEE LICENSE IN LICENSE",
   "author": "Jack Skipworth",
@@ -114,6 +84,12 @@
     "latex",
     "svg",
     "typesetting",
-    "latin-modern"
+    "latin-modern",
+    "markdown",
+    "markdown-it",
+    "rehype",
+    "unified",
+    "offline",
+    "math-rendering"
   ]
 }

package/src/math/api.js

@@ -100,7 +100,7 @@ function renderMath(source,options={}) {
 }
 
 globalThis.RapierMath=Object.freeze({
-  version:'1.1.0',
+  version:'1.1.1',
   parse:parseMathTex,
   render:renderMath,
   fit:mathFit,

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 {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 {assembleMath} = await import('../tools/build-math.mjs');
-  const {bytes} = await assembleMath({root});
-  const text = mathModule(bytes);
-  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

@@ -1,8 +1,45 @@
 // SPDX-License-Identifier: MIT
-import {readFileSync} from 'node:fs';
 export function mathReadme(resources) {
-  return readFileSync(new URL('./README.md', import.meta.url), 'utf8')
-    .replace('rapier-math-VERSION.js', resources.bundle) +
-    '\nBuild: ' + resources.version + '. Classic payload: ' + resources.bytes +
-    ' bytes; gzip (level 9): ' + resources.gzipBytes + ' bytes.\nSHA-384: `' + resources.sha384 + '`\n';
+  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,17 +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.1.0';
+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', 'math/adoption-verify.mjs', 'math/package-build.mjs', 'math/package-check.mjs', 'math/package-readme.mjs', 'math/README.md'];
+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: file}));
+  .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',
@@ -30,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;
@@ -44,15 +47,16 @@ export async function fillMathLicense(markup, {root = ROOT} = {}) {
   return markup.replace(marker, () => '<pre class="license-text">' + escaped + '</pre>');
 }
 
-export async function assembleMath({root = ROOT} = {}) {
+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;
@@ -60,27 +64,40 @@ export async function assembleMath({root = ROOT} = {}) {
   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 readFile(resolve(root, file));
+    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} = {}) {
-  const {resources, bytes} = await assembleMath({root});
+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});
@@ -107,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/{src/math/adoption-verify.mjs → tests/adoption.mjs}

@@ -7,7 +7,7 @@ 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';
+import {processor} from '../examples/unified.mjs';
 
 const md = new MarkdownIt({html: false}).use(rapierMath);
 const dollar = new MarkdownIt({html: false}).use(rapierMath, {singleDollar: true});

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

@@ -3,21 +3,21 @@
 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');
@@ -27,7 +27,7 @@ for (const name of ['./LICENSE', './index.mjs', './' + resources.bundle]) {
 // 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]))

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/adoption-check.mjs

@@ -1,149 +0,0 @@
-// 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/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.