diff --git a/package.json b/package.json
index d29f54fc7..14b6ba9ea 100644
--- a/package.json
+++ b/package.json
@@ -31,6 +31,7 @@
     "iso-639-1": "^3.1.5",
     "js-levenshtein": "^1.1.6",
     "js-yaml": "^4.1.0",
+    "jsdom": "^29.0.0",
     "normalize-url": "^9.0.0",
     "p-queue": "^7.3.4",
     "pixelmatch": "^5.3.0",
@@ -50,6 +51,7 @@
     "@types/get-folder-size": "^3.0.4",
     "@types/js-levenshtein": "^1.1.3",
     "@types/js-yaml": "^4.0.8",
+    "@types/jsdom": "^28.0.0",
     "@types/node": "^20.8.7",
     "@types/pixelmatch": "^5.2.6",
     "@types/pngjs": "^6.0.4",
diff --git a/src/crawler.ts b/src/crawler.ts
index 8ca4f13ea..24847c696 100644
--- a/src/crawler.ts
+++ b/src/crawler.ts
@@ -19,7 +19,10 @@ import yaml from "js-yaml";
 import { WACZ, WACZInitOpts, mergeCDXJ } from "./util/wacz.js";
 
 import { HealthChecker } from "./util/healthcheck.js";
-import { TextExtractViaSnapshot } from "./util/textextract.js";
+import {
+  TextExtractViaResponse,
+  TextExtractViaSnapshot,
+} from "./util/textextract.js";
 import {
   initStorage,
   getFileSize,
@@ -1178,11 +1181,55 @@ self.__bx_behaviors.selectMainBehavior();
       recorder.pageSeedDepth = depth;
     }
 
+    // Enable Network domain to track document request for raw text extraction
+    let documentRequestId: string | null = null;
+    let trackDocumentRequest:
+      | ((params: Protocol.Network.ResponseReceivedEvent) => void)
+      | null = null;
+
+    if (this.params.text.includes("to-warc-from-raw")) {
+      await cdp.send("Network.enable");
+      trackDocumentRequest = (
+        params: Protocol.Network.ResponseReceivedEvent,
+      ) => {
+        if (params.type === "Document" && !documentRequestId) {
+          documentRequestId = params.requestId;
+          logger.debug(
+            "Captured document request ID",
+            { requestId: documentRequestId, url: params.response.url },
+            "text",
+          );
+        }
+      };
+      cdp.on("Network.responseReceived", trackDocumentRequest);
+    }
+
     // run custom driver here, if any
-    if (this.driver) {
-      await this.driver({ page, data, crawler: this, seed });
-    } else {
-      await this.loadPage(page, data, seed);
+    try {
+      if (this.driver) {
+        await this.driver({ page, data, crawler: this, seed });
+      } else {
+        await this.loadPage(page, data, seed);
+      }
+    } finally {
+      // Store document request ID and clean up listener
+      if (documentRequestId) {
+        data.documentRequestId = documentRequestId;
+        logger.info(
+          "Stored document request ID for raw text extraction",
+          { url: data.url, requestId: documentRequestId },
+          "text",
+        );
+      } else if (trackDocumentRequest) {
+        logger.warn(
+          "No document request ID captured",
+          { url: data.url },
+          "text",
+        );
+      }
+      if (trackDocumentRequest) {
+        cdp.off("Network.responseReceived", trackDocumentRequest);
+      }
     }
 
     data.title = await timedRun(
@@ -1235,23 +1282,61 @@ self.__bx_behaviors.selectMainBehavior();
       }
     }
 
-    let textextract = null;
+    let textExtract = null;
 
     if (this.textWriter) {
-      textextract = new TextExtractViaSnapshot(cdp, {
+      textExtract = new TextExtractViaSnapshot(cdp, {
         writer: this.textWriter,
         url,
         skipDocs: this.skipTextDocs,
       });
-      const { text } = await textextract.extractAndStoreText(
+      const { text } = await textExtract.extractAndStoreText(
         "text",
         false,
         this.params.text.includes("to-warc"),
+        data.originalWarcRecordId,
       );
 
       if (text !== null && (this.textInPages || saveOutput)) {
         data.text = text;
       }
+
+      if (this.params.text.includes("to-warc-from-raw")) {
+        logger.info(
+          "Extracting text from raw response",
+          {
+            url,
+            hasRequestId: !!data.documentRequestId,
+            refersTo: String(data.originalWarcRecordId),
+          },
+          "text",
+        );
+        textExtract = new TextExtractViaResponse(cdp, {
+          writer: this.textWriter,
+          url,
+          skipDocs: this.skipTextDocs,
+          requestId: data.documentRequestId,
+        });
+        const { text: textFromResponse } =
+          await textExtract.extractAndStoreText(
+            "text-from-response",
+            false,
+            this.params.text.includes("to-warc-from-raw"),
+            data.originalWarcRecordId,
+          );
+        logger.info(
+          "Extracted text from raw response result",
+          {
+            url,
+            hasText: textFromResponse !== null,
+            refersTo: String(data.originalWarcRecordId),
+          },
+          "text",
+        );
+        if (textFromResponse !== null && (this.textInPages || saveOutput)) {
+          data.textFromResponse = textFromResponse;
+        }
+      }
     }
 
     data.loadState = LoadState.EXTRACTION_DONE;
@@ -1280,8 +1365,13 @@ self.__bx_behaviors.selectMainBehavior();
           data.loadState = LoadState.BEHAVIORS_DONE;
         }
 
-        if (textextract && this.params.text.includes("final-to-warc")) {
-          await textextract.extractAndStoreText("textFinal", true, true);
+        if (textExtract && this.params.text.includes("final-to-warc")) {
+          await textExtract.extractAndStoreText(
+            "textFinal",
+            true,
+            true,
+            data.originalWarcRecordId,
+          );
         }
 
         if (
@@ -2640,6 +2730,7 @@ self.__bx_behaviors.selectMainBehavior();
     logDetails: LogDetails = {},
     ts = 0,
     pageid?: string,
+    originalWarcRecordId?: string,
   ) {
     if (this.limitHit) {
       return false;
@@ -2658,7 +2749,7 @@ self.__bx_behaviors.selectMainBehavior();
     }
 
     const result = await this.crawlState.addToQueue(
-      { url, seedId, depth, extraHops, ts, pageid },
+      { url, seedId, depth, extraHops, ts, pageid, originalWarcRecordId },
       this.pageLimit,
     );
 
diff --git a/src/replaycrawler.ts b/src/replaycrawler.ts
index 091c2e4c4..763ac2ec6 100644
--- a/src/replaycrawler.ts
+++ b/src/replaycrawler.ts
@@ -21,6 +21,8 @@ import { WARCWriter } from "./util/warcwriter.js";
 import { parseRx } from "./util/seeds.js";
 import { getFileOrUrlJson } from "./util/file_reader.js";
 import { WACZLoader } from "./util/wacz.js";
+import { CSR_CLUES } from "./util/clientSideRenderingClues.js";
+import { extractTextFromDOM } from "./util/textextract.js";
 
 // RWP Replay Prefix
 const REPLAY_PREFIX = "http://localhost:9990/replay/w/replay/";
@@ -43,12 +45,17 @@ type ComparisonData = {
   comparison: {
     screenshotMatch?: number;
     textMatch?: number;
+    rawTextMatch?: number;
     resourceCounts: {
       crawlGood?: number;
       crawlBad?: number;
       replayGood?: number;
       replayBad?: number;
     };
+    csrClues?: {
+      clues: Record<string, number>;
+      categories: Record<string, number>;
+    };
   };
 };
 
@@ -65,6 +72,7 @@ export class ReplayCrawler extends Crawler {
 
   pageInfos: Map<Page, ReplayPageInfoRecord>;
   infoWriter: WARCWriter | null;
+  htmlWriter: WARCWriter | null;
 
   reloadTimeouts: WeakMap<Page, NodeJS.Timeout>;
 
@@ -95,13 +103,14 @@ export class ReplayCrawler extends Crawler {
     this.skipTextDocs = SKIP_FRAMES;
 
     this.params.screenshot = ["view"];
-    this.params.text = ["to-warc"];
+    this.params.text = ["to-warc", "to-warc-from-raw"];
 
     this.params.serviceWorker = "enabled";
 
     this.reloadTimeouts = new WeakMap<Page, NodeJS.Timeout>();
 
     this.infoWriter = null;
+    this.htmlWriter = null;
 
     this.includeRx = parseRx(this.params.scopeIncludeRx);
     this.excludeRx = parseRx(this.params.scopeExcludeRx);
@@ -111,6 +120,7 @@ export class ReplayCrawler extends Crawler {
     await super.bootstrap();
 
     this.infoWriter = this.createExtraResourceWarcWriter("info");
+    this.htmlWriter = this.createExtraResourceWarcWriter("html");
   }
 
   protected parseArgs() {
@@ -226,6 +236,7 @@ export class ReplayCrawler extends Crawler {
   }
 
   async _addPageIfInScope({ url, ts, id, mime }: ReplayPage, depth: number) {
+    logger.debug("Adding page to queue", { url, id, hasId: !!id }, "replay");
     if (mime && mime !== "text/html") {
       logger.info("Skipping non-HTML page", { url, mime }, "replay");
       return;
@@ -252,7 +263,7 @@ export class ReplayCrawler extends Crawler {
       }
     }
 
-    await this.queueUrl(0, url, depth, 0, {}, ts, id);
+    await this.queueUrl(0, url, depth, 0, {}, ts, id, id);
   }
 
   async loadPagesDirect(pages: ReplayPage[]) {
@@ -384,7 +395,7 @@ export class ReplayCrawler extends Crawler {
   async crawlPage(opts: WorkerState): Promise<void> {
     await this.writeStats();
 
-    const { page, data, workerid } = opts;
+    const { page, data, workerid, cdp } = opts;
     const { url, ts, pageid } = data;
 
     if (!ts) {
@@ -409,7 +420,7 @@ export class ReplayCrawler extends Crawler {
       comparison: { resourceCounts: {} },
       counts: { jsErrors: 0 },
       tsStatus: 999,
-    };
+    } satisfies ReplayPageInfoRecord;
     this.pageInfos.set(page, pageInfo);
 
     let replayFrame;
@@ -422,22 +433,121 @@ export class ReplayCrawler extends Crawler {
       replayFrame = page.frames()[SKIP_FRAMES];
     }
 
+    // Capture document request ID for raw text extraction if enabled
+    let documentRequestId: string | null = null;
+    let trackDocumentRequest:
+      | ((params: Protocol.Network.ResponseReceivedEvent) => void)
+      | null = null;
+
+    if (this.params.text.includes("to-warc-from-raw")) {
+      trackDocumentRequest = (
+        params: Protocol.Network.ResponseReceivedEvent,
+      ) => {
+        if (params.type === "Document" && !documentRequestId) {
+          documentRequestId = params.requestId;
+          logger.debug(
+            "Captured document request ID",
+            { requestId: documentRequestId, url: params.response.url },
+            "text",
+          );
+        }
+      };
+      cdp.on("Network.responseReceived", trackDocumentRequest);
+    }
+
+    let navigationSuccess = false;
     try {
-      await replayFrame.goto(
+      const response = await replayFrame.goto(
         `${REPLAY_PREFIX}${timestamp}mp_/${url}`,
         this.gotoOpts,
       );
+      navigationSuccess = true;
+      if (response) {
+        const status = response.status();
+        logger.info(
+          "Replay navigation completed",
+          { url, status, replayUrl: `${REPLAY_PREFIX}${timestamp}mp_/${url}` },
+          "replay",
+        );
+        if (status >= 400) {
+          logger.warn(
+            "Replay returned error status",
+            { url, status },
+            "replay",
+          );
+        }
+      } else {
+        logger.warn(
+          "Replay navigation returned null response",
+          { url },
+          "replay",
+        );
+      }
     } catch (e) {
       logger.warn(
-        "Loading replay timed out",
+        "Loading replay timed out or failed",
         { ...logDetails, ...formatErr(e) },
         "replay",
       );
+    } finally {
+      // Store document request ID and clean up listener
+      if (documentRequestId) {
+        data.documentRequestId = documentRequestId;
+        logger.info(
+          "Stored document request ID for raw text extraction",
+          {
+            url: data.url,
+            requestId: documentRequestId,
+            originalWarcRecordId: String(data.originalWarcRecordId),
+          },
+          "text",
+        );
+      } else if (trackDocumentRequest) {
+        logger.warn(
+          "No document request ID captured",
+          {
+            url: data.url,
+            originalWarcRecordId: String(data.originalWarcRecordId),
+          },
+          "text",
+        );
+      }
+      if (trackDocumentRequest) {
+        cdp.off("Network.responseReceived", trackDocumentRequest);
+      }
     }
 
-    while (replayFrame.url().indexOf("about:blank") >= 0) {
-      logger.debug("Waiting for replay frame to update");
-      await sleep(2);
+    // Only wait for frame to update if navigation succeeded
+    if (navigationSuccess) {
+      let frameWaitIterations = 0;
+      const maxFrameWaitIterations = 150; // 150 * 2 seconds = 5 min timeout
+      while (replayFrame.url().indexOf("about:blank") >= 0) {
+        if (frameWaitIterations >= maxFrameWaitIterations) {
+          logger.warn(
+            "Replay frame failed to update from about:blank",
+            {
+              url,
+              frameUrl: replayFrame.url(),
+              iterations: frameWaitIterations,
+            },
+            "replay",
+          );
+          break;
+        }
+        logger.debug(
+          "Waiting for replay frame to update",
+          {
+            url,
+            frameUrl: replayFrame.url(),
+            iterations: frameWaitIterations,
+          },
+          "replay",
+        );
+        await sleep(2);
+        frameWaitIterations++;
+      }
+    } else {
+      logger.warn("Skipping frame wait - navigation failed", { url }, "replay");
     }
 
     // optionally reload (todo: reevaluate if this is needed)
@@ -467,6 +577,15 @@ export class ReplayCrawler extends Crawler {
 
     await this.compareResources(page, data, url, date);
 
+    if (data.doRawTextCompare) {
+      await this.compareRawText(page, data, url, date);
+
+      await this.writeHtmlToWarc(page, url, date, data.originalWarcRecordId);
+    }
+
+    if (this.params.qaDetectClientSideRendering)
+      await this.processCSRClues(page, data);
+
     await this.processPageInfo(page, data);
   }
 
@@ -561,6 +680,7 @@ export class ReplayCrawler extends Crawler {
       url,
       date.toISOString().replace(/[^\d]/g, ""),
     );
+    state.originalText = origText;
     const replayText = state.text;
 
     if (origText === undefined || replayText === undefined) {
@@ -591,6 +711,182 @@ export class ReplayCrawler extends Crawler {
     }
   }
 
+  async compareRawText(page: Page, state: PageState, url: string, date: Date) {
+    // In the future, we could use the existing `text-from-response` data in the
+    // original archived data if it exists, but for now we're running on data we
+    // know doesn't include it
+    logger.info(
+      "Extracting raw text from archived response",
+      { url },
+      "replay",
+    );
+    const rawText = await this.extractRawTextFromArchive(page, url, date);
+
+    // Write raw text to WARC if textWriter is available
+    if (rawText && this.textWriter) {
+      this.textWriter.writeNewResourceRecord(
+        {
+          buffer: new TextEncoder().encode(rawText),
+          resourceType: "text-from-response",
+          contentType: "text/plain",
+          url: url,
+          date: date,
+          refersTo: state.originalWarcRecordId,
+        },
+        { type: "text-from-response", url: url },
+        "replay",
+      );
+      logger.info(
+        "Wrote raw text to WARC",
+        { url, length: rawText.length, refersTo: state.originalWarcRecordId },
+        "replay",
+      );
+    }
+
+    // Get the crawl-time rendered text (extracted from browser after JS runs)
+    const origText = state.originalText;
+
+    if (rawText === undefined || origText === undefined) {
+      logger.warn(
+        "Text missing for raw vs rendered comparison",
+        {
+          url,
+          rawTextLen: rawText?.length,
+          renderedTextLen: origText?.length,
+        },
+        "replay",
+      );
+      return;
+    }
+
+    const dist = levenshtein(rawText, origText);
+    const maxLen = Math.max(rawText.length, origText.length);
+
+    let matchPercent = 1.0;
+    if (maxLen > 0) {
+      matchPercent = (maxLen - dist) / maxLen;
+    }
+    logger.info("Raw vs Rendered Text Levenshtein Dist", {
+      url,
+      dist,
+      matchPercent,
+      maxLen,
+      rawTextLen: rawText.length,
+      renderedTextLen: origText.length,
+    });
+
+    const pageInfo = this.pageInfos.get(page);
+    if (pageInfo) {
+      pageInfo.comparison.rawTextMatch = matchPercent;
+    }
+  }
+
+  async extractRawTextFromArchive(
+    page: Page,
+    url: string,
+    date: Date,
+  ): Promise<string | undefined> {
+    const timestamp = date.toISOString().slice(0, 19).replace(/[T:-]/g, "");
+    // `id_` suffix ensures wabac.js serves the unaltered source
+    const replayUrl = REPLAY_PREFIX + `${timestamp}id_/${url}`;
+
+    const frame = page.frames()[1];
+    if (!frame) {
+      logger.warn(
+        "Replay frame missing for raw text extraction",
+        { url },
+        "replay",
+      );
+      return undefined;
+    }
+
+    const htmlContent = await frame.evaluate(async (url) => {
+      const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+      });
+      if (response.status !== 200) {
+        return undefined;
+      }
+      return await response.text();
+    }, replayUrl);
+
+    if (!htmlContent) {
+      logger.warn(
+        "Could not fetch HTML content for raw text extraction",
+        { url },
+        "replay",
+      );
+      return undefined;
+    }
+
+    // Extract text from the raw HTML using the shared extraction logic
+    const { JSDOM } = await import("jsdom");
+    const dom = new JSDOM(htmlContent);
+    try {
+      return extractTextFromDOM(dom.window.document);
+    } finally {
+      dom.window.close();
+    }
+  }
+
+  async writeHtmlToWarc(
+    page: Page,
+    url: string,
+    date: Date,
+    originalWarcRecordId?: string,
+  ) {
+    const timestamp = date.toISOString().slice(0, 19).replace(/[T:-]/g, "");
+    // `id_` suffix ensures wabac.js serves the unaltered source
+    const replayUrl = REPLAY_PREFIX + `${timestamp}id_/${url}`;
+
+    const frame = page.frames()[1];
+    if (!frame) {
+      logger.warn(
+        "Replay frame missing for HTML extraction",
+        { url },
+        "replay",
+      );
+      return;
+    }
+
+    const htmlContent = await frame.evaluate(async (url) => {
+      const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+      });
+      if (response.status !== 200) {
+        return undefined;
+      }
+      return await response.text();
+    }, replayUrl);
+
+    if (!htmlContent) {
+      logger.warn("Could not fetch HTML content for WARC", { url }, "replay");
+      return;
+    }
+
+    if (this.htmlWriter) {
+      this.htmlWriter.writeNewResourceRecord(
+        {
+          buffer: new TextEncoder().encode(htmlContent),
+          resourceType: "html-response",
+          contentType: "text/html",
+          url: url,
+          date: date,
+          refersTo: originalWarcRecordId,
+        },
+        { type: "html-response", url: url },
+        "replay",
+      );
+      logger.info(
+        "Wrote HTML to WARC",
+        { url, length: htmlContent.length, refersTo: originalWarcRecordId },
+        "replay",
+      );
+    }
+  }
+
   async compareResources(
     page: Page,
     state: PageState,
@@ -628,6 +924,14 @@ export class ReplayCrawler extends Crawler {
       pageInfo.ts = origResData.ts;
     }
 
+    const status = origResData.urls[origResData.url]?.status;
+
+    logger.info("Page Resource Status", { status });
+
+    if (origResData.url && status === 200) {
+      state.doRawTextCompare = true;
+    }
+
     const { resourceCounts } = pageInfo.comparison;
 
     const { good: crawlGood, bad: crawlBad } = this.countResources(origResData);
@@ -739,6 +1043,9 @@ export class ReplayCrawler extends Crawler {
     if (this.infoWriter) {
       await this.infoWriter.flush();
     }
+    if (this.htmlWriter) {
+      await this.htmlWriter.flush();
+    }
   }
 
   async processPageInfo(page: Page, state?: PageState) {
@@ -755,7 +1062,7 @@ export class ReplayCrawler extends Crawler {
       if (state) {
         const { comparison } = pageInfo;
 
-        // add comparison to page state
+        // add comparison & csr clues to page state
         (state as ComparisonPageState).comparison = comparison;
       }
 
@@ -765,20 +1072,132 @@ export class ReplayCrawler extends Crawler {
           resourceType: "pageinfo",
           contentType: "application/json",
           url: pageInfo.url,
+          refersTo: state?.originalWarcRecordId,
         },
         { type: "pageinfo", url: pageInfo.url },
         "replay",
       );
+      logger.debug(
+        "Wrote pageinfo to WARC",
+        { url: pageInfo.url, refersTo: state?.originalWarcRecordId },
+        "replay",
+      );
 
       this.pageInfos.delete(page);
     }
   }
 
+  async processCSRClues(page: Page, state?: PageState) {
+    const pageInfo = this.pageInfos.get(page);
+    if (!pageInfo) {
+      logger.warn("No pageInfo found for CSR clues processing", {}, "replay");
+      return;
+    }
+
+    if (!state?.isHTMLPage) {
+      logger.info(
+        "Skipping CSR clues - not an HTML page",
+        { url: pageInfo.url },
+        "replay",
+      );
+      return;
+    }
+
+    if (!pageInfo.ts) {
+      logger.warn("Missing page timestamp, skipping", { pageInfo });
+      return;
+    }
+
+    const timestamp = new Date(pageInfo.ts)
+      .toISOString()
+      .slice(0, 19)
+      .replace(/[T:-]/g, "");
+    // `id_` suffix to timestamp ensures wabac.js serves the unaltered source
+    const replayUrl = REPLAY_PREFIX + `${timestamp}id_/${pageInfo.url}`;
+
+    const frame = page.frames()[1];
+    if (!frame) {
+      logger.warn(
+        "Replay frame missing for CSR clues",
+        { url: pageInfo.url },
+        "replay",
+      );
+      return;
+    }
+
+    const htmlContent = await frame.evaluate(async (url) => {
+      const response = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+      });
+      if (response.status !== 200) {
+        console.log("Got non-200 status code, proceeding", { url });
+      }
+      return await response.text();
+    }, replayUrl);
+
+    if (!htmlContent) {
+      logger.warn(
+        "Could not fetch HTML content for CSR clues",
+        { url: pageInfo.url },
+        "replay",
+      );
+      return;
+    }
+
+    const clueCounts: Record<string, number> = {};
+    const categoryCounts: Record<string, number> = {};
+
+    for (const clue of CSR_CLUES) {
+      const regex = new RegExp(clue.pattern, "gi");
+      const matches = htmlContent.match(regex);
+
+      if (matches && matches.length > 0) {
+        // count by clue name
+        clueCounts[clue.name] = matches.length;
+
+        // count by category (sum of all patterns in category)
+        categoryCounts[clue.category] =
+          (categoryCounts[clue.category] || 0) + matches.length;
+
+        logger.debug(
+          "CSR clue detected",
+          {
+            pattern: clue.name,
+            category: clue.category,
+            url: pageInfo.url,
+            count: matches.length,
+          },
+          "replay",
+        );
+      }
+    }
+
+    // add clue counts to pageInfo
+    pageInfo.comparison["csrClues"] = {
+      clues: clueCounts,
+      categories: categoryCounts,
+    };
+    if (Object.keys(clueCounts).length > 0) {
+      logger.info(
+        "CSR clues detected",
+        {
+          url: pageInfo.url,
+          categories: categoryCounts,
+          clues: clueCounts,
+        },
+        "replay",
+      );
+    } else {
+      logger.info("No CSR clues detected", { url: pageInfo.url }, "replay");
+    }
+  }
+
   protected pageEntryForRedis(
     entry: Record<string, string | number | boolean | object>,
-    state: PageState,
+    state: ComparisonPageState,
   ) {
-    entry.comparison = (state as ComparisonPageState).comparison;
+    entry.comparison = state.comparison;
     return entry;
   }
 
diff --git a/src/util/argParser.ts b/src/util/argParser.ts
index f1f41b082..7afe345d5 100644
--- a/src/util/argParser.ts
+++ b/src/util/argParser.ts
@@ -19,6 +19,7 @@ import {
   DEFAULT_MAX_RETRIES,
   BxFunctionBindings,
   DEFAULT_CRAWL_ID_TEMPLATE,
+  type ExtractTextType,
 } from "./constants.js";
 import { interpolateFilename } from "./storage.js";
 import { screenshotTypes } from "./screenshots.js";
@@ -38,7 +39,7 @@ export type CrawlerArgs = ReturnType<typeof parseArgs> & {
   logLevel: LogLevel[];
   logContext: LogContext[];
   logExcludeContext: LogContext[];
-  text: string[];
+  text: ExtractTextType[];
 
   customBehaviors: string[];
 
@@ -704,6 +705,12 @@ class ArgParser {
           type: "boolean",
         },
 
+        qaDetectClientSideRendering: {
+          describe:
+            "use heuristics to detect when a page might use client-side rendering (CSR)",
+          type: "boolean",
+        },
+
         sshProxyPrivateKeyFile: {
           describe:
             "path to SSH private key for SOCKS5 over SSH proxy connection",
diff --git a/src/util/clientSideRenderingClues.ts b/src/util/clientSideRenderingClues.ts
new file mode 100644
index 000000000..5c0efbadd
--- /dev/null
+++ b/src/util/clientSideRenderingClues.ts
@@ -0,0 +1,213 @@
+export type CSRClue = {
+  name: string;
+  category: string;
+  pattern: string;
+  description: string;
+};
+
+/**
+ * Various clues to identify client-side rendering (CSR) in source HTML.
+ */
+export const CSR_CLUES: CSRClue[] = [
+  // Empty container divs
+  {
+    name: "empty_div",
+    category: "empty_container",
+    pattern:
+      "<div\\s+id=[\"'](?:app|root|mount|application|main|__next|__nuxt|react-root|vue-app|gatsby-focus-wrapper)[\"']\\s*>\\s*</div>",
+    description: "Empty container divs typical of SPA/CSR",
+  },
+  {
+    name: "empty_div_self_closing",
+    category: "empty_container",
+    pattern:
+      "<div\\s+id=[\"'](?:app|root|mount|application|main|__next|__nuxt|react-root|vue-app|gatsby-focus-wrapper)[\"']\\s*/>",
+    description: "Empty container divs typical of SPA/CSR (self-closing)",
+  },
+  // Framework meta tags
+  {
+    name: "nextjs_generator",
+    category: "framework_meta",
+    pattern: "<meta\\s+name=[\"']generator[\"']\\s+content=[\"']Next\\.js[\"']",
+    description: "Next.js generator meta tag",
+  },
+  {
+    name: "nextjs_head_count",
+    category: "framework_meta",
+    pattern: "<meta\\s+name=[\"']next-head-count[\"']",
+    description: "Next.js head count meta tag",
+  },
+  {
+    name: "framework_meta",
+    category: "framework_meta",
+    pattern:
+      "<meta\\s+name=[\"']framework[\"']\\s+content=[\"'](?:React|Vue\\.js|Angular)[\"']",
+    description: "Framework meta tag",
+  },
+  {
+    name: "app_name_meta",
+    category: "framework_meta",
+    pattern:
+      "<meta\\s+name=[\"']application-name[\"']\\s+content=[\"'](?:Vue\\s+App|React\\s+App)[\"']",
+    description: "Application name meta tag",
+  },
+  // Bundler scripts
+  {
+    name: "bundler_script",
+    category: "bundler_scripts",
+    pattern:
+      "<script[^>]*src=[\"'][^\"']*(?:webpack|vite|parcel|rollup|esbuild)[^\"']*\\.js[\"']",
+    description: "Bundler script",
+  },
+  {
+    name: "bundled_script",
+    category: "bundler_scripts",
+    pattern:
+      "<script[^>]*src=[\"'][^\"']*(?:bundle|chunk|vendor|runtime|main)[^\"']*\\.[a-f0-9]{8,}\\.js[\"']",
+    description: "Bundled script with hash",
+  },
+  {
+    name: "webpack_data_attr",
+    category: "bundler_scripts",
+    pattern: "<script[^>]*\\sdata-webpack=[\"'][^\"']*[\"']",
+    description: "Webpack data attribute",
+  },
+  {
+    name: "vite_data_attr",
+    category: "bundler_scripts",
+    pattern: "<script[^>]*\\sdata-vite-fid=[\"'][^\"']*[\"']",
+    description: "Vite data attribute",
+  },
+  // Hydration data
+  {
+    name: "nextjs_hydration",
+    category: "hydration_data",
+    pattern: "<script[^>]*id=[\"']__NEXT_DATA__[\"']",
+    description: "Next.js hydration data",
+  },
+  {
+    name: "nuxt_hydration",
+    category: "hydration_data",
+    pattern: "<script[^>]*id=[\"']__NUXT(?:_DATA)?__[\"']",
+    description: "Nuxt hydration data",
+  },
+  {
+    name: "vue_hydration",
+    category: "hydration_data",
+    pattern: "<script[^>]*id=[\"']__VUE__[\"']",
+    description: "Vue hydration data",
+  },
+  {
+    name: "angular_hydration",
+    category: "hydration_data",
+    pattern: "<script[^>]*id=[\"']ng-state[\"']",
+    description: "Angular hydration data",
+  },
+  {
+    name: "svelte_hydration",
+    category: "hydration_data",
+    pattern: "data-sveltekit-hydrate",
+    description: "Svelte hydration data",
+  },
+  // Noscript warnings
+  {
+    name: "noscript",
+    category: "noscript_warning",
+    pattern: "<noscript>",
+    description: "Noscript warning requiring JavaScript",
+  },
+  {
+    name: "react_noscript",
+    category: "noscript_warning",
+    pattern: "<noscript>You\\s+need\\s+to\\s+enable\\s+JavaScript",
+    description: "React noscript warning",
+  },
+  // Modern script loading
+  {
+    name: "async_script",
+    category: "modern_script_loading",
+    pattern: "<script[^>]*\\sasync[^>]*>",
+    description: "Async script loading",
+  },
+  {
+    name: "defer_script",
+    category: "modern_script_loading",
+    pattern: "<script[^>]*\\sdefer[^>]*>",
+    description: "Defer script loading",
+  },
+  {
+    name: "module_script",
+    category: "modern_script_loading",
+    pattern: "<script[^>]*\\stype=[\"']module[\"'][^>]*>",
+    description: "ES module script",
+  },
+  {
+    name: "dynamic_import",
+    category: "modern_script_loading",
+    pattern: "import\\s*\\(",
+    description: "Dynamic import()",
+  },
+  // Web components
+  {
+    name: "multi_part_element_name",
+    category: "web_components",
+    pattern: "<\\w+(?:-\\w+)+\\b",
+    description:
+      "Multi-part element name (custom elements must have a dash in the name)",
+  },
+  {
+    name: "custom_elements_api",
+    category: "web_components",
+    pattern:
+      "customElements\\.(?:define|get|getName|upgrade|initialize|whenDefined)",
+    description:
+      "Defining/registering a custom element using the Custom Elements API",
+  },
+  {
+    name: "custom_element_registry",
+    category: "web_components",
+    pattern: "customElementRegistry",
+    description: "Custom element registry",
+  },
+  // Direct DOM manipulation
+  {
+    name: "dom_manipulation",
+    category: "dom_manipulation",
+    pattern:
+      "[\\w\\d_]+(?:[\"'`]?\\])?\\.(?:createElement|createElementNS|createTextNode|appendChild|append|appendNode|replaceChild|replaceChildren|replaceWith|insertBefore|insertAdjacentElement|insertAdjacentHTML|insertAdjacentText|removeChild|remove|moveBefore|innerHTML|innerText)",
+    description: "Create/add/move/remove a node/element/text to/from the DOM",
+  },
+  {
+    name: "output_element",
+    category: "dom_manipulation",
+    pattern: "<output[^>]*>",
+    description:
+      "Output element (often used for outputs of calculations or form results)",
+  },
+  {
+    name: "template_element",
+    category: "dom_manipulation",
+    pattern: "<template[^>]*>",
+    description:
+      "Template element (used for defining reusable HTML structures that can be cloned and inserted into the DOM with JS)",
+  },
+  // Frames and embeds (e.g. iframes)
+  {
+    name: "iframe",
+    category: "frames_and_embeds",
+    pattern: "<iframe[^>]*>",
+    description: "Iframe element",
+  },
+  {
+    name: "object",
+    category: "frames_and_embeds",
+    pattern: "<object[^>]*>",
+    description: "Object element",
+  },
+  {
+    name: "embed",
+    category: "frames_and_embeds",
+    pattern: "<embed[^>]*>",
+    description: "Embed element",
+  },
+];
diff --git a/src/util/constants.ts b/src/util/constants.ts
index 902e081a6..1f0945eea 100644
--- a/src/util/constants.ts
+++ b/src/util/constants.ts
@@ -20,7 +20,13 @@ export type ServiceWorkerOpt = (typeof SERVICE_WORKER_OPTS)[number];
 
 export const DETECT_SITEMAP = "<detect>";
 
-export const EXTRACT_TEXT_TYPES = ["to-pages", "to-warc", "final-to-warc"];
+export const EXTRACT_TEXT_TYPES = [
+  "to-pages",
+  "to-warc",
+  "final-to-warc",
+  "to-warc-from-raw",
+] as const;
+export type ExtractTextType = (typeof EXTRACT_TEXT_TYPES)[number];
 
 export const DUPE_ALL_HASH_KEY = "alldupes";
 export const DUPE_ALL_CRAWLS = "allcrawls";
diff --git a/src/util/state.ts b/src/util/state.ts
index 48211fb8d..80fa46998 100644
--- a/src/util/state.ts
+++ b/src/util/state.ts
@@ -59,6 +59,7 @@ export type QueueEntry = {
   ts?: number;
   pageid?: string;
   retry?: number;
+  originalWarcRecordId?: string;
 };
 
 // ============================================================================
@@ -93,8 +94,13 @@ export class PageState {
 
   isHTMLPage = true;
   text?: string;
+  originalText?: string;
+  doRawTextCompare?: boolean;
+  textFromResponse?: string;
+  documentRequestId?: string;
   screenshotView?: Buffer;
   favicon?: string;
+  originalWarcRecordId?: string;
 
   skipBehaviors = false;
   pageSkipped = false;
@@ -119,6 +125,16 @@ export class PageState {
     this.pageid = redisData.pageid || uuidv4();
     this.status = 0;
     this.retry = redisData.retry || 0;
+    this.originalWarcRecordId = redisData.originalWarcRecordId;
+    logger.debug(
+      "PageState created",
+      {
+        url: this.url,
+        pageid: this.pageid,
+        originalWarcRecordId: String(this.originalWarcRecordId),
+      },
+      "state",
+    );
   }
 }
 
@@ -1275,6 +1291,7 @@ return inx;
       extraHops = 0,
       ts = 0,
       pageid = undefined,
+      originalWarcRecordId = undefined,
     }: QueueEntry,
     limit = 0,
   ) {
@@ -1290,6 +1307,9 @@ return inx;
     if (pageid) {
       data.pageid = pageid;
     }
+    if (originalWarcRecordId) {
+      data.originalWarcRecordId = originalWarcRecordId;
+    }
 
     // return codes
     // 0 - url queued successfully
diff --git a/src/util/textextract.ts b/src/util/textextract.ts
index 816668b4e..71cb53225 100644
--- a/src/util/textextract.ts
+++ b/src/util/textextract.ts
@@ -1,24 +1,28 @@
 import { logger } from "./logger.js";
 import { CDPSession, Protocol } from "puppeteer-core";
 import { WARCWriter } from "./warcwriter.js";
+import { JSDOM } from "jsdom";
 
 // ============================================================================
-type TextExtractOpts = {
+interface TextExtractOptsBase {
   url: string;
   writer: WARCWriter;
   skipDocs: number;
-};
+}
+
+interface TextExtractViaResponseOpts extends TextExtractOptsBase {
+  requestId?: string;
+}
 
 // ============================================================================
 export abstract class BaseTextExtract {
-  cdp: CDPSession;
-  lastText: string | null = null;
-  text: string | null = null;
-  skipDocs: number = 0;
-  writer: WARCWriter;
-  url: string;
+  protected cdp: CDPSession;
+  protected lastText: string | null = null;
+  protected skipDocs: number = 0;
+  protected writer: WARCWriter;
+  protected url: string;
 
-  constructor(cdp: CDPSession, { writer, skipDocs, url }: TextExtractOpts) {
+  constructor(cdp: CDPSession, { writer, skipDocs, url }: TextExtractOptsBase) {
     this.writer = writer;
     this.cdp = cdp;
     this.url = url;
@@ -29,12 +33,13 @@ export abstract class BaseTextExtract {
     resourceType: string,
     ignoreIfMatchesLast = false,
     saveToWarc = false,
+    refersTo?: string,
   ) {
     try {
       const text = await this.doGetText();
 
       if (ignoreIfMatchesLast && text === this.lastText) {
-        this.lastText = this.text;
+        this.lastText = text;
         logger.debug(
           "Skipping, extracted text unchanged from last extraction",
           { url: this.url },
@@ -49,6 +54,7 @@ export abstract class BaseTextExtract {
             resourceType,
             contentType: "text/plain",
             url: this.url,
+            refersTo,
           },
           {
             resource: "text",
@@ -77,130 +83,236 @@ export class TextExtractViaSnapshot extends BaseTextExtract {
     const result = await this.cdp.send("DOMSnapshot.captureSnapshot", {
       computedStyles: [],
     });
-    return this.parseTextFromDOMSnapshot(result);
+    return extractTextFromDOMSnapshot(result, this.skipDocs);
   }
+}
 
-  parseTextFromDOMSnapshot(
-    result: Protocol.DOMSnapshot.CaptureSnapshotResponse,
-  ): string {
-    const TEXT_NODE = 3;
-    const ELEMENT_NODE = 1;
-
-    const SKIPPED_NODES = [
-      "SCRIPT",
-      "STYLE",
-      "HEADER",
-      "FOOTER",
-      "BANNER-DIV",
-      "NOSCRIPT",
-      "TITLE",
-    ];
-
-    const { strings, documents } = result;
-
-    const accum: string[] = [];
-
-    for (const doc of documents.slice(this.skipDocs)) {
-      const nodeValues = doc.nodes.nodeValue || [];
-      const nodeNames = doc.nodes.nodeName || [];
-      const nodeTypes = doc.nodes.nodeType || [];
-      const parentIndex = doc.nodes.parentIndex || [];
-
-      for (let i = 0; i < nodeValues.length; i++) {
-        if (nodeValues[i] === -1) {
-          continue;
-        }
+// ============================================================================
+export class TextExtractViaResponse extends BaseTextExtract {
+  protected requestId: string | undefined;
 
-        if (nodeTypes[i] === TEXT_NODE) {
-          const pi = parentIndex[i];
-          if (pi >= 0 && nodeTypes[pi] === ELEMENT_NODE) {
-            const name = strings[nodeNames[pi]];
-
-            if (!SKIPPED_NODES.includes(name)) {
-              const value = strings[nodeValues[i]].trim();
-              if (value) {
-                accum.push(value as string);
-              }
-            }
-          }
-        }
+  constructor(cdp: CDPSession, opts: TextExtractViaResponseOpts) {
+    super(cdp, opts);
+    this.requestId = opts.requestId;
+  }
+
+  async doGetText(): Promise<string> {
+    if (!this.requestId) {
+      logger.warn(
+        "Missing document request ID, skipping",
+        { url: this.url },
+        "text",
+      );
+      throw new Error("Missing document request ID");
+    }
+
+    logger.info(
+      "Fetching raw response body via CDP",
+      { url: this.url, requestId: this.requestId },
+      "text",
+    );
+
+    try {
+      const { body, base64Encoded } = await this.cdp.send(
+        "Network.getResponseBody",
+        {
+          requestId: this.requestId,
+        },
+      );
+
+      const text = base64Encoded
+        ? Buffer.from(body, "base64").toString()
+        : body;
+
+      logger.info(
+        "Got raw response body",
+        { url: this.url, size: text.length },
+        "text",
+      );
+
+      const dom = new JSDOM(text, {
+        runScripts: undefined,
+        resources: undefined,
+      });
+      try {
+        const extracted = this.parseTextFromDOM(dom.window.document);
+        logger.info(
+          "Extracted text from raw response",
+          { url: this.url, textLength: extracted.length },
+          "text",
+        );
+        return extracted;
+      } finally {
+        dom.window.close();
       }
+    } catch (e) {
+      logger.error(
+        "Failed to get response body",
+        { url: this.url, requestId: this.requestId, error: String(e) },
+        "text",
+      );
+      throw e;
     }
+  }
 
-    return accum.join("\n");
+  parseTextFromDOM(dom: Document): string {
+    return extractTextFromDOM(dom);
   }
 }
 
 // ============================================================================
-export class TextExtractViaDocument extends BaseTextExtract {
-  async doGetText(): Promise<string> {
-    const result = await this.cdp.send("DOM.getDocument", {
-      depth: -1,
-      pierce: true,
-    });
-    return this.parseTextFromDOM(result);
-  }
+// Shared text extraction utilities
+// ============================================================================
 
-  parseTextFromDOM(dom: Protocol.DOM.GetDocumentResponse): string {
-    const accum: string[] = [];
-    const metadata = {};
+// Nodes to skip when extracting text (headers, scripts, etc.)
+const SKIPPED_NODES = [
+  "SCRIPT",
+  "STYLE",
+  "HEADER",
+  "FOOTER",
+  "BANNER-DIV",
+  "NOSCRIPT",
+  "TITLE",
+];
 
-    this.parseText(dom.root, metadata, accum);
+const TEXT_NODE = 3;
+const ELEMENT_NODE = 1;
 
-    return accum.join("\n");
-  }
+/**
+ * Normalized node data for text extraction.
+ * Can come from CDP DOMSnapshot or from DOM tree walker.
+ */
+interface NodeData {
+  values: (string | number)[];
+  names: (string | number)[];
+  types: number[];
+  parentIndex: number[];
+  strings?: string[]; // For DOMSnapshot: lookup table for string indices
+}
 
-  parseText(
-    node: Protocol.DOM.Node,
-    metadata: Record<string, string> | null,
-    accum: string[],
-  ) {
-    const SKIPPED_NODES = [
-      "head",
-      "script",
-      "style",
-      "header",
-      "footer",
-      "banner-div",
-      "noscript",
-    ];
-    const EMPTY_LIST: Protocol.DOM.Node[] = [];
-    const TEXT = "#text";
-    const TITLE = "title";
-
-    const name = node.nodeName.toLowerCase();
-
-    if (SKIPPED_NODES.includes(name)) {
-      return;
+/**
+ * Extract text from normalized node data.
+ * Shared logic used by both DOMSnapshot and DOM walker extraction.
+ */
+function extractTextFromNodes(data: NodeData, skipDocs = 0): string {
+  const { values, names, types, parentIndex, strings } = data;
+  const accum: string[] = [];
+
+  // Helper to get string value (handle both direct strings and indices)
+  const getValue = (val: string | number): string => {
+    if (typeof val === "string") return val;
+    // For DOMSnapshot: -1 means no value
+    if (val === -1) return "";
+    return strings?.[val] ?? "";
+  };
+
+  const getName = (val: string | number): string => {
+    if (typeof val === "string") return val;
+    return strings?.[val] ?? "";
+  };
+
+  const startIdx = skipDocs;
+  const endIdx = values.length;
+
+  for (let i = startIdx; i < endIdx; i++) {
+    const textValue = getValue(values[i]);
+
+    // Skip empty values (-1 for snapshot indices, "" for direct strings)
+    if (textValue === "" || values[i] === -1) {
+      continue;
     }
 
-    const children = node.children || EMPTY_LIST;
+    if (types[i] === TEXT_NODE) {
+      const pi = parentIndex[i];
+      if (pi >= 0 && types[pi] === ELEMENT_NODE) {
+        const name = getName(names[pi]);
 
-    if (name === TEXT) {
-      const value = node.nodeValue ? node.nodeValue.trim() : "";
-      if (value) {
-        accum.push(value);
+        if (!SKIPPED_NODES.includes(name)) {
+          const value = textValue.trim();
+          if (value) {
+            accum.push(value);
+          }
+        }
       }
-    } else if (name === TITLE) {
-      const title: string[] = [];
+    }
+  }
 
-      for (const child of children) {
-        this.parseText(child, null, title);
-      }
+  return accum.join("\n");
+}
 
-      if (metadata) {
-        metadata.title = title.join(" ");
-      } else {
-        accum.push(title.join(" "));
-      }
+/**
+ * Extract text from CDP DOMSnapshot response.
+ */
+export function extractTextFromDOMSnapshot(
+  result: Protocol.DOMSnapshot.CaptureSnapshotResponse,
+  skipDocs = 0,
+): string {
+  const { strings, documents } = result;
+  const accum: string[] = [];
+
+  for (const doc of documents.slice(skipDocs)) {
+    const nodeData: NodeData = {
+      values: doc.nodes.nodeValue || [],
+      names: doc.nodes.nodeName || [],
+      types: doc.nodes.nodeType || [],
+      parentIndex: doc.nodes.parentIndex || [],
+      strings,
+    };
+
+    accum.push(extractTextFromNodes(nodeData));
+  }
+
+  return accum.join("\n");
+}
+
+/**
+ * Extract text content from a DOM Document.
+ * Uses createTreeWalker for efficient traversal.
+ * Works with both browser DOM and JSDOM.
+ */
+export function extractTextFromDOM(dom: Document): string {
+  // Build flat arrays similar to DOMSnapshot format
+  const nodeValues: string[] = [];
+  const nodeNames: string[] = [];
+  const nodeTypes: number[] = [];
+  const parentIndex: number[] = [];
+  const nodeToIndex = new Map<Node, number>();
+
+  // Use window.NodeFilter from the document's window (required for JSDOM)
+  const window = dom.defaultView!;
+  const walker = dom.createTreeWalker(
+    dom,
+    window.NodeFilter.SHOW_ELEMENT | window.NodeFilter.SHOW_TEXT,
+    null,
+  );
+
+  let node: Node | null;
+  while ((node = walker.nextNode())) {
+    nodeToIndex.set(node, nodeValues.length);
+    nodeTypes.push(node.nodeType);
+
+    if (node.nodeType === TEXT_NODE) {
+      nodeValues.push(node.textContent || "");
+      nodeNames.push("");
     } else {
-      for (const child of children) {
-        this.parseText(child, metadata, accum);
-      }
+      nodeValues.push("");
+      nodeNames.push((node as Element).tagName);
+    }
 
-      if (node.contentDocument) {
-        this.parseText(node.contentDocument, null, accum);
-      }
+    const parent = node.parentNode;
+    if (parent && nodeToIndex.has(parent)) {
+      parentIndex.push(nodeToIndex.get(parent)!);
+    } else {
+      parentIndex.push(-1);
     }
   }
+
+  const nodeData: NodeData = {
+    values: nodeValues,
+    names: nodeNames,
+    types: nodeTypes,
+    parentIndex,
+  };
+
+  return extractTextFromNodes(nodeData);
 }
diff --git a/src/util/warcwriter.ts b/src/util/warcwriter.ts
index d13b6717d..b4387d020 100644
--- a/src/util/warcwriter.ts
+++ b/src/util/warcwriter.ts
@@ -19,6 +19,7 @@ export type ResourceRecordData = {
   contentType: string;
   url: string;
   date?: Date;
+  refersTo?: string;
 };
 
 // =================================================================
@@ -258,10 +259,14 @@ export class WARCWriter implements IndexerOffsetLength {
     contentType,
     url,
     date,
+    refersTo,
   }: ResourceRecordData) {
     const warcVersion = "WARC/1.1";
     const warcRecordType = "resource";
-    const warcHeaders = { "Content-Type": contentType };
+    const warcHeaders: Record<string, string> = { "Content-Type": contentType };
+    if (refersTo) {
+      warcHeaders["WARC-Refers-To"] = `<url:uuid:${refersTo}>`;
+    }
     async function* content() {
       yield buffer;
     }
diff --git a/tests/qa_compare.test.js b/tests/qa_compare.test.js
index f2b1aa870..74cc5be9d 100644
--- a/tests/qa_compare.test.js
+++ b/tests/qa_compare.test.js
@@ -2,7 +2,22 @@ import child_process from "child_process";
 import fs from "fs";
 import { Redis } from "ioredis";
 
+/**
+ *
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
 const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
+/**
+ *
+ * @param {child_process.ChildProcess} child
+ * @returns {Promise<string>}
+ */
+const asPromise = (child) =>
+  new Promise(function (resolve, reject) {
+    child.addListener("error", reject);
+    child.addListener("exit", resolve);
+  });
 
 test("run initial crawl with text and screenshots to prepare for QA", async () => {
   fs.rmSync("./test-crawls/qa-wr-net", { recursive: true, force: true });
@@ -16,7 +31,7 @@ test("run initial crawl with text and screenshots to prepare for QA", async () =
   ).toBe(true);
 });
 
-test("run QA comparison, with write pages to redis", async () => {
+test("run QA comparison without CSR detection, with write pages to redis", async () => {
   fs.rmSync("./test-crawls/qa-wr-net-replay", { recursive: true, force: true });
 
   const child = child_process.exec(
@@ -28,8 +43,12 @@ test("run QA comparison, with write pages to redis", async () => {
   child.on("exit", function () {
     crawler_exited = true;
   });
+  const crawlerExitedPromise = asPromise(child);
 
-  const redis = new Redis("redis://127.0.0.1:36380/0", { lazyConnect: true, retryStrategy: () => null });
+  const redis = new Redis("redis://127.0.0.1:36380/0", {
+    lazyConnect: true,
+    retryStrategy: () => null,
+  });
 
   await sleep(3000);
 
@@ -58,9 +77,11 @@ test("run QA comparison, with write pages to redis", async () => {
 
     expect(json.comparison).toHaveProperty("screenshotMatch");
     expect(json.comparison).toHaveProperty("textMatch");
+    expect(json.comparison).toHaveProperty("rawTextMatch");
     expect(json.comparison).toHaveProperty("resourceCounts");
     expect(json.comparison.screenshotMatch).toBe(1);
     expect(json.comparison.textMatch).toBe(1);
+    expect(typeof json.comparison.rawTextMatch).toBe("number");
 
     expect(json.comparison.resourceCounts).toHaveProperty("crawlGood");
     expect(json.comparison.resourceCounts).toHaveProperty("crawlBad");
@@ -73,7 +94,94 @@ test("run QA comparison, with write pages to redis", async () => {
   expect(count).toBe(3);
 
   // wait for crawler exit
-  while (!crawler_exited) {
-    await sleep(100);
+  await crawlerExitedPromise;
+});
+
+test("run QA comparison with CSR detection, with write pages to redis", async () => {
+  fs.rmSync("./test-crawls/qa-wr-net-replay-with-csr-detection", {
+    recursive: true,
+    force: true,
+  });
+
+  const child = child_process.exec(
+    "docker run -p 36380:6379 -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler qa --qaSource /crawls/collections/qa-wr-net/qa-wr-net.wacz --collection qa-wr-net-replay-with-csr-detection --crawlId test-with-csr-detection --qaDebugImageDiff --qaDetectClientSideRendering --writePagesToRedis --debugAccessRedis --exclude contact",
+  );
+
+  // detect crawler exit
+  let crawler_exited = false;
+  child.on("exit", function () {
+    crawler_exited = true;
+  });
+  const crawlerExitedPromise = asPromise(child);
+
+  const redis = new Redis("redis://127.0.0.1:36380/0", {
+    lazyConnect: true,
+    retryStrategy: () => null,
+  });
+
+  await sleep(3000);
+
+  await redis.connect({ maxRetriesPerRequest: 50 });
+
+  let count = 0;
+
+  const expectedCSRCluesValues = {
+    "https://old.webrecorder.net/": {
+      clues: { dom_manipulation: 4 },
+      categories: { dom_manipulation: 4 },
+    },
+    "https://archiveweb.page/": {
+      clues: { defer_script: 1 },
+      categories: { modern_script_loading: 1 },
+    },
+    "https://old.webrecorder.net/about": { clues: {}, categories: {} },
+  };
+
+  while (count < 3) {
+    const res = await redis.lpop("test-with-csr-detection:pages");
+    if (!res) {
+      if (crawler_exited) {
+        break;
+      }
+      await sleep(100);
+      continue;
+    }
+    const json = JSON.parse(res);
+    expect(json).toHaveProperty("id");
+    expect(json).toHaveProperty("url");
+    expect(json).toHaveProperty("ts");
+    expect(json).toHaveProperty("title");
+    expect(json).toHaveProperty("loadState");
+    expect(json).toHaveProperty("comparison");
+
+    expect(json.title.indexOf("contact") < 0).toBe(true);
+
+    expect(json.comparison).toHaveProperty("screenshotMatch");
+    expect(json.comparison).toHaveProperty("textMatch");
+    expect(json.comparison).toHaveProperty("rawTextMatch");
+    expect(json.comparison).toHaveProperty("resourceCounts");
+    expect(json.comparison.screenshotMatch).toBe(1);
+    expect(json.comparison.textMatch).toBe(1);
+    expect(typeof json.comparison.rawTextMatch).toBe("number");
+
+    expect(json.comparison.resourceCounts).toHaveProperty("crawlGood");
+    expect(json.comparison.resourceCounts).toHaveProperty("crawlBad");
+    expect(json.comparison.resourceCounts).toHaveProperty("replayGood");
+    expect(json.comparison.resourceCounts).toHaveProperty("replayBad");
+
+    expect(json.comparison).toHaveProperty("csrClues");
+    expect(json.comparison.csrClues).toHaveProperty("clues");
+    expect(json.comparison.csrClues.clues).toBeInstanceOf(Object);
+    expect(json.comparison.csrClues).toHaveProperty("categories");
+    expect(json.comparison.csrClues.categories).toBeInstanceOf(Object);
+
+    expect(json.comparison.csrClues).toEqual(expectedCSRCluesValues[json.url]);
+
+    count++;
   }
+
+  expect(count).toBe(3);
+
+  // wait for crawler exit
+  await crawlerExitedPromise;
 });
diff --git a/tests/raw-text-extract.test.js b/tests/raw-text-extract.test.js
new file mode 100644
index 000000000..ea75a99e9
--- /dev/null
+++ b/tests/raw-text-extract.test.js
@@ -0,0 +1,162 @@
+import child_process from "child_process";
+import fs from "fs";
+import { Redis } from "ioredis";
+
+/**
+ *
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
+
+/**
+ *
+ * @param {child_process.ChildProcess} child
+ * @returns {Promise<string>}
+ */
+const asPromise = (child) =>
+  new Promise(function (resolve, reject) {
+    child.addListener("error", reject);
+    child.addListener("exit", resolve);
+  });
+
+test("run crawl with to-warc-from-raw option and verify text records", async () => {
+  fs.rmSync("./test-crawls/raw-text-test", { recursive: true, force: true });
+
+  child_process.execSync(
+    "docker run -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler crawl --url https://old.webrecorder.net/ --scopeType page --collection raw-text-test --text to-warc,to-warc-from-raw --generateCDX",
+  );
+
+  const cdxData = fs.readFileSync(
+    "test-crawls/collections/raw-text-test/indexes/index.cdxj",
+    { encoding: "utf-8" },
+  );
+
+  // Check that both regular text and raw text records exist
+  expect(cdxData.indexOf("urn:text:https://old.webrecorder.net/") >= 0).toBe(true);
+  expect(cdxData.indexOf("urn:text-from-response:https://old.webrecorder.net/") >= 0).toBe(true);
+});
+
+test("verify raw text and rendered text are different for CSR pages", async () => {
+  fs.rmSync("./test-crawls/csr-test", { recursive: true, force: true });
+
+  // Crawl a page known to have client-side rendering
+  child_process.execSync(
+    "docker run -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler crawl --url https://old.webrecorder.net/ --scopeType page --collection csr-test --text to-warc,to-warc-from-raw --generateWACZ",
+  );
+
+  expect(
+    fs.existsSync("test-crawls/collections/csr-test/csr-test.wacz"),
+  ).toBe(true);
+});
+
+test("run QA comparison with raw text match", async () => {
+  fs.rmSync("./test-crawls/qa-raw-text-replay", { recursive: true, force: true });
+
+  const child = child_process.exec(
+    "docker run -p 36381:6379 -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler qa --qaSource /crawls/collections/raw-text-test/raw-text-test.wacz --collection qa-raw-text-replay --crawlId raw-text-test --writePagesToRedis --debugAccessRedis",
+  );
+
+  // detect crawler exit
+  let crawler_exited = false;
+  child.on("exit", function () {
+    crawler_exited = true;
+  });
+  const crawlerExitedPromise = asPromise(child);
+
+  const redis = new Redis("redis://127.0.0.1:36381/0", {
+    lazyConnect: true,
+    retryStrategy: () => null,
+  });
+
+  await sleep(3000);
+
+  await redis.connect({ maxRetriesPerRequest: 50 });
+
+  let count = 0;
+
+  while (count < 1) {
+    const res = await redis.lpop("raw-text-test:pages");
+    if (!res) {
+      if (crawler_exited) {
+        break;
+      }
+      await sleep(100);
+      continue;
+    }
+    const json = JSON.parse(res);
+    expect(json).toHaveProperty("id");
+    expect(json).toHaveProperty("url");
+    expect(json).toHaveProperty("comparison");
+
+    // Check that raw text comparison is present
+    expect(json.comparison).toHaveProperty("rawTextMatch");
+    expect(typeof json.comparison.rawTextMatch).toBe("number");
+    expect(json.comparison.rawTextMatch).toBeGreaterThanOrEqual(0);
+    expect(json.comparison.rawTextMatch).toBeLessThanOrEqual(1);
+
+    // Check that both regular and raw text comparisons exist
+    expect(json.comparison).toHaveProperty("textMatch");
+    expect(json.comparison).toHaveProperty("screenshotMatch");
+
+    count++;
+  }
+
+  expect(count).toBe(1);
+
+  // wait for crawler exit
+  await crawlerExitedPromise;
+});
+
+test("run QA comparison with fallback to on-the-fly raw text extraction", async () => {
+  // Use the original qa-wr-net archive which doesn't have stored raw text
+  fs.rmSync("./test-crawls/qa-fallback-test", { recursive: true, force: true });
+
+  const child = child_process.exec(
+    "docker run -p 36382:6379 -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler qa --qaSource /crawls/collections/qa-wr-net/qa-wr-net.wacz --collection qa-fallback-test --crawlId fallback-test --writePagesToRedis --debugAccessRedis --exclude contact",
+  );
+
+  // detect crawler exit
+  let crawler_exited = false;
+  child.on("exit", function () {
+    crawler_exited = true;
+  });
+  const crawlerExitedPromise = asPromise(child);
+
+  const redis = new Redis("redis://127.0.0.1:36382/0", {
+    lazyConnect: true,
+    retryStrategy: () => null,
+  });
+
+  await sleep(3000);
+
+  await redis.connect({ maxRetriesPerRequest: 50 });
+
+  let count = 0;
+
+  while (count < 3) {
+    const res = await redis.lpop("fallback-test:pages");
+    if (!res) {
+      if (crawler_exited) {
+        break;
+      }
+      await sleep(100);
+      continue;
+    }
+    const json = JSON.parse(res);
+    expect(json).toHaveProperty("id");
+    expect(json).toHaveProperty("url");
+    expect(json).toHaveProperty("comparison");
+
+    // Check that raw text comparison works even without stored raw text
+    expect(json.comparison).toHaveProperty("rawTextMatch");
+    expect(typeof json.comparison.rawTextMatch).toBe("number");
+
+    count++;
+  }
+
+  expect(count).toBe(3);
+
+  // wait for crawler exit
+  await crawlerExitedPromise;
+});
diff --git a/tests/text-extract.test.js b/tests/text-extract.test.js
index 9f12edaa3..95b83959e 100644
--- a/tests/text-extract.test.js
+++ b/tests/text-extract.test.js
@@ -20,3 +20,26 @@ test("check that urn:text and urn:textfinal records are written to WARC", async
 
   expect(data.indexOf("urn:textFinal:https://www.nytimes.com/") > 0).toBe(true);
 });
+
+test("check that raw text extraction creates urn:text-from-response records", async () => {
+  fs.rmSync("./test-crawls/raw-text-crawl", { recursive: true, force: true });
+  
+  try {
+    child_process.execSync(
+      "docker run -v $PWD/test-crawls:/crawls webrecorder/browsertrix-crawler crawl --collection raw-text-crawl --url https://example.com/ --scopeType page --generateCDX --text to-warc,to-warc-from-raw",
+    );
+  } catch (error) {
+    console.log(error.stderr);
+  }
+
+  const data = fs.readFileSync(
+    "test-crawls/collections/raw-text-crawl/indexes/index.cdxj",
+    { encoding: "utf-8" },
+  );
+
+  // Regular rendered text record
+  expect(data.indexOf("urn:text:https://example.com/") >= 0).toBe(true);
+  
+  // Raw response text record
+  expect(data.indexOf("urn:text-from-response:https://example.com/") >= 0).toBe(true);
+});
diff --git a/tests/textextract-unit.test.js b/tests/textextract-unit.test.js
new file mode 100644
index 000000000..24258b797
--- /dev/null
+++ b/tests/textextract-unit.test.js
@@ -0,0 +1,189 @@
+import { extractTextFromDOM, extractTextFromDOMSnapshot } from "../src/util/textextract.js";
+import { JSDOM } from "jsdom";
+
+describe("extractTextFromDOM", () => {
+  test("extracts text from simple HTML", () => {
+    const html = `
+      <html>
+        <body>
+          <h1>Title</h1>
+          <p>Paragraph text</p>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toContain("Title");
+    expect(text).toContain("Paragraph text");
+  });
+
+  test("skips script and style content", () => {
+    const html = `
+      <html>
+        <head>
+          <style>body { color: red; }</style>
+        </head>
+        <body>
+          <p>Visible text</p>
+          <script>var x = 'hidden';</script>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toContain("Visible text");
+    expect(text).not.toContain("color: red");
+    expect(text).not.toContain("hidden");
+  });
+
+  test("skips header, footer, and noscript", () => {
+    const html = `
+      <html>
+        <body>
+          <header>Header content</header>
+          <main>Main content</main>
+          <footer>Footer content</footer>
+          <noscript>No script content</noscript>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toContain("Main content");
+    expect(text).not.toContain("Header content");
+    expect(text).not.toContain("Footer content");
+    expect(text).not.toContain("No script content");
+  });
+
+  test("skips title tag content", () => {
+    const html = `
+      <html>
+        <head><title>Page Title</title></head>
+        <body>
+          <p>Body content</p>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toContain("Body content");
+    expect(text).not.toContain("Page Title");
+  });
+
+  test("handles deeply nested elements", () => {
+    const html = `
+      <html>
+        <body>
+          <div>
+            <div>
+              <div>
+                <p>Deeply nested text</p>
+              </div>
+            </div>
+          </div>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toContain("Deeply nested text");
+  });
+
+  test("returns empty string for empty document", () => {
+    const html = `<html><body></body></html>`;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toBe("");
+  });
+
+  test("trims whitespace from text nodes", () => {
+    const html = `
+      <html>
+        <body>
+          <p>   Text with whitespace   </p>
+        </body>
+      </html>
+    `;
+    const dom = new JSDOM(html);
+    const text = extractTextFromDOM(dom.window.document);
+    
+    expect(text).toBe("Text with whitespace");
+  });
+});
+
+describe("extractTextFromDOMSnapshot", () => {
+  test("extracts text from CDP DOMSnapshot format", () => {
+    const snapshot = {
+      strings: ["HTML", "BODY", "P", "Hello World", "SCRIPT", "hidden"],
+      documents: [{
+        nodes: {
+          nodeType: [1, 1, 1, 3, 1, 3],
+          nodeName: [0, 1, 2, -1, 4, -1],
+          nodeValue: [-1, -1, -1, 3, -1, 5],
+          parentIndex: [-1, 0, 1, 2, 1, 4],
+        },
+      }],
+    };
+    
+    const text = extractTextFromDOMSnapshot(snapshot);
+    
+    expect(text).toContain("Hello World");
+    expect(text).not.toContain("hidden");
+  });
+
+  test("handles empty snapshot", () => {
+    const snapshot = {
+      strings: [],
+      documents: [{
+        nodes: {
+          nodeType: [],
+          nodeName: [],
+          nodeValue: [],
+          parentIndex: [],
+        },
+      }],
+    };
+    
+    const text = extractTextFromDOMSnapshot(snapshot);
+    
+    expect(text).toBe("");
+  });
+
+  test("skips documents based on skipDocs parameter", () => {
+    const snapshot = {
+      strings: ["HTML", "BODY", "P", "First Doc", "HTML", "BODY", "P", "Second Doc"],
+      documents: [
+        {
+          nodes: {
+            nodeType: [1, 1, 1, 3],
+            nodeName: [0, 1, 2, -1],
+            nodeValue: [-1, -1, -1, 3],
+            parentIndex: [-1, 0, 1, 2],
+          },
+        },
+        {
+          nodes: {
+            nodeType: [1, 1, 1, 3],
+            nodeName: [4, 5, 6, -1],
+            nodeValue: [-1, -1, -1, 7],
+            parentIndex: [-1, 0, 1, 2],
+          },
+        },
+      ],
+    };
+    
+    const textWithSkip = extractTextFromDOMSnapshot(snapshot, 1);
+    const textWithoutSkip = extractTextFromDOMSnapshot(snapshot, 0);
+    
+    expect(textWithSkip).toContain("Second Doc");
+    expect(textWithSkip).not.toContain("First Doc");
+    expect(textWithoutSkip).toContain("First Doc");
+    expect(textWithoutSkip).toContain("Second Doc");
+  });
+});
diff --git a/yarn.lock b/yarn.lock
index 867f722bf..933c79b5a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -10,6 +10,33 @@
     "@jridgewell/gen-mapping" "^0.3.5"
     "@jridgewell/trace-mapping" "^0.3.24"
 
+"@asamuzakjp/css-color@^5.0.1":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@asamuzakjp/css-color/-/css-color-5.0.1.tgz#3b9462a9b52f3c6680a0945a3d0851881017550f"
+  integrity sha512-2SZFvqMyvboVV1d15lMf7XiI3m7SDqXUuKaTymJYLN6dSGadqp+fVojqJlVoMlbZnlTmu3S0TLwLTJpvBMO1Aw==
+  dependencies:
+    "@csstools/css-calc" "^3.1.1"
+    "@csstools/css-color-parser" "^4.0.2"
+    "@csstools/css-parser-algorithms" "^4.0.0"
+    "@csstools/css-tokenizer" "^4.0.0"
+    lru-cache "^11.2.6"
+
+"@asamuzakjp/dom-selector@^7.0.2":
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/@asamuzakjp/dom-selector/-/dom-selector-7.0.3.tgz#4417c419c79a560dac6c191d4e7592fa06057da1"
+  integrity sha512-Q6mU0Z6bfj6YvnX2k9n0JxiIwrCFN59x/nWmYQnAqP000ruX/yV+5bp/GRcF5T8ncvfwJQ7fgfP74DlpKExILA==
+  dependencies:
+    "@asamuzakjp/nwsapi" "^2.3.9"
+    bidi-js "^1.0.3"
+    css-tree "^3.2.1"
+    is-potential-custom-element-name "^1.0.1"
+    lru-cache "^11.2.7"
+
+"@asamuzakjp/nwsapi@^2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz#ad5549322dfe9d153d4b4dd6f7ff2ae234b06e24"
+  integrity sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==
+
 "@aws-crypto/crc32@5.2.0":
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/@aws-crypto/crc32/-/crc32-5.2.0.tgz#cfcc22570949c98c6689cfcbd2d693d36cdae2e1"
@@ -893,11 +920,51 @@
   resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
   integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==
 
+"@bramus/specificity@^2.4.2":
+  version "2.4.2"
+  resolved "https://registry.yarnpkg.com/@bramus/specificity/-/specificity-2.4.2.tgz#aa8db8eb173fdee7324f82284833106adeecc648"
+  integrity sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==
+  dependencies:
+    css-tree "^3.0.0"
+
 "@colors/colors@1.5.0":
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
   integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
 
+"@csstools/color-helpers@^6.0.2":
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/@csstools/color-helpers/-/color-helpers-6.0.2.tgz#82c59fd30649cf0b4d3c82160489748666e6550b"
+  integrity sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==
+
+"@csstools/css-calc@^3.1.1":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@csstools/css-calc/-/css-calc-3.1.1.tgz#78b494996dac41a02797dcca18ac3b46d25b3fd7"
+  integrity sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==
+
+"@csstools/css-color-parser@^4.0.2":
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/@csstools/css-color-parser/-/css-color-parser-4.0.2.tgz#c27e03a3770d0352db92d668d6dde427a37859e5"
+  integrity sha512-0GEfbBLmTFf0dJlpsNU7zwxRIH0/BGEMuXLTCvFYxuL1tNhqzTbtnFICyJLTNK4a+RechKP75e7w42ClXSnJQw==
+  dependencies:
+    "@csstools/color-helpers" "^6.0.2"
+    "@csstools/css-calc" "^3.1.1"
+
+"@csstools/css-parser-algorithms@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz#e1c65dc09378b42f26a111fca7f7075fc2c26164"
+  integrity sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==
+
+"@csstools/css-syntax-patches-for-csstree@^1.1.1":
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.1.tgz#ce4c9a0cbe30590491fcd5c03fe6426d22ba89e4"
+  integrity sha512-BvqN0AMWNAnLk9G8jnUT77D+mUbY/H2b3uDTvg2isJkHaOufUE2R3AOwxWo7VBQKT1lOdwdvorddo2B/lk64+w==
+
+"@csstools/css-tokenizer@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz#798a33950d11226a0ebb6acafa60f5594424967f"
+  integrity sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==
+
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.4.0":
   version "4.4.1"
   resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.1.tgz#d1145bf2c20132d6400495d6df4bf59362fd9d56"
@@ -930,6 +997,11 @@
   resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.57.1.tgz#de633db3ec2ef6a3c89e2f19038063e8a122e2c2"
   integrity sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==
 
+"@exodus/bytes@^1.11.0", "@exodus/bytes@^1.15.0", "@exodus/bytes@^1.6.0":
+  version "1.15.0"
+  resolved "https://registry.yarnpkg.com/@exodus/bytes/-/bytes-1.15.0.tgz#54479e0f406cbad024d6fe1c3190ecca4468df3b"
+  integrity sha512-UY0nlA+feH81UGSHv92sLEPLCeZFjXOuHhrIo0HQydScuQc8s0A7kL/UdgwgDq8g8ilksmuoF35YVTNphV2aBQ==
+
 "@formatjs/ecma402-abstract@2.3.4":
   version "2.3.4"
   resolved "https://registry.yarnpkg.com/@formatjs/ecma402-abstract/-/ecma402-abstract-2.3.4.tgz#e90c5a846ba2b33d92bc400fdd709da588280fbc"
@@ -2077,6 +2149,16 @@
   resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-4.0.9.tgz#cd82382c4f902fed9691a2ed79ec68c5898af4c2"
   integrity sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==
 
+"@types/jsdom@^28.0.0":
+  version "28.0.0"
+  resolved "https://registry.yarnpkg.com/@types/jsdom/-/jsdom-28.0.0.tgz#387bcb5fe60c753ae0c58584b659a598319938f2"
+  integrity sha512-A8TBQQC/xAOojy9kM8E46cqT00sF0h7dWjV8t8BJhUi2rG6JRh7XXQo/oLoENuZIQEpXsxLccLCnknyQd7qssQ==
+  dependencies:
+    "@types/node" "*"
+    "@types/tough-cookie" "*"
+    parse5 "^7.0.0"
+    undici-types "^7.21.0"
+
 "@types/json-schema@^7.0.12":
   version "7.0.15"
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841"
@@ -2139,6 +2221,11 @@
   dependencies:
     "@types/node" "*"
 
+"@types/tough-cookie@*":
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/@types/tough-cookie/-/tough-cookie-4.0.5.tgz#cb6e2a691b70cb177c6e3ae9c1d2e8b2ea8cd304"
+  integrity sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==
+
 "@types/uuid@^9.0.6":
   version "9.0.8"
   resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-9.0.8.tgz#7545ba4fc3c003d6c756f651f3bf163d8f0f29ba"
@@ -2685,6 +2772,13 @@ basic-ftp@^5.0.2:
   resolved "https://registry.yarnpkg.com/basic-ftp/-/basic-ftp-5.0.5.tgz#14a474f5fffecca1f4f406f1c26b18f800225ac0"
   integrity sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==
 
+bidi-js@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/bidi-js/-/bidi-js-1.0.3.tgz#6f8bcf3c877c4d9220ddf49b9bb6930c88f877d2"
+  integrity sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==
+  dependencies:
+    require-from-string "^2.0.2"
+
 bl@^4.0.3:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
@@ -3080,11 +3174,27 @@ css-selector-parser@^3.0.5:
   resolved "https://registry.yarnpkg.com/css-selector-parser/-/css-selector-parser-3.0.5.tgz#9b636ebccf7c4bcce5c1ac21ae27de9f01180ae9"
   integrity sha512-3itoDFbKUNx1eKmVpYMFyqKX04Ww9osZ+dLgrk6GEv6KMVeXUhUnp4I5X+evw+u3ZxVU6RFXSSRxlTeMh8bA+g==
 
+css-tree@^3.0.0, css-tree@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-3.2.1.tgz#86cac7011561272b30e6b1e042ba6ce047aa7518"
+  integrity sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==
+  dependencies:
+    mdn-data "2.27.1"
+    source-map-js "^1.2.1"
+
 data-uri-to-buffer@^6.0.2:
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz#8a58bb67384b261a38ef18bea1810cb01badd28b"
   integrity sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==
 
+data-urls@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/data-urls/-/data-urls-7.0.0.tgz#6dce8b63226a1ecfdd907ce18a8ccfb1eee506d3"
+  integrity sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==
+  dependencies:
+    whatwg-mimetype "^5.0.0"
+    whatwg-url "^16.0.0"
+
 data-view-buffer@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/data-view-buffer/-/data-view-buffer-1.0.1.tgz#8ea6326efec17a2e42620696e671d7d5a8bc66b2"
@@ -3179,6 +3289,11 @@ decimal.js@^10.4.3:
   resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.5.0.tgz#0f371c7cf6c4898ce0afb09836db73cd82010f22"
   integrity sha512-8vDa8Qxvr/+d94hSh5P3IJwI5t8/c0KsMp+g8bNw9cY2icONa5aPfvKeieW1WlG0WQYwwhJ7mjui2xtiePQSXw==
 
+decimal.js@^10.6.0:
+  version "10.6.0"
+  resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.6.0.tgz#e649a43e3ab953a72192ff5983865e509f37ed9a"
+  integrity sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==
+
 decompress-response@^6.0.0:
   version "6.0.0"
   resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-6.0.0.tgz#ca387612ddb7e104bd16d85aab00d5ecf09c66fc"
@@ -3345,6 +3460,11 @@ entities@^4.3.0, entities@^4.5.0:
   resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48"
   integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==
 
+entities@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-6.0.1.tgz#c28c34a43379ca7f61d074130b2f5f7020a30694"
+  integrity sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==
+
 env-paths@^2.2.1:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2"
@@ -4224,6 +4344,13 @@ html-encoding-sniffer@^3.0.0:
   dependencies:
     whatwg-encoding "^2.0.0"
 
+html-encoding-sniffer@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz#f8d9390b3b348b50d4f61c16dd2ef5c05980a882"
+  integrity sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==
+  dependencies:
+    "@exodus/bytes" "^1.6.0"
+
 html-escaper@^2.0.0:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
@@ -4633,6 +4760,11 @@ is-path-inside@^3.0.3:
   resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
   integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
 
+is-potential-custom-element-name@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz#171ed6f19e3ac554394edf78caa05784a45bebb5"
+  integrity sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==
+
 is-regex@^1.1.4:
   version "1.1.4"
   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
@@ -5253,6 +5385,33 @@ jsbn@1.1.0:
   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-1.1.0.tgz#b01307cb29b618a1ed26ec79e911f803c4da0040"
   integrity sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==
 
+jsdom@^29.0.0:
+  version "29.0.0"
+  resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-29.0.0.tgz#5f2e47251570df4bf0c8dec7b68644259f73aaa4"
+  integrity sha512-9FshNB6OepopZ08unmmGpsF7/qCjxGPbo3NbgfJAnPeHXnsODE9WWffXZtRFRFe0ntzaAOcSKNJFz8wiyvF1jQ==
+  dependencies:
+    "@asamuzakjp/css-color" "^5.0.1"
+    "@asamuzakjp/dom-selector" "^7.0.2"
+    "@bramus/specificity" "^2.4.2"
+    "@csstools/css-syntax-patches-for-csstree" "^1.1.1"
+    "@exodus/bytes" "^1.15.0"
+    css-tree "^3.2.1"
+    data-urls "^7.0.0"
+    decimal.js "^10.6.0"
+    html-encoding-sniffer "^6.0.0"
+    is-potential-custom-element-name "^1.0.1"
+    lru-cache "^11.2.7"
+    parse5 "^8.0.0"
+    saxes "^6.0.0"
+    symbol-tree "^3.2.4"
+    tough-cookie "^6.0.1"
+    undici "^7.24.3"
+    w3c-xmlserializer "^5.0.0"
+    webidl-conversions "^8.0.1"
+    whatwg-mimetype "^5.0.0"
+    whatwg-url "^16.0.1"
+    xml-name-validator "^5.0.0"
+
 jsesc@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e"
@@ -5444,6 +5603,11 @@ loose-envify@^1.4.0:
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
+lru-cache@^11.2.6, lru-cache@^11.2.7:
+  version "11.2.7"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-11.2.7.tgz#9127402617f34cd6767b96daee98c28e74458d35"
+  integrity sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==
+
 lru-cache@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
@@ -5496,6 +5660,11 @@ md5@^2.3.0:
     crypt "0.0.2"
     is-buffer "~1.1.6"
 
+mdn-data@2.27.1:
+  version "2.27.1"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.27.1.tgz#e37b9c50880b75366c4d40ac63d9bbcacdb61f0e"
+  integrity sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==
+
 merge-stream@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
@@ -5876,6 +6045,13 @@ parse5@^7.0.0:
   dependencies:
     entities "^4.5.0"
 
+parse5@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-8.0.0.tgz#aceb267f6b15f9b6e6ba9e35bfdd481fc2167b12"
+  integrity sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==
+  dependencies:
+    entities "^6.0.0"
+
 path-exists@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
@@ -6058,7 +6234,7 @@ pump@^3.0.0:
     end-of-stream "^1.1.0"
     once "^1.3.1"
 
-punycode@^2.1.0:
+punycode@^2.1.0, punycode@^2.3.1:
   version "2.3.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5"
   integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
@@ -6239,6 +6415,11 @@ require-directory@^2.1.1:
   resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
 
+require-from-string@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
+  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
+
 requires-port@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
@@ -6366,6 +6547,13 @@ sax@^1.3.0:
   resolved "https://registry.yarnpkg.com/sax/-/sax-1.3.0.tgz#a5dbe77db3be05c9d1ee7785dbd3ea9de51593d0"
   integrity sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==
 
+saxes@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/saxes/-/saxes-6.0.0.tgz#fe5b4a4768df4f14a201b1ba6a65c1f3d9988cc5"
+  integrity sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==
+  dependencies:
+    xmlchars "^2.2.0"
+
 search-params@3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/search-params/-/search-params-3.0.0.tgz#dbc7c243058e5a33ae1e9870be91f5aced4100d8"
@@ -6574,6 +6762,11 @@ socks@^2.8.3:
     ip-address "^9.0.5"
     smart-buffer "^4.2.0"
 
+source-map-js@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46"
+  integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
+
 source-map-support@0.5.13:
   version "0.5.13"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932"
@@ -6798,6 +6991,11 @@ supports-preserve-symlinks-flag@^1.0.0:
   resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
+symbol-tree@^3.2.4:
+  version "3.2.4"
+  resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2"
+  integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==
+
 tar-fs@^2.0.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-2.1.1.tgz#489a15ab85f1f0befabb370b7de4f9eb5cbe8784"
@@ -6905,6 +7103,11 @@ tldts-core@^6.1.85:
   resolved "https://registry.yarnpkg.com/tldts-core/-/tldts-core-6.1.85.tgz#6f6b795468c0b5f7660a11c7306ff2766ceaea7e"
   integrity sha512-DTjUVvxckL1fIoPSb3KE7ISNtkWSawZdpfxGxwiIrZoO6EbHVDXXUIlIuWympPaeS+BLGyggozX/HTMsRAdsoA==
 
+tldts-core@^7.0.26:
+  version "7.0.26"
+  resolved "https://registry.yarnpkg.com/tldts-core/-/tldts-core-7.0.26.tgz#070f14bc7a4deabf115c6501bc5c0bae4da74d17"
+  integrity sha512-5WJ2SqFsv4G2Dwi7ZFVRnz6b2H1od39QME1lc2y5Ew3eWiZMAeqOAfWpRP9jHvhUl881406QtZTODvjttJs+ew==
+
 tldts-icann@^6.1.16:
   version "6.1.85"
   resolved "https://registry.yarnpkg.com/tldts-icann/-/tldts-icann-6.1.85.tgz#9eb8794c20805c29e59c7ee491ba138652fd776e"
@@ -6912,6 +7115,13 @@ tldts-icann@^6.1.16:
   dependencies:
     tldts-core "^6.1.85"
 
+tldts@^7.0.5:
+  version "7.0.26"
+  resolved "https://registry.yarnpkg.com/tldts/-/tldts-7.0.26.tgz#bf2472ed84e55faaaff5c2424c03a6bab69b92c5"
+  integrity sha512-WiGwQjr0qYdNNG8KpMKlSvpxz652lqa3Rd+/hSaDcY4Uo6SKWZq2LAF+hsAhUewTtYhXlorBKgNF3Kk8hnjGoQ==
+  dependencies:
+    tldts-core "^7.0.26"
+
 tmpl@1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc"
@@ -6929,6 +7139,20 @@ to-regex-range@^5.0.1:
   dependencies:
     is-number "^7.0.0"
 
+tough-cookie@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-6.0.1.tgz#a495f833836609ed983c19bc65639cfbceb54c76"
+  integrity sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==
+  dependencies:
+    tldts "^7.0.5"
+
+tr46@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/tr46/-/tr46-6.0.0.tgz#f5a1ae546a0adb32a277a2278d0d17fa2f9093e6"
+  integrity sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==
+  dependencies:
+    punycode "^2.3.1"
+
 ts-api-utils@^1.0.1:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/ts-api-utils/-/ts-api-utils-1.4.0.tgz#709c6f2076e511a81557f3d07a0cbd566ae8195c"
@@ -7077,6 +7301,11 @@ unbox-primitive@^1.0.2, unbox-primitive@^1.1.0:
     has-symbols "^1.1.0"
     which-boxed-primitive "^1.1.1"
 
+undici-types@^7.21.0:
+  version "7.24.4"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-7.24.4.tgz#642dac0cb65a2ae389f8c228fda927308c65543b"
+  integrity sha512-cRaY9PagdEZoRmcwzk3tUV3SVGrVQkR6bcSilav/A0vXsfpW4Lvd0BvgRMwTEDTLLGN+QdyBTG+nnvTgJhdt6w==
+
 undici-types@~6.19.2, undici-types@~6.19.8:
   version "6.19.8"
   resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.19.8.tgz#35111c9d1437ab83a7cdc0abae2f26d88eda0a02"
@@ -7087,6 +7316,11 @@ undici@>=6, undici@^7.16.0:
   resolved "https://registry.yarnpkg.com/undici/-/undici-7.16.0.tgz#cb2a1e957726d458b536e3f076bf51f066901c1a"
   integrity sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==
 
+undici@^7.24.3:
+  version "7.24.4"
+  resolved "https://registry.yarnpkg.com/undici/-/undici-7.24.4.tgz#873bce680d7c6354c941399fd4e8ea4563de4ea7"
+  integrity sha512-BM/JzwwaRXxrLdElV2Uo6cTLEjhSb3WXboncJamZ15NgUURmvlXvxa6xkwIOILIjPNo9i8ku136ZvWV0Uly8+w==
+
 union@~0.5.0:
   version "0.5.0"
   resolved "https://registry.yarnpkg.com/union/-/union-0.5.0.tgz#b2c11be84f60538537b846edb9ba266ba0090075"
@@ -7157,6 +7391,13 @@ v8-to-istanbul@^9.0.1:
     "@types/istanbul-lib-coverage" "^2.0.1"
     convert-source-map "^2.0.0"
 
+w3c-xmlserializer@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz#f925ba26855158594d907313cedd1476c5967f6c"
+  integrity sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==
+  dependencies:
+    xml-name-validator "^5.0.0"
+
 walker@^1.0.8:
   version "1.0.8"
   resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f"
@@ -7183,6 +7424,11 @@ webdriver-bidi-protocol@0.4.1:
   resolved "https://registry.yarnpkg.com/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.4.1.tgz#d411e7b8e158408d83bb166b0b4f1054fa3f077e"
   integrity sha512-ARrjNjtWRRs2w4Tk7nqrf2gBI0QXWuOmMCx2hU+1jUt6d00MjMxURrhxhGbrsoiZKJrhTSTzbIrc554iKI10qw==
 
+webidl-conversions@^8.0.1:
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-8.0.1.tgz#0657e571fe6f06fcb15ca50ed1fdbcb495cd1686"
+  integrity sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==
+
 whatwg-encoding@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz#e7635f597fd87020858626805a2729fa7698ac53"
@@ -7190,6 +7436,20 @@ whatwg-encoding@^2.0.0:
   dependencies:
     iconv-lite "0.6.3"
 
+whatwg-mimetype@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz#d8232895dbd527ceaee74efd4162008fb8a8cf48"
+  integrity sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==
+
+whatwg-url@^16.0.0, whatwg-url@^16.0.1:
+  version "16.0.1"
+  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-16.0.1.tgz#047f7f4bd36ef76b7198c172d1b1cebc66f764dd"
+  integrity sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==
+  dependencies:
+    "@exodus/bytes" "^1.11.0"
+    tr46 "^6.0.0"
+    webidl-conversions "^8.0.1"
+
 which-boxed-primitive@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
@@ -7348,6 +7608,16 @@ xdg-basedir@^4.0.0:
   resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-4.0.0.tgz#4bc8d9984403696225ef83a1573cbbcb4e79db13"
   integrity sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==
 
+xml-name-validator@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-5.0.0.tgz#82be9b957f7afdacf961e5980f1bf227c0bf7673"
+  integrity sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==
+
+xmlchars@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb"
+  integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==
+
 y18n@^5.0.5:
   version "5.0.8"
   resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"