@link-assistant/web-capture 1.10.0 → 1.10.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/web-capture
 
+## 1.10.2
+
+### Patch Changes
+
+- Add xpaste.pro raw text capture and large-paste markdown archive handling.
+
+## 1.10.1
+
+### Patch Changes
+
+- 31b93a8: Add a live integration test that downloads the Wikipedia page
+  (https://en.wikipedia.org/wiki/Wikipedia) as both Markdown and an image (PNG
+  screenshot) using every supported browser engine — Puppeteer and Playwright
+  (issue #8). The suite is gated behind `WIKIPEDIA_INTEGRATION=true` so default
+  offline runs stay deterministic, and is wired into CI as a dedicated live step.
+
 ## 1.10.0
 
 ### Minor Changes

package/README.md

@@ -10,6 +10,7 @@ A CLI and microservice to fetch URLs and render them as:
 
 - **Markdown**: Converted from HTML with image extraction (default)
 - **HTML**: Rendered page content
+- **Plain text**: Raw text downloads for paste-like URLs such as xpaste.pro
 - **PNG/JPEG screenshot**: Viewport or full-page capture with theme support
 - **ZIP archive**: Markdown + locally downloaded images
 - **PDF**: Print-quality document with embedded images
@@ -48,6 +49,9 @@ web-capture https://example.com -o -
 # Capture as HTML
 web-capture https://example.com --format html -o page.html
 
+# Capture raw paste text
+web-capture https://xpaste.pro/p/t4q0Lsp0 --format txt -o paste.txt
+
 # Take a PNG screenshot
 web-capture https://example.com --format png -o screenshot.png
 
@@ -141,6 +145,14 @@ GET /markdown?url=<URL>
 
 Converts the HTML content of the specified URL to Markdown format. By default, original remote image URLs are preserved and base64 data URIs are stripped (clean single-file output). Use `keepOriginalLinks=false` to strip all images, or `embedImages=true` to keep base64 images inline.
 
+For xpaste.pro paste URLs, `/markdown` fetches the visual paste page, keeps
+visible header, language, metadata, paste body, and footer text in visual order,
+and appends the raw paste text as a fenced block named `xpaste-pro-<id>.txt`
+when the final Markdown stays under 1500 lines. Larger paste pages return a ZIP
+containing `index.md`, `xpaste-pro-<id>.md`, and `xpaste-pro-<id>.txt`.
+Canonical `/p/<id>`, `/p/<id>/raw`, `/ru/p/<id>`, and `/en/p/<id>` URLs are
+normalized before capture.
+
 | Parameter           | Required | Description                                                               | Default  |
 | ------------------- | -------- | ------------------------------------------------------------------------- | -------- |
 | `url`               | Yes      | URL to fetch                                                              | -        |
@@ -149,6 +161,20 @@ Converts the HTML content of the specified URL to Markdown format. By default, o
 | `embedImages`       | No       | Keep base64 images inline (`true`/`false`)                                | `false`  |
 | `keepOriginalLinks` | No       | Keep original remote URLs, strip base64                                   | `true`   |
 
+### Text Endpoint
+
+```
+GET /txt?url=<URL>
+```
+
+Returns raw text content as a `.txt` attachment. xpaste.pro paste URLs are
+normalized to their `/raw` endpoint, including localized `/ru/p/<id>` and
+`/en/p/<id>` URLs.
+
+| Parameter | Required | Description  | Default |
+| --------- | -------- | ------------ | ------- |
+| `url`     | Yes      | URL to fetch | -       |
+
 ### Image Endpoint
 
 ```
@@ -334,6 +360,7 @@ web-capture <url> [options]
 | ----------------- | ---------------------------------------- |
 | `markdown` / `md` | Markdown conversion (default)            |
 | `html`            | Rendered HTML                            |
+| `txt` / `text`    | Raw text download                        |
 | `image` / `png`   | PNG screenshot (lossless)                |
 | `jpeg`            | JPEG screenshot (configurable quality)   |
 | `pdf`             | PDF with embedded images                 |
@@ -456,6 +483,18 @@ npm run test:e2e            # Run end-to-end tests
 npm run test:all            # Run all tests including build
 ```
 
+Some integration suites hit live servers and are skipped by default. Enable them
+with environment variables:
+
+```bash
+# Download the Wikipedia page (markdown + image) in every supported engine
+WIKIPEDIA_INTEGRATION=true npm test -- --testPathPattern="wikipedia-download"
+
+# Habr articles and public Google Docs live suites
+HABR_INTEGRATION=true npm test -- --testPathPattern="habr-article"
+GDOCS_INTEGRATION=true npm test -- --testPathPattern="gdocs-public-doc"
+```
+
 ## Built With
 
 - Express.js for the web server

package/bin/web-capture.js

@@ -78,7 +78,7 @@ const config = makeConfig({
         alias: 'f',
         type: 'string',
         description:
-          'Output format: markdown, md, html, image, png, jpeg, pdf, docx, archive',
+          'Output format: markdown, md, html, txt, text, image, png, jpeg, pdf, docx, archive',
         default: 'markdown',
       })
       .option('theme', {
@@ -289,7 +289,7 @@ const config = makeConfig({
         'Capture private Google Doc with API token'
       )
       .epilogue(
-        'API Endpoints (in server mode):\n  GET /html?url=<URL>&engine=<ENGINE>           Get rendered HTML\n  GET /markdown?url=<URL>                       Get Markdown conversion\n  GET /image?url=<URL>&format=png|jpeg&theme=light|dark  Screenshot\n  GET /archive?url=<URL>&localImages=true&documentFormat=markdown|html  ZIP archive\n  GET /pdf?url=<URL>&theme=light|dark           PDF with embedded images\n  GET /docx?url=<URL>                           DOCX with embedded images\n  GET /fetch?url=<URL>                          Proxy fetch\n  GET /stream?url=<URL>                         Streaming proxy'
+        'API Endpoints (in server mode):\n  GET /html?url=<URL>&engine=<ENGINE>           Get rendered HTML\n  GET /markdown?url=<URL>                       Get Markdown conversion\n  GET /txt?url=<URL>                            Get text content\n  GET /image?url=<URL>&format=png|jpeg&theme=light|dark  Screenshot\n  GET /archive?url=<URL>&localImages=true&documentFormat=markdown|html  ZIP archive\n  GET /pdf?url=<URL>&theme=light|dark           PDF with embedded images\n  GET /docx?url=<URL>                           DOCX with embedded images\n  GET /fetch?url=<URL>                          Proxy fetch\n  GET /stream?url=<URL>                         Streaming proxy'
       )
       .strict(),
   lenv: {
@@ -322,6 +322,7 @@ async function startServer(port) {
       console.log('Available endpoints:');
       console.log(`  GET /html?url=<URL>       - Render page as HTML`);
       console.log(`  GET /markdown?url=<URL>   - Convert page to Markdown`);
+      console.log(`  GET /txt?url=<URL>        - Fetch text content`);
       console.log(`  GET /image?url=<URL>      - Screenshot (PNG/JPEG)`);
       console.log(
         `  GET /archive?url=<URL>    - ZIP archive with markdown + images`
@@ -598,8 +599,12 @@ async function captureUrl(url, options) {
   }
 
   // Import required modules
-  const { fetchHtml, convertToUtf8, convertRelativeUrls } =
-    await import('../src/lib.js');
+  const {
+    fetchHtml,
+    convertToUtf8,
+    convertRelativeUrls,
+    normalizeUrlForTextContent,
+  } = await import('../src/lib.js');
   const { createBrowser } = await import('../src/browser.js');
   const {
     isGoogleDocsUrl,
@@ -915,7 +920,28 @@ async function captureUrl(url, options) {
   }
 
   try {
-    if (normalizedFormat === 'jpeg') {
+    if (normalizedFormat === 'txt' || normalizedFormat === 'text') {
+      const response = await fetch(normalizeUrlForTextContent(absoluteUrl));
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const contentType = response.headers.get('content-type') || 'text/plain';
+      if (!contentType.includes('text/')) {
+        throw new Error(`Expected text content, got ${contentType}`);
+      }
+      const text = await response.text();
+      const output =
+        explicitOutput === '-'
+          ? null
+          : explicitOutput || deriveOutputPath(absoluteUrl, 'txt', dataDir);
+      if (output) {
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, text, 'utf-8');
+        console.error(`Text saved to: ${output}`);
+      } else {
+        process.stdout.write(text);
+      }
+    } else if (normalizedFormat === 'jpeg') {
       // JPEG screenshot
       const { createBrowser } = await import('../src/browser.js');
       const { dismissPopups, scrollToLoadContent } =
@@ -1160,6 +1186,8 @@ async function captureUrl(url, options) {
       normalizedFormat === 'screenshot'
     ) {
       // Image/screenshot format
+      const { dismissPopups, scrollToLoadContent } =
+        await import('../src/popups.js');
       const browser = await createBrowser(engine);
       try {
         const page = await browser.newPage();
@@ -1177,8 +1205,12 @@ async function captureUrl(url, options) {
         });
         // Wait for 5 seconds after page load
         await new Promise((resolve) => setTimeout(resolve, 5000));
+        if (fullPage) {
+          await scrollToLoadContent(page);
+        }
+        await dismissPopups(page);
 
-        const buffer = await page.screenshot({ type: 'png' });
+        const buffer = await page.screenshot({ type: 'png', fullPage });
 
         if (explicitOutput) {
           fs.writeFileSync(explicitOutput, buffer);

package/jest.config.mjs

@@ -13,6 +13,7 @@ export default {
     '**/tests/mock/**/*.test.js',
     '**/tests/e2e/**/*.test.js',
     '**/tests/integration/**/*.test.js',
+    '**/tests/xpaste/**/*.test.js',
   ],
   setupFiles: ['./tests/jest.setup.mjs'],
 };

package/package.json

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

package/src/index.js

@@ -5,6 +5,7 @@ import { markdownHandler } from './markdown.js';
 import { imageHandler } from './image.js';
 import { streamHandler } from './stream.js';
 import { fetchHandler } from './fetch.js';
+import { txtHandler } from './txt.js';
 import { archiveHandler } from './archive.js';
 import { pdfHandler } from './pdf.js';
 import { docxHandler } from './docx.js';
@@ -22,6 +23,7 @@ app.get('/markdown', markdownHandler);
 app.get('/image', imageHandler);
 app.get('/stream', streamHandler);
 app.get('/fetch', fetchHandler);
+app.get('/txt', txtHandler);
 app.get('/archive', archiveHandler);
 app.get('/pdf', pdfHandler);
 app.get('/docx', docxHandler);

package/src/lib.js

@@ -19,6 +19,95 @@ export async function fetchHtml(url) {
   return response.text();
 }
 
+export function isTextPasteUrl(url) {
+  const parsed = parseTextPasteUrl(url);
+  return Boolean(parsed);
+}
+
+export function normalizeUrlForTextContent(url) {
+  const parsed = parseTextPasteUrl(url);
+  if (!parsed) {
+    return url;
+  }
+  return `https://${parsed.host}${parsed.pathPrefix}/p/${parsed.pasteId}/raw`;
+}
+
+export function normalizeUrlForTextPage(url) {
+  const parsed = parseTextPasteUrl(url);
+  if (!parsed) {
+    return url;
+  }
+  return `https://${parsed.host}${parsed.pathPrefix}/p/${parsed.pasteId}`;
+}
+
+export function getTextPasteId(url) {
+  return parseTextPasteUrl(url)?.pasteId || null;
+}
+
+export function getTextPasteFilename(url) {
+  const pasteId = getTextPasteId(url);
+  return pasteId ? `xpaste-pro-${pasteId}.txt` : null;
+}
+
+export function appendTextPasteMarkdownAttachment(markdown, url, rawText) {
+  const textFilename = getTextPasteFilename(url) || 'download.txt';
+  const normalizedRawText = normalizeMarkdownAttachmentText(rawText);
+  const fence = markdownFenceFor(normalizedRawText);
+  const attachmentText = normalizedRawText.endsWith('\n')
+    ? normalizedRawText
+    : `${normalizedRawText}\n`;
+
+  return [
+    markdown.trimEnd(),
+    '',
+    `## ${textFilename}`,
+    '',
+    `${fence}text`,
+    `${attachmentText}${fence}`,
+    '',
+  ].join('\n');
+}
+
+function normalizeMarkdownAttachmentText(text) {
+  return String(text).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function markdownFenceFor(text) {
+  const runs = text.match(/`{3,}/g) || [];
+  const length = runs.reduce((max, run) => Math.max(max, run.length + 1), 3);
+  return '`'.repeat(length);
+}
+
+function parseTextPasteUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.toLowerCase();
+    if (host !== 'xpaste.pro' && host !== 'www.xpaste.pro') {
+      return null;
+    }
+
+    const parts = parsed.pathname.split('/').filter(Boolean);
+    const index = parts.indexOf('p');
+    let pathPrefix = '';
+    if (index === -1 || !parts[index + 1]) {
+      return null;
+    }
+    if (index === 1 && ['en', 'ru'].includes(parts[0])) {
+      pathPrefix = `/${parts[0]}`;
+    } else if (index !== 0) {
+      return null;
+    }
+    const tail = parts.slice(index + 2);
+    if (tail.length > 1 || (tail[0] && tail[0] !== 'raw')) {
+      return null;
+    }
+
+    return { host: 'xpaste.pro', pathPrefix, pasteId: parts[index + 1] };
+  } catch {
+    return null;
+  }
+}
+
 export function convertHtmlToMarkdown(html, baseUrl) {
   // Ensure all URLs are absolute before Markdown conversion
   if (baseUrl) {
@@ -27,6 +116,8 @@ export function convertHtmlToMarkdown(html, baseUrl) {
   // Load HTML into Cheerio
   const $ = cheerio.load(html);
 
+  reorderVisualLayoutElements($);
+
   // Remove <style>, <script>, and <noscript> tags
   $('style, script, noscript').remove();
 
@@ -199,6 +290,20 @@ function coalesceBrRunsToParagraphBreak(markdown) {
   return markdown.replace(/(?: {2,}\n){2,}/g, '\n\n');
 }
 
+function reorderVisualLayoutElements($) {
+  const $header = $('header').first();
+  const $main = $('main').first();
+  const $footer = $('footer').first();
+
+  if ($header.length && $main.length && $header.index() > $main.index()) {
+    $main.before($header);
+  }
+
+  if ($footer.length && $main.length && $footer.index() < $main.index()) {
+    $main.after($footer);
+  }
+}
+
 // Lift <br> nodes out of inline parents when they sit at the leading or
 // trailing edge.
 //
@@ -598,6 +703,8 @@ export function convertHtmlToMarkdownEnhanced(html, baseUrl, options = {}) {
   html = scopeHtmlForMarkdown(html, { contentSelector, bodySelector });
   $ = cheerio.load(html);
 
+  reorderVisualLayoutElements($);
+
   // Remove unwanted elements
   $('style, script, noscript').remove();
   $('*').each(function () {

package/src/markdown.js

@@ -1,10 +1,19 @@
 import {
+  appendTextPasteMarkdownAttachment,
   fetchHtml,
   convertHtmlToMarkdownEnhanced,
+  getTextPasteId,
+  isTextPasteUrl,
+  normalizeUrlForTextContent,
+  normalizeUrlForTextPage,
   scopeHtmlForMarkdown,
 } from './lib.js';
 import { convertWithKreuzberg, isKreuzbergAvailable } from './kreuzberg.js';
 import { applyImageMode } from './extract-images.js';
+import archiver from 'archiver';
+import fetch from 'node-fetch';
+
+const INLINE_MARKDOWN_LINE_LIMIT = 1500;
 
 export async function markdownHandler(req, res) {
   const url = req.query.url;
@@ -29,7 +38,8 @@ export async function markdownHandler(req, res) {
   }
 
   try {
-    const html = await fetchHtml(url);
+    const pageUrl = normalizeUrlForTextPage(url);
+    const html = await fetchHtml(pageUrl);
 
     if (converter === 'kreuzberg') {
       const available = await isKreuzbergAvailable();
@@ -45,7 +55,9 @@ export async function markdownHandler(req, res) {
         contentSelector: req.query.contentSelector,
         bodySelector: req.query.bodySelector,
       });
-      const result = await convertWithKreuzberg(scopedHtml, { baseUrl: url });
+      const result = await convertWithKreuzberg(scopedHtml, {
+        baseUrl: pageUrl,
+      });
       const imageResult = await applyImageMode(result.content, {
         mode: embedImages ? 'embed' : 'default',
       });
@@ -54,10 +66,10 @@ export async function markdownHandler(req, res) {
       if (format === 'json') {
         return res.json(result);
       }
-      return res.type('text/markdown').send(result.content);
+      return await sendMarkdownResponse(res, url, result.content);
     }
 
-    const { markdown } = convertHtmlToMarkdownEnhanced(html, url, {
+    let { markdown } = convertHtmlToMarkdownEnhanced(html, pageUrl, {
       contentSelector: req.query.contentSelector,
       bodySelector: req.query.bodySelector,
     });
@@ -67,9 +79,64 @@ export async function markdownHandler(req, res) {
     const result = await applyImageMode(markdown, {
       mode: embedImages ? 'embed' : 'default',
     });
-    res.type('text/markdown').send(result.markdown);
+    markdown = result.markdown;
+    return await sendMarkdownResponse(res, url, markdown);
   } catch (err) {
     console.error(err);
     res.status(500).send('Error converting to Markdown');
   }
 }
+
+async function sendMarkdownResponse(res, url, markdown) {
+  if (!isTextPasteUrl(url)) {
+    return res.type('text/markdown').send(markdown);
+  }
+
+  const rawText = await fetchRawText(url);
+  const markdownWithText = appendTextPasteMarkdownAttachment(
+    markdown,
+    url,
+    rawText
+  );
+  if (markdownWithText.split('\n').length >= INLINE_MARKDOWN_LINE_LIMIT) {
+    return await sendTextPasteMarkdownArchive(res, url, markdown, rawText);
+  }
+
+  return res.type('text/markdown').send(markdownWithText);
+}
+
+async function sendTextPasteMarkdownArchive(res, url, markdown, rawText) {
+  const pasteId = getTextPasteId(url) || 'paste';
+  const markdownFilename = `xpaste-pro-${pasteId}.md`;
+  const textFilename = `xpaste-pro-${pasteId}.txt`;
+  const lineCount = markdown.split('\n').length;
+
+  res.setHeader('Content-Type', 'application/zip');
+  res.setHeader('Content-Disposition', `attachment; filename="${pasteId}.zip"`);
+
+  const archive = archiver('zip', { zlib: { level: 9 } });
+  archive.pipe(res);
+  archive.append(
+    [
+      `# ${url}`,
+      '',
+      `Content from: ${url}`,
+      '',
+      `The page markdown is available in [${markdownFilename}](${markdownFilename}) (${lineCount} lines).`,
+      `The raw text content is available in [${textFilename}](${textFilename}).`,
+      '',
+    ].join('\n'),
+    { name: 'index.md' }
+  );
+  archive.append(markdown, { name: markdownFilename });
+  archive.append(rawText, { name: textFilename });
+  await archive.finalize();
+}
+
+async function fetchRawText(url) {
+  const response = await fetch(normalizeUrlForTextContent(url));
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return response.text();
+}

package/src/txt.js

@@ -0,0 +1,60 @@
+import fetch from 'node-fetch';
+import { URL } from 'node:url';
+import { getTextPasteFilename, normalizeUrlForTextContent } from './lib.js';
+
+export async function txtHandler(req, res) {
+  const url = req.query.url;
+  if (!url) {
+    return res.status(400).send('Missing `url` parameter');
+  }
+
+  try {
+    // Normalize URL to get text content (e.g., xpaste.pro -> xpaste.pro/raw)
+    const textUrl = normalizeUrlForTextContent(url);
+
+    const response = await fetch(textUrl);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const contentType = response.headers.get('content-type') || 'text/plain';
+
+    // Only accept text content types
+    if (!contentType.includes('text/')) {
+      throw new Error(`Expected text content, got ${contentType}`);
+    }
+
+    const text = await response.text();
+
+    // Set appropriate headers for text file download
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename="${getFilenameFromUrl(url)}"`
+    );
+    res.send(text);
+  } catch (err) {
+    console.error('Text fetch error:', err);
+    res.status(500).send('Error fetching text content');
+  }
+}
+
+function getFilenameFromUrl(url) {
+  const textPasteFilename = getTextPasteFilename(url);
+  if (textPasteFilename) {
+    return textPasteFilename;
+  }
+
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname.replace(/\./g, '-');
+    const path = urlObj.pathname
+      .replace(/\//g, '-')
+      .replace(/^-/, '')
+      .replace(/-raw$/, '');
+    return `${hostname}${path}.txt`;
+  } catch {
+    return 'download.txt';
+  }
+}

package/tests/integration/wikipedia-download.test.js

@@ -0,0 +1,142 @@
+/**
+ * Integration tests for downloading the Wikipedia page (issue #8).
+ *
+ * Verifies that web-capture can actually download the Wikipedia article about
+ * Wikipedia itself (https://en.wikipedia.org/wiki/Wikipedia) as both Markdown
+ * and an image (PNG screenshot) using every supported browser engine
+ * (Puppeteer and Playwright).
+ *
+ * These tests hit the live Wikipedia servers. Set WIKIPEDIA_INTEGRATION=true to
+ * run them. In CI they are enabled via the workflow environment variable. When
+ * the variable is unset the suite is skipped so default/offline runs stay
+ * deterministic.
+ *
+ * Navigation uses retry with exponential backoff to absorb transient network
+ * failures, mirroring the Habr integration suite.
+ */
+
+import { jest } from '@jest/globals';
+import { createBrowser } from '../../src/browser.js';
+import { convertHtmlToMarkdown } from '../../src/lib.js';
+import { retry } from '../../src/retry.js';
+
+const WIKIPEDIA_URL = 'https://en.wikipedia.org/wiki/Wikipedia';
+
+// PNG magic number (89 50 4E 47 0D 0A 1A 0A).
+const PNG_SIGNATURE = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+
+const SKIP_LIVE =
+  !process.env.WIKIPEDIA_INTEGRATION ||
+  process.env.WIKIPEDIA_INTEGRATION === 'false';
+const describeIfLive = SKIP_LIVE ? describe.skip : describe;
+
+// These tests hit live servers and may take a while.
+jest.setTimeout(120000);
+
+// Navigate with retry + exponential backoff, then give the page a moment to
+// settle so late-loading content and images are present before we capture.
+async function navigateWithRetry(page, url) {
+  await retry(
+    async () => {
+      await page.goto(url, {
+        waitUntil: 'networkidle0',
+        timeout: 60000,
+      });
+    },
+    {
+      retries: 3,
+      baseDelay: 2000,
+      onRetry: (err, attempt, delay) => {
+        console.log(
+          `Navigation retry ${attempt} for ${url} after ${delay}ms: ${err.message}`
+        );
+      },
+    }
+  );
+  await new Promise((resolve) => setTimeout(resolve, 5000));
+}
+
+// Run the full matrix (Markdown + image) once per supported engine.
+describe.each(['puppeteer', 'playwright'])(
+  'Wikipedia Page Download (%s engine)',
+  (engine) => {
+    describeIfLive(`${engine}`, () => {
+      let browser;
+      let page;
+
+      beforeAll(async () => {
+        browser = await createBrowser(engine);
+        page = await browser.newPage();
+        await page.setViewport({ width: 1280, height: 800 });
+        await navigateWithRetry(page, WIKIPEDIA_URL);
+      });
+
+      afterAll(async () => {
+        if (browser) {
+          await browser.close();
+        }
+      });
+
+      it('downloads the Wikipedia page as Markdown', async () => {
+        const html = await page.content();
+        expect(html).toMatch(/<html/i);
+        expect(html.length).toBeGreaterThan(1000);
+
+        const markdown = convertHtmlToMarkdown(html, WIKIPEDIA_URL);
+
+        // Markdown should carry the page's real content...
+        expect(markdown).toContain('Wikipedia');
+        expect(markdown.length).toBeGreaterThan(500);
+        // ...and should contain markdown structure (headings and/or links)...
+        expect(markdown).toMatch(/(^#{1,6}\s)|(\[.*?\]\(.*?\))/m);
+        // ...but no longer be raw HTML document scaffolding.
+        expect(markdown).not.toMatch(/<html/i);
+        expect(markdown).not.toMatch(/<head[\s>]/i);
+      });
+
+      it('downloads the Wikipedia page as an image (PNG screenshot)', async () => {
+        const screenshot = await page.screenshot({ type: 'png' });
+
+        expect(screenshot).toBeInstanceOf(Buffer);
+        expect(screenshot.length).toBeGreaterThan(1000);
+        // Verify the PNG signature so we know it is a real image.
+        expect(screenshot.slice(0, 8)).toEqual(PNG_SIGNATURE);
+      });
+    });
+  }
+);
+
+describeIfLive('Wikipedia Page Download (engine parity)', () => {
+  it('both engines download Markdown and an image for the Wikipedia page', async () => {
+    const engines = ['puppeteer', 'playwright'];
+    const results = [];
+
+    for (const engine of engines) {
+      const browser = await createBrowser(engine);
+      try {
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1280, height: 800 });
+        await navigateWithRetry(page, WIKIPEDIA_URL);
+
+        const html = await page.content();
+        const markdown = convertHtmlToMarkdown(html, WIKIPEDIA_URL);
+        const screenshot = await page.screenshot({ type: 'png' });
+
+        results.push({ engine, markdown, screenshot });
+      } finally {
+        await browser.close();
+      }
+    }
+
+    for (const { markdown, screenshot } of results) {
+      // Markdown captured from both engines.
+      expect(markdown).toContain('Wikipedia');
+      expect(markdown.length).toBeGreaterThan(500);
+      // Image captured from both engines.
+      expect(screenshot.slice(0, 8)).toEqual(PNG_SIGNATURE);
+      expect(screenshot.length).toBeGreaterThan(1000);
+    }
+  }, 180000);
+});