@runelight/react 0.0.9

package/dist/contract-analyzer.js

@@ -0,0 +1,2918 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import ts from "typescript";
+export function createRunelightReactAnalysisCache() {
+    return createRunelightReactAnalysisCacheData();
+}
+export function createRunelightReactAnalysisCacheData(sourceFilesByPath = new Map()) {
+    return {
+        componentDependencyBindingsByPath: new Map(),
+        exportedStaticValuesByPath: new Map(),
+        exportedComponentTargetsByPath: new Map(),
+        importedRunelightPathByKey: new Map(),
+        importedStaticSourcePathByKey: new Map(),
+        importedScopeHookNamesByPath: new Map(),
+        providerSummariesByPath: new Map(),
+        scopeHookProviderNamesByPath: new Map(),
+        sourceFilesByPath,
+        topLevelFunctionLikeBodiesByPath: new Map(),
+    };
+}
+export function readRunelightReactAnalysisCacheData(cache) {
+    return cache;
+}
+export function analyzeEntry(options) {
+    const entryCoordinate = parseEntryCoordinate(options.entry);
+    const entryPath = resolve(options.cwd, entryCoordinate.file);
+    const cache = readRunelightReactAnalysisCacheData(options.cache);
+    const diagnostics = [];
+    if (!existsSync(entryPath)) {
+        return {
+            entry: options.entry,
+            mode: "unknown",
+            defaultExport: false,
+            frames: [],
+            providers: {},
+            diagnostics: [
+                {
+                    stage: "contract-extraction",
+                    severity: "error",
+                    code: "entry-not-found",
+                    message: `Runelight entry does not exist: ${options.entry}`,
+                    file: options.entry,
+                },
+            ],
+        };
+    }
+    const sourceFile = sourceFileForAbsolutePath(entryPath, cache);
+    if (!sourceFile) {
+        return {
+            entry: options.entry,
+            mode: "unknown",
+            defaultExport: false,
+            frames: [],
+            providers: {},
+            diagnostics: [
+                {
+                    stage: "contract-extraction",
+                    severity: "error",
+                    code: "entry-not-found",
+                    message: `Runelight entry does not exist: ${options.entry}`,
+                    file: options.entry,
+                },
+            ],
+        };
+    }
+    const componentExportName = getComponentExportName(sourceFile, entryCoordinate.exportName);
+    const scopeHookNames = new Set([
+        ...getScopeHookNames(sourceFile),
+        ...getImportedScopeHookNames(sourceFile, entryPath, options.cwd, cache),
+    ]);
+    const providerFrames = Object.fromEntries(getGProviderSummariesForFile(sourceFile, entryPath, options.cwd, cache));
+    const componentAssignments = [];
+    const scopeAssignments = [];
+    for (const statement of sourceFile.statements) {
+        const assignment = getFramesAssignment(statement, sourceFile, diagnostics);
+        if (!assignment)
+            continue;
+        if (scopeHookNames.has(assignment.targetName)) {
+            scopeAssignments.push(assignment);
+        }
+        else if (!componentExportName || assignment.targetName === componentExportName) {
+            componentAssignments.push(assignment);
+        }
+    }
+    if (!componentExportName) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: entryCoordinate.explicitExportName && entryCoordinate.exportName === "default"
+                ? "missing-default-export"
+                : "missing-component-export",
+            message: entryCoordinate.explicitExportName && entryCoordinate.exportName === "default"
+                ? "A .g.tsx entry must have a default React component export."
+                : entryCoordinate.explicitExportName
+                    ? `A .g.tsx entry must export component "${entryCoordinate.exportName}".`
+                    : "A .g.tsx entry must export at least one React component.",
+            file: options.entry,
+        });
+    }
+    else {
+        validateFramesAssignmentOrder(sourceFile, componentExportName, componentAssignments, diagnostics, options.entry);
+        const usedScopeHooks = getGScopeHookCalls(sourceFile, componentExportName, scopeHookNames);
+        if (usedScopeHooks.length > 1) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "multiple-scope-hooks",
+                message: "A stateful Runelight component may have exactly one primary GScope hook.",
+                file: options.entry,
+            });
+        }
+        for (const violation of getNonRunelightHookCalls(sourceFile, componentExportName, scopeHookNames, {
+            cwd: options.cwd,
+            entryPath,
+            cache,
+            sourceFilesByPath: cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        })) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "non-runelight-hook",
+                message: violation.file === normalizeProjectPath(relative(options.cwd, entryPath))
+                    ? `Runelight components may only call Runelight hooks; found "${violation.hookName}" in "${violation.componentName}". Wrap production hooks with createGScopeHook(...).`
+                    : `Runelight components may only call Runelight hooks; found "${violation.hookName}" in dependency "${violation.file}#${violation.componentName}". Wrap production hooks with createGScopeHook(...).`,
+                file: violation.file,
+            });
+        }
+    }
+    if (scopeAssignments.length > 1) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "multiple-scope-hooks",
+            message: "A non-pure Runelight entry may have exactly one primary scope hook with frames.",
+            file: options.entry,
+        });
+    }
+    if (scopeAssignments.length > 0) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "scope-hook-frames-unsupported",
+            message: "GScope hooks do not own frames; move frames to the exported component.",
+            file: options.entry,
+        });
+    }
+    const componentFrames = componentAssignments.flatMap((assignment) => assignment.frames);
+    const componentStaticFrames = componentAssignments.flatMap((assignment) => assignment.staticFrames);
+    const mode = componentFrames.length === 0
+        ? "unknown"
+        : componentFrames.some((frame) => frame.kind === "scope")
+            ? "scope"
+            : "pure";
+    const selectedFrames = mode === "scope"
+        ? componentFrames.map((frame) => ({ ...frame, kind: "scope" }))
+        : componentFrames.map((frame) => ({ ...frame, kind: "pure" }));
+    const importedNames = getImportedNames(sourceFile);
+    for (const frame of selectedFrames) {
+        for (const providerName of frame.providers ?? []) {
+            if (!providerFrames[providerName] && importedNames.has(providerName)) {
+                providerFrames[providerName] = { name: providerName, frames: [] };
+            }
+        }
+    }
+    if (selectedFrames.length === 0) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "missing-frames",
+            message: "A Runelight entry must expose statically enumerable pure or scope frames.",
+            file: options.entry,
+        });
+    }
+    for (const frame of selectedFrames) {
+        validateProviderSelections(frame, providerFrames, diagnostics, options.entry);
+        validateProviderVariantSelections(frame, providerFrames, diagnostics, options.entry);
+    }
+    if (componentExportName) {
+        const consumedProviderNames = getGProviderConsumers(sourceFile, componentExportName, {
+            cwd: options.cwd,
+            entryPath,
+            cache,
+            sourceFilesByPath: cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
+        validateProviderVariantCoverage(consumedProviderNames, providerFrames, selectedFrames, diagnostics, options.entry);
+        validateJSXTreeFrameReachability(sourceFile, componentExportName, scopeHookNames, componentStaticFrames, diagnostics, options.entry, {
+            cwd: options.cwd,
+            entryPath,
+            cache,
+            sourceFilesByPath: cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
+        validateProviderProjectionWarnings(sourceFile, componentExportName, scopeHookNames, providerFrames, diagnostics, options.entry, {
+            cwd: options.cwd,
+            entryPath,
+            cache,
+            sourceFilesByPath: cache?.sourceFilesByPath ?? new Map([[entryPath, sourceFile]]),
+            visitedComponents: new Set(),
+        });
+    }
+    return {
+        entry: options.entry,
+        mode,
+        defaultExport: Boolean(componentExportName),
+        frames: selectedFrames,
+        providers: providerFrames,
+        diagnostics,
+    };
+}
+function parseEntryCoordinate(entry) {
+    const separatorIndex = entry.indexOf("#");
+    if (separatorIndex < 0) {
+        return { file: entry, explicitExportName: false };
+    }
+    return {
+        file: entry.slice(0, separatorIndex),
+        exportName: entry.slice(separatorIndex + 1) || "default",
+        explicitExportName: true,
+    };
+}
+function getComponentExportName(sourceFile, exportName) {
+    if (!exportName)
+        return getDefaultExportName(sourceFile) ?? getFirstNamedExportName(sourceFile);
+    if (exportName === "default")
+        return getDefaultExportName(sourceFile);
+    return getNamedExportName(sourceFile, exportName);
+}
+function getDefaultExportName(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) &&
+            hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+            return statement.name?.text;
+        }
+        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;
+}
+function getNamedExportName(sourceFile, exportName) {
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) &&
+            statement.name?.text === 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;
+}
+function getFirstNamedExportName(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) &&
+            statement.name &&
+            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;
+}
+function getScopeHookNames(sourceFile) {
+    const names = new Set();
+    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 (isCreateGScopeCall(unwrapExpression(declaration.initializer))) {
+                names.add(declaration.name.text);
+            }
+        }
+    }
+    return names;
+}
+function validateFramesAssignmentOrder(sourceFile, componentName, assignments, diagnostics, file) {
+    const declarationStart = topLevelValueDeclarationStart(sourceFile, componentName);
+    if (declarationStart === undefined)
+        return;
+    for (const assignment of assignments) {
+        if (assignment.targetName !== componentName || assignment.statementStart >= declarationStart)
+            continue;
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "frames-before-component-export",
+            message: `Move ${componentName}.frames after the "${componentName}" component declaration. Runelight component boundaries are initialized at runtime, so frames cannot rely on function hoisting.`,
+            file,
+        });
+    }
+}
+function topLevelValueDeclarationStart(sourceFile, name) {
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === name) {
+            return statement.getStart(sourceFile);
+        }
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) && declaration.name.text === name) {
+                return statement.getStart(sourceFile);
+            }
+        }
+    }
+    return undefined;
+}
+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;
+            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);
+        }
+    }
+    cache?.scopeHookProviderNamesByPath.set(filePath, hookProviders);
+    return hookProviders;
+}
+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,
+                frames: [],
+                ...(variants && variants.length > 0 ? { variants } : {}),
+            });
+        }
+    }
+    return providers;
+}
+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 = resolveImportedRunelightPath(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 });
+            }
+        }
+        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 });
+            }
+        }
+    }
+    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 = resolveImportedRunelightPath(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 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);
+                }
+            }
+            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);
+            }
+        }
+    }
+    return exportedScopeHookNames;
+}
+function resolveImportedRunelightPath(entryPath, cwd, specifier, cache) {
+    const cacheKey = `${entryPath}\0${specifier}`;
+    const cached = cache?.importedRunelightPathByKey.get(cacheKey);
+    if (cached !== undefined)
+        return cached ?? undefined;
+    const basePath = resolveImportBasePath(entryPath, cwd, specifier);
+    if (!basePath) {
+        cache?.importedRunelightPathByKey.set(cacheKey, null);
+        return undefined;
+    }
+    const visited = new Set();
+    const resolved = resolveImportedRunelightPathFromBase(basePath, cwd, visited, cache);
+    cache?.importedRunelightPathByKey.set(cacheKey, resolved ?? null);
+    return resolved;
+}
+function resolveImportedStaticSourcePath(entryPath, cwd, specifier, cache) {
+    const cacheKey = `${entryPath}\0${specifier}`;
+    const cached = cache?.importedStaticSourcePathByKey.get(cacheKey);
+    if (cached !== undefined)
+        return cached ?? undefined;
+    const basePath = resolveImportBasePath(entryPath, cwd, specifier);
+    if (!basePath) {
+        cache?.importedStaticSourcePathByKey.set(cacheKey, null);
+        return undefined;
+    }
+    const resolved = importedStaticSourcePathCandidates(basePath).find((candidate) => isFile(candidate));
+    cache?.importedStaticSourcePathByKey.set(cacheKey, resolved ?? null);
+    return resolved;
+}
+function getExportedStaticValuesForFile(sourceFile, filePath, cwd, cache, visited = new Set()) {
+    const cached = cache?.exportedStaticValuesByPath.get(filePath);
+    if (cached)
+        return cached;
+    if (visited.has(filePath))
+        return new Map();
+    visited.add(filePath);
+    const exports = new Map();
+    const localStaticValues = new Map();
+    cache?.exportedStaticValuesByPath.set(filePath, exports);
+    bindImportedStaticValuesForFile(sourceFile, filePath, cwd, localStaticValues, cache, visited);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || !isConstDeclarationList(statement.declarationList))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+                continue;
+            const staticValue = staticExportValueForExpression(declaration.initializer, localStaticValues);
+            if (!staticValue)
+                continue;
+            localStaticValues.set(declaration.name.text, staticValue);
+            if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+                exports.set(declaration.name.text, staticValue);
+            }
+        }
+    }
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportAssignment(statement)) {
+            const staticValue = staticExportValueForExpression(statement.expression, localStaticValues);
+            if (staticValue)
+                exports.set("default", staticValue);
+            continue;
+        }
+        if (!ts.isExportDeclaration(statement))
+            continue;
+        if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+            for (const [exportName, staticValue] of getReExportedStaticValues(filePath, cwd, statement.moduleSpecifier.text, cache, visited)) {
+                if (exportName !== "default" && !exports.has(exportName))
+                    exports.set(exportName, staticValue);
+            }
+            continue;
+        }
+        if (statement.exportClause && ts.isNamespaceExport(statement.exportClause) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+            exports.set(statement.exportClause.name.text, {
+                kind: "namespace",
+                exports: getReExportedStaticValues(filePath, cwd, statement.moduleSpecifier.text, cache, visited),
+            });
+            continue;
+        }
+        if (!statement.exportClause || !ts.isNamedExports(statement.exportClause))
+            continue;
+        const targetExports = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+            ? getReExportedStaticValues(filePath, cwd, statement.moduleSpecifier.text, cache, visited)
+            : localStaticValues;
+        for (const element of statement.exportClause.elements) {
+            const localName = element.propertyName?.text ?? element.name.text;
+            const expression = targetExports.get(localName);
+            if (expression)
+                exports.set(element.name.text, expression);
+        }
+    }
+    visited.delete(filePath);
+    return exports;
+}
+function bindImportedStaticValuesForFile(sourceFile, filePath, cwd, localStaticValues, cache, visited) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const targetExports = getReExportedStaticValues(filePath, cwd, statement.moduleSpecifier.text, cache, visited);
+        if (targetExports.size === 0)
+            continue;
+        const importClause = statement.importClause;
+        if (importClause.name) {
+            const defaultValue = targetExports.get("default");
+            if (defaultValue)
+                localStaticValues.set(importClause.name.text, defaultValue);
+        }
+        const namedBindings = importClause.namedBindings;
+        if (!namedBindings)
+            continue;
+        if (ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+                const importedName = element.propertyName?.text ?? element.name.text;
+                const staticValue = targetExports.get(importedName);
+                if (staticValue)
+                    localStaticValues.set(element.name.text, staticValue);
+            }
+            continue;
+        }
+        localStaticValues.set(namedBindings.name.text, { kind: "namespace", exports: targetExports });
+    }
+}
+function staticExportValueForExpression(expression, localStaticValues) {
+    const value = unwrapExpression(expression);
+    if (ts.isIdentifier(value))
+        return localStaticValues.get(value.text);
+    const context = staticExportMaterializationContext(value.getSourceFile(), localStaticValues);
+    if (!readStaticBranchValue(value) && !isStaticSpreadLiteral(value, context))
+        return undefined;
+    const values = new Map();
+    flattenStaticObjectExpression(value, "$", values, context);
+    return { kind: "facts", values: relativeStaticFacts("$", values) };
+}
+function staticExportMaterializationContext(sourceFile, localStaticValues) {
+    const context = {
+        expressionAliases: new Map(),
+        factorBindings: new Map(),
+        sourceFile,
+        staticValues: new Map(),
+    };
+    for (const [name, value] of localStaticValues) {
+        bindStaticExportValueAtPath([name], value, context, name);
+    }
+    return context;
+}
+function relativeStaticFacts(rootPrefix, values) {
+    const facts = new Map();
+    const childPrefix = `${rootPrefix}.`;
+    for (const [key, value] of values) {
+        if (key === rootPrefix) {
+            facts.set("", value);
+        }
+        else if (key.startsWith(childPrefix)) {
+            facts.set(key.slice(childPrefix.length), value);
+        }
+    }
+    return facts;
+}
+function getReExportedStaticValues(filePath, cwd, specifier, cache, visited) {
+    const targetPath = resolveImportedStaticSourcePath(filePath, cwd, specifier, cache);
+    if (!targetPath)
+        return new Map();
+    const targetSource = sourceFileForAbsolutePath(targetPath, cache);
+    return targetSource ? getExportedStaticValuesForFile(targetSource, targetPath, cwd, cache, visited) : new Map();
+}
+function resolveImportedRunelightPathFromBase(basePath, cwd, visited, cache) {
+    for (const candidate of importedRunelightPathCandidates(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 ? resolveImportedRunelightPathFromBase(nextBasePath, cwd, visited, cache) : undefined;
+            if (resolvedPath)
+                return resolvedPath;
+        }
+    }
+    return undefined;
+}
+function resolveImportBasePath(entryPath, cwd, specifier) {
+    if (specifier.startsWith("@/")) {
+        const direct = resolve(cwd, specifier.slice(2));
+        if (importedRunelightPathCandidates(direct).some((candidate) => isFile(candidate)) ||
+            importedTSXBarrelCandidates(direct).some((candidate) => isFile(candidate))) {
+            return direct;
+        }
+        return resolve(cwd, "src", specifier.slice(2));
+    }
+    if (specifier.startsWith("."))
+        return resolve(dirname(entryPath), specifier);
+    return undefined;
+}
+function importedRunelightPathCandidates(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 importedStaticSourcePathCandidates(basePath) {
+    const hasKnownExtension = /\.(?:tsx|ts|jsx|js)$/.test(basePath);
+    const candidates = [
+        hasKnownExtension ? basePath : undefined,
+        !hasKnownExtension ? `${basePath}.ts` : undefined,
+        !hasKnownExtension ? `${basePath}.tsx` : undefined,
+        !hasKnownExtension ? `${basePath}.js` : undefined,
+        !hasKnownExtension ? `${basePath}.jsx` : undefined,
+        !hasKnownExtension ? `${basePath}.g.tsx` : undefined,
+        !hasKnownExtension ? `${basePath}.g.ts` : undefined,
+        join(basePath, "index.ts"),
+        join(basePath, "index.tsx"),
+        join(basePath, "index.js"),
+        join(basePath, "index.jsx"),
+    ];
+    return [...new Set(candidates.filter((candidate) => Boolean(candidate)))];
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+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 names;
+}
+function validateProviderSelections(frame, providerFrames, diagnostics, file) {
+    if (!frame.providers)
+        return;
+    for (const providerName of frame.providers) {
+        if (!providerFrames[providerName]) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "missing-provider",
+                message: `Frame "${frame.name}" selects unknown provider "${providerName}".`,
+                file,
+                frameName: frame.name,
+            });
+        }
+    }
+}
+function validateProviderVariantSelections(frame, providerFrames, diagnostics, file) {
+    if (!frame.providerVariants)
+        return;
+    for (const [providerName, selection] of Object.entries(frame.providerVariants)) {
+        const variants = providerVariantSelectionValues(selection);
+        const provider = providerFrames[providerName];
+        if (!provider) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "missing-provider",
+                message: `Frame "${frame.name}" marks unknown provider "${providerName}" variants "${variants.join(", ")}".`,
+                file,
+                frameName: frame.name,
+            });
+            continue;
+        }
+        if (!provider.variants || provider.variants.length === 0) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "missing-provider-variants",
+                message: `Frame "${frame.name}" marks provider "${providerName}" variants "${variants.join(", ")}", but "${providerName}" does not declare variants.`,
+                file,
+                frameName: frame.name,
+            });
+            continue;
+        }
+        const unknownVariants = variants.filter((variant) => !provider.variants?.includes(variant));
+        if (unknownVariants.length > 0) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "unknown-provider-variant",
+                message: `Frame "${frame.name}" marks unknown "${providerName}" variants "${unknownVariants.join(", ")}". Expected one of: ${provider.variants.join(", ")}.`,
+                file,
+                frameName: frame.name,
+            });
+        }
+    }
+}
+function validateProviderVariantCoverage(consumedProviderNames, providerFrames, selectedFrames, diagnostics, file) {
+    for (const providerName of consumedProviderNames) {
+        const provider = providerFrames[providerName];
+        if (!provider?.variants || provider.variants.length === 0)
+            continue;
+        const coveredVariants = new Set(selectedFrames.flatMap((frame) => {
+            const selection = frame.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",
+            severity: "error",
+            code: "missing-provider-variant-frames",
+            message: `Runelight entry consumes provider "${providerName}" but its frames do not cover variants: ${missingVariants.join(", ")}.`,
+            file,
+        });
+    }
+}
+function providerVariantSelectionValues(selection) {
+    return Array.isArray(selection) ? selection : [selection];
+}
+function validateJSXTreeFrameReachability(sourceFile, componentName, scopeHookNames, staticFrames, diagnostics, file, context) {
+    if (staticFrames.length === 0)
+        return;
+    const component = getFunctionLikeDeclaration(sourceFile, componentName);
+    if (!component?.body)
+        return;
+    const branchContext = createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames, context);
+    const defaultValues = defaultStaticValuesForFunctionLike(component);
+    const frameFacts = staticFrames.map((frame) => ({
+        ...frame,
+        values: new Map([...branchContext.staticValues, ...defaultValues, ...frame.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",
+                severity: "error",
+                code: "opaque-jsx-control-flow",
+                message: `JSX dependency <${dependency.tagName}> is controlled by an opaque expression "${opaque.text}". Use props, Runelight context, or GScope values directly so frames can cover the tree structure.`,
+                file,
+            });
+            continue;
+        }
+        const evaluations = frameFacts.map((frame) => evaluateJSXBranchPredicate(dependency.condition, frame.values));
+        const coveredFrameNames = frameFacts
+            .filter((_frame, index) => evaluations[index] === true)
+            .map((frame) => frame.name);
+        if (coveredFrameNames.length > 0)
+            continue;
+        const unknownFrameNames = frameFacts
+            .filter((_frame, index) => evaluations[index] === "unknown")
+            .map((frame) => frame.name);
+        if (unknownFrameNames.length > 0) {
+            const key = `unknown:${dependency.tagName}:${formatJSXBranchPredicate(dependency.condition)}`;
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "unknown-jsx-branch-coverage",
+                message: `JSX dependency <${dependency.tagName}> is controlled by "${formatJSXBranchPredicate(dependency.condition)}", but frame values are not static enough to prove coverage. Unknown frames: ${unknownFrameNames.join(", ")}.`,
+                file,
+            });
+            continue;
+        }
+        const key = `uncovered:${dependency.tagName}:${formatJSXBranchPredicate(dependency.condition)}`;
+        if (reported.has(key))
+            continue;
+        reported.add(key);
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "uncovered-jsx-branch",
+            message: `No frame renders JSX dependency <${dependency.tagName}> behind "${formatJSXBranchPredicate(dependency.condition)}". Add a frame whose props, Runelight context, or GScope values make that branch reachable.`,
+            file,
+        });
+    }
+}
+function validateProviderProjectionWarnings(sourceFile, componentName, scopeHookNames, providerFrames, diagnostics, file, context) {
+    const warnings = providerProjectionWarningsForComponent(sourceFile, componentName, scopeHookNames, providerFrames, 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 frames do not mark "${warning.providerName}" variants. If those props are environment projections, add GProviderFrame markers; if the child is environment-neutral, this warning can be ignored.`,
+            file,
+        });
+    }
+}
+function providerProjectionWarningsForComponent(sourceFile, componentName, scopeHookNames, providerFrames, context) {
+    const component = getFunctionLikeDeclaration(sourceFile, componentName);
+    if (!component?.body)
+        return [];
+    const warnings = [];
+    const branchContext = createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames, context);
+    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, providerFrames, currentBranchContext);
+        if (projectedProviderNames.size === 0)
+            return;
+        const targetSourceFile = sourceFileForPath(target.filePath, context);
+        if (!targetSourceFile)
+            return;
+        for (const providerName of projectedProviderNames) {
+            const markerStatus = componentFramesProviderVariantMarkerStatus(targetSourceFile, target.componentName, providerName);
+            if (markerStatus !== false)
+                continue;
+            warnings.push({
+                providerName,
+                tagName: jsxTagNameText(node.tagName, sourceFile),
+                target,
+            });
+        }
+    }
+}
+function providerVariantNamesReferencedByJsxAttributes(attributes, providerFrames, 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, providerFrames, context)) {
+            providerNames.add(providerName);
+        }
+    }
+    return providerNames;
+}
+function providerVariantNamesReferencedByExpression(expression, providerFrames, 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" && (providerFrames[reference.providerName]?.variants?.length ?? 0) > 0) {
+                providerNames.add(reference.providerName);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+}
+function componentFramesProviderVariantMarkerStatus(sourceFile, componentName, providerName) {
+    let hasFrames = false;
+    for (const statement of sourceFile.statements) {
+        const assignment = getFramesAssignment(statement, sourceFile, []);
+        if (!assignment || assignment.targetName !== componentName)
+            continue;
+        if (assignment.frames.length === 0)
+            continue;
+        hasFrames = true;
+        if (assignment.frames.some((frame) => frame.providerVariants?.[providerName]))
+            return true;
+    }
+    return hasFrames ? false : undefined;
+}
+function createJSXBranchAnalysisContext(sourceFile, component, scopeHookNames, analysisContext) {
+    const context = {
+        expressionAliases: new Map(),
+        factorBindings: new Map(),
+        sourceFile,
+        staticValues: new Map(),
+    };
+    bindImportedStaticConstDeclarations(sourceFile, analysisContext.entryPath, analysisContext.cwd, context, analysisContext.cache);
+    bindTopLevelStaticConstDeclarations(sourceFile, context);
+    bindFunctionParameters(component, context);
+    if (component.body && ts.isBlock(component.body)) {
+        for (const statement of component.body.statements) {
+            bindTopLevelBranchVariableStatement(statement, context, scopeHookNames);
+        }
+    }
+    return context;
+}
+function bindTopLevelStaticConstDeclarations(sourceFile, context) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || !isConstDeclarationList(statement.declarationList))
+            continue;
+        bindStaticConstDeclarations(statement.declarationList, context, (name) => [name]);
+    }
+}
+function bindImportedStaticConstDeclarations(sourceFile, filePath, cwd, context, cache) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const targetPath = resolveImportedStaticSourcePath(filePath, cwd, statement.moduleSpecifier.text, cache);
+        if (!targetPath)
+            continue;
+        const targetSource = sourceFileForAbsolutePath(targetPath, cache);
+        if (!targetSource)
+            continue;
+        const targetExports = getExportedStaticValuesForFile(targetSource, targetPath, cwd, cache);
+        if (targetExports.size === 0)
+            continue;
+        const importClause = statement.importClause;
+        if (importClause.name) {
+            bindImportedStaticExpression(importClause.name.text, targetExports.get("default"), context);
+        }
+        const namedBindings = importClause.namedBindings;
+        if (!namedBindings)
+            continue;
+        if (ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+                const importedName = element.propertyName?.text ?? element.name.text;
+                bindImportedStaticExpression(element.name.text, targetExports.get(importedName), context);
+            }
+            continue;
+        }
+        for (const [exportName, staticValue] of targetExports) {
+            bindStaticExportValueAtPath([namedBindings.name.text, exportName], staticValue, context);
+        }
+        context.factorBindings.set(namedBindings.name.text, { root: "static", path: [namedBindings.name.text] });
+    }
+}
+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 (isConstDeclarationList(statement.declarationList) && bindStaticConstDeclaration(declaration, context, (name) => [
+            `local:${declaration.name.getStart(context.sourceFile)}:${name}`,
+        ])) {
+            continue;
+        }
+        if (ts.isIdentifier(declaration.name) && !expressionContainsJSX(initializer)) {
+            context.expressionAliases.set(declaration.name.text, initializer);
+        }
+    }
+}
+function bindStaticConstDeclarations(declarationList, context, staticPathForName) {
+    for (const declaration of declarationList.declarations) {
+        bindStaticConstDeclaration(declaration, context, staticPathForName);
+    }
+}
+function bindStaticConstDeclaration(declaration, context, staticPathForName) {
+    if (!declaration.initializer)
+        return false;
+    const initializer = unwrapExpression(declaration.initializer);
+    const rootReference = factorReferenceForExpression(initializer, context);
+    if (rootReference) {
+        if (ts.isIdentifier(declaration.name)) {
+            context.factorBindings.set(declaration.name.text, rootReference);
+            return true;
+        }
+        if (ts.isObjectBindingPattern(declaration.name)) {
+            bindObjectBindingPattern(declaration.name, rootReference, context);
+            return true;
+        }
+        return false;
+    }
+    if (!ts.isIdentifier(declaration.name))
+        return false;
+    return bindStaticExpressionAtPath(staticPathForName(declaration.name.text), initializer, context, declaration.name.text);
+}
+function bindImportedStaticExpression(localName, staticValue, context) {
+    return bindStaticExportValueAtPath([localName], staticValue, context, localName);
+}
+function bindStaticExportValueAtPath(staticPath, staticValue, context, bindingName) {
+    if (!staticValue)
+        return false;
+    const reference = { root: "static", path: staticPath };
+    if (bindingName)
+        context.factorBindings.set(bindingName, reference);
+    if (staticValue.kind === "expression") {
+        return bindStaticExpressionAtPath(staticPath, staticValue.expression, context, bindingName);
+    }
+    if (staticValue.kind === "facts") {
+        let bound = false;
+        const prefix = factorReferenceKey(reference);
+        for (const [suffix, value] of staticValue.values) {
+            writeStaticBranchValue(context.staticValues, suffix ? `${prefix}.${suffix}` : prefix, value, "override");
+            bound = true;
+        }
+        return bound;
+    }
+    let bound = false;
+    context.staticValues.set(factorReferenceKey(reference), { kind: "object" });
+    for (const [exportName, childValue] of staticValue.exports) {
+        bound = bindStaticExportValueAtPath([...staticPath, exportName], childValue, context) || bound;
+    }
+    return bound;
+}
+function bindStaticExpressionAtPath(staticPath, expression, context, bindingName) {
+    if (!expression)
+        return false;
+    const initializer = unwrapExpression(expression);
+    if (!readStaticBranchValue(initializer) && !isStaticSpreadLiteral(initializer, context))
+        return false;
+    const reference = {
+        root: "static",
+        path: staticPath,
+    };
+    if (bindingName)
+        context.factorBindings.set(bindingName, reference);
+    flattenStaticObjectExpression(initializer, factorReferenceKey(reference), context.staticValues, context);
+    return true;
+}
+function isConstDeclarationList(declarationList) {
+    return (declarationList.flags & ts.NodeFlags.Const) !== 0;
+}
+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,
+        staticValues: new Map(context.staticValues),
+    };
+}
+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 getNonRunelightHookCalls(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 (!isAllowedRunelightHookCall(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 = resolveImportedRunelightPath(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 isAllowedRunelightHookCall(node, hookName, scopeHookNames) {
+    if (ts.isIdentifier(node.expression)) {
+        return hookName === "useGContext" || hookName === "useGContextUpdate" || scopeHookNames.has(hookName);
+    }
+    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 getFramesAssignment(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 !== "frames") {
+        return undefined;
+    }
+    if (!ts.isIdentifier(expression.left.expression))
+        return undefined;
+    const framesExpression = unwrapExpression(expression.right);
+    if (!ts.isObjectLiteralExpression(framesExpression)) {
+        diagnostics.push({
+            stage: "contract-extraction",
+            severity: "error",
+            code: "malformed-frames",
+            message: "Runelight frames must be a statically enumerable object literal.",
+            file: sourceFile.fileName,
+        });
+        return { targetName: expression.left.expression.text, frames: [], staticFrames: [], statementStart: statement.getStart(sourceFile) };
+    }
+    return {
+        targetName: expression.left.expression.text,
+        statementStart: statement.getStart(sourceFile),
+        ...readFramesObject(framesExpression, sourceFile, diagnostics),
+    };
+}
+function readFramesObject(objectLiteral, sourceFile, diagnostics) {
+    const frames = [];
+    const staticFrames = [];
+    for (const property of objectLiteral.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "malformed-frames",
+                message: "Runelight frames do not support spread composition in the first implementation.",
+                file: sourceFile.fileName,
+            });
+            continue;
+        }
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const frameName = getStaticPropertyName(property.name);
+        if (!frameName) {
+            diagnostics.push({
+                stage: "contract-extraction",
+                severity: "error",
+                code: "non-static-frame-key",
+                message: "Runelight frame keys must be statically enumerable object literal keys.",
+                file: sourceFile.fileName,
+            });
+            continue;
+        }
+        const providerVariants = readProviderVariantMarkers(property.initializer);
+        const frameValue = unwrapExpression(property.initializer);
+        const providers = ts.isObjectLiteralExpression(frameValue) ? readProviderSelections(frameValue) : undefined;
+        const kind = ts.isObjectLiteralExpression(frameValue) && hasStaticProperty(frameValue, "scope") ? "scope" : "pure";
+        frames.push({
+            kind,
+            name: frameName,
+            ...(providerVariants && Object.keys(providerVariants).length > 0 ? { providerVariants } : {}),
+            ...(providers && Object.keys(providers).length > 0 ? { providers } : {}),
+        });
+        staticFrames.push(readFrameStaticFacts(frameName, frameValue, providerVariants));
+    }
+    return { frames, staticFrames };
+}
+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 readFrameStaticFacts(frameName, frameValue, providerVariants) {
+    const values = new Map();
+    if (ts.isObjectLiteralExpression(frameValue)) {
+        const props = objectLiteralPropertyExpression(frameValue, "props");
+        if (props)
+            flattenStaticObjectExpression(props, "props", values);
+        const scope = objectLiteralPropertyExpression(frameValue, "scope");
+        if (scope)
+            flattenStaticObjectExpression(scope, "scope", values);
+        const providers = objectLiteralPropertyExpression(frameValue, "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: frameName,
+        ...(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, context, writeMode = "override") {
+    const value = unwrapExpression(expression);
+    const staticValue = readStaticBranchValue(value);
+    if (staticValue) {
+        writeStaticBranchValue(values, prefix, staticValue, writeMode);
+        if (staticValue.kind === "array")
+            writeStaticBranchValue(values, `${prefix}.length`, { kind: "number", value: staticValue.length }, writeMode);
+        if (staticValue.kind === "string")
+            writeStaticBranchValue(values, `${prefix}.length`, { kind: "number", value: staticValue.value.length }, writeMode);
+    }
+    if (ts.isArrayLiteralExpression(value)) {
+        const spreadLength = staticArrayLiteralLength(value, context);
+        if (!staticValue && spreadLength !== undefined) {
+            writeStaticBranchValue(values, prefix, { kind: "array", length: spreadLength }, writeMode);
+            writeStaticBranchValue(values, `${prefix}.length`, { kind: "number", value: spreadLength }, writeMode);
+        }
+        for (const element of value.elements) {
+            if (ts.isSpreadElement(element)) {
+                if (!context || !copyStaticArraySpreadValues(element.expression, `${prefix}.number`, values, context)) {
+                    setStaticBranchValue(values, `${prefix}.number`, { kind: "unknown" });
+                }
+                continue;
+            }
+            flattenStaticObjectExpression(element, `${prefix}.number`, values, context, "merge");
+        }
+        return;
+    }
+    if (!ts.isObjectLiteralExpression(value)) {
+        if (!staticValue)
+            writeStaticBranchValue(values, prefix, { kind: "unknown" }, writeMode);
+        return;
+    }
+    for (const property of value.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            if (!context || !copyStaticSpreadValues(property.expression, prefix, values, context, writeMode)) {
+                writeStaticBranchValue(values, prefix, { kind: "unknown" }, writeMode);
+            }
+            continue;
+        }
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const propertyName = getStaticPropertyName(property.name);
+        if (!propertyName)
+            continue;
+        flattenStaticObjectExpression(property.initializer, `${prefix}.${propertyName}`, values, context, writeMode);
+    }
+}
+function isStaticSpreadLiteral(expression, context) {
+    const value = unwrapExpression(expression);
+    if (ts.isArrayLiteralExpression(value)) {
+        return value.elements.every((element) => {
+            if (ts.isSpreadElement(element))
+                return Boolean(staticSpreadPrefixForExpression(element.expression, context));
+            return Boolean(readStaticBranchValue(element) || isStaticSpreadLiteral(element, context));
+        });
+    }
+    if (!ts.isObjectLiteralExpression(value))
+        return false;
+    return value.properties.every((property) => {
+        if (ts.isSpreadAssignment(property))
+            return Boolean(staticSpreadPrefixForExpression(property.expression, context));
+        if (!ts.isPropertyAssignment(property))
+            return true;
+        return Boolean(readStaticBranchValue(property.initializer) || isStaticSpreadLiteral(property.initializer, context));
+    });
+}
+function copyStaticSpreadValues(expression, targetPrefix, values, context, writeMode) {
+    const sourcePrefix = staticSpreadPrefixForExpression(expression, context);
+    if (!sourcePrefix)
+        return false;
+    const sourceValue = context.staticValues.get(sourcePrefix);
+    if (sourceValue)
+        writeStaticBranchValue(values, targetPrefix, sourceValue, writeMode);
+    const childPrefix = `${sourcePrefix}.`;
+    let copied = Boolean(sourceValue);
+    for (const [key, value] of context.staticValues) {
+        if (!key.startsWith(childPrefix))
+            continue;
+        const suffix = key.slice(childPrefix.length);
+        writeStaticBranchValue(values, `${targetPrefix}.${suffix}`, value, writeMode);
+        copied = true;
+    }
+    return copied;
+}
+function copyStaticArraySpreadValues(expression, targetElementPrefix, values, context) {
+    const sourcePrefix = staticSpreadPrefixForExpression(expression, context);
+    if (!sourcePrefix)
+        return false;
+    const sourceElementPrefix = `${sourcePrefix}.number`;
+    const sourceValue = context.staticValues.get(sourceElementPrefix);
+    if (sourceValue)
+        setStaticBranchValue(values, targetElementPrefix, sourceValue);
+    const childPrefix = `${sourceElementPrefix}.`;
+    let copied = Boolean(sourceValue);
+    for (const [key, value] of context.staticValues) {
+        if (!key.startsWith(childPrefix))
+            continue;
+        const suffix = key.slice(childPrefix.length);
+        setStaticBranchValue(values, `${targetElementPrefix}.${suffix}`, value);
+        copied = true;
+    }
+    return copied;
+}
+function staticArrayLiteralLength(value, context) {
+    let length = 0;
+    for (const element of value.elements) {
+        if (!ts.isSpreadElement(element)) {
+            length += 1;
+            continue;
+        }
+        if (!context)
+            return undefined;
+        const sourcePrefix = staticSpreadPrefixForExpression(element.expression, context);
+        if (!sourcePrefix)
+            return undefined;
+        const sourceLength = context.staticValues.get(`${sourcePrefix}.length`);
+        if (sourceLength?.kind !== "number")
+            return undefined;
+        length += sourceLength.value;
+    }
+    return length;
+}
+function staticSpreadPrefixForExpression(expression, context) {
+    const reference = factorReferenceForExpression(expression, context);
+    return reference?.root === "static" ? factorReferenceKey(reference) : undefined;
+}
+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 writeStaticBranchValue(values, key, value, mode) {
+    if (mode === "override") {
+        values.set(key, value);
+        return;
+    }
+    setStaticBranchValue(values, key, 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 !== "GProviderFrame")
+            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(frameValue) {
+    const providersProperty = frameValue.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 = [];
+    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;
+        if (providerExpression && ts.isIdentifier(providerExpression)) {
+            providers.push(providerExpression.text);
+        }
+    }
+    return providers;
+}
+function getStaticPropertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function unwrapExpression(expression) {
+    if (ts.isSatisfiesExpression(expression) || ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
+function isCreateGScopeCall(expression) {
+    return ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "createGScopeHook";
+}
+function isCreateGProviderCall(expression) {
+    return ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "createGProvider";
+}
+function hasStaticProperty(objectLiteral, propertyName) {
+    return objectLiteral.properties.some((property) => ts.isPropertyAssignment(property) && getStaticPropertyName(property.name) === 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=contract-analyzer.js.map