@elench/testkit 0.1.65 → 0.1.66

package/node_modules/@elench/next-analysis/src/route-tree.mjs

@@ -1,621 +0,0 @@
-import path from "path";
-import {
-  collectExportedCallables,
-  collectImports,
-  collectJsxAttributes,
-  collectScopeLocalFunctions,
-  collectTopLevelFunctions,
-  extractJsxLabel,
-  extractLineNumber,
-  parseModule,
-  walkJsx,
-} from "./swc.mjs";
-import {
-  createDiagnostic,
-  dedupeById,
-  dedupeRefs,
-  dedupeRequests,
-  HTTP_WRAPPER_METHODS,
-  humanizeTagName,
-  normalizePath,
-  SURFACE_COMPONENT_NAMES,
-} from "./shared.mjs";
-
-export function analyzeRouteTree({ project, routeOrPageFile, diagnostics = [] }) {
-  const pageEntry = resolvePageEntry(project, routeOrPageFile);
-  if (!pageEntry) return null;
-
-  const routeTree = {
-    id: `route-tree:${pageEntry.route}`,
-    kind: "route_tree",
-    route: pageEntry.route,
-    pageFile: pageEntry.filePath,
-    rootFiles: [...pageEntry.rootFiles],
-    surfaces: [],
-    actions: [],
-    requests: [],
-    serverActionRefs: [],
-    reachableModules: [],
-    diagnostics: [],
-  };
-
-  const analyzerContext = {
-    project,
-    route: pageEntry.route,
-    pageId: pageEntry.id,
-    rootFiles: pageEntry.rootFiles,
-    routeTree,
-    diagnostics,
-    visitedExports: new Set(),
-    visitedComponentImports: new Set(),
-  };
-
-  for (const rootFile of pageEntry.rootFiles) {
-    const moduleInfo = loadModuleInfo(project, rootFile);
-    if (!moduleInfo) continue;
-    analyzeModuleExport(moduleInfo, "default", analyzerContext);
-  }
-
-  routeTree.surfaces = dedupeById(routeTree.surfaces);
-  routeTree.actions = dedupeById(routeTree.actions);
-  routeTree.requests = dedupeRequests(routeTree.requests);
-  routeTree.serverActionRefs = dedupeRefs(routeTree.serverActionRefs);
-  routeTree.reachableModules = [...new Set(routeTree.reachableModules)].sort();
-  routeTree.diagnostics = dedupeDiagnostics(routeTree.diagnostics);
-  return routeTree;
-}
-
-function resolvePageEntry(project, routeOrPageFile) {
-  const normalized = normalizePath(routeOrPageFile);
-  const pages = project.discoverPages();
-  return pages.find((page) => page.route === normalized || page.filePath === normalized) || null;
-}
-
-function loadModuleInfo(project, relativeFilePath) {
-  const existing = project.loadModule(relativeFilePath);
-  if (existing) return existing;
-  const content = project.readSourceFile(relativeFilePath);
-  if (!content) return null;
-  const ast = parseModule(content, relativeFilePath);
-  const imports = collectImports(ast, {
-    rootDir: project.rootDir,
-    filePath: relativeFilePath,
-    readSourceFile: (absolutePath) => {
-      try {
-        return project.readSourceFile(normalizePath(path.relative(project.rootDir, absolutePath)));
-      } catch {
-        return null;
-      }
-    },
-  });
-  const topLevelFunctions = collectTopLevelFunctions(ast);
-  const { exports, defaultExport } = collectExportedCallables(ast, topLevelFunctions);
-  const moduleInfo = {
-    filePath: relativeFilePath,
-    content,
-    ast,
-    imports,
-    topLevelFunctions,
-    exports,
-    defaultExport,
-  };
-  project.setModule(relativeFilePath, moduleInfo);
-  return moduleInfo;
-}
-
-function analyzeModuleExport(moduleInfo, exportName, context) {
-  if (!moduleInfo) return;
-  const visitKey = `${moduleInfo.filePath}#${exportName}`;
-  if (context.visitedExports.has(visitKey)) return;
-  context.visitedExports.add(visitKey);
-  pushReachableModule(context, moduleInfo.filePath);
-
-  const callable = resolveModuleExportCallable(moduleInfo, exportName);
-  if (!callable) {
-    pushDiagnostic(context, {
-      level: "info",
-      code: "missing-export-callable",
-      filePath: moduleInfo.filePath,
-      message: `No callable export "${exportName}" found in "${moduleInfo.filePath}".`,
-    });
-    return;
-  }
-
-  const localFunctions = new Map(moduleInfo.topLevelFunctions);
-  for (const [name, node] of collectScopeLocalFunctions(callable)) {
-    localFunctions.set(name, node);
-  }
-
-  const directAnalysis = analyzeCallableLikeNode(callable, {
-    moduleInfo,
-    localFunctions,
-    context,
-  }, new Set(), { skipNestedFunctions: true });
-
-  for (const request of directAnalysis.requests) {
-    context.routeTree.requests.push({
-      ...request,
-      ownerId: context.pageId,
-      ownerKind: "page",
-      route: context.route,
-      filePath: moduleInfo.filePath,
-    });
-  }
-  for (const ref of directAnalysis.serverActionRefs) {
-    context.routeTree.serverActionRefs.push({
-      ...ref,
-      ownerId: context.pageId,
-      ownerKind: "page",
-    });
-  }
-
-  walkJsx(callable, (element, formContext) => {
-    const descriptor = describeSurface(moduleInfo, element, formContext);
-    if (descriptor) {
-      const surfaceId = descriptor.targetHint?.value
-        ? `surface:${context.route}:${descriptor.targetHint.value}`
-        : `surface:${context.route}:${moduleInfo.filePath}:${descriptor.tagName}:${descriptor.line}`;
-      const surface = {
-        id: surfaceId,
-        kind: "ui_surface",
-        route: context.route,
-        filePath: moduleInfo.filePath,
-        label: descriptor.label,
-        line: descriptor.line,
-        surfaceKind: descriptor.surfaceKind,
-        tagName: descriptor.tagName,
-        ...(descriptor.actionBinding ? { actionId: `action:${context.route}:${descriptor.actionBinding.key}` } : {}),
-        ...(descriptor.targetHint ? { targetHint: descriptor.targetHint } : {}),
-      };
-      context.routeTree.surfaces.push(surface);
-
-      if (descriptor.actionBinding) {
-        const actionId = `action:${context.route}:${descriptor.actionBinding.key}`;
-        context.routeTree.actions.push({
-          id: actionId,
-          kind: "ui_action",
-          route: context.route,
-          filePath: moduleInfo.filePath,
-          line: descriptor.line,
-          label: descriptor.actionBinding.label,
-          bindingKind: descriptor.actionBinding.kind,
-          actionProp: descriptor.actionBinding.actionProp,
-        });
-
-        const bindingAnalysis = analyzeActionBinding(descriptor.actionBinding, {
-          moduleInfo,
-          localFunctions,
-          context,
-        });
-
-        for (const request of bindingAnalysis.requests) {
-          context.routeTree.requests.push({
-            ...request,
-            ownerId: actionId,
-            ownerKind: "action",
-            route: context.route,
-            filePath: moduleInfo.filePath,
-          });
-        }
-        for (const ref of bindingAnalysis.serverActionRefs) {
-          context.routeTree.serverActionRefs.push({
-            ...ref,
-            ownerId: actionId,
-            ownerKind: "action",
-          });
-        }
-      }
-
-      return descriptor.formContext ?? formContext;
-    }
-
-    const componentRef = resolveImportedComponentRef(element, moduleInfo.imports);
-    if (componentRef) analyzeImportedComponent(componentRef, context);
-    return formContext;
-  });
-}
-
-function describeSurface(moduleInfo, node, inheritedFormContext) {
-  const opening = node.type === "JSXElement" ? node.opening : node;
-  const tagName = opening.name?.value || null;
-  if (!SURFACE_COMPONENT_NAMES.has(tagName)) return null;
-  const attributes = collectJsxAttributes(opening);
-  const targetValue = attributes["data-testid"]?.stringValue || null;
-  const role = tagName === "form" || tagName === "Form" ? "form" : tagName === "a" || tagName === "Link" ? "link" : "button";
-  const surfaceKind =
-    role === "form" ? "form" : role === "link" ? "link" : attributes.type?.stringValue === "submit" ? "submit" : "control";
-  const ownBinding =
-    buildActionBinding(attributes.onClick?.expression, "onClick") ||
-    buildActionBinding(attributes.action?.expression, "action") ||
-    buildActionBinding(attributes.onSubmit?.expression, "onSubmit");
-  const inheritedSubmitBinding =
-    !ownBinding && isSubmitSurface(tagName, attributes) && inheritedFormContext?.actionBinding
-      ? inheritedFormContext.actionBinding
-      : null;
-  const actionBinding = ownBinding || inheritedSubmitBinding;
-
-  if (!actionBinding && !targetValue) {
-    return tagName === "form" || tagName === "Form"
-      ? { formContext: buildFormContext(attributes) }
-      : null;
-  }
-
-  const label =
-    extractJsxLabel(node, attributes) ||
-    actionBinding?.label ||
-    targetValue ||
-    humanizeTagName(tagName);
-  const line = extractLineNumber(moduleInfo.content, node);
-  return {
-    tagName,
-    surfaceKind,
-    label,
-    line,
-    targetHint: targetValue
-      ? {
-          kind: "testId",
-          value: targetValue,
-          label,
-          confidence: "high",
-        }
-      : null,
-    actionBinding,
-    formContext: buildFormContext(attributes, actionBinding),
-  };
-}
-
-function buildFormContext(attributes, explicitBinding = null) {
-  const actionBinding =
-    explicitBinding ||
-    buildActionBinding(attributes.action?.expression, "action") ||
-    buildActionBinding(attributes.onSubmit?.expression, "onSubmit");
-  return actionBinding ? { actionBinding } : null;
-}
-
-function buildActionBinding(expression, actionProp) {
-  if (!expression) return null;
-  if (expression.type === "Identifier") {
-    return {
-      kind: "identifier",
-      actionProp,
-      key: expression.value,
-      label: expression.value,
-      node: expression,
-      confidence: actionProp === "action" ? "high" : "medium",
-    };
-  }
-  if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") {
-    return {
-      kind: "inline",
-      actionProp,
-      key: `inline:${expression.span?.start || 0}`,
-      label: actionProp === "action" ? "Inline action" : "Inline handler",
-      node: expression,
-      confidence: "medium",
-    };
-  }
-  return null;
-}
-
-function analyzeActionBinding(binding, options) {
-  if (!binding) return emptyActionAnalysis();
-  if (binding.kind === "identifier" && binding.node?.type === "Identifier") {
-    const identifier = binding.node.value;
-    const imported = options.moduleInfo.imports.get(identifier);
-    if (imported?.isServerAction) {
-      return {
-        requests: [],
-        serverActionRefs: [{
-          exportKey: `${imported.resolvedFilePath}#${imported.importedName}`,
-          confidence: "high",
-        }],
-      };
-    }
-
-    if (imported?.resolvedFilePath) {
-      return analyzeImportedCallable(imported, options, new Set([imported.resolvedFilePath]));
-    }
-
-    const localFunction = options.localFunctions.get(identifier);
-    if (!localFunction) return emptyActionAnalysis();
-    return analyzeCallableLikeNode(localFunction, options, new Set([identifier]));
-  }
-
-  if (binding.kind === "inline") {
-    return analyzeCallableLikeNode(binding.node, options, new Set());
-  }
-
-  return emptyActionAnalysis();
-}
-
-function analyzeImportedCallable(imported, options, visited) {
-  if (!imported?.resolvedFilePath || imported.isServerAction || visited.has(imported.resolvedFilePath)) {
-    return emptyActionAnalysis();
-  }
-  const moduleInfo = loadModuleInfo(options.context.project, imported.resolvedFilePath);
-  if (!moduleInfo) return emptyActionAnalysis();
-  pushReachableModule(options.context, imported.resolvedFilePath);
-  const callable = resolveModuleExportCallable(moduleInfo, imported.importedName);
-  if (!callable) return emptyActionAnalysis();
-
-  const localFunctions = new Map(moduleInfo.topLevelFunctions);
-  for (const [name, node] of collectScopeLocalFunctions(callable)) {
-    localFunctions.set(name, node);
-  }
-
-  const nextVisited = new Set(visited);
-  nextVisited.add(imported.resolvedFilePath);
-  return analyzeCallableLikeNode(callable, {
-    moduleInfo,
-    localFunctions,
-    context: options.context,
-  }, nextVisited);
-}
-
-function analyzeCallableLikeNode(node, options, visited = new Set(), settings = {}) {
-  const requests = [];
-  const serverActionRefs = [];
-
-  walkCallableNode(node, (child) => {
-    if (
-      settings.skipNestedFunctions &&
-      child !== node &&
-      (child.type === "ArrowFunctionExpression" || child.type === "FunctionExpression" || child.type === "FunctionDeclaration")
-    ) {
-      return "skip";
-    }
-
-    if (child.type === "CallExpression") {
-      const request = resolveHttpRequestCall(child);
-      if (request) {
-        requests.push(request);
-        return;
-      }
-
-      const serverAction = resolveServerActionCall(child, options.moduleInfo.imports);
-      if (serverAction) {
-        serverActionRefs.push(serverAction);
-        return;
-      }
-
-      const localCall = resolveLocalFunctionCall(child, options, visited);
-      if (localCall) {
-        requests.push(...localCall.requests);
-        serverActionRefs.push(...localCall.serverActionRefs);
-        return;
-      }
-
-      const importedCall = resolveImportedLocalCall(child, options, visited);
-      if (importedCall) {
-        requests.push(...importedCall.requests);
-        serverActionRefs.push(...importedCall.serverActionRefs);
-        return;
-      }
-
-      for (const callbackAnalysis of resolveExecutedCallbackAnalyses(child, options, visited)) {
-        requests.push(...callbackAnalysis.requests);
-        serverActionRefs.push(...callbackAnalysis.serverActionRefs);
-      }
-    }
-  });
-
-  return {
-    requests: dedupeRequests(requests),
-    serverActionRefs: dedupeRefs(serverActionRefs),
-  };
-}
-
-function resolveLocalFunctionCall(callExpression, options, visited) {
-  const callee = callExpression.callee;
-  if (callee?.type !== "Identifier") return null;
-  const functionName = callee.value;
-  const localFunction = options.localFunctions.get(functionName);
-  if (!localFunction || visited.has(functionName)) return null;
-  const nextVisited = new Set(visited);
-  nextVisited.add(functionName);
-  return analyzeCallableLikeNode(localFunction, options, nextVisited);
-}
-
-function resolveImportedLocalCall(callExpression, options, visited) {
-  const callee = callExpression.callee;
-  if (callee?.type !== "Identifier") return null;
-  const imported = options.moduleInfo.imports.get(callee.value);
-  if (!imported?.resolvedFilePath || imported.isServerAction) return null;
-  return analyzeImportedCallable(imported, options, visited);
-}
-
-function resolveExecutedCallbackAnalyses(callExpression, options, visited) {
-  const callbacks = [];
-  const callee = callExpression.callee;
-  if (callee?.type === "Identifier" && (callee.value === "useEffect" || callee.value === "useLayoutEffect")) {
-    const callbackArg = callExpression.arguments?.[0]?.expression;
-    if (callbackArg && (callbackArg.type === "ArrowFunctionExpression" || callbackArg.type === "FunctionExpression")) {
-      callbacks.push(analyzeCallableLikeNode(callbackArg, options, new Set(visited)));
-    }
-  }
-  return callbacks;
-}
-
-function resolveServerActionCall(callExpression, imports) {
-  const callee = callExpression.callee;
-  if (callee?.type !== "Identifier") return null;
-  const imported = imports.get(callee.value);
-  if (!imported?.isServerAction) return null;
-  return {
-    exportKey: `${imported.resolvedFilePath}#${imported.importedName}`,
-    confidence: "high",
-  };
-}
-
-function resolveHttpRequestCall(callExpression) {
-  const callee = callExpression.callee;
-  if (callee?.type === "Identifier") {
-    if (callee.value === "fetch") {
-      const path = extractRequestPath(callExpression.arguments?.[0]?.expression);
-      if (!path || !path.startsWith("/api/")) return null;
-      const method = extractFetchMethod(callExpression.arguments?.[1]?.expression) || "GET";
-      return {
-        id: `request:${callee.span?.start || 0}:${method}:${path}`,
-        method,
-        path,
-        confidence: "high",
-      };
-    }
-
-    if (callee.value === "rawReq") {
-      const methodLiteral = extractStringLiteral(callExpression.arguments?.[0]?.expression);
-      const path = extractRequestPath(callExpression.arguments?.[1]?.expression);
-      if (!methodLiteral || !path) return null;
-      return {
-        id: `request:${callee.span?.start || 0}:${methodLiteral.toUpperCase()}:${path}`,
-        method: methodLiteral.toUpperCase(),
-        path,
-        confidence: "high",
-      };
-    }
-
-    const wrapperMethod = HTTP_WRAPPER_METHODS[callee.value];
-    if (wrapperMethod) {
-      const path = extractRequestPath(callExpression.arguments?.[0]?.expression);
-      if (!path || !path.startsWith("/api/")) return null;
-      return {
-        id: `request:${callee.span?.start || 0}:${wrapperMethod}:${path}`,
-        method: wrapperMethod,
-        path,
-        confidence: "high",
-      };
-    }
-  }
-
-  if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && callee.property.value === "rawReq") {
-    const methodLiteral = extractStringLiteral(callExpression.arguments?.[0]?.expression);
-    const path = extractRequestPath(callExpression.arguments?.[1]?.expression);
-    if (!methodLiteral || !path) return null;
-    return {
-      id: `request:${callee.span?.start || 0}:${methodLiteral.toUpperCase()}:${path}`,
-      method: methodLiteral.toUpperCase(),
-      path,
-      confidence: "high",
-    };
-  }
-
-  return null;
-}
-
-function resolveImportedComponentRef(node, imports) {
-  const opening = node.type === "JSXElement" ? node.opening : node;
-  const tagName = opening.name?.value || null;
-  if (!tagName || !/^[A-Z]/u.test(tagName)) return null;
-  const imported = imports.get(tagName);
-  if (!imported?.resolvedFilePath || imported.isServerAction) return null;
-  if (imported.resolvedFilePath.includes("/components/ui/")) return null;
-  return {
-    filePath: imported.resolvedFilePath,
-    exportName: imported.importedName,
-  };
-}
-
-function analyzeImportedComponent(componentRef, context) {
-  const key = `${componentRef.filePath}#${componentRef.exportName}`;
-  if (context.visitedComponentImports.has(key)) return;
-  context.visitedComponentImports.add(key);
-  const moduleInfo = loadModuleInfo(context.project, componentRef.filePath);
-  if (!moduleInfo) return;
-  analyzeModuleExport(moduleInfo, componentRef.exportName, context);
-}
-
-function resolveModuleExportCallable(moduleInfo, exportName) {
-  if (exportName === "default") return moduleInfo.defaultExport || null;
-  const direct = moduleInfo.exports.get(exportName);
-  if (direct?.type === "Identifier") {
-    return moduleInfo.topLevelFunctions.get(direct.value) || null;
-  }
-  return direct || null;
-}
-
-function pushReachableModule(context, filePath) {
-  context.routeTree.reachableModules.push(filePath);
-}
-
-function pushDiagnostic(context, diagnostic) {
-  const entry = createDiagnostic(diagnostic);
-  context.routeTree.diagnostics.push(entry);
-  context.diagnostics.push(entry);
-}
-
-function dedupeDiagnostics(entries) {
-  const seen = new Set();
-  return entries.filter((entry) => {
-    const key = `${entry.code}:${entry.filePath || ""}:${entry.line || ""}:${entry.message}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-function walkCallableNode(node, visitor) {
-  const visit = (current) => {
-    const action = visitor(current);
-    if (action === "skip") return;
-    for (const value of Object.values(current || {})) {
-      if (!value) continue;
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item && typeof item === "object" && item.type) visit(item);
-        }
-      } else if (value && typeof value === "object" && value.type) {
-        visit(value);
-      }
-    }
-  };
-
-  if (node?.body?.type === "BlockStatement") {
-    visit(node.body);
-  } else if (node?.type) {
-    visit(node);
-  }
-}
-
-function extractStringLiteral(node) {
-  if (!node) return null;
-  if (node.type === "StringLiteral") return node.value;
-  if (node.type === "TemplateLiteral") {
-    let value = node.quasis?.[0]?.raw || "";
-    for (let index = 0; index < (node.expressions || []).length; index += 1) {
-      value += "[id]";
-      value += node.quasis?.[index + 1]?.raw || "";
-    }
-    return value;
-  }
-  return null;
-}
-
-function extractRequestPath(node) {
-  const literal = extractStringLiteral(node);
-  if (!literal) return null;
-  return literal.split("?")[0];
-}
-
-function extractFetchMethod(node) {
-  if (!node || node.type !== "ObjectExpression") return null;
-  for (const property of node.properties || []) {
-    if (property.type !== "KeyValueProperty") continue;
-    const key = property.key?.value || property.key?.name?.value || property.key?.name;
-    if (key !== "method") continue;
-    const value = extractStringLiteral(property.value);
-    return value ? value.toUpperCase() : null;
-  }
-  return null;
-}
-
-function isSubmitSurface(tagName, attributes) {
-  const type = attributes.type?.stringValue || "";
-  return tagName === "button" || tagName === "Button" || (tagName === "input" && type === "submit");
-}
-
-function emptyActionAnalysis() {
-  return {
-    requests: [],
-    serverActionRefs: [],
-  };
-}

package/node_modules/@elench/next-analysis/src/routes.mjs

@@ -1,41 +0,0 @@
-import path from "path";
-import { normalizePath, normalizeRouteSegments } from "./shared.mjs";
-
-export function routeFromAppFile(appRoot, filePath) {
-  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(appRoot, filePath);
-  const relative = normalizePath(path.relative(appRoot, absolutePath));
-  const segments = relative.split("/");
-  segments.pop();
-  return normalizeRouteSegments(segments);
-}
-
-export function routeFromApiFile(appRoot, filePath) {
-  const appRelative = normalizePath(path.relative(appRoot, path.dirname(filePath)));
-  const segments = appRelative.split("/").filter(Boolean);
-  if (segments[0] === "api") segments.shift();
-  return normalizeRouteSegments(segments);
-}
-
-export function requestPathPatternFromLiteral(literal) {
-  const normalized = String(literal || "").trim();
-  if (!normalized) return null;
-  const withoutQuery = normalized.split("?")[0];
-  const withDynamicSegments = withoutQuery
-    .replace(/\$\{[^}]+\}/gu, "[id]")
-    .replace(/__TESTKIT_DYNAMIC_SEGMENT__/gu, "[id]");
-  return withDynamicSegments.startsWith("/") ? withDynamicSegments : `/${withDynamicSegments}`;
-}
-
-export function routePatternMatches(routePattern, candidatePath) {
-  const routeSegments = normalizePath(routePattern).split("/").filter(Boolean);
-  const candidateSegments = normalizePath(candidatePath).split("/").filter(Boolean);
-  if (routeSegments.length !== candidateSegments.length) return false;
-  return routeSegments.every((segment, index) => {
-    if (segment.startsWith("[") && segment.endsWith("]")) return true;
-    return segment === candidateSegments[index];
-  });
-}
-
-export function normalizeRequestPathFromRoute(route) {
-  return route === "/" ? "/api" : `/api${route}`;
-}

package/node_modules/@elench/next-analysis/src/routes.test.mjs

@@ -1,25 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  requestPathPatternFromLiteral,
-  routeFromApiFile,
-  routeFromAppFile,
-  routePatternMatches,
-} from "./index.mjs";
-
-describe("@elench/next-analysis route helpers", () => {
-  it("derives app and API routes from App Router files", () => {
-    const appRoot = "/repo/src/app";
-    expect(routeFromAppFile(appRoot, "/repo/src/app/(dashboard)/projects/page.tsx")).toBe("/projects");
-    expect(routeFromApiFile(appRoot, "/repo/src/app/api/projects/[projectId]/events/route.ts")).toBe("/projects/[projectId]/events");
-  });
-
-  it("normalizes dynamic request literals into route patterns", () => {
-    expect(requestPathPatternFromLiteral("/api/projects/${projectId}/events?limit=100")).toBe("/api/projects/[id]/events");
-    expect(requestPathPatternFromLiteral("/api/projects/__TESTKIT_DYNAMIC_SEGMENT__/overview")).toBe("/api/projects/[id]/overview");
-  });
-
-  it("matches dynamic route patterns against concrete paths", () => {
-    expect(routePatternMatches("/api/projects/[projectId]/events", "/api/projects/123/events")).toBe(true);
-    expect(routePatternMatches("/api/projects/[projectId]/events", "/api/projects/123/stats")).toBe(false);
-  });
-});