@elench/testkit 0.1.64 → 0.1.66

package/node_modules/@elench/testkit-protocol/src/index.mjs

@@ -1,265 +0,0 @@
-export const TESTKIT_BROWSER_PROTOCOL_VERSION = 1;
-export const TESTKIT_COVERAGE_GRAPH_VERSION = 1;
-
-const TARGET_KINDS = new Set(["testId", "role", "text", "css", "xpath", "component"]);
-const CONFIDENCE_LEVELS = new Set(["low", "medium", "high"]);
-const FAILURE_STATES = new Set(["failing", "healthy", "unavailable"]);
-const COVERAGE_STATES = new Set(["covered", "missing", "unavailable"]);
-const NODE_KINDS = new Set([
-  "page_view",
-  "ui_surface",
-  "ui_action",
-  "client_request",
-  "api_route",
-  "server_action",
-  "server_capability",
-  "data_capability",
-  "test_file",
-]);
-const EDGE_KINDS = new Set([
-  "contains",
-  "renders",
-  "triggers",
-  "requests",
-  "handles",
-  "delegates_to",
-  "covers",
-]);
-const EVIDENCE_SOURCES = new Set(["convention", "static", "runtime"]);
-
-export function normalizeBrowserTarget(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const kind = normalizeOptionalString(value.kind);
-  const targetValue = normalizeOptionalString(value.value);
-  if (!kind || !TARGET_KINDS.has(kind) || !targetValue) return null;
-  const label = normalizeOptionalString(value.label);
-  const confidence = normalizeOptionalString(value.confidence);
-  return {
-    kind,
-    value: targetValue,
-    ...(label ? { label } : {}),
-    ...(confidence && CONFIDENCE_LEVELS.has(confidence) ? { confidence } : {}),
-  };
-}
-
-export function normalizeBrowserMetadata(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const label = normalizeOptionalString(value.label);
-  const origins = normalizeStringArray(value.origins);
-  const routes = normalizeStringArray(value.routes);
-  const targets = Array.isArray(value.targets) ? value.targets.map(normalizeBrowserTarget).filter(Boolean) : [];
-  if (!label && origins.length === 0 && routes.length === 0 && targets.length === 0) {
-    return null;
-  }
-  return {
-    ...(label ? { label } : {}),
-    ...(origins.length > 0 ? { origins } : {}),
-    ...(routes.length > 0 ? { routes } : {}),
-    ...(targets.length > 0 ? { targets } : {}),
-  };
-}
-
-export function normalizeBrowserMetadataDocument(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const schemaVersion =
-    Number.isInteger(value.schemaVersion) && value.schemaVersion > 0
-      ? value.schemaVersion
-      : TESTKIT_BROWSER_PROTOCOL_VERSION;
-  const browser = normalizeBrowserMetadata(value.browser);
-  if (!browser) return null;
-  return {
-    schemaVersion,
-    browser,
-  };
-}
-
-export function normalizeCoverageGraphNode(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const id = normalizeOptionalString(value.id);
-  const kind = normalizeOptionalString(value.kind);
-  const service = normalizeOptionalString(value.service);
-  const label = normalizeOptionalString(value.label);
-  if (!id || !kind || !NODE_KINDS.has(kind) || !service || !label) return null;
-  const filePath = normalizeOptionalString(value.filePath);
-  const route = normalizeOptionalString(value.route);
-  const method = normalizeOptionalString(value.method);
-  const path = normalizeOptionalString(value.path);
-  const target = normalizeBrowserTarget(value.target);
-  const metadata = normalizeMetadataRecord(value.metadata);
-  return {
-    id,
-    kind,
-    service,
-    label,
-    ...(filePath ? { filePath } : {}),
-    ...(route ? { route } : {}),
-    ...(method ? { method } : {}),
-    ...(path ? { path } : {}),
-    ...(target ? { target } : {}),
-    ...(metadata ? { metadata } : {}),
-  };
-}
-
-export function normalizeCoverageGraphEdge(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const id = normalizeOptionalString(value.id);
-  const kind = normalizeOptionalString(value.kind);
-  const from = normalizeOptionalString(value.from);
-  const to = normalizeOptionalString(value.to);
-  if (!id || !kind || !EDGE_KINDS.has(kind) || !from || !to) return null;
-  const confidence = normalizeOptionalString(value.confidence);
-  const metadata = normalizeMetadataRecord(value.metadata);
-  return {
-    id,
-    kind,
-    from,
-    to,
-    ...(confidence && CONFIDENCE_LEVELS.has(confidence) ? { confidence } : {}),
-    ...(metadata ? { metadata } : {}),
-  };
-}
-
-export function normalizeCoverageEvidence(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const id = normalizeOptionalString(value.id);
-  const source = normalizeOptionalString(value.source);
-  const service = normalizeOptionalString(value.service);
-  const suiteName = normalizeOptionalString(value.suiteName);
-  const selectionType = normalizeOptionalString(value.selectionType);
-  const framework = normalizeOptionalString(value.framework);
-  const testFilePath = normalizeOptionalString(value.testFilePath);
-  const coveredNodeIds = normalizeStringArray(value.coveredNodeIds);
-  if (
-    !id ||
-    !source ||
-    !EVIDENCE_SOURCES.has(source) ||
-    !service ||
-    !suiteName ||
-    !selectionType ||
-    !framework ||
-    !testFilePath ||
-    coveredNodeIds.length === 0
-  ) {
-    return null;
-  }
-  const confidence = normalizeOptionalString(value.confidence);
-  const details = normalizeEvidenceDetails(value.details);
-  return {
-    id,
-    source,
-    service,
-    suiteName,
-    selectionType,
-    framework,
-    testFilePath,
-    coveredNodeIds,
-    ...(confidence && CONFIDENCE_LEVELS.has(confidence) ? { confidence } : {}),
-    ...(details ? { details } : {}),
-  };
-}
-
-const DIAGNOSTIC_LEVELS = new Set(["info", "warn"]);
-
-export function normalizeCoverageGraphDiagnostic(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const level = normalizeOptionalString(value.level);
-  const code = normalizeOptionalString(value.code);
-  const filePath = normalizeOptionalString(value.filePath);
-  const service = normalizeOptionalString(value.service);
-  const message = normalizeOptionalString(value.message);
-  if (!level || !code || !filePath || !service || !message) return null;
-  if (!DIAGNOSTIC_LEVELS.has(level)) return null;
-  return { level, code, filePath, service, message };
-}
-
-export function normalizeCoverageGraph(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const schemaVersion =
-    Number.isInteger(value.schemaVersion) && value.schemaVersion > 0
-      ? value.schemaVersion
-      : TESTKIT_COVERAGE_GRAPH_VERSION;
-  const nodes = Array.isArray(value.nodes) ? value.nodes.map(normalizeCoverageGraphNode).filter(Boolean) : [];
-  const edges = Array.isArray(value.edges) ? value.edges.map(normalizeCoverageGraphEdge).filter(Boolean) : [];
-  const evidence = Array.isArray(value.evidence)
-    ? value.evidence.map(normalizeCoverageEvidence).filter(Boolean)
-    : [];
-  const diagnostics = Array.isArray(value.diagnostics)
-    ? value.diagnostics.map(normalizeCoverageGraphDiagnostic).filter(Boolean)
-    : [];
-  if (nodes.length === 0) return null;
-  return {
-    schemaVersion,
-    nodes,
-    edges,
-    evidence,
-    diagnostics,
-  };
-}
-
-export function isPageOverlayResponse(value) {
-  return Boolean(normalizePageOverlayResponse(value));
-}
-
-export function normalizePageOverlayResponse(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  if (value.protocolVersion !== TESTKIT_BROWSER_PROTOCOL_VERSION) return null;
-  if (!value.page || typeof value.page !== "object") return null;
-  if (!value.match || typeof value.match !== "object") return null;
-  if (!value.summary || typeof value.summary !== "object") return null;
-  if (!Array.isArray(value.coverage) || !Array.isArray(value.failures)) return null;
-  if (!FAILURE_STATES.has(value.summary.failureState)) return null;
-  if (!COVERAGE_STATES.has(value.summary.coverageState)) return null;
-  return value;
-}
-
-export function createBridgeErrorResponse(code, message) {
-  return {
-    protocolVersion: TESTKIT_BROWSER_PROTOCOL_VERSION,
-    error: {
-      code,
-      message,
-    },
-  };
-}
-
-function normalizeEvidenceDetails(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const requestPaths = normalizeStringArray(value.requestPaths);
-  const route = normalizeOptionalString(value.route);
-  const targets = Array.isArray(value.targets) ? value.targets.map(normalizeBrowserTarget).filter(Boolean) : [];
-  if (requestPaths.length === 0 && !route && targets.length === 0) return null;
-  return {
-    ...(requestPaths.length > 0 ? { requestPaths } : {}),
-    ...(route ? { route } : {}),
-    ...(targets.length > 0 ? { targets } : {}),
-  };
-}
-
-function normalizeMetadataRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const normalized = {};
-  for (const [key, entry] of Object.entries(value)) {
-    const normalizedKey = normalizeOptionalString(key);
-    if (!normalizedKey) continue;
-    if (
-      entry === null ||
-      typeof entry === "string" ||
-      typeof entry === "number" ||
-      typeof entry === "boolean"
-    ) {
-      normalized[normalizedKey] = entry;
-    }
-  }
-  return Object.keys(normalized).length > 0 ? normalized : null;
-}
-
-function normalizeStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return value.map(normalizeOptionalString).filter(Boolean);
-}
-
-function normalizeOptionalString(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}

package/node_modules/@elench/testkit-protocol/src/index.test.mjs

@@ -1,242 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  TESTKIT_BROWSER_PROTOCOL_VERSION,
-  TESTKIT_COVERAGE_GRAPH_VERSION,
-  isPageOverlayResponse,
-  normalizeBrowserTarget,
-  normalizeCoverageEvidence,
-  normalizeCoverageGraph,
-  normalizeCoverageGraphDiagnostic,
-  normalizeCoverageGraphEdge,
-  normalizeCoverageGraphNode,
-} from "./index.mjs";
-
-describe("testkit browser protocol", () => {
-  it("normalizes browser targets", () => {
-    expect(
-      normalizeBrowserTarget({
-        kind: "testId",
-        value: "coverage-refresh-button",
-        confidence: "high",
-      })
-    ).toEqual({
-      kind: "testId",
-      value: "coverage-refresh-button",
-      confidence: "high",
-    });
-  });
-
-  it("normalizes coverage graph nodes and edges", () => {
-    expect(
-      normalizeCoverageGraphNode({
-        id: "page_view:web:/coverage",
-        kind: "page_view",
-        service: "web",
-        label: "Coverage",
-        route: "/coverage",
-      })
-    ).toEqual({
-      id: "page_view:web:/coverage",
-      kind: "page_view",
-      service: "web",
-      label: "Coverage",
-      route: "/coverage",
-    });
-
-    expect(
-      normalizeCoverageGraphEdge({
-        id: "edge-1",
-        kind: "requests",
-        from: "page_view:web:/coverage",
-        to: "client_request:web:/api/coverage",
-        confidence: "high",
-      })
-    ).toEqual({
-      id: "edge-1",
-      kind: "requests",
-      from: "page_view:web:/coverage",
-      to: "client_request:web:/api/coverage",
-      confidence: "high",
-    });
-  });
-
-  it("normalizes positive coverage evidence", () => {
-    expect(
-      normalizeCoverageEvidence({
-        id: "evidence-1",
-        source: "convention",
-        confidence: "high",
-        service: "web",
-        suiteName: "coverage",
-        selectionType: "pw",
-        framework: "playwright",
-        testFilePath: "app/__testkit__/coverage/home.pw.testkit.ts",
-        coveredNodeIds: ["page_view:web:/coverage"],
-        details: {
-          route: "/coverage",
-          requestPaths: ["/api/coverage"],
-          targets: [
-            {
-              kind: "testId",
-              value: "coverage-refresh-button",
-              confidence: "high",
-            },
-          ],
-        },
-      })
-    ).toEqual({
-      id: "evidence-1",
-      source: "convention",
-      confidence: "high",
-      service: "web",
-      suiteName: "coverage",
-      selectionType: "pw",
-      framework: "playwright",
-      testFilePath: "app/__testkit__/coverage/home.pw.testkit.ts",
-      coveredNodeIds: ["page_view:web:/coverage"],
-      details: {
-        route: "/coverage",
-        requestPaths: ["/api/coverage"],
-        targets: [
-          {
-            kind: "testId",
-            value: "coverage-refresh-button",
-            confidence: "high",
-          },
-        ],
-      },
-    });
-  });
-
-  it("normalizes coverage graph diagnostics", () => {
-    expect(
-      normalizeCoverageGraphDiagnostic({
-        level: "warn",
-        code: "no-service-context",
-        filePath: "tests/example.int.testkit.ts",
-        service: "web",
-        message: 'No coverage context available for service "web".',
-      })
-    ).toEqual({
-      level: "warn",
-      code: "no-service-context",
-      filePath: "tests/example.int.testkit.ts",
-      service: "web",
-      message: 'No coverage context available for service "web".',
-    });
-
-    expect(normalizeCoverageGraphDiagnostic({ level: "error", code: "x", filePath: "f", service: "s", message: "m" })).toBeNull();
-    expect(normalizeCoverageGraphDiagnostic({ level: "warn", code: "", filePath: "f", service: "s", message: "m" })).toBeNull();
-    expect(normalizeCoverageGraphDiagnostic(null)).toBeNull();
-  });
-
-  it("normalizes graph payloads with diagnostics", () => {
-    expect(
-      normalizeCoverageGraph({
-        schemaVersion: TESTKIT_COVERAGE_GRAPH_VERSION,
-        nodes: [
-          {
-            id: "page_view:web:/coverage",
-            kind: "page_view",
-            service: "web",
-            label: "Coverage",
-            route: "/coverage",
-          },
-        ],
-        edges: [],
-        evidence: [],
-        diagnostics: [
-          {
-            level: "info",
-            code: "zero-coverage-inferred",
-            filePath: "tests/example.pw.testkit.ts",
-            service: "web",
-            message: "No routes matched.",
-          },
-        ],
-      })
-    ).toEqual({
-      schemaVersion: TESTKIT_COVERAGE_GRAPH_VERSION,
-      nodes: [
-        {
-          id: "page_view:web:/coverage",
-          kind: "page_view",
-          service: "web",
-          label: "Coverage",
-          route: "/coverage",
-        },
-      ],
-      edges: [],
-      evidence: [],
-      diagnostics: [
-        {
-          level: "info",
-          code: "zero-coverage-inferred",
-          filePath: "tests/example.pw.testkit.ts",
-          service: "web",
-          message: "No routes matched.",
-        },
-      ],
-    });
-  });
-
-  it("normalizes graph payloads without diagnostics field", () => {
-    expect(
-      normalizeCoverageGraph({
-        schemaVersion: TESTKIT_COVERAGE_GRAPH_VERSION,
-        nodes: [
-          {
-            id: "page_view:web:/coverage",
-            kind: "page_view",
-            service: "web",
-            label: "Coverage",
-            route: "/coverage",
-          },
-        ],
-        edges: [],
-        evidence: [],
-      })
-    ).toEqual({
-      schemaVersion: TESTKIT_COVERAGE_GRAPH_VERSION,
-      nodes: [
-        {
-          id: "page_view:web:/coverage",
-          kind: "page_view",
-          service: "web",
-          label: "Coverage",
-          route: "/coverage",
-        },
-      ],
-      edges: [],
-      evidence: [],
-      diagnostics: [],
-    });
-  });
-
-  it("recognizes valid page overlay responses", () => {
-    expect(
-      isPageOverlayResponse({
-        protocolVersion: TESTKIT_BROWSER_PROTOCOL_VERSION,
-        page: { url: "http://localhost:3000/coverage", origin: "http://localhost:3000", route: "/coverage" },
-        match: {
-          protocolVersion: TESTKIT_BROWSER_PROTOCOL_VERSION,
-          url: "http://localhost:3000/coverage",
-          origin: "http://localhost:3000",
-          route: "/coverage",
-          matched: true,
-          product: { name: "web", directory: "/tmp/web" },
-          service: { name: "web", baseUrl: "http://localhost:3000", origin: "http://localhost:3000" },
-        },
-        run: { artifactAvailable: true, generatedAt: null, status: "failed" },
-        summary: {
-          failureState: "failing",
-          coverageState: "covered",
-          relatedFailureCount: 1,
-          relatedCoverageCount: 1,
-        },
-        failures: [],
-        coverage: [],
-      })
-    ).toBe(true);
-  });
-});

package/node_modules/@elench/ts-analysis/src/callables.mjs

@@ -1,135 +0,0 @@
-import ts from "typescript";
-import { extractStringLiteral } from "./syntax.mjs";
-
-export function collectImports(sourceFile, options) {
-  const imports = new Map();
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
-    const specifier = extractStringLiteral(statement.moduleSpecifier);
-    if (!specifier) continue;
-    const resolvedFilePath = options.resolveImportPath(specifier);
-    const sourceContent = resolvedFilePath ? options.readSourceFile(resolvedFilePath) : null;
-    const serverActionImport = Boolean(sourceContent && options.isServerActionFile(sourceContent));
-
-    if (statement.importClause.name) {
-      imports.set(statement.importClause.name.text, {
-        importedName: "default",
-        specifier,
-        resolvedFilePath,
-        isServerAction: serverActionImport,
-      });
-    }
-
-    const bindings = statement.importClause.namedBindings;
-    if (!bindings || !ts.isNamedImports(bindings)) continue;
-    for (const element of bindings.elements) {
-      const localName = element.name.text;
-      const importedName = element.propertyName?.text || localName;
-      imports.set(localName, {
-        importedName,
-        specifier,
-        resolvedFilePath,
-        isServerAction: serverActionImport,
-      });
-    }
-  }
-  return imports;
-}
-
-export function collectTopLevelFunctions(sourceFile) {
-  const functions = new Map();
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement) && statement.name) {
-      functions.set(statement.name.text, statement);
-      continue;
-    }
-
-    if (!ts.isVariableStatement(statement)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-      if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
-        functions.set(declaration.name.text, declaration.initializer);
-      }
-    }
-  }
-  return functions;
-}
-
-export function collectExportedCallables(sourceFile, topLevelFunctions) {
-  const exports = new Map();
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement) && statement.name && hasExportModifier(statement.modifiers)) {
-      exports.set(statement.name.text, statement);
-      continue;
-    }
-
-    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement.modifiers)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-      if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
-        exports.set(declaration.name.text, declaration.initializer);
-      } else if (ts.isIdentifier(declaration.initializer)) {
-        const referenced = topLevelFunctions.get(declaration.initializer.text);
-        if (referenced) exports.set(declaration.name.text, referenced);
-      }
-    }
-  }
-  return exports;
-}
-
-export function collectScopeLocalFunctions(node) {
-  const functions = new Map();
-  const callableBody = "body" in node ? node.body : null;
-  if (!callableBody) return functions;
-
-  const visit = (child) => {
-    if (ts.isFunctionDeclaration(child) && child.name) {
-      functions.set(child.name.text, child);
-      if (child !== callableBody) return;
-    }
-
-    if (
-      child !== callableBody &&
-      (ts.isArrowFunction(child) || ts.isFunctionExpression(child))
-    ) {
-      return;
-    }
-
-    if (ts.isVariableDeclaration(child) && ts.isIdentifier(child.name) && child.initializer) {
-      if (ts.isArrowFunction(child.initializer) || ts.isFunctionExpression(child.initializer)) {
-        functions.set(child.name.text, child.initializer);
-      }
-    }
-
-    ts.forEachChild(child, visit);
-  };
-
-  visit(callableBody);
-  return functions;
-}
-
-export function findDefaultExportCallable(sourceFile, localFunctions) {
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement) && hasDefaultModifier(statement.modifiers)) {
-      return statement;
-    }
-
-    if (ts.isExportAssignment(statement)) {
-      if (ts.isIdentifier(statement.expression)) {
-        return localFunctions.get(statement.expression.text) || null;
-      }
-      if (ts.isArrowFunction(statement.expression) || ts.isFunctionExpression(statement.expression)) {
-        return statement.expression;
-      }
-    }
-  }
-  return null;
-}
-
-function hasExportModifier(modifiers) {
-  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
-}
-
-function hasDefaultModifier(modifiers) {
-  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword));
-}

package/node_modules/@elench/ts-analysis/src/callables.test.mjs

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  collectExportedCallables,
-  collectImports,
-  collectScopeLocalFunctions,
-  collectTopLevelFunctions,
-  createSourceFile,
-  findDefaultExportCallable,
-} from "./index.mjs";
-
-describe("@elench/ts-analysis callables", () => {
-  it("collects top-level, exported, and scope-local callables", () => {
-    const content = `
-      import { saveSettings as save } from "./actions";
-
-      function helper() {}
-      const localArrow = () => {};
-
-      export function namedExport() {}
-      export const exportedArrow = () => {};
-
-      export default function Page() {
-        function nestedDecl() {}
-        const nestedArrow = () => {};
-        return <button onClick={nestedArrow}>Save</button>;
-      }
-    `;
-    const sourceFile = createSourceFile("page.tsx", content);
-    const topLevel = collectTopLevelFunctions(sourceFile);
-    const exported = collectExportedCallables(sourceFile, topLevel);
-    const defaultExport = findDefaultExportCallable(sourceFile, topLevel);
-    const locals = collectScopeLocalFunctions(defaultExport);
-
-    expect([...topLevel.keys()]).toEqual(["helper", "localArrow", "namedExport", "exportedArrow", "Page"]);
-    expect([...exported.keys()]).toEqual(["namedExport", "exportedArrow", "Page"]);
-    expect([...locals.keys()]).toEqual(["nestedDecl", "nestedArrow"]);
-  });
-
-  it("collects imports with server action metadata", () => {
-    const sourceFile = createSourceFile(
-      "page.tsx",
-      `import action, { saveSettings as save } from "./actions"; import { Button } from "@/components/ui/button";`
-    );
-    const imports = collectImports(sourceFile, {
-      readSourceFile: (filePath) => (filePath === "src/app/actions.ts" ? '"use server";\nexport async function saveSettings() {}' : "export const Button = () => null;"),
-      resolveImportPath: (specifier) =>
-        specifier === "./actions" ? "src/app/actions.ts" : specifier === "@/components/ui/button" ? "src/components/ui/button.tsx" : null,
-      isServerActionFile: (content) => content.includes('"use server"'),
-    });
-
-    expect(imports.get("action")).toMatchObject({ importedName: "default", isServerAction: true });
-    expect(imports.get("save")).toMatchObject({ importedName: "saveSettings", isServerAction: true });
-    expect(imports.get("Button")).toMatchObject({ importedName: "Button", isServerAction: false });
-  });
-});