@vibecheckai/cli 3.2.2 → 3.2.4

package/bin/runners/lib/reality/request-mapper.js

@@ -1,453 +1,453 @@
-/**
- * Request Mapper v2
- * 
- * Maps runtime requests to client calls with specificity scoring.
- * Handles URL normalization, basePath, proxies, tRPC/GraphQL operations.
- */
-
-"use strict";
-
-const crypto = require("crypto");
-
-// =============================================================================
-// IGNORE PATTERNS
-// =============================================================================
-
-const IGNORE_PATTERNS = {
-  // Asset extensions
-  assets: /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff2?|ttf|eot|map|webp|avif)(\?.*)?$/i,
-  
-  // Dev/HMR patterns
-  hmr: /(_next\/static|__webpack_hmr|hot-update|\.hot-update\.|webpack|turbopack)/i,
-  
-  // Analytics/tracking
-  analytics: /(analytics|gtag|ga\.js|gtm\.js|pixel|clarity|hotjar|segment|mixpanel|amplitude)/i,
-  
-  // Third party
-  thirdParty: /^https?:\/\/(fonts\.googleapis|cdn\.|unpkg\.com|cdnjs\.|jsdelivr)/i,
-  
-  // Browser internals
-  browser: /^(chrome-extension|moz-extension|safari-extension|about:|data:|blob:)/i,
-  
-  // Favicon
-  favicon: /favicon\.ico/i,
-  
-  // Source maps
-  sourceMaps: /\.map$/i,
-  
-  // WebSocket
-  websocket: /^wss?:/i,
-};
-
-/**
- * Check if request should be ignored
- */
-function shouldIgnoreRequest(url, method = "GET") {
-  if (!url) return true;
-  
-  // Always include mutations
-  if (["POST", "PUT", "PATCH", "DELETE"].includes(method?.toUpperCase())) {
-    // But still ignore analytics POST
-    if (IGNORE_PATTERNS.analytics.test(url)) return true;
-    return false;
-  }
-  
-  for (const pattern of Object.values(IGNORE_PATTERNS)) {
-    if (pattern.test(url)) return true;
-  }
-  
-  return false;
-}
-
-// =============================================================================
-// URL NORMALIZATION
-// =============================================================================
-
-/**
- * Normalize URL for matching
- */
-function normalizeRequestUrl(url, options = {}) {
-  const { basePath = "", stripHost = true, stripQuery = true } = options;
-  
-  if (!url) return null;
-  
-  let normalized = url;
-  
-  // Strip host if absolute URL
-  if (stripHost && /^https?:\/\//.test(normalized)) {
-    try {
-      const parsed = new URL(normalized);
-      normalized = parsed.pathname + (stripQuery ? "" : parsed.search);
-    } catch {
-      // Invalid URL, try to extract path
-      normalized = normalized.replace(/^https?:\/\/[^/]+/, "");
-    }
-  }
-  
-  // Strip query string
-  if (stripQuery) {
-    normalized = normalized.split("?")[0].split("#")[0];
-  }
-  
-  // Strip basePath prefix
-  if (basePath && normalized.startsWith(basePath)) {
-    normalized = normalized.slice(basePath.length) || "/";
-  }
-  
-  // Ensure leading slash
-  if (!normalized.startsWith("/")) {
-    normalized = "/" + normalized;
-  }
-  
-  // Remove trailing slash except for root
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
-  }
-  
-  // Normalize multiple slashes
-  normalized = normalized.replace(/\/+/g, "/");
-  
-  return normalized;
-}
-
-/**
- * Extract tRPC operation from URL
- */
-function extractTrpcOperation(url) {
-  // /api/trpc/user.get?batch=1&input=...
-  const match = url.match(/\/trpc\/([^?]+)/);
-  if (!match) return null;
-  
-  const procedure = match[1];
-  // Handle batch queries
-  const procedures = procedure.split(",").map(p => p.trim());
-  
-  return {
-    type: "trpc",
-    procedures,
-    isBatch: procedures.length > 1,
-  };
-}
-
-/**
- * Extract GraphQL operation from request
- */
-function extractGraphqlOperation(url, body) {
-  // Check if it's a GraphQL endpoint
-  if (!url.includes("graphql")) return null;
-  
-  if (!body) return { type: "graphql", operationName: null };
-  
-  try {
-    const parsed = typeof body === "string" ? JSON.parse(body) : body;
-    return {
-      type: "graphql",
-      operationName: parsed.operationName || null,
-      operationType: parsed.query?.trim().startsWith("mutation") ? "mutation" : "query",
-    };
-  } catch {
-    return { type: "graphql", operationName: null };
-  }
-}
-
-// =============================================================================
-// REQUEST → CLIENT CALL MATCHING
-// =============================================================================
-
-/**
- * Match a runtime request to client calls
- */
-function matchRequestToClientCalls(request, clientCalls, options = {}) {
-  const { basePath = "", rewrites = [] } = options;
-  
-  const normalizedPath = normalizeRequestUrl(request.url, { basePath });
-  if (!normalizedPath) return null;
-  
-  const method = (request.method || "GET").toUpperCase();
-  
-  // Check for tRPC
-  const trpcOp = extractTrpcOperation(request.url);
-  if (trpcOp) {
-    return matchTrpcRequest(trpcOp, clientCalls, request);
-  }
-  
-  // Check for GraphQL
-  const gqlOp = extractGraphqlOperation(request.url, request.body);
-  if (gqlOp) {
-    return matchGraphqlRequest(gqlOp, clientCalls, request);
-  }
-  
-  // Standard HTTP matching
-  const candidates = [];
-  
-  for (const call of clientCalls) {
-    if (call.kind !== "http") continue;
-    
-    const score = calculateMatchScore(normalizedPath, method, call, { basePath, rewrites });
-    if (score > 0) {
-      candidates.push({ call, score });
-    }
-  }
-  
-  // Sort by score descending
-  candidates.sort((a, b) => b.score - a.score);
-  
-  if (candidates.length === 0) {
-    return {
-      matched: false,
-      request,
-      normalizedPath,
-      method,
-      candidates: [],
-    };
-  }
-  
-  return {
-    matched: true,
-    request,
-    normalizedPath,
-    method,
-    bestMatch: candidates[0].call,
-    score: candidates[0].score,
-    candidates: candidates.slice(0, 3),
-  };
-}
-
-/**
- * Match tRPC request to client calls
- */
-function matchTrpcRequest(trpcOp, clientCalls, request) {
-  const trpcCalls = clientCalls.filter(c => c.kind === "trpc");
-  
-  for (const call of trpcCalls) {
-    const callProcedure = call.meta?.procedure;
-    if (!callProcedure) continue;
-    
-    // Check if any procedure matches
-    for (const proc of trpcOp.procedures) {
-      if (proc === callProcedure || proc.endsWith(callProcedure)) {
-        return {
-          matched: true,
-          request,
-          matchType: "trpc",
-          procedure: proc,
-          bestMatch: call,
-          score: 1.0,
-        };
-      }
-    }
-  }
-  
-  return {
-    matched: false,
-    request,
-    matchType: "trpc",
-    procedures: trpcOp.procedures,
-  };
-}
-
-/**
- * Match GraphQL request to client calls
- */
-function matchGraphqlRequest(gqlOp, clientCalls, request) {
-  const gqlCalls = clientCalls.filter(c => c.kind === "graphql");
-  
-  if (gqlOp.operationName) {
-    for (const call of gqlCalls) {
-      if (call.meta?.operationName === gqlOp.operationName) {
-        return {
-          matched: true,
-          request,
-          matchType: "graphql",
-          operationName: gqlOp.operationName,
-          bestMatch: call,
-          score: 1.0,
-        };
-      }
-    }
-  }
-  
-  // Fallback: match any GraphQL call
-  if (gqlCalls.length > 0) {
-    return {
-      matched: true,
-      request,
-      matchType: "graphql",
-      operationName: gqlOp.operationName,
-      bestMatch: gqlCalls[0],
-      score: 0.5,
-    };
-  }
-  
-  return {
-    matched: false,
-    request,
-    matchType: "graphql",
-    operationName: gqlOp.operationName,
-  };
-}
-
-/**
- * Calculate match score between request and client call
- */
-function calculateMatchScore(requestPath, requestMethod, call, options = {}) {
-  const { basePath = "", rewrites = [] } = options;
-  
-  let callPath = call.canonicalPath;
-  if (!callPath) return 0;
-  
-  // Apply rewrites
-  for (const rewrite of rewrites) {
-    if (rewrite.source && rewrite.destination) {
-      const sourceRegex = new RegExp("^" + rewrite.source.replace(/:(\w+)/g, "([^/]+)") + "$");
-      if (sourceRegex.test(requestPath)) {
-        // Rewrite matches, adjust call path expectation
-        callPath = requestPath.replace(sourceRegex, rewrite.destination);
-        break;
-      }
-    }
-  }
-  
-  let score = 0;
-  
-  // Exact path match
-  if (requestPath === callPath) {
-    score += 1.0;
-  }
-  // Parameterized match
-  else if (callPath.includes("{") || callPath.includes(":")) {
-    const pattern = "^" + callPath
-      .replace(/\{[^}]+\}/g, "[^/]+")
-      .replace(/:(\w+)/g, "[^/]+") + "$";
-    const regex = new RegExp(pattern);
-    if (regex.test(requestPath)) {
-      score += 0.9;
-    }
-  }
-  // Prefix match (less confident)
-  else if (requestPath.startsWith(callPath) || callPath.startsWith(requestPath)) {
-    score += 0.5;
-  }
-  
-  if (score === 0) return 0;
-  
-  // Method match bonus
-  const callMethod = (call.method || "UNKNOWN").toUpperCase();
-  if (callMethod === requestMethod) {
-    score += 0.1;
-  } else if (callMethod === "UNKNOWN" || callMethod === "*") {
-    // No penalty for unknown
-  } else {
-    score -= 0.2; // Method mismatch penalty
-  }
-  
-  // Confidence bonus
-  if (call.confidence === "high") {
-    score += 0.05;
-  } else if (call.confidence === "low") {
-    score -= 0.05;
-  }
-  
-  return Math.max(0, Math.min(1, score));
-}
-
-// =============================================================================
-// BATCH MAPPING
-// =============================================================================
-
-/**
- * Map all runtime requests to client calls
- */
-function mapAllRequests(requests, clientCalls, options = {}) {
-  const { basePath = "", rewrites = [], includeIgnored = false } = options;
-  
-  const results = {
-    mapped: [],
-    unmapped: [],
-    ignored: [],
-    stats: {
-      total: requests.length,
-      mapped: 0,
-      unmapped: 0,
-      ignored: 0,
-      byMatchType: {},
-    },
-  };
-  
-  for (const request of requests) {
-    // Check if should ignore
-    if (shouldIgnoreRequest(request.url, request.method)) {
-      if (includeIgnored) {
-        results.ignored.push(request);
-      }
-      results.stats.ignored++;
-      continue;
-    }
-    
-    const match = matchRequestToClientCalls(request, clientCalls, { basePath, rewrites });
-    
-    if (match.matched) {
-      results.mapped.push(match);
-      results.stats.mapped++;
-      
-      const matchType = match.matchType || "http";
-      results.stats.byMatchType[matchType] = (results.stats.byMatchType[matchType] || 0) + 1;
-    } else {
-      results.unmapped.push(match);
-      results.stats.unmapped++;
-    }
-  }
-  
-  return results;
-}
-
-/**
- * Group mapped requests by client call
- */
-function groupRequestsByClientCall(mappedResults) {
-  const groups = new Map();
-  
-  for (const match of mappedResults) {
-    if (!match.bestMatch) continue;
-    
-    const callId = match.bestMatch.id;
-    if (!groups.has(callId)) {
-      groups.set(callId, {
-        clientCall: match.bestMatch,
-        requests: [],
-        statuses: [],
-      });
-    }
-    
-    const group = groups.get(callId);
-    group.requests.push(match.request);
-    if (match.request.status) {
-      group.statuses.push(match.request.status);
-    }
-  }
-  
-  return groups;
-}
-
-// =============================================================================
-// EXPORTS
-// =============================================================================
-
-module.exports = {
-  // Ignore patterns
-  IGNORE_PATTERNS,
-  shouldIgnoreRequest,
-  
-  // URL normalization
-  normalizeRequestUrl,
-  extractTrpcOperation,
-  extractGraphqlOperation,
-  
-  // Matching
-  matchRequestToClientCalls,
-  calculateMatchScore,
-  
-  // Batch operations
-  mapAllRequests,
-  groupRequestsByClientCall,
-};
+/**
+ * Request Mapper v2
+ * 
+ * Maps runtime requests to client calls with specificity scoring.
+ * Handles URL normalization, basePath, proxies, tRPC/GraphQL operations.
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+
+// =============================================================================
+// IGNORE PATTERNS
+// =============================================================================
+
+const IGNORE_PATTERNS = {
+  // Asset extensions
+  assets: /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff2?|ttf|eot|map|webp|avif)(\?.*)?$/i,
+  
+  // Dev/HMR patterns
+  hmr: /(_next\/static|__webpack_hmr|hot-update|\.hot-update\.|webpack|turbopack)/i,
+  
+  // Analytics/tracking
+  analytics: /(analytics|gtag|ga\.js|gtm\.js|pixel|clarity|hotjar|segment|mixpanel|amplitude)/i,
+  
+  // Third party
+  thirdParty: /^https?:\/\/(fonts\.googleapis|cdn\.|unpkg\.com|cdnjs\.|jsdelivr)/i,
+  
+  // Browser internals
+  browser: /^(chrome-extension|moz-extension|safari-extension|about:|data:|blob:)/i,
+  
+  // Favicon
+  favicon: /favicon\.ico/i,
+  
+  // Source maps
+  sourceMaps: /\.map$/i,
+  
+  // WebSocket
+  websocket: /^wss?:/i,
+};
+
+/**
+ * Check if request should be ignored
+ */
+function shouldIgnoreRequest(url, method = "GET") {
+  if (!url) return true;
+  
+  // Always include mutations
+  if (["POST", "PUT", "PATCH", "DELETE"].includes(method?.toUpperCase())) {
+    // But still ignore analytics POST
+    if (IGNORE_PATTERNS.analytics.test(url)) return true;
+    return false;
+  }
+  
+  for (const pattern of Object.values(IGNORE_PATTERNS)) {
+    if (pattern.test(url)) return true;
+  }
+  
+  return false;
+}
+
+// =============================================================================
+// URL NORMALIZATION
+// =============================================================================
+
+/**
+ * Normalize URL for matching
+ */
+function normalizeRequestUrl(url, options = {}) {
+  const { basePath = "", stripHost = true, stripQuery = true } = options;
+  
+  if (!url) return null;
+  
+  let normalized = url;
+  
+  // Strip host if absolute URL
+  if (stripHost && /^https?:\/\//.test(normalized)) {
+    try {
+      const parsed = new URL(normalized);
+      normalized = parsed.pathname + (stripQuery ? "" : parsed.search);
+    } catch {
+      // Invalid URL, try to extract path
+      normalized = normalized.replace(/^https?:\/\/[^/]+/, "");
+    }
+  }
+  
+  // Strip query string
+  if (stripQuery) {
+    normalized = normalized.split("?")[0].split("#")[0];
+  }
+  
+  // Strip basePath prefix
+  if (basePath && normalized.startsWith(basePath)) {
+    normalized = normalized.slice(basePath.length) || "/";
+  }
+  
+  // Ensure leading slash
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  
+  // Remove trailing slash except for root
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  
+  // Normalize multiple slashes
+  normalized = normalized.replace(/\/+/g, "/");
+  
+  return normalized;
+}
+
+/**
+ * Extract tRPC operation from URL
+ */
+function extractTrpcOperation(url) {
+  // /api/trpc/user.get?batch=1&input=...
+  const match = url.match(/\/trpc\/([^?]+)/);
+  if (!match) return null;
+  
+  const procedure = match[1];
+  // Handle batch queries
+  const procedures = procedure.split(",").map(p => p.trim());
+  
+  return {
+    type: "trpc",
+    procedures,
+    isBatch: procedures.length > 1,
+  };
+}
+
+/**
+ * Extract GraphQL operation from request
+ */
+function extractGraphqlOperation(url, body) {
+  // Check if it's a GraphQL endpoint
+  if (!url.includes("graphql")) return null;
+  
+  if (!body) return { type: "graphql", operationName: null };
+  
+  try {
+    const parsed = typeof body === "string" ? JSON.parse(body) : body;
+    return {
+      type: "graphql",
+      operationName: parsed.operationName || null,
+      operationType: parsed.query?.trim().startsWith("mutation") ? "mutation" : "query",
+    };
+  } catch {
+    return { type: "graphql", operationName: null };
+  }
+}
+
+// =============================================================================
+// REQUEST → CLIENT CALL MATCHING
+// =============================================================================
+
+/**
+ * Match a runtime request to client calls
+ */
+function matchRequestToClientCalls(request, clientCalls, options = {}) {
+  const { basePath = "", rewrites = [] } = options;
+  
+  const normalizedPath = normalizeRequestUrl(request.url, { basePath });
+  if (!normalizedPath) return null;
+  
+  const method = (request.method || "GET").toUpperCase();
+  
+  // Check for tRPC
+  const trpcOp = extractTrpcOperation(request.url);
+  if (trpcOp) {
+    return matchTrpcRequest(trpcOp, clientCalls, request);
+  }
+  
+  // Check for GraphQL
+  const gqlOp = extractGraphqlOperation(request.url, request.body);
+  if (gqlOp) {
+    return matchGraphqlRequest(gqlOp, clientCalls, request);
+  }
+  
+  // Standard HTTP matching
+  const candidates = [];
+  
+  for (const call of clientCalls) {
+    if (call.kind !== "http") continue;
+    
+    const score = calculateMatchScore(normalizedPath, method, call, { basePath, rewrites });
+    if (score > 0) {
+      candidates.push({ call, score });
+    }
+  }
+  
+  // Sort by score descending
+  candidates.sort((a, b) => b.score - a.score);
+  
+  if (candidates.length === 0) {
+    return {
+      matched: false,
+      request,
+      normalizedPath,
+      method,
+      candidates: [],
+    };
+  }
+  
+  return {
+    matched: true,
+    request,
+    normalizedPath,
+    method,
+    bestMatch: candidates[0].call,
+    score: candidates[0].score,
+    candidates: candidates.slice(0, 3),
+  };
+}
+
+/**
+ * Match tRPC request to client calls
+ */
+function matchTrpcRequest(trpcOp, clientCalls, request) {
+  const trpcCalls = clientCalls.filter(c => c.kind === "trpc");
+  
+  for (const call of trpcCalls) {
+    const callProcedure = call.meta?.procedure;
+    if (!callProcedure) continue;
+    
+    // Check if any procedure matches
+    for (const proc of trpcOp.procedures) {
+      if (proc === callProcedure || proc.endsWith(callProcedure)) {
+        return {
+          matched: true,
+          request,
+          matchType: "trpc",
+          procedure: proc,
+          bestMatch: call,
+          score: 1.0,
+        };
+      }
+    }
+  }
+  
+  return {
+    matched: false,
+    request,
+    matchType: "trpc",
+    procedures: trpcOp.procedures,
+  };
+}
+
+/**
+ * Match GraphQL request to client calls
+ */
+function matchGraphqlRequest(gqlOp, clientCalls, request) {
+  const gqlCalls = clientCalls.filter(c => c.kind === "graphql");
+  
+  if (gqlOp.operationName) {
+    for (const call of gqlCalls) {
+      if (call.meta?.operationName === gqlOp.operationName) {
+        return {
+          matched: true,
+          request,
+          matchType: "graphql",
+          operationName: gqlOp.operationName,
+          bestMatch: call,
+          score: 1.0,
+        };
+      }
+    }
+  }
+  
+  // Fallback: match any GraphQL call
+  if (gqlCalls.length > 0) {
+    return {
+      matched: true,
+      request,
+      matchType: "graphql",
+      operationName: gqlOp.operationName,
+      bestMatch: gqlCalls[0],
+      score: 0.5,
+    };
+  }
+  
+  return {
+    matched: false,
+    request,
+    matchType: "graphql",
+    operationName: gqlOp.operationName,
+  };
+}
+
+/**
+ * Calculate match score between request and client call
+ */
+function calculateMatchScore(requestPath, requestMethod, call, options = {}) {
+  const { basePath = "", rewrites = [] } = options;
+  
+  let callPath = call.canonicalPath;
+  if (!callPath) return 0;
+  
+  // Apply rewrites
+  for (const rewrite of rewrites) {
+    if (rewrite.source && rewrite.destination) {
+      const sourceRegex = new RegExp("^" + rewrite.source.replace(/:(\w+)/g, "([^/]+)") + "$");
+      if (sourceRegex.test(requestPath)) {
+        // Rewrite matches, adjust call path expectation
+        callPath = requestPath.replace(sourceRegex, rewrite.destination);
+        break;
+      }
+    }
+  }
+  
+  let score = 0;
+  
+  // Exact path match
+  if (requestPath === callPath) {
+    score += 1.0;
+  }
+  // Parameterized match
+  else if (callPath.includes("{") || callPath.includes(":")) {
+    const pattern = "^" + callPath
+      .replace(/\{[^}]+\}/g, "[^/]+")
+      .replace(/:(\w+)/g, "[^/]+") + "$";
+    const regex = new RegExp(pattern);
+    if (regex.test(requestPath)) {
+      score += 0.9;
+    }
+  }
+  // Prefix match (less confident)
+  else if (requestPath.startsWith(callPath) || callPath.startsWith(requestPath)) {
+    score += 0.5;
+  }
+  
+  if (score === 0) return 0;
+  
+  // Method match bonus
+  const callMethod = (call.method || "UNKNOWN").toUpperCase();
+  if (callMethod === requestMethod) {
+    score += 0.1;
+  } else if (callMethod === "UNKNOWN" || callMethod === "*") {
+    // No penalty for unknown
+  } else {
+    score -= 0.2; // Method mismatch penalty
+  }
+  
+  // Confidence bonus
+  if (call.confidence === "high") {
+    score += 0.05;
+  } else if (call.confidence === "low") {
+    score -= 0.05;
+  }
+  
+  return Math.max(0, Math.min(1, score));
+}
+
+// =============================================================================
+// BATCH MAPPING
+// =============================================================================
+
+/**
+ * Map all runtime requests to client calls
+ */
+function mapAllRequests(requests, clientCalls, options = {}) {
+  const { basePath = "", rewrites = [], includeIgnored = false } = options;
+  
+  const results = {
+    mapped: [],
+    unmapped: [],
+    ignored: [],
+    stats: {
+      total: requests.length,
+      mapped: 0,
+      unmapped: 0,
+      ignored: 0,
+      byMatchType: {},
+    },
+  };
+  
+  for (const request of requests) {
+    // Check if should ignore
+    if (shouldIgnoreRequest(request.url, request.method)) {
+      if (includeIgnored) {
+        results.ignored.push(request);
+      }
+      results.stats.ignored++;
+      continue;
+    }
+    
+    const match = matchRequestToClientCalls(request, clientCalls, { basePath, rewrites });
+    
+    if (match.matched) {
+      results.mapped.push(match);
+      results.stats.mapped++;
+      
+      const matchType = match.matchType || "http";
+      results.stats.byMatchType[matchType] = (results.stats.byMatchType[matchType] || 0) + 1;
+    } else {
+      results.unmapped.push(match);
+      results.stats.unmapped++;
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Group mapped requests by client call
+ */
+function groupRequestsByClientCall(mappedResults) {
+  const groups = new Map();
+  
+  for (const match of mappedResults) {
+    if (!match.bestMatch) continue;
+    
+    const callId = match.bestMatch.id;
+    if (!groups.has(callId)) {
+      groups.set(callId, {
+        clientCall: match.bestMatch,
+        requests: [],
+        statuses: [],
+      });
+    }
+    
+    const group = groups.get(callId);
+    group.requests.push(match.request);
+    if (match.request.status) {
+      group.statuses.push(match.request.status);
+    }
+  }
+  
+  return groups;
+}
+
+// =============================================================================
+// EXPORTS
+// =============================================================================
+
+module.exports = {
+  // Ignore patterns
+  IGNORE_PATTERNS,
+  shouldIgnoreRequest,
+  
+  // URL normalization
+  normalizeRequestUrl,
+  extractTrpcOperation,
+  extractGraphqlOperation,
+  
+  // Matching
+  matchRequestToClientCalls,
+  calculateMatchScore,
+  
+  // Batch operations
+  mapAllRequests,
+  groupRequestsByClientCall,
+};