@link-assistant/web-capture 1.7.9 → 1.7.10

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/web-capture
 
+## 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

@@ -527,8 +527,24 @@ async function captureUrl(url, options) {
           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: { ...result, images: [] },
+            archiveResult: {
+              ...result,
+              markdown: localized.markdown,
+              html: localized.html,
+              images: localized.images,
+            },
             absoluteUrl,
             explicitOutput,
             dataDir,

package/package.json

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

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,10 @@ 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';
+
+export { preprocessGoogleDocsExportHtml, localizeGoogleDocsModelImages };
 
 const GDOCS_URL_PATTERN = /docs\.google\.com\/document\/d\/([a-zA-Z0-9_-]+)/;
 
@@ -283,7 +287,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,
@@ -384,7 +395,8 @@ export async function captureGoogleDocWithBrowser(url, options = {}) {
 
     const capture = parseGoogleDocsModelChunks(
       modelData.chunks,
-      modelData.cidUrlMap
+      modelData.cidUrlMap,
+      { log }
     );
     log?.debug?.(() => ({
       event: 'gdocs.browser-model.parsed',
@@ -531,9 +543,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 +600,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 +623,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 +642,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 +680,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 +711,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 +749,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 +1059,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 +1126,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 +1393,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

@@ -10,6 +10,8 @@ import {
   renderGoogleDocsCapture,
   renderDocsApiDocument,
   selectGoogleDocsCaptureMethod,
+  localizeGoogleDocsModelImages,
+  preprocessGoogleDocsExportHtml,
   GDOCS_EXPORT_FORMATS,
 } from '../../src/gdocs.js';
 import {
@@ -250,6 +252,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',
@@ -442,6 +553,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">';