@link-assistant/web-capture 1.10.4 → 1.10.6

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

@@ -0,0 +1,144 @@
+/**
+ * Integration test for converting the DeepWiki search page from issue #17.
+ *
+ * The page is JavaScript-rendered, so this suite verifies the /markdown
+ * endpoint captures rendered content instead of the initial Next.js shell.
+ *
+ * Set DEEPWIKI_INTEGRATION=true to run it. The suite is skipped by default so
+ * local/offline test runs remain deterministic.
+ */
+
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+import request from 'supertest';
+import { fileURLToPath } from 'url';
+import { app } from '../../src/index.js';
+import { retry } from '../../src/retry.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEEPWIKI_URL =
+  'https://deepwiki.com/search/-57-4-23-57_0e4aa687-7a9d-4591-8c6f-67c4b2d732f6';
+const FIXTURE_DIR = path.join(__dirname, '..', 'fixtures', 'deepwiki');
+const INLINE_MARKDOWN_LINE_LIMIT = 1500;
+const PNG_SIGNATURE = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+const ORDERED_CONTENT_MARKERS = [
+  'Search | DeepWiki',
+  'deep-assistant/hive-mind',
+  'расскажи пожалуйста на английском',
+  'Deep\n\nThought Process',
+  '# Hive Mind: A Comprehensive Overview of an AI Agent System for Software Development',
+  '## Executive Summary',
+  '## I. Foundational Philosophy: Human-AI Collaboration Model',
+  '## II. Architectural Layers: The Three-Tier Design',
+  '## III. Original Ideas and Innovations',
+  'Innovation 1: The Task Clarification System',
+  'Innovation 2: Multi-Dimensional Feedback Detection',
+  'Innovation 3: Thinking Depth Control',
+  '## IV. The Workflow Logic: How Everything Connects',
+  '## XI. Practical Implications: What This Enables',
+];
+
+const SKIP_LIVE =
+  !process.env.DEEPWIKI_INTEGRATION ||
+  process.env.DEEPWIKI_INTEGRATION === 'false';
+const describeIfLive = SKIP_LIVE ? describe.skip : describe;
+
+jest.setTimeout(180000);
+
+function readFixtureChunks() {
+  return ['index.md', 'part-1.md'].map((filename) =>
+    fs.readFileSync(path.join(FIXTURE_DIR, filename), 'utf8')
+  );
+}
+
+function splitMarkdown(markdown) {
+  const lines = markdown.split('\n');
+  const chunks = [];
+  for (
+    let index = 0;
+    index < lines.length;
+    index += INLINE_MARKDOWN_LINE_LIMIT
+  ) {
+    chunks.push(
+      lines.slice(index, index + INLINE_MARKDOWN_LINE_LIMIT).join('\n')
+    );
+  }
+  return chunks;
+}
+
+function expectMarkersInOrder(markdown, markers) {
+  let previousIndex = -1;
+  for (const marker of markers) {
+    const index = markdown.indexOf(marker);
+    expect(index).toBeGreaterThan(previousIndex);
+    previousIndex = index;
+  }
+}
+
+async function getDeepwikiMarkdown() {
+  const response = await retry(
+    () =>
+      request(app)
+        .get('/markdown')
+        .query({ url: DEEPWIKI_URL, engine: 'playwright' })
+        .expect(200),
+    {
+      retries: 2,
+      baseDelay: 3000,
+      onRetry: (err, attempt, delay) => {
+        console.log(
+          `Retry ${attempt} for DeepWiki markdown after ${delay}ms: ${err.message}`
+        );
+      },
+    }
+  );
+
+  expect(response.headers['content-type']).toMatch(/text\/markdown/);
+  return response.text;
+}
+
+describe('DeepWiki committed reference fixtures (issue #17)', () => {
+  it('stores markdown split into inline-sized reference documents', () => {
+    const fixtureChunks = readFixtureChunks();
+    const fixtureMarkdown = fixtureChunks.join('\n');
+
+    expect(fixtureChunks).toHaveLength(2);
+    expect(fixtureChunks[0].split('\n').length).toBeLessThanOrEqual(
+      INLINE_MARKDOWN_LINE_LIMIT
+    );
+    expect(fixtureChunks[1].split('\n').length).toBeGreaterThan(0);
+    expect(fixtureMarkdown.split('\n').length).toBeGreaterThan(
+      INLINE_MARKDOWN_LINE_LIMIT
+    );
+    expectMarkersInOrder(fixtureMarkdown, ORDERED_CONTENT_MARKERS);
+  });
+
+  it('keeps the full-page screenshot fixture as a PNG visual reference', () => {
+    const screenshot = fs.readFileSync(
+      path.join(FIXTURE_DIR, 'deepwiki-full-page.png')
+    );
+
+    expect(screenshot.subarray(0, PNG_SIGNATURE.length)).toEqual(PNG_SIGNATURE);
+    expect(screenshot.length).toBeGreaterThan(100000);
+  });
+});
+
+describeIfLive('DeepWiki search page markdown capture (issue #17)', () => {
+  it('matches the committed markdown fixture split from the rendered page', async () => {
+    const markdown = await getDeepwikiMarkdown();
+    const fixtureChunks = readFixtureChunks();
+    const fixtureMarkdown = fixtureChunks.join('\n');
+
+    expect(markdown).not.toMatch(/<html/i);
+    expect(markdown).not.toContain('__NEXT_DATA__');
+    expect(markdown.split('\n').length).toBeGreaterThan(
+      INLINE_MARKDOWN_LINE_LIMIT
+    );
+    expectMarkersInOrder(markdown, ORDERED_CONTENT_MARKERS);
+    expectMarkersInOrder(fixtureMarkdown, ORDERED_CONTENT_MARKERS);
+    expect(splitMarkdown(markdown)).toEqual(fixtureChunks);
+  }, 180000);
+});

package/tests/integration/deepwiki-rendered-page.mock.test.js

@@ -0,0 +1,121 @@
+import { jest } from '@jest/globals';
+import nock from 'nock';
+import request from 'supertest';
+import { URL, fileURLToPath } from 'url';
+
+const DEEPWIKI_URL =
+  'https://deepwiki.com/search/-57-4-23-57_0e4aa687-7a9d-4591-8c6f-67c4b2d732f6';
+const deepwikiShellHtml = `<!doctype html>
+<html lang="en">
+  <head>
+    <title>Search | DeepWiki</title>
+    <script src="/_next/static/chunks/app.js"></script>
+    <script>self.__next_f = []; self.__next_f.push([1, "shell"])</script>
+  </head>
+  <body><div id="__next"></div></body>
+</html>`;
+const renderedDeepwikiHtml = `<!doctype html>
+<html lang="en">
+  <head><title>Search | DeepWiki</title></head>
+  <body>
+    <main>
+      <p>deep-assistant/hive-mind</p>
+      <p>расскажи пожалуйста на английском</p>
+      <h1>Hive Mind: A Comprehensive Overview of an AI Agent System for Software Development</h1>
+      <h2>Executive Summary</h2>
+      <p>Deep analysis of the issue-solver workflow.</p>
+      <h2>Thought Process</h2>
+      <pre><code>const clarifyPrompt = \`Task: "\${taskDescription}"\`;
+await solver.run(clarifyPrompt);</code></pre>
+    </main>
+  </body>
+</html>`;
+
+const fakePage = {
+  type: 'playwright',
+  rawPage: {
+    evaluate: jest
+      .fn()
+      .mockRejectedValueOnce(
+        new Error(
+          'Execution context was destroyed, most likely because of a navigation'
+        )
+      )
+      .mockResolvedValue(
+        renderedDeepwikiHtml.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ')
+          .length
+      ),
+  },
+  setViewport: jest.fn(async () => {}),
+  setExtraHTTPHeaders: jest.fn(async () => {}),
+  setUserAgent: jest.fn(async () => {}),
+  goto: jest.fn(async () => {}),
+  waitForTimeout: jest.fn(
+    (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  ),
+  content: jest.fn(async () => renderedDeepwikiHtml),
+};
+const fakeBrowser = {
+  newPage: jest.fn(async () => fakePage),
+  close: jest.fn(async () => {}),
+};
+const createBrowser = jest.fn(async () => fakeBrowser);
+const browserModulePath = fileURLToPath(
+  new URL('../../src/browser.js', import.meta.url)
+);
+
+jest.unstable_mockModule(browserModulePath, () => ({
+  createBrowser,
+  getBrowserEngine: (req) => req.query.engine || 'puppeteer',
+}));
+
+const { app } = await import('../../src/index.js');
+
+describe('DeepWiki rendered markdown endpoint behavior', () => {
+  beforeEach(() => {
+    nock.cleanAll();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('converts browser-rendered content when the initial fetch is a Next.js shell', async () => {
+    nock('https://deepwiki.com')
+      .get('/search/-57-4-23-57_0e4aa687-7a9d-4591-8c6f-67c4b2d732f6')
+      .reply(200, deepwikiShellHtml);
+
+    const response = await request(app)
+      .get('/markdown')
+      .query({ url: DEEPWIKI_URL, engine: 'playwright' })
+      .expect(200);
+
+    expect(createBrowser).toHaveBeenCalledWith(
+      'playwright',
+      expect.objectContaining({
+        args: expect.arrayContaining([
+          expect.stringContaining('--user-agent='),
+          '--window-size=1280,800',
+          '--disable-blink-features=AutomationControlled',
+        ]),
+      })
+    );
+    expect(fakePage.goto).toHaveBeenCalledWith(
+      DEEPWIKI_URL,
+      expect.objectContaining({ waitUntil: 'networkidle0' })
+    );
+    expect(fakeBrowser.close).toHaveBeenCalledTimes(1);
+    expect(response.headers['content-type']).toMatch(/text\/markdown/);
+    expect(response.text).toContain('Search | DeepWiki');
+    expect(response.text).toContain('deep-assistant/hive-mind');
+    expect(response.text).toContain('расскажи пожалуйста на английском');
+    expect(response.text).toContain(
+      '# Hive Mind: A Comprehensive Overview of an AI Agent System for Software Development'
+    );
+    expect(response.text).toContain('## Thought Process');
+    expect(response.text).toContain('```');
+    expect(response.text).toContain('const clarifyPrompt');
+    expect(response.text).not.toContain('__next_f');
+  });
+});

package/tests/integration/google-drive-image.test.js

@@ -0,0 +1,246 @@
+import request from 'supertest';
+import nock from 'nock';
+import unzipper from 'unzipper';
+import { app } from '../../src/index.js';
+
+const FIRST_FILE_ID = '1Cxkx6-428EQAX0-eiaq66H829ohnPp7q';
+const SECOND_FILE_ID = '1fgJaftjv53xCN7vgiJOaQlbfWkUqPgyd';
+const JPEG_BYTES = Buffer.from(
+  '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////2wBDAf//////////////////////////////////////////////////////////////////////////////////////wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAX/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAH/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAEFAqf/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAEDAQE/ASP/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAECAQE/ASP/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAY/Ap//xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAE/IV//2gAMAwEAAgADAAAAEP/EFBQRAQAAAAAAAAAAAAAAAAAAARD/2gAIAQMBAT8QH//EFBQRAQAAAAAAAAAAAAAAAAAAARD/2gAIAQIBAT8QH//EFBABAQAAAAAAAAAAAAAAAAAAARD/2gAIAQEAAT8QH//Z',
+  'base64'
+);
+
+const DRIVE_URLS = [
+  {
+    name: 'first issue URL with /view',
+    fileId: FIRST_FILE_ID,
+    url: `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`,
+  },
+  {
+    name: 'first issue URL without /view',
+    fileId: FIRST_FILE_ID,
+    url: `https://drive.google.com/file/d/${FIRST_FILE_ID}`,
+  },
+  {
+    name: 'second issue URL with /view',
+    fileId: SECOND_FILE_ID,
+    url: `https://drive.google.com/file/d/${SECOND_FILE_ID}/view`,
+  },
+  {
+    name: 'second issue URL without /view',
+    fileId: SECOND_FILE_ID,
+    url: `https://drive.google.com/file/d/${SECOND_FILE_ID}`,
+  },
+];
+
+function directDownloadUrl(fileId) {
+  return `https://drive.google.com/uc?export=download&id=${fileId}`;
+}
+
+function mockDriveHead(fileId) {
+  return nock('https://drive.google.com')
+    .head('/uc')
+    .query({ export: 'download', id: fileId })
+    .reply(200, '', { 'content-type': 'image/jpeg' });
+}
+
+function mockDriveGet(fileId) {
+  return nock('https://drive.google.com')
+    .get('/uc')
+    .query({ export: 'download', id: fileId })
+    .reply(200, JPEG_BYTES, {
+      'content-type': 'image/jpeg',
+      'content-length': String(JPEG_BYTES.length),
+    });
+}
+
+function bufferParser(res, callback) {
+  const chunks = [];
+  res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+  res.on('end', () => callback(null, Buffer.concat(chunks)));
+}
+
+afterEach(() => {
+  nock.cleanAll();
+});
+
+describe('Google Drive public image links', () => {
+  it.each(DRIVE_URLS)(
+    '/image downloads image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/image')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/fetch proxies direct image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/fetch')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/stream proxies direct image bytes for $name',
+    async (item) => {
+      mockDriveGet(item.fileId);
+
+      const res = await request(app)
+        .get('/stream')
+        .query({ url: item.url })
+        .buffer(true)
+        .parse(bufferParser)
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/^image\/jpeg/);
+      expect(res.body.subarray(0, 3)).toEqual(Buffer.from([0xff, 0xd8, 0xff]));
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/markdown includes a direct image link for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/markdown')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/markdown/);
+      expect(res.text).toContain(
+        `![Google Drive image](${directDownloadUrl(item.fileId)})`
+      );
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/txt includes the original and direct image links for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/txt')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/plain/);
+      expect(res.text).toContain('Google Drive image');
+      expect(res.text).toContain(`Original Google Drive file: ${item.url}`);
+      expect(res.text).toContain(`Image: ${directDownloadUrl(item.fileId)}`);
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it.each(DRIVE_URLS)(
+    '/html includes a direct image tag for $name',
+    async (item) => {
+      mockDriveHead(item.fileId);
+
+      const res = await request(app)
+        .get('/html')
+        .query({ url: item.url })
+        .expect(200);
+
+      expect(res.headers['content-type']).toMatch(/text\/html/);
+      expect(res.text).toContain(
+        `src="${directDownloadUrl(item.fileId).replace('&', '&')}"`
+      );
+      expect(nock.isDone()).toBe(true);
+    }
+  );
+
+  it('archive includes markdown and the downloaded Drive image', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveHead(item.fileId);
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/archive')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    const zip = await unzipper.Open.buffer(res.body);
+    const document = zip.files.find((file) => file.path === 'document.md');
+    const image = zip.files.find((file) => file.path.startsWith('images/'));
+
+    expect(document).toBeDefined();
+    expect(image).toBeDefined();
+    expect((await document.buffer()).toString('utf8')).toContain(
+      '![Google Drive image](images/image-1.jpg)'
+    );
+    expect((await image.buffer()).subarray(0, 3)).toEqual(
+      Buffer.from([0xff, 0xd8, 0xff])
+    );
+    expect(nock.isDone()).toBe(true);
+  });
+
+  it('docx includes the downloaded Drive image', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveHead(item.fileId);
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/docx')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    expect(res.headers['content-type']).toMatch(
+      /application\/vnd\.openxmlformats-officedocument\.wordprocessingml\.document/
+    );
+    expect(res.body.subarray(0, 2)).toEqual(Buffer.from('PK'));
+
+    const docx = await unzipper.Open.buffer(res.body);
+    const mediaEntry = docx.files.find(
+      (file) => file.path.startsWith('word/media/') && !file.path.endsWith('/')
+    );
+    expect(mediaEntry).toBeDefined();
+    expect((await mediaEntry.buffer()).subarray(0, 3)).toEqual(
+      Buffer.from([0xff, 0xd8, 0xff])
+    );
+    expect(nock.isDone()).toBe(true);
+  });
+
+  it('pdf renders the downloaded Drive image document', async () => {
+    const item = DRIVE_URLS[0];
+    mockDriveGet(item.fileId);
+
+    const res = await request(app)
+      .get('/pdf')
+      .query({ url: item.url })
+      .buffer(true)
+      .parse(bufferParser)
+      .expect(200);
+
+    expect(res.headers['content-type']).toMatch(/application\/pdf/);
+    expect(res.body.subarray(0, 4).toString('utf8')).toBe('%PDF');
+    expect(nock.isDone()).toBe(true);
+  });
+});

package/tests/unit/convertGoogleDriveUrl.test.js

@@ -0,0 +1,89 @@
+import {
+  convertGoogleDriveUrl,
+  getGoogleDriveFileId,
+  googleDriveImageTextForUrl,
+  isGoogleDriveFileUrl,
+} from '../../src/lib.js';
+
+const FIRST_FILE_ID = '1Cxkx6-428EQAX0-eiaq66H829ohnPp7q';
+const SECOND_FILE_ID = '1fgJaftjv53xCN7vgiJOaQlbfWkUqPgyd';
+
+function directDownloadUrl(fileId) {
+  return `https://drive.google.com/uc?export=download&id=${fileId}`;
+}
+
+describe('Google Drive URL helpers', () => {
+  it.each([
+    [
+      'issue URL with /view',
+      `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'issue URL without /view',
+      `https://drive.google.com/file/d/${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'second issue URL with /view',
+      `https://drive.google.com/file/d/${SECOND_FILE_ID}/view`,
+      SECOND_FILE_ID,
+    ],
+    [
+      'second issue URL without /view',
+      `https://drive.google.com/file/d/${SECOND_FILE_ID}`,
+      SECOND_FILE_ID,
+    ],
+    [
+      'open?id URL',
+      `https://drive.google.com/open?id=${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'direct uc URL',
+      `https://drive.google.com/uc?export=download&id=${FIRST_FILE_ID}`,
+      FIRST_FILE_ID,
+    ],
+    [
+      'redirected usercontent URL',
+      `https://drive.usercontent.google.com/download?id=${FIRST_FILE_ID}&export=download`,
+      FIRST_FILE_ID,
+    ],
+  ])('extracts and converts %s', (_name, input, fileId) => {
+    expect(getGoogleDriveFileId(input)).toBe(fileId);
+    expect(isGoogleDriveFileUrl(input)).toBe(true);
+    expect(convertGoogleDriveUrl(input)).toBe(directDownloadUrl(fileId));
+  });
+
+  it('ignores non-Google Drive URLs and malformed Drive IDs', () => {
+    const example = 'https://example.com/image.jpg';
+    const malformed = 'https://drive.google.com/file/d/not%20valid/view';
+
+    expect(getGoogleDriveFileId(example)).toBeNull();
+    expect(isGoogleDriveFileUrl(example)).toBe(false);
+    expect(convertGoogleDriveUrl(example)).toBe(example);
+    expect(getGoogleDriveFileId(malformed)).toBeNull();
+    expect(isGoogleDriveFileUrl(malformed)).toBe(false);
+    expect(convertGoogleDriveUrl(malformed)).toBe(malformed);
+  });
+
+  it('keeps empty or missing inputs unchanged when converting', () => {
+    expect(convertGoogleDriveUrl(null)).toBeNull();
+    expect(convertGoogleDriveUrl(undefined)).toBeUndefined();
+    expect(convertGoogleDriveUrl('')).toBe('');
+  });
+
+  it('renders text output with the original file URL and direct image URL', () => {
+    const input = `https://drive.google.com/file/d/${FIRST_FILE_ID}/view`;
+
+    expect(googleDriveImageTextForUrl(input)).toContain(
+      `Original Google Drive file: ${input}`
+    );
+    expect(googleDriveImageTextForUrl(input)).toContain(
+      `Image: ${directDownloadUrl(FIRST_FILE_ID)}`
+    );
+    expect(
+      googleDriveImageTextForUrl('https://example.com/image.jpg')
+    ).toBeNull();
+  });
+});

package/tests/unit/markdown.test.js

@@ -0,0 +1,36 @@
+import { shouldRenderHtmlWithBrowser } from '../../src/markdown.js';
+
+describe('markdown rendering decisions', () => {
+  it('uses browser rendering for JavaScript-heavy HTML shells', () => {
+    const html = `<!doctype html>
+      <html>
+        <head><script src="/_next/static/app.js"></script></head>
+        <body><div id="__next"></div></body>
+      </html>`;
+
+    expect(shouldRenderHtmlWithBrowser(html)).toBe(true);
+  });
+
+  it('keeps plain HTML on the direct fetch path', () => {
+    const html = `<!doctype html>
+      <html>
+        <head><title>Static page</title></head>
+        <body><main><h1>Static content</h1></main></body>
+      </html>`;
+
+    expect(shouldRenderHtmlWithBrowser(html)).toBe(false);
+  });
+
+  it('keeps static pages with incidental scripts on the direct fetch path', () => {
+    const html = `<!doctype html>
+      <html>
+        <head>
+          <title>Static page</title>
+          <script src="/analytics.js"></script>
+        </head>
+        <body><main><h1>Static content</h1></main></body>
+      </html>`;
+
+    expect(shouldRenderHtmlWithBrowser(html)).toBe(false);
+  });
+});