@gtsx/core 0.0.1 → 0.0.2

package/dist/analyzer.js

@@ -1,6 +1,18 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import ts from "typescript";
+export function createGTSXAnalysisCache(sourceFilesByPath = new Map()) {
+    return {
+        componentDependencyBindingsByPath: new Map(),
+        exportedComponentTargetsByPath: new Map(),
+        importedGTSXPathByKey: new Map(),
+        importedScopeHookNamesByPath: new Map(),
+        providerSummariesByPath: new Map(),
+        scopeHookProviderNamesByPath: new Map(),
+        sourceFilesByPath,
+        topLevelFunctionLikeBodiesByPath: new Map(),
+    };
+}
 export function analyzeEntry(options) {
     const entryCoordinate = parseEntryCoordinate(options.entry);
     const entryPath = resolve(options.cwd, entryCoordinate.file);
@@ -22,11 +34,30 @@ export function analyzeEntry(options) {
             ],
         };
     }
-    const sourceText = readFileSync(entryPath, "utf8");
-    const sourceFile = ts.createSourceFile(entryPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const sourceFile = sourceFileForAbsolutePath(entryPath, options.cache);
+    if (!sourceFile) {
+        return {
+            entry: options.entry,
+            mode: "unknown",
+            defaultExport: false,
+            cases: [],
+            providers: {},
+            diagnostics: [
+                {
+                    stage: "contract-extraction",
+                    code: "entry-not-found",
+                    message: `GTSX entry does not exist: ${options.entry}`,
+                    file: options.entry,
+                },
+            ],
+        };
+    }
     const componentExportName = getComponentExportName(sourceFile, entryCoordinate.exportName);
-    const scopeHookNames = getScopeHookNames(sourceFile);
-    const providerCases = Object.fromEntries([...getGProviderNames(sourceFile)].map((name) => [name, { name, cases: [] }]));
+    const scopeHookNames = new Set([
+        ...getScopeHookNames(sourceFile),
+        ...getImportedScopeHookNames(sourceFile, entryPath, options.cwd, options.cache),
+    ]);
+    const providerCases = Object.fromEntries(getGProviderSummariesForFile(sourceFile, entryPath, options.cwd, options.cache));
     const componentAssignments = [];
     const scopeAssignments = [];
     for (const statement of sourceFile.statements) {
@@ -64,12 +95,20 @@ export function analyzeEntry(options) {
                 file: options.entry,
             });
         }
-        for (const hookName of getNonGTSXHookCalls(sourceFile, componentExportName, scopeHookNames)) {
+        for (const violation of getNonGTSXHookCalls(sourceFile, componentExportName, scopeHookNames, {
+            cwd: options.cwd,
+            entryPath,
+            cache: options.cache,
+            sourceFilesByPath: options.cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        })) {
             diagnostics.push({
                 stage: "contract-extraction",
                 code: "non-gtsx-hook",
-                message: `GTSX components may only call GTSX hooks; found "${hookName}". Wrap production hooks with createGScopeHook(...).`,
-                file: options.entry,
+                message: violation.file === normalizeProjectPath(relative(options.cwd, entryPath))
+                    ? `GTSX components may only call GTSX hooks; found "${violation.hookName}" in "${violation.componentName}". Wrap production hooks with createGScopeHook(...).`
+                    : `GTSX components may only call GTSX hooks; found "${violation.hookName}" in dependency "${violation.file}#${violation.componentName}". Wrap production hooks with createGScopeHook(...).`,
+                file: violation.file,
             });
         }
     }
@@ -90,6 +129,7 @@ export function analyzeEntry(options) {
         });
     }
     const componentCases = componentAssignments.flatMap((assignment) => assignment.cases);
+    const componentStaticCases = componentAssignments.flatMap((assignment) => assignment.staticCases);
     const mode = componentCases.length === 0
         ? "unknown"
         : componentCases.some((testCase) => testCase.kind === "scope")
@@ -98,6 +138,14 @@ export function analyzeEntry(options) {
     const selectedCases = mode === "scope"
         ? componentCases.map((testCase) => ({ ...testCase, kind: "scope" }))
         : componentCases.map((testCase) => ({ ...testCase, kind: "pure" }));
+    const importedNames = getImportedNames(sourceFile);
+    for (const testCase of selectedCases) {
+        for (const providerName of testCase.providers ?? []) {
+            if (!providerCases[providerName] && importedNames.has(providerName)) {
+                providerCases[providerName] = { name: providerName, cases: [] };
+            }
+        }
+    }
     if (selectedCases.length === 0) {
         diagnostics.push({
             stage: "contract-extraction",
@@ -108,6 +156,31 @@ export function analyzeEntry(options) {
     }
     for (const testCase of selectedCases) {
         validateProviderSelections(testCase, providerCases, diagnostics, options.entry);
+        validateProviderVariantSelections(testCase, providerCases, diagnostics, options.entry);
+    }
+    if (componentExportName) {
+        const consumedProviderNames = getGProviderConsumers(sourceFile, componentExportName, {
+            cwd: options.cwd,
+            entryPath,
+            cache: options.cache,
+            sourceFilesByPath: options.cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
+        validateProviderVariantCoverage(consumedProviderNames, providerCases, selectedCases, diagnostics, options.entry);
+        validateJSXTreeCaseReachability(sourceFile, componentExportName, scopeHookNames, componentStaticCases, diagnostics, options.entry, {
+            cwd: options.cwd,
+            entryPath,
+            cache: options.cache,
+            sourceFilesByPath: options.cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
+        validateProviderProjectionWarnings(sourceFile, componentExportName, scopeHookNames, providerCases, diagnostics, options.entry, {
+            cwd: options.cwd,
+            entryPath,
+            cache: options.cache,
+            sourceFilesByPath: options.cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
     }
     return {
         entry: options.entry,
@@ -145,6 +218,13 @@ function getDefaultExportName(sourceFile) {
         if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) {
             return statement.expression.text;
         }
+        if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                if (element.name.text === "default") {
+                    return element.propertyName?.text ?? element.name.text;
+                }
+            }
+        }
     }
     return undefined;
 }
@@ -155,6 +235,20 @@ function getNamedExportName(sourceFile, exportName) {
             hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
             return exportName;
         }
+        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && declaration.name.text === exportName && getFunctionLikeBody(sourceFile, exportName)) {
+                    return exportName;
+                }
+            }
+        }
+        if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                if (element.name.text === exportName) {
+                    return element.propertyName?.text ?? element.name.text;
+                }
+            }
+        }
     }
     return undefined;
 }
@@ -165,6 +259,18 @@ function getFirstNamedExportName(sourceFile) {
             hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
             return statement.name.text;
         }
+        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && getFunctionLikeBody(sourceFile, declaration.name.text)) {
+                    return declaration.name.text;
+                }
+            }
+        }
+        if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            const element = statement.exportClause.elements[0];
+            if (element)
+                return element.propertyName?.text ?? element.name.text;
+        }
     }
     return undefined;
 }
@@ -176,186 +282,2159 @@ function getScopeHookNames(sourceFile) {
         for (const declaration of statement.declarationList.declarations) {
             if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
                 continue;
-            if (isCreateGScopeCall(declaration.initializer)) {
+            if (isCreateGScopeCall(unwrapExpression(declaration.initializer))) {
                 names.add(declaration.name.text);
             }
         }
     }
     return names;
 }
-function getGProviderNames(sourceFile) {
-    const names = new Set();
+function getScopeHookProviderNamesForFile(sourceFile, filePath, cache) {
+    const cached = cache?.scopeHookProviderNamesByPath.get(filePath);
+    if (cached)
+        return cached;
+    const hookProviders = new Map();
     for (const statement of sourceFile.statements) {
         if (!ts.isVariableStatement(statement))
             continue;
         for (const declaration of statement.declarationList.declarations) {
             if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
                 continue;
-            if (isCreateGProviderCall(unwrapExpression(declaration.initializer))) {
-                names.add(declaration.name.text);
-            }
+            const initializer = unwrapExpression(declaration.initializer);
+            if (!isCreateGScopeCall(initializer))
+                continue;
+            const providersExpression = initializer.arguments[1];
+            if (!providersExpression)
+                continue;
+            const providerNames = readProviderNameList(providersExpression, sourceFile);
+            if (providerNames.length > 0)
+                hookProviders.set(declaration.name.text, providerNames);
         }
     }
-    return names;
+    cache?.scopeHookProviderNamesByPath.set(filePath, hookProviders);
+    return hookProviders;
 }
-function validateProviderSelections(testCase, providerCases, diagnostics, file) {
-    if (!testCase.providers)
-        return;
-    for (const providerName of testCase.providers) {
-        if (!providerCases[providerName]) {
-            diagnostics.push({
-                stage: "contract-extraction",
-                code: "missing-provider",
-                message: `Case "${testCase.name}" selects unknown provider "${providerName}".`,
-                file,
-                caseName: testCase.name,
+function readProviderNameList(expression, sourceFile, visited = new Set()) {
+    const value = unwrapExpression(expression);
+    if (ts.isArrayLiteralExpression(value)) {
+        return value.elements.flatMap((element) => {
+            const provider = unwrapExpression(element);
+            return ts.isIdentifier(provider) ? [provider.text] : [];
+        });
+    }
+    if (ts.isIdentifier(value)) {
+        if (visited.has(value.text))
+            return [];
+        visited.add(value.text);
+        const initializer = topLevelVariableInitializer(sourceFile, value.text);
+        return initializer ? readProviderNameList(initializer, sourceFile, visited) : [];
+    }
+    return [];
+}
+function topLevelVariableInitializer(sourceFile, name) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) && declaration.name.text === name)
+                return declaration.initializer;
+        }
+    }
+    return undefined;
+}
+function getGProviderSummaries(sourceFile) {
+    const providers = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+                continue;
+            const initializer = unwrapExpression(declaration.initializer);
+            if (!isCreateGProviderCall(initializer))
+                continue;
+            const variants = readCreateGProviderVariants(initializer);
+            providers.set(declaration.name.text, {
+                name: declaration.name.text,
+                cases: [],
+                ...(variants && variants.length > 0 ? { variants } : {}),
             });
         }
     }
+    return providers;
 }
-function getNonGTSXHookCalls(sourceFile, componentName, scopeHookNames) {
-    const component = getFunctionDeclaration(sourceFile, componentName);
-    if (!component?.body)
-        return [];
-    const helperFunctions = getTopLevelFunctionDeclarations(sourceFile);
-    const visitedHelpers = new Set([componentName]);
-    const hookNames = new Set();
-    visit(component.body);
-    return [...hookNames];
-    function visit(node) {
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            const hookName = node.expression.text;
-            if (isHookName(hookName) && hookName !== "useGContext" && !scopeHookNames.has(hookName)) {
-                hookNames.add(hookName);
+function getGProviderSummariesForFile(sourceFile, filePath, cwd, cache) {
+    const cached = cache?.providerSummariesByPath.get(filePath);
+    if (cached)
+        return cached;
+    const providers = new Map(getGProviderSummaries(sourceFile));
+    cache?.providerSummariesByPath.set(filePath, providers);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const targetPath = resolveImportedGTSXPath(filePath, cwd, statement.moduleSpecifier.text, cache);
+        if (!targetPath)
+            continue;
+        const targetSource = sourceFileForAbsolutePath(targetPath, cache);
+        if (!targetSource)
+            continue;
+        const targetProviders = getGProviderSummariesForFile(targetSource, targetPath, cwd, cache);
+        const importClause = statement.importClause;
+        if (importClause.name) {
+            const importedDefault = targetProviders.get("default");
+            if (importedDefault) {
+                providers.set(importClause.name.text, { ...importedDefault, name: importClause.name.text });
             }
-            else if (!isHookName(hookName)) {
-                visitHelper(hookName);
+        }
+        const namedBindings = importClause.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        for (const element of namedBindings.elements) {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            const importedProvider = targetProviders.get(importedName);
+            if (importedProvider) {
+                providers.set(element.name.text, { ...importedProvider, name: element.name.text });
             }
         }
-        ts.forEachChild(node, visit);
     }
-    function visitHelper(functionName) {
-        if (visitedHelpers.has(functionName))
-            return;
-        const helper = helperFunctions.get(functionName);
-        if (!helper?.body)
-            return;
-        visitedHelpers.add(functionName);
-        visit(helper.body);
+    return providers;
+}
+function readCreateGProviderVariants(expression) {
+    const options = expression.arguments[1] ? unwrapExpression(expression.arguments[1]) : undefined;
+    if (!options || !ts.isObjectLiteralExpression(options))
+        return undefined;
+    const variantsProperty = options.properties.find((property) => ts.isPropertyAssignment(property) && getStaticPropertyName(property.name) === "variants");
+    if (!variantsProperty)
+        return undefined;
+    const variantsValue = unwrapExpression(variantsProperty.initializer);
+    if (!ts.isArrayLiteralExpression(variantsValue))
+        return undefined;
+    return variantsValue.elements.flatMap((element) => {
+        const variant = unwrapExpression(element);
+        return ts.isStringLiteral(variant) ? [variant.text] : [];
+    });
+}
+function getImportedScopeHookNames(sourceFile, entryPath, cwd, cache) {
+    const cached = cache?.importedScopeHookNamesByPath.get(entryPath);
+    if (cached)
+        return cached;
+    const names = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const clause = statement.importClause;
+        if (!clause || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const targetPath = resolveImportedGTSXPath(entryPath, cwd, statement.moduleSpecifier.text, cache);
+        if (!targetPath)
+            continue;
+        const targetSource = sourceFileForAbsolutePath(targetPath, cache);
+        if (!targetSource)
+            continue;
+        const exportedScopeHookNames = getExportedScopeHookNames(targetSource);
+        if (clause.name && exportedScopeHookNames.has("default") && isHookName(clause.name.text)) {
+            names.add(clause.name.text);
+        }
+        const namedBindings = clause.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        for (const element of namedBindings.elements) {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            if (exportedScopeHookNames.has(importedName) && isHookName(element.name.text)) {
+                names.add(element.name.text);
+            }
+        }
     }
+    cache?.importedScopeHookNamesByPath.set(entryPath, names);
+    return names;
 }
-function getGScopeHookCalls(sourceFile, componentName, scopeHookNames) {
-    const component = getFunctionDeclaration(sourceFile, componentName);
-    if (!component?.body)
-        return [];
-    const helperFunctions = getTopLevelFunctionDeclarations(sourceFile);
-    const visitedHelpers = new Set([componentName]);
-    const hookNames = new Set();
-    visit(component.body);
-    return [...hookNames];
-    function visit(node) {
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            if (scopeHookNames.has(node.expression.text)) {
-                hookNames.add(node.expression.text);
+function getExportedScopeHookNames(sourceFile) {
+    const localScopeHookNames = getScopeHookNames(sourceFile);
+    const exportedScopeHookNames = new Set();
+    for (const statement of sourceFile.statements) {
+        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && localScopeHookNames.has(declaration.name.text)) {
+                    exportedScopeHookNames.add(declaration.name.text);
+                }
             }
-            else if (!isHookName(node.expression.text)) {
-                visitHelper(node.expression.text);
+            continue;
+        }
+        if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression) && localScopeHookNames.has(statement.expression.text)) {
+            exportedScopeHookNames.add("default");
+            continue;
+        }
+        if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            const localName = element.propertyName?.text ?? element.name.text;
+            if (localScopeHookNames.has(localName)) {
+                exportedScopeHookNames.add(element.name.text);
             }
         }
-        ts.forEachChild(node, visit);
     }
-    function visitHelper(functionName) {
-        if (visitedHelpers.has(functionName))
-            return;
-        const helper = helperFunctions.get(functionName);
-        if (!helper?.body)
-            return;
-        visitedHelpers.add(functionName);
-        visit(helper.body);
+    return exportedScopeHookNames;
+}
+function resolveImportedGTSXPath(entryPath, cwd, specifier, cache) {
+    const cacheKey = `${entryPath}\0${specifier}`;
+    const cached = cache?.importedGTSXPathByKey.get(cacheKey);
+    if (cached !== undefined)
+        return cached ?? undefined;
+    const basePath = resolveImportBasePath(entryPath, cwd, specifier);
+    if (!basePath) {
+        cache?.importedGTSXPathByKey.set(cacheKey, null);
+        return undefined;
     }
+    const visited = new Set();
+    const resolved = resolveImportedGTSXPathFromBase(basePath, cwd, visited, cache);
+    cache?.importedGTSXPathByKey.set(cacheKey, resolved ?? null);
+    return resolved;
 }
-function getFunctionDeclaration(sourceFile, functionName) {
-    return sourceFile.statements.find((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === functionName);
+function resolveImportedGTSXPathFromBase(basePath, cwd, visited, cache) {
+    for (const candidate of importedGTSXPathCandidates(basePath)) {
+        if (isFile(candidate))
+            return candidate;
+    }
+    for (const barrelCandidate of importedTSXBarrelCandidates(basePath)) {
+        if (!isFile(barrelCandidate) || visited.has(barrelCandidate))
+            continue;
+        visited.add(barrelCandidate);
+        const barrelSource = sourceFileForAbsolutePath(barrelCandidate, cache);
+        if (!barrelSource)
+            continue;
+        for (const statement of barrelSource.statements) {
+            if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier))
+                continue;
+            const nextBasePath = resolveImportBasePath(barrelCandidate, cwd, statement.moduleSpecifier.text);
+            const resolvedPath = nextBasePath ? resolveImportedGTSXPathFromBase(nextBasePath, cwd, visited, cache) : undefined;
+            if (resolvedPath)
+                return resolvedPath;
+        }
+    }
+    return undefined;
 }
-function getTopLevelFunctionDeclarations(sourceFile) {
-    const functions = new Map();
-    for (const statement of sourceFile.statements) {
-        if (ts.isFunctionDeclaration(statement) && statement.name) {
-            functions.set(statement.name.text, statement);
+function resolveImportBasePath(entryPath, cwd, specifier) {
+    if (specifier.startsWith("@/")) {
+        const direct = resolve(cwd, specifier.slice(2));
+        if (importedGTSXPathCandidates(direct).some((candidate) => isFile(candidate)) ||
+            importedTSXBarrelCandidates(direct).some((candidate) => isFile(candidate))) {
+            return direct;
         }
+        return resolve(cwd, "src", specifier.slice(2));
     }
-    return functions;
+    if (specifier.startsWith("."))
+        return resolve(dirname(entryPath), specifier);
+    return undefined;
 }
-function isHookName(name) {
-    return /^use[A-Z0-9_]/.test(name);
+function importedGTSXPathCandidates(basePath) {
+    const extensionCandidate = /\.(?:tsx|ts|jsx|js)$/.test(basePath) ? basePath.replace(/\.(?:tsx|ts|jsx|js)$/, ".g.tsx") : undefined;
+    const extensionTypeCandidate = /\.(?:tsx|ts|jsx|js)$/.test(basePath) ? basePath.replace(/\.(?:tsx|ts|jsx|js)$/, ".g.ts") : undefined;
+    const candidates = [
+        basePath.endsWith(".g.tsx") ? basePath : undefined,
+        basePath.endsWith(".g.ts") ? basePath : undefined,
+        basePath.endsWith(".g") ? `${basePath}.tsx` : undefined,
+        basePath.endsWith(".g") ? `${basePath}.ts` : undefined,
+        `${basePath}.g.tsx`,
+        `${basePath}.g.ts`,
+        extensionCandidate,
+        extensionTypeCandidate,
+        join(basePath, "index.g.tsx"),
+        join(basePath, "index.g.ts"),
+    ];
+    return [...new Set(candidates.filter((candidate) => Boolean(candidate)))];
 }
-function getCasesAssignment(statement, sourceFile, diagnostics) {
-    if (!ts.isExpressionStatement(statement))
-        return undefined;
-    const expression = statement.expression;
-    if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
-        return undefined;
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
     }
-    if (!ts.isPropertyAccessExpression(expression.left) || expression.left.name.text !== "cases") {
-        return undefined;
+    catch {
+        return false;
     }
-    if (!ts.isIdentifier(expression.left.expression))
-        return undefined;
-    const casesExpression = unwrapExpression(expression.right);
-    if (!ts.isObjectLiteralExpression(casesExpression)) {
-        diagnostics.push({
-            stage: "contract-extraction",
-            code: "malformed-cases",
-            message: "GTSX cases must be a statically enumerable object literal.",
-            file: sourceFile.fileName,
-        });
-        return { targetName: expression.left.expression.text, cases: [] };
+}
+function importedTSXBarrelCandidates(basePath) {
+    const candidates = [
+        basePath.endsWith(".tsx") ? basePath : undefined,
+        `${basePath}.tsx`,
+        join(basePath, "index.tsx"),
+    ];
+    return [...new Set(candidates.filter((candidate) => Boolean(candidate)))];
+}
+function getImportedNames(sourceFile) {
+    const names = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const clause = statement.importClause;
+        if (!clause)
+            continue;
+        if (clause.name) {
+            names.add(clause.name.text);
+        }
+        const namedBindings = clause.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        for (const element of namedBindings.elements) {
+            names.add(element.name.text);
+        }
     }
-    return {
-        targetName: expression.left.expression.text,
-        cases: readCasesObject(casesExpression, sourceFile, diagnostics),
-    };
+    return names;
 }
-function readCasesObject(objectLiteral, sourceFile, diagnostics) {
-    const cases = [];
-    for (const property of objectLiteral.properties) {
-        if (ts.isSpreadAssignment(property)) {
+function validateProviderSelections(testCase, providerCases, diagnostics, file) {
+    if (!testCase.providers)
+        return;
+    for (const providerName of testCase.providers) {
+        if (!providerCases[providerName]) {
             diagnostics.push({
                 stage: "contract-extraction",
-                code: "malformed-cases",
-                message: "GTSX cases do not support spread composition in the first implementation.",
-                file: sourceFile.fileName,
+                code: "missing-provider",
+                message: `Case "${testCase.name}" selects unknown provider "${providerName}".`,
+                file,
+                caseName: testCase.name,
             });
-            continue;
         }
-        if (!ts.isPropertyAssignment(property))
+    }
+}
+function validateProviderVariantSelections(testCase, providerCases, diagnostics, file) {
+    if (!testCase.providerVariants)
+        return;
+    for (const [providerName, selection] of Object.entries(testCase.providerVariants)) {
+        const variants = providerVariantSelectionValues(selection);
+        const provider = providerCases[providerName];
+        if (!provider) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "missing-provider",
+                message: `Case "${testCase.name}" marks unknown provider "${providerName}" variants "${variants.join(", ")}".`,
+                file,
+                caseName: testCase.name,
+            });
             continue;
-        const caseName = getStaticPropertyName(property.name);
-        if (!caseName) {
+        }
+        if (!provider.variants || provider.variants.length === 0) {
             diagnostics.push({
                 stage: "contract-extraction",
-                code: "non-static-case-key",
-                message: "GTSX case keys must be statically enumerable object literal keys.",
-                file: sourceFile.fileName,
+                code: "missing-provider-variants",
+                message: `Case "${testCase.name}" marks provider "${providerName}" variants "${variants.join(", ")}", but "${providerName}" does not declare variants.`,
+                file,
+                caseName: testCase.name,
             });
             continue;
         }
-        const caseValue = unwrapExpression(property.initializer);
-        const providers = ts.isObjectLiteralExpression(caseValue) ? readProviderSelections(caseValue) : undefined;
-        const kind = ts.isObjectLiteralExpression(caseValue) && hasStaticProperty(caseValue, "scope") ? "scope" : "pure";
-        cases.push({
-            kind,
-            name: caseName,
-            ...(providers && Object.keys(providers).length > 0 ? { providers } : {}),
+        const unknownVariants = variants.filter((variant) => !provider.variants?.includes(variant));
+        if (unknownVariants.length > 0) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "unknown-provider-variant",
+                message: `Case "${testCase.name}" marks unknown "${providerName}" variants "${unknownVariants.join(", ")}". Expected one of: ${provider.variants.join(", ")}.`,
+                file,
+                caseName: testCase.name,
+            });
+        }
+    }
+}
+function validateProviderVariantCoverage(consumedProviderNames, providerCases, selectedCases, diagnostics, file) {
+    for (const providerName of consumedProviderNames) {
+        const provider = providerCases[providerName];
+        if (!provider?.variants || provider.variants.length === 0)
+            continue;
+        const coveredVariants = new Set(selectedCases.flatMap((testCase) => {
+            const selection = testCase.providerVariants?.[providerName];
+            return selection ? providerVariantSelectionValues(selection) : [];
+        }));
+        const missingVariants = provider.variants.filter((variant) => !coveredVariants.has(variant));
+        if (missingVariants.length === 0)
+            continue;
+        diagnostics.push({
+            stage: "contract-extraction",
+            code: "missing-provider-variant-cases",
+            message: `GTSX entry consumes provider "${providerName}" but its cases do not cover variants: ${missingVariants.join(", ")}.`,
+            file,
         });
     }
-    return cases;
 }
-function readProviderSelections(caseValue) {
-    const providersProperty = caseValue.properties.find((property) => ts.isPropertyAssignment(property) && getStaticPropertyName(property.name) === "providers");
-    if (!providersProperty)
-        return undefined;
-    const providersValue = unwrapExpression(providersProperty.initializer);
+function providerVariantSelectionValues(selection) {
+    return Array.isArray(selection) ? selection : [selection];
+}
+function validateJSXTreeCaseReachability(sourceFile, componentName, scopeHookNames, staticCases, diagnostics, file, context) {
+    if (staticCases.length === 0)
+        return;
+    const component = getFunctionLikeDeclaration(sourceFile, componentName);
+    if (!component?.body)
+        return;
+    const branchContext = createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames);
+    const defaultValues = defaultStaticValuesForFunctionLike(component);
+    const caseFacts = staticCases.map((testCase) => ({
+        ...testCase,
+        values: new Map([...defaultValues, ...testCase.values]),
+    }));
+    const dependencies = reachableJSXDependenciesForComponent(sourceFile, componentName, branchContext, context);
+    const reported = new Set();
+    for (const dependency of dependencies) {
+        const opaque = firstOpaqueJSXBranchPredicate(dependency.condition);
+        if (opaque) {
+            const key = `opaque:${dependency.tagName}:${opaque.text}`;
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "opaque-jsx-control-flow",
+                message: `JSX dependency <${dependency.tagName}> is controlled by an opaque expression "${opaque.text}". Use props, GTSX context, or GScope values directly so cases can cover the tree structure.`,
+                file,
+            });
+            continue;
+        }
+        const evaluations = caseFacts.map((testCase) => evaluateJSXBranchPredicate(dependency.condition, testCase.values));
+        const coveredCaseNames = caseFacts
+            .filter((_testCase, index) => evaluations[index] === true)
+            .map((testCase) => testCase.name);
+        if (coveredCaseNames.length > 0)
+            continue;
+        const unknownCaseNames = caseFacts
+            .filter((_testCase, index) => evaluations[index] === "unknown")
+            .map((testCase) => testCase.name);
+        if (unknownCaseNames.length > 0) {
+            const key = `unknown:${dependency.tagName}:${formatJSXBranchPredicate(dependency.condition)}`;
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "unknown-jsx-branch-coverage",
+                message: `JSX dependency <${dependency.tagName}> is controlled by "${formatJSXBranchPredicate(dependency.condition)}", but case values are not static enough to prove coverage. Unknown cases: ${unknownCaseNames.join(", ")}.`,
+                file,
+            });
+            continue;
+        }
+        const key = `uncovered:${dependency.tagName}:${formatJSXBranchPredicate(dependency.condition)}`;
+        if (reported.has(key))
+            continue;
+        reported.add(key);
+        diagnostics.push({
+            stage: "contract-extraction",
+            code: "uncovered-jsx-branch",
+            message: `No case renders JSX dependency <${dependency.tagName}> behind "${formatJSXBranchPredicate(dependency.condition)}". Add a case whose props, GTSX context, or GScope values make that branch reachable.`,
+            file,
+        });
+    }
+}
+function validateProviderProjectionWarnings(sourceFile, componentName, scopeHookNames, providerCases, diagnostics, file, context) {
+    const warnings = providerProjectionWarningsForComponent(sourceFile, componentName, scopeHookNames, providerCases, context);
+    const reported = new Set();
+    for (const warning of warnings) {
+        const key = `${warning.target.filePath}#${warning.target.componentName}:${warning.providerName}`;
+        if (reported.has(key))
+            continue;
+        reported.add(key);
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "warning",
+            code: "unmarked-provider-variant-projection",
+            message: `JSX dependency <${warning.tagName}> receives props derived from provider "${warning.providerName}", but its cases do not mark "${warning.providerName}" variants. If those props are environment projections, add GProviderCase markers; if the child is environment-neutral, this warning can be ignored.`,
+            file,
+        });
+    }
+}
+function providerProjectionWarningsForComponent(sourceFile, componentName, scopeHookNames, providerCases, context) {
+    const component = getFunctionLikeDeclaration(sourceFile, componentName);
+    if (!component?.body)
+        return [];
+    const warnings = [];
+    const branchContext = createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames);
+    const helperFunctions = getTopLevelFunctionLikeBodiesForPath(sourceFile, context.entryPath, context.cache);
+    const importBindings = componentDependencyBindingsForFile(sourceFile, context.entryPath, context);
+    const visitedHelpers = new Set([componentName]);
+    visitFunctionLikeBody(component, branchContext, visitedHelpers);
+    return warnings;
+    function visitFunctionLikeBody(functionLike, currentBranchContext, currentVisitedHelpers) {
+        if (!functionLike.body)
+            return;
+        const localAliases = localComponentAliasBindingsForBody(functionLike.body);
+        visit(functionLike.body, currentBranchContext, currentVisitedHelpers, localAliases);
+    }
+    function visit(node, currentBranchContext, currentVisitedHelpers, localAliases) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && !isHookName(node.expression.text)) {
+            const helper = getFunctionLikeDeclaration(sourceFile, node.expression.text);
+            if (helper?.body && expressionContainsJSX(helper.body) && !currentVisitedHelpers.has(node.expression.text)) {
+                const helperVisited = new Set(currentVisitedHelpers);
+                helperVisited.add(node.expression.text);
+                const helperContext = bindFunctionCallArguments(helper, node.arguments, currentBranchContext);
+                visitFunctionLikeBody(helper, helperContext, helperVisited);
+                return;
+            }
+        }
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+            visitJSXOpeningLike(node, currentBranchContext, localAliases);
+        }
+        ts.forEachChild(node, (child) => visit(child, currentBranchContext, currentVisitedHelpers, localAliases));
+    }
+    function visitJSXOpeningLike(node, currentBranchContext, localAliases) {
+        const target = componentDependencyTargetForJsxTag(node.tagName, {
+            filePath: context.entryPath,
+            importBindings,
+            localAliases,
+            localComponentNames: helperFunctions,
+        });
+        if (!target)
+            return;
+        const projectedProviderNames = providerVariantNamesReferencedByJsxAttributes(node.attributes, providerCases, currentBranchContext);
+        if (projectedProviderNames.size === 0)
+            return;
+        const targetSourceFile = sourceFileForPath(target.filePath, context);
+        if (!targetSourceFile)
+            return;
+        for (const providerName of projectedProviderNames) {
+            const markerStatus = componentCasesProviderVariantMarkerStatus(targetSourceFile, target.componentName, providerName);
+            if (markerStatus !== false)
+                continue;
+            warnings.push({
+                providerName,
+                tagName: jsxTagNameText(node.tagName, sourceFile),
+                target,
+            });
+        }
+    }
+}
+function providerVariantNamesReferencedByJsxAttributes(attributes, providerCases, context) {
+    const providerNames = new Set();
+    for (const property of attributes.properties) {
+        const expression = ts.isJsxAttribute(property) && property.initializer
+            ? ts.isJsxExpression(property.initializer)
+                ? property.initializer.expression
+                : property.initializer
+            : ts.isJsxSpreadAttribute(property)
+                ? property.expression
+                : undefined;
+        if (!expression)
+            continue;
+        for (const providerName of providerVariantNamesReferencedByExpression(expression, providerCases, context)) {
+            providerNames.add(providerName);
+        }
+    }
+    return providerNames;
+}
+function providerVariantNamesReferencedByExpression(expression, providerCases, context) {
+    const providerNames = new Set();
+    visit(expression);
+    return providerNames;
+    function visit(node) {
+        if (ts.isExpression(node)) {
+            const reference = factorReferenceForExpression(node, context);
+            if (reference?.root === "context" && (providerCases[reference.providerName]?.variants?.length ?? 0) > 0) {
+                providerNames.add(reference.providerName);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+}
+function componentCasesProviderVariantMarkerStatus(sourceFile, componentName, providerName) {
+    let hasCases = false;
+    for (const statement of sourceFile.statements) {
+        const assignment = getCasesAssignment(statement, sourceFile, []);
+        if (!assignment || assignment.targetName !== componentName)
+            continue;
+        if (assignment.cases.length === 0)
+            continue;
+        hasCases = true;
+        if (assignment.cases.some((testCase) => testCase.providerVariants?.[providerName]))
+            return true;
+    }
+    return hasCases ? false : undefined;
+}
+function createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames) {
+    const context = {
+        expressionAliases: new Map(),
+        factorBindings: new Map(),
+        sourceFile,
+    };
+    bindFunctionParameters(component, context);
+    if (component.body && ts.isBlock(component.body)) {
+        for (const statement of component.body.statements) {
+            bindTopLevelBranchVariableStatement(statement, context, scopeHookNames);
+        }
+    }
+    return context;
+}
+function bindFunctionParameters(component, context) {
+    const propsParameter = component.parameters[0];
+    if (!propsParameter)
+        return;
+    if (ts.isIdentifier(propsParameter.name)) {
+        context.factorBindings.set(propsParameter.name.text, { root: "props", path: [] });
+        return;
+    }
+    if (ts.isObjectBindingPattern(propsParameter.name)) {
+        bindObjectBindingPattern(propsParameter.name, { root: "props", path: [] }, context);
+    }
+}
+function bindTopLevelBranchVariableStatement(statement, context, scopeHookNames) {
+    if (!ts.isVariableStatement(statement))
+        return;
+    for (const declaration of statement.declarationList.declarations) {
+        if (!declaration.initializer)
+            continue;
+        const initializer = unwrapExpression(declaration.initializer);
+        const scopeProvider = scopeHookProviderFromCall(initializer, scopeHookNames);
+        const contextProvider = ts.isCallExpression(initializer) ? gContextProviderNameFromCall(initializer) : undefined;
+        const rootReference = scopeProvider
+            ? { root: "scope", path: [] }
+            : contextProvider
+                ? { root: "context", providerName: contextProvider, path: [] }
+                : factorReferenceForExpression(initializer, context);
+        if (rootReference) {
+            if (ts.isIdentifier(declaration.name)) {
+                context.factorBindings.set(declaration.name.text, rootReference);
+            }
+            else if (ts.isObjectBindingPattern(declaration.name)) {
+                bindObjectBindingPattern(declaration.name, rootReference, context);
+            }
+            continue;
+        }
+        if (ts.isIdentifier(declaration.name) && !expressionContainsJSX(initializer)) {
+            context.expressionAliases.set(declaration.name.text, initializer);
+        }
+    }
+}
+function bindObjectBindingPattern(pattern, rootReference, context) {
+    for (const element of pattern.elements) {
+        if (element.dotDotDotToken)
+            continue;
+        const propertyName = element.propertyName ? bindingNameText(element.propertyName) : bindingNameText(element.name);
+        if (!propertyName)
+            continue;
+        const nextReference = appendFactorReferencePath(rootReference, propertyName);
+        if (ts.isIdentifier(element.name)) {
+            context.factorBindings.set(element.name.text, nextReference);
+        }
+        else if (ts.isObjectBindingPattern(element.name)) {
+            bindObjectBindingPattern(element.name, nextReference, context);
+        }
+    }
+}
+function bindingNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    return undefined;
+}
+function cloneJSXBranchAnalysisContext(context) {
+    return {
+        expressionAliases: new Map(context.expressionAliases),
+        factorBindings: new Map(context.factorBindings),
+        sourceFile: context.sourceFile,
+    };
+}
+function bindCallbackItemParameter(callback, sourceReference, context) {
+    const callbackContext = cloneJSXBranchAnalysisContext(context);
+    const itemReference = appendFactorReferencePath(sourceReference, "number");
+    const parameter = callback.parameters[0];
+    if (!parameter)
+        return callbackContext;
+    if (ts.isIdentifier(parameter.name)) {
+        callbackContext.factorBindings.set(parameter.name.text, itemReference);
+    }
+    else if (ts.isObjectBindingPattern(parameter.name)) {
+        bindObjectBindingPattern(parameter.name, itemReference, callbackContext);
+    }
+    return callbackContext;
+}
+function bindFunctionCallArguments(functionLike, args, context) {
+    const callContext = cloneJSXBranchAnalysisContext(context);
+    for (let index = 0; index < functionLike.parameters.length; index += 1) {
+        const parameter = functionLike.parameters[index];
+        const argument = args[index];
+        if (!parameter || !argument)
+            continue;
+        const argumentReference = factorReferenceForExpression(argument, context);
+        if (argumentReference) {
+            if (ts.isIdentifier(parameter.name)) {
+                callContext.factorBindings.set(parameter.name.text, argumentReference);
+            }
+            else if (ts.isObjectBindingPattern(parameter.name)) {
+                bindObjectBindingPattern(parameter.name, argumentReference, callContext);
+            }
+            continue;
+        }
+        if (ts.isIdentifier(parameter.name) && !expressionContainsJSX(argument)) {
+            callContext.expressionAliases.set(parameter.name.text, argument);
+        }
+    }
+    return callContext;
+}
+function nonEmptyCollectionPredicate(reference) {
+    return {
+        kind: "relation",
+        operator: ">",
+        ref: appendFactorReferencePath(reference, "length"),
+        value: { kind: "number", value: 0 },
+    };
+}
+function opaqueJSXBranchPredicate(expression, context) {
+    return {
+        kind: "opaque",
+        reason: "JSX callback source is not a direct props/context/scope expression",
+        text: expression.getText(context.sourceFile),
+    };
+}
+function jsxAttributeFactorReference(attributes, context) {
+    for (const property of attributes.properties) {
+        if (!ts.isJsxAttribute(property) || !property.initializer)
+            continue;
+        if (!ts.isIdentifier(property.name))
+            continue;
+        if (!new Set(["items", "rows", "data", "options"]).has(property.name.text))
+            continue;
+        if (!ts.isJsxExpression(property.initializer) || !property.initializer.expression)
+            continue;
+        const reference = factorReferenceForExpression(property.initializer.expression, context);
+        if (reference)
+            return reference;
+    }
+    return undefined;
+}
+function defaultStaticValuesForFunctionLike(component) {
+    const values = new Map();
+    const propsParameter = component.parameters[0];
+    if (!propsParameter || !ts.isObjectBindingPattern(propsParameter.name))
+        return values;
+    collectBindingDefaults(propsParameter.name, { root: "props", path: [] }, values);
+    return values;
+}
+function collectBindingDefaults(pattern, rootReference, values) {
+    for (const element of pattern.elements) {
+        if (element.dotDotDotToken)
+            continue;
+        const propertyName = element.propertyName ? bindingNameText(element.propertyName) : bindingNameText(element.name);
+        if (!propertyName)
+            continue;
+        const nextReference = appendFactorReferencePath(rootReference, propertyName);
+        if (element.initializer) {
+            const value = readStaticBranchValue(element.initializer);
+            if (value)
+                values.set(factorReferenceKey(nextReference), value);
+        }
+        if (ts.isObjectBindingPattern(element.name)) {
+            collectBindingDefaults(element.name, nextReference, values);
+        }
+    }
+}
+function scopeHookProviderFromCall(expression, scopeHookNames) {
+    return ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && scopeHookNames.has(expression.expression.text)
+        ? expression.expression.text
+        : undefined;
+}
+function reachableJSXDependenciesForComponent(sourceFile, componentName, branchContext, context) {
+    const dependencies = [];
+    const componentBody = getFunctionLikeBody(sourceFile, componentName);
+    if (!componentBody)
+        return dependencies;
+    const helperFunctions = getTopLevelFunctionLikeBodiesForPath(sourceFile, context.entryPath, context.cache);
+    const localComponentNames = helperFunctions;
+    const importBindings = componentDependencyBindingsForFile(sourceFile, context.entryPath, context);
+    const localAliases = localComponentAliasBindingsForBody(componentBody);
+    const always = { kind: "always" };
+    const visitedHelpers = new Set([componentName]);
+    if (ts.isBlock(componentBody)) {
+        for (const statement of componentBody.statements)
+            visitStatement(statement, always, branchContext, visitedHelpers);
+    }
+    else {
+        visitExpression(componentBody, always, branchContext, visitedHelpers);
+    }
+    return dependencies;
+    function visitStatement(statement, condition, currentBranchContext, currentVisitedHelpers) {
+        if (ts.isBlock(statement)) {
+            for (const child of statement.statements)
+                visitStatement(child, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isReturnStatement(statement)) {
+            if (statement.expression)
+                visitExpression(statement.expression, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isIfStatement(statement)) {
+            const predicate = parseJSXBranchPredicate(statement.expression, currentBranchContext);
+            visitStatementOrBlock(statement.thenStatement, andJSXBranchPredicates(condition, predicate), currentBranchContext, currentVisitedHelpers);
+            if (statement.elseStatement) {
+                visitStatementOrBlock(statement.elseStatement, andJSXBranchPredicates(condition, notJSXBranchPredicate(predicate)), currentBranchContext, currentVisitedHelpers);
+            }
+            return;
+        }
+        if (ts.isExpressionStatement(statement)) {
+            visitExpression(statement.expression, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (nodeContainsJSX(statement)) {
+            visitOpaqueJSXSubtree(statement, condition, currentBranchContext, currentVisitedHelpers);
+        }
+    }
+    function visitStatementOrBlock(statement, condition, currentBranchContext, currentVisitedHelpers) {
+        if (ts.isBlock(statement)) {
+            for (const child of statement.statements)
+                visitStatement(child, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        visitStatement(statement, condition, currentBranchContext, currentVisitedHelpers);
+    }
+    function visitExpression(expression, condition, currentBranchContext, currentVisitedHelpers) {
+        const value = unwrapExpression(expression);
+        if (ts.isJsxElement(value)) {
+            visitJSXOpeningLike(value.openingElement, condition, currentBranchContext, currentVisitedHelpers);
+            for (const child of value.children)
+                visitJSXChild(child, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isJsxSelfClosingElement(value)) {
+            visitJSXOpeningLike(value, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isJsxFragment(value)) {
+            for (const child of value.children)
+                visitJSXChild(child, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isConditionalExpression(value)) {
+            const predicate = parseJSXBranchPredicate(value.condition, currentBranchContext);
+            visitExpression(value.whenTrue, andJSXBranchPredicates(condition, predicate), currentBranchContext, currentVisitedHelpers);
+            visitExpression(value.whenFalse, andJSXBranchPredicates(condition, notJSXBranchPredicate(predicate)), currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+            const predicate = parseJSXBranchPredicate(value.left, currentBranchContext);
+            visitExpression(value.right, andJSXBranchPredicates(condition, predicate), currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            const predicate = parseJSXBranchPredicate(value.left, currentBranchContext);
+            visitExpression(value.right, andJSXBranchPredicates(condition, notJSXBranchPredicate(predicate)), currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+            visitFunctionLikeBody(value, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        if (ts.isCallExpression(value) && visitJSXProducingCall(value, condition, currentBranchContext, currentVisitedHelpers)) {
+            return;
+        }
+        ts.forEachChild(value, (child) => {
+            if (isExpressionWithPossibleJSX(child))
+                visitExpression(child, condition, currentBranchContext, currentVisitedHelpers);
+        });
+    }
+    function visitFunctionLikeBody(functionLike, condition, currentBranchContext, currentVisitedHelpers) {
+        if (!functionLike.body)
+            return;
+        if (ts.isBlock(functionLike.body)) {
+            for (const statement of functionLike.body.statements)
+                visitStatement(statement, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        visitExpression(functionLike.body, condition, currentBranchContext, currentVisitedHelpers);
+    }
+    function visitJSXProducingCall(call, condition, currentBranchContext, currentVisitedHelpers) {
+        if (ts.isPropertyAccessExpression(call.expression) && call.expression.name.text === "map") {
+            const callback = call.arguments[0] ? unwrapExpression(call.arguments[0]) : undefined;
+            if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+                const sourceReference = factorReferenceForExpression(call.expression.expression, currentBranchContext);
+                const callbackCondition = sourceReference
+                    ? andJSXBranchPredicates(condition, nonEmptyCollectionPredicate(sourceReference))
+                    : andJSXBranchPredicates(condition, opaqueJSXBranchPredicate(call.expression.expression, currentBranchContext));
+                const callbackContext = sourceReference
+                    ? bindCallbackItemParameter(callback, sourceReference, currentBranchContext)
+                    : cloneJSXBranchAnalysisContext(currentBranchContext);
+                visitFunctionLikeBody(callback, callbackCondition, callbackContext, currentVisitedHelpers);
+                return true;
+            }
+        }
+        if (ts.isIdentifier(call.expression)) {
+            const helper = getFunctionLikeDeclaration(sourceFile, call.expression.text);
+            if (helper?.body && expressionContainsJSX(helper.body) && !currentVisitedHelpers.has(call.expression.text)) {
+                const helperVisited = new Set(currentVisitedHelpers);
+                helperVisited.add(call.expression.text);
+                const helperContext = bindFunctionCallArguments(helper, call.arguments, currentBranchContext);
+                visitFunctionLikeBody(helper, condition, helperContext, helperVisited);
+                return true;
+            }
+        }
+        let handled = false;
+        for (const argument of call.arguments) {
+            if (!expressionContainsJSX(argument))
+                continue;
+            visitExpression(argument, condition, currentBranchContext, currentVisitedHelpers);
+            handled = true;
+        }
+        return handled;
+    }
+    function visitOpaqueJSXSubtree(node, condition, currentBranchContext, currentVisitedHelpers) {
+        const opaqueCondition = andJSXBranchPredicates(condition, {
+            kind: "opaque",
+            reason: "JSX is produced from unsupported statement-level control flow",
+            text: summarizeNodeText(node, currentBranchContext.sourceFile),
+        });
+        visit(node);
+        function visit(current) {
+            if (ts.isJsxElement(current)) {
+                visitJSXOpeningLike(current.openingElement, opaqueCondition, currentBranchContext, currentVisitedHelpers);
+                for (const child of current.children)
+                    visit(child);
+                return;
+            }
+            if (ts.isJsxSelfClosingElement(current)) {
+                visitJSXOpeningLike(current, opaqueCondition, currentBranchContext, currentVisitedHelpers);
+                return;
+            }
+            if (ts.isJsxFragment(current)) {
+                for (const child of current.children)
+                    visit(child);
+                return;
+            }
+            ts.forEachChild(current, visit);
+        }
+    }
+    function visitJSXChild(child, condition, currentBranchContext, currentVisitedHelpers) {
+        if (ts.isJsxText(child))
+            return;
+        if (ts.isJsxExpression(child)) {
+            if (child.expression)
+                visitExpression(child.expression, condition, currentBranchContext, currentVisitedHelpers);
+            return;
+        }
+        visitExpression(child, condition, currentBranchContext, currentVisitedHelpers);
+    }
+    function visitJSXOpeningLike(node, condition, currentBranchContext, currentVisitedHelpers) {
+        const target = componentDependencyTargetForJsxTag(node.tagName, {
+            filePath: context.entryPath,
+            importBindings,
+            localAliases,
+            localComponentNames,
+        });
+        if (target) {
+            dependencies.push({
+                condition,
+                tagName: jsxTagNameText(node.tagName, sourceFile),
+                target,
+            });
+        }
+        visitJSXAttributes(node.attributes, condition, currentBranchContext, currentVisitedHelpers);
+    }
+    function visitJSXAttributes(attributes, condition, currentBranchContext, currentVisitedHelpers) {
+        const itemSource = jsxAttributeFactorReference(attributes, currentBranchContext);
+        for (const property of attributes.properties) {
+            if (!ts.isJsxAttribute(property) || !property.initializer)
+                continue;
+            const initializer = property.initializer;
+            const expression = ts.isJsxExpression(initializer) ? initializer.expression : initializer;
+            if (!expression || !expressionContainsJSX(expression))
+                continue;
+            const value = unwrapExpression(expression);
+            if ((ts.isArrowFunction(value) || ts.isFunctionExpression(value)) && value.parameters.length > 0) {
+                const callbackCondition = itemSource
+                    ? andJSXBranchPredicates(condition, nonEmptyCollectionPredicate(itemSource))
+                    : andJSXBranchPredicates(condition, opaqueJSXBranchPredicate(value, currentBranchContext));
+                const callbackContext = itemSource ? bindCallbackItemParameter(value, itemSource, currentBranchContext) : currentBranchContext;
+                visitFunctionLikeBody(value, callbackCondition, callbackContext, currentVisitedHelpers);
+                continue;
+            }
+            visitExpression(expression, condition, currentBranchContext, currentVisitedHelpers);
+        }
+    }
+}
+function isExpressionWithPossibleJSX(node) {
+    return ts.isExpression(node) && nodeContainsJSX(node);
+}
+function expressionContainsJSX(node) {
+    return nodeContainsJSX(node);
+}
+function nodeContainsJSX(node) {
+    let found = false;
+    visit(node);
+    return found;
+    function visit(current) {
+        if (found)
+            return;
+        if (ts.isJsxElement(current) || ts.isJsxSelfClosingElement(current) || ts.isJsxFragment(current)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(current, visit);
+    }
+}
+function summarizeNodeText(node, sourceFile) {
+    const text = node.getText(sourceFile).replace(/\s+/g, " ").trim();
+    return text.length > 140 ? `${text.slice(0, 137)}...` : text;
+}
+function parseJSXBranchPredicate(expression, context, resolvingAliases = new Set()) {
+    const value = unwrapExpression(expression);
+    if (value.kind === ts.SyntaxKind.TrueKeyword)
+        return { kind: "static", value: true };
+    if (value.kind === ts.SyntaxKind.FalseKeyword)
+        return { kind: "static", value: false };
+    if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.ExclamationToken) {
+        return notJSXBranchPredicate(parseJSXBranchPredicate(value.operand, context, resolvingAliases));
+    }
+    if (ts.isBinaryExpression(value)) {
+        if (value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+            return andJSXBranchPredicates(parseJSXBranchPredicate(value.left, context, resolvingAliases), parseJSXBranchPredicate(value.right, context, resolvingAliases));
+        }
+        if (value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            return orJSXBranchPredicates(parseJSXBranchPredicate(value.left, context, resolvingAliases), parseJSXBranchPredicate(value.right, context, resolvingAliases));
+        }
+        const equalityPredicate = parseBinaryComparisonPredicate(value, context, resolvingAliases);
+        if (equalityPredicate)
+            return equalityPredicate;
+    }
+    if (ts.isCallExpression(value) &&
+        ts.isIdentifier(value.expression) &&
+        value.expression.text === "Boolean" &&
+        value.arguments.length === 1 &&
+        value.arguments[0]) {
+        return parseJSXBranchPredicate(value.arguments[0], context, resolvingAliases);
+    }
+    if (ts.isIdentifier(value)) {
+        const alias = context.expressionAliases.get(value.text);
+        if (alias && !resolvingAliases.has(value.text)) {
+            resolvingAliases.add(value.text);
+            const predicate = parseJSXBranchPredicate(alias, context, resolvingAliases);
+            resolvingAliases.delete(value.text);
+            return predicate;
+        }
+    }
+    const reference = factorReferenceForExpression(value, context);
+    if (reference)
+        return { kind: "truthy", ref: reference };
+    const staticValue = readStaticBranchValue(value);
+    const staticTruthy = staticValue ? staticBranchValueTruthy(staticValue) : undefined;
+    if (staticTruthy !== undefined)
+        return { kind: "static", value: staticTruthy };
+    return {
+        kind: "opaque",
+        reason: "condition is not a direct props/context/scope expression",
+        text: value.getText(context.sourceFile),
+    };
+}
+function parseBinaryComparisonPredicate(expression, context, resolvingAliases) {
+    const leftReference = factorReferenceForExpression(expression.left, context);
+    const rightReference = factorReferenceForExpression(expression.right, context);
+    const leftValue = readStaticBranchValue(expression.left);
+    const rightValue = readStaticBranchValue(expression.right);
+    const equalityOperators = new Set([
+        ts.SyntaxKind.EqualsEqualsEqualsToken,
+        ts.SyntaxKind.EqualsEqualsToken,
+        ts.SyntaxKind.ExclamationEqualsEqualsToken,
+        ts.SyntaxKind.ExclamationEqualsToken,
+    ]);
+    if (equalityOperators.has(expression.operatorToken.kind)) {
+        if (leftReference && rightReference) {
+            const predicate = { kind: "equals-ref", left: leftReference, right: rightReference };
+            return expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+                expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken
+                ? notJSXBranchPredicate(predicate)
+                : predicate;
+        }
+        const reference = leftReference ?? rightReference;
+        const staticValue = leftReference ? rightValue : rightReference ? leftValue : undefined;
+        if (!reference || !staticValue)
+            return undefined;
+        const predicate = { kind: "equals", ref: reference, value: staticValue };
+        return expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+            expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken
+            ? notJSXBranchPredicate(predicate)
+            : predicate;
+    }
+    const relationOperator = relationOperatorText(expression.operatorToken.kind);
+    if (relationOperator) {
+        if (leftReference && rightValue)
+            return { kind: "relation", operator: relationOperator, ref: leftReference, value: rightValue };
+        if (rightReference && leftValue) {
+            const invertedOperator = invertRelationOperator(relationOperator);
+            return { kind: "relation", operator: invertedOperator, ref: rightReference, value: leftValue };
+        }
+    }
+    return undefined;
+}
+function relationOperatorText(kind) {
+    if (kind === ts.SyntaxKind.LessThanToken)
+        return "<";
+    if (kind === ts.SyntaxKind.LessThanEqualsToken)
+        return "<=";
+    if (kind === ts.SyntaxKind.GreaterThanToken)
+        return ">";
+    if (kind === ts.SyntaxKind.GreaterThanEqualsToken)
+        return ">=";
+    return undefined;
+}
+function invertRelationOperator(operator) {
+    if (operator === "<")
+        return ">";
+    if (operator === "<=")
+        return ">=";
+    if (operator === ">")
+        return "<";
+    return "<=";
+}
+function factorReferenceForExpression(expression, context) {
+    const value = unwrapExpression(expression);
+    if (ts.isIdentifier(value)) {
+        const direct = context.factorBindings.get(value.text);
+        if (direct)
+            return direct;
+        const alias = context.expressionAliases.get(value.text);
+        return alias ? factorReferenceForExpression(alias, context) : undefined;
+    }
+    if (ts.isPropertyAccessExpression(value)) {
+        const base = factorReferenceForExpression(value.expression, context);
+        return base ? appendFactorReferencePath(base, value.name.text) : undefined;
+    }
+    if (ts.isElementAccessExpression(value) && ts.isStringLiteralLike(value.argumentExpression)) {
+        const base = factorReferenceForExpression(value.expression, context);
+        return base ? appendFactorReferencePath(base, value.argumentExpression.text) : undefined;
+    }
+    if (ts.isElementAccessExpression(value) && ts.isNumericLiteral(value.argumentExpression)) {
+        const base = factorReferenceForExpression(value.expression, context);
+        return base ? appendFactorReferencePath(base, "number") : undefined;
+    }
+    return undefined;
+}
+function appendFactorReferencePath(reference, propertyName) {
+    if (reference.root === "context") {
+        return { root: "context", providerName: reference.providerName, path: [...reference.path, propertyName] };
+    }
+    return { root: reference.root, path: [...reference.path, propertyName] };
+}
+function andJSXBranchPredicates(left, right) {
+    if (left.kind === "always")
+        return right;
+    if (right.kind === "always")
+        return left;
+    if (left.kind === "static" && left.value)
+        return right;
+    if (right.kind === "static" && right.value)
+        return left;
+    if (left.kind === "static" && !left.value)
+        return left;
+    if (right.kind === "static" && !right.value)
+        return right;
+    return {
+        kind: "and",
+        predicates: [
+            ...(left.kind === "and" ? left.predicates : [left]),
+            ...(right.kind === "and" ? right.predicates : [right]),
+        ],
+    };
+}
+function orJSXBranchPredicates(left, right) {
+    if (left.kind === "static" && left.value)
+        return left;
+    if (right.kind === "static" && right.value)
+        return right;
+    if (left.kind === "static" && !left.value)
+        return right;
+    if (right.kind === "static" && !right.value)
+        return left;
+    return {
+        kind: "or",
+        predicates: [
+            ...(left.kind === "or" ? left.predicates : [left]),
+            ...(right.kind === "or" ? right.predicates : [right]),
+        ],
+    };
+}
+function notJSXBranchPredicate(predicate) {
+    if (predicate.kind === "static")
+        return { kind: "static", value: !predicate.value };
+    if (predicate.kind === "not")
+        return predicate.predicate;
+    return { kind: "not", predicate };
+}
+function firstOpaqueJSXBranchPredicate(predicate) {
+    if (predicate.kind === "opaque")
+        return predicate;
+    if (predicate.kind === "not")
+        return firstOpaqueJSXBranchPredicate(predicate.predicate);
+    if (predicate.kind === "and" || predicate.kind === "or") {
+        for (const child of predicate.predicates) {
+            const opaque = firstOpaqueJSXBranchPredicate(child);
+            if (opaque)
+                return opaque;
+        }
+    }
+    return undefined;
+}
+function evaluateJSXBranchPredicate(predicate, values) {
+    if (predicate.kind === "always")
+        return true;
+    if (predicate.kind === "static")
+        return predicate.value;
+    if (predicate.kind === "opaque")
+        return "unknown";
+    if (predicate.kind === "truthy") {
+        return evaluateStaticBranchValueTruthy(staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" });
+    }
+    if (predicate.kind === "equals") {
+        return evaluateSameStaticBranchValue(staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" }, predicate.value);
+    }
+    if (predicate.kind === "equals-ref") {
+        return evaluateSameStaticBranchValue(staticBranchValueForReference(values, predicate.left) ?? { kind: "undefined" }, staticBranchValueForReference(values, predicate.right) ?? { kind: "undefined" });
+    }
+    if (predicate.kind === "relation") {
+        return evaluateStaticBranchRelation(staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" }, predicate.operator, predicate.value);
+    }
+    if (predicate.kind === "not") {
+        return evaluateNegatedJSXBranchPredicate(predicate.predicate, values);
+    }
+    if (predicate.kind === "and") {
+        let unknown = false;
+        for (const child of predicate.predicates) {
+            const value = evaluateJSXBranchPredicate(child, values);
+            if (value === false)
+                return false;
+            if (value === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : true;
+    }
+    if (predicate.kind === "or") {
+        let unknown = false;
+        for (const child of predicate.predicates) {
+            const value = evaluateJSXBranchPredicate(child, values);
+            if (value === true)
+                return true;
+            if (value === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    return "unknown";
+}
+function evaluateNegatedJSXBranchPredicate(predicate, values) {
+    if (predicate.kind === "truthy") {
+        const value = staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" };
+        if (value.kind === "oneOf") {
+            let unknown = false;
+            for (const option of value.values) {
+                const result = evaluateStaticBranchValueTruthy(option);
+                if (result === false)
+                    return true;
+                if (result === "unknown")
+                    unknown = true;
+            }
+            return unknown ? "unknown" : false;
+        }
+        const truthy = evaluateStaticBranchValueTruthy(value);
+        return truthy === "unknown" ? "unknown" : !truthy;
+    }
+    if (predicate.kind === "equals") {
+        const value = staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" };
+        if (value.kind === "oneOf") {
+            let unknown = false;
+            for (const option of value.values) {
+                const result = evaluateSameStaticBranchValue(option, predicate.value);
+                if (result === false)
+                    return true;
+                if (result === "unknown")
+                    unknown = true;
+            }
+            return unknown ? "unknown" : false;
+        }
+        const result = evaluateSameStaticBranchValue(value, predicate.value);
+        return result === "unknown" ? "unknown" : !result;
+    }
+    if (predicate.kind === "equals-ref") {
+        const left = staticBranchValueForReference(values, predicate.left) ?? { kind: "undefined" };
+        const right = staticBranchValueForReference(values, predicate.right) ?? { kind: "undefined" };
+        if (left.kind === "oneOf") {
+            let unknown = false;
+            for (const option of left.values) {
+                const result = evaluateSameStaticBranchValue(option, right);
+                if (result === false)
+                    return true;
+                if (result === "unknown")
+                    unknown = true;
+            }
+            return unknown ? "unknown" : false;
+        }
+        if (right.kind === "oneOf") {
+            let unknown = false;
+            for (const option of right.values) {
+                const result = evaluateSameStaticBranchValue(left, option);
+                if (result === false)
+                    return true;
+                if (result === "unknown")
+                    unknown = true;
+            }
+            return unknown ? "unknown" : false;
+        }
+        const result = evaluateSameStaticBranchValue(left, right);
+        return result === "unknown" ? "unknown" : !result;
+    }
+    if (predicate.kind === "relation") {
+        const value = staticBranchValueForReference(values, predicate.ref) ?? { kind: "undefined" };
+        if (value.kind === "oneOf") {
+            let unknown = false;
+            for (const option of value.values) {
+                const result = evaluateStaticBranchRelation(option, predicate.operator, predicate.value);
+                if (result === false)
+                    return true;
+                if (result === "unknown")
+                    unknown = true;
+            }
+            return unknown ? "unknown" : false;
+        }
+        const result = evaluateStaticBranchRelation(value, predicate.operator, predicate.value);
+        return result === "unknown" ? "unknown" : !result;
+    }
+    if (predicate.kind === "and")
+        return evaluateJSXBranchPredicate({ kind: "or", predicates: predicate.predicates.map(notJSXBranchPredicate) }, values);
+    if (predicate.kind === "or")
+        return evaluateJSXBranchPredicate({ kind: "and", predicates: predicate.predicates.map(notJSXBranchPredicate) }, values);
+    const value = evaluateJSXBranchPredicate(predicate, values);
+    return value === "unknown" ? "unknown" : !value;
+}
+function staticBranchValueForReference(values, reference) {
+    const key = factorReferenceKey(reference);
+    const exact = values.get(key);
+    if (exact)
+        return exact;
+    const parts = key.split(".");
+    while (parts.length > 1) {
+        parts.pop();
+        const ancestor = values.get(parts.join("."));
+        if (ancestor && staticBranchValueIncludesUnknown(ancestor))
+            return { kind: "unknown" };
+    }
+    return undefined;
+}
+function staticBranchValueIncludesUnknown(value) {
+    return value.kind === "unknown" || (value.kind === "oneOf" && value.values.some(staticBranchValueIncludesUnknown));
+}
+function evaluateStaticBranchValueTruthy(value) {
+    if (value.kind === "unknown")
+        return "unknown";
+    if (value.kind === "oneOf") {
+        let unknown = false;
+        for (const option of value.values) {
+            const result = evaluateStaticBranchValueTruthy(option);
+            if (result === true)
+                return true;
+            if (result === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    return staticBranchValueTruthy(value);
+}
+function evaluateSameStaticBranchValue(left, right) {
+    if (left.kind === "unknown" || right.kind === "unknown")
+        return "unknown";
+    if (left.kind === "oneOf") {
+        let unknown = false;
+        for (const option of left.values) {
+            const result = evaluateSameStaticBranchValue(option, right);
+            if (result === true)
+                return true;
+            if (result === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    if (right.kind === "oneOf") {
+        let unknown = false;
+        for (const option of right.values) {
+            const result = evaluateSameStaticBranchValue(left, option);
+            if (result === true)
+                return true;
+            if (result === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    return sameStaticBranchValue(left, right);
+}
+function staticBranchValueTruthy(value) {
+    if (value.kind === "unknown")
+        return false;
+    if (value.kind === "oneOf")
+        return value.values.some(staticBranchValueTruthy);
+    if (value.kind === "undefined" || value.kind === "null")
+        return false;
+    if (value.kind === "boolean")
+        return value.value;
+    if (value.kind === "number")
+        return value.value !== 0 && !Number.isNaN(value.value);
+    if (value.kind === "string")
+        return value.value.length > 0;
+    if (value.kind === "array" || value.kind === "object" || value.kind === "truthy")
+        return true;
+    return false;
+}
+function sameStaticBranchValue(left, right) {
+    if (left.kind === "oneOf")
+        return left.values.some((value) => sameStaticBranchValue(value, right));
+    if (right.kind === "oneOf")
+        return right.values.some((value) => sameStaticBranchValue(left, value));
+    if (left.kind === "undefined" && right.kind === "undefined")
+        return true;
+    if (left.kind === "null" && right.kind === "null")
+        return true;
+    if (left.kind === "boolean" && right.kind === "boolean")
+        return left.value === right.value;
+    if (left.kind === "number" && right.kind === "number")
+        return left.value === right.value;
+    if (left.kind === "string" && right.kind === "string")
+        return left.value === right.value;
+    if (left.kind === "array" && right.kind === "array")
+        return left.length === right.length;
+    return false;
+}
+function evaluateStaticBranchRelation(left, operator, right) {
+    if (left.kind === "unknown" || right.kind === "unknown")
+        return "unknown";
+    if (left.kind === "oneOf") {
+        let unknown = false;
+        for (const value of left.values) {
+            const result = evaluateStaticBranchRelation(value, operator, right);
+            if (result === true)
+                return true;
+            if (result === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    if (right.kind === "oneOf") {
+        let unknown = false;
+        for (const value of right.values) {
+            const result = evaluateStaticBranchRelation(left, operator, value);
+            if (result === true)
+                return true;
+            if (result === "unknown")
+                unknown = true;
+        }
+        return unknown ? "unknown" : false;
+    }
+    const leftNumber = staticBranchValueNumber(left);
+    const rightNumber = staticBranchValueNumber(right);
+    if (leftNumber === undefined || rightNumber === undefined)
+        return "unknown";
+    if (operator === "<")
+        return leftNumber < rightNumber;
+    if (operator === "<=")
+        return leftNumber <= rightNumber;
+    if (operator === ">")
+        return leftNumber > rightNumber;
+    return leftNumber >= rightNumber;
+}
+function staticBranchValueNumber(value) {
+    if (value.kind === "number")
+        return value.value;
+    if (value.kind === "array")
+        return value.length;
+    return undefined;
+}
+function factorReferenceKey(reference) {
+    if (reference.root === "context")
+        return ["context", reference.providerName, ...reference.path].join(".");
+    return [reference.root, ...reference.path].join(".");
+}
+function formatJSXBranchPredicate(predicate) {
+    if (predicate.kind === "always")
+        return "always";
+    if (predicate.kind === "static")
+        return String(predicate.value);
+    if (predicate.kind === "truthy")
+        return factorReferenceKey(predicate.ref);
+    if (predicate.kind === "equals")
+        return `${factorReferenceKey(predicate.ref)} === ${formatStaticBranchValue(predicate.value)}`;
+    if (predicate.kind === "equals-ref")
+        return `${factorReferenceKey(predicate.left)} === ${factorReferenceKey(predicate.right)}`;
+    if (predicate.kind === "relation") {
+        return `${factorReferenceKey(predicate.ref)} ${predicate.operator} ${formatStaticBranchValue(predicate.value)}`;
+    }
+    if (predicate.kind === "not")
+        return `!(${formatJSXBranchPredicate(predicate.predicate)})`;
+    if (predicate.kind === "and")
+        return predicate.predicates.map(formatJSXBranchPredicate).join(" && ");
+    if (predicate.kind === "or")
+        return predicate.predicates.map(formatJSXBranchPredicate).join(" || ");
+    return predicate.text;
+}
+function formatStaticBranchValue(value) {
+    if (value.kind === "boolean")
+        return String(value.value);
+    if (value.kind === "number")
+        return String(value.value);
+    if (value.kind === "string")
+        return JSON.stringify(value.value);
+    if (value.kind === "array")
+        return `array(length=${value.length})`;
+    if (value.kind === "oneOf")
+        return `oneOf(${value.values.map(formatStaticBranchValue).join(", ")})`;
+    return value.kind;
+}
+function jsxTagNameText(tagName, sourceFile) {
+    if (ts.isIdentifier(tagName))
+        return tagName.text;
+    return tagName.getText(sourceFile);
+}
+function getNonGTSXHookCalls(sourceFile, componentName, scopeHookNames, context) {
+    const violations = new Map();
+    visitComponent(sourceFile, context.entryPath, componentName);
+    return [...violations.values()];
+    function visitComponent(currentSourceFile, currentPath, currentComponentName) {
+        const componentKey = `${currentPath}#${currentComponentName}`;
+        if (context.visitedComponents.has(componentKey))
+            return;
+        context.visitedComponents.add(componentKey);
+        const componentBody = getFunctionLikeBody(currentSourceFile, currentComponentName);
+        if (!componentBody)
+            return;
+        const currentScopeHookNames = currentPath === context.entryPath
+            ? scopeHookNames
+            : new Set([
+                ...getScopeHookNames(currentSourceFile),
+                ...getImportedScopeHookNames(currentSourceFile, currentPath, context.cwd, context.cache),
+            ]);
+        const helperFunctions = getTopLevelFunctionLikeBodiesForPath(currentSourceFile, currentPath, context.cache);
+        const visitedHelpers = new Set([currentComponentName]);
+        const localComponentNames = helperFunctions;
+        const importBindings = componentDependencyBindingsForFile(currentSourceFile, currentPath, context);
+        const file = normalizeProjectPath(relative(context.cwd, currentPath));
+        visit(componentBody, localComponentAliasBindingsForBody(componentBody));
+        function visit(node, localAliases) {
+            if (ts.isCallExpression(node)) {
+                const hookName = getHookCallName(node, currentSourceFile);
+                if (hookName) {
+                    if (!isAllowedGTSXHookCall(node, hookName, currentScopeHookNames)) {
+                        const key = `${file}#${currentComponentName}:${hookName}`;
+                        violations.set(key, { hookName, componentName: currentComponentName, file });
+                    }
+                }
+                else if (ts.isIdentifier(node.expression)) {
+                    visitHelper(node.expression.text);
+                }
+            }
+            if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+                visitJSXDependency(node.tagName, localAliases);
+            }
+            ts.forEachChild(node, (child) => visit(child, localAliases));
+        }
+        function visitHelper(functionName) {
+            if (visitedHelpers.has(functionName))
+                return;
+            const helperBody = helperFunctions.get(functionName);
+            if (!helperBody)
+                return;
+            visitedHelpers.add(functionName);
+            visit(helperBody, localComponentAliasBindingsForBody(helperBody));
+        }
+        function visitJSXDependency(tagName, localAliases) {
+            const target = componentDependencyTargetForJsxTag(tagName, {
+                filePath: currentPath,
+                importBindings,
+                localAliases,
+                localComponentNames,
+            });
+            if (!target)
+                return;
+            const targetSourceFile = sourceFileForPath(target.filePath, context);
+            if (!targetSourceFile)
+                return;
+            visitComponent(targetSourceFile, target.filePath, target.componentName);
+        }
+    }
+}
+function getGProviderConsumers(sourceFile, componentName, context) {
+    const providers = new Set();
+    visitComponent(sourceFile, context.entryPath, componentName);
+    return providers;
+    function visitComponent(currentSourceFile, currentPath, currentComponentName) {
+        const componentKey = `${currentPath}#${currentComponentName}`;
+        if (context.visitedComponents.has(componentKey))
+            return;
+        context.visitedComponents.add(componentKey);
+        const componentBody = getFunctionLikeBody(currentSourceFile, currentComponentName);
+        if (!componentBody)
+            return;
+        const scopeHookProviderNames = getScopeHookProviderNamesForFile(currentSourceFile, currentPath, context.cache);
+        const helperFunctions = getTopLevelFunctionLikeBodiesForPath(currentSourceFile, currentPath, context.cache);
+        const visitedHelpers = new Set([currentComponentName]);
+        const localComponentNames = helperFunctions;
+        const importBindings = componentDependencyBindingsForFile(currentSourceFile, currentPath, context);
+        visit(componentBody, localComponentAliasBindingsForBody(componentBody));
+        function visit(node, localAliases) {
+            if (ts.isCallExpression(node)) {
+                const contextProvider = gContextProviderNameFromCall(node);
+                if (contextProvider) {
+                    providers.add(contextProvider);
+                }
+                else if (ts.isIdentifier(node.expression) && scopeHookProviderNames.has(node.expression.text)) {
+                    for (const providerName of scopeHookProviderNames.get(node.expression.text) ?? [])
+                        providers.add(providerName);
+                }
+                else if (ts.isIdentifier(node.expression) && !isHookName(node.expression.text)) {
+                    visitHelper(node.expression.text);
+                }
+            }
+            if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+                visitJSXDependency(node.tagName, localAliases);
+            }
+            ts.forEachChild(node, (child) => visit(child, localAliases));
+        }
+        function visitHelper(functionName) {
+            if (visitedHelpers.has(functionName))
+                return;
+            const helperBody = helperFunctions.get(functionName);
+            if (!helperBody)
+                return;
+            visitedHelpers.add(functionName);
+            visit(helperBody, localComponentAliasBindingsForBody(helperBody));
+        }
+        function visitJSXDependency(tagName, localAliases) {
+            const target = componentDependencyTargetForJsxTag(tagName, {
+                filePath: currentPath,
+                importBindings,
+                localAliases,
+                localComponentNames,
+            });
+            if (!target)
+                return;
+            const targetSourceFile = sourceFileForPath(target.filePath, context);
+            if (!targetSourceFile)
+                return;
+            visitComponent(targetSourceFile, target.filePath, target.componentName);
+        }
+    }
+}
+function gContextProviderNameFromCall(node) {
+    if (!ts.isIdentifier(node.expression))
+        return undefined;
+    if (node.expression.text !== "useGContext" && node.expression.text !== "useGContextUpdate")
+        return undefined;
+    const provider = node.arguments[0] ? unwrapExpression(node.arguments[0]) : undefined;
+    return provider && ts.isIdentifier(provider) ? provider.text : undefined;
+}
+function localComponentAliasBindingsForBody(body) {
+    const aliases = new Map();
+    if (!ts.isBlock(body))
+        return aliases;
+    for (const statement of body.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+                continue;
+            const initializer = unwrapExpression(declaration.initializer);
+            if (ts.isIdentifier(initializer)) {
+                aliases.set(declaration.name.text, initializer.text);
+            }
+        }
+    }
+    return aliases;
+}
+function getFunctionLikeBody(sourceFile, functionName) {
+    return getFunctionLikeDeclaration(sourceFile, functionName)?.body;
+}
+function getFunctionLikeDeclaration(sourceFile, functionName) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name?.text === functionName) {
+            return statement;
+        }
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== functionName || !declaration.initializer)
+                continue;
+            const initializer = unwrapExpression(declaration.initializer);
+            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+                return initializer;
+            }
+        }
+    }
+    return undefined;
+}
+function getTopLevelFunctionLikeBodies(sourceFile) {
+    const functions = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name && statement.body) {
+            functions.set(statement.name.text, statement.body);
+            continue;
+        }
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+                continue;
+            const initializer = unwrapExpression(declaration.initializer);
+            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+                functions.set(declaration.name.text, initializer.body);
+            }
+        }
+    }
+    return functions;
+}
+function getTopLevelFunctionLikeBodiesForPath(sourceFile, filePath, cache) {
+    const cached = cache?.topLevelFunctionLikeBodiesByPath.get(filePath);
+    if (cached)
+        return cached;
+    const functions = getTopLevelFunctionLikeBodies(sourceFile);
+    cache?.topLevelFunctionLikeBodiesByPath.set(filePath, functions);
+    return functions;
+}
+function componentDependencyBindingsForFile(sourceFile, filePath, context) {
+    const cached = context.cache?.componentDependencyBindingsByPath.get(filePath);
+    if (cached)
+        return cached;
+    const bindings = {
+        names: new Map(),
+        namespaces: new Map(),
+    };
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause)
+            continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const targetPath = resolveImportedGTSXPath(filePath, context.cwd, statement.moduleSpecifier.text, context.cache);
+        if (!targetPath)
+            continue;
+        const targetSourceFile = sourceFileForPath(targetPath, context);
+        if (!targetSourceFile)
+            continue;
+        const importClause = statement.importClause;
+        if (importClause.name) {
+            const componentName = getComponentExportName(targetSourceFile, "default");
+            if (componentName) {
+                bindings.names.set(importClause.name.text, { filePath: targetPath, componentName });
+            }
+        }
+        if (!importClause.namedBindings)
+            continue;
+        if (ts.isNamedImports(importClause.namedBindings)) {
+            for (const element of importClause.namedBindings.elements) {
+                const importedName = element.propertyName?.text ?? element.name.text;
+                const componentName = getComponentExportName(targetSourceFile, importedName);
+                if (componentName) {
+                    bindings.names.set(element.name.text, { filePath: targetPath, componentName });
+                }
+            }
+        }
+        else if (ts.isNamespaceImport(importClause.namedBindings)) {
+            const namespaceExports = exportedComponentTargetsForFile(targetSourceFile, targetPath, context.cache);
+            if (namespaceExports.size > 0) {
+                bindings.namespaces.set(importClause.namedBindings.name.text, namespaceExports);
+            }
+        }
+    }
+    context.cache?.componentDependencyBindingsByPath.set(filePath, bindings);
+    return bindings;
+}
+function sourceFileForPath(filePath, context) {
+    const cached = context.sourceFilesByPath.get(filePath);
+    if (cached)
+        return cached;
+    const sourceFile = sourceFileForAbsolutePath(filePath, context.cache);
+    if (!sourceFile)
+        return undefined;
+    context.sourceFilesByPath.set(filePath, sourceFile);
+    return sourceFile;
+}
+function sourceFileForAbsolutePath(filePath, cache) {
+    const cached = cache?.sourceFilesByPath.get(filePath);
+    if (cached)
+        return cached;
+    if (!isFile(filePath))
+        return undefined;
+    const sourceFile = ts.createSourceFile(filePath, readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    cache?.sourceFilesByPath.set(filePath, sourceFile);
+    return sourceFile;
+}
+function exportedComponentTargetsForFile(sourceFile, filePath, cache) {
+    const cached = cache?.exportedComponentTargetsByPath.get(filePath);
+    if (cached)
+        return cached;
+    const targets = new Map();
+    const defaultName = getComponentExportName(sourceFile, "default");
+    if (defaultName) {
+        targets.set("default", { filePath, componentName: defaultName });
+    }
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+            if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+                targets.set(statement.name.text, { filePath, componentName: statement.name.text });
+            }
+            continue;
+        }
+        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && getFunctionLikeBody(sourceFile, declaration.name.text)) {
+                    targets.set(declaration.name.text, { filePath, componentName: declaration.name.text });
+                }
+            }
+            continue;
+        }
+        if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            const localName = element.propertyName?.text ?? element.name.text;
+            if (getFunctionLikeBody(sourceFile, localName)) {
+                targets.set(element.name.text, { filePath, componentName: localName });
+            }
+        }
+    }
+    cache?.exportedComponentTargetsByPath.set(filePath, targets);
+    return targets;
+}
+function componentDependencyTargetForJsxTag(tagName, input) {
+    if (ts.isIdentifier(tagName)) {
+        return componentDependencyTargetForIdentifier(tagName.text, input);
+    }
+    if (ts.isPropertyAccessExpression(tagName) && ts.isIdentifier(tagName.expression)) {
+        return input.importBindings.namespaces.get(tagName.expression.text)?.get(tagName.name.text);
+    }
+    return undefined;
+}
+function componentDependencyTargetForIdentifier(name, input) {
+    if (!isComponentName(name))
+        return undefined;
+    let currentName = name;
+    const visited = new Set();
+    while (!visited.has(currentName)) {
+        visited.add(currentName);
+        const aliasTarget = input.localAliases?.get(currentName);
+        if (aliasTarget) {
+            currentName = aliasTarget;
+            continue;
+        }
+        if (input.localComponentNames?.has(currentName)) {
+            return { filePath: input.filePath, componentName: currentName };
+        }
+        const importTarget = input.importBindings.names.get(currentName);
+        if (importTarget)
+            return importTarget;
+        return undefined;
+    }
+    return undefined;
+}
+function getHookCallName(node, sourceFile) {
+    if (ts.isIdentifier(node.expression) && isHookName(node.expression.text)) {
+        return node.expression.text;
+    }
+    if (ts.isPropertyAccessExpression(node.expression) && isHookName(node.expression.name.text)) {
+        return node.expression.getText(sourceFile);
+    }
+    return undefined;
+}
+function isAllowedGTSXHookCall(node, hookName, scopeHookNames) {
+    if (ts.isIdentifier(node.expression)) {
+        return hookName === "useGContext" || hookName === "useGContextUpdate" || scopeHookNames.has(hookName);
+    }
+    if (ts.isPropertyAccessExpression(node.expression)) {
+        return node.expression.name.text === "useUpdate";
+    }
+    return false;
+}
+function getGScopeHookCalls(sourceFile, componentName, scopeHookNames) {
+    const component = getFunctionDeclaration(sourceFile, componentName);
+    if (!component?.body)
+        return [];
+    const helperFunctions = getTopLevelFunctionDeclarations(sourceFile);
+    const visitedHelpers = new Set([componentName]);
+    const hookNames = new Set();
+    visit(component.body);
+    return [...hookNames];
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            if (scopeHookNames.has(node.expression.text)) {
+                hookNames.add(node.expression.text);
+            }
+            else if (!isHookName(node.expression.text)) {
+                visitHelper(node.expression.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    function visitHelper(functionName) {
+        if (visitedHelpers.has(functionName))
+            return;
+        const helper = helperFunctions.get(functionName);
+        if (!helper?.body)
+            return;
+        visitedHelpers.add(functionName);
+        visit(helper.body);
+    }
+}
+function getFunctionDeclaration(sourceFile, functionName) {
+    return sourceFile.statements.find((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === functionName);
+}
+function getTopLevelFunctionDeclarations(sourceFile) {
+    const functions = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name) {
+            functions.set(statement.name.text, statement);
+        }
+    }
+    return functions;
+}
+function isHookName(name) {
+    return name === "use" || /^use[A-Z0-9_]/.test(name);
+}
+function isComponentName(name) {
+    return /^[A-Z]/.test(name);
+}
+function jsxTagIdentifier(tagName) {
+    if (ts.isIdentifier(tagName))
+        return tagName.text;
+    return undefined;
+}
+function getCasesAssignment(statement, sourceFile, diagnostics) {
+    if (!ts.isExpressionStatement(statement))
+        return undefined;
+    const expression = statement.expression;
+    if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+        return undefined;
+    }
+    if (!ts.isPropertyAccessExpression(expression.left) || expression.left.name.text !== "cases") {
+        return undefined;
+    }
+    if (!ts.isIdentifier(expression.left.expression))
+        return undefined;
+    const casesExpression = unwrapExpression(expression.right);
+    if (!ts.isObjectLiteralExpression(casesExpression)) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            code: "malformed-cases",
+            message: "GTSX cases must be a statically enumerable object literal.",
+            file: sourceFile.fileName,
+        });
+        return { targetName: expression.left.expression.text, cases: [], staticCases: [] };
+    }
+    return {
+        targetName: expression.left.expression.text,
+        ...readCasesObject(casesExpression, sourceFile, diagnostics),
+    };
+}
+function readCasesObject(objectLiteral, sourceFile, diagnostics) {
+    const cases = [];
+    const staticCases = [];
+    for (const property of objectLiteral.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "malformed-cases",
+                message: "GTSX cases do not support spread composition in the first implementation.",
+                file: sourceFile.fileName,
+            });
+            continue;
+        }
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const caseName = getStaticPropertyName(property.name);
+        if (!caseName) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                code: "non-static-case-key",
+                message: "GTSX case keys must be statically enumerable object literal keys.",
+                file: sourceFile.fileName,
+            });
+            continue;
+        }
+        const providerVariants = readProviderVariantMarkers(property.initializer);
+        const caseValue = unwrapExpression(property.initializer);
+        const providers = ts.isObjectLiteralExpression(caseValue) ? readProviderSelections(caseValue) : undefined;
+        const kind = ts.isObjectLiteralExpression(caseValue) && hasStaticProperty(caseValue, "scope") ? "scope" : "pure";
+        cases.push({
+            kind,
+            name: caseName,
+            ...(providerVariants && Object.keys(providerVariants).length > 0 ? { providerVariants } : {}),
+            ...(providers && Object.keys(providers).length > 0 ? { providers } : {}),
+        });
+        staticCases.push(readCaseStaticFacts(caseName, caseValue, providerVariants));
+    }
+    return { cases, staticCases };
+}
+function readProviderVariantMarkers(expression) {
+    if (ts.isSatisfiesExpression(expression))
+        return readProviderVariantMarkersFromType(expression.type);
+    if (ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression))
+        return readProviderVariantMarkers(expression.expression);
+    return undefined;
+}
+function readCaseStaticFacts(caseName, caseValue, providerVariants) {
+    const values = new Map();
+    if (ts.isObjectLiteralExpression(caseValue)) {
+        const props = objectLiteralPropertyExpression(caseValue, "props");
+        if (props)
+            flattenStaticObjectExpression(props, "props", values);
+        const scope = objectLiteralPropertyExpression(caseValue, "scope");
+        if (scope)
+            flattenStaticObjectExpression(scope, "scope", values);
+        const providers = objectLiteralPropertyExpression(caseValue, "providers");
+        if (providers)
+            flattenProviderStaticValues(providers, values);
+    }
+    for (const [providerName, selection] of Object.entries(providerVariants ?? {})) {
+        const variants = providerVariantSelectionValues(selection);
+        values.set(`context.${providerName}.variant`, variants.length === 1
+            ? { kind: "string", value: variants[0] }
+            : { kind: "oneOf", values: variants.map((variant) => ({ kind: "string", value: variant })) });
+    }
+    return {
+        name: caseName,
+        ...(providerVariants && Object.keys(providerVariants).length > 0 ? { providerVariants } : {}),
+        values,
+    };
+}
+function objectLiteralPropertyExpression(objectLiteral, propertyName) {
+    const property = objectLiteral.properties.find((candidate) => ts.isPropertyAssignment(candidate) && getStaticPropertyName(candidate.name) === propertyName);
+    return property ? unwrapExpression(property.initializer) : undefined;
+}
+function flattenProviderStaticValues(expression, values) {
+    const providersValue = unwrapExpression(expression);
+    if (!ts.isArrayLiteralExpression(providersValue))
+        return;
+    for (const element of providersValue.elements) {
+        const entry = unwrapExpression(element);
+        if (!ts.isArrayLiteralExpression(entry))
+            continue;
+        const providerExpression = entry.elements[0] ? unwrapExpression(entry.elements[0]) : undefined;
+        const valueExpression = entry.elements[1] ? unwrapExpression(entry.elements[1]) : undefined;
+        if (!providerExpression || !ts.isIdentifier(providerExpression) || !valueExpression)
+            continue;
+        flattenStaticObjectExpression(valueExpression, `context.${providerExpression.text}`, values);
+    }
+}
+function flattenStaticObjectExpression(expression, prefix, values) {
+    const value = unwrapExpression(expression);
+    const staticValue = readStaticBranchValue(value);
+    if (staticValue) {
+        setStaticBranchValue(values, prefix, staticValue);
+        if (staticValue.kind === "array")
+            setStaticBranchValue(values, `${prefix}.length`, { kind: "number", value: staticValue.length });
+        if (staticValue.kind === "string")
+            setStaticBranchValue(values, `${prefix}.length`, { kind: "number", value: staticValue.value.length });
+    }
+    if (ts.isArrayLiteralExpression(value)) {
+        for (const element of value.elements) {
+            if (ts.isSpreadElement(element)) {
+                setStaticBranchValue(values, `${prefix}.number`, { kind: "unknown" });
+                continue;
+            }
+            flattenStaticObjectExpression(element, `${prefix}.number`, values);
+        }
+        return;
+    }
+    if (!ts.isObjectLiteralExpression(value)) {
+        if (!staticValue)
+            setStaticBranchValue(values, prefix, { kind: "unknown" });
+        return;
+    }
+    for (const property of value.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            setStaticBranchValue(values, prefix, { kind: "unknown" });
+            continue;
+        }
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const propertyName = getStaticPropertyName(property.name);
+        if (!propertyName)
+            continue;
+        flattenStaticObjectExpression(property.initializer, `${prefix}.${propertyName}`, values);
+    }
+}
+function setStaticBranchValue(values, key, value) {
+    const existing = values.get(key);
+    if (!existing) {
+        values.set(key, value);
+        return;
+    }
+    if (sameStaticBranchValue(existing, value))
+        return;
+    values.set(key, { kind: "oneOf", values: [...staticBranchValueOptions(existing), value] });
+}
+function staticBranchValueOptions(value) {
+    return value.kind === "oneOf" ? value.values : [value];
+}
+function readStaticBranchValue(expression) {
+    const value = unwrapExpression(expression);
+    if (value.kind === ts.SyntaxKind.TrueKeyword)
+        return { kind: "boolean", value: true };
+    if (value.kind === ts.SyntaxKind.FalseKeyword)
+        return { kind: "boolean", value: false };
+    if (value.kind === ts.SyntaxKind.NullKeyword)
+        return { kind: "null" };
+    if (ts.isIdentifier(value) && value.text === "undefined")
+        return { kind: "undefined" };
+    if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value))
+        return { kind: "string", value: value.text };
+    if (ts.isNumericLiteral(value))
+        return { kind: "number", value: Number(value.text) };
+    if (ts.isArrayLiteralExpression(value)) {
+        if (value.elements.some((element) => ts.isSpreadElement(element)))
+            return undefined;
+        return { kind: "array", length: value.elements.length };
+    }
+    if (ts.isObjectLiteralExpression(value))
+        return { kind: "object" };
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
+        return { kind: "truthy" };
+    if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.ExclamationToken) {
+        const inner = readStaticBranchValue(value.operand);
+        const truthy = inner ? staticBranchValueTruthy(inner) : undefined;
+        return truthy === undefined ? undefined : { kind: "boolean", value: !truthy };
+    }
+    return undefined;
+}
+function readProviderVariantMarkersFromType(typeNode) {
+    const variants = new Map();
+    visit(typeNode);
+    return Object.fromEntries([...variants.entries()].map(([providerName, providerVariants]) => {
+        const values = [...providerVariants];
+        return [providerName, values.length === 1 ? values[0] : values];
+    }));
+    function visit(node) {
+        if (ts.isIntersectionTypeNode(node) || ts.isUnionTypeNode(node)) {
+            for (const child of node.types)
+                visit(child);
+            return;
+        }
+        if (ts.isParenthesizedTypeNode(node)) {
+            visit(node.type);
+            return;
+        }
+        if (!ts.isTypeReferenceNode(node))
+            return;
+        if (!ts.isIdentifier(node.typeName) || node.typeName.text !== "GProviderCase")
+            return;
+        const providerType = node.typeArguments?.[0];
+        const variantType = node.typeArguments?.[1];
+        if (!providerType || !variantType || !ts.isTypeQueryNode(providerType))
+            return;
+        if (!ts.isIdentifier(providerType.exprName))
+            return;
+        const providerVariants = readProviderVariantTypeValues(variantType);
+        if (providerVariants.length === 0)
+            return;
+        const providerName = providerType.exprName.text;
+        const current = variants.get(providerName) ?? new Set();
+        for (const variant of providerVariants)
+            current.add(variant);
+        variants.set(providerName, current);
+    }
+}
+function readProviderVariantTypeValues(typeNode) {
+    if (ts.isParenthesizedTypeNode(typeNode))
+        return readProviderVariantTypeValues(typeNode.type);
+    if (ts.isUnionTypeNode(typeNode))
+        return typeNode.types.flatMap(readProviderVariantTypeValues);
+    if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal))
+        return [typeNode.literal.text];
+    return [];
+}
+function readProviderSelections(caseValue) {
+    const providersProperty = caseValue.properties.find((property) => ts.isPropertyAssignment(property) && getStaticPropertyName(property.name) === "providers");
+    if (!providersProperty)
+        return undefined;
+    const providersValue = unwrapExpression(providersProperty.initializer);
     if (!ts.isArrayLiteralExpression(providersValue))
         return undefined;
     const providers = [];
@@ -394,4 +2473,7 @@ function hasStaticProperty(objectLiteral, propertyName) {
 function hasModifier(node, kind) {
     return Boolean(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === kind));
 }
+function normalizeProjectPath(filePath) {
+    return filePath.split(sep).join("/");
+}
 //# sourceMappingURL=analyzer.js.map