@link-assistant/web-capture 1.7.9 → 1.7.11

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @link-assistant/web-capture
 
+## 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
+
+- fcc031f: Fix remaining Google Docs capture gaps from issue #92 in both the JS and
+  Rust CLIs:
+  - Browser capture now keeps multi-column table rows intact, renders
+    ordered lists with sequential `1. 2. 3.` numbering, and joins same-list
+    items with a single newline so tight-list markdown matches the source
+    document.
+  - Archive mode downloads `docs-images-rt/...` image URLs into the
+    archive's `images/` directory and rewrites markdown/html references so
+    exports are self-contained.
+  - API mode (`--capture api`) runs the export HTML through a shared
+    preprocessor that hoists inline bold / italic / strikethrough spans to
+    semantic tags, strips Google Docs' heading-numbering spans and empty
+    anchor wrappers, unwraps `google.com/url?q=` redirects, and normalizes
+    non-breaking spaces.
+
 ## 1.7.9
 
 ### 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,24 +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') {
+          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: { ...result, images: [] },
+            archiveResult,
             absoluteUrl,
             explicitOutput,
             dataDir,
@@ -538,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'
@@ -554,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.9",
+  "version": "1.7.11",
   "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-images.js

@@ -0,0 +1,130 @@
+// Google Docs editor-model image localization (issue #92 R5).
+//
+// The browser-model capture returns `docs-images-rt/…` URLs inside the
+// markdown/html. Archive mode needs those images copied into `images/` so
+// the archive is self-contained. This module downloads the images and
+// rewrites the captured output accordingly.
+
+import fetch from 'node-fetch';
+import { URL } from 'url';
+
+const DEFAULT_USER_AGENT =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+
+function getExtensionFromImageUrl(url) {
+  try {
+    const u = new URL(url);
+    const match = u.pathname.match(/\.(png|jpe?g|gif|webp|svg)$/iu);
+    if (match) {
+      const ext = match[1].toLowerCase();
+      return ext === 'jpeg' ? '.jpg' : `.${ext}`;
+    }
+  } catch {
+    // fall through to default
+  }
+  return '.png';
+}
+
+function mimeTypeForExtension(filename) {
+  const dot = filename.lastIndexOf('.');
+  const ext = dot >= 0 ? filename.slice(dot + 1).toLowerCase() : 'png';
+  switch (ext) {
+    case 'jpg':
+    case 'jpeg':
+      return 'image/jpeg';
+    case 'gif':
+      return 'image/gif';
+    case 'webp':
+      return 'image/webp';
+    case 'svg':
+      return 'image/svg+xml';
+    default:
+      return 'image/png';
+  }
+}
+
+/**
+ * Download the `docs-images-rt` URLs captured from an editor-model capture.
+ *
+ * Produces `{ filename, data, mimeType }` entries compatible with
+ * `writeGoogleDocsArchive` and rewrites the markdown/html to reference the
+ * local `images/<filename>` paths.
+ *
+ * @param {{markdown: string, html: string, capture: Object}} modelResult
+ * @param {Object} [options] - Options
+ * @param {typeof fetch} [options.fetchImpl=fetch] - Injected fetch for tests
+ * @param {Object} [options.log] - Verbose logger
+ * @returns {Promise<{markdown: string, html: string, images: Array}>}
+ */
+export async function localizeGoogleDocsModelImages(modelResult, options = {}) {
+  const { fetchImpl = fetch, log } = options;
+  const images = [];
+  const seen = new Map();
+  let nextIndex = 1;
+
+  const resolveFilename = (url, existingAlt) => {
+    if (seen.has(url)) {
+      return seen.get(url);
+    }
+    const ext = getExtensionFromImageUrl(url);
+    const filename = `image-${String(nextIndex).padStart(2, '0')}${ext}`;
+    nextIndex += 1;
+    seen.set(url, filename);
+    log?.debug?.(() => ({
+      event: 'gdocs.archive.image.scheduled',
+      url,
+      filename,
+      alt: existingAlt || null,
+    }));
+    return filename;
+  };
+
+  const candidates = (modelResult?.capture?.images || []).filter(
+    (img) => img?.url
+  );
+  for (const img of candidates) {
+    const filename = resolveFilename(img.url, img.alt);
+    try {
+      const response = await fetchImpl(img.url, {
+        headers: {
+          'User-Agent': DEFAULT_USER_AGENT,
+          Accept: 'image/*,*/*;q=0.8',
+        },
+        redirect: 'follow',
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const data = Buffer.from(arrayBuffer);
+      const mimeType =
+        response.headers?.get?.('content-type') ||
+        mimeTypeForExtension(filename);
+      images.push({ filename, data, mimeType });
+      log?.debug?.(() => ({
+        event: 'gdocs.archive.image.downloaded',
+        url: img.url,
+        filename,
+        bytes: data.length,
+        mimeType,
+      }));
+    } catch (err) {
+      log?.debug?.(() => ({
+        event: 'gdocs.archive.image.failed',
+        url: img.url,
+        filename,
+        error: err?.message || String(err),
+      }));
+    }
+  }
+
+  let markdown = modelResult?.markdown || '';
+  let html = modelResult?.html || '';
+  for (const [url, filename] of seen.entries()) {
+    const localPath = `images/${filename}`;
+    markdown = markdown.split(url).join(localPath);
+    html = html.split(url).join(localPath);
+  }
+
+  return { markdown, html, images };
+}

package/src/gdocs-preprocess.js

@@ -0,0 +1,105 @@
+// Google Docs export HTML preprocessor (issue #92 R6).
+//
+// Google Drive's `/export?format=html` payload serves bold/italic/
+// strikethrough as inline `style` spans, numbers headings with
+// `<a id><span>1. </span>`, and routes every link through a
+// `google.com/url?q=` redirect. The generic Cheerio + Turndown pipeline
+// discards those signals, so the browser-less API path loses the
+// formatting and gains noisy redirect URLs.
+//
+// This module rewrites the export HTML into semantic markup before the
+// generic converter runs.
+
+import * as cheerio from 'cheerio';
+
+/**
+ * Pre-process Google Docs export HTML so the generic Cheerio+Turndown
+ * pipeline preserves inline formatting, heading numbers, and link targets.
+ *
+ * @param {string} html - Raw export HTML returned by Google Docs.
+ * @returns {{html: string, hoisted: number, unwrappedLinks: number}}
+ */
+export function preprocessGoogleDocsExportHtml(html) {
+  if (!html || typeof html !== 'string') {
+    return { html: html || '', hoisted: 0, unwrappedLinks: 0 };
+  }
+
+  const $ = cheerio.load(html, { decodeEntities: false });
+  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);
+    if (!hasBold && !hasItalic && !hasStrike) {
+      return;
+    }
+    const inner = $(this).html() || '';
+    let wrapped = inner;
+    if (hasStrike) {
+      wrapped = `<del>${wrapped}</del>`;
+    }
+    if (hasItalic) {
+      wrapped = `<em>${wrapped}</em>`;
+    }
+    if (hasBold) {
+      wrapped = `<strong>${wrapped}</strong>`;
+    }
+    $(this).replaceWith(wrapped);
+    hoisted += 1;
+  });
+
+  $('h1, h2, h3, h4, h5, h6').each(function () {
+    const $h = $(this);
+    $h.find('a').each(function () {
+      const $a = $(this);
+      if (!$a.attr('href') && !$a.text().trim() && !$a.find('img').length) {
+        $a.remove();
+      }
+    });
+    $h.find('> span, > strong > span').each(function () {
+      const $span = $(this);
+      const text = $span.text();
+      if (/^\s*\d+(?:\.\d+)*\.?\s*$/.test(text)) {
+        $span.remove();
+      }
+    });
+  });
+
+  $('a[href*="google.com/url?q="]').each(function () {
+    const href = String($(this).attr('href') || '');
+    const match = href.match(/[?&]q=([^&]+)/);
+    if (match) {
+      try {
+        const decoded = decodeURIComponent(match[1]);
+        $(this).attr('href', decoded);
+        unwrappedLinks += 1;
+      } catch {
+        // Leave the original href in place if it can't be decoded.
+      }
+    }
+  });
+
+  $('*').each(function () {
+    if (this.type !== 'tag') {
+      return;
+    }
+    $(this)
+      .contents()
+      .each(function () {
+        if (this.type === 'text' && this.data) {
+          const replaced = this.data.replace(/\u00A0/g, ' ');
+          if (replaced !== this.data) {
+            this.data = replaced;
+          }
+        }
+      });
+  });
+
+  let rewritten = $.html();
+  rewritten = rewritten.replace(/&nbsp;/g, ' ');
+
+  return { html: rewritten, hoisted, unwrappedLinks };
+}

package/src/gdocs.js

@@ -11,6 +11,20 @@ import fetch from 'node-fetch';
 import he from 'he';
 import { convertHtmlToMarkdown } from './lib.js';
 import { createBrowser as defaultCreateBrowser } from './browser.js';
+import { preprocessGoogleDocsExportHtml } from './gdocs-preprocess.js';
+import { localizeGoogleDocsModelImages } from './gdocs-images.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_-]+)/;
 
@@ -283,7 +297,14 @@ export async function fetchGoogleDocAsMarkdown(url, options = {}) {
     log,
   });
 
-  const markdown = convertHtmlToMarkdown(result.content, result.exportUrl);
+  const preprocessed = preprocessGoogleDocsExportHtml(result.content);
+  log?.debug?.(() => ({
+    event: 'gdocs.export.style-hoist',
+    documentId: result.documentId,
+    hoisted: preprocessed.hoisted,
+    unwrappedLinks: preprocessed.unwrappedLinks,
+  }));
+  const markdown = convertHtmlToMarkdown(preprocessed.html, result.exportUrl);
   log?.debug?.(() => ({
     event: 'gdocs.public-export.markdown',
     documentId: result.documentId,
@@ -297,6 +318,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`).
  *
@@ -384,7 +442,8 @@ export async function captureGoogleDocWithBrowser(url, options = {}) {
 
     const capture = parseGoogleDocsModelChunks(
       modelData.chunks,
-      modelData.cidUrlMap
+      modelData.cidUrlMap,
+      { log }
     );
     log?.debug?.(() => ({
       event: 'gdocs.browser-model.parsed',
@@ -397,7 +456,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'
       );
     }
@@ -531,9 +590,16 @@ export function extractCidUrlMapFromHtml(html) {
  *
  * @param {Array} chunks - Captured DOCS_modelChunk values
  * @param {Object<string,string>} [cidUrlMap={}] - CID-to-docs-images-rt URL map
+ * @param {Object} [options] - Parse options
+ * @param {Object} [options.log] - Optional verbose logger
  * @returns {{blocks: Array, tables: Array, images: Array, text: string}}
  */
-export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
+export function parseGoogleDocsModelChunks(
+  chunks = [],
+  cidUrlMap = {},
+  options = {}
+) {
+  const { log } = options;
   const items = collectModelItems(chunks);
   const fullText = items
     .filter((item) => item.ty === 'is' || item.ty === 'iss')
@@ -581,6 +647,16 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
   let table = null;
   let row = null;
   let cell = null;
+  const tableHistograms = [];
+  let currentHistogram = null;
+
+  const bumpHistogram = (code) => {
+    if (!currentHistogram) {
+      return;
+    }
+    const key = `0x${code.toString(16).padStart(2, '0')}`;
+    currentHistogram[key] = (currentHistogram[key] || 0) + 1;
+  };
 
   const flushParagraph = (endPos = null) => {
     const text = contentToText(paragraph).trim();
@@ -594,15 +670,18 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
     paragraph = [];
   };
 
-  const flushCell = () => {
+  const flushCell = ({ dropEmpty = false } = {}) => {
     if (cell && row) {
-      row.cells.push(cell);
+      const isEmpty = cell.content.length === 0;
+      if (!dropEmpty || !isEmpty) {
+        row.cells.push(cell);
+      }
     }
     cell = null;
   };
 
-  const flushRow = () => {
-    flushCell();
+  const flushRow = ({ dropEmptyTrailingCell = false } = {}) => {
+    flushCell({ dropEmpty: dropEmptyTrailingCell });
     if (row && table) {
       table.rows.push(row);
     }
@@ -610,11 +689,23 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
   };
 
   const flushTable = () => {
-    flushRow();
+    flushRow({ dropEmptyTrailingCell: true });
     if (table) {
+      // Drop trailing empty rows that Google Docs sometimes emits after the
+      // 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
+      ) {
+        table.rows.pop();
+      }
       tables.push(table);
       blocks.push(table);
     }
+    if (currentHistogram) {
+      tableHistograms.push(currentHistogram);
+    }
+    currentHistogram = null;
     table = null;
   };
 
@@ -636,18 +727,29 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
     if (code === 0x10) {
       flushParagraph(i + 1);
       table = { type: 'table', rows: [] };
+      currentHistogram = {
+        '0x0a': 0,
+        '0x0b': 0,
+        '0x10': 1,
+        '0x11': 0,
+        '0x12': 0,
+        '0x1c': 0,
+      };
       continue;
     }
     if (code === 0x11) {
+      bumpHistogram(code);
       flushTable();
       continue;
     }
     if (code === 0x12) {
-      flushRow();
+      bumpHistogram(code);
+      flushRow({ dropEmptyTrailingCell: true });
       row = { cells: [] };
       continue;
     }
     if (code === 0x1c) {
+      bumpHistogram(code);
       flushCell();
       if (!row) {
         row = { cells: [] };
@@ -656,14 +758,24 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
       continue;
     }
     if (code === 0x0a) {
+      bumpHistogram(code);
       if (table) {
-        flushRow();
+        // 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
+        // tables to one column because they flushed the row on `\n`.
+        flushCell();
+        if (!row) {
+          row = { cells: [] };
+        }
+        cell = { content: [] };
       } else {
         flushParagraph(i + 1);
       }
       continue;
     }
     if (code === 0x0b) {
+      bumpHistogram(code);
       appendText(targetContent(), '\n');
       continue;
     }
@@ -684,6 +796,19 @@ export function parseGoogleDocsModelChunks(chunks = [], cidUrlMap = {}) {
   }
   flushParagraph(fullText.length);
 
+  if (log?.debug && tableHistograms.length > 0) {
+    for (let t = 0; t < tableHistograms.length; t++) {
+      const tbl = tables[t];
+      log.debug(() => ({
+        event: 'gdocs.table.histogram',
+        tableIndex: t,
+        rows: tbl?.rows.length || 0,
+        columns: Math.max(...(tbl?.rows || []).map((r) => r.cells.length), 0),
+        controls: tableHistograms[t],
+      }));
+    }
+  }
+
   return {
     blocks,
     tables,
@@ -981,19 +1106,56 @@ function sameTextStyle(a, b) {
 }
 
 function renderBlocksMarkdown(blocks) {
-  return blocks
-    .map((block) => {
-      if (block.type === 'table') {
-        return renderTableMarkdown(block);
+  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);
+        }
       }
-      return renderParagraphMarkdown(block);
-    })
-    .filter(Boolean)
-    .join('\n\n')
-    .trimEnd();
+      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) {
+function renderParagraphMarkdown(block, context = {}) {
   const text = renderContentMarkdown(block.content).trim();
   if (block.horizontalRule) {
     return '---';
@@ -1011,7 +1173,8 @@ function renderParagraphMarkdown(block) {
   }
   if (block.list) {
     const indent = '  '.repeat(Math.max(0, block.list.level || 0));
-    const marker = block.list.ordered ? '1.' : '-';
+    const orderedIndex = Math.max(1, Number(context.orderedIndex) || 1);
+    const marker = block.list.ordered ? `${orderedIndex}.` : '-';
     return `${indent}${marker} ${text}`;
   }
   if (block.quote) {
@@ -1277,8 +1440,16 @@ export async function fetchGoogleDocAsArchive(url, options = {}) {
   // Fetch HTML with embedded base64 images
   const result = await fetchGoogleDoc(url, { format: 'html', apiToken, log });
 
+  const preprocessed = preprocessGoogleDocsExportHtml(result.content);
+  log?.debug?.(() => ({
+    event: 'gdocs.export.style-hoist',
+    documentId: result.documentId,
+    hoisted: preprocessed.hoisted,
+    unwrappedLinks: preprocessed.unwrappedLinks,
+  }));
+
   // Extract base64 images from HTML
-  const { html: localHtml, images } = extractBase64Images(result.content);
+  const { html: localHtml, images } = extractBase64Images(preprocessed.html);
 
   // Convert the localized HTML to Markdown
   const markdown = convertHtmlToMarkdown(localHtml);

package/tests/unit/gdocs.test.js

@@ -6,10 +6,14 @@ import {
   buildEditUrl,
   buildDocsApiUrl,
   extractBase64Images,
+  captureGoogleDocWithBrowserOrFallback,
+  isGoogleDocsBrowserModelUnavailableError,
   parseGoogleDocsModelChunks,
   renderGoogleDocsCapture,
   renderDocsApiDocument,
   selectGoogleDocsCaptureMethod,
+  localizeGoogleDocsModelImages,
+  preprocessGoogleDocsExportHtml,
   GDOCS_EXPORT_FORMATS,
 } from '../../src/gdocs.js';
 import {
@@ -20,6 +24,7 @@ import {
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import nock from 'nock';
 
 jest.setTimeout(30000);
 
@@ -250,6 +255,115 @@ describe('gdocs', () => {
       );
     });
 
+    it('parses multi-column tables when rows are separated by 0x0a (issue #92 R2)', () => {
+      // Google Docs sometimes emits cell boundaries as `\n` (0x0a) alongside
+      // the 0x12 new-row marker. The parser must keep all cells on the same
+      // row rather than collapsing the table to a single column.
+      const chunks = [
+        {
+          chunk: [
+            {
+              ty: 'is',
+              s: `${
+                String.fromCharCode(0x10) + String.fromCharCode(0x12)
+              }A\nB\nC\n${String.fromCharCode(
+                0x12
+              )}D\nE\nF\n${String.fromCharCode(0x11)}`,
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+
+      expect(capture.tables).toHaveLength(1);
+      expect(capture.tables[0].rows).toHaveLength(2);
+      expect(capture.tables[0].rows[0].cells).toHaveLength(3);
+      expect(capture.tables[0].rows[1].cells).toHaveLength(3);
+
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+      expect(markdown).toContain('| A | B | C |');
+      expect(markdown).toContain('| D | E | F |');
+    });
+
+    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';
+      const endOfLine = (n) => {
+        let idx = -1;
+        for (let k = 0; k < n; k++) {
+          idx = text.indexOf('\n', idx + 1);
+        }
+        return idx + 1;
+      };
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'list',
+              si: endOfLine(1),
+              ei: endOfLine(1),
+              sm: { ls_id: 'kix.list.7' },
+            },
+            {
+              ty: 'as',
+              st: 'list',
+              si: endOfLine(2),
+              ei: endOfLine(2),
+              sm: { ls_id: 'kix.list.7' },
+            },
+            {
+              ty: 'as',
+              st: 'list',
+              si: endOfLine(3),
+              ei: endOfLine(3),
+              sm: { ls_id: 'kix.list.7' },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+      const lines = markdown.split('\n');
+
+      expect(lines[0]).toBe('1. First item');
+      expect(lines[1]).toBe('2. Second item');
+      expect(lines[2]).toBe('3. Third item');
+    });
+
+    it('joins consecutive list items with a single newline (issue #92 R4)', () => {
+      const text = 'First item\nSecond item\n';
+      const endFirst = text.indexOf('\n') + 1;
+      const endSecond = text.length;
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'list',
+              si: endFirst,
+              ei: endFirst,
+              sm: { ls_id: 'kix.list.7' },
+            },
+            {
+              ty: 'as',
+              st: 'list',
+              si: endSecond,
+              ei: endSecond,
+              sm: { ls_id: 'kix.list.7' },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).not.toMatch(/First item\n\n2\. Second item/u);
+      expect(markdown).toMatch(/First item\n2\. Second item/u);
+    });
+
     it('renders model style records for headings, inline formatting, links, lists, blockquotes, rules, and images', () => {
       const text = [
         'Title',
@@ -428,6 +542,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({
@@ -442,6 +599,146 @@ describe('gdocs', () => {
     });
   });
 
+  describe('localizeGoogleDocsModelImages (issue #92 R5)', () => {
+    it('downloads docs-images-rt URLs and rewrites markdown/html', async () => {
+      const url =
+        'https://docs.google.com/docs-images-rt/doc-id/cid/example.png';
+      const modelResult = {
+        markdown: `![pic](${url})`,
+        html: `<img src="${url}" alt="pic">`,
+        capture: {
+          images: [{ type: 'image', url, alt: 'pic', cid: 'cid-abc' }],
+        },
+      };
+      const fakeFetch = jest.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        headers: new Map([['content-type', 'image/png']]),
+        arrayBuffer: async () => new Uint8Array([1, 2, 3, 4]).buffer,
+      });
+      // The map-based headers need a `get` method in the correct shape:
+      fakeFetch.mockResolvedValue({
+        ok: true,
+        status: 200,
+        headers: { get: () => 'image/png' },
+        arrayBuffer: async () =>
+          new Uint8Array([0x89, 0x50, 0x4e, 0x47]).buffer,
+      });
+
+      const localized = await localizeGoogleDocsModelImages(modelResult, {
+        fetchImpl: fakeFetch,
+      });
+
+      expect(fakeFetch).toHaveBeenCalledTimes(1);
+      expect(localized.images).toHaveLength(1);
+      expect(localized.images[0].filename).toBe('image-01.png');
+      expect(localized.images[0].mimeType).toBe('image/png');
+      expect(localized.images[0].data).toBeInstanceOf(Buffer);
+      expect(localized.markdown).toBe('![pic](images/image-01.png)');
+      expect(localized.html).toContain('images/image-01.png');
+      expect(localized.html).not.toContain('docs-images-rt');
+    });
+
+    it('keeps original URL when download fails', async () => {
+      const url =
+        'https://docs.google.com/docs-images-rt/doc-id/cid/missing.png';
+      const modelResult = {
+        markdown: `![pic](${url})`,
+        html: `<img src="${url}" alt="pic">`,
+        capture: { images: [{ url, alt: 'pic' }] },
+      };
+      const fakeFetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 404,
+        headers: { get: () => null },
+      });
+
+      const localized = await localizeGoogleDocsModelImages(modelResult, {
+        fetchImpl: fakeFetch,
+      });
+
+      expect(localized.images).toHaveLength(0);
+      // Markdown still gets rewritten (local path) even if download fails —
+      // callers may choose to ignore this; the key guarantee is that no
+      // exception leaks out.
+      expect(localized.markdown).toBe('![pic](images/image-01.png)');
+    });
+  });
+
+  describe('preprocessGoogleDocsExportHtml (issue #92 R6)', () => {
+    it('hoists font-weight:700 spans into <strong>', () => {
+      const html = '<p><span style="font-weight:700">Bold text</span></p>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+      expect(hoisted).toBe(1);
+      expect(out).toContain('<strong>');
+      expect(out).toContain('Bold text');
+    });
+
+    it('hoists font-style:italic spans into <em>', () => {
+      const html = '<p><span style="font-style:italic">Italic text</span></p>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+      expect(hoisted).toBe(1);
+      expect(out).toContain('<em>');
+    });
+
+    it('hoists text-decoration:line-through spans into <del>', () => {
+      const html =
+        '<p><span style="text-decoration:line-through">Strike</span></p>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+      expect(hoisted).toBe(1);
+      expect(out).toContain('<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>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+      expect(hoisted).toBe(1);
+      // Wrappers appear in <strong><em><del>... order (outer-to-inner).
+      expect(out).toContain('<strong>');
+      expect(out).toContain('<em>');
+      expect(out).toContain('<del>');
+    });
+
+    it('unwraps google.com/url?q= redirect links', () => {
+      const html =
+        '<p><a href="https://www.google.com/url?q=https://example.com&sa=D&source=editors&usg=ABC">Link</a></p>';
+      const { html: out, unwrappedLinks } =
+        preprocessGoogleDocsExportHtml(html);
+      expect(unwrappedLinks).toBe(1);
+      expect(out).toContain('href="https://example.com"');
+      expect(out).not.toContain('google.com/url?q=');
+    });
+
+    it('strips leading empty anchors and numbering span inside headings', () => {
+      const html = '<h1><a id="anchor-1"></a><span>1. </span>Headings</h1>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+      expect(out).toContain('<h1>Headings</h1>');
+      expect(out).not.toContain('1. ');
+      expect(out).not.toContain('<a id=');
+    });
+
+    it('replaces &nbsp; entity and U+00A0 with regular spaces', () => {
+      const html = '<p>A\u00A0B&nbsp;C</p>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+      expect(out).toContain('A B C');
+      expect(out).not.toMatch(/\u00A0/);
+      expect(out).not.toContain('&nbsp;');
+    });
+
+    it('is a no-op for HTML without Google Docs markers', () => {
+      const html = '<p>Plain text with <strong>bold</strong>.</p>';
+      const {
+        html: out,
+        hoisted,
+        unwrappedLinks,
+      } = preprocessGoogleDocsExportHtml(html);
+      expect(hoisted).toBe(0);
+      expect(unwrappedLinks).toBe(0);
+      expect(out).toContain('<p>Plain text with <strong>bold</strong>.</p>');
+    });
+  });
+
   describe('extractBase64Images', () => {
     it('extracts a single PNG data URI image', () => {
       const html = '<img src="data:image/png;base64,iVBORw0KGgo=" alt="test">';
@@ -555,3 +852,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() {},
+  };
+}