@link-assistant/web-capture 1.7.10 → 1.7.12

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @link-assistant/web-capture
 
+## 1.7.12
+
+### Patch Changes
+
+- ed70bc8: Fix Google Docs browser-model markdown regressions around table separators,
+  blockquote continuation, nested inline markers, final newlines, and
+  public-export style preprocessing.
+
+## 1.7.11
+
+### Patch Changes
+
+- 71e7eb9: Fall back to the Google Docs export pipeline when browser capture cannot read editor model chunks, preserving archive content and embedded images.
+- 7b4d2d2: Fix Rust CLI `--capture browser` silently routing through direct HTTP
+  fetches for non-Google-Docs URLs (issue #80):
+  - `rust/src/main.rs` now passes `--capture browser` through
+    `render_html` for markdown, archive, and html output formats so the
+    flag actually launches headless Chrome instead of calling
+    `fetch_html`.
+  - `rust/src/browser.rs` `capture_screenshot` is no longer a stub — it
+    launches headless Chrome with `--screenshot` and returns real PNG
+    bytes.
+  - Adds Rust integration tests that run a local HTTP fixture whose DOM
+    is mutated by JavaScript after load and verify the rendered HTML,
+    the CLI `--capture browser` markdown output, and the PNG signature
+    on the screenshot bytes.
+
+  No JS package behavior changes in this patch; the Rust CLI is the only
+  affected surface.
+
 ## 1.7.10
 
 ### Patch Changes

package/bin/web-capture.js

@@ -459,7 +459,7 @@ async function captureUrl(url, options) {
     fetchGoogleDoc,
     fetchGoogleDocAsMarkdown,
     fetchGoogleDocFromDocsApi,
-    captureGoogleDocWithBrowser,
+    captureGoogleDocWithBrowserOrFallback,
     selectGoogleDocsCaptureMethod,
   } = await import('../src/gdocs.js');
   const { stripBase64Images } = await import('../src/extract-images.js');
@@ -511,40 +511,60 @@ async function captureUrl(url, options) {
       // Screenshot/PDF/DOCX formats should use the regular browser pipeline below.
     } else if (gdocsMethod === 'browser-model') {
       try {
-        const result = await captureGoogleDocWithBrowser(absoluteUrl, {
-          engine,
-          apiToken,
-          log,
-        });
+        const result = await captureGoogleDocWithBrowserOrFallback(
+          absoluteUrl,
+          {
+            engine,
+            apiToken,
+            format: normalizedFormat,
+            log,
+            onFallback: (err) => {
+              console.error(
+                `Warning: Google Docs browser capture could not read editor content (${err.message}); falling back to Google Docs export API.`
+              );
+            },
+          }
+        );
+        const resultMethod = result.fallback ? result.method : gdocsMethod;
+        const resultCapture = result.capture || {};
         log.debug(() => ({
-          event: 'gdocs.capture.browser-model.rendered',
+          event: result.fallback
+            ? 'gdocs.capture.browser-model.fallback-rendered'
+            : 'gdocs.capture.browser-model.rendered',
           documentId: result.documentId,
-          blocks: result.capture?.blocks?.length || 0,
-          tables: result.capture?.tables?.length || 0,
-          images: result.capture?.images?.length || 0,
+          method: resultMethod,
+          blocks: resultCapture.blocks?.length || 0,
+          tables: resultCapture.tables?.length || 0,
+          images: resultCapture.images?.length || result.images?.length || 0,
           markdownBytes: Buffer.byteLength(result.markdown || ''),
           htmlBytes: Buffer.byteLength(result.html || ''),
           textBytes: Buffer.byteLength(result.text || ''),
         }));
         if (normalizedFormat === 'archive' || normalizedFormat === 'zip') {
-          const { localizeGoogleDocsModelImages } =
-            await import('../src/gdocs.js');
-          const localized = await localizeGoogleDocsModelImages(result, {
-            log,
-          });
-          log.debug(() => ({
-            event: 'gdocs.capture.browser-model.archive.localized',
-            images: localized.images.length,
-            markdownBytes: Buffer.byteLength(localized.markdown),
-            htmlBytes: Buffer.byteLength(localized.html),
-          }));
-          await writeGoogleDocsArchive({
-            archiveResult: {
+          let archiveResult;
+          if (result.fallback) {
+            archiveResult = result;
+          } else {
+            const { localizeGoogleDocsModelImages } =
+              await import('../src/gdocs.js');
+            const localized = await localizeGoogleDocsModelImages(result, {
+              log,
+            });
+            log.debug(() => ({
+              event: 'gdocs.capture.browser-model.archive.localized',
+              images: localized.images.length,
+              markdownBytes: Buffer.byteLength(localized.markdown),
+              htmlBytes: Buffer.byteLength(localized.html),
+            }));
+            archiveResult = {
               ...result,
               markdown: localized.markdown,
               html: localized.html,
               images: localized.images,
-            },
+            };
+          }
+          await writeGoogleDocsArchive({
+            archiveResult,
             absoluteUrl,
             explicitOutput,
             dataDir,
@@ -554,10 +574,10 @@ async function captureUrl(url, options) {
         } else {
           const rendered =
             normalizedFormat === 'html'
-              ? result.html
+              ? result.html || result.content
               : normalizedFormat === 'txt' || normalizedFormat === 'text'
-                ? result.text
-                : result.markdown;
+                ? result.text || result.content
+                : result.markdown || result.content;
           const ext =
             normalizedFormat === 'html'
               ? 'html'
@@ -570,7 +590,7 @@ async function captureUrl(url, options) {
             ext,
             explicitOutput,
             dataDir,
-            label: `Google Doc (${gdocsMethod})`,
+            label: `Google Doc (${resultMethod})`,
           });
         }
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/web-capture",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "CLI and microservice to render web pages as HTML, Markdown, or PNG",
   "main": "src/index.js",
   "bin": {

package/src/gdocs-fallback.js

@@ -0,0 +1,152 @@
+// Google Docs browser-model fallback helpers.
+//
+// When browser-model capture cannot read DOCS_modelChunk data from the editor
+// page, fall back to the public export pipeline so that content and images
+// are preserved (instead of returning an empty or lossy capture).
+
+const GDOCS_BROWSER_MODEL_UNAVAILABLE = 'GDOCS_BROWSER_MODEL_UNAVAILABLE';
+
+/**
+ * Build the sentinel error thrown when browser-model capture finds no chunks.
+ *
+ * @param {string} message - Human-readable error message
+ * @returns {Error} Error carrying the sentinel code
+ */
+export function googleDocsBrowserModelUnavailableError(message) {
+  const err = new Error(message);
+  err.code = GDOCS_BROWSER_MODEL_UNAVAILABLE;
+  return err;
+}
+
+/**
+ * Check whether an error means Google Docs browser-model data was unavailable.
+ *
+ * @param {Error} err - Error to classify
+ * @returns {boolean} True if export fallback is appropriate
+ */
+export function isGoogleDocsBrowserModelUnavailableError(err) {
+  return (
+    err?.code === GDOCS_BROWSER_MODEL_UNAVAILABLE ||
+    String(err?.message || '').includes('did not expose DOCS_modelChunk data')
+  );
+}
+
+/**
+ * Fetch a Google Doc through the public export pipeline for a requested output
+ * format. This is used as the lossless fallback when browser-model capture
+ * cannot read DOCS_modelChunk data from the editor page.
+ *
+ * @param {Object} deps - Injected dependencies from gdocs.js
+ * @param {string} url - Google Docs URL
+ * @param {Object} [options] - Options
+ * @returns {Promise<Object>} Export result normalized for CLI rendering
+ */
+export async function fetchGoogleDocByExportFormat(deps, url, options = {}) {
+  const { fetchGoogleDoc, fetchGoogleDocAsMarkdown, fetchGoogleDocAsArchive } =
+    deps;
+  const { format = 'markdown', apiToken, log } = options;
+  const normalized = (format || 'markdown').toLowerCase();
+
+  if (normalized === 'archive' || normalized === 'zip') {
+    const archiveResult = await fetchGoogleDocAsArchive(url, { apiToken, log });
+    return {
+      ...archiveResult,
+      content: archiveResult.markdown,
+      sourceFormat: 'archive',
+    };
+  }
+
+  if (normalized === 'markdown' || normalized === 'md') {
+    const result = await fetchGoogleDocAsMarkdown(url, { apiToken, log });
+    return {
+      ...result,
+      content: result.markdown,
+      sourceFormat: 'markdown',
+    };
+  }
+
+  if (normalized === 'html') {
+    const result = await fetchGoogleDoc(url, {
+      format: 'html',
+      apiToken,
+      log,
+    });
+    return {
+      ...result,
+      html: result.content,
+      sourceFormat: 'html',
+    };
+  }
+
+  if (normalized === 'txt' || normalized === 'text') {
+    const result = await fetchGoogleDoc(url, {
+      format: 'txt',
+      apiToken,
+      log,
+    });
+    return {
+      ...result,
+      text: result.content,
+      sourceFormat: 'txt',
+    };
+  }
+
+  throw new Error(
+    `Unsupported Google Docs export fallback format "${format}".`
+  );
+}
+
+/**
+ * Capture a Google Doc through the browser model, falling back to public export
+ * when the editor does not expose model chunks.
+ *
+ * @param {Object} deps - Injected dependencies from gdocs.js
+ * @param {string} url - Google Docs URL
+ * @param {Object} [options] - Capture options
+ * @returns {Promise<Object>} Browser-model or public-export result
+ */
+export async function captureGoogleDocWithBrowserOrFallback(
+  deps,
+  url,
+  options = {}
+) {
+  const { captureGoogleDocWithBrowser } = deps;
+  const {
+    format = 'markdown',
+    fallback = true,
+    onFallback,
+    ...browserOptions
+  } = options;
+
+  try {
+    const result = await captureGoogleDocWithBrowser(url, browserOptions);
+    return {
+      ...result,
+      method: 'browser-model',
+      fallback: false,
+    };
+  } catch (err) {
+    if (!fallback || !isGoogleDocsBrowserModelUnavailableError(err)) {
+      throw err;
+    }
+
+    onFallback?.(err);
+    browserOptions.log?.warn?.(() => ({
+      event: 'gdocs.browser-model.fallback-public-export',
+      reason: err.message,
+      format,
+    }));
+
+    const result = await fetchGoogleDocByExportFormat(deps, url, {
+      format,
+      apiToken: browserOptions.apiToken,
+      log: browserOptions.log,
+    });
+    return {
+      ...result,
+      method: 'public-export',
+      fallback: true,
+      browserError: err.message,
+    };
+  }
+}

package/src/gdocs-preprocess.js

@@ -25,14 +25,15 @@ export function preprocessGoogleDocsExportHtml(html) {
   }
 
   const $ = cheerio.load(html, { decodeEntities: false });
+  const classStyles = parseCssClassStyles($);
   let hoisted = 0;
   let unwrappedLinks = 0;
 
-  $('span[style], p[style]').each(function () {
-    const style = String($(this).attr('style') || '');
-    const hasBold = /font-weight\s*:\s*(?:bold|[6-9]\d{2})/i.test(style);
-    const hasItalic = /font-style\s*:\s*italic/i.test(style);
-    const hasStrike = /text-decoration[^;]*\bline-through\b/i.test(style);
+  $('span, p').each(function () {
+    const style = combinedElementStyle($, this, classStyles);
+    const hasBold = hasBoldStyle(style);
+    const hasItalic = hasItalicStyle(style);
+    const hasStrike = hasStrikeStyle(style);
     if (!hasBold && !hasItalic && !hasStrike) {
       return;
     }
@@ -47,10 +48,31 @@ export function preprocessGoogleDocsExportHtml(html) {
     if (hasBold) {
       wrapped = `<strong>${wrapped}</strong>`;
     }
-    $(this).replaceWith(wrapped);
+    if (this.tagName === 'p') {
+      $(this).html(wrapped);
+    } else {
+      $(this).replaceWith(wrapped);
+    }
     hoisted += 1;
   });
 
+  $('p').each(function () {
+    const style = combinedElementStyle($, this, classStyles);
+    if (!isBlockquoteStyle(style)) {
+      return;
+    }
+    $(this).replaceWith(
+      `<blockquote><p>${$(this).html() || ''}</p></blockquote>`
+    );
+  });
+
+  $('a').each(function () {
+    const $a = $(this);
+    if (!$a.attr('href') && !$a.text().trim() && !$a.find('img').length) {
+      $a.remove();
+    }
+  });
+
   $('h1, h2, h3, h4, h5, h6').each(function () {
     const $h = $(this);
     $h.find('a').each(function () {
@@ -103,3 +125,63 @@ export function preprocessGoogleDocsExportHtml(html) {
 
   return { html: rewritten, hoisted, unwrappedLinks };
 }
+
+function parseCssClassStyles($) {
+  const classStyles = new Map();
+  $('style').each(function () {
+    const css = $(this).html() || '';
+    const classRule = /\.([A-Za-z0-9_-]+)\s*\{([^{}]*)\}/g;
+    let match;
+    while ((match = classRule.exec(css)) !== null) {
+      const [, className, style] = match;
+      classStyles.set(
+        className,
+        `${classStyles.get(className) || ''};${style}`
+      );
+    }
+  });
+  return classStyles;
+}
+
+function combinedElementStyle($, element, classStyles) {
+  const $el = $(element);
+  const styles = [String($el.attr('style') || '')];
+  const classes = String($el.attr('class') || '')
+    .split(/\s+/u)
+    .filter(Boolean);
+  for (const className of classes) {
+    if (classStyles.has(className)) {
+      styles.push(classStyles.get(className));
+    }
+  }
+  return styles.join(';');
+}
+
+function hasBoldStyle(style) {
+  return /font-weight\s*:\s*(?:bold|[6-9]\d{2})/i.test(style);
+}
+
+function hasItalicStyle(style) {
+  return /font-style\s*:\s*italic/i.test(style);
+}
+
+function hasStrikeStyle(style) {
+  return /text-decoration[^;]*\bline-through\b/i.test(style);
+}
+
+function isBlockquoteStyle(style) {
+  const marginLeft = numericCssPointValue(style, 'margin-left');
+  const marginRight = numericCssPointValue(style, 'margin-right');
+  return (
+    marginLeft > 0 &&
+    marginRight > 0 &&
+    Math.abs(marginLeft - marginRight) < 0.1
+  );
+}
+
+function numericCssPointValue(style, property) {
+  const match = style.match(
+    new RegExp(`${property}\\s*:\\s*(-?\\d+(?:\\.\\d+)?)pt`, 'i')
+  );
+  return match ? Number(match[1]) : 0;
+}

package/src/gdocs-render-markdown.js

@@ -0,0 +1,173 @@
+export function renderBlocksMarkdown(blocks) {
+  const counters = new Map();
+  const rendered = blocks.map((block) => {
+    if (block.type === 'table') {
+      counters.clear();
+      return { text: renderTableMarkdown(block), list: null, quote: false };
+    }
+    const counterKey = block.list
+      ? `${block.list.id || ''}\u0000${block.list.level || 0}`
+      : null;
+    if (block.list) {
+      for (const key of [...counters.keys()]) {
+        const level = Number(key.split('\u0000')[1]);
+        if (level > (block.list.level || 0)) {
+          counters.delete(key);
+        }
+      }
+      const next = (counters.get(counterKey) || 0) + 1;
+      counters.set(counterKey, next);
+      return {
+        text: renderParagraphMarkdown(block, { orderedIndex: next }),
+        list: block.list,
+        quote: Boolean(block.quote),
+      };
+    }
+    counters.clear();
+    return {
+      text: renderParagraphMarkdown(block),
+      list: null,
+      quote: Boolean(block.quote),
+    };
+  });
+
+  const joined = [];
+  for (let i = 0; i < rendered.length; i++) {
+    const cur = rendered[i];
+    if (!cur.text) {
+      continue;
+    }
+    if (joined.length > 0) {
+      const prev = rendered
+        .slice(0, i)
+        .reverse()
+        .find((entry) => entry.text);
+      const sameList =
+        cur.list && prev?.list && (cur.list.id || '') === (prev.list.id || '');
+      if (sameList) {
+        joined.push('\n');
+      } else if (cur.quote && prev?.quote) {
+        joined.push('\n>\n');
+      } else {
+        joined.push('\n\n');
+      }
+    }
+    joined.push(cur.text);
+  }
+  const markdown = joined.join('').trimEnd();
+  return markdown ? `${markdown}\n` : '';
+}
+
+function renderParagraphMarkdown(block, context = {}) {
+  const text = renderContentMarkdown(block.content).trim();
+  if (block.horizontalRule) {
+    return '---';
+  }
+  const style = block.style || '';
+  const headingMatch = style.match(/^HEADING_(\d)$/u);
+  if (headingMatch) {
+    return `${'#'.repeat(Number(headingMatch[1]))} ${text}`;
+  }
+  if (style === 'TITLE') {
+    return `# ${text}`;
+  }
+  if (style === 'SUBTITLE') {
+    return `## ${text}`;
+  }
+  if (block.list) {
+    const indent = '  '.repeat(Math.max(0, block.list.level || 0));
+    const orderedIndex = Math.max(1, Number(context.orderedIndex) || 1);
+    const marker = block.list.ordered ? `${orderedIndex}.` : '-';
+    return `${indent}${marker} ${text}`;
+  }
+  if (block.quote) {
+    return text
+      .split('\n')
+      .map((line) => (line ? `> ${line}` : '>'))
+      .join('\n');
+  }
+  return text;
+}
+
+function renderTableMarkdown(table) {
+  if (!table.rows.length) {
+    return '';
+  }
+  const width = Math.max(...table.rows.map((row) => row.cells.length), 1);
+  const rows = table.rows.map((row) =>
+    Array.from({ length: width }, (_, idx) =>
+      escapeMarkdownTableCell(
+        renderContentMarkdown(row.cells[idx]?.content || [])
+      )
+    )
+  );
+  const separator = Array.from({ length: width }, () => '---');
+  return [rows[0], separator, ...rows.slice(1)]
+    .map((row) => `| ${row.join(' | ')} |`)
+    .join('\n');
+}
+
+function renderContentMarkdown(content = []) {
+  const rendered = [];
+  for (let idx = 0; idx < content.length; idx++) {
+    const node = content[idx];
+    if (node.type === 'image') {
+      rendered.push(node.url ? `![${node.alt || 'image'}](${node.url})` : '');
+      continue;
+    }
+
+    const link = node.link || null;
+    const linkNodes = [node];
+    while (
+      content[idx + 1]?.type === 'text' &&
+      (content[idx + 1].link || null) === link
+    ) {
+      linkNodes.push(content[++idx]);
+    }
+    const label = renderTextRunsMarkdown(linkNodes);
+    rendered.push(link ? `[${label}](${link})` : label);
+  }
+  return rendered.join('');
+}
+
+function renderTextRunsMarkdown(nodes = []) {
+  const inactive = { bold: false, italic: false, strike: false };
+  let active = { ...inactive };
+  let output = '';
+  for (const node of nodes) {
+    const next = {
+      bold: Boolean(node.bold),
+      italic: Boolean(node.italic),
+      strike: Boolean(node.strike),
+    };
+    output += markdownStyleTransition(active, next);
+    output += node.text || '';
+    active = next;
+  }
+  output += markdownStyleTransition(active, inactive);
+  return output;
+}
+
+function markdownStyleTransition(active, next) {
+  const styles = [
+    ['bold', '**'],
+    ['italic', '*'],
+    ['strike', '~~'],
+  ];
+  let markers = '';
+  for (const [key, marker] of [...styles].reverse()) {
+    if (active[key] && !next[key]) {
+      markers += marker;
+    }
+  }
+  for (const [key, marker] of styles) {
+    if (!active[key] && next[key]) {
+      markers += marker;
+    }
+  }
+  return markers;
+}
+
+function escapeMarkdownTableCell(value) {
+  return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
+}

package/src/gdocs.js

@@ -13,8 +13,19 @@ import { convertHtmlToMarkdown } from './lib.js';
 import { createBrowser as defaultCreateBrowser } from './browser.js';
 import { preprocessGoogleDocsExportHtml } from './gdocs-preprocess.js';
 import { localizeGoogleDocsModelImages } from './gdocs-images.js';
-
-export { preprocessGoogleDocsExportHtml, localizeGoogleDocsModelImages };
+import { renderBlocksMarkdown } from './gdocs-render-markdown.js';
+import {
+  googleDocsBrowserModelUnavailableError,
+  isGoogleDocsBrowserModelUnavailableError,
+  fetchGoogleDocByExportFormat as fetchGoogleDocByExportFormatImpl,
+  captureGoogleDocWithBrowserOrFallback as captureGoogleDocWithBrowserOrFallbackImpl,
+} from './gdocs-fallback.js';
+
+export {
+  preprocessGoogleDocsExportHtml,
+  localizeGoogleDocsModelImages,
+  isGoogleDocsBrowserModelUnavailableError,
+};
 
 const GDOCS_URL_PATTERN = /docs\.google\.com\/document\/d\/([a-zA-Z0-9_-]+)/;
 
@@ -308,6 +319,43 @@ export async function fetchGoogleDocAsMarkdown(url, options = {}) {
   };
 }
 
+/**
+ * Fetch a Google Doc through the public export pipeline for a requested output
+ * format. Thin wrapper over the fallback module that injects sibling fetchers.
+ *
+ * @param {string} url - Google Docs URL
+ * @param {Object} [options] - Options
+ * @returns {Promise<Object>} Export result normalized for CLI rendering
+ */
+export function fetchGoogleDocByExportFormat(url, options = {}) {
+  return fetchGoogleDocByExportFormatImpl(
+    { fetchGoogleDoc, fetchGoogleDocAsMarkdown, fetchGoogleDocAsArchive },
+    url,
+    options
+  );
+}
+
+/**
+ * Capture a Google Doc through the browser model, falling back to public export
+ * when the editor does not expose model chunks. Thin wrapper.
+ *
+ * @param {string} url - Google Docs URL
+ * @param {Object} [options] - Capture options
+ * @returns {Promise<Object>} Browser-model or public-export result
+ */
+export function captureGoogleDocWithBrowserOrFallback(url, options = {}) {
+  return captureGoogleDocWithBrowserOrFallbackImpl(
+    {
+      captureGoogleDocWithBrowser,
+      fetchGoogleDoc,
+      fetchGoogleDocAsMarkdown,
+      fetchGoogleDocAsArchive,
+    },
+    url,
+    options
+  );
+}
+
 /**
  * Capture a Google Doc from the editor page model (`DOCS_modelChunk`).
  *
@@ -409,7 +457,7 @@ export async function captureGoogleDocWithBrowser(url, options = {}) {
       textBytes: Buffer.byteLength(capture.text || ''),
     }));
     if (capture.blocks.length === 0) {
-      throw new Error(
+      throw googleDocsBrowserModelUnavailableError(
         'Google Docs editor page did not expose DOCS_modelChunk data'
       );
     }
@@ -602,6 +650,7 @@ export function parseGoogleDocsModelChunks(
   let cell = null;
   const tableHistograms = [];
   let currentHistogram = null;
+  let previousTableControl = null;
 
   const bumpHistogram = (code) => {
     if (!currentHistogram) {
@@ -625,7 +674,7 @@ export function parseGoogleDocsModelChunks(
 
   const flushCell = ({ dropEmpty = false } = {}) => {
     if (cell && row) {
-      const isEmpty = cell.content.length === 0;
+      const isEmpty = cellIsEmpty(cell);
       if (!dropEmpty || !isEmpty) {
         row.cells.push(cell);
       }
@@ -648,7 +697,7 @@ export function parseGoogleDocsModelChunks(
       // last cell content (from `\n` just before the `0x11` close marker).
       while (
         table.rows.length > 1 &&
-        table.rows[table.rows.length - 1].cells.length === 0
+        rowIsEmpty(table.rows[table.rows.length - 1])
       ) {
         table.rows.pop();
       }
@@ -660,6 +709,7 @@ export function parseGoogleDocsModelChunks(
     }
     currentHistogram = null;
     table = null;
+    previousTableControl = null;
   };
 
   const targetContent = () => {
@@ -680,6 +730,7 @@ export function parseGoogleDocsModelChunks(
     if (code === 0x10) {
       flushParagraph(i + 1);
       table = { type: 'table', rows: [] };
+      previousTableControl = code;
       currentHistogram = {
         '0x0a': 0,
         '0x0b': 0,
@@ -699,6 +750,7 @@ export function parseGoogleDocsModelChunks(
       bumpHistogram(code);
       flushRow({ dropEmptyTrailingCell: true });
       row = { cells: [] };
+      previousTableControl = code;
       continue;
     }
     if (code === 0x1c) {
@@ -708,11 +760,19 @@ export function parseGoogleDocsModelChunks(
         row = { cells: [] };
       }
       cell = { content: [] };
+      previousTableControl = code;
       continue;
     }
     if (code === 0x0a) {
       bumpHistogram(code);
       if (table) {
+        if (
+          cellIsEmpty(cell) &&
+          (previousTableControl === 0x1c || previousTableControl === 0x12)
+        ) {
+          previousTableControl = code;
+          continue;
+        }
         // Inside a Google Docs table, `\n` (0x0a) separates CELLS, not rows.
         // Row boundaries are communicated via the explicit `0x12` marker and
         // the closing `0x11` marker. Earlier versions collapsed multi-column
@@ -722,6 +782,7 @@ export function parseGoogleDocsModelChunks(
           row = { cells: [] };
         }
         cell = { content: [] };
+        previousTableControl = code;
       } else {
         flushParagraph(i + 1);
       }
@@ -730,18 +791,21 @@ export function parseGoogleDocsModelChunks(
     if (code === 0x0b) {
       bumpHistogram(code);
       appendText(targetContent(), '\n');
+      previousTableControl = null;
       continue;
     }
 
     const image = imagesByPos.get(i);
     if (image) {
       targetContent().push(image);
+      previousTableControl = null;
       if (fullText[i] === '*') {
         continue;
       }
     }
 
     appendText(targetContent(), fullText[i], styleMaps.inlineStyles[i]);
+    previousTableControl = null;
   }
 
   if (table) {
@@ -770,6 +834,22 @@ export function parseGoogleDocsModelChunks(
   };
 }
 
+function cellIsEmpty(cell) {
+  if (!cell) {
+    return true;
+  }
+  return (cell.content || []).every((node) => {
+    if (node.type === 'image') {
+      return false;
+    }
+    return !String(node.text || '').trim();
+  });
+}
+
+function rowIsEmpty(row) {
+  return !row || row.cells.length === 0 || row.cells.every(cellIsEmpty);
+}
+
 function buildModelStyleMaps(items, textLength) {
   const inlineStyles = Array.from({ length: textLength }, () => ({
     bold: false,
@@ -821,11 +901,17 @@ function applyInlineTextStyle(inlineStyles, start, end, patch) {
 }
 
 function textStyleFromModel(item) {
-  return {
-    bold: Boolean(item.sm?.ts_bd),
-    italic: Boolean(item.sm?.ts_it),
-    strike: Boolean(item.sm?.ts_st),
-  };
+  const style = {};
+  if (item.sm?.ts_bd) {
+    style.bold = true;
+  }
+  if (item.sm?.ts_it) {
+    style.italic = true;
+  }
+  if (item.sm?.ts_st) {
+    style.strike = true;
+  }
+  return style;
 }
 
 function paragraphStyleFromModel(item) {
@@ -1058,152 +1144,6 @@ function sameTextStyle(a, b) {
   );
 }
 
-function renderBlocksMarkdown(blocks) {
-  const counters = new Map();
-  const rendered = blocks.map((block) => {
-    if (block.type === 'table') {
-      counters.clear();
-      return { text: renderTableMarkdown(block), list: null };
-    }
-    const counterKey = block.list
-      ? `${block.list.id || ''}\u0000${block.list.level || 0}`
-      : null;
-    if (block.list) {
-      // Reset deeper siblings when we re-enter a shallower level so
-      // nested lists restart from 1 on each new parent.
-      for (const key of [...counters.keys()]) {
-        const level = Number(key.split('\u0000')[1]);
-        if (level > (block.list.level || 0)) {
-          counters.delete(key);
-        }
-      }
-      const next = (counters.get(counterKey) || 0) + 1;
-      counters.set(counterKey, next);
-      return {
-        text: renderParagraphMarkdown(block, { orderedIndex: next }),
-        list: block.list,
-      };
-    }
-    counters.clear();
-    return { text: renderParagraphMarkdown(block), list: null };
-  });
-
-  const joined = [];
-  for (let i = 0; i < rendered.length; i++) {
-    const cur = rendered[i];
-    if (!cur.text) {
-      continue;
-    }
-    if (joined.length > 0) {
-      const prev = rendered
-        .slice(0, i)
-        .reverse()
-        .find((entry) => entry.text);
-      const sameList =
-        cur.list && prev?.list && (cur.list.id || '') === (prev.list.id || '');
-      joined.push(sameList ? '\n' : '\n\n');
-    }
-    joined.push(cur.text);
-  }
-  return joined.join('').replace(/\s+$/u, '');
-}
-
-function renderParagraphMarkdown(block, context = {}) {
-  const text = renderContentMarkdown(block.content).trim();
-  if (block.horizontalRule) {
-    return '---';
-  }
-  const style = block.style || '';
-  const headingMatch = style.match(/^HEADING_(\d)$/u);
-  if (headingMatch) {
-    return `${'#'.repeat(Number(headingMatch[1]))} ${text}`;
-  }
-  if (style === 'TITLE') {
-    return `# ${text}`;
-  }
-  if (style === 'SUBTITLE') {
-    return `## ${text}`;
-  }
-  if (block.list) {
-    const indent = '  '.repeat(Math.max(0, block.list.level || 0));
-    const orderedIndex = Math.max(1, Number(context.orderedIndex) || 1);
-    const marker = block.list.ordered ? `${orderedIndex}.` : '-';
-    return `${indent}${marker} ${text}`;
-  }
-  if (block.quote) {
-    return text
-      .split('\n')
-      .map((line) => (line ? `> ${line}` : '>'))
-      .join('\n');
-  }
-  return text;
-}
-
-function renderTableMarkdown(table) {
-  if (!table.rows.length) {
-    return '';
-  }
-  const width = Math.max(...table.rows.map((row) => row.cells.length), 1);
-  const rows = table.rows.map((row) =>
-    Array.from({ length: width }, (_, idx) =>
-      escapeMarkdownTableCell(
-        renderContentMarkdown(row.cells[idx]?.content || [])
-      )
-    )
-  );
-  const separator = Array.from({ length: width }, () => '---');
-  return [rows[0], separator, ...rows.slice(1)]
-    .map((row) => `| ${row.join(' | ')} |`)
-    .join('\n');
-}
-
-function renderContentMarkdown(content = []) {
-  const rendered = [];
-  for (let idx = 0; idx < content.length; idx++) {
-    const node = content[idx];
-    if (node.type === 'image') {
-      rendered.push(node.url ? `![${node.alt || 'image'}](${node.url})` : '');
-      continue;
-    }
-    if (!node.link) {
-      rendered.push(renderMarkedText(node.text || '', node));
-      continue;
-    }
-
-    const link = node.link;
-    const linkNodes = [node];
-    while (
-      content[idx + 1]?.type === 'text' &&
-      content[idx + 1].link === link
-    ) {
-      linkNodes.push(content[++idx]);
-    }
-    const label = linkNodes
-      .map((linkNode) => renderMarkedText(linkNode.text || '', linkNode))
-      .join('');
-    rendered.push(`[${label}](${link})`);
-  }
-  return rendered.join('');
-}
-
-function renderMarkedText(text, node = {}) {
-  let output = text;
-  if (!output) {
-    return output;
-  }
-  if (node.bold && node.italic) {
-    output = `***${output}***`;
-  } else if (node.bold) {
-    output = `**${output}**`;
-  } else if (node.italic) {
-    output = `*${output}*`;
-  }
-  if (node.strike) {
-    output = `~~${output}~~`;
-  }
-  return output;
-}
-
 function renderBlocksHtml(blocks) {
   return `<!doctype html><html><body>${blocks
     .map((block) => {
@@ -1336,10 +1276,6 @@ function escapeHtml(value) {
   });
 }
 
-function escapeMarkdownTableCell(value) {
-  return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
-}
-
 /**
  * Extract base64 data URI images from HTML content.
  *

package/tests/unit/gdocs.test.js

@@ -6,6 +6,8 @@ import {
   buildEditUrl,
   buildDocsApiUrl,
   extractBase64Images,
+  captureGoogleDocWithBrowserOrFallback,
+  isGoogleDocsBrowserModelUnavailableError,
   parseGoogleDocsModelChunks,
   renderGoogleDocsCapture,
   renderDocsApiDocument,
@@ -22,6 +24,7 @@ import {
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import nock from 'nock';
 
 jest.setTimeout(30000);
 
@@ -282,6 +285,29 @@ describe('gdocs', () => {
       expect(markdown).toContain('| D | E | F |');
     });
 
+    it('does not create empty columns when Docs emits both 0x1c and 0x0a cell separators (issue #96)', () => {
+      const chunks = [
+        {
+          chunk: [
+            {
+              ty: 'is',
+              s: `${
+                String.fromCharCode(0x10) + String.fromCharCode(0x12)
+              }A${String.fromCharCode(0x1c)}\nB${String.fromCharCode(
+                0x1c
+              )}\nC\n${String.fromCharCode(0x11)}`,
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(capture.tables[0].rows[0].cells).toHaveLength(3);
+      expect(markdown).toContain('| A | B | C |');
+      expect(markdown).not.toContain('| A |  | B |');
+    });
+
     it('numbers ordered list items sequentially (issue #92 R3)', () => {
       // Three list items sharing the same list id should render as 1. 2. 3.
       const text = 'First item\nSecond item\nThird item\n';
@@ -467,6 +493,108 @@ describe('gdocs', () => {
         '![Blue rectangle](https://docs.google.com/docs-images-rt/image-id)'
       );
     });
+
+    it('keeps nested bold and italic markers balanced (issue #96)', () => {
+      const text = 'Bold text with italic inside and back to bold\n';
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'text',
+              si: 1,
+              ei: text.length - 1,
+              sm: { ts_bd: true },
+            },
+            {
+              ty: 'as',
+              st: 'text',
+              si: text.indexOf('italic') + 1,
+              ei: text.indexOf('italic') + 'italic inside'.length,
+              sm: { ts_it: true },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe(
+        '**Bold text with *italic inside* and back to bold**\n'
+      );
+    });
+
+    it('keeps styled same-target link segments in one link label (issue #96)', () => {
+      const text = 'Link with bold text\n';
+      const startOf = (needle) => text.indexOf(needle) + 1;
+      const endOf = (needle) => startOf(needle) + needle.length - 1;
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'link',
+              si: 1,
+              ei: text.length - 1,
+              sm: { lnks_link: { ulnk_url: 'https://example.com' } },
+            },
+            {
+              ty: 'as',
+              st: 'text',
+              si: startOf('bold'),
+              ei: endOf('bold'),
+              sm: { ts_bd: true },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe('[Link with **bold** text](https://example.com)\n');
+    });
+
+    it('keeps consecutive blockquote paragraphs in the same quote block (issue #96)', () => {
+      const text = 'Quote paragraph one\nQuote paragraph two\n';
+      const lineEnd = (needle) => text.indexOf(needle) + needle.length + 1;
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'paragraph',
+              si: lineEnd('Quote paragraph one'),
+              ei: lineEnd('Quote paragraph one'),
+              sm: { ps_il: 24, ps_ifl: 24 },
+            },
+            {
+              ty: 'as',
+              st: 'paragraph',
+              si: lineEnd('Quote paragraph two'),
+              ei: lineEnd('Quote paragraph two'),
+              sm: { ps_il: 24, ps_ifl: 24 },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe(
+        '> Quote paragraph one\n>\n> Quote paragraph two\n'
+      );
+    });
+
+    it('ends rendered markdown with a newline (issue #96)', () => {
+      const capture = parseGoogleDocsModelChunks([
+        { ty: 'is', s: 'Last line\n' },
+      ]);
+
+      expect(renderGoogleDocsCapture(capture, 'markdown')).toBe('Last line\n');
+    });
   });
 
   describe('renderDocsApiDocument (issue #72)', () => {
@@ -539,6 +667,49 @@ describe('gdocs', () => {
     });
   });
 
+  describe('captureGoogleDocWithBrowserOrFallback (issue #81)', () => {
+    afterEach(() => {
+      nock.cleanAll();
+    });
+
+    it('falls back to public export archive when the editor exposes no model chunks', async () => {
+      const tinyPng =
+        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==';
+      nock('https://docs.google.com')
+        .get('/document/d/fallback-doc/export')
+        .query({ format: 'html' })
+        .reply(
+          200,
+          `<html><body><h1>Fallback Doc</h1><p>Complete text</p><img src="data:image/png;base64,${tinyPng}" alt="diagram"></body></html>`,
+          { 'content-type': 'text/html; charset=utf-8' }
+        );
+
+      const fallbackErrors = [];
+      const result = await captureGoogleDocWithBrowserOrFallback(
+        'https://docs.google.com/document/d/fallback-doc/edit',
+        {
+          format: 'archive',
+          waitMs: 0,
+          createBrowser: async () =>
+            fakeBrowserReturningModel({ chunks: [], cidUrlMap: {} }),
+          onFallback: (err) => fallbackErrors.push(err),
+        }
+      );
+
+      expect(result.method).toBe('public-export');
+      expect(result.fallback).toBe(true);
+      expect(result.markdown).toContain('Fallback Doc');
+      expect(result.markdown).toContain('Complete text');
+      expect(result.images).toHaveLength(1);
+      expect(result.html).toContain('images/image-01.png');
+      expect(fallbackErrors).toHaveLength(1);
+      expect(isGoogleDocsBrowserModelUnavailableError(fallbackErrors[0])).toBe(
+        true
+      );
+      expect(nock.isDone()).toBe(true);
+    });
+  });
+
   describe('GDOCS_EXPORT_FORMATS', () => {
     it('contains all expected formats', () => {
       expect(GDOCS_EXPORT_FORMATS).toEqual({
@@ -643,6 +814,18 @@ describe('gdocs', () => {
       expect(out).toContain('<del>');
     });
 
+    it('hoists Google Docs CSS class styles into semantic inline tags', () => {
+      const html =
+        '<style>.c7{font-weight:700}.c19{font-style:italic}.c21{text-decoration:line-through}</style>' +
+        '<p><span class="c7">Bold</span> <span class="c19">Italic</span> <span class="c21">Strike</span></p>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+
+      expect(hoisted).toBe(3);
+      expect(out).toContain('<strong>Bold</strong>');
+      expect(out).toContain('<em>Italic</em>');
+      expect(out).toContain('<del>Strike</del>');
+    });
+
     it('combines multiple styles on a single span', () => {
       const html =
         '<p><span style="font-weight:700;font-style:italic;text-decoration:line-through">Mixed</span></p>';
@@ -672,6 +855,22 @@ describe('gdocs', () => {
       expect(out).not.toContain('<a id=');
     });
 
+    it('strips standalone empty anchors before headings', () => {
+      const html = '<a id="anchor-1"></a><h2>Headings</h2>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+
+      expect(out).toContain('<h2>Headings</h2>');
+      expect(out).not.toContain('<a id=');
+    });
+
+    it('turns class-indented Google Docs paragraphs into blockquotes', () => {
+      const html =
+        '<style>.c18{margin-left:24pt;margin-right:24pt}</style><p class="c18">Quote</p>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+
+      expect(out).toContain('<blockquote><p>Quote</p></blockquote>');
+    });
+
     it('replaces &nbsp; entity and U+00A0 with regular spaces', () => {
       const html = '<p>A\u00A0B&nbsp;C</p>';
       const { html: out } = preprocessGoogleDocsExportHtml(html);
@@ -806,3 +1005,23 @@ describe('gdocs', () => {
     });
   });
 });
+
+function fakeBrowserReturningModel(modelData) {
+  return {
+    async newPage() {
+      return {
+        async addInitScript() {},
+        async setUserAgent() {},
+        async setExtraHTTPHeaders() {},
+        async setViewport() {},
+        async goto() {},
+        async waitForTimeout() {},
+        async evaluate() {
+          return modelData;
+        },
+        async close() {},
+      };
+    },
+    async close() {},
+  };
+}