From 20108545d8e23a830fff1ae34756e7e386be909c Mon Sep 17 00:00:00 2001
From: Rowan Cockett <rowanc1@gmail.com>
Date: Tue, 26 Mar 2024 11:34:51 -0600
Subject: [PATCH] =?UTF-8?q?=F0=9F=A7=AE=20Fix=20math-spacing=20in=20paragr?=
 =?UTF-8?q?aphs=20(#1032)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .changeset/chilled-tigers-fail.md             |   5 +
 .changeset/hip-zoos-thank.md                  |   5 +
 .changeset/honest-penguins-shave.md           |   5 +
 .changeset/modern-frogs-join.md               |   5 +
 .changeset/nasty-forks-look.md                |   5 +
 .changeset/popular-chairs-swim.md             |   5 +
 .changeset/rich-waves-taste.md                |   5 +
 .changeset/stale-wolves-lie.md                |   5 +
 .changeset/thirty-months-pretend.md           |   5 +
 packages/markdown-it-myst/src/directives.ts   |  16 ++
 .../markdown-it-myst/tests/directives.spec.ts |  15 ++
 packages/myst-common/src/types.ts             |   2 +-
 packages/myst-directives/src/math.ts          |  19 ++-
 packages/myst-parser/src/fromMarkdown.ts      |  23 ++-
 packages/myst-parser/src/myst.ts              |   2 +-
 packages/myst-parser/src/tokensToMyst.ts      |  34 +++-
 packages/myst-parser/src/types.ts             |   8 +-
 .../tests/directives/directives.spec.ts       |  12 +-
 .../myst-parser/tests/directives/math.yml     |  31 ++++
 packages/myst-parser/tests/math.spec.ts       |  42 +++++
 packages/myst-parser/tests/myst.spec.ts       |  36 ++--
 packages/myst-spec-ext/src/types.ts           |   1 +
 packages/myst-to-tex/src/math.ts              |  13 +-
 packages/myst-to-tex/tests/math.spec.ts       |  16 ++
 packages/myst-transforms/src/math.spec.ts     | 155 ++++++++++++++----
 packages/myst-transforms/src/math.ts          |  28 ++++
 packages/mystmd/tests/basic-tex-math/input.md |  19 +++
 packages/mystmd/tests/basic-tex-math/myst.yml |   8 +
 packages/mystmd/tests/exports.yml             |   6 +
 .../mystmd/tests/outputs/basic-tex-math.tex   |  19 +++
 30 files changed, 480 insertions(+), 70 deletions(-)
 create mode 100644 .changeset/chilled-tigers-fail.md
 create mode 100644 .changeset/hip-zoos-thank.md
 create mode 100644 .changeset/honest-penguins-shave.md
 create mode 100644 .changeset/modern-frogs-join.md
 create mode 100644 .changeset/nasty-forks-look.md
 create mode 100644 .changeset/popular-chairs-swim.md
 create mode 100644 .changeset/rich-waves-taste.md
 create mode 100644 .changeset/stale-wolves-lie.md
 create mode 100644 .changeset/thirty-months-pretend.md
 create mode 100644 packages/myst-parser/tests/math.spec.ts
 create mode 100644 packages/mystmd/tests/basic-tex-math/input.md
 create mode 100644 packages/mystmd/tests/basic-tex-math/myst.yml
 create mode 100644 packages/mystmd/tests/outputs/basic-tex-math.tex

diff --git a/.changeset/chilled-tigers-fail.md b/.changeset/chilled-tigers-fail.md
new file mode 100644
index 000000000..a8a6f8c35
--- /dev/null
+++ b/.changeset/chilled-tigers-fail.md
@@ -0,0 +1,5 @@
+---
+"myst-to-tex": patch
+---
+
+Respect math node tightness
diff --git a/.changeset/hip-zoos-thank.md b/.changeset/hip-zoos-thank.md
new file mode 100644
index 000000000..f7c21ed51
--- /dev/null
+++ b/.changeset/hip-zoos-thank.md
@@ -0,0 +1,5 @@
+---
+"myst-spec-ext": patch
+---
+
+Add tightness to math node extension
diff --git a/.changeset/honest-penguins-shave.md b/.changeset/honest-penguins-shave.md
new file mode 100644
index 000000000..8398efac0
--- /dev/null
+++ b/.changeset/honest-penguins-shave.md
@@ -0,0 +1,5 @@
+---
+"markdown-it-myst": patch
+---
+
+Add block tightness to the directives
diff --git a/.changeset/modern-frogs-join.md b/.changeset/modern-frogs-join.md
new file mode 100644
index 000000000..1326e324d
--- /dev/null
+++ b/.changeset/modern-frogs-join.md
@@ -0,0 +1,5 @@
+---
+"myst-directives": patch
+---
+
+Add math tightness to the directive
diff --git a/.changeset/nasty-forks-look.md b/.changeset/nasty-forks-look.md
new file mode 100644
index 000000000..0135088a5
--- /dev/null
+++ b/.changeset/nasty-forks-look.md
@@ -0,0 +1,5 @@
+---
+"myst-parser": patch
+---
+
+Pass src to the state handlers
diff --git a/.changeset/popular-chairs-swim.md b/.changeset/popular-chairs-swim.md
new file mode 100644
index 000000000..2c8501e5b
--- /dev/null
+++ b/.changeset/popular-chairs-swim.md
@@ -0,0 +1,5 @@
+---
+"mystmd": patch
+---
+
+Handle math tightness for latex
diff --git a/.changeset/rich-waves-taste.md b/.changeset/rich-waves-taste.md
new file mode 100644
index 000000000..8d7b33c45
--- /dev/null
+++ b/.changeset/rich-waves-taste.md
@@ -0,0 +1,5 @@
+---
+"myst-parser": patch
+---
+
+compute AMS math tightness based on source
diff --git a/.changeset/stale-wolves-lie.md b/.changeset/stale-wolves-lie.md
new file mode 100644
index 000000000..f4d21bfe2
--- /dev/null
+++ b/.changeset/stale-wolves-lie.md
@@ -0,0 +1,5 @@
+---
+"myst-transforms": patch
+---
+
+Keep math tightness when lifting from paragraphs
diff --git a/.changeset/thirty-months-pretend.md b/.changeset/thirty-months-pretend.md
new file mode 100644
index 000000000..a732d31d3
--- /dev/null
+++ b/.changeset/thirty-months-pretend.md
@@ -0,0 +1,5 @@
+---
+"myst-common": patch
+---
+
+Add block tightness to the directive data
diff --git a/packages/markdown-it-myst/src/directives.ts b/packages/markdown-it-myst/src/directives.ts
index 1b66cead2..cdc07435e 100644
--- a/packages/markdown-it-myst/src/directives.ts
+++ b/packages/markdown-it-myst/src/directives.ts
@@ -8,6 +8,20 @@ import { stateError, stateWarn } from './utils.js';
 
 const COLON_OPTION_REGEX = /^:(?<option>[^:\s]+?):(\s*(?<value>.*)){0,1}\s*$/;
 
+function computeBlockTightness(
+  src: string,
+  map: [number, number] | null | undefined,
+): boolean | 'before' | 'after' {
+  const lines = src.split('\n');
+  const tightBefore =
+    typeof map?.[0] === 'number' && map[0] > 0 ? lines[map[0] - 1].trim() !== '' : false;
+  const tightAfter =
+    typeof map?.[1] === 'number' && map[1] < lines.length ? lines[map[1]].trim() !== '' : false;
+  const tight =
+    tightBefore && tightAfter ? true : tightBefore ? 'before' : tightAfter ? 'after' : false;
+  return tight;
+}
+
 /** Convert fences identified as directives to `directive` tokens */
 function replaceFences(state: StateCore): boolean {
   for (const token of state.tokens) {
@@ -51,6 +65,8 @@ function runDirectives(state: StateCore): boolean {
         directiveOpen.meta = {
           arg,
           options: simplifyDirectiveOptions(options),
+          // Tightness is computed for all directives (are they separated by a newline before/after)
+          tight: computeBlockTightness(state.src, token.map),
         };
         const startLineNumber = map ? map[0] : 0;
         const argTokens = directiveArgToTokens(arg, startLineNumber, state);
diff --git a/packages/markdown-it-myst/tests/directives.spec.ts b/packages/markdown-it-myst/tests/directives.spec.ts
index 01b33d9cc..5994c4818 100644
--- a/packages/markdown-it-myst/tests/directives.spec.ts
+++ b/packages/markdown-it-myst/tests/directives.spec.ts
@@ -176,4 +176,19 @@ describe('parses directives', () => {
     expect(tokens.map((t) => t.type)).toEqual(['fence']);
     expect(tokens[0].info).toEqual(' { ab c }');
   });
+  it.each([
+    [false, 'Paragraph\n\n```{math}\nAx=b\n```\n\nAfter paragraph'],
+    [false, '```{math}\nAx=b\n```'],
+    [false, '```{math}\nAx=b\n```\n\nAfter paragraph'],
+    [true, 'Paragraph\n```{math}\nAx=b\n```\nAfter paragraph'],
+    ['before', 'Paragraph\n```{math}\nAx=b\n```\n\nAfter paragraph'],
+    ['before', 'Paragraph\n```{math}\nAx=b\n```'],
+    ['after', 'Paragraph\n\n```{math}\nAx=b\n```\nAfter paragraph'],
+    ['after', '```{math}\nAx=b\n```\nAfter paragraph'],
+  ])('directives have tightness information: "%s"', (tight, src) => {
+    const mdit = MarkdownIt().use(plugin);
+    const tokens = mdit.parse(src, {});
+    const open = tokens.find((t) => t.type === 'parsed_directive_open');
+    expect(open?.meta.tight).toBe(tight);
+  });
 });
diff --git a/packages/myst-common/src/types.ts b/packages/myst-common/src/types.ts
index 147571fb0..1ba8d50e5 100644
--- a/packages/myst-common/src/types.ts
+++ b/packages/myst-common/src/types.ts
@@ -72,7 +72,7 @@ export type OptionDefinition = ArgDefinition & {
 
 export type DirectiveData = {
   name: string;
-  node: Directive;
+  node: Directive & { tight?: boolean | 'before' | 'after' };
   arg?: ParseTypes;
   options?: Record<string, ParseTypes>;
   body?: ParseTypes;
diff --git a/packages/myst-directives/src/math.ts b/packages/myst-directives/src/math.ts
index 2c70e0a9a..243c01f82 100644
--- a/packages/myst-directives/src/math.ts
+++ b/packages/myst-directives/src/math.ts
@@ -15,13 +15,16 @@ export const mathDirective: DirectiveSpec = {
   },
   run(data: DirectiveData): GenericNode[] {
     const { label, identifier } = normalizeLabel(data.options?.label as string | undefined) || {};
-    return [
-      {
-        type: 'math',
-        identifier,
-        label,
-        value: data.body as string,
-      },
-    ];
+    const math = {
+      type: 'math',
+      identifier,
+      label,
+      value: data.body as string,
+    } as GenericNode;
+    if (data.node.tight) {
+      // The default `false` is not written to the AST
+      math.tight = data.node.tight;
+    }
+    return [math];
   },
 };
diff --git a/packages/myst-parser/src/fromMarkdown.ts b/packages/myst-parser/src/fromMarkdown.ts
index 46ac60c31..2c5ca8e7f 100644
--- a/packages/myst-parser/src/fromMarkdown.ts
+++ b/packages/myst-parser/src/fromMarkdown.ts
@@ -28,9 +28,11 @@ export function withoutTrailingNewline(str: string) {
  * Loosely based on prosemirror-markdown
  */
 export class MarkdownParseState {
+  src: string;
   stack: GenericNode[];
   handlers: Record<string, TokenHandler>;
-  constructor(handlers: Record<string, TokenHandlerSpec>) {
+  constructor(src: string, handlers: Record<string, TokenHandlerSpec>) {
+    this.src = src;
     this.stack = [u('root', [] as GenericParent[])];
     this.handlers = getTokenHandlers(handlers);
   }
@@ -77,8 +79,9 @@ export class MarkdownParseState {
     tokens?.forEach((token, index) => {
       if (token.hidden && !UNHIDDEN_TOKENS.has(token.type)) return;
       const handler = this.handlers[token.type];
-      if (!handler)
+      if (!handler) {
         throw new Error(`Token type ${token.type} not supported by tokensToMyst parser`);
+      }
       handler(this, token, tokens, index);
     });
   }
@@ -111,8 +114,14 @@ type TokenHandler = (
   index: number,
 ) => void;
 
-function getAttrs(spec: TokenHandlerSpec, token: Token, tokens: Token[], index: number) {
-  const attrs = spec.getAttrs?.(token, tokens, index) || spec.attrs || {};
+function getAttrs(
+  state: MarkdownParseState,
+  spec: TokenHandlerSpec,
+  token: Token,
+  tokens: Token[],
+  index: number,
+) {
+  const attrs = spec.getAttrs?.(token, tokens, index, state) || spec.attrs || {};
   if ('type' in attrs) throw new Error('You can not have "type" as attrs.');
   if ('children' in attrs) throw new Error('You can not have "children" as attrs.');
   return attrs;
@@ -134,17 +143,17 @@ function getTokenHandlers(specHandlers: Record<string, TokenHandlerSpec>) {
             withoutTrailingNewline(tok.content),
             tok,
             spec.type,
-            getAttrs(spec, tok, tokens, i),
+            getAttrs(state, spec, tok, tokens, i),
           );
           return;
         }
-        state.openNode(nodeType, tok, getAttrs(spec, tok, tokens, i), spec.isLeaf);
+        state.openNode(nodeType, tok, getAttrs(state, spec, tok, tokens, i), spec.isLeaf);
         state.addText(withoutTrailingNewline(tok.content), tok);
         state.closeNode();
       };
     } else {
       handlers[type + '_open'] = (state, tok, tokens, i) =>
-        state.openNode(nodeType, tok, getAttrs(spec, tok, tokens, i));
+        state.openNode(nodeType, tok, getAttrs(state, spec, tok, tokens, i));
       handlers[type + '_close'] = (state) => state.closeNode();
     }
   });
diff --git a/packages/myst-parser/src/myst.ts b/packages/myst-parser/src/myst.ts
index 9d1a56680..824710676 100644
--- a/packages/myst-parser/src/myst.ts
+++ b/packages/myst-parser/src/myst.ts
@@ -92,7 +92,7 @@ export function mystParse(content: string, opts?: Options) {
   const { vfile } = opts || {};
   const parsedOpts = parseOptions(opts);
   const tokenizer = createTokenizer(parsedOpts);
-  const tree = tokensToMyst(tokenizer.parse(content, { vfile }), parsedOpts.mdast);
+  const tree = tokensToMyst(content, tokenizer.parse(content, { vfile }), parsedOpts.mdast);
   applyDirectives(tree, parsedOpts.directives, parsedOpts.vfile);
   applyRoles(tree, parsedOpts.roles, parsedOpts.vfile);
   return tree;
diff --git a/packages/myst-parser/src/tokensToMyst.ts b/packages/myst-parser/src/tokensToMyst.ts
index 4b6f46e6d..d4f332611 100644
--- a/packages/myst-parser/src/tokensToMyst.ts
+++ b/packages/myst-parser/src/tokensToMyst.ts
@@ -9,6 +9,22 @@ import { u } from 'unist-builder';
 import { MarkdownParseState, withoutTrailingNewline } from './fromMarkdown.js';
 import type { MdastOptions, TokenHandlerSpec } from './types.js';
 
+export function computeAmsmathTightness(
+  src: string,
+  map: [number, number] | null | undefined,
+): boolean | 'before' | 'after' {
+  const lines = src.split('\n');
+  const tightBefore =
+    typeof map?.[0] === 'number' && map[0] > 0 ? lines[map[0] - 1].trim() !== '' : false;
+  // Note: The end line might be different/wrong for AMS math. If that is updated, remove the `+1` that shifts the index
+  const last = typeof map?.[1] === 'number' ? map?.[1] + 1 : undefined;
+  const tightAfter =
+    typeof last === 'number' && last < lines.length ? lines[last]?.trim() !== '' : false;
+  const tight =
+    tightBefore && tightAfter ? true : tightBefore ? 'before' : tightAfter ? 'after' : false;
+  return tight;
+}
+
 const NUMBERED_CLASS = /^numbered$/;
 const ALIGN_CLASS = /(?:(?:align-)|^)(left|right|center)/;
 
@@ -298,10 +314,13 @@ const defaultMdast: Record<string, TokenHandlerSpec> = {
     type: 'math',
     noCloseToken: true,
     isText: true,
-    getAttrs(t) {
-      return {
+    getAttrs(t, tokens, index, state) {
+      const tight = computeAmsmathTightness(state.src, t.map);
+      const attrs = {
         enumerated: t.meta?.enumerated,
-      };
+      } as Record<string, any>;
+      if (tight) attrs.tight = tight;
+      return attrs;
     },
   },
   footnote_ref: {
@@ -360,6 +379,7 @@ const defaultMdast: Record<string, TokenHandlerSpec> = {
         args: t.meta?.arg,
         options: t.meta?.options,
         value: t.content || undefined,
+        tight: t.meta?.tight || undefined,
       };
     },
   },
@@ -489,13 +509,17 @@ const defaultOptions: MdastOptions = {
   nestBlocks: true,
 };
 
-export function tokensToMyst(tokens: Token[], options = defaultOptions): GenericParent {
+export function tokensToMyst(
+  src: string,
+  tokens: Token[],
+  options = defaultOptions,
+): GenericParent {
   const opts = {
     ...defaultOptions,
     ...options,
     handlers: { ...defaultOptions.handlers, ...options?.handlers },
   };
-  const state = new MarkdownParseState(opts.handlers);
+  const state = new MarkdownParseState(src, opts.handlers);
   state.parseTokens(tokens);
   let tree: GenericParent;
   do {
diff --git a/packages/myst-parser/src/types.ts b/packages/myst-parser/src/types.ts
index dfe151e5a..fd2641942 100644
--- a/packages/myst-parser/src/types.ts
+++ b/packages/myst-parser/src/types.ts
@@ -3,6 +3,7 @@ import type Token from 'markdown-it/lib/token.js';
 import type { DirectiveSpec, RoleSpec } from 'myst-common';
 import type { VFile } from 'vfile';
 import type { MathExtensionOptions } from './plugins.js';
+import type { MarkdownParseState } from './fromMarkdown.js';
 
 export type MdastOptions = {
   handlers?: Record<string, TokenHandlerSpec>;
@@ -12,7 +13,12 @@ export type MdastOptions = {
 
 export type TokenHandlerSpec = {
   type: string;
-  getAttrs?: (token: Token, tokens: Token[], index: number) => Record<string, any>;
+  getAttrs?: (
+    token: Token,
+    tokens: Token[],
+    index: number,
+    state: MarkdownParseState,
+  ) => Record<string, any>;
   attrs?: Record<string, any>;
   noCloseToken?: boolean;
   isText?: boolean;
diff --git a/packages/myst-parser/tests/directives/directives.spec.ts b/packages/myst-parser/tests/directives/directives.spec.ts
index 35b3c0914..7f5180321 100644
--- a/packages/myst-parser/tests/directives/directives.spec.ts
+++ b/packages/myst-parser/tests/directives/directives.spec.ts
@@ -8,6 +8,7 @@ import { VFile } from 'vfile';
 
 type TestCase = {
   title: string;
+  skip?: boolean;
   markdown: string;
   mdast: Record<string, any>;
   warnings?: number;
@@ -26,9 +27,18 @@ const casesList: TestCases[] = fs
     return yaml.load(content) as TestCases;
   });
 
+const only = ''; // Can set this to a test title
+
 casesList.forEach(({ title, cases }) => {
+  const casesToUse = cases.filter((c) => (!only && !c.skip) || (only && c.title === only));
+  const skippedCases = cases.filter((c) => c.skip || (only && c.title !== only));
+  if (casesToUse.length === 0) return;
   describe(title, () => {
-    test.each(cases.map((c): [string, TestCase] => [c.title, c]))(
+    if (skippedCases.length > 0) {
+      // Log to test output for visibility
+      test.skip.each(skippedCases.map((c): [string, TestCase] => [c.title, c]))('%s', () => {});
+    }
+    test.each(casesToUse.map((c): [string, TestCase] => [c.title, c]))(
       '%s',
       (_, { markdown, mdast, warnings = 0 }) => {
         const vfile = new VFile();
diff --git a/packages/myst-parser/tests/directives/math.yml b/packages/myst-parser/tests/directives/math.yml
index 2d62dc70d..e897de983 100644
--- a/packages/myst-parser/tests/directives/math.yml
+++ b/packages/myst-parser/tests/directives/math.yml
@@ -13,10 +13,41 @@ cases:
           name: math
           options:
             label: addition
+          value: 1+2
+          children:
+            - type: math
+              identifier: addition
+              label: addition
+              value: 1+2
+  - title: tight math
+    markdown: |-
+      Tight above
+      ```{math}
+      :label: addition
+      1+2
+      ```
 
+      But not below
+    mdast:
+      type: root
+      children:
+        - type: paragraph
+          children:
+            - type: text
+              value: Tight above
+        - type: mystDirective
+          name: math
+          tight: before
+          options:
+            label: addition
           value: 1+2
           children:
             - type: math
               identifier: addition
               label: addition
+              tight: before
               value: 1+2
+        - type: paragraph
+          children:
+            - type: text
+              value: But not below
diff --git a/packages/myst-parser/tests/math.spec.ts b/packages/myst-parser/tests/math.spec.ts
new file mode 100644
index 000000000..ea4c60079
--- /dev/null
+++ b/packages/myst-parser/tests/math.spec.ts
@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { VFile } from 'vfile';
+import { mystParse } from '../src';
+import { mathNestingTransform } from 'myst-transforms';
+import { select } from 'unist-util-select';
+import type { Math } from 'myst-spec-ext';
+
+describe('Test math tightness', () => {
+  test.each([
+    [true, 'p\n$$Ax=b$$\np'],
+    [undefined, 'p\n\n$$Ax=b$$\n\np'],
+    ['before', 'p\n$$Ax=b$$\n\np'],
+    // ['after', 'p\n\n$$Ax=b$$\np'], // TODO: this is (maybe) a bug in the dollar-math parser
+    [undefined, 'p\n\n$$Ax=b$$'],
+  ])('double-math %s', (tight, src) => {
+    const file = new VFile();
+    const tree = mystParse(src);
+    expect((select('math', tree) as Math).tight).toBe(undefined);
+    mathNestingTransform(tree, file);
+    expect((select('math', tree) as Math).tight).toBe(tight);
+  });
+  test.each([
+    [true, 'p\n:::{math}\nAx=b\n:::\np'],
+    [undefined, 'p\n\n:::{math}\nAx=b\n:::\n\np'],
+    ['before', 'p\n:::{math}\nAx=b\n:::\n\np'],
+    ['after', 'p\n\n:::{math}\nAx=b\n:::\np'],
+    [undefined, 'p\n\n:::{math}\nAx=b\n:::'],
+  ])('math directive %s', (tight, src) => {
+    const tree = mystParse(src);
+    expect((select('math', tree) as Math)?.tight).toBe(tight);
+  });
+  test.each([
+    // [true, 'a\n\\begin{equation}\nAx=b\n\\end{equation}\nb'],
+    [undefined, 'a\n\n\\begin{equation}\nAx=b\n\\end{equation}\n\nb'],
+    ['before', 'p\n\\begin{equation}\nAx=b\n\\end{equation}\n\np'],
+    ['after', 'p\n\n\\begin{equation}\nAx=b\n\\end{equation}\np'],
+    [undefined, 'p\n\n\\begin{equation}\nAx=b\n\\end{equation}'],
+  ])('amsmath %s', (tight, src) => {
+    const tree = mystParse(src);
+    expect((select('math', tree) as Math)?.tight).toBe(tight);
+  });
+});
diff --git a/packages/myst-parser/tests/myst.spec.ts b/packages/myst-parser/tests/myst.spec.ts
index 3a01dd92e..b23069ac0 100644
--- a/packages/myst-parser/tests/myst.spec.ts
+++ b/packages/myst-parser/tests/myst.spec.ts
@@ -85,6 +85,14 @@ function stripPositions(tree: GenericParent) {
   return tree;
 }
 
+function removeTightAnnotations(tree: GenericParent) {
+  selectAll('mystDirective', tree).forEach((node) => {
+    // These are added on afterwards and we aren't taking them into account in myst spec
+    delete (node as any).tight;
+  });
+  return tree;
+}
+
 function replaceMystCommentNodes(tree: GenericParent) {
   selectAll('comment', tree).forEach((node) => {
     // In a future version of the spec, hopefully this is removed
@@ -107,19 +115,21 @@ describe('Testing myst --> mdast conversions', () => {
   test.each(mystCases)('%s', (_, { myst, mdast }) => {
     if (myst) {
       const mdastString = yaml.dump(mdast);
-      const newAst = replaceMystCommentNodes(
-        stripPositions(
-          mystParse(myst, {
-            mdast: {
-              hoistSingleImagesOutofParagraphs: false,
-              nestBlocks: false,
-            },
-            extensions: {
-              frontmatter: false, // Frontmatter screws with some tests!
-              citations: false,
-              smartquotes: false,
-            },
-          }),
+      const newAst = removeTightAnnotations(
+        replaceMystCommentNodes(
+          stripPositions(
+            mystParse(myst, {
+              mdast: {
+                hoistSingleImagesOutofParagraphs: false,
+                nestBlocks: false,
+              },
+              extensions: {
+                frontmatter: false, // Frontmatter screws with some tests!
+                citations: false,
+                smartquotes: false,
+              },
+            }),
+          ),
         ),
       );
       // Figure caption/legend creation described in myst-spec has been moved
diff --git a/packages/myst-spec-ext/src/types.ts b/packages/myst-spec-ext/src/types.ts
index 643e8f0f3..f6b9d9043 100644
--- a/packages/myst-spec-ext/src/types.ts
+++ b/packages/myst-spec-ext/src/types.ts
@@ -57,6 +57,7 @@ export type InlineMath = SpecInlineMath & {
 
 export type Math = SpecMath & {
   kind?: 'subequation';
+  tight?: 'before' | 'after' | boolean;
 };
 
 export type MathGroup = {
diff --git a/packages/myst-to-tex/src/math.ts b/packages/myst-to-tex/src/math.ts
index 04e02ddac..8756040a1 100644
--- a/packages/myst-to-tex/src/math.ts
+++ b/packages/myst-to-tex/src/math.ts
@@ -70,6 +70,12 @@ export function withRecursiveCommands(
 
 const math: Handler = (node, state) => {
   const { label, enumerated } = node;
+  const tightBefore = node.tight === true || node.tight === 'before';
+  const tightAfter = node.tight === true || node.tight === 'after';
+  if (tightBefore) {
+    // Removes the preceding space
+    state.ensureNewLine(true);
+  }
   state.usePackages('amsmath');
   addMacrosToState(node.value, state);
   if (state.data.isInTable) {
@@ -96,7 +102,12 @@ const math: Handler = (node, state) => {
       state.write(`\\end{equation${enumerated === false ? '*' : ''}}`);
     }
   }
-  if (!state.data.isInTable) state.closeBlock(node);
+  if (state.data.isInTable) return;
+  if (tightAfter) {
+    state.ensureNewLine(true);
+  } else {
+    state.closeBlock(node);
+  }
 };
 
 const inlineMath: Handler = (node, state) => {
diff --git a/packages/myst-to-tex/tests/math.spec.ts b/packages/myst-to-tex/tests/math.spec.ts
index 2643ba0d4..6e001a1c3 100644
--- a/packages/myst-to-tex/tests/math.spec.ts
+++ b/packages/myst-to-tex/tests/math.spec.ts
@@ -21,4 +21,20 @@ describe('myst-to-tex math', () => {
     expect((file.result as LatexResult).value).toEqual('$\\aRecursion$');
     expect((file.result as LatexResult).commands).toEqual(plugins);
   });
+  it.each([
+    [false, 'start\n\n\\begin{equation}\nAx=b\n\\end{equation}\n\nend'],
+    ['before', 'start\n\\begin{equation}\nAx=b\n\\end{equation}\n\nend'],
+    ['after', 'start\n\n\\begin{equation}\nAx=b\n\\end{equation}\nend'],
+    [true, 'start\n\\begin{equation}\nAx=b\n\\end{equation}\nend'],
+  ])('works with tight math %s', (tight, tex) => {
+    const tree = u('root', [
+      u('paragraph', [u('text', 'start')]),
+      u('math', { value: 'Ax=b', tight }),
+      u('paragraph', [u('text', 'end')]),
+    ]);
+    const pipe = unified().use(mystToTex);
+    pipe.runSync(tree as any);
+    const file = pipe.stringify(tree as any);
+    expect((file.result as LatexResult).value).toEqual(tex);
+  });
 });
diff --git a/packages/myst-transforms/src/math.spec.ts b/packages/myst-transforms/src/math.spec.ts
index ed80b8f6b..f58943d93 100644
--- a/packages/myst-transforms/src/math.spec.ts
+++ b/packages/myst-transforms/src/math.spec.ts
@@ -3,6 +3,8 @@ import { unified } from 'unified';
 import { VFile } from 'vfile';
 import { mathTransform, mathPlugin, mathNestingTransform } from './math';
 import { codeBlockToDirectiveTransform } from './code';
+import { select } from 'unist-util-select';
+import type { Math } from 'myst-spec-ext';
 
 const ARRAY_ALIGN = `\\begin{align*}
   L=
@@ -22,12 +24,12 @@ const ARRAY_ALIGN = `\\begin{align*}
 
 const EQNARRAY = `\\mathbb{E}(\\hat{U}_{ij}) &=& (1-4 \\alpha) \\mathbb{E}(F_{ij}) + \\alpha( \\mathbb{E}(F_{i-1j}) + \\mathbb{E}(F_{i+1j}) + \\mathbb{E}(F_{ij-1}) + \\mathbb{E}(F_{ij+1})) \\\\ &=& (1-4 \\alpha) \\hat F_{ij} + \\alpha( \\hat F_{i-1j} + \\hat F_{i+1j} + \\hat F_{ij-1} + \\hat F_{ij+1}),`;
 
-describe('Test math trasformations', () => {
+describe('Test math transformations', () => {
   test('Array alignment', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: ARRAY_ALIGN } as any;
-    const mdast = { children: [mathNode] } as any;
-    mathTransform(mdast, file);
+    const tree = { children: [mathNode] } as any;
+    mathTransform(tree, file);
     expect(mathNode.error).toBeUndefined();
     expect(mathNode.html).toBeTruthy();
   });
@@ -38,16 +40,16 @@ describe('Test math trasformations', () => {
       // Replace the expression with something that isn't caught
       value: ARRAY_ALIGN.replace('{array}{*{16}c}', '{array}{*c}'),
     } as any;
-    const mdast = { children: [mathNode] } as any;
-    mathTransform(mdast, file);
+    const tree = { children: [mathNode] } as any;
+    mathTransform(tree, file);
     expect(mathNode.error).toBe(true);
     expect(mathNode.message.includes('Unknown column alignment')).toBe(true);
   });
   test('\\begin{eqnarray}', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: EQNARRAY } as any;
-    const mdast = { children: [mathNode] } as any;
-    mathTransform(mdast, file);
+    const tree = { children: [mathNode] } as any;
+    mathTransform(tree, file);
     expect(file.messages[0].message.includes('\\begin{align*}')).toBe(true);
     expect(file.messages[0].note?.includes("Expected 'EOF'")).toBe(true);
     expect(mathNode.error).toBeUndefined();
@@ -56,8 +58,8 @@ describe('Test math trasformations', () => {
   test('Test raises warning', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: '\\x' } as any;
-    const mdast = { children: [mathNode] } as any;
-    mathTransform(mdast, file);
+    const tree = { children: [mathNode] } as any;
+    mathTransform(tree, file);
     expect(file.messages.length).toBe(1);
     expect(file.messages[0].message.includes('Undefined control sequence: \\x')).toBe(true);
     expect(file.messages[0].fatal).toBe(true);
@@ -65,8 +67,8 @@ describe('Test math trasformations', () => {
   test('Test no warning on macro replacement', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: '\\bf{y}' } as any;
-    const mdast = { children: [mathNode] } as any;
-    mathTransform(mdast, file, { macros: { '\\bf': '{\\mathbf #1}' } });
+    const tree = { children: [mathNode] } as any;
+    mathTransform(tree, file, { macros: { '\\bf': '{\\mathbf #1}' } });
     expect(file.messages.length).toBe(0);
   });
 });
@@ -75,17 +77,17 @@ describe('Test math transform as a plugin', () => {
   test('Test basic pipeline', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: '\\bf{y}' } as any;
-    const mdast = { type: 'root', children: [mathNode] } as any;
+    const tree = { type: 'root', children: [mathNode] } as any;
     unified()
       .use(mathPlugin, { macros: { '\\bf': '{\\mathbf #1}' } })
-      .runSync(mdast, file);
+      .runSync(tree, file);
     expect(file.messages.length).toBe(0);
   });
   test('Test basic pipeline with error', () => {
     const file = new VFile();
     const mathNode = { type: 'math', value: '\\x' } as any;
-    const mdast = { type: 'root', children: [mathNode] } as any;
-    unified().use(mathPlugin).runSync(mdast, file);
+    const tree = { type: 'root', children: [mathNode] } as any;
+    unified().use(mathPlugin).runSync(tree, file);
     expect(file.messages.length).toBe(1);
     expect(file.messages[0].message.includes('Undefined control sequence: \\x')).toBe(true);
     expect(file.messages[0].fatal).toBe(true);
@@ -99,10 +101,10 @@ describe('Test math nesting transformation', () => {
       type: 'paragraph',
       children: [{ type: 'math', value: '' }],
     } as any;
-    const mdast = { children: [paragraph] } as any;
-    expect(mdast.children[0].type).toBe('paragraph');
-    mathNestingTransform(mdast, file);
-    expect(mdast.children[0].type).toBe('math');
+    const tree = { children: [paragraph] } as any;
+    expect(tree.children[0].type).toBe('paragraph');
+    mathNestingTransform(tree, file);
+    expect(tree.children[0].type).toBe('math');
   });
   test('Unnest math in paragraph with other content', () => {
     const file = new VFile();
@@ -115,24 +117,113 @@ describe('Test math nesting transformation', () => {
         { type: 'text', value: 'math!' },
       ],
     } as any;
-    const mdast = { type: 'root', children: [{ type: 'block', children: [paragraph] }] } as any;
-    expect(mdast.children[0].children[0].type).toBe('paragraph');
-    mathNestingTransform(mdast, file);
-    expect(mdast.children[0].children[0].type).toBe('paragraph');
-    expect(mdast.children[0].children[0].class).toBe('importantClass');
-    expect(mdast.children[0].children[1].type).toBe('math');
-    expect(mdast.children[0].children[2].type).toBe('paragraph');
-    expect(mdast.children[0].children[2].class).toBe('importantClass');
+    const tree = { type: 'root', children: [{ type: 'block', children: [paragraph] }] } as any;
+    expect(tree.children[0].children[0].type).toBe('paragraph');
+    mathNestingTransform(tree, file);
+    expect(tree.children[0].children[0].type).toBe('paragraph');
+    expect(tree.children[0].children[0].class).toBe('importantClass');
+    expect(tree.children[0].children[1].type).toBe('math');
+    expect(tree.children[0].children[2].type).toBe('paragraph');
+    expect(tree.children[0].children[2].class).toBe('importantClass');
   });
 });
 
 describe('Test math code block transformation', () => {
   test('Block paragraph', () => {
     const file = new VFile();
-    const mdast = { children: [{ type: 'code', lang: 'math', value: 'Ax = b' }] } as any;
-    codeBlockToDirectiveTransform(mdast, file, { translate: ['math'] });
-    expect(mdast.children[0].type).toBe('math');
-    expect(mdast.children[0].lang).toBeUndefined();
-    expect(mdast.children[0].value).toBe('Ax = b');
+    const tree = { children: [{ type: 'code', lang: 'math', value: 'Ax = b' }] } as any;
+    codeBlockToDirectiveTransform(tree, file, { translate: ['math'] });
+    expect(tree.children[0].type).toBe('math');
+    expect(tree.children[0].lang).toBeUndefined();
+    expect(tree.children[0].value).toBe('Ax = b');
+  });
+});
+
+describe('Test math tightness', () => {
+  test.each([
+    [
+      true,
+      [
+        {
+          type: 'paragraph',
+          children: [
+            { type: 'text', value: 'a\n' }, // Newlines are added in the dollar-math parser
+            { type: 'math', value: '' },
+            { type: 'text', value: '\nb' }, // Newlines are added in the dollar-math parser
+          ],
+        },
+      ],
+    ],
+    [
+      'before',
+      [
+        {
+          type: 'paragraph',
+          children: [
+            { type: 'text', value: 'a\n' }, // Newlines are added in the dollar-math parser
+            { type: 'math', value: '' },
+          ],
+        },
+        {
+          type: 'paragraph',
+          children: [{ type: 'text', value: 'b' }],
+        },
+      ],
+    ],
+    [
+      'after',
+      [
+        {
+          type: 'paragraph',
+          children: [{ type: 'text', value: 'a' }],
+        },
+        {
+          type: 'paragraph',
+          children: [
+            { type: 'math', value: '' },
+            { type: 'text', value: '\nb' }, // Newlines are added in the dollar-math parser
+          ],
+        },
+      ],
+    ],
+    [
+      undefined,
+      [
+        {
+          type: 'paragraph',
+          children: [{ type: 'text', value: 'a' }],
+        },
+        {
+          type: 'math',
+          value: '',
+        },
+        {
+          type: 'paragraph',
+          children: [{ type: 'text', value: 'b' }],
+        },
+      ],
+    ],
+  ])('math tightness %s', (tight, children) => {
+    const file = new VFile();
+    const tree = { type: 'root', children } as any;
+    expect((select('math', tree) as Math)?.tight).toBe(undefined);
+    mathNestingTransform(tree, file);
+    expect((select('math', tree) as Math)?.tight).toBe(tight);
+    // Also ensure that the \n are deleted
+    delete (select('math', tree) as Math).tight;
+    expect(tree.children).toEqual([
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'a' }],
+      },
+      {
+        type: 'math',
+        value: '',
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'b' }],
+      },
+    ]);
   });
 });
diff --git a/packages/myst-transforms/src/math.ts b/packages/myst-transforms/src/math.ts
index fca831b15..b7c512d4f 100644
--- a/packages/myst-transforms/src/math.ts
+++ b/packages/myst-transforms/src/math.ts
@@ -241,6 +241,33 @@ export function mathNestingTransform(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   file: VFile,
 ) {
+  // Dollar math can be nested inside of a paragraph
+  // This finds those and marks them as `tight` in some way, depending on where they are in the paragraph
+  // Directives and AMSMath will never follow this path
+  const paragraphs = selectAll('paragraph', tree) as GenericParent[];
+  paragraphs.forEach((paragraph) => {
+    if (paragraph.children.length === 1) return; // no need to traverse, the math node can never be tight!
+    paragraph.children.forEach((child, index) => {
+      if (child.type !== 'math') return;
+      const math = child as Math;
+      const before = paragraph.children[index - 1];
+      const after = paragraph.children[index + 1];
+      if (index === 0) {
+        math.tight = 'after';
+      } else if (index === paragraph.children.length - 1) {
+        math.tight = 'before';
+      } else {
+        math.tight = true;
+      }
+      // Note: There is likely a bug in the dollar-math parser that we are correcting here
+      if (before?.type === 'text') {
+        before.value = before.value?.replace(/\n$/, '') ?? '';
+      }
+      if (after?.type === 'text') {
+        after.value = after.value?.replace(/^\n/, '') ?? '';
+      }
+    });
+  });
   unnestTransform(tree as GenericParent, 'paragraph', 'math');
 }
 
@@ -253,6 +280,7 @@ export function mathLabelTransform(tree: GenericParent, file: VFile) {
   });
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function subequationTransform(tree: GenericParent, file: VFile) {
   const nodes = selectAll('mathGroup > math', tree) as Math[];
   nodes.forEach((node) => {
diff --git a/packages/mystmd/tests/basic-tex-math/input.md b/packages/mystmd/tests/basic-tex-math/input.md
new file mode 100644
index 000000000..db290ab00
--- /dev/null
+++ b/packages/mystmd/tests/basic-tex-math/input.md
@@ -0,0 +1,19 @@
+# Lorem Ipsum
+
+Paragraph
+$$Ax=b$$
+Paragraph
+
+Paragraph
+\begin{equation}
+Ax=b
+\end{equation}
+Paragraph
+
+\begin{equation}
+Ax=b
+\end{equation}
+Paragraph
+\begin{equation}
+Ax=b
+\end{equation}
diff --git a/packages/mystmd/tests/basic-tex-math/myst.yml b/packages/mystmd/tests/basic-tex-math/myst.yml
new file mode 100644
index 000000000..739f7f295
--- /dev/null
+++ b/packages/mystmd/tests/basic-tex-math/myst.yml
@@ -0,0 +1,8 @@
+version: 1
+project:
+  export:
+    format: tex
+    template: null
+    output: _build/out.tex
+    article: input.md
+site: {}
diff --git a/packages/mystmd/tests/exports.yml b/packages/mystmd/tests/exports.yml
index 6d8c6f615..dd531cdcb 100644
--- a/packages/mystmd/tests/exports.yml
+++ b/packages/mystmd/tests/exports.yml
@@ -17,6 +17,12 @@ cases:
     outputs:
       - path: basic-tex/_build/out.tex
         content: outputs/basic-tex.tex
+  - title: Basic tex math build
+    cwd: basic-tex-math
+    command: myst build --tex
+    outputs:
+      - path: basic-tex-math/_build/out.tex
+        content: outputs/basic-tex-math.tex
   - title: Basic typst build
     cwd: basic-typst
     command: myst build --typst
diff --git a/packages/mystmd/tests/outputs/basic-tex-math.tex b/packages/mystmd/tests/outputs/basic-tex-math.tex
new file mode 100644
index 000000000..08cd56e8b
--- /dev/null
+++ b/packages/mystmd/tests/outputs/basic-tex-math.tex
@@ -0,0 +1,19 @@
+Paragraph
+\begin{equation}
+Ax=b
+\end{equation}
+Paragraph
+
+Paragraph
+\begin{equation}
+Ax=b
+\end{equation}
+Paragraph
+
+\begin{equation}
+Ax=b
+\end{equation}
+Paragraph
+\begin{equation}
+Ax=b
+\end{equation}
\ No newline at end of file