diff --git a/__tests__/lib/stripComments.test.ts b/__tests__/lib/stripComments.test.ts
index 6794ab628..e1d4753a9 100644
--- a/__tests__/lib/stripComments.test.ts
+++ b/__tests__/lib/stripComments.test.ts
@@ -356,6 +356,89 @@ end"`);
     expect(output).toContain('A name field');
   });
 
+  it('does not break an HTML block when an inner comment occupies a whole line', async () => {
+    const input = `<table>
+  <tbody>
+    <tr><td>Row 1</td></tr>
+    <!-- <tr><td>Row 2</td></tr> -->
+    <tr><td>Row 3</td></tr>
+  </tbody>
+</table>`;
+
+    const expected = `<table>
+  <tbody>
+    <tr><td>Row 1</td></tr>
+    <tr><td>Row 3</td></tr>
+  </tbody>
+</table>`;
+
+    const output = await stripComments(input, { mdxish: true });
+    expect(output).toBe(expected);
+  });
+
+  it('removes only the comment line and preserves authorial blank lines around it', async () => {
+    const input = `<table>
+    <tbody>
+        <tr><td>row 1</td></tr>
+        <!-- <tr><td>commented out</td></tr> -->
+
+        <tr><td>row 2</td></tr>
+
+
+        <!-- <tr><td>another commented out</td></tr> -->
+        <tr><td>row 3</td></tr>
+    </tbody>
+</table>`;
+
+    const expected = `<table>
+    <tbody>
+        <tr><td>row 1</td></tr>
+
+        <tr><td>row 2</td></tr>
+
+
+        <tr><td>row 3</td></tr>
+    </tbody>
+</table>`;
+
+    const output = await stripComments(input, { mdxish: true });
+    expect(output).toBe(expected);
+  });
+
+  it('preserves authorial blank lines inside a table cell', async () => {
+    const input = `<table>
+    <tr>
+        <td>
+            line 1
+
+            line 2
+        </td>
+    </tr>
+</table>`;
+
+    const output = await stripComments(input, { mdxish: true });
+    expect(output).toBe(input);
+  });
+
+  it('preserves a fenced code block (with internal blank lines) inside a table cell', async () => {
+    const input = `<table>
+    <tr>
+        <td>
+
+\`\`\`js
+const a = 1;
+
+const b = 2;
+\`\`\`
+
+        </td>
+    </tr>
+</table>`;
+
+    const output = await stripComments(input, { mdxish: true });
+    expect(output).toBe(input);
+  });
+
   it('strips comments inside jsx tables in mdxish mode', async () => {
     const input = `<!-- top comment -->
 
diff --git a/__tests__/parsers/tables.test.ts b/__tests__/parsers/tables.test.ts
index bab7a7f28..02f81fb5f 100644
--- a/__tests__/parsers/tables.test.ts
+++ b/__tests__/parsers/tables.test.ts
@@ -6,6 +6,7 @@ import { removePosition } from 'unist-util-remove-position';
 
 import { mdast } from '../../lib';
 import { mdxish } from '../../lib/mdxish';
+import { collapseBlankLines } from '../../processor/transform/mdxish/tables/mdxish-tables';
 import { collectNodes, findAllElementsByTagName, parseMdxishWithSource } from '../helpers';
 
 describe('table parser', () => {
@@ -1170,4 +1171,79 @@ None of the following content will get rendered!`;
       expect(html).toContain('<code>another_name_here</code>');
     });
   });
+
+  describe('lowercase <table> fallback path', () => {
+    it('keeps a block-with-whitespace-only-line intact when the mdx-aware parser throws on a cell expression', () => {
+      const doc = ['<table>', '    <tr>', '        <td>{not valid jsx}</td>', '    ', '    </tr>', '</table>'].join('\n');
+
+      const hast = mdxish(doc);
+      const html = toHtml(hast);
+
+      expect(html).not.toContain('<pre>');
+      expect(html).toContain('{not valid jsx}');
+    });
+
+    it('keeps a block-with-empty-line intact when the mdx-aware parser throws on a cell expression', () => {
+      const doc = ['<table>', '    <tr>', '        <td>{not valid jsx}</td>', '', '    </tr>', '</table>'].join('\n');
+
+      const hast = mdxish(doc);
+      const html = toHtml(hast);
+
+      expect(html).not.toContain('<pre>');
+      expect(html).toContain('{not valid jsx}');
+    });
+
+    it('keeps a block-with-many-blank-lines intact', () => {
+      const doc = [
+        '<table>',
+        '    <tr>',
+        '        <td>{not valid jsx}</td>',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '    </tr>',
+        '</table>',
+      ].join('\n');
+
+      const hast = mdxish(doc);
+      const html = toHtml(hast);
+
+      expect(html).not.toContain('<pre>');
+      expect(html).toContain('{not valid jsx}');
+    });
+
+    it('collapseBlankLines: removes every blank line, leaves every other line byte-identical', () => {
+      const input = [
+        '<table>',
+        '    <tr>',
+        '        <td>row 1</td>',
+        '    ',
+        '        <td>row 2</td>',
+        '',
+        '        <td>row 3</td>',
+        '    </tr>',
+        '</table>',
+      ].join('\n');
+
+      const output = collapseBlankLines(input);
+      const inputLines = input.split('\n');
+      const nonBlankInputLines = inputLines.filter(line => !/^[ \t]*$/.test(line));
+
+      expect(output.split('\n')).toStrictEqual(nonBlankInputLines);
+    });
+
+    it('collapseBlankLines: collapses any run of consecutive blank lines to a single newline', () => {
+      expect(collapseBlankLines('a\n\n\nb')).toBe('a\nb');
+      expect(collapseBlankLines('a\n\n\n\n\n\n\nb')).toBe('a\nb');
+      expect(collapseBlankLines('a\n   \n   \nb')).toBe('a\nb');
+    });
+
+    it('collapseBlankLines: does not strip trailing whitespace on non-empty lines', () => {
+      const input = 'a   \nb';
+      expect(collapseBlankLines(input)).toBe(input);
+    });
+  });
 });
diff --git a/example/Doc.tsx b/example/Doc.tsx
index 7bcd9bffe..149afae40 100644
--- a/example/Doc.tsx
+++ b/example/Doc.tsx
@@ -53,6 +53,20 @@ const variables = {
   ],
 };
 
+interface StripState {
+  error: string | null;
+  stripped: string | null;
+}
+
+type PipelineKey = 'legacy' | 'mdxish' | 'rmdx';
+
+const EMPTY_STRIP_STATE: StripState = { error: null, stripped: null };
+const EMPTY_STRIP_STATE_MAP: Record<PipelineKey, StripState> = {
+  legacy: EMPTY_STRIP_STATE,
+  mdxish: EMPTY_STRIP_STATE,
+  rmdx: EMPTY_STRIP_STATE,
+};
+
 const Doc = () => {
   const { fixture } = useParams();
   const [searchParams] = useSearchParams();
@@ -61,7 +75,6 @@ const Doc = () => {
   const mdxish = searchParams.has('mdxish');
   const showRmdx = searchParams.has('rmdx');
 
-  type PipelineKey = 'legacy' | 'mdxish' | 'rmdx';
   const selectedPipelines: PipelineKey[] = [];
   if (showRmdx) selectedPipelines.push('rmdx');
   if (legacy) selectedPipelines.push('legacy');
@@ -88,8 +101,8 @@ const Doc = () => {
   const [rmdxHast, setRmdxHast] = useState<object | null>(null);
   const [mdxishMdast, setMdxishMdast] = useState<object | null>(null);
   const [mdxishHast, setMdxishHast] = useState<object | null>(null);
-  const [strippedMarkdown, setStrippedMarkdown] = useState<string | null>(null);
-  const [stripError, setStripError] = useState<string | null>(null);
+  const [stripByPipeline, setStripByPipeline] = useState<Record<PipelineKey, StripState>>(EMPTY_STRIP_STATE_MAP);
+  const hasAnyStripped = Object.values(stripByPipeline).some(s => s.stripped !== null);
   const [view, setView] = useState<'hast' | 'markdown' | 'mdast' | 'rendered'>('rendered');
   const showToc = fixture === 'tableOfContentsTests';
 
@@ -101,8 +114,7 @@ const Doc = () => {
   useEffect(() => {
     const sanitize = async (mode: PipelineKey) => {
       if (!stripComments) {
-        setStrippedMarkdown(null);
-        setStripError(null);
+        setStripByPipeline(prev => ({ ...prev, [mode]: EMPTY_STRIP_STATE }));
         return doc;
       }
       try {
@@ -110,15 +122,13 @@ const Doc = () => {
           mdx: mode === 'rmdx',
           mdxish: mode === 'mdxish',
         });
-        setStrippedMarkdown(sanitized);
-        setStripError(null);
+        setStripByPipeline(prev => ({ ...prev, [mode]: { stripped: sanitized, error: null } }));
         return sanitized;
       } catch (e) {
         // eslint-disable-next-line no-console
         console.error(e);
         const message = e instanceof Error ? e.message : String(e);
-        setStripError(message);
-        setStrippedMarkdown(null);
+        setStripByPipeline(prev => ({ ...prev, [mode]: { stripped: null, error: message } }));
         return null;
       }
     };
@@ -261,7 +271,7 @@ const Doc = () => {
     <div className="rdmd-demo--display">
       <section id="hub-content">
         {!ci && <h2 className="rdmd-demo--markdown-header">{name}</h2>}
-        {(strippedMarkdown !== null || showAst) && (
+        {(hasAnyStripped || showAst) && (
           <div className="rdmd-demo--view-toggle">
             <button
               className={view === 'rendered' ? 'active' : ''}
@@ -270,7 +280,7 @@ const Doc = () => {
             >
               Rendered
             </button>
-            {strippedMarkdown !== null && (
+            {hasAnyStripped && (
               <button
                 className={view === 'markdown' ? 'active' : ''}
                 onClick={() => setView('markdown')}
@@ -299,13 +309,27 @@ const Doc = () => {
             )}
           </div>
         )}
-        {stripError && (
-          <div className="rdmd-demo--strip-error">
-            <strong>stripComments error:</strong> {stripError}
+        {view === 'markdown' && hasAnyStripped ? (
+          <div className="rdmd-demo--panels">
+            {activePipelines.map(p => {
+              const { error, stripped } = stripByPipeline[p];
+              return (
+                <div key={p} className="rdmd-demo--panel">
+                  <div className="rdmd-demo--panel-label">{pipelineLabels[p]}</div>
+                  {error && (
+                    <div className="rdmd-demo--strip-error">
+                      <strong>stripComments error:</strong> {error}
+                    </div>
+                  )}
+                  {stripped !== null ? (
+                    <pre className="rdmd-demo--stripped-output">{stripped}</pre>
+                  ) : (
+                    !error && <div className="rdmd-demo--empty">No stripped output for this pipeline</div>
+                  )}
+                </div>
+              );
+            })}
           </div>
-        )}
-        {view === 'markdown' && strippedMarkdown !== null ? (
-          <pre className="rdmd-demo--stripped-output">{strippedMarkdown}</pre>
         ) : (view === 'mdast' || view === 'hast') && showAst ? (
           <div className="rdmd-demo--panels">
             {activePipelines.map(p => {
diff --git a/package.json b/package.json
index fa071476e..0b6fd595d 100644
--- a/package.json
+++ b/package.json
@@ -177,7 +177,7 @@
       },
       {
         "path": "dist/main.node.js",
-        "maxSize": "947KB"
+        "maxSize": "950KB"
       }
     ]
   },
diff --git a/processor/transform/mdxish/tables/mdxish-tables.ts b/processor/transform/mdxish/tables/mdxish-tables.ts
index 46e217ff7..45590179f 100644
--- a/processor/transform/mdxish/tables/mdxish-tables.ts
+++ b/processor/transform/mdxish/tables/mdxish-tables.ts
@@ -61,6 +61,15 @@ const buildTableNodeProcessor = (withMdx: boolean) =>
 const tableNodeProcessor = buildTableNodeProcessor(true);
 const fallbackTableNodeProcessor = buildTableNodeProcessor(false);
 
+const BLANK_LINE_REGEX = /(\r?\n)(?:[ \t]*\r?\n)+/g;
+
+/**
+ * Collapses any run of blank lines (empty or whitespace-only) to a single
+ * newline so the CommonMark type-6 block isn't terminated mid-table.
+ */
+export const collapseBlankLines = (value: string): string =>
+  value.replace(BLANK_LINE_REGEX, '$1');
+
 /**
  * Parse the HTML node that contains the full table substring
  * into the table parts (headers, rows, cells).
@@ -355,8 +364,9 @@ const mdxishTables = (): Transform => tree => {
     } else if (node.value.startsWith('<table')) {
       // If the parsing still fails, give an opportunity to the fallback parser
       // without remarkMdx to process lowercase tables as it's likely to not
-      // have needed MDX parsing anyway
-      const fallback = parseTableNode(fallbackTableNodeProcessor, node);
+      // have needed MDX parsing anyway.
+      const sanitizedValue = collapseBlankLines(node.value);
+      const fallback = parseTableNode(fallbackTableNodeProcessor, { ...node, value: sanitizedValue });
       if (!fallback || fallback.children.length <= 1) return;
       parent.children.splice(index, 1, ...(fallback.children as typeof parent.children));
     }
diff --git a/processor/transform/stripComments.ts b/processor/transform/stripComments.ts
index 5bc5b83b4..973b8cf8c 100644
--- a/processor/transform/stripComments.ts
+++ b/processor/transform/stripComments.ts
@@ -3,6 +3,9 @@ import type { Root } from 'mdast';
 import { visit, SKIP } from 'unist-util-visit';
 
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
+// Indented whole-line comment plus trailing newline; removing the whole line
+// avoids leaving a whitespace-only line that terminates the surrounding block.
+const WHOLE_LINE_HTML_COMMENT_REGEX = /^[ \t]+<!--[\s\S]*?-->[ \t]*(?:\r?\n|$)/gm;
 export const MDX_COMMENT_REGEX = /\/\*(?:(?!\*\/)[\s\S])*\*\//g;
 
 /**
@@ -14,7 +17,10 @@ export const stripCommentsTransformer = () => {
       if (parent && typeof index === 'number') {
         // Remove HTML comments
         if (node.type === 'html' && HTML_COMMENT_REGEX.test(node.value)) {
-          const newValue = node.value.replace(HTML_COMMENT_REGEX, '').trim();
+          const newValue = node.value
+            .replace(WHOLE_LINE_HTML_COMMENT_REGEX, '')
+            .replace(HTML_COMMENT_REGEX, '')
+            .trim();
           if (newValue) {
             node.value = newValue;
           } else {