firecrawl 1.29.2 → 3.0.2

package/src/__tests__/e2e/v2/search.test.ts

@@ -0,0 +1,247 @@
+/**
+ * E2E tests for v2 search (translated from Python tests)
+ */
+import Firecrawl from "../../../index";
+import type { Document, SearchResult } from "../../../index";
+import { config } from "dotenv";
+import { getIdentity, getApiUrl } from "./utils/idmux";
+import { describe, test, expect, beforeAll } from "@jest/globals";
+
+config();
+
+const API_URL = getApiUrl();
+let client: Firecrawl;
+
+beforeAll(async () => {
+  const { apiKey } = await getIdentity({ name: "js-e2e-search" });
+  client = new Firecrawl({ apiKey, apiUrl: API_URL });
+});
+
+function collectTexts(entries: any[] | undefined): string[] {
+  const texts: string[] = [];
+  for (const r of entries || []) {
+    const title = (r && typeof r === 'object') ? (r.title as unknown as string | undefined) : undefined;
+    const desc = (r && typeof r === 'object') ? (r.description as unknown as string | undefined) : undefined;
+    if (title) texts.push(String(title).toLowerCase());
+    if (desc) texts.push(String(desc).toLowerCase());
+  }
+  return texts;
+}
+
+function isDocument(entry: Document | SearchResult | undefined | null): entry is Document {
+  if (!entry) return false;
+  const d = entry as Document;
+  return (
+    typeof d.markdown === 'string' ||
+    typeof d.rawHtml === 'string' ||
+    typeof d.html === 'string' ||
+    typeof d.links === 'object' ||
+    typeof d.screenshot === 'string' ||
+    typeof d.changeTracking === 'object' ||
+    typeof d.summary === 'string' ||
+    typeof d.json === 'object'
+  );
+}
+
+describe("v2.search e2e", () => {
+
+  test("minimal request", async () => {
+    if (!client) throw new Error();
+    const results = await client.search("What is the capital of France?");
+    expect(results).toBeTruthy();
+    expect(results).toHaveProperty("web");
+    expect(results).not.toHaveProperty("news");
+    expect(results).not.toHaveProperty("images");
+
+    expect(results.web).toBeTruthy();
+    expect((results.web || []).length).toBeGreaterThan(0);
+
+    for (const result of results.web || []) {
+      if (isDocument(result)) {
+        // documents appear if scraping happens
+        continue;
+      }
+      expect(typeof result.url).toBe("string");
+      expect(result.url.startsWith("http")).toBe(true);
+      expect(typeof result.title === "string" || result.title == null).toBe(true);
+      expect(typeof result.description === "string" || result.description == null).toBe(true);
+    }
+
+    const allText = collectTexts(results.web).join(" ");
+    expect(allText.includes("paris")).toBe(true);
+
+    expect(results.news == null).toBe(true);
+    expect(results.images == null).toBe(true);
+  }, 90_000);
+
+  test("with sources web+news and limit", async () => {
+    if (!client) throw new Error();
+    const results = await client.search("firecrawl", { sources: ["web", "news"], limit: 3 });
+    expect(results).toBeTruthy();
+    expect(results.web).toBeTruthy();
+    expect((results.web || []).length).toBeLessThanOrEqual(3);
+    if (results.news != null) {
+      expect((results.news || []).length).toBeLessThanOrEqual(3);
+    }
+    expect(results.images == null).toBe(true);
+
+    const webTitles = (results.web || [])
+      .filter((r): r is SearchResult => !isDocument(r))
+      .map(r => (r.title || "").toString().toLowerCase());
+    const webDescriptions = (results.web || [])
+      .filter((r): r is SearchResult => !isDocument(r))
+      .map(r => (r.description || "").toString().toLowerCase());
+    const allWebText = (webTitles.concat(webDescriptions)).join(" ");
+    expect(allWebText.includes("firecrawl")).toBe(true);
+  }, 90_000);
+
+  test("result structure", async () => {
+    if (!client) throw new Error();
+    const results = await client.search("test query", { limit: 1 });
+    if (results.web && results.web.length > 0) {
+      const result: any = results.web[0];
+      expect(result).toHaveProperty("url");
+      expect(result).toHaveProperty("title");
+      expect(result).toHaveProperty("description");
+      expect(typeof result.url).toBe("string");
+      expect(typeof result.title === "string" || result.title == null).toBe(true);
+      expect(typeof result.description === "string" || result.description == null).toBe(true);
+      expect(result.url.startsWith("http")).toBe(true);
+    }
+  }, 90_000);
+
+  test("all parameters (comprehensive)", async () => {
+    if (!client) throw new Error();
+    const schema = {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        description: { type: "string" },
+        url: { type: "string" },
+      },
+      required: ["title", "description"],
+    } as const;
+
+    const results = await client.search("artificial intelligence", {
+      sources: [ "web", "news", "images" ],
+      limit: 3,
+      tbs: "qdr:m",
+      location: "US",
+      ignoreInvalidURLs: true,
+      timeout: 60_000,
+      scrapeOptions: {
+        formats: [
+          "markdown",
+          "html",
+          { type: "json", prompt: "Extract the title and description from the page", schema },
+        ],
+        headers: { "User-Agent": "Firecrawl-Test/1.0" },
+        includeTags: ["h1", "h2", "p"],
+        excludeTags: ["nav", "footer"],
+        onlyMainContent: true,
+        waitFor: 2000,
+        mobile: false,
+        skipTlsVerification: false,
+        removeBase64Images: true,
+        blockAds: true,
+        proxy: "basic",
+        maxAge: 3_600_000,
+        storeInCache: true,
+        location: { country: "US", languages: ["en"] },
+        actions: [{ type: "wait", milliseconds: 1000 }],
+      },
+    });
+
+    expect(results).toBeTruthy();
+    expect(results).toHaveProperty("web");
+    expect(results).toHaveProperty("news");
+    expect(results).toHaveProperty("images");
+
+    expect(results.web).toBeTruthy();
+    expect((results.web || []).length).toBeLessThanOrEqual(3);
+
+    const nonDocEntries = (results.web || []).filter(r => !isDocument(r));
+    if (nonDocEntries.length > 0) {
+      const allWebText = collectTexts(nonDocEntries).join(" ");
+      const aiTerms = ["artificial", "intelligence", "ai", "machine", "learning"];
+      expect(aiTerms.some(t => allWebText.includes(t))).toBe(true);
+    }
+
+    for (const result of results.web || []) {
+      if (isDocument(result)) {
+        expect(Boolean(result.markdown) || Boolean(result.html)).toBe(true);
+      } else {
+        expect(typeof result.url).toBe("string");
+        expect(result.url.startsWith("http")).toBe(true);
+      }
+    }
+
+    if (results.news != null) {
+      expect((results.news || []).length).toBeLessThanOrEqual(3);
+      for (const result of results.news || []) {
+        if (isDocument(result)) {
+          expect(Boolean(result.markdown) || Boolean(result.html)).toBe(true);
+        } else {
+          expect(typeof result.url).toBe("string");
+          expect(result.url.startsWith("http")).toBe(true);
+        }
+      }
+    }
+
+    expect(results.images).toBeTruthy();
+    expect((results.images || []).length).toBeLessThanOrEqual(3);
+    for (const result of results.images || []) {
+      if (!isDocument(result)) {
+        expect(typeof result.url).toBe("string");
+        expect(result.url.startsWith("http")).toBe(true);
+      }
+    }
+  }, 120_000);
+
+  test("formats flexibility: list vs object", async () => {
+    if (!client) throw new Error();
+    const results1 = await client.search("python programming", {
+      limit: 1,
+      scrapeOptions: { formats: ["markdown"] },
+    });
+    const results2 = await client.search("python programming", {
+      limit: 1,
+      scrapeOptions: { formats: ["markdown"] },
+    });
+    expect(results1).toBeTruthy();
+    expect(results2).toBeTruthy();
+    expect(results1.web).toBeTruthy();
+    expect(results2.web).toBeTruthy();
+  }, 90_000);
+
+  test("with json format object", async () => {
+    if (!client) throw new Error();
+    const jsonSchema = {
+      type: "object",
+      properties: { title: { type: "string" } },
+      required: ["title"],
+    } as const;
+    const results = await client.search("site:docs.firecrawl.dev", {
+      limit: 1,
+      scrapeOptions: {
+        formats: [{ type: "json", prompt: "Extract page title", schema: jsonSchema }],
+      },
+    });
+    expect(results).toBeTruthy();
+    expect(Array.isArray(results.web) || results.web == null).toBe(true);
+  }, 90_000);
+
+  test("with summary format, documents include summary when present", async () => {
+    if (!client) throw new Error();
+    const results = await client.search("site:firecrawl.dev", {
+      limit: 1,
+      scrapeOptions: { formats: ["summary"] },
+    });
+    const docs = (results.web || []).filter(r => isDocument(r)) as Document[];
+    if (docs.length > 0) {
+      expect(typeof docs[0].summary).toBe("string");
+      expect((docs[0].summary || "").length).toBeGreaterThan(5);
+    }
+  }, 90_000);
+});
+

package/src/__tests__/e2e/v2/usage.test.ts

@@ -0,0 +1,36 @@
+/**
+ * E2E tests for v2 usage endpoints (translated from Python tests)
+ */
+import Firecrawl from "../../../index";
+import { config } from "dotenv";
+import { getIdentity, getApiUrl } from "./utils/idmux";
+import { describe, test, expect, beforeAll } from "@jest/globals";
+
+config();
+
+const API_URL = getApiUrl();
+let client: Firecrawl;
+
+beforeAll(async () => {
+  const { apiKey } = await getIdentity({ name: "js-e2e-usage" });
+  client = new Firecrawl({ apiKey, apiUrl: API_URL });
+});
+
+describe("v2.usage e2e", () => {
+  test("get_concurrency", async () => {
+    const resp = await client.getConcurrency();
+    expect(typeof resp.concurrency).toBe("number");
+    expect(typeof resp.maxConcurrency).toBe("number");
+  }, 60_000);
+
+  test("get_credit_usage", async () => {
+    const resp = await client.getCreditUsage();
+    expect(typeof resp.remainingCredits).toBe("number");
+  }, 60_000);
+
+  test("get_token_usage", async () => {
+    const resp = await client.getTokenUsage();
+    expect(typeof resp.remainingTokens).toBe("number");
+  }, 60_000);
+});
+

package/src/__tests__/e2e/v2/utils/idmux.ts

@@ -0,0 +1,58 @@
+export type IdmuxRequest = {
+  name?: string;
+  concurrency?: number;
+  credits?: number;
+  tokens?: number;
+  teamId?: string;
+  flags?: Record<string, unknown>;
+};
+
+export type Identity = {
+  apiKey: string;
+  teamId: string;
+};
+
+let cachedIdentity: Identity | null = null;
+
+export function getApiUrl(): string {
+  return process.env.TEST_URL ?? process.env.FIRECRAWL_API_URL ?? "https://api.firecrawl.dev";
+}
+
+export async function getIdentity(req: IdmuxRequest = {}): Promise<Identity> {
+  if (cachedIdentity) return cachedIdentity;
+
+  const idmuxUrl = process.env.IDMUX_URL;
+  if (!idmuxUrl) {
+    const fallback: Identity = {
+      apiKey: process.env.TEST_API_KEY ?? process.env.FIRECRAWL_API_KEY ?? "",
+      teamId: process.env.TEST_TEAM_ID ?? "",
+    };
+    cachedIdentity = fallback;
+    return fallback;
+  }
+
+  const runNumberRaw = process.env.GITHUB_RUN_NUMBER;
+  const runNumber = runNumberRaw ? Number(runNumberRaw) : 0;
+  const body = {
+    refName: process.env.GITHUB_REF_NAME ?? "local",
+    runNumber: Number.isFinite(runNumber) ? runNumber : 0,
+    concurrency: req.concurrency ?? 100,
+    ...req,
+  };
+
+  const res = await fetch(`${idmuxUrl}/`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`idmux request failed: ${res.status} ${text}`);
+  }
+
+  const identity = (await res.json()) as Identity;
+  cachedIdentity = identity;
+  return identity;
+}
+

package/src/__tests__/e2e/v2/watcher.test.ts

@@ -0,0 +1,96 @@
+import Firecrawl from "../../../index";
+import { config } from "dotenv";
+import { describe, test, expect, beforeAll } from "@jest/globals";
+import { getIdentity } from "./utils/idmux";
+
+config();
+
+const API_URL = process.env.FIRECRAWL_API_URL ?? "https://api.firecrawl.dev";
+let client: Firecrawl;
+
+beforeAll(async () => {
+  const { apiKey } = await getIdentity({ name: "js-e2e-watcher" });
+  client = new Firecrawl({ apiKey, apiUrl: API_URL });
+});
+
+describe("v2.watcher e2e", () => {
+  test("crawl watcher minimal", async () => {
+    // client is initialized in beforeAll
+    const start = await client.startCrawl("https://docs.firecrawl.dev", { limit: 3 });
+
+    expect(typeof start.id).toBe("string");
+
+    const watcher = client.watcher(start.id, { pollInterval: 2 });
+
+    let snapshots = 0;
+    let documents = 0;
+
+    watcher.on("snapshot", (snap: any) => {
+      snapshots += 1;
+      expect(["scraping", "completed", "failed", "cancelled"]).toContain(snap.status);
+      expect(typeof snap.completed).toBe("number");
+      expect(typeof snap.total).toBe("number");
+    });
+
+    watcher.on("document", (_doc: any) => {
+      documents += 1;
+    });
+
+    const final = await new Promise<any>(async (resolve) => {
+      watcher.on("done", (payload: any) => {
+        resolve(payload);
+      });
+      watcher.on("error", (err: any) => {
+        resolve(err);
+      });
+      await watcher.start();
+    });
+
+    expect(["completed", "failed", "cancelled"]).toContain(final.status);
+    expect(Array.isArray(final.data)).toBe(true);
+    expect(typeof final.id).toBe("string");
+    expect(snapshots).toBeGreaterThanOrEqual(1);
+    expect(documents).toBeGreaterThanOrEqual(0);
+    watcher.close();
+  }, 240_000);
+
+  test("batch watcher with options (kind, pollInterval, timeout)", async () => {
+    // client is initialized in beforeAll
+    const urls = [
+      "https://docs.firecrawl.dev",
+      "https://firecrawl.dev",
+    ];
+
+    const start = await client.startBatchScrape(urls, { options: { formats: ["markdown"] }, ignoreInvalidURLs: true });
+    expect(typeof start.id).toBe("string");
+
+    const watcher = client.watcher(start.id, { kind: "batch", pollInterval: 2, timeout: 180 });
+
+    let snapshots = 0;
+    let gotCompleted = false;
+
+    watcher.on("snapshot", (snap: any) => {
+      snapshots += 1;
+      if (snap.status === "completed") gotCompleted = true;
+      expect(["scraping", "completed", "failed", "cancelled"]).toContain(snap.status);
+    });
+
+    const final = await new Promise<any>(async (resolve) => {
+      watcher.on("done", (payload: any) => {
+        resolve(payload);
+      });
+      watcher.on("error", (err: any) => {
+        resolve(err);
+      });
+      await watcher.start();
+    });
+
+    expect(["completed", "failed", "cancelled"]).toContain(final.status);
+    expect(Array.isArray(final.data)).toBe(true);
+    expect(typeof final.id).toBe("string");
+    expect(snapshots).toBeGreaterThanOrEqual(1);
+    expect(gotCompleted || final.status !== "completed").toBe(true);
+    watcher.close();
+  }, 300_000);
+});
+

package/src/__tests__/unit/v1/monitor-job-status-retry.test.ts

@@ -0,0 +1,154 @@
+import FirecrawlApp from '../../../index';
+import { describe, test, expect, jest, beforeEach, afterEach } from '@jest/globals';
+
+describe('monitorJobStatus retry logic', () => {
+  let app: FirecrawlApp;
+  let originalConsoleWarn: typeof console.warn;
+  
+  beforeEach(() => {
+    app = new FirecrawlApp({ apiKey: 'test-key', apiUrl: 'https://test.com' });
+    originalConsoleWarn = console.warn;
+    console.warn = jest.fn();
+  });
+
+  afterEach(() => {
+    console.warn = originalConsoleWarn;
+    jest.clearAllMocks();
+  });
+
+  test('should retry on socket hang up error', async () => {
+    const socketHangUpError = new Error('socket hang up') as any;
+    socketHangUpError.code = 'ECONNRESET';
+    
+    const successResponse = {
+      status: 200,
+      data: { status: 'completed', data: [{ url: 'test.com', markdown: 'test' }] }
+    };
+
+    const originalGetRequest = app.getRequest;
+    let callCount = 0;
+    
+    app.getRequest = async function(url: string, headers: any) {
+      callCount++;
+      if (callCount === 1) {
+        throw socketHangUpError;
+      }
+      return successResponse;
+    };
+
+    const result = await app.monitorJobStatus('test-id', {}, 1);
+    
+    expect(callCount).toBe(2);
+    expect(result).toEqual(successResponse.data);
+    expect(console.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Network error during job status check (attempt 1/3): socket hang up')
+    );
+  });
+
+  test('should retry on ETIMEDOUT error', async () => {
+    const timeoutError = new Error('timeout') as any;
+    timeoutError.code = 'ETIMEDOUT';
+    
+    const successResponse = {
+      status: 200,
+      data: { status: 'completed', data: [{ url: 'test.com', markdown: 'test' }] }
+    };
+
+    const originalGetRequest = app.getRequest;
+    let callCount = 0;
+    
+    app.getRequest = async function(url: string, headers: any) {
+      callCount++;
+      if (callCount === 1) {
+        throw timeoutError;
+      }
+      return successResponse;
+    };
+
+    const result = await app.monitorJobStatus('test-id', {}, 1);
+    
+    expect(callCount).toBe(2);
+    expect(result).toEqual(successResponse.data);
+  });
+
+  test('should fail after max retries exceeded', async () => {
+    const socketHangUpError = new Error('socket hang up') as any;
+    socketHangUpError.code = 'ECONNRESET';
+    
+    app.getRequest = async function(url: string, headers: any) {
+      throw socketHangUpError;
+    };
+
+    await expect(app.monitorJobStatus('test-id', {}, 1)).rejects.toThrow('socket hang up');
+    
+    expect(console.warn).toHaveBeenCalledTimes(3);
+  }, 15000);
+
+  test('should not retry on non-retryable errors', async () => {
+    const authError = new Error('Unauthorized') as any;
+    authError.response = { status: 401, data: { error: 'Unauthorized' } };
+    
+    app.getRequest = async function(url: string, headers: any) {
+      throw authError;
+    };
+
+    await expect(app.monitorJobStatus('test-id', {}, 1)).rejects.toThrow('Unauthorized');
+    
+    expect(console.warn).not.toHaveBeenCalled();
+  });
+
+  test('should retry on HTTP timeout status codes', async () => {
+    const timeoutError = new Error('Request timeout') as any;
+    timeoutError.response = { status: 408, data: { error: 'Request timeout' } };
+    
+    const successResponse = {
+      status: 200,
+      data: { status: 'completed', data: [{ url: 'test.com', markdown: 'test' }] }
+    };
+
+    const originalGetRequest = app.getRequest;
+    let callCount = 0;
+    
+    app.getRequest = async function(url: string, headers: any) {
+      callCount++;
+      if (callCount === 1) {
+        throw timeoutError;
+      }
+      return successResponse;
+    };
+
+    const result = await app.monitorJobStatus('test-id', {}, 1);
+    
+    expect(callCount).toBe(2);
+    expect(result).toEqual(successResponse.data);
+  });
+
+  test('should use exponential backoff for retries', async () => {
+    const socketHangUpError = new Error('socket hang up') as any;
+    socketHangUpError.code = 'ECONNRESET';
+    
+    const successResponse = {
+      status: 200,
+      data: { status: 'completed', data: [{ url: 'test.com', markdown: 'test' }] }
+    };
+
+    const originalGetRequest = app.getRequest;
+    let callCount = 0;
+    
+    app.getRequest = async function(url: string, headers: any) {
+      callCount++;
+      if (callCount <= 2) {
+        throw socketHangUpError;
+      }
+      return successResponse;
+    };
+
+    const startTime = Date.now();
+    const result = await app.monitorJobStatus('test-id', {}, 1);
+    const endTime = Date.now();
+    
+    expect(callCount).toBe(3);
+    expect(result).toEqual(successResponse.data);
+    expect(endTime - startTime).toBeGreaterThan(3000);
+  });
+});

package/src/__tests__/unit/v2/errorHandler.test.ts

@@ -0,0 +1,19 @@
+import { describe, test, expect } from "@jest/globals";
+import { throwForBadResponse, normalizeAxiosError } from "../../../v2/utils/errorHandler";
+
+describe("v2 utils: errorHandler", () => {
+  test("throwForBadResponse: throws SdkError with message from body.error", () => {
+    const resp: any = { status: 400, data: { error: "bad" } };
+    expect(() => throwForBadResponse(resp, "do thing")).toThrow(/bad/);
+  });
+
+  test("normalizeAxiosError: prefers body.error then err.message", () => {
+    const err: any = {
+      isAxiosError: true,
+      response: { status: 402, data: { error: "payment required" } },
+      message: "network",
+    };
+    expect(() => normalizeAxiosError(err, "action")).toThrow(/payment required/);
+  });
+});
+

package/src/__tests__/unit/v2/scrape.unit.test.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal unit test for v2 scrape (no mocking; sanity check payload path)
+ */
+import { FirecrawlClient } from "../../../v2/client";
+
+describe("v2.scrape unit", () => {
+  test("constructor requires apiKey", () => {
+    expect(() => new FirecrawlClient({ apiKey: "", apiUrl: "https://api.firecrawl.dev" })).toThrow();
+  });
+});
+

package/src/__tests__/unit/v2/validation.test.ts

@@ -0,0 +1,59 @@
+import { describe, test, expect } from "@jest/globals";
+import { ensureValidFormats, ensureValidScrapeOptions } from "../../../v2/utils/validation";
+import type { FormatOption } from "../../../v2/types";
+import { z } from "zod";
+
+describe("v2 utils: validation", () => {
+  test("ensureValidFormats: plain 'json' string is invalid", () => {
+    const formats: FormatOption[] = ["markdown", "json"] as unknown as FormatOption[];
+    expect(() => ensureValidFormats(formats)).toThrow(/json format must be an object/i);
+  });
+
+  test("ensureValidFormats: json format requires prompt and schema", () => {
+    const bad1: FormatOption[] = [{ type: "json", prompt: "p" } as any];
+    const bad2: FormatOption[] = [{ type: "json", schema: {} } as any];
+    expect(() => ensureValidFormats(bad1)).toThrow(/requires 'prompt' and 'schema'/i);
+    expect(() => ensureValidFormats(bad2)).toThrow(/requires 'prompt' and 'schema'/i);
+  });
+
+  test("ensureValidFormats: converts zod schema to JSON schema", () => {
+    const schema = z.object({ title: z.string() });
+    const formats: FormatOption[] = [
+      { type: "json", prompt: "extract", schema } as any,
+    ];
+    ensureValidFormats(formats);
+    const jsonFmt = formats[0] as any;
+    expect(typeof jsonFmt.schema).toBe("object");
+    expect(jsonFmt.schema?.properties).toBeTruthy();
+  });
+
+  test("ensureValidFormats: screenshot quality must be non-negative number", () => {
+    const formats: FormatOption[] = [
+      { type: "screenshot", quality: -1 } as any,
+    ];
+    expect(() => ensureValidFormats(formats)).toThrow(/non-negative number/i);
+  });
+
+  test("ensureValidScrapeOptions: validates timeout and waitFor bounds", () => {
+    expect(() => ensureValidScrapeOptions({ timeout: 0 })).toThrow(/timeout must be positive/i);
+    expect(() => ensureValidScrapeOptions({ waitFor: -1 })).toThrow(/waitFor must be non-negative/i);
+    // valid
+    expect(() => ensureValidScrapeOptions({ timeout: 1000, waitFor: 0 })).not.toThrow();
+  });
+
+  test("ensureValidFormats: accepts screenshot viewport width/height", () => {
+    const formats: FormatOption[] = [
+      { type: "screenshot", viewport: { width: 800, height: 600 } } as any,
+    ];
+    expect(() => ensureValidFormats(formats)).not.toThrow();
+    expect((formats[0] as any).viewport).toEqual({ width: 800, height: 600 });
+  });
+
+  test("ensureValidScrapeOptions: leaves parsers untouched", () => {
+    const options = { parsers: ["pdf", "images"] as string[] } as any;
+    const before = [...options.parsers];
+    expect(() => ensureValidScrapeOptions(options)).not.toThrow();
+    expect(options.parsers).toEqual(before);
+  });
+});
+