@analitikisler/ai-tag-debugger 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.7.3 (2026-10-13)
+
+- `replay` no longer crashes with `NavigationAbortedError: net::ERR_BLOCKED_BY_CLIENT` when a saved page redirects to another site. The redirect is refused again, so the journey stays unfinished as it was saved, and the other sites are still replayed.
+- Tracking hits sent while the browser closes are answered locally again on normal runs. In 0.7.2 the routes were removed before closing, so a hit sent at that moment could reach the real account. They are now removed only on `replay`, which never goes online.
+
+## 0.7.2 (2026-10-13)
+
+- **GA4 and Google Ads hits sent through Google tag gateway are captured.** Sites using the gateway send GA4 to a short path on their own domain (`/<prefix>/ag/g/c`, `/<prefix>/ga/g/c`) and Google Ads to `/<prefix>/as/p/c/<id>/`. These were neither recognized nor answered locally, so their events were reported as missing and the audit's visits reached the site's real accounts. A `/g/c` path counts as GA4 only with a GA4 measurement id (`tid=G-…`).
+- Google Tag Manager and gtag.js loaded from the site's own domain are labelled as such in the network timeline.
+- Two more Google pings are answered locally instead of reaching Google: `www.google.com/measurement/conversion` and `google.<tld>/ads/ga-audiences`.
+- Saved sites also leave out cookies named like a login or token (`auth_token`, `sid`, `csrftoken`, …) and cookies holding an email address, even when they aren't HttpOnly.
+- Writing a saved site's recording can no longer stall a run: the page is left first, so what it is still loading is cancelled, and after 30 seconds the recording is skipped (the site is then not saved). The log says when the recording is being written. Reading the browser's cookies at the end of a journey has a time limit too.
+- `replay` no longer crashes with "Target page, context or browser has been closed" when a request is still being answered as the browser closes.
+- A saved journey whose start page could not be opened (a redirect to another site, a bot check) can be replayed; it stays unfinished with its saved note.
+- When a site can't be saved, a `site.json` from an earlier save is removed so it can't be replayed against the new recordings, and `run` exits with code 1.
+
 ## 0.7.1 (2026-10-13)
 
 - A page whose script stops responding after a step can no longer stall a run. Reading the page now has a 1 minute limit too, and when it runs out the journey ends as incomplete with a note. Before, only the model call and the browser action itself had a limit.

package/README.md

@@ -45,7 +45,7 @@ Manual tag QA catches this, but it's tedious, so it rarely happens after every r
 | Personal data | An email address sent to an ad platform in plain text |
 | Unplanned events | Events firing that aren't in your measurement plan |
 
-Platforms: GA4 (including server-side GTM endpoints), Google Ads conversions, Meta Pixel, TikTok Pixel, and basic X Pixel events.
+Platforms: GA4 (including server-side GTM endpoints and Google tag gateway paths on the site's own domain), Google Ads conversions, Meta Pixel, TikTok Pixel, and basic X Pixel events.
 
 ### Choose the providers to check
 
@@ -180,7 +180,7 @@ npx @analitikisler/ai-tag-debugger replay saved/*
     - warning duplicate purchase desktop ga4 page_view
 ```
 
-The first run's findings become the expected ones. When a change is right, for example a false alarm that is fixed, `replay --update` makes the new findings the expected ones. Use it to check a new version of the tool against sites you know, or a site change against its last good run. A saved site is usually a few MB. It leaves out tracking requests, images and video, session cookies and the cookies the browser sent, authorization headers, form data, and requests with an email or other user data in their address. It still holds the site's pages and scripts, so keep sites you don't own out of public repositories.
+The first run's findings become the expected ones. When a change is right, for example a false alarm that is fixed, `replay --update` makes the new findings the expected ones. Use it to check a new version of the tool against sites you know, or a site change against its last good run. A saved site is usually a few MB. It leaves out tracking requests, images and video, HttpOnly and login cookies and the cookies the browser sent, authorization headers, form data, and requests with an email or other user data in their address. It still holds the site's pages and scripts, so keep sites you don't own out of public repositories.
 
 ## Configure your site
 

package/README.tr.md

@@ -45,7 +45,7 @@ Tag'leri elle test etmek bunu yakalar, ama zahmetli olduğu için her sürümden
 | Kişisel veri | Bir e-posta adresi reklam platformuna açık metin olarak gönderildi |
 | Planda olmayan event'ler | Ölçümleme planınızda bulunmayan event'ler gönderiliyor |
 
-Platformlar: GA4 (server-side GTM adresleri dahil), Google Ads dönüşümleri, Meta Pixel, TikTok Pixel ve temel X Pixel event'leri.
+Platformlar: GA4 (server-side GTM adresleri ve sitenin kendi alan adındaki Google tag gateway yolları dahil), Google Ads dönüşümleri, Meta Pixel, TikTok Pixel ve temel X Pixel event'leri.
 
 ### Kontrol edilecek platformları seçin
 
@@ -182,7 +182,7 @@ npx @analitikisler/ai-tag-debugger replay saved/*
     - warning duplicate purchase desktop ga4 page_view
 ```
 
-İlk çalıştırmanın bulguları beklenen bulgular olur. Bir değişiklik doğruysa (örneğin düzeltilmiş bir yanlış alarm), `replay --update` yeni bulguları beklenen bulgular yapar. Aracın yeni bir sürümünü bildiğiniz sitelerle ya da bir site değişikliğini son sağlıklı çalıştırmayla karşılaştırmak için kullanın. Kaydedilmiş bir site genellikle birkaç MB'tır. İzleme isteklerini, görselleri ve videoları, oturum çerezlerini ve tarayıcının gönderdiği çerezleri, yetkilendirme başlıklarını, form verilerini ve adresinde e-posta ya da başka kullanıcı verisi olan istekleri içermez. Yine de sitenin sayfalarını ve betiklerini içerdiği için size ait olmayan siteleri herkese açık depolara koymayın.
+İlk çalıştırmanın bulguları beklenen bulgular olur. Bir değişiklik doğruysa (örneğin düzeltilmiş bir yanlış alarm), `replay --update` yeni bulguları beklenen bulgular yapar. Aracın yeni bir sürümünü bildiğiniz sitelerle ya da bir site değişikliğini son sağlıklı çalıştırmayla karşılaştırmak için kullanın. Kaydedilmiş bir site genellikle birkaç MB'tır. İzleme isteklerini, görselleri ve videoları, HttpOnly ve oturum açma çerezlerini ve tarayıcının gönderdiği çerezleri, yetkilendirme başlıklarını, form verilerini ve adresinde e-posta ya da başka kullanıcı verisi olan istekleri içermez. Yine de sitenin sayfalarını ve betiklerini içerdiği için size ait olmayan siteleri herkese açık depolara koymayın.
 
 ## Sitenizi ayarlayın
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analitikisler/ai-tag-debugger",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Open-source AI agent that QA-tests your website's analytics, ad and consent tracking (GA4, GTM, Google Ads, Meta, TikTok). Bring your own model (Claude, OpenAI, Gemini) or use it from your chat app over MCP.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -164,15 +164,15 @@ export async function runAgentJourney(session, journey, opts = {}) {
 /** Replays fixed steps from the config, without calling an AI model. */
 export async function runScriptedJourney(session, journey, opts = {}) {
   const log = opts.log ?? (() => {});
-  if (!journey.steps?.length) throw new Error(`Journey "${journey.id}" has no "steps" for --scripted mode.`);
-  for (const step of journey.steps) {
+  if (!journey.steps?.length && !journey.incomplete) throw new Error(`Journey "${journey.id}" has no "steps" for --scripted mode.`);
+  for (const step of journey.steps ?? []) {
     log(`  ${step.reason ?? `${step.action} ${step.selector ?? step.url ?? ""}`}`);
     const error = await session.act(step);
     if (error && !step.optional) return { completed: false, note: `Step "${step.reason ?? step.action}" failed: ${error}` };
   }
   // Tags often send a moment after the last click (GA4 batches events). An AI run gives them that time
   // while the model answers; a scripted run would otherwise close the browser first.
-  await session.page.waitForTimeout(LAST_STEP_WAIT_MS);
+  await session.page.waitForTimeout(LAST_STEP_WAIT_MS).catch(() => {});
   if (journey.incomplete) return { completed: false, note: journey.incomplete };
   return { completed: true, note: "All scripted steps completed." };
 }
@@ -194,7 +194,8 @@ export async function runJourney(config, journey, viewport, opts = {}) {
     await session.start();
     const startUrl = new URL(journey.start ?? "/", config.site).href;
     const startError = await session.act({ action: "goto", url: startUrl, reason: `Open ${startUrl}` });
-    if (startError) return { ...collect(session, journey, viewport), completed: false, note: `Could not open the start page: ${startError}` };
+    // A replayed journey that was unfinished when saved keeps its saved note, however it fails this time.
+    if (startError) return { ...collect(session, journey, viewport), completed: false, note: journey.incomplete ?? `Could not open the start page: ${startError}` };
 
     const outcome = await (opts.scripted ? runScriptedJourney(session, journey, opts) : runAgentJourney(session, journey, opts)).catch((err) => {
       if (err instanceof StepTimeout) return { completed: false, note: err.message };
@@ -202,6 +203,7 @@ export async function runJourney(config, journey, viewport, opts = {}) {
     });
     return { ...collect(session, journey, viewport), ...outcome, cookies: await session.cookies() };
   } finally {
+    if (opts.saveSite) opts.log?.("  Writing the recording…");
     await session.close();
   }
 }

package/src/audit.js

@@ -1,6 +1,6 @@
 // A full audit from a config file: run every journey, check, explain, write the reports.
 // Shared by the CLI and the MCP server's run_audit tool.
-import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { readFile, mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { runJourney } from "./agent.js";
 import { checkRun, groupFindings, summarize } from "./checks.js";
@@ -9,7 +9,7 @@ import { LANGUAGES, messages } from "./i18n.js";
 import { createProvider } from "./providers.js";
 import { filterFindings, planRun } from "./journeys.js";
 import { resolveProviders } from "./parsers.js";
-import { writeSavedSite } from "./replay.js";
+import { SAVED_SITE_FILE, writeSavedSite } from "./replay.js";
 
 export async function readJson(file, baseDir = ".") {
   const full = path.resolve(baseDir, file);
@@ -72,7 +72,7 @@ export async function runAudit(opts) {
   const viewports = opts.viewports?.length ? opts.viewports : config.viewports ?? ["desktop"];
   if (!journeys.length) throw new Error("No journeys to run. Pick one with --journey (e.g. purchase) or describe one with --goal.");
   if (opts.scripted) {
-    const unscripted = journeys.filter((j) => !j.steps?.length).map((j) => j.id);
+    const unscripted = journeys.filter((j) => !j.steps?.length && !j.incomplete).map((j) => j.id);
     if (unscripted.length) throw new Error(`Journeys without fixed steps can't be replayed with --scripted: ${unscripted.join(", ")}.`);
   }
 
@@ -91,10 +91,17 @@ export async function runAudit(opts) {
   }
 
   const findings = filterFindings(runs.flatMap((run) => checkRun(plan, run, { lang })), events);
+  let saveError = null;
   if (opts.saveSite) {
-    await writeSavedSite(opts.saveSite, { config, plan, runs, findings })
-      .then(() => log(`\nSaved the site for offline replay in ${opts.saveSite}`))
-      .catch((err) => log(`\nCould not save the site in ${opts.saveSite}: ${err.message}`));
+    try {
+      await writeSavedSite(opts.saveSite, { config, plan, runs, findings });
+      log(`\nSaved the site for offline replay in ${opts.saveSite}`);
+    } catch (err) {
+      // A site.json from an earlier save would no longer match the recordings next to it.
+      await rm(path.join(opts.saveSite, SAVED_SITE_FILE), { force: true });
+      saveError = err.message;
+      log(`\nCould not save the site in ${opts.saveSite}: ${err.message}`);
+    }
   }
   let explained = null;
   if (provider) {
@@ -105,5 +112,5 @@ export async function runAudit(opts) {
   const outDir = path.resolve(opts.outDir ?? defaultOutDir());
   const reportPath = await writeReports({ outDir, config, plan, runs, findings, explained, lang, branding: opts.branding ?? config.branding !== false });
   const counts = summarize(groupFindings(findings));
-  return { runs, findings, explained, counts, reportPath, outDir, lang };
+  return { runs, findings, explained, counts, reportPath, outDir, lang, ...(saveError ? { saveError } : {}) };
 }

package/src/browser.js

@@ -232,14 +232,23 @@ const isDroppedMedia = (request) =>
   ["image", "font", "media"].includes(request.resourceType()) || MEDIA_FILE.test(new URL(request.url()).pathname);
 
 // Cookies the server sets for the page's scripts (a country or language, for example) are kept, since
-// sites often need them to render; HttpOnly ones, where sessions and logins live, are dropped. Replay
-// applies only one Set-Cookie header, so the kept ones are joined into one, one cookie per line.
+// sites often need them to render. HttpOnly ones, where sessions and logins usually live, are dropped,
+// and so are ones named or holding like a login. Replay applies only one Set-Cookie header, so the
+// kept ones are joined into one, one cookie per line.
+const LOGIN_COOKIE = /sess|sid|token|auth|jwt|login|csrf|xsrf|remember/i;
 function keptHeaders(headers) {
   const isSetCookie = (h) => /^set-cookie$/i.test(h.name);
-  const cookies = headers.filter(isSetCookie).flatMap((h) => h.value.split("\n")).filter((c) => !/;\s*httponly\s*(;|$)/i.test(c));
+  const isPrivate = (cookie) => {
+    const [pair] = cookie.split(";");
+    const name = pair.slice(0, pair.indexOf("=")).trim();
+    return /;\s*httponly\s*(;|$)/i.test(cookie) || LOGIN_COOKIE.test(name) || /@|%40/.test(pair);
+  };
+  const cookies = headers.filter(isSetCookie).flatMap((h) => h.value.split("\n")).filter((c) => !isPrivate(c));
   return [...headers.filter((h) => !isSetCookie(h)), ...(cookies.length ? [{ name: "Set-Cookie", value: cookies.join("\n") }] : [])];
 }
 
+const CLOSE_TIMEOUT_MS = 30_000;
+
 const SECRET_REQUEST_HEADER = /^(cookie|authorization|proxy-authorization)$/i;
 
 /**
@@ -276,6 +285,7 @@ export class AuditSession {
    *     others are still answered locally, but only counted, per step, in this.skipped.
    *   site: navigation is limited to this site's host and its subdomains, plus allowedHosts.
    *   recordHar: save every response the site sends into this .har file, so the journey can be replayed offline later.
+   *     closeTimeoutMs: how long close() waits for the recording to be written (default 30 s) before skipping it.
    *   replayHar: answer requests from a .har file saved with recordHar instead of the network; requests it lacks fail.
    *   blockPrivate: refuse loopback, private and link-local addresses (used when the MCP server is reachable over HTTP).
    *     All browser traffic then goes through the egress proxy. A function decides which addresses count as private (for tests).
@@ -312,6 +322,11 @@ export class AuditSession {
       launch.proxy = { server: this.egress.url, bypass: "<-loopback>" };
       launch.args = ["--force-webrtc-ip-handling-policy=disable_non_proxied_udp"];
     }
+    if (this.opts.replayHar) {
+      // A replay never goes online: requests the routes below don't answer, including any still in
+      // flight once they are removed at the end, go to a proxy that isn't there.
+      launch.proxy = { server: "http://127.0.0.1:9", bypass: "<-loopback>" };
+    }
     this.browser = await chromium.launch(launch);
     const record = this.opts.recordHar ? { recordHar: { path: this.opts.recordHar, mode: "minimal" } } : {};
     this.context = await this.browser.newContext({ ...device, locale: "en-US", ...record });
@@ -394,9 +409,15 @@ export class AuditSession {
       // Requests the recording lacks fail, except the media left out of it: those get an empty answer,
       // since a failed image or icon can stop a script (a consent banner waiting for its logo, for example).
       await this.context.route("**/*", (route) =>
-        isDroppedMedia(route.request()) ? route.fulfill({ status: 200, body: "" }) : route.abort(),
+        (isDroppedMedia(route.request()) ? route.fulfill({ status: 200, body: "" }) : route.abort()).catch(() => {}),
       );
       await this.context.routeFromHAR(this.opts.replayHar, { notFound: "fallback" });
+      // A saved redirect to a page the browser may not open fails here, as it did when saved. Left to the
+      // recording, the redirect would be followed outside any handler, and its failure would end the run.
+      const refusedRedirects = await this.refusedRedirects(this.opts.replayHar);
+      if (refusedRedirects.size) {
+        await this.context.route((url) => refusedRedirects.has(url.href), (route) => route.abort("blockedbyclient").catch(() => {}));
+      }
     }
     if (this.opts.blockHits) {
       await this.context.route((url) => isCollectionEndpoint(url.href), async (route) => {
@@ -485,6 +506,21 @@ export class AuditSession {
     return true;
   }
 
+  /** Addresses whose saved answer redirects somewhere the browser may not go. */
+  async refusedRedirects(file) {
+    const refused = new Set();
+    const har = JSON.parse(await readFile(file, "utf8"));
+    for (const e of har.log.entries) {
+      const status = e.response?.status;
+      if (status < 300 || status >= 400) continue;
+      const location = e.response.redirectURL || e.response.headers?.find((h) => /^location$/i.test(h.name))?.value;
+      if (!location) continue;
+      const target = new URL(location, e.request.url).href;
+      if (await this.checkUrl(target)) refused.add(e.request.url);
+    }
+    return refused;
+  }
+
   /** Error message when the browser may not be on this URL, or null. */
   checkUrl(url) {
     if (url.startsWith("chrome-error:")) return null; // Chromium's own error page, e.g. after a blocked navigation
@@ -693,9 +729,9 @@ export class AuditSession {
       switch (a.action) {
         case "goto": {
           const target = new URL(a.url, this.page.url() === "about:blank" ? undefined : this.page.url()).href;
+          step.replay = { action: "goto", url: target };
           const refused = await this.checkUrl(target);
           if (refused) return refused;
-          step.replay = { action: "goto", url: target };
           await this.page.goto(target, { waitUntil: "domcontentloaded", timeout: 30000 });
           break;
         }
@@ -745,13 +781,43 @@ export class AuditSession {
   }
 
   async cookies() {
-    return (await this.context.cookies()).map((c) => ({ name: c.name, domain: c.domain }));
+    let timer;
+    const tooLong = new Promise((resolve) => (timer = setTimeout(() => resolve([]), 10_000)));
+    const cookies = await Promise.race([this.context.cookies().catch(() => []), tooLong]);
+    clearTimeout(timer);
+    return cookies.map((c) => ({ name: c.name, domain: c.domain }));
   }
 
   async close() {
+    // Leaving the page first cancels what it is still loading (the recording would otherwise wait for it),
+    // while tracking requests sent on the way out are still answered locally.
+    if (this.opts.recordHar) await this.page?.goto("about:blank", { timeout: 5000 }).catch(() => {});
+    if (this.opts.replayHar) {
+      // The recording's own route callbacks would otherwise throw for requests still in flight once the
+      // browser is gone. Without routes, those go nowhere (see start). Elsewhere the routes stay, so a
+      // hit sent while the browser closes is still answered locally instead of reaching the real account.
+      // A page stuck in a script never answers, so this waits at most 5 seconds.
+      let unrouteTimer;
+      await Promise.race([
+        this.context?.unrouteAll({ behavior: "ignoreErrors" }).catch(() => {}),
+        new Promise((resolve) => (unrouteTimer = setTimeout(resolve, 5000))),
+      ]);
+      clearTimeout(unrouteTimer);
+    }
     if (this.opts.recordHar && this.context) {
-      // Writes the recording. If the browser already went away, there is none to clean.
-      const written = await this.context.close().then(() => true, () => false);
+      // Writes the recording. If the browser already went away, or writing it takes too long, there is
+      // none to clean: closing the browser below then ends the run's wait.
+      let timer;
+      const limit = this.opts.closeTimeoutMs ?? CLOSE_TIMEOUT_MS;
+      const tooLong = new Promise((resolve) => (timer = setTimeout(() => resolve("timeout"), limit)));
+      const closed = await Promise.race([this.context.close().then(() => "closed", () => "gone"), tooLong]);
+      clearTimeout(timer);
+      if (closed === "timeout") {
+        console.warn(`Writing the recording ${this.opts.recordHar} took over ${Math.round(limit / 1000)} seconds, so it was skipped.`);
+        await this.browser?.close().catch(() => {});
+        await rm(this.opts.recordHar, { force: true }); // a partly written file
+      }
+      const written = closed === "closed";
       // A recording that could not be cleaned may hold cookies or form data, so it is deleted.
       if (written) {
         await cleanRecording(this.opts.recordHar).catch(async (err) => {

package/src/cli.js

@@ -180,6 +180,7 @@ async function main() {
     const threshold = levels.indexOf(failOn);
     if (levels.slice(0, threshold + 1).some((l) => result.counts[l] > 0)) process.exitCode = 1;
   }
+  if (result.saveError) process.exitCode = 1;
 }
 
 main().catch((err) => {

package/src/parsers.js

@@ -29,12 +29,19 @@ function ga4Consent(searchParams) {
 // Only www.google.<tld> and doubleclick.net: analytics.google.com is a primary GA4 endpoint.
 const GOOGLE_COMPANION_HOST = /^(www\.)?google\.[a-z]{2,3}(\.[a-z]{2})?$|(^|\.)doubleclick\.net$/;
 
+/**
+ * Google tag gateway serves Google's endpoints from a path on the site's own domain, with
+ * short names: /<prefix>/ag/g/c or /<prefix>/ga/g/c for GA4's /g/collect. Only accepted with a
+ * GA4 measurement id, since "/g/c" alone is too common a path.
+ */
+const isGa4Path = (u) => u.pathname.endsWith("/g/collect") || (/\/g\/c$/.test(u.pathname) && /^G-[A-Z0-9]+$/.test(u.searchParams.get("tid") ?? ""));
+
 /** @returns {Hit[] | null} */
 export function parseGa4(url, postData) {
   const u = new URL(url);
   // Matched on the GA4 protocol rather than the host, so server-side GTM
   // endpoints on first-party domains are captured too.
-  if (!u.pathname.endsWith("/g/collect") || u.searchParams.get("v") !== "2") return null;
+  if (!isGa4Path(u) || u.searchParams.get("v") !== "2") return null;
   // gtag.js resends a hit to www.google.com/g/collect when the first send seems lost, and
   // copies some to doubleclick.net. GA4 doesn't count these twice, so they aren't hits.
   // (Primary hits can carry gaf too, e.g. gaf=2, so the host decides, not the parameter.)
@@ -74,11 +81,14 @@ export function parseMeta(url) {
 /** @returns {Hit[] | null} */
 export function parseGoogleAds(url) {
   const u = new URL(url);
+  // Google tag gateway serves /pagead/conversion/<id>/ as /<prefix>/as/p/c/<id>/ on the site's own domain.
+  const gateway = u.pathname.match(/\/as\/p\/c\/(\d+)\/?$/);
   const isAds =
     (u.hostname === "www.googleadservices.com" && u.pathname.startsWith("/pagead/conversion/")) ||
-    (/(^|\.)google\.[a-z.]+$/.test(u.hostname) && u.pathname.startsWith("/pagead/1p-conversion/"));
+    (/(^|\.)google\.[a-z.]+$/.test(u.hostname) && u.pathname.startsWith("/pagead/1p-conversion/")) ||
+    (gateway && u.searchParams.has("cv"));
   if (!isAds) return null;
-  const conversionId = u.pathname.split("/").filter(Boolean)[2];
+  const conversionId = gateway ? gateway[1] : u.pathname.split("/").filter(Boolean)[2];
   const params = {};
   for (const key of ["label", "value", "currency_code", "oid"]) {
     if (u.searchParams.has(key)) params[key === "currency_code" ? "currency" : key === "oid" ? "transaction_id" : key] = u.searchParams.get(key);
@@ -136,7 +146,7 @@ export function parseTrackingRequest(url, postData) {
 // hits: Google Ads remarketing and consent pings, and the other common ad pixels.
 const OTHER_BEACONS = [
   [/(^|\.)(doubleclick\.net|googleadservices\.com|google\.[a-z.]+)$/, /^\/pagead\/(viewthroughconversion|1p-user-list|landing)\//],
-  [/(^|\.)google\.[a-z.]+$/, /^\/rmkt\/collect\//],
+  [/(^|\.)google\.[a-z.]+$/, /^\/(rmkt\/collect\/|measurement\/conversion|ads\/ga-audiences)/],
   [GOOGLE_COMPANION_HOST, /\/g\/collect$/],
   [/(^|\.)merchant-center-analytics\.goog$/, /^\/mc\/collect/],
   // Google tag pings on any host: consent mode (ccm), the Google tag's own /g/s/collect, and
@@ -217,8 +227,12 @@ export function providerOf(url) {
   if (/(^|\.)(doubleclick\.net|google\.[a-z.]+)$/.test(host) && /^\/(pagead|ccm)\//.test(u.pathname)) return of("google_ads");
   if (/(^|\.)doubleclick\.net$/.test(host)) return of("doubleclick");
   for (const [pattern, key] of HOSTS) if (pattern.test(host)) return of(key);
-  if (u.pathname.endsWith("/g/collect")) return of("ga4");
-  if (u.pathname.startsWith("/pagead/")) return of("google_ads");
+  if (isGa4Path(u)) return of("ga4");
+  if (u.pathname.startsWith("/pagead/") || /\/as\/p\/c\/\d+\/?$/.test(u.pathname)) return of("google_ads");
+  // Google Tag Manager and gtag.js served from the site's own domain (server-side GTM, Google tag gateway).
+  const id = u.searchParams.get("id") ?? "";
+  if (/^GTM-[A-Z0-9]+$/.test(id)) return of("gtm");
+  if (/\/gtag\/js$/.test(u.pathname) && id.startsWith("G-")) return of("ga4");
   return null;
 }