@wordbricks/playwright-mcp 0.1.20 → 0.1.22

package/lib/hooks/core.js

@@ -1,8 +1,8 @@
-import { reduce } from '@fxts/core';
-import { getEventStore, trackEvent } from './events.js';
-import { consumeEvents } from './eventConsumer.js';
-import { toolNameSchema } from './schema.js';
-export { Ok, Err } from '../utils/result.js';
+import { reduce } from "@fxts/core";
+import { consumeEvents } from "./eventConsumer.js";
+import { getEventStore, trackEvent } from "./events.js";
+import { toolNameSchema } from "./schema.js";
+export { Err, Ok } from "../utils/result.js";
 export const runHook = async (hook, ctx) => {
     const result = await hook.handler(ctx);
     if (!result.ok)
@@ -28,7 +28,8 @@ export const wrapToolWithHooks = (tool, registry) => {
     const toolName = parsedName.data;
     const toolHooks = getToolHooks(registry, toolName);
     // Even if no hooks configured, we still need to consume events and track tool calls
-    if (!toolHooks || (toolHooks.preHooks.length === 0 && toolHooks.postHooks.length === 0)) {
+    if (!toolHooks ||
+        (toolHooks.preHooks.length === 0 && toolHooks.postHooks.length === 0)) {
         return {
             ...tool,
             handle: async (context, params, response) => {
@@ -49,7 +50,7 @@ export const wrapToolWithHooks = (tool, registry) => {
                     // Record tool call completion
                     const executionTime = Date.now() - startTime;
                     trackEvent(context, {
-                        type: 'tool-call',
+                        type: "tool-call",
                         data: {
                             toolName,
                             params: params,
@@ -102,7 +103,7 @@ export const wrapToolWithHooks = (tool, registry) => {
                 // Record tool call completion
                 const executionTime = Date.now() - startTime;
                 trackEvent(context, {
-                    type: 'tool-call',
+                    type: "tool-call",
                     data: {
                         toolName,
                         params: params,
@@ -125,7 +126,7 @@ export const wrapToolWithHooks = (tool, registry) => {
                 await reduce(async (ctx, hook) => runHook(hook, await ctx), Promise.resolve(postHookContext), toolHooks.postHooks);
             }
             catch (error) {
-                response.addError(error instanceof Error ? error.message : 'Post-hook failed');
+                response.addError(error instanceof Error ? error.message : "Post-hook failed");
             }
             // Consume post-tool events
             consumeEvents(context, eventStore, response);
@@ -140,5 +141,5 @@ export const applyHooksToTools = (tools, context) => {
     const registry = getHookRegistry(context);
     if (registry.tools.size === 0)
         return tools;
-    return tools.map(tool => wrapToolWithHooks(tool, registry));
+    return tools.map((tool) => wrapToolWithHooks(tool, registry));
 };

package/lib/hooks/eventConsumer.js

@@ -1,21 +1,21 @@
-import { getEventsAfter, isEventType, updateLastSeenId } from './events.js';
-import { formatWaitEvent } from './waitHook.js';
-import { formatPageHeightEvent } from './pageHeightHook.js';
-import { formatNetworkEvent } from './networkTrackingHook.js';
-import { planGroupedMessages } from './grouping.js';
-import { formatToolCallEvent } from './formatToolCallEvent.js';
-import { formatFrameworkStateEvent } from './frameworkStateHook.js';
-import { formatJsonLdEvent } from './jsonLdDetectionHook.js';
-import { formatAntiBotEvent, getAntiBotProviderConfigs } from './antiBotDetectionHook.js';
-import { isAntiBotUrl } from './networkFilters.js';
+import { formatAntiBotEvent, getAntiBotProviderConfigs, } from "./antiBotDetectionHook.js";
+import { getEventsAfter, isEventType, updateLastSeenId } from "./events.js";
+import { formatToolCallEvent } from "./formatToolCallEvent.js";
+import { formatFrameworkStateEvent } from "./frameworkStateHook.js";
+import { planGroupedMessages } from "./grouping.js";
+import { formatJsonLdEvent } from "./jsonLdDetectionHook.js";
+import { isAntiBotUrl } from "./networkFilters.js";
+import { formatNetworkEvent } from "./networkTrackingHook.js";
+import { formatPageHeightEvent } from "./pageHeightHook.js";
+import { formatWaitEvent } from "./waitHook.js";
 const eventFormatters = {
-    'wait': formatWaitEvent,
-    'page-height-change': formatPageHeightEvent,
-    'network-request': formatNetworkEvent,
-    'tool-call': formatToolCallEvent,
-    'framework-state': formatFrameworkStateEvent,
-    'json-ld': formatJsonLdEvent,
-    'anti-bot': formatAntiBotEvent,
+    wait: formatWaitEvent,
+    "page-height-change": formatPageHeightEvent,
+    "network-request": formatNetworkEvent,
+    "tool-call": formatToolCallEvent,
+    "framework-state": formatFrameworkStateEvent,
+    "json-ld": formatJsonLdEvent,
+    "anti-bot": formatAntiBotEvent,
 };
 const formatEvent = (event) => {
     const formatter = eventFormatters[event.type];
@@ -29,19 +29,19 @@ const consumeEvent = (event, response, plan) => {
     response.addEvent(`[${event.id}] ${formattedMessage}`);
 };
 const shouldHideEvent = (event) => {
-    const isNetworkRequest = isEventType('network-request');
+    const isNetworkRequest = isEventType("network-request");
     if (!isNetworkRequest(event))
         return false;
     if (isAntiBotUrl(event.data.url))
         return true;
-    const configs = getAntiBotProviderConfigs().filter(config => config.provider === 'cloudflare-turnstile');
-    return configs.some(config => config.match(event));
+    const configs = getAntiBotProviderConfigs().filter((config) => config.provider === "cloudflare-turnstile");
+    return configs.some((config) => config.match(event));
 };
 export const consumeEvents = (context, eventStore, response) => {
     const unconsumedEvents = getEventsAfter(eventStore, eventStore.lastSeenEventId);
     if (unconsumedEvents.length === 0)
         return;
-    const visibleEvents = unconsumedEvents.filter(event => !shouldHideEvent(event));
+    const visibleEvents = unconsumedEvents.filter((event) => !shouldHideEvent(event));
     const plan = planGroupedMessages(visibleEvents);
     // Consume all events in chronological order
     for (const event of visibleEvents)

package/lib/hooks/events.js

@@ -1,4 +1,4 @@
-import { pipe, filter, toArray } from '@fxts/core';
+import { filter, pipe, toArray } from "@fxts/core";
 export const isEventType = (type) => (event) => event.type === type;
 export const createEventStore = () => ({
     events: new Map(),
@@ -12,7 +12,7 @@ export const trackEvent = (context, params) => {
         id: eventId,
         type: params.type,
         data: params.data,
-        timestamp: params.timestamp ?? Date.now()
+        timestamp: params.timestamp ?? Date.now(),
     };
     store.events.set(eventId, event);
     return eventId;
@@ -26,7 +26,7 @@ export const getEventsAfter = (store, afterEventId) => {
     if (!afterEventId) {
         return pipe(store.events.values(), toArray);
     }
-    return pipe(store.events.values(), filter(event => event.id > afterEventId), toArray);
+    return pipe(store.events.values(), filter((event) => event.id > afterEventId), toArray);
 };
 const eventStoreMap = new WeakMap();
 export const getEventStore = (context) => {

package/lib/hooks/formatToolCallEvent.js

@@ -3,14 +3,10 @@ export const formatToolCallEvent = (event) => {
     // Format parameters (truncate if too long)
     const paramStr = params && Object.keys(params).length > 0
         ? ` with params: ${JSON.stringify(params, null, 0).slice(0, 100)}`
-        : '';
+        : "";
     // Format execution time if available
-    const timeStr = executionTime !== undefined
-        ? ` (${executionTime}ms)`
-        : '';
+    const timeStr = executionTime !== undefined ? ` (${executionTime}ms)` : "";
     // Format success status if available
-    const statusStr = success !== undefined
-        ? success ? ' ✓' : ' ✗'
-        : '';
+    const statusStr = success !== undefined ? (success ? " ✓" : " ✗") : "";
     return `Tool ${toolName}${paramStr}${timeStr}${statusStr}`;
 };

package/lib/hooks/frameworkStateHook.js

@@ -1,7 +1,7 @@
-import { Ok } from '../utils/result.js';
-import { hookNameSchema } from './schema.js';
-import { trackEvent } from './events.js';
-import { FRAMEWORK_STATE_PATTERNS, MAX_DISPLAY_ITEMS } from '../frameworkPatterns.js';
+import { FRAMEWORK_STATE_PATTERNS, MAX_DISPLAY_ITEMS, } from "../frameworkPatterns.js";
+import { Ok } from "../utils/result.js";
+import { trackEvent } from "./events.js";
+import { hookNameSchema } from "./schema.js";
 const pageFrameworkStates = new WeakMap();
 const seenFrameworkKeysByContext = new WeakMap();
 const getSeenFrameworkKeys = (context) => {
@@ -13,7 +13,7 @@ const getSeenFrameworkKeys = (context) => {
     return set;
 };
 export const frameworkStatePreHook = {
-    name: hookNameSchema.enum['framework-state-pre'],
+    name: hookNameSchema.enum["framework-state-pre"],
     handler: async (context) => {
         const frameworkState = await detectFrameworkState(context);
         if (frameworkState) {
@@ -21,27 +21,29 @@ export const frameworkStatePreHook = {
             if (context.tab?.page)
                 pageFrameworkStates.set(context.tab.page, frameworkState);
             // Track event for newly detected framework state
-            const newKeys = Object.keys(frameworkState).filter(key => !getSeenFrameworkKeys(context.context).has(key));
+            const newKeys = Object.keys(frameworkState).filter((key) => !getSeenFrameworkKeys(context.context).has(key));
             if (newKeys.length > 0) {
                 trackEvent(context.context, {
-                    type: 'framework-state',
+                    type: "framework-state",
                     data: {
                         state: frameworkState,
-                        action: 'detected',
+                        action: "detected",
                     },
                 });
                 // Mark keys as seen
-                newKeys.forEach(key => getSeenFrameworkKeys(context.context).add(key));
+                newKeys.forEach((key) => getSeenFrameworkKeys(context.context).add(key));
             }
         }
         return Ok(undefined);
     },
 };
 export const frameworkStatePostHook = {
-    name: hookNameSchema.enum['framework-state-post'],
+    name: hookNameSchema.enum["framework-state-post"],
     handler: async (context) => {
         const newFrameworkState = await detectFrameworkState(context);
-        const initialState = context.tab?.page ? pageFrameworkStates.get(context.tab.page) : undefined;
+        const initialState = context.tab?.page
+            ? pageFrameworkStates.get(context.tab.page)
+            : undefined;
         if (newFrameworkState) {
             const changes = [];
             if (initialState) {
@@ -64,27 +66,27 @@ export const frameworkStatePostHook = {
                 }
                 if (changes.length > 0) {
                     trackEvent(context.context, {
-                        type: 'framework-state',
+                        type: "framework-state",
                         data: {
                             state: newFrameworkState,
                             changes,
-                            action: 'changed',
+                            action: "changed",
                         },
                     });
                 }
             }
             else {
                 // No initial state, but we have state now
-                const newKeys = Object.keys(newFrameworkState).filter(key => !getSeenFrameworkKeys(context.context).has(key));
+                const newKeys = Object.keys(newFrameworkState).filter((key) => !getSeenFrameworkKeys(context.context).has(key));
                 if (newKeys.length > 0) {
                     trackEvent(context.context, {
-                        type: 'framework-state',
+                        type: "framework-state",
                         data: {
                             state: newFrameworkState,
-                            action: 'detected',
+                            action: "detected",
                         },
                     });
-                    newKeys.forEach(key => getSeenFrameworkKeys(context.context).add(key));
+                    newKeys.forEach((key) => getSeenFrameworkKeys(context.context).add(key));
                 }
             }
             // Update stored state
@@ -107,11 +109,11 @@ async function detectFrameworkState(context) {
                     const value = window[pattern];
                     // Only capture if it's a non-empty object or has meaningful content
                     if (value &&
-                        (typeof value === 'object' || typeof value === 'string')) {
+                        (typeof value === "object" || typeof value === "string")) {
                         state[pattern] =
-                            typeof value === 'object'
+                            typeof value === "object"
                                 ? {
-                                    type: 'object',
+                                    type: "object",
                                     keys: Object.keys(value).slice(0, MAX_ITEMS * 2),
                                 }
                                 : {
@@ -127,19 +129,19 @@ async function detectFrameworkState(context) {
         }
         // Also check for React Fiber internals
         const reactRootSelectors = [
-            '#__next',
-            '#root',
-            '#app',
-            '[data-reactroot]',
+            "#__next",
+            "#root",
+            "#app",
+            "[data-reactroot]",
         ];
         for (const selector of reactRootSelectors) {
             const element = document.querySelector(selector);
             if (element) {
-                const fiberKey = Object.keys(element).find(key => key.startsWith('__reactInternalInstance') ||
-                    key.startsWith('__reactFiber') ||
-                    key.startsWith('_reactRootContainer'));
+                const fiberKey = Object.keys(element).find((key) => key.startsWith("__reactInternalInstance") ||
+                    key.startsWith("__reactFiber") ||
+                    key.startsWith("_reactRootContainer"));
                 if (fiberKey) {
-                    state['React Fiber Root'] = { selector, fiberKey };
+                    state["React Fiber Root"] = { selector, fiberKey };
                     break;
                 }
             }
@@ -149,32 +151,30 @@ async function detectFrameworkState(context) {
     return result;
 }
 function formatValue(value) {
-    if (typeof value === 'object' && value !== null && 'type' in value) {
-        if (value.type === 'object' &&
-            'keys' in value &&
-            Array.isArray(value.keys))
-            return `{${value.keys.join(', ')}${value.keys.length >= MAX_DISPLAY_ITEMS * 2 ? ', ...' : ''}}`;
-        else if ('preview' in value && typeof value.preview === 'string')
-            return `"${value.preview}${value.preview.length >= 200 ? '...' : ''}"`;
+    if (typeof value === "object" && value !== null && "type" in value) {
+        if (value.type === "object" && "keys" in value && Array.isArray(value.keys))
+            return `{${value.keys.join(", ")}${value.keys.length >= MAX_DISPLAY_ITEMS * 2 ? ", ..." : ""}}`;
+        else if ("preview" in value && typeof value.preview === "string")
+            return `"${value.preview}${value.preview.length >= 200 ? "..." : ""}"`;
     }
     return JSON.stringify(value);
 }
 export const formatFrameworkStateEvent = (event) => {
     const { state, changes, action } = event.data;
     const messages = [];
-    if (action === 'detected') {
-        messages.push('Framework state detected:');
+    if (action === "detected") {
+        messages.push("Framework state detected:");
         const keys = Object.keys(state);
         for (const key of keys) {
             const value = state[key];
             messages.push(`  ${key}: ${formatValue(value)}`);
         }
     }
-    else if (action === 'changed' && changes) {
-        messages.push('Framework state changed:');
+    else if (action === "changed" && changes) {
+        messages.push("Framework state changed:");
         messages.push(...changes.map((change) => `  ${change}`));
     }
-    return messages.join('\n');
+    return messages.join("\n");
 };
 export const frameworkStateHooks = {
     pre: frameworkStatePreHook,

package/lib/hooks/grouping.js

@@ -7,7 +7,7 @@ export const defineGroupingRule = (spec) => {
         keyOf: (e) => {
             // Planner guarantees keyOf is only called when match(e) is true
             if (!match(e))
-                return '';
+                return "";
             return spec.keyOf(e);
         },
         summaryOf: (first, run) => {
@@ -19,9 +19,9 @@ export const defineGroupingRule = (spec) => {
             }
             const typedFirst = match(first) ? first : typedRun[0];
             if (!typedFirst)
-                return '';
+                return "";
             return spec.summaryOf(typedFirst, typedRun);
-        }
+        },
     };
 };
 export const registerGroupingRule = (type, rule) => {

package/lib/hooks/jsonLdDetectionHook.js

@@ -1,6 +1,6 @@
-import { Ok } from '../utils/result.js';
-import { hookNameSchema } from './schema.js';
-import { trackEvent } from './events.js';
+import { Ok } from "../utils/result.js";
+import { trackEvent } from "./events.js";
+import { hookNameSchema } from "./schema.js";
 const MAX_DISPLAY_ITEMS = 5;
 const pageJsonLdStates = new WeakMap();
 const seenJsonLdTypesByContext = new WeakMap();
@@ -13,7 +13,7 @@ const getSeenJsonLdTypes = (context) => {
     return set;
 };
 export const jsonLdDetectionPreHook = {
-    name: hookNameSchema.enum['json-ld-detection-pre'],
+    name: hookNameSchema.enum["json-ld-detection-pre"],
     handler: async (context) => {
         const jsonLdState = await detectJsonLdState(context);
         if (jsonLdState) {
@@ -21,27 +21,29 @@ export const jsonLdDetectionPreHook = {
             if (context.tab?.page)
                 pageJsonLdStates.set(context.tab.page, jsonLdState);
             // Track event for newly detected JSON-LD types
-            const newTypes = Object.keys(jsonLdState).filter(type => !getSeenJsonLdTypes(context.context).has(type));
+            const newTypes = Object.keys(jsonLdState).filter((type) => !getSeenJsonLdTypes(context.context).has(type));
             if (newTypes.length > 0) {
                 trackEvent(context.context, {
-                    type: 'json-ld',
+                    type: "json-ld",
                     data: {
                         state: jsonLdState,
-                        action: 'detected',
+                        action: "detected",
                     },
                 });
                 // Mark types as seen
-                newTypes.forEach(type => getSeenJsonLdTypes(context.context).add(type));
+                newTypes.forEach((type) => getSeenJsonLdTypes(context.context).add(type));
             }
         }
         return Ok(undefined);
     },
 };
 export const jsonLdDetectionPostHook = {
-    name: hookNameSchema.enum['json-ld-detection-post'],
+    name: hookNameSchema.enum["json-ld-detection-post"],
     handler: async (context) => {
         const newJsonLdState = await detectJsonLdState(context);
-        const initialState = context.tab?.page ? pageJsonLdStates.get(context.tab.page) : undefined;
+        const initialState = context.tab?.page
+            ? pageJsonLdStates.get(context.tab.page)
+            : undefined;
         if (newJsonLdState || initialState) {
             const changes = [];
             if (initialState && newJsonLdState) {
@@ -54,37 +56,35 @@ export const jsonLdDetectionPostHook = {
                     const initInfo = initialState[type];
                     const currInfo = newJsonLdState[type];
                     if (!initInfo && currInfo)
-                        changes.push(`+ ${type}${currInfo.count > 1 ? ` (${currInfo.count} instances)` : ''}`);
+                        changes.push(`+ ${type}${currInfo.count > 1 ? ` (${currInfo.count} instances)` : ""}`);
                     else if (initInfo && !currInfo)
-                        changes.push(`- ${type}${initInfo.count > 1 ? ` (${initInfo.count} instances)` : ''}`);
-                    else if (initInfo &&
-                        currInfo &&
-                        initInfo.count !== currInfo.count)
+                        changes.push(`- ${type}${initInfo.count > 1 ? ` (${initInfo.count} instances)` : ""}`);
+                    else if (initInfo && currInfo && initInfo.count !== currInfo.count)
                         changes.push(`~ ${type}: ${initInfo.count} → ${currInfo.count} instances`);
                 }
                 if (changes.length > 0) {
                     trackEvent(context.context, {
-                        type: 'json-ld',
+                        type: "json-ld",
                         data: {
                             state: newJsonLdState,
                             changes,
-                            action: 'changed',
+                            action: "changed",
                         },
                     });
                 }
             }
             else if (newJsonLdState && !initialState) {
                 // No initial state, but we have state now
-                const newTypes = Object.keys(newJsonLdState).filter(type => !getSeenJsonLdTypes(context.context).has(type));
+                const newTypes = Object.keys(newJsonLdState).filter((type) => !getSeenJsonLdTypes(context.context).has(type));
                 if (newTypes.length > 0) {
                     trackEvent(context.context, {
-                        type: 'json-ld',
+                        type: "json-ld",
                         data: {
                             state: newJsonLdState,
-                            action: 'detected',
+                            action: "detected",
                         },
                     });
-                    newTypes.forEach(type => getSeenJsonLdTypes(context.context).add(type));
+                    newTypes.forEach((type) => getSeenJsonLdTypes(context.context).add(type));
                 }
             }
             // Update stored state
@@ -104,23 +104,27 @@ async function detectJsonLdState(context) {
         scripts.forEach((script, index) => {
             try {
                 // Parse JSON
-                const data = JSON.parse(script.textContent || '{}');
+                const data = JSON.parse(script.textContent || "{}");
                 // Extract @type - handle both single and array types
                 let types = [];
-                if (data['@type']) {
-                    types = Array.isArray(data['@type']) ? data['@type'] : [data['@type']];
+                if (data["@type"]) {
+                    types = Array.isArray(data["@type"])
+                        ? data["@type"]
+                        : [data["@type"]];
                 }
-                else if (data['@graph'] && Array.isArray(data['@graph'])) {
+                else if (data["@graph"] && Array.isArray(data["@graph"])) {
                     // Handle @graph structures
-                    data['@graph'].forEach((item) => {
-                        if (item['@type']) {
-                            const itemTypes = Array.isArray(item['@type']) ? item['@type'] : [item['@type']];
+                    data["@graph"].forEach((item) => {
+                        if (item["@type"]) {
+                            const itemTypes = Array.isArray(item["@type"])
+                                ? item["@type"]
+                                : [item["@type"]];
                             types.push(...itemTypes);
                         }
                     });
                 }
                 // Count occurrences of each type
-                types.forEach(type => {
+                types.forEach((type) => {
                     if (!state[type])
                         state[type] = { count: 0, indices: [] };
                     state[type].count++;
@@ -128,9 +132,12 @@ async function detectJsonLdState(context) {
                 });
             }
             catch (e) {
-                state['InvalidJSON-LD'] = state['InvalidJSON-LD'] || { count: 0, indices: [] };
-                state['InvalidJSON-LD'].count++;
-                state['InvalidJSON-LD'].indices.push(index);
+                state["InvalidJSON-LD"] = state["InvalidJSON-LD"] || {
+                    count: 0,
+                    indices: [],
+                };
+                state["InvalidJSON-LD"].count++;
+                state["InvalidJSON-LD"].indices.push(index);
             }
         });
         return Object.keys(state).length > 0 ? state : null;
@@ -159,15 +166,15 @@ function buildStateMessages(state, types) {
 export const formatJsonLdEvent = (event) => {
     const { state, changes, action } = event.data;
     const messages = [];
-    if (action === 'detected') {
-        messages.push('New JSON-LD types detected:');
+    if (action === "detected") {
+        messages.push("New JSON-LD types detected:");
         messages.push(...buildStateMessages(state));
     }
-    else if (action === 'changed' && changes) {
-        messages.push('JSON-LD changes after action:');
+    else if (action === "changed" && changes) {
+        messages.push("JSON-LD changes after action:");
         messages.push(...changes.map((change) => `  ${change}`));
     }
-    return messages.join('\n');
+    return messages.join("\n");
 };
 export const jsonLdDetectionHooks = {
     pre: jsonLdDetectionPreHook,

package/lib/hooks/networkFilters.js

@@ -1,20 +1,20 @@
-const MEANINGFUL_RESOURCE_TYPES = ['document', 'xhr', 'fetch'];
-const ALLOWED_METHODS = ['GET', 'POST'];
+const MEANINGFUL_RESOURCE_TYPES = ["document", "xhr", "fetch"];
+const ALLOWED_METHODS = ["GET", "POST"];
 const EXCLUDED_EXTENSIONS = [
-    '.svg',
-    '.css',
-    '.map', // JS files and source maps
+    ".svg",
+    ".css",
+    ".map", // JS files and source maps
 ];
 const hasExcludedExtension = (url) => {
-    return EXCLUDED_EXTENSIONS.some(ext => {
-        const extRegex = new RegExp(`${ext.replace('.', '\\.')}(\\?|#|$)`, 'i');
+    return EXCLUDED_EXTENSIONS.some((ext) => {
+        const extRegex = new RegExp(`${ext.replace(".", "\\.")}(\\?|#|$)`, "i");
         return extRegex.test(url);
     });
 };
 export const isAntiBotUrl = (url) => {
-    if (url.includes('challenges.cloudflare.com'))
+    if (url.includes("challenges.cloudflare.com"))
         return true;
-    if (url.includes('.awswaf.com'))
+    if (url.includes(".awswaf.com"))
         return true;
     return false;
 };
@@ -27,10 +27,10 @@ const isSuccessfulStatus = (status) => {
 export const shouldCaptureRequest = (method, url, status, resourceType) => {
     if (isAntiBotUrl(url))
         return true;
-    return !hasExcludedExtension(url) &&
+    return (!hasExcludedExtension(url) &&
         MEANINGFUL_RESOURCE_TYPES.includes(resourceType) &&
         ALLOWED_METHODS.includes(method) &&
-        isSuccessfulStatus(status);
+        isSuccessfulStatus(status));
 };
 /**
  * Format URL with trimmed parameters
@@ -43,7 +43,7 @@ export const formatUrlWithTrimmedParams = (url) => {
             const trimmedParams = new URLSearchParams();
             params.forEach((value, key) => {
                 if (value.length > 5)
-                    trimmedParams.set(key, value.substring(0, 5) + '...');
+                    trimmedParams.set(key, value.substring(0, 5) + "...");
                 else
                     trimmedParams.set(key, value);
             });
@@ -61,10 +61,10 @@ export const formatUrlWithTrimmedParams = (url) => {
  */
 export const normalizePathname = (pathname) => {
     if (!pathname)
-        return '/';
-    if (pathname === '/')
-        return '/';
-    return pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
+        return "/";
+    if (pathname === "/")
+        return "/";
+    return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
 };
 /**
  * Normalize URL for grouping by ignoring query/hash and trailing slash
@@ -76,7 +76,7 @@ export const normalizeUrlForGrouping = (url) => {
     }
     catch {
         // Fallback for non-standard/relative URLs: strip query/hash and trailing slash
-        const base = url.split(/[?#]/)[0] || '/';
+        const base = url.split(/[?#]/)[0] || "/";
         return normalizePathname(base);
     }
 };