@glubean/scanner 0.4.0 → 0.5.1

package/dist/extractor-static.js

@@ -1,23 +1,15 @@
 /**
- * Static analysis extractor for Glubean test files.
- *
- * Uses regex patterns to extract test metadata WITHOUT importing files.
- * This is useful for:
- * - Build systems that scan code without execution
- * - CI/CD pipelines
- * - IDE extensions (VSCode)
- *
- * Note: Static analysis may miss dynamically computed metadata.
- *
- * **Limitations:**
- * - Template variables (`$id`, `$_pick`) in IDs are preserved as-is, not resolved.
- * - Dynamically computed IDs or tags are not detected.
- * - `test.each()` / `test.pick()` produce one ExportMeta with the template ID,
- *   not one per data row (row count is unknown statically).
- * - Deeply nested or multi-line object literals with complex expressions may
- *   not be fully parsed.
+ * Static guards + shared static-metadata types for Glubean scanning.
+ *
+ * The test/contract/pick EXTRACTORS that used to live here are gone — they are
+ * now AST-based (@babel/parser) in `extractor-ast.ts`. What remains are the two
+ * cheap regex GUARDS that run over every candidate file in phase 1 (no TS
+ * expression parsing, so a parser would only add cost):
+ *   - `isGlubeanFile` — does this file import the SDK / a test-like function?
+ *   - `extractAliasesFromSource` — `const x = test.extend(...)` alias names.
+ * Plus the result types consumed across packages (`ExportMeta` lives in
+ * `types.ts`; `PickMeta` / `Contract*StaticMeta` live here).
  */
-import { resolveDataPath } from "./data-path.js";
 // ---------------------------------------------------------------------------
 // SDK import detection
 // ---------------------------------------------------------------------------
@@ -50,7 +42,7 @@ function buildFnAlternation(customFns) {
 /**
  * Check if a file's content looks like a Glubean test/task file.
  *
- * Useful as a fast guard before running the more expensive `extractFromSource`.
+ * A fast, parse-free guard run before the (AST) extractors.
  *
  * Detection layers (any match → true):
  * 1. Direct SDK module import (`jsr:@glubean/sdk`, `@glubean/sdk`)
@@ -141,264 +133,6 @@ function stripComments(source) {
     return result;
 }
 // ---------------------------------------------------------------------------
-// Parsing helpers
-// ---------------------------------------------------------------------------
-/** Count newlines before `offset` to compute 1-based line number. */
-function getLineNumber(content, offset) {
-    let line = 1;
-    for (let i = 0; i < offset && i < content.length; i++) {
-        if (content[i] === "\n")
-            line++;
-    }
-    return line;
-}
-/**
- * Find the index of the matching closing bracket starting from `startIndex`
- * (which must point to the opening bracket). Respects string boundaries.
- * Returns -1 if no match is found.
- */
-function findMatching(source, startIndex, open, close) {
-    let depth = 0;
-    let inString = false;
-    let stringChar = "";
-    for (let i = startIndex; i < source.length; i++) {
-        const ch = source[i];
-        if (inString) {
-            if (ch === "\\" && i + 1 < source.length) {
-                i++; // skip escaped char
-                continue;
-            }
-            if (ch === stringChar)
-                inString = false;
-            continue;
-        }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            inString = true;
-            stringChar = ch;
-            continue;
-        }
-        if (ch === open)
-            depth++;
-        if (ch === close) {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-/** Shorthand: find closing `)` for an opening `(`. */
-function findCloseParen(source, openIndex) {
-    return findMatching(source, openIndex, "(", ")");
-}
-/** Shorthand: find closing `}` for an opening `{`. */
-function findCloseBrace(source, openIndex) {
-    return findMatching(source, openIndex, "{", "}");
-}
-// ---------------------------------------------------------------------------
-// Metadata extraction from object literals
-// ---------------------------------------------------------------------------
-/**
- * Parse `id`, `name`, `tags`, and `timeout` from a TestMeta-like object literal string.
- * Handles both `tags: ["a", "b"]` and `tags: "a"` forms, with single or double quotes.
- */
-function parseMetaObject(source) {
-    const result = {};
-    const idMatch = source.match(/id:\s*(['"])([^'"]+)\1/);
-    if (idMatch)
-        result.id = idMatch[2];
-    const nameMatch = source.match(/name:\s*(['"])([^'"]+)\1/);
-    if (nameMatch)
-        result.name = nameMatch[2];
-    // Tags as array: tags: ["smoke", "auth"] or tags: ['smoke', 'auth']
-    const tagsArrayMatch = source.match(/tags:\s*\[([^\]]*)\]/);
-    if (tagsArrayMatch) {
-        result.tags = [...tagsArrayMatch[1].matchAll(/(['"])([^'"]+)\1/g)].map((m) => m[2]);
-    }
-    else {
-        // Tags as single string: tags: "smoke" or tags: 'smoke'
-        const tagsStringMatch = source.match(/tags:\s*(['"])([^'"]+)\1/);
-        if (tagsStringMatch)
-            result.tags = [tagsStringMatch[2]];
-    }
-    const timeoutMatch = source.match(/timeout:\s*(\d+)/);
-    if (timeoutMatch)
-        result.timeout = Number(timeoutMatch[1]);
-    const requiresMatch = source.match(/requires:\s*(['"])(headless|browser|out-of-band)\1/);
-    if (requiresMatch) {
-        result.requires = requiresMatch[2];
-    }
-    const defaultRunMatch = source.match(/defaultRun:\s*(['"])(always|opt-in)\1/);
-    if (defaultRunMatch) {
-        result.defaultRun = defaultRunMatch[2];
-    }
-    return result;
-}
-/**
- * Extract `name` and `tags` from a `.meta({...})` builder call within `scope`.
- */
-function extractBuilderMeta(scope) {
-    // Caller (parseTestDeclaration) already bounds `scope` to the text
-    // AFTER the test() call's closing paren, so we only see the builder
-    // chain. Anchor on either start-of-scope (so the first chained
-    // `.meta(...)` matches when the test takes no callback, e.g.
-    // `test("id").meta(...)`) or a preceding `)` (e.g.
-    // `test("id").step(...).meta(...)`). This belt-and-suspenders defense
-    // also protects callers that pass a wider scope.
-    const match = scope.match(/(?:^|\))\s*\.\s*meta\s*\(\s*\{/);
-    if (!match || match.index === undefined)
-        return {};
-    const braceStart = scope.indexOf("{", match.index);
-    const braceEnd = findCloseBrace(scope, braceStart);
-    if (braceEnd === -1)
-        return {};
-    const obj = scope.substring(braceStart, braceEnd + 1);
-    return parseMetaObject(obj);
-}
-/**
- * Extract step names from `.step("name", ...)` or `.step('name', ...)` chains within `scope`.
- */
-function extractSteps(scope) {
-    const steps = [];
-    const stepPattern = /\.step\(\s*(['"])([^'"]+)\1/g;
-    let m;
-    while ((m = stepPattern.exec(scope)) !== null) {
-        steps.push({ name: m[2] });
-    }
-    return steps;
-}
-// ---------------------------------------------------------------------------
-// Declaration parser
-// ---------------------------------------------------------------------------
-/**
- * Parse a single test declaration from the text that follows `test` in
- * `export const NAME = test<scope>`. Returns null if the pattern is not
- * recognized.
- */
-function parseTestDeclaration(scope, exportName, line) {
-    let rest = scope;
-    let variant;
-    // Check for .each() or .pick() — may appear on same line or next line
-    let parallel = false;
-    const dataMatch = rest.match(/^\s*\.\s*(each|pick)\s*\(/);
-    if (dataMatch) {
-        variant = dataMatch[1];
-        const openIndex = rest.indexOf("(", dataMatch.index);
-        const closeIndex = findCloseParen(rest, openIndex);
-        if (closeIndex === -1)
-            return null;
-        // Check for { parallel: true } in .each() args
-        if (variant === "each") {
-            const eachArgs = rest.substring(openIndex + 1, closeIndex);
-            if (/parallel\s*:\s*true/.test(eachArgs)) {
-                parallel = true;
-            }
-        }
-        rest = rest.substring(closeIndex + 1);
-    }
-    // Expect opening paren of the test call: test( or test.each(...)( or <generic>test<T>(
-    const callMatch = rest.match(/^\s*(?:<[^>]*>)?\s*\(/);
-    if (!callMatch)
-        return null;
-    const callOpenIndex = rest.indexOf("(", callMatch.index);
-    // Bound the builder-chain search to text AFTER the test() call closes
-    // AND BEFORE the test statement ends (first depth-0 semicolon). Without
-    // both bounds `scope` runs until the next export and could pick up a
-    // sibling `foo().meta({ requires: "browser" })` between this test and
-    // the next export, mis-attributing capability metadata.
-    const callCloseIndex = findCloseParen(rest, callOpenIndex);
-    let builderChainScope = "";
-    if (callCloseIndex !== -1) {
-        const chainStart = callCloseIndex + 1;
-        let depth = 0;
-        let chainEnd = rest.length;
-        for (let i = chainStart; i < rest.length; i++) {
-            const c = rest[i];
-            if (c === "(" || c === "{" || c === "[")
-                depth++;
-            else if (c === ")" || c === "}" || c === "]")
-                depth--;
-            else if (c === ";" && depth === 0) {
-                chainEnd = i;
-                break;
-            }
-        }
-        builderChainScope = rest.substring(chainStart, chainEnd);
-    }
-    const afterOpen = rest.substring(callOpenIndex + 1).trimStart();
-    let id;
-    let name;
-    let tags;
-    let timeout;
-    let requires;
-    let defaultRun;
-    if (afterOpen.startsWith('"') || afterOpen.startsWith("'")) {
-        // String ID
-        const quote = afterOpen[0];
-        const endQuote = afterOpen.indexOf(quote, 1);
-        if (endQuote === -1)
-            return null;
-        id = afterOpen.substring(1, endQuote);
-    }
-    else if (afterOpen.startsWith("{")) {
-        // TestMeta object
-        const braceEnd = findCloseBrace(afterOpen, 0);
-        if (braceEnd === -1)
-            return null;
-        const objStr = afterOpen.substring(0, braceEnd + 1);
-        const parsed = parseMetaObject(objStr);
-        id = parsed.id;
-        name = parsed.name;
-        tags = parsed.tags;
-        timeout = parsed.timeout;
-        requires = parsed.requires;
-        defaultRun = parsed.defaultRun;
-    }
-    if (!id)
-        return null;
-    // Extract builder .meta({...}) ONLY from the chain after the test()
-    // call closes — not from inside the callback body.
-    const builderMeta = extractBuilderMeta(builderChainScope);
-    if (!name && builderMeta.name)
-        name = builderMeta.name;
-    if (!tags && builderMeta.tags)
-        tags = builderMeta.tags;
-    if (timeout === undefined && builderMeta.timeout !== undefined) {
-        timeout = builderMeta.timeout;
-    }
-    if (requires === undefined && builderMeta.requires !== undefined) {
-        requires = builderMeta.requires;
-    }
-    if (defaultRun === undefined && builderMeta.defaultRun !== undefined) {
-        defaultRun = builderMeta.defaultRun;
-    }
-    // Extract .step("name", ...) chains from the full scope
-    const steps = extractSteps(scope);
-    const result = {
-        type: "test",
-        id,
-        exportName,
-        location: { line, col: 1 },
-    };
-    if (name)
-        result.name = name;
-    if (tags && tags.length > 0)
-        result.tags = tags;
-    if (timeout !== undefined)
-        result.timeout = timeout;
-    if (requires !== undefined)
-        result.requires = requires;
-    if (defaultRun !== undefined)
-        result.defaultRun = defaultRun;
-    if (variant)
-        result.variant = variant;
-    if (steps.length > 0)
-        result.steps = steps;
-    if (parallel)
-        result.parallel = true;
-    return result;
-}
-// ---------------------------------------------------------------------------
 // Alias discovery (auto-detect test.extend / task.extend)
 // ---------------------------------------------------------------------------
 /**
@@ -426,480 +160,4 @@ export function extractAliasesFromSource(content) {
     }
     return aliases;
 }
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Extract test metadata from TypeScript source using static analysis (regex).
- *
- * Recognizes the following patterns:
- * - `export const x = test("id", fn)` — simple test with string ID
- * - `export const x = test({ id, name, tags }, fn)` — simple test with meta
- * - `export const x = test("id").step(...)` — builder with steps
- * - `export const x = test.each(data)("id-$key", fn)` — data-driven
- * - `export const x = test.pick(examples)("id-$_pick", fn)` — example selection
- *
- * This is a pure function — no file system or runtime access needed.
- *
- * @param content - TypeScript source code
- * @param customFns - Additional function names discovered via `extractAliasesFromSource`.
- *                    When provided, these names are matched alongside `test` and `task`.
- *                    When omitted, falls back to `*Test` / `*Task` convention matching.
- * @returns Array of extracted export metadata
- */
-export function extractFromSource(content, customFns) {
-    const results = [];
-    const stripped = stripComments(content);
-    // Build the function-name alternation — either explicit aliases or convention fallback
-    const alt = buildFnAlternation(customFns);
-    const exportPattern = new RegExp(`export\\s+const\\s+(\\w+)\\s*=\\s*(${alt})\\b`, "g");
-    const matches = [];
-    let m;
-    while ((m = exportPattern.exec(stripped)) !== null) {
-        matches.push({
-            exportName: m[1],
-            offset: m.index,
-            afterTest: m.index + m[0].length,
-        });
-    }
-    for (let i = 0; i < matches.length; i++) {
-        const { exportName, offset, afterTest } = matches[i];
-        // Scope from right after the function name to the start of the next export (or EOF)
-        const endOffset = i + 1 < matches.length ? matches[i + 1].offset : stripped.length;
-        const scope = stripped.substring(afterTest, endOffset);
-        const line = getLineNumber(stripped, offset);
-        const meta = parseTestDeclaration(scope, exportName, line);
-        if (meta)
-            results.push(meta);
-    }
-    return results;
-}
-/**
- * Create a static metadata extractor that uses file system to read content.
- *
- * Aliases can be supplied at two levels:
- * - `customFns` (construction-time): baked-in aliases known upfront.
- * - `runtimeFns` (call-time): aliases discovered during a Scanner two-phase
- *   scan. These are merged with `customFns` so the extractor benefits from
- *   aliases discovered after construction.
- *
- * @param readFile - Function to read file content as string
- * @param customFns - Additional function names (from alias discovery)
- * @returns MetadataExtractor function
- */
-export function createStaticExtractor(readFile, customFns) {
-    return async (filePath, runtimeFns) => {
-        const content = await readFile(filePath);
-        // Merge construction-time and call-time aliases
-        const merged = customFns || runtimeFns ? [...new Set([...(customFns ?? []), ...(runtimeFns ?? [])])] : undefined;
-        return extractFromSource(content, merged);
-    };
-}
-/**
- * Extract test.pick() metadata from TypeScript source for CodeLens rendering.
- *
- * Handles data source patterns:
- * 1. Inline object literal: `test.pick({ "key1": ..., "key2": ... })`
- * 2. JSON import variable: `import X from "./data.json"` then `test.pick(X)`
- * 3. fromDir.merge variable: `const X = await fromDir.merge("./dir/")` then `test.pick(X)`
- * 4. fromDir variable: `const X = await fromDir("./dir/")` then `test.pick(X)`
- * 5. fromDir.concat variable: `const X = await fromDir.concat("./dir/")` then `test.pick(X)`
- * 6. fromYaml.map variable: `const X = await fromYaml.map("./file.yaml")` then `test.pick(X)`
- * 7. fromJson variable: `const X = await fromJson("./file.json")` then `test.each(X)`
- * 8. fromJson.map variable: `const X = await fromJson.map("./file.json")` then `test.pick(X)`
- *
- * For other patterns (dynamic vars, etc.), returns keys: null.
- *
- * @param content - TypeScript source code
- * @param options - Optional settings
- * @param options.customFns - Additional function names discovered via alias scanning.
- * @param options.filePath - Source file path. When provided, file-relative
- *                           paths are resolved against this file's directory.
- * @param options.projectRoot - Project root. When provided, bare paths are
- *                              resolved against the project root instead of
- *                              the source file directory.
- * @returns Array of PickMeta, or empty if no test.pick calls found
- */
-export function extractPickExamples(content, options) {
-    const customFns = options?.customFns;
-    const filePath = options?.filePath;
-    const projectRoot = options?.projectRoot;
-    const results = [];
-    // Build function-name alternation for pick patterns
-    const fnAlt = customFns && customFns.length > 0
-        ? [...new Set(["test", "task", ...customFns])].map(s => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")
-        : "\\w*(?:Test|Task)|test|task";
-    // Build a map of JSON imports: variable name → file path
-    const jsonImports = new Map();
-    const importPattern = /import\s+(\w+)\s+from\s+["']([^"']+\.json)["']/g;
-    let importMatch;
-    while ((importMatch = importPattern.exec(content)) !== null) {
-        jsonImports.set(importMatch[1], importMatch[2]);
-    }
-    // Build a map of fromDir.merge assignments: variable name → directory path
-    const dirMergeSources = new Map();
-    const dirMergePattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromDir\.merge\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let dirMergeMatch;
-    while ((dirMergeMatch = dirMergePattern.exec(content)) !== null) {
-        dirMergeSources.set(dirMergeMatch[1], dirMergeMatch[2]);
-    }
-    // Build a map of fromDir assignments: variable name → directory path
-    const dirSources = new Map();
-    const dirPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromDir\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let dirMatch;
-    while ((dirMatch = dirPattern.exec(content)) !== null) {
-        // Exclude fromDir.merge and fromDir.concat which are already matched
-        const fullMatch = dirMatch[0];
-        if (!fullMatch.includes("fromDir.merge") && !fullMatch.includes("fromDir.concat")) {
-            dirSources.set(dirMatch[1], dirMatch[2]);
-        }
-    }
-    // Build a map of fromDir.concat assignments: variable name → directory path
-    const dirConcatSources = new Map();
-    const dirConcatPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromDir\.concat\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let dirConcatMatch;
-    while ((dirConcatMatch = dirConcatPattern.exec(content)) !== null) {
-        dirConcatSources.set(dirConcatMatch[1], dirConcatMatch[2]);
-    }
-    // Build a map of fromYaml.map assignments: variable name → file path
-    const yamlMapSources = new Map();
-    const yamlMapPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromYaml\.map\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let yamlMapMatch;
-    while ((yamlMapMatch = yamlMapPattern.exec(content)) !== null) {
-        yamlMapSources.set(yamlMapMatch[1], yamlMapMatch[2]);
-    }
-    // Build a map of fromJson assignments: variable name → file path
-    const jsonLoaderSources = new Map();
-    const jsonLoaderPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromJson\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let jsonLoaderMatch;
-    while ((jsonLoaderMatch = jsonLoaderPattern.exec(content)) !== null) {
-        // Exclude fromJson.map which is matched separately
-        if (!jsonLoaderMatch[0].includes("fromJson.map")) {
-            jsonLoaderSources.set(jsonLoaderMatch[1], jsonLoaderMatch[2]);
-        }
-    }
-    // Build a map of fromJson.map assignments: variable name → file path
-    const jsonMapSources = new Map();
-    const jsonMapPattern = /(?:const|let)\s+(\w+)\s*=\s*await\s+fromJson\.map\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/g;
-    let jsonMapMatch;
-    while ((jsonMapMatch = jsonMapPattern.exec(content)) !== null) {
-        jsonMapSources.set(jsonMapMatch[1], jsonMapMatch[2]);
-    }
-    // ── Pattern 1: Inline object literal ────────────────────────────────────
-    const inlinePickPattern = new RegExp(`export\\s+const\\s+(\\w+)\\s*=\\s*(?:${fnAlt})\\s*\\.pick\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)\\s*\\(\\s*(?:["']([^"']+)["']|\\{\\s*id:\\s*["']([^"']+)["'])`, "g");
-    let match;
-    while ((match = inlinePickPattern.exec(content)) !== null) {
-        const exportName = match[1];
-        const objectBody = match[2];
-        const testId = match[3] ?? match[4];
-        const line = getLineNumber(content, match.index);
-        const keys = [];
-        let depth = 0;
-        for (let i = 0; i < objectBody.length; i++) {
-            const ch = objectBody[i];
-            if (ch === "{" || ch === "[") {
-                depth++;
-            }
-            else if (ch === "}" || ch === "]") {
-                depth--;
-            }
-            else if (depth === 0) {
-                const remaining = objectBody.slice(i);
-                const keyMatch = remaining.match(/^(?:["']([^"']+)["']|([a-zA-Z_]\w*))\s*:/);
-                if (keyMatch) {
-                    keys.push(keyMatch[1] || keyMatch[2]);
-                    i += keyMatch[0].length - 1;
-                }
-            }
-        }
-        results.push({
-            testId,
-            line,
-            exportName,
-            keys: keys.length > 0 ? keys : null,
-            dataSource: keys.length > 0 ? { type: "inline" } : undefined,
-        });
-    }
-    // ── Pattern 2: Variable reference ────────────────────────────────────────
-    const varPickPattern = new RegExp(`export\\s+const\\s+(\\w+)\\s*=\\s*(?:${fnAlt})\\s*\\.pick\\s*\\(\\s*(\\w+)\\s*\\)\\s*\\(\\s*(?:["']([^"']+)["']|\\{\\s*id:\\s*["']([^"']+)["'])`, "g");
-    while ((match = varPickPattern.exec(content)) !== null) {
-        const exportName = match[1];
-        const varName = match[2];
-        const testId = match[3] ?? match[4];
-        const line = getLineNumber(content, match.index);
-        // Check JSON import
-        const jsonPath = jsonImports.get(varName);
-        if (jsonPath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "json-import",
-                    path: resolveDataPath(jsonPath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromDir.merge
-        const dirMergePath = dirMergeSources.get(varName);
-        if (dirMergePath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "dir-merge",
-                    path: resolveDataPath(dirMergePath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromDir
-        const dirPathVal = dirSources.get(varName);
-        if (dirPathVal) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "dir",
-                    path: resolveDataPath(dirPathVal, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromDir.concat
-        const dirConcatPath = dirConcatSources.get(varName);
-        if (dirConcatPath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "dir-concat",
-                    path: resolveDataPath(dirConcatPath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromYaml.map
-        const yamlMapPath = yamlMapSources.get(varName);
-        if (yamlMapPath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "yaml-map",
-                    path: resolveDataPath(yamlMapPath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromJson
-        const jsonLoaderPath = jsonLoaderSources.get(varName);
-        if (jsonLoaderPath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "json-loader",
-                    path: resolveDataPath(jsonLoaderPath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Check fromJson.map
-        const jsonMapPath = jsonMapSources.get(varName);
-        if (jsonMapPath) {
-            results.push({
-                testId,
-                line,
-                exportName,
-                keys: null,
-                dataSource: {
-                    type: "json-map",
-                    path: resolveDataPath(jsonMapPath, {
-                        filePath,
-                        projectRoot,
-                    }).resolvedPath,
-                },
-            });
-            continue;
-        }
-        // Unknown variable
-        results.push({
-            testId,
-            line,
-            exportName,
-            keys: null,
-            dataSource: undefined,
-        });
-    }
-    return results;
-}
-/**
- * Extract contract.http()/contract.grpc()/etc. metadata from TypeScript source.
- *
- * Statically extracts:
- * - Contract ID, endpoint, export name, line number
- * - Each case key with its line number
- * - Expected status code (if literal number)
- * - Deferred reason (if literal string)
- *
- * @param content - TypeScript source code
- * @returns Array of ContractStaticMeta, or empty if no contract calls found
- */
-export function extractContractCases(content) {
-    const results = [];
-    // Match: export const X = contract.http("id", {
-    const contractPattern = /export\s+const\s+(\w+)\s*=\s*contract\.(\w+)\s*\(\s*["']([^"']+)["']\s*,\s*\{/g;
-    let contractMatch;
-    while ((contractMatch = contractPattern.exec(content)) !== null) {
-        const exportName = contractMatch[1];
-        const protocol = contractMatch[2];
-        const contractId = contractMatch[3];
-        const line = getLineNumber(content, contractMatch.index);
-        const afterContract = content.slice(contractMatch.index + contractMatch[0].length);
-        // Find the cases: { ... } block
-        const casesStart = afterContract.indexOf("cases:");
-        // Extract contract-level fields from the region BEFORE cases: to avoid
-        // matching case-level fields inside the cases block.
-        const specHeader = casesStart !== -1 ? afterContract.slice(0, casesStart) : afterContract;
-        let endpoint = "";
-        const endpointMatch = specHeader.match(/endpoint\s*:\s*["']([^"']+)["']/);
-        if (endpointMatch) {
-            endpoint = endpointMatch[1];
-        }
-        let description;
-        const descriptionMatch = specHeader.match(/description\s*:\s*["']([^"']+)["']/);
-        if (descriptionMatch) {
-            description = descriptionMatch[1];
-        }
-        let feature;
-        const featureMatch = specHeader.match(/feature\s*:\s*["']([^"']+)["']/);
-        if (featureMatch) {
-            feature = featureMatch[1];
-        }
-        if (casesStart === -1) {
-            results.push({ contractId, exportName, line, endpoint, protocol, description, feature, cases: [] });
-            continue;
-        }
-        // Find the opening brace after "cases:"
-        const afterCases = afterContract.slice(casesStart);
-        const braceIdx = afterCases.indexOf("{");
-        if (braceIdx === -1) {
-            results.push({ contractId, exportName, line, endpoint, protocol, description, feature, cases: [] });
-            continue;
-        }
-        // Extract top-level keys in the cases object by tracking brace depth
-        const casesContent = afterCases.slice(braceIdx);
-        const cases = [];
-        const topLevelKeys = [];
-        let depth = 0;
-        for (let i = 0; i < casesContent.length; i++) {
-            if (casesContent[i] === "{") {
-                if (depth === 1) {
-                    // Look backward for the key name
-                    const before = casesContent.slice(0, i).trimEnd();
-                    const keyMatch = before.match(/["']?(\w+)["']?\s*:\s*$/);
-                    if (keyMatch) {
-                        topLevelKeys.push({ key: keyMatch[1], offset: i });
-                    }
-                }
-                depth++;
-            }
-            else if (casesContent[i] === "}") {
-                depth--;
-                if (depth === 0)
-                    break;
-            }
-        }
-        for (const { key, offset } of topLevelKeys) {
-            const absoluteOffset = contractMatch.index +
-                contractMatch[0].length +
-                casesStart +
-                braceIdx +
-                offset;
-            const caseLine = getLineNumber(content, absoluteOffset);
-            // Extract case body between matching braces
-            let caseDepth = 0;
-            let caseEnd = offset;
-            for (let i = offset; i < casesContent.length; i++) {
-                if (casesContent[i] === "{")
-                    caseDepth++;
-                else if (casesContent[i] === "}") {
-                    caseDepth--;
-                    if (caseDepth === 0) {
-                        caseEnd = i;
-                        break;
-                    }
-                }
-            }
-            const caseBody = casesContent.slice(offset, caseEnd + 1);
-            let description;
-            const descMatch = caseBody.match(/description\s*:\s*["']([^"']+)["']/);
-            if (descMatch)
-                description = descMatch[1];
-            let expectStatus;
-            const statusMatch = caseBody.match(/status\s*:\s*(\d+)/);
-            if (statusMatch)
-                expectStatus = parseInt(statusMatch[1], 10);
-            let deferred;
-            const deferredMatch = caseBody.match(/deferred\s*:\s*["']([^"']+)["']/);
-            if (deferredMatch)
-                deferred = deferredMatch[1];
-            let requires;
-            const requiresMatch = caseBody.match(/requires\s*:\s*["'](headless|browser|out-of-band)["']/);
-            if (requiresMatch)
-                requires = requiresMatch[1];
-            let defaultRun;
-            const defaultRunMatch = caseBody.match(/defaultRun\s*:\s*["'](always|opt-in)["']/);
-            if (defaultRunMatch)
-                defaultRun = defaultRunMatch[1];
-            let given;
-            const givenMatch = caseBody.match(/given\s*:\s*["']([^"']+)["']/);
-            if (givenMatch)
-                given = givenMatch[1];
-            cases.push({
-                key,
-                line: caseLine,
-                description,
-                expectStatus,
-                deferred,
-                requires,
-                defaultRun,
-                given,
-            });
-        }
-        results.push({ contractId, exportName, line, endpoint, protocol, description, feature, cases });
-    }
-    return results;
-}
 //# sourceMappingURL=extractor-static.js.map