@link-assistant/web-capture 1.10.1 → 1.10.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

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                 |

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.1",
+  "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/xpaste/xpaste-screenshot-markdown.mock.test.js

@@ -0,0 +1,375 @@
+/**
+ * Integration tests to verify that markdown extraction from xpaste.pro
+ * includes ALL text visible in screenshots of the same page
+ *
+ * This ensures 100% coverage of visual content extraction as required in issue #15
+ */
+
+import request from 'supertest';
+import nock from 'nock';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let app;
+
+beforeAll(async () => {
+  app = (await import('../../src/index.js')).app;
+});
+
+describe('xpaste.pro screenshot-to-markdown content matching', () => {
+  beforeEach(() => {
+    nock.cleanAll();
+  });
+
+  describe('GET /markdown for t4q0Lsp0', () => {
+    const testUrl = 'https://xpaste.pro/p/t4q0Lsp0';
+
+    // Load the actual HTML page content that was saved
+    const htmlPath = path.join(
+      __dirname,
+      '../../../tests/xpaste/data/t4q0Lsp0-page.html'
+    );
+    const rawTextPath = path.join(
+      __dirname,
+      '../../../tests/xpaste/data/t4q0Lsp0-actual-content.txt'
+    );
+    let testHtml;
+    let rawText;
+
+    beforeAll(() => {
+      if (fs.existsSync(htmlPath)) {
+        testHtml = fs.readFileSync(htmlPath, 'utf-8');
+      }
+      if (fs.existsSync(rawTextPath)) {
+        rawText = fs.readFileSync(rawTextPath, 'utf-8');
+      }
+    });
+
+    beforeEach(() => {
+      if (rawText) {
+        nock('https://xpaste.pro')
+          .persist()
+          .get('/p/t4q0Lsp0/raw')
+          .reply(200, rawText, {
+            'content-type': 'text/plain; charset=utf-8',
+          });
+      }
+    });
+
+    it('should include all header/metadata text visible in screenshot', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/markdown');
+
+      // Verify page title/branding (top of screenshot)
+      expect(response.text).toContain('Xpaste');
+      expect(response.text).toContain('xPaste');
+
+      // Verify metadata section (visible in screenshot)
+      expect(response.text).toContain('Формат');
+      expect(response.text).toContain('text');
+      expect(response.text).toContain('Время создания');
+      expect(response.text).toContain('07.07.2021');
+      expect(response.text).toContain('12:48 UTC');
+      expect(response.text).toContain('Будет удалена');
+      expect(response.text).toContain('05.07.2031');
+    });
+
+    it('should include all SQL query content visible in screenshot', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      // Verify all 4 SQL queries visible in screenshot are present
+
+      // Query #1 metadata (lines 1-8 in screenshot)
+      expect(response.text).toContain('# 1');
+      expect(response.text).toContain('Time: 210707 15:39:36');
+      expect(response.text).toMatch(
+        /User@Host:\s+1703313381\[1703313381\]\s+@\s+\[136\.243\.53\.188\]/
+      );
+      expect(response.text).toContain('Id: 1138102510');
+      expect(response.text).toContain('Schema: xxxxxx');
+      expect(response.text).toContain('Query_time: 2.182754');
+      expect(response.text).toContain('Rows_examined: 324036');
+
+      // Query #2 metadata (lines 19-28 in screenshot)
+      expect(response.text).toContain('# 2');
+      expect(response.text).toContain('Time: 210707 15:38:11');
+      expect(response.text).toContain('Id: 1138100591');
+      expect(response.text).toContain('Query_time: 9.259469');
+      expect(response.text).toContain('DELETE FROM phpbb_post_revisions');
+      expect(response.text).toContain('WHERE post_id = 10472158');
+
+      // Query #3 metadata (lines 30-46 in screenshot)
+      expect(response.text).toContain('# 3');
+      expect(response.text).toContain('Time: 210707 15:32:18');
+      expect(response.text).toContain('Id: 1138094492');
+      expect(response.text).toContain('Query_time: 1.113014');
+      expect(response.text).toContain('Rows_examined: 521597');
+
+      // Query #4 metadata (lines 48-64 in screenshot)
+      expect(response.text).toContain('# 4');
+      expect(response.text).toContain('Time: 210707 15:27:56');
+      expect(response.text).toContain('Id: 1138089558');
+      expect(response.text).toContain('Query_time: 4.682828');
+      expect(response.text).toContain('Rows_examined: 2457916');
+
+      // Verify SQL statements contain key elements
+      expect(response.text).toContain('SELECT f.*, t.*, p.*, u.*');
+      expect(response.text).toContain('phpbb_posts');
+      expect(response.text).toContain('phpbb_users');
+      expect(response.text).toContain('phpbb_topics');
+      expect(response.text).toContain('phpbb_forums');
+    });
+
+    it('should include all footer text visible in screenshot', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      // Verify footer elements (bottom of screenshot)
+      expect(response.text).toContain('xPaste');
+      expect(response.text).toContain('Упакуем пароль или код в');
+      expect(response.text).toMatch(/cсылку для передачи/); // Note: 'c' can be different Unicode char
+      expect(response.text).toContain('Сделано в');
+      expect(response.text).toContain('Southbridge');
+      expect(response.text).toContain('Справка');
+      expect(response.text).toContain('Политика конфиденциальности');
+    });
+
+    it('should include language selector links visible in screenshot', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      // Verify language links (top right of screenshot)
+      expect(response.text).toContain('Ru');
+      expect(response.text).toContain('En');
+    });
+
+    it('should include RAW link visible in screenshot', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      // Verify RAW button (visible in screenshot)
+      expect(response.text).toContain('RAW');
+    });
+
+    it('should embed the raw text file as a markdown text block', async () => {
+      if (!testHtml || !rawText) {
+        console.warn('Skipping test - fixture files not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/markdown');
+      expect(response.text).toContain('## xpaste-pro-t4q0Lsp0.txt');
+      expect(response.text).toContain('```text');
+      expect(response.text).toContain(
+        rawText.split('\n')[0].replace(/\r/g, '')
+      );
+      expect(response.text).toContain('DELETE FROM phpbb_post_revisions');
+    });
+
+    it('should verify correct element ordering - heading and languages at top', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      const lines = response.text.split('\n');
+
+      // Find line numbers of key elements
+      const headingLine = lines.findIndex((l) => l.includes('Упакуем пароль'));
+      const languageLine = lines.findIndex(
+        (l) => l.includes('[Ru]') || l.includes('[En]')
+      );
+      const formatLine = lines.findIndex((l) => l.includes('Формат:'));
+      const firstQueryLine = lines.findIndex(
+        (l) => l.includes('# 1') && l.includes('#')
+      );
+
+      // Verify heading comes before metadata (as shown in screenshot)
+      expect(headingLine).toBeGreaterThan(0);
+      expect(headingLine).toBeLessThan(formatLine);
+
+      // Verify languages come before metadata (as shown in screenshot)
+      expect(languageLine).toBeGreaterThan(0);
+      expect(languageLine).toBeLessThan(formatLine);
+
+      // Verify heading comes before main content
+      expect(headingLine).toBeLessThan(firstQueryLine);
+
+      // Verify metadata comes before main content
+      expect(formatLine).toBeLessThan(firstQueryLine);
+
+      console.log(
+        `✓ Element ordering verified: heading (line ${headingLine + 1}) -> languages (line ${languageLine + 1}) -> metadata (line ${formatLine + 1}) -> content (line ${firstQueryLine + 1})`
+      );
+    });
+
+    it('should verify markdown extraction matches screenshot - comprehensive check', async () => {
+      if (!testHtml) {
+        console.warn('Skipping test - HTML file not found');
+        return;
+      }
+
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+
+      // Define all key text elements visible in the screenshot
+      const requiredElements = [
+        // Header/branding
+        'Xpaste',
+
+        // Metadata section
+        'Формат:',
+        'text',
+        'Время создания:',
+        '07.07.2021, 12:48 UTC',
+        'Будет удалена:',
+        '05.07.2031, 12:48 UTC',
+
+        // Query #1
+        '# 1',
+        'Time: 210707 15:39:36',
+        'User@Host: 1703313381[1703313381]',
+        '[136.243.53.188]',
+        'Id: 1138102510',
+        'Query_time: 2.182754',
+
+        // Query #2
+        '# 2',
+        'Time: 210707 15:38:11',
+        'Id: 1138100591',
+        'DELETE FROM phpbb_post_revisions',
+
+        // Query #3
+        '# 3',
+        'Time: 210707 15:32:18',
+        'Id: 1138094492',
+
+        // Query #4
+        '# 4',
+        'Time: 210707 15:27:56',
+        'Id: 1138089558',
+
+        // Footer
+        'Упакуем пароль',
+        'Southbridge',
+        'Справка',
+        'Политика конфиденциальности',
+
+        // Language links
+        'Ru',
+        'En',
+
+        // RAW button
+        'RAW',
+      ];
+
+      // Verify ALL elements are present
+      const missingElements = [];
+      requiredElements.forEach((element) => {
+        if (!response.text.includes(element)) {
+          missingElements.push(element);
+        }
+      });
+
+      expect(missingElements).toEqual([]);
+
+      // Log success with coverage stats
+      if (missingElements.length === 0) {
+        console.log(
+          `✓ All ${requiredElements.length} screenshot text elements found in markdown`
+        );
+      }
+    });
+  });
+});

package/tests/xpaste/xpaste.e2e.test.js

@@ -0,0 +1,36 @@
+import getPort from 'get-port';
+import nock from 'nock';
+import { app } from '../../src/index.js';
+
+describe('xpaste.pro HTTP e2e', () => {
+  let server;
+
+  afterEach(async () => {
+    nock.cleanAll();
+    if (server) {
+      await new Promise((resolve) => server.close(resolve));
+      server = null;
+    }
+  });
+
+  it('serves raw paste text through the real HTTP server', async () => {
+    const pasteText = 'console.log("xpaste fixture");\n';
+    nock('https://xpaste.pro')
+      .get('/p/js123/raw')
+      .reply(200, pasteText, { 'content-type': 'text/plain; charset=utf-8' });
+
+    const port = await getPort();
+    server = app.listen(port);
+
+    const response = await fetch(
+      `http://127.0.0.1:${port}/txt?url=${encodeURIComponent('https://xpaste.pro/p/js123')}`
+    );
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get('content-type')).toMatch(/text\/plain/);
+    expect(response.headers.get('content-disposition')).toContain(
+      'xpaste-pro-js123.txt'
+    );
+    expect(await response.text()).toBe(pasteText);
+  });
+});

package/tests/xpaste/xpaste.integration.test.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { convertHtmlToMarkdownEnhanced } from '../../src/lib.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = path.join(__dirname, '../../../tests/xpaste/data');
+
+describe('xpaste.pro fixture integration', () => {
+  it('converts the captured page fixture with the same visual ordering as the screenshot', () => {
+    const html = fs.readFileSync(
+      path.join(DATA_DIR, 't4q0Lsp0-page.html'),
+      'utf-8'
+    );
+    const { markdown } = convertHtmlToMarkdownEnhanced(
+      html,
+      'https://xpaste.pro/p/t4q0Lsp0',
+      {
+        extractMetadata: false,
+        postProcess: false,
+      }
+    );
+
+    const headingIndex = markdown.indexOf('Упакуем пароль');
+    const languageIndexes = ['[Ru]', '[En]']
+      .map((label) => markdown.indexOf(label))
+      .filter((index) => index >= 0);
+    const languageIndex = Math.min(...languageIndexes);
+    const formatIndex = markdown.indexOf('Формат:');
+    const firstQueryIndex = markdown.indexOf('# 1');
+
+    expect(headingIndex).toBeGreaterThanOrEqual(0);
+    expect(languageIndexes).not.toHaveLength(0);
+    expect(languageIndex).toBeGreaterThanOrEqual(0);
+    expect(formatIndex).toBeGreaterThanOrEqual(0);
+    expect(firstQueryIndex).toBeGreaterThanOrEqual(0);
+    expect(headingIndex).toBeLessThan(formatIndex);
+    expect(languageIndex).toBeLessThan(formatIndex);
+    expect(formatIndex).toBeLessThan(firstQueryIndex);
+  });
+});

package/tests/xpaste/xpaste.mock.test.js

@@ -0,0 +1,261 @@
+import request from 'supertest';
+import nock from 'nock';
+import { jest } from '@jest/globals';
+import unzipper from 'unzipper';
+
+let app;
+
+beforeAll(async () => {
+  app = (await import('../../src/index.js')).app;
+});
+
+describe('xpaste.pro integration tests', () => {
+  beforeEach(() => {
+    nock.cleanAll();
+    jest.clearAllMocks();
+  });
+
+  describe('GET /txt with xpaste.pro URL', () => {
+    const testUrl = 'https://xpaste.pro/p/t4q0Lsp0';
+    // Using actual data from https://xpaste.pro/p/t4q0Lsp0 (captured on 2025-11-14)
+    const testText = `# 1
+#
+# Time: 210707 15:39:36
+# User@Host: 1703313381[1703313381] @  [136.243.53.188]  Id: 1138102510
+# Schema: xxxxxx  Last_errno: 0  Killed: 0
+# Query_time: 2.182754  Lock_time: 0.000120  Rows_sent: 0  Rows_examined: 324036  Rows_affected: 0
+# Bytes_sent: 20494
+SET timestamp=1625661576;
+SELECT f.*, t.*, p.*, u.*, tt.mark_time AS topic_mark_time, ft.mark_time AS forum_mark_time FROM (phpbb_posts p CROSS JOIN phpbb_users u CROSS JOIN phpbb_topics t) LEFT JOIN phpbb_forums f ON (t.forum_id = f.forum_id) LEFT JOIN phpbb_topics_track tt ON (t.topic_id = tt.topic_id AND tt.user_id = 659822) LEFT JOIN phpbb_forums_track ft ON (f.forum_id = ft.forum_id AND ft.user_id = 659822) WHERE p.topic_id = t.topic_id
+				AND p.poster_id = u.user_id
+				 AND p.post_time > 1625660099
+				 AND p.forum_id = 326
+
+
+
+				AND p.post_approved = 1 ORDER BY t.topic_last_post_time DESC, p.post_time
+ LIMIT 100;`;
+
+    it('should fetch and return text content from xpaste.pro', async () => {
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0/raw')
+        .reply(200, testText, { 'content-type': 'text/plain; charset=utf-8' });
+
+      const response = await request(app).get('/txt').query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/plain');
+      expect(response.text).toBe(testText);
+      expect(response.headers['content-disposition']).toContain('attachment');
+      expect(response.headers['content-disposition']).toContain('.txt');
+    });
+
+    it('should return 400 when URL is missing', async () => {
+      const response = await request(app).get('/txt');
+
+      expect(response.status).toBe(400);
+      expect(response.text).toBe('Missing `url` parameter');
+    });
+
+    it('should return 500 when fetch fails', async () => {
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0/raw')
+        .replyWithError('Network error');
+
+      const response = await request(app).get('/txt').query({ url: testUrl });
+
+      expect(response.status).toBe(500);
+      expect(response.text).toBe('Error fetching text content');
+    });
+  });
+
+  describe('GET /markdown with xpaste.pro URL (small content)', () => {
+    const testUrl = 'https://xpaste.pro/p/t4q0Lsp0';
+    const rawText = `# 1
+#
+# Time: 210707 15:39:36
+SET timestamp=1625661576;
+SELECT * FROM phpbb_posts WHERE topic_id = 123;`;
+    // Mock HTML that resembles actual xpaste.pro page structure
+    const testHtml = `<!DOCTYPE html>
+<html>
+<head><title>xPaste</title></head>
+<body>
+  <h1>Xpaste</h1>
+  <div>
+    <strong>Формат:</strong> text<br>
+    <strong>Время создания:</strong> 07.07.2021, 12:48 UTC<br>
+    <strong>Будет удалена:</strong> 05.07.2031, 12:48 UTC
+  </div>
+  <pre># 1
+#
+# Time: 210707 15:39:36
+# User@Host: 1703313381[1703313381] @  [136.243.53.188]  Id: 1138102510
+# Schema: xxxxxx  Last_errno: 0  Killed: 0
+# Query_time: 2.182754  Lock_time: 0.000120  Rows_sent: 0  Rows_examined: 324036  Rows_affected: 0
+SET timestamp=1625661576;
+SELECT * FROM phpbb_posts WHERE topic_id = 123;</pre>
+  <footer>
+    <a href="https://xpaste.pro/">xPaste</a>
+    <p>Упакуем пароль или код в cсылку для передачи</p>
+    <p>Сделано в <a href="https://southbridge.io/">Southbridge</a></p>
+  </footer>
+</body>
+</html>`;
+
+    it('should convert HTML to markdown with all page elements when content is less than 1500 lines', async () => {
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0/raw')
+        .reply(200, rawText, { 'content-type': 'text/plain; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/markdown');
+
+      // Verify it includes page metadata (visible in screenshot)
+      expect(response.text).toContain('Xpaste');
+      expect(response.text).toContain('Формат:');
+      expect(response.text).toContain('text');
+      expect(response.text).toContain('07.07.2021');
+
+      // Verify it includes the SQL query content
+      expect(response.text).toContain('1703313381');
+      // Note: markdown escapes special characters like * and _
+      expect(response.text).toMatch(/SELECT.*FROM phpbb.*posts/);
+
+      // Verify it includes footer elements (visible in screenshot)
+      expect(response.text).toContain('Southbridge');
+      expect(response.text).toContain('Упакуем пароль или код');
+
+      // Verify the raw text file is embedded as a named markdown block.
+      expect(response.text).toContain('## xpaste-pro-t4q0Lsp0.txt');
+      expect(response.text).toContain('```text\n# 1\n#');
+    });
+
+    it('should normalize raw xpaste URLs before markdown conversion', async () => {
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0')
+        .reply(200, testHtml, { 'content-type': 'text/html; charset=utf-8' });
+      nock('https://xpaste.pro')
+        .get('/p/t4q0Lsp0/raw')
+        .reply(200, rawText, { 'content-type': 'text/plain; charset=utf-8' });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: `${testUrl}/raw` });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/markdown');
+      expect(response.text).toContain('Формат:');
+      expect(response.text).toContain('## xpaste-pro-t4q0Lsp0.txt');
+    });
+  });
+
+  describe('GET /markdown with xpaste.pro URL (large content)', () => {
+    const testUrl = 'https://xpaste.pro/p/largefile';
+
+    it('should create a zip archive when content is 1500 lines or more', async () => {
+      // Create HTML content that will result in exactly 1500 lines of markdown
+      const largeContent = Array(1480).fill('<p>Line of text</p>').join('\n');
+      const largeHtml = `<!DOCTYPE html>
+<html><head><title>Large File</title></head><body>${largeContent}</body></html>`;
+
+      nock('https://xpaste.pro')
+        .get('/p/largefile')
+        .reply(200, largeHtml, { 'content-type': 'text/html; charset=utf-8' });
+      nock('https://xpaste.pro')
+        .get('/p/largefile/raw')
+        .reply(200, largeContent.replace(/<\/?p>/g, ''), {
+          'content-type': 'text/plain; charset=utf-8',
+        });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl })
+        .buffer(true)
+        .parse((res, callback) => {
+          const chunks = [];
+          res.on('data', (chunk) => chunks.push(chunk));
+          res.on('end', () => callback(null, Buffer.concat(chunks)));
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('application/zip');
+      expect(response.headers['content-disposition']).toContain('attachment');
+      expect(response.headers['content-disposition']).toContain(
+        'largefile.zip'
+      );
+
+      const dir = await unzipper.Open.buffer(response.body);
+      const names = dir.files.map((file) => file.path);
+      expect(names).toEqual(
+        expect.arrayContaining([
+          'index.md',
+          'xpaste-pro-largefile.md',
+          'xpaste-pro-largefile.txt',
+        ])
+      );
+
+      const index = await dir.files
+        .find((file) => file.path === 'index.md')
+        .buffer();
+      const rawTextFile = await dir.files
+        .find((file) => file.path === 'xpaste-pro-largefile.txt')
+        .buffer();
+      expect(index.toString()).toContain(
+        '[xpaste-pro-largefile.txt](xpaste-pro-largefile.txt)'
+      );
+      expect(rawTextFile.toString()).toContain('Line of text');
+    });
+
+    it('should create a zip archive for content with more than 1500 lines', async () => {
+      // Create HTML content that will result in more than 1500 lines of markdown
+      const largeContent = Array(1600).fill('<p>Line of text</p>').join('\n');
+      const largeHtml = `<!DOCTYPE html>
+<html><head><title>Large File</title></head><body>${largeContent}</body></html>`;
+
+      nock('https://xpaste.pro')
+        .get('/p/largefile')
+        .reply(200, largeHtml, { 'content-type': 'text/html; charset=utf-8' });
+      nock('https://xpaste.pro')
+        .get('/p/largefile/raw')
+        .reply(200, largeContent.replace(/<\/?p>/g, ''), {
+          'content-type': 'text/plain; charset=utf-8',
+        });
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('application/zip');
+    });
+  });
+
+  describe('GET /markdown with non-xpaste.pro URL', () => {
+    const testUrl = 'https://example.com';
+    const testHtml =
+      '<html><body><h1>Test Page</h1><p>Regular HTML content</p></body></html>';
+
+    it('should process regular HTML URLs normally', async () => {
+      nock(testUrl).get('/').reply(200, testHtml);
+
+      const response = await request(app)
+        .get('/markdown')
+        .query({ url: testUrl });
+
+      expect(response.status).toBe(200);
+      expect(response.type).toBe('text/markdown');
+      expect(response.text).toContain('Test Page');
+      expect(response.text).toContain('Regular HTML content');
+      // Should not be a zip file
+      expect(response.headers['content-type']).not.toBe('application/zip');
+    });
+  });
+});

package/tests/xpaste/xpaste.unit.test.js

@@ -0,0 +1,119 @@
+import {
+  appendTextPasteMarkdownAttachment,
+  getTextPasteFilename,
+  isTextPasteUrl,
+  normalizeUrlForTextContent,
+  normalizeUrlForTextPage,
+} from '../../src/lib.js';
+
+describe('xpaste.pro URL handling utilities', () => {
+  describe('normalizeUrlForTextContent', () => {
+    it('should convert xpaste.pro URL to raw endpoint', () => {
+      const url = 'https://xpaste.pro/p/t4q0Lsp0';
+      const normalized = normalizeUrlForTextContent(url);
+      expect(normalized).toBe('https://xpaste.pro/p/t4q0Lsp0/raw');
+    });
+
+    it('should convert localized xpaste.pro URLs to localized raw endpoints', () => {
+      expect(
+        normalizeUrlForTextContent('https://xpaste.pro/ru/p/t4q0Lsp0')
+      ).toBe('https://xpaste.pro/ru/p/t4q0Lsp0/raw');
+      expect(
+        normalizeUrlForTextContent('https://xpaste.pro/en/p/t4q0Lsp0')
+      ).toBe('https://xpaste.pro/en/p/t4q0Lsp0/raw');
+    });
+
+    it('should not modify xpaste.pro URL that already has /raw', () => {
+      const url = 'https://xpaste.pro/p/t4q0Lsp0/raw';
+      const normalized = normalizeUrlForTextContent(url);
+      expect(normalized).toBe('https://xpaste.pro/p/t4q0Lsp0/raw');
+    });
+
+    it('should not modify non-xpaste.pro URLs', () => {
+      const url = 'https://example.com/page';
+      const normalized = normalizeUrlForTextContent(url);
+      expect(normalized).toBe(url);
+    });
+
+    it('should handle invalid URLs gracefully', () => {
+      const url = 'not-a-valid-url';
+      const normalized = normalizeUrlForTextContent(url);
+      expect(normalized).toBe(url);
+    });
+  });
+
+  describe('normalizeUrlForTextPage', () => {
+    it('should convert xpaste.pro raw URLs back to visual page URLs', () => {
+      expect(normalizeUrlForTextPage('https://xpaste.pro/p/t4q0Lsp0/raw')).toBe(
+        'https://xpaste.pro/p/t4q0Lsp0'
+      );
+      expect(
+        normalizeUrlForTextPage('https://xpaste.pro/ru/p/t4q0Lsp0/raw')
+      ).toBe('https://xpaste.pro/ru/p/t4q0Lsp0');
+    });
+
+    it('should not modify non-xpaste.pro URLs', () => {
+      const url = 'https://example.com/page';
+      expect(normalizeUrlForTextPage(url)).toBe(url);
+    });
+  });
+
+  describe('isTextPasteUrl', () => {
+    it('should return true for xpaste.pro paste URLs', () => {
+      expect(isTextPasteUrl('https://xpaste.pro/p/t4q0Lsp0')).toBe(true);
+      expect(isTextPasteUrl('https://xpaste.pro/p/abc123')).toBe(true);
+      expect(isTextPasteUrl('https://xpaste.pro/ru/p/t4q0Lsp0')).toBe(true);
+      expect(isTextPasteUrl('https://xpaste.pro/en/p/t4q0Lsp0')).toBe(true);
+    });
+
+    it('should return false for non-xpaste.pro URLs', () => {
+      expect(isTextPasteUrl('https://example.com')).toBe(false);
+      expect(isTextPasteUrl('https://pastebin.com/xyz')).toBe(false);
+    });
+
+    it('should return false for xpaste.pro URLs without /p/ path', () => {
+      expect(isTextPasteUrl('https://xpaste.pro')).toBe(false);
+      expect(isTextPasteUrl('https://xpaste.pro/about')).toBe(false);
+      expect(isTextPasteUrl('https://xpaste.pro/foo/p/t4q0Lsp0')).toBe(false);
+      expect(isTextPasteUrl('https://xpaste.pro/p/t4q0Lsp0/raw/extra')).toBe(
+        false
+      );
+    });
+
+    it('should return false for invalid URLs', () => {
+      expect(isTextPasteUrl('not-a-url')).toBe(false);
+    });
+  });
+
+  describe('getTextPasteFilename', () => {
+    it('should derive a canonical text filename for paste URLs', () => {
+      expect(getTextPasteFilename('https://xpaste.pro/p/t4q0Lsp0')).toBe(
+        'xpaste-pro-t4q0Lsp0.txt'
+      );
+      expect(getTextPasteFilename('https://xpaste.pro/ru/p/t4q0Lsp0/raw')).toBe(
+        'xpaste-pro-t4q0Lsp0.txt'
+      );
+    });
+
+    it('should return null for non-paste URLs', () => {
+      expect(getTextPasteFilename('https://example.com/page')).toBeNull();
+    });
+  });
+
+  describe('appendTextPasteMarkdownAttachment', () => {
+    it('should embed raw text as a named fenced attachment block', () => {
+      const markdown = '# Page\n\nVisible content';
+      const rawText = 'first line\n```inside paste```\nlast line';
+      const result = appendTextPasteMarkdownAttachment(
+        markdown,
+        'https://xpaste.pro/p/t4q0Lsp0',
+        rawText
+      );
+
+      expect(result).toContain('## xpaste-pro-t4q0Lsp0.txt');
+      expect(result).toContain(
+        '````text\nfirst line\n```inside paste```\nlast line\n````'
+      );
+    });
+  });
+});