@trojanbox-vcp-test/site-edit-engine 0.1.0

package/dist/internal/provenance/resolve-text-provenance.js

@@ -0,0 +1,3090 @@
+import path from "node:path";
+import * as parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { resolveLocalImport } from "../graph/import-resolver.js";
+import { findAliasInitializer, findPatternBindingPath, findPropDefaultBinding, getParamPropReference as getBindingParamPropReference, } from "./binding-graph.js";
+import { classifyBindingDataSource, classifyExpressionDataSource, isApiSource, } from "./data-source-classifier.js";
+const traverse = (typeof _traverse === "function" ? _traverse : _traverse.default);
+function buildApiExternalProvenance(file, sourceId, displayPath) {
+    return {
+        kind: "external",
+        file,
+        sourceType: "api-field",
+        sourceId,
+        displayPath,
+        editMode: "readonly",
+        diagnostics: [
+            {
+                code: "external-source-readonly",
+                message: "Dynamic API data is read-only for content edits",
+            },
+        ],
+    };
+}
+export async function resolveTextProvenance(params) {
+    const { file, source, segment, readFile, exists } = params;
+    const fileCache = params.fileCache ?? new Map();
+    const ast = parseSourceCached(fileCache, file, source);
+    if (!ast) {
+        return null;
+    }
+    const expressionPath = findExpressionPathByRange(ast, segment.sourceRange);
+    if (!expressionPath) {
+        return null;
+    }
+    const sourceInfo = segment.source ??
+        (await buildExpressionSourceInfo({
+            expression: expressionPath.node,
+            scope: expressionPath.scope,
+            source,
+            currentFile: file,
+            readFile,
+            exists,
+            fileCache,
+            visited: new Set(),
+        }));
+    if (!sourceInfo) {
+        const directProvenance = await resolveDirectExpressionProvenance({
+            currentFile: file,
+            expressionPath,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited: new Set(),
+        });
+        if (!directProvenance) {
+            return null;
+        }
+        if (directProvenance.kind === "external") {
+            return {
+                kind: "external-entry",
+                file: directProvenance.file,
+                sourceType: directProvenance.sourceType,
+                sourceId: directProvenance.sourceId,
+                adapterId: directProvenance.adapterId,
+                displayExpression: directProvenance.displayPath,
+            };
+        }
+        const directLocator = {
+            kind: "value",
+            root: directProvenance.root,
+            path: directProvenance.path.length > 0 ? directProvenance.path : [],
+        };
+        return {
+            kind: "value-binding",
+            file: directProvenance.file,
+            locator: directLocator,
+            root: directProvenance.root,
+            path: directProvenance.path,
+            displayExpression: directProvenance.displayExpression ??
+                getExpressionText(expressionPath.node, source),
+            sourceKind: directProvenance.sourceKind,
+            ...(directProvenance.collectionIndexMap
+                ? { collectionIndexMap: directProvenance.collectionIndexMap }
+                : {}),
+            ...(directProvenance.collectionPathMap
+                ? { collectionPathMap: directProvenance.collectionPathMap }
+                : {}),
+        };
+    }
+    const visited = new Set();
+    const provenance = await resolveSegmentProvenance({
+        currentFile: file,
+        expressionPath,
+        segment: {
+            ...segment,
+            source: sourceInfo,
+        },
+        readFile,
+        exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    if (!provenance) {
+        return null;
+    }
+    if (provenance.kind === "external") {
+        return {
+            kind: "external-entry",
+            file: provenance.file,
+            sourceType: provenance.sourceType,
+            sourceId: provenance.sourceId,
+            adapterId: provenance.adapterId,
+            displayExpression: provenance.displayPath,
+        };
+    }
+    const locator = {
+        kind: "value",
+        root: provenance.root,
+        path: provenance.path.length > 0 ? provenance.path : [],
+    };
+    return {
+        kind: "value-binding",
+        file: provenance.file,
+        locator,
+        root: provenance.root,
+        path: provenance.path,
+        displayExpression: provenance.displayExpression ?? sourceInfo.expression,
+        sourceKind: provenance.sourceKind,
+        ...(provenance.collectionIndexMap
+            ? { collectionIndexMap: provenance.collectionIndexMap }
+            : {}),
+        ...(provenance.collectionPathMap
+            ? { collectionPathMap: provenance.collectionPathMap }
+            : {}),
+    };
+}
+export async function resolveProvenance(params) {
+    const { file, source, readFile, exists } = params;
+    const fileCache = params.fileCache ?? new Map();
+    const ast = parseSourceCached(fileCache, file, source);
+    if (!ast) {
+        return unsupportedResolution("unsupported-expression", "Unable to parse source for provenance resolution");
+    }
+    const visited = new Set();
+    if (params.target.kind === "text-segment") {
+        return resolveTextSegmentProvenance({
+            file,
+            source,
+            ast,
+            segment: params.target.segment,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+    }
+    return resolveConditionalBranchProvenance({
+        file,
+        source,
+        ast,
+        candidate: params.target.candidate,
+        readFile,
+        exists,
+        graph: params.graph,
+        fileCache,
+        visited,
+    });
+}
+function parseSource(source) {
+    try {
+        return parser.parse(source, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function parseSourceCached(fileCache, file, source) {
+    const cached = fileCache.get(file);
+    if (cached?.source === source) {
+        return cached.ast;
+    }
+    const ast = parseSource(source);
+    fileCache.set(file, { source, ast });
+    return ast;
+}
+function findExpressionPathByRange(ast, range) {
+    let match = null;
+    let matchSpan = -1;
+    traverse(ast, {
+        Expression(path) {
+            const loc = path.node.loc;
+            if (!loc || !rangeContains(loc, range)) {
+                return;
+            }
+            const span = (path.node.end ?? 0) - (path.node.start ?? 0);
+            if (span >= matchSpan) {
+                match = path;
+                matchSpan = span;
+            }
+        },
+    });
+    return match;
+}
+function findExpressionPathByExactRange(ast, range) {
+    let match = null;
+    let matchSpan = Number.POSITIVE_INFINITY;
+    traverse(ast, {
+        Expression(path) {
+            if (!matchesRange(path.node.loc, range)) {
+                return;
+            }
+            const span = (path.node.end ?? 0) - (path.node.start ?? 0);
+            if (span <= matchSpan) {
+                match = path;
+                matchSpan = span;
+            }
+        },
+    });
+    return match;
+}
+function findJSXElementPathByRange(ast, range) {
+    let match = null;
+    let matchSpan = Number.POSITIVE_INFINITY;
+    traverse(ast, {
+        JSXElement(path) {
+            const loc = path.node.loc;
+            if (!loc || !rangeContains(loc, range)) {
+                return;
+            }
+            const span = (path.node.end ?? 0) - (path.node.start ?? 0);
+            if (span <= matchSpan) {
+                match = path;
+                matchSpan = span;
+            }
+        },
+    });
+    return match;
+}
+function matchesRange(loc, range) {
+    if (!loc) {
+        return false;
+    }
+    return (loc.start.line === range.startLine &&
+        loc.start.column === range.startColumn &&
+        loc.end.line === range.endLine &&
+        loc.end.column === range.endColumn);
+}
+function rangeContains(loc, range) {
+    const start = comparePosition({ line: loc.start.line, column: loc.start.column }, { line: range.startLine, column: range.startColumn });
+    const end = comparePosition({ line: loc.end.line, column: loc.end.column }, { line: range.endLine, column: range.endColumn });
+    return start >= 0 && end <= 0;
+}
+function toValueSourceRange(node) {
+    if (!node.loc) {
+        return null;
+    }
+    return {
+        startLine: node.loc.start.line,
+        startColumn: node.loc.start.column,
+        endLine: node.loc.end.line,
+        endColumn: node.loc.end.column,
+    };
+}
+function comparePosition(left, right) {
+    if (left.line !== right.line) {
+        return left.line < right.line ? -1 : 1;
+    }
+    if (left.column !== right.column) {
+        return left.column < right.column ? -1 : 1;
+    }
+    return 0;
+}
+function expressionSourceInfo(expr, source) {
+    if (t.isIdentifier(expr)) {
+        return {
+            kind: "identifier",
+            expression: expr.name,
+            base: expr.name,
+            path: [],
+        };
+    }
+    if (!t.isMemberExpression(expr)) {
+        return null;
+    }
+    const path = [];
+    let current = expr;
+    while (t.isMemberExpression(current)) {
+        if (current.computed) {
+            if (t.isNumericLiteral(current.property)) {
+                path.unshift({ kind: "index", index: current.property.value });
+            }
+            else if (t.isStringLiteral(current.property)) {
+                path.unshift({ kind: "property", name: current.property.value });
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            if (!t.isIdentifier(current.property)) {
+                return null;
+            }
+            path.unshift({ kind: "property", name: current.property.name });
+        }
+        current = current.object;
+    }
+    if (!t.isIdentifier(current)) {
+        return null;
+    }
+    return {
+        kind: path.some((segment) => segment.kind === "index")
+            ? "index-expression"
+            : "member-expression",
+        expression: getExpressionText(expr, source),
+        base: current.name,
+        path,
+    };
+}
+async function buildExpressionSourceInfo(params) {
+    if (t.isIdentifier(params.expression)) {
+        return {
+            kind: "identifier",
+            expression: params.expression.name,
+            base: params.expression.name,
+            path: [],
+        };
+    }
+    if (!t.isMemberExpression(params.expression)) {
+        return null;
+    }
+    const normalized = await normalizeExpressionWithScope(params.expression, params.scope, params.currentFile, params.readFile, params.exists, params.fileCache, params.visited);
+    if (!normalized) {
+        return null;
+    }
+    return {
+        kind: normalized.path.some((segment) => segment.kind === "index")
+            ? "index-expression"
+            : "member-expression",
+        expression: getExpressionText(params.expression, params.source),
+        base: normalized.base,
+        path: normalized.path,
+    };
+}
+function getExpressionText(node, source) {
+    if (source) {
+        return getNodeText(node, source);
+    }
+    const normalized = normalizeExpression(node);
+    if (!normalized) {
+        return "";
+    }
+    return normalized.path.reduce((expression, segment) => segment.kind === "property"
+        ? `${expression}.${segment.name}`
+        : `${expression}[${segment.index}]`, normalized.base);
+}
+function getNodeText(node, source) {
+    if (node.start == null || node.end == null) {
+        return "";
+    }
+    return source.slice(node.start, node.end);
+}
+function findExpressionPathByText(ast, source, expressionText) {
+    let match = null;
+    let matchSpan = Number.POSITIVE_INFINITY;
+    traverse(ast, {
+        Expression(path) {
+            if (getNodeText(path.node, source) !== expressionText) {
+                return;
+            }
+            const span = (path.node.end ?? 0) - (path.node.start ?? 0);
+            if (span <= matchSpan) {
+                match = path;
+                matchSpan = span;
+            }
+        },
+    });
+    return match;
+}
+function findExpressionPathByTextInRange(ast, source, expressionText, range) {
+    let match = null;
+    let matchSpan = Number.POSITIVE_INFINITY;
+    traverse(ast, {
+        Expression(path) {
+            if (getNodeText(path.node, source) !== expressionText) {
+                return;
+            }
+            const loc = path.node.loc;
+            if (!loc || !rangeContains(loc, range)) {
+                return;
+            }
+            const span = (path.node.end ?? 0) - (path.node.start ?? 0);
+            if (span <= matchSpan) {
+                match = path;
+                matchSpan = span;
+            }
+        },
+    });
+    return match;
+}
+async function resolveTextSegmentProvenance(ctx) {
+    const { file, source, ast, segment, readFile, exists, fileCache, visited } = ctx;
+    const expressionPath = findExpressionPathByRange(ast, segment.sourceRange);
+    const sourceInfo = segment.source ??
+        (expressionPath
+            ? await buildExpressionSourceInfo({
+                expression: expressionPath.node,
+                scope: expressionPath.scope,
+                source,
+                currentFile: file,
+                readFile,
+                exists,
+                fileCache,
+                visited,
+            })
+            : null);
+    if (!sourceInfo) {
+        if (!expressionPath) {
+            return literalResolution(file, segment.value);
+        }
+        const directProvenance = await resolveDirectExpressionProvenance({
+            currentFile: file,
+            expressionPath,
+            readFile,
+            exists,
+            graph: ctx.graph,
+            externalSourceResolvers: ctx.externalSourceResolvers,
+            externalAdapters: ctx.externalAdapters,
+            functionCallContracts: ctx.functionCallContracts,
+            fileCache,
+            visited,
+        });
+        if (directProvenance) {
+            return directProvenance.kind === "external"
+                ? buildExternalResolution(file, directProvenance)
+                : buildValueResolution(file, getExpressionText(expressionPath.node, source), directProvenance);
+        }
+        return unsupportedResolutionForExpression({
+            expression: expressionPath.node,
+            scope: expressionPath.scope,
+            currentFile: file,
+            source,
+            readFile,
+            exists,
+            fileCache,
+            visited,
+            functionCallContracts: ctx.functionCallContracts,
+        });
+    }
+    if (!expressionPath) {
+        return unsupportedResolution("unsupported-expression", "Unable to locate text expression for provenance resolution");
+    }
+    const provenance = await resolveSourceInfoProvenance({
+        currentFile: file,
+        expressionPath,
+        sourceInfo,
+        readFile,
+        exists,
+        graph: ctx.graph,
+        externalSourceResolvers: ctx.externalSourceResolvers,
+        externalAdapters: ctx.externalAdapters,
+        functionCallContracts: ctx.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    if (!provenance) {
+        const directExternalDiagnostic = getInvalidExternalHelperDiagnostic(expressionPath.node);
+        if (directExternalDiagnostic) {
+            return unsupportedResolution(directExternalDiagnostic.code, directExternalDiagnostic.message);
+        }
+        const binding = expressionPath.scope.getBinding(sourceInfo.base);
+        if (binding?.path.isVariableDeclarator()) {
+            const bindingExternalDiagnostic = getInvalidExternalHelperDiagnostic(binding.path.node.init);
+            if (bindingExternalDiagnostic) {
+                return unsupportedResolution(bindingExternalDiagnostic.code, bindingExternalDiagnostic.message);
+            }
+        }
+        if (binding?.path.isVariableDeclarator() &&
+            t.isCallExpression(binding.path.node.init)) {
+            return readonlyResolution("unsupported-expression", getFunctionCallReadonlyMessage(binding.path.node.init, ctx.functionCallContracts));
+        }
+        return unsupportedResolution("unsupported-expression", `Unable to resolve provenance for expression "${sourceInfo.expression}"`);
+    }
+    return provenance.kind === "external"
+        ? buildExternalResolution(file, provenance)
+        : buildValueResolution(file, sourceInfo.expression, provenance);
+}
+async function resolveConditionalBranchProvenance(ctx) {
+    const { file, source, ast, candidate, readFile, exists, fileCache, visited } = ctx;
+    if (!candidate.conditionSource) {
+        return unsupportedResolution("conditional-branch-unresolved", `Unable to resolve conditional branch source for "${candidate.conditionExpression}"`);
+    }
+    const expressionPath = findExpressionPathByText(ast, source, candidate.conditionExpression);
+    if (!expressionPath) {
+        return unsupportedResolution("conditional-branch-unresolved", `Unable to locate conditional expression "${candidate.conditionExpression}"`);
+    }
+    const provenance = await resolveSourceInfoProvenance({
+        currentFile: file,
+        expressionPath,
+        sourceInfo: candidate.conditionSource,
+        readFile,
+        exists,
+        graph: ctx.graph,
+        externalSourceResolvers: ctx.externalSourceResolvers,
+        externalAdapters: ctx.externalAdapters,
+        functionCallContracts: ctx.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    if (!provenance) {
+        return unsupportedResolution("conditional-branch-unresolved", `Unable to resolve conditional branch source for "${candidate.conditionExpression}"`);
+    }
+    if (provenance.kind === "external") {
+        return unsupportedResolution("conditional-branch-unresolved", `Unable to resolve conditional branch source for "${candidate.conditionExpression}"`);
+    }
+    const resolution = buildValueResolution(file, candidate.conditionExpression, provenance);
+    if (!resolution.finalSource) {
+        return resolution;
+    }
+    return {
+        ...resolution,
+        finalSource: {
+            ...resolution.finalSource,
+            kind: "conditional-branch",
+            displayPath: candidate.conditionExpression,
+        },
+        chain: [
+            ...resolution.chain,
+            {
+                kind: "conditional-branch",
+                file: provenance.file,
+                displayName: candidate.conditionExpression,
+                canEditHere: true,
+            },
+        ],
+    };
+}
+function literalResolution(file, value) {
+    return {
+        finalSource: {
+            kind: "jsx-literal",
+            file,
+            locator: null,
+            displayPath: value,
+        },
+        chain: [
+            {
+                kind: "jsx-literal",
+                file,
+                displayName: value,
+                canEditHere: true,
+            },
+        ],
+        confidence: "exact",
+        editMode: "direct",
+        diagnostics: [],
+    };
+}
+async function unsupportedResolutionForExpression(params) {
+    const diagnostics = await collectExpressionDiagnostics(params);
+    if (diagnostics.length === 0) {
+        return unsupportedResolution("unsupported-expression", `Unsupported expression type: ${params.expression.type}`);
+    }
+    if (isReadonlyExpression(params.expression)) {
+        return readonlyResolutionWithDiagnostics(diagnostics);
+    }
+    if (isInvalidI18nHelperCall(params.expression)) {
+        return unsupportedResolution("unsupported-expression", "i18n helpers require a static message id string");
+    }
+    if (t.isMemberExpression(params.expression) &&
+        params.expression.computed &&
+        !t.isNumericLiteral(params.expression.property) &&
+        !t.isStringLiteral(params.expression.property)) {
+        return unsupportedResolution("dynamic-key", "Computed member expressions are not supported for provenance resolution");
+    }
+    const [primary] = diagnostics;
+    return unsupportedResolution(primary.code, primary.message);
+}
+function unsupportedResolution(code, message) {
+    return {
+        finalSource: null,
+        chain: [],
+        confidence: "unknown",
+        editMode: "unsupported",
+        diagnostics: [{ code, message }],
+    };
+}
+function readonlyResolution(code, message) {
+    return readonlyResolutionWithDiagnostics([{ code, message }]);
+}
+function readonlyResolutionWithDiagnostics(diagnostics) {
+    return {
+        finalSource: null,
+        chain: [],
+        confidence: "partial",
+        editMode: "readonly",
+        diagnostics,
+    };
+}
+function isReadonlyExpression(expr) {
+    return (t.isCallExpression(expr) ||
+        t.isConditionalExpression(expr) ||
+        t.isLogicalExpression(expr) ||
+        t.isBinaryExpression(expr));
+}
+function uniqueDiagnostics(diagnostics) {
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = `${diagnostic.code}:${diagnostic.message}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+async function collectExpressionDiagnostics(params) {
+    const { expression, scope, currentFile, source, readFile, exists, fileCache, visited, functionCallContracts, } = params;
+    const invalidExternalDiagnostic = getInvalidExternalHelperDiagnostic(expression);
+    if (invalidExternalDiagnostic) {
+        return [invalidExternalDiagnostic];
+    }
+    if (t.isCallExpression(expression)) {
+        return [
+            {
+                code: "unsupported-expression",
+                message: getFunctionCallReadonlyMessage(expression, functionCallContracts),
+            },
+        ];
+    }
+    if (t.isMemberExpression(expression) && expression.computed) {
+        const property = expression.property;
+        if (!t.isNumericLiteral(property) && !t.isStringLiteral(property)) {
+            if (!t.isExpression(property)) {
+                return [
+                    {
+                        code: "dynamic-key",
+                        message: "Computed member expressions are not supported for provenance resolution",
+                    },
+                ];
+            }
+            const computedProperty = property;
+            const computedValue = await evaluateStaticExpression(computedProperty, scope, currentFile, readFile, exists, fileCache, visited);
+            if (typeof computedValue !== "string" &&
+                !Number.isInteger(computedValue)) {
+                return [
+                    {
+                        code: "dynamic-key",
+                        message: "Computed member expressions are not supported for provenance resolution",
+                    },
+                ];
+            }
+        }
+    }
+    if (t.isBinaryExpression(expression)) {
+        return uniqueDiagnostics([
+            ...(await collectNestedExpressionDiagnostics(expression.left, expression.right, params)),
+            {
+                code: "unsupported-expression",
+                message: "Mixed expressions are recognized but remain readonly until a safer composition editing strategy is available",
+            },
+        ]);
+    }
+    if (t.isLogicalExpression(expression)) {
+        return uniqueDiagnostics([
+            ...(await collectNestedExpressionDiagnostics(expression.left, expression.right, params)),
+            {
+                code: "unsupported-expression",
+                message: expression.operator === "??" || expression.operator === "||"
+                    ? "Fallback expressions are recognized but remain readonly until a safer composition editing strategy is available"
+                    : "Complex conditional expressions are recognized but remain readonly until a safer editing strategy is available",
+            },
+        ]);
+    }
+    if (t.isConditionalExpression(expression)) {
+        return uniqueDiagnostics([
+            ...(await collectNestedExpressionDiagnostics(expression.test, expression.consequent, expression.alternate, params)),
+            {
+                code: "unsupported-expression",
+                message: "Complex conditional expressions are recognized but remain readonly until a safer editing strategy is available",
+            },
+        ]);
+    }
+    return [];
+}
+function getInvalidExternalHelperDiagnostic(node) {
+    if (isInvalidI18nHelperCall(node)) {
+        return createExternalUnsupportedDiagnostic("i18n helpers require a static message id string");
+    }
+    if (isInvalidCmsHelperCall(node)) {
+        return createExternalUnsupportedDiagnostic("CMS helpers require static entry id and field path string arguments");
+    }
+    return null;
+}
+async function collectNestedExpressionDiagnostics(...args) {
+    const params = args[args.length - 1];
+    const expressions = args.slice(0, -1);
+    const diagnostics = [];
+    for (const expression of expressions) {
+        diagnostics.push(...(await collectExpressionDiagnostics({
+            ...params,
+            expression,
+        })));
+    }
+    return diagnostics;
+}
+function selectExternalAdapter(match, registrations) {
+    const candidates = (registrations ?? []).filter((registration) => registration.sourceType === match.sourceType &&
+        (registration.capabilities === undefined ||
+            registration.capabilities.includes("write-text")));
+    if (match.adapterId) {
+        const explicit = candidates.find((candidate) => candidate.adapterId === match.adapterId);
+        if (explicit) {
+            return {
+                adapterId: explicit.adapterId,
+                editMode: "proxy",
+                diagnostics: [],
+            };
+        }
+    }
+    else if (candidates.length > 0) {
+        return {
+            adapterId: candidates[0]?.adapterId,
+            editMode: "proxy",
+            diagnostics: [],
+        };
+    }
+    return {
+        adapterId: undefined,
+        editMode: "readonly",
+        diagnostics: [createMissingAdapterDiagnostic(match.sourceType)],
+    };
+}
+async function resolveExternalExpression(params) {
+    for (const resolver of BUILT_IN_EXTERNAL_SOURCE_RESOLVERS) {
+        if (!shouldTryExternalSourceResolver(params.expressionPath, resolver.helperNames)) {
+            continue;
+        }
+        const result = await resolver.resolve(params);
+        if (result) {
+            return buildResolvedExternalProvenance(normalizeExternalSourceResolution(result), params.externalAdapters);
+        }
+    }
+    const resolverContext = {
+        currentFile: params.currentFile,
+        expressionPath: params.expressionPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+    };
+    for (const resolver of params.externalSourceResolvers ?? []) {
+        if (!shouldTryExternalSourceResolver(params.expressionPath, resolver.helperNames)) {
+            continue;
+        }
+        const result = await resolver.resolve(resolverContext);
+        if (result) {
+            return buildResolvedExternalProvenance(normalizeExternalSourceResolution(result), params.externalAdapters);
+        }
+    }
+    return null;
+}
+function createMissingAdapterDiagnostic(sourceType) {
+    return {
+        code: "missing-adapter",
+        message: `No external adapter is registered for ${sourceType}`,
+    };
+}
+function createExternalReadonlyDiagnostic(message) {
+    return {
+        code: "external-source-readonly",
+        message,
+    };
+}
+function createExternalUnsupportedDiagnostic(message) {
+    return {
+        code: "unsupported-expression",
+        message,
+    };
+}
+function getCallExpressionHelperName(node) {
+    if (!node || !t.isCallExpression(node)) {
+        return null;
+    }
+    if (t.isIdentifier(node.callee)) {
+        return node.callee.name;
+    }
+    if (t.isMemberExpression(node.callee) &&
+        !node.callee.computed &&
+        t.isIdentifier(node.callee.object) &&
+        t.isIdentifier(node.callee.property)) {
+        return `${node.callee.object.name}.${node.callee.property.name}`;
+    }
+    return null;
+}
+function shouldTryExternalSourceResolver(expressionPath, helperNames) {
+    if (!helperNames || helperNames.length === 0) {
+        return true;
+    }
+    const helperName = getCallExpressionHelperName(expressionPath.node);
+    return helperName ? helperNames.includes(helperName) : false;
+}
+function normalizeExternalSourceResolution(result) {
+    if ("match" in result) {
+        return {
+            match: result.match,
+            editMode: result.editMode,
+            diagnostics: uniqueDiagnostics(result.diagnostics ?? []),
+        };
+    }
+    return {
+        match: result,
+        diagnostics: [],
+    };
+}
+function buildResolvedExternalProvenance(result, registrations) {
+    const selected = selectExternalAdapter(result.match, registrations);
+    return {
+        kind: "external",
+        file: result.match.file,
+        sourceType: result.match.sourceType,
+        sourceId: result.match.sourceId,
+        adapterId: result.match.adapterId ?? selected.adapterId,
+        displayPath: result.match.displayPath,
+        editMode: result.editMode === "readonly" ? "readonly" : selected.editMode,
+        diagnostics: uniqueDiagnostics([
+            ...result.diagnostics,
+            ...(result.editMode === "readonly" || selected.editMode === "readonly"
+                ? selected.diagnostics
+                : []),
+        ]),
+    };
+}
+function resolveCmsFieldExpression(expressionPath) {
+    if (!expressionPath.isCallExpression()) {
+        return null;
+    }
+    const callee = expressionPath.node.callee;
+    if (!t.isIdentifier(callee) || callee.name !== "getCmsField") {
+        return null;
+    }
+    const [entryArgument, fieldArgument] = expressionPath.node.arguments;
+    if (!entryArgument ||
+        !fieldArgument ||
+        !t.isStringLiteral(entryArgument) ||
+        !t.isStringLiteral(fieldArgument)) {
+        return null;
+    }
+    const entryId = entryArgument.value;
+    const fieldPath = fieldArgument.value;
+    return {
+        sourceType: "cms-field",
+        sourceId: `${entryId}:${fieldPath}`,
+        file: `cms://${entryId}/${fieldPath.replace(/\./g, "/")}`,
+        displayPath: `${entryId}.${fieldPath}`,
+    };
+}
+function isInvalidCmsHelperCall(node) {
+    return (!!node &&
+        t.isCallExpression(node) &&
+        t.isIdentifier(node.callee) &&
+        node.callee.name === "getCmsField" &&
+        (node.arguments.length < 2 ||
+            !t.isStringLiteral(node.arguments[0]) ||
+            !t.isStringLiteral(node.arguments[1])));
+}
+function getI18nMessageIdFromCall(node) {
+    if (!node || !t.isCallExpression(node)) {
+        return undefined;
+    }
+    if (t.isIdentifier(node.callee) && node.callee.name === "t") {
+        const [firstArg] = node.arguments;
+        return firstArg && t.isStringLiteral(firstArg) ? firstArg.value : null;
+    }
+    if (t.isMemberExpression(node.callee) &&
+        !node.callee.computed &&
+        t.isIdentifier(node.callee.object) &&
+        node.callee.object.name === "intl" &&
+        t.isIdentifier(node.callee.property) &&
+        node.callee.property.name === "formatMessage") {
+        const [descriptorArg] = node.arguments;
+        if (!descriptorArg || !t.isObjectExpression(descriptorArg)) {
+            return null;
+        }
+        for (const property of descriptorArg.properties) {
+            if (t.isObjectProperty(property) &&
+                !property.computed &&
+                ((t.isIdentifier(property.key) && property.key.name === "id") ||
+                    (t.isStringLiteral(property.key) && property.key.value === "id")) &&
+                t.isStringLiteral(property.value)) {
+                return property.value.value;
+            }
+        }
+        return null;
+    }
+    return undefined;
+}
+function isInvalidI18nHelperCall(node) {
+    return getI18nMessageIdFromCall(node) === null;
+}
+async function locateLocaleFile(currentFile, locale, exists) {
+    const directories = new Set();
+    let cursor = path.posix.dirname(currentFile);
+    while (true) {
+        directories.add(cursor);
+        if (cursor === "." || cursor === "/") {
+            break;
+        }
+        const parent = path.posix.dirname(cursor);
+        if (parent === cursor) {
+            directories.add(".");
+            break;
+        }
+        cursor = parent;
+    }
+    directories.add("src");
+    directories.add(".");
+    for (const directory of directories) {
+        const prefixes = directory === "."
+            ? ["locales", "messages"]
+            : [
+                path.posix.join(directory, "locales"),
+                path.posix.join(directory, "messages"),
+            ];
+        for (const prefix of prefixes) {
+            const candidate = path.posix.join(prefix, `${locale}.json`);
+            if (await exists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function resolveI18nExpression(params) {
+    const messageId = getI18nMessageIdFromCall(params.expressionPath.node);
+    if (typeof messageId !== "string" || messageId.length === 0) {
+        return null;
+    }
+    const locale = "en";
+    const localeFile = await locateLocaleFile(params.currentFile, locale, params.exists);
+    if (!localeFile) {
+        return null;
+    }
+    return {
+        sourceType: "i18n-message",
+        sourceId: `${locale}:${messageId}`,
+        file: localeFile,
+        displayPath: messageId,
+    };
+}
+async function resolveApiFieldExpression(params) {
+    if (!params.expressionPath.isCallExpression()) {
+        return null;
+    }
+    const callee = params.expressionPath.node.callee;
+    if (!t.isIdentifier(callee) || callee.name !== "apiField") {
+        return null;
+    }
+    const [mappingArgument, transformArgument] = params.expressionPath.node.arguments;
+    if (!mappingArgument || !t.isExpression(mappingArgument)) {
+        return null;
+    }
+    const sourceId = await evaluateStaticExpression(mappingArgument, params.expressionPath.scope, params.currentFile, params.readFile, params.exists, params.fileCache, params.visited);
+    if (typeof sourceId !== "string" || sourceId.length === 0) {
+        return null;
+    }
+    const match = {
+        sourceType: "api-field",
+        sourceId,
+        file: `api://${sourceId}`,
+        displayPath: sourceId,
+    };
+    if (transformArgument) {
+        return {
+            match,
+            editMode: "readonly",
+            diagnostics: [
+                createExternalReadonlyDiagnostic("API mapping transforms must stay readonly until a reversible mapping strategy is registered"),
+            ],
+        };
+    }
+    return match;
+}
+const BUILT_IN_EXTERNAL_SOURCE_RESOLVERS = [
+    {
+        helperNames: ["getCmsField"],
+        resolve: ({ expressionPath }) => resolveCmsFieldExpression(expressionPath),
+    },
+    {
+        helperNames: ["apiField"],
+        resolve: (params) => resolveApiFieldExpression(params),
+    },
+    {
+        helperNames: ["t", "intl.formatMessage"],
+        resolve: ({ currentFile, expressionPath, exists }) => resolveI18nExpression({
+            currentFile,
+            expressionPath,
+            exists,
+        }),
+    },
+];
+function buildExternalResolution(currentFile, provenance) {
+    return {
+        finalSource: {
+            kind: provenance.sourceType,
+            file: provenance.file,
+            locator: null,
+            displayPath: provenance.displayPath,
+            externalSource: {
+                sourceType: provenance.sourceType,
+                sourceId: provenance.sourceId,
+                adapterId: provenance.adapterId,
+            },
+        },
+        chain: [
+            ...(provenance.chainPrefix ?? []),
+            {
+                kind: provenance.sourceType,
+                file: provenance.file,
+                displayName: provenance.displayPath,
+                canEditHere: provenance.editMode !== "readonly",
+            },
+        ],
+        confidence: "exact",
+        editMode: provenance.editMode === "direct"
+            ? provenance.file === currentFile
+                ? "direct"
+                : "proxy"
+            : provenance.editMode,
+        diagnostics: provenance.diagnostics,
+    };
+}
+function buildValueResolution(currentFile, displayExpression, provenance) {
+    const locator = {
+        kind: "value",
+        root: provenance.root,
+        path: provenance.path.length > 0 ? provenance.path : [],
+    };
+    const hasIndex = provenance.path.some((segment) => segment.kind === "index");
+    const configEntry = describeConfigEntry(provenance);
+    let finalKind;
+    if (provenance.semanticKind) {
+        finalKind = provenance.semanticKind;
+    }
+    else if (configEntry) {
+        finalKind = "config-entry";
+    }
+    else if (provenance.sourceKind === "repeat-template") {
+        finalKind = "repeat-template";
+    }
+    else if (provenance.path.length === 0) {
+        finalKind =
+            provenance.sourceKind === "imported-binding"
+                ? "imported-binding"
+                : "binding";
+    }
+    else {
+        finalKind = hasIndex ? "array-item" : "object-field";
+    }
+    const resolvedDisplayExpression = provenance.displayExpression ?? displayExpression;
+    const chain = [...(provenance.chainPrefix ?? [])];
+    if (provenance.sourceKind === "binding") {
+        chain.push({
+            kind: "binding",
+            file: provenance.file,
+            displayName: provenance.root.kind === "binding"
+                ? provenance.root.name
+                : resolvedDisplayExpression,
+            canEditHere: true,
+        });
+    }
+    else if (provenance.sourceKind === "imported-binding") {
+        chain.push({
+            kind: "imported-binding",
+            file: provenance.file,
+            displayName: provenance.root.kind === "named-export"
+                ? provenance.root.name
+                : "default",
+            canEditHere: true,
+        });
+    }
+    else if (provenance.sourceKind === "repeat-template") {
+        chain.push({
+            kind: "repeat-template",
+            file: provenance.file,
+            displayName: displayExpression,
+            canEditHere: true,
+        });
+    }
+    if (provenance.path.length > 0 &&
+        provenance.sourceKind !== "repeat-template") {
+        chain.push({
+            kind: hasIndex ? "array-item" : "object-field",
+            file: provenance.file,
+            displayName: resolvedDisplayExpression,
+            canEditHere: true,
+        });
+    }
+    if (configEntry) {
+        chain.push({
+            kind: "config-entry",
+            file: provenance.file,
+            displayName: configEntry.displayPath,
+            canEditHere: true,
+        });
+    }
+    return {
+        finalSource: {
+            kind: finalKind,
+            file: provenance.file,
+            locator,
+            root: provenance.root,
+            path: provenance.path,
+            displayPath: resolvedDisplayExpression,
+            externalSource: configEntry
+                ? {
+                    sourceType: "config-entry",
+                    sourceId: configEntry.sourceId,
+                }
+                : undefined,
+        },
+        chain,
+        confidence: provenance.sourceKind === "repeat-template" ? "safe-derived" : "exact",
+        editMode: provenance.editMode ??
+            (provenance.file === currentFile ? "direct" : "proxy"),
+        diagnostics: provenance.diagnostics ?? [],
+    };
+}
+const DEFAULT_FUNCTION_CALL_CONTRACTS = [
+    { helperName: "formatPrice", purity: "pure", sourceArgIndex: 0 },
+    { helperName: "formatDate", purity: "pure", sourceArgIndex: 0 },
+    { helperName: "pickLabel", purity: "pure", sourceArgIndex: 0 },
+];
+function getFunctionCallContract(helperName, contracts) {
+    const allContracts = [
+        ...DEFAULT_FUNCTION_CALL_CONTRACTS,
+        ...(contracts ?? []),
+    ];
+    for (let index = allContracts.length - 1; index >= 0; index -= 1) {
+        const contract = allContracts[index];
+        if (contract?.helperName === helperName) {
+            return contract;
+        }
+    }
+    return null;
+}
+function getFunctionCallReadonlyMessage(expression, contracts) {
+    const callee = expression.callee;
+    if (!t.isIdentifier(callee)) {
+        return "Function calls are recognized but remain readonly until a pure-call strategy is registered";
+    }
+    const contract = getFunctionCallContract(callee.name, contracts);
+    if (contract?.purity === "side-effect") {
+        return `Helper "${callee.name}" is registered as side-effectful and remains readonly`;
+    }
+    return "Function calls are recognized but remain readonly until a pure-call strategy is registered";
+}
+async function resolveDirectExpressionProvenance(params) {
+    const directExternal = await resolveExternalExpression(params);
+    if (directExternal) {
+        return directExternal;
+    }
+    if (params.expressionPath.isTemplateLiteral()) {
+        const expression = params.expressionPath.node.expressions[0];
+        const expressionPath = params.expressionPath.get("expressions.0");
+        if (params.expressionPath.node.expressions.length === 1 &&
+            expression &&
+            expressionPath &&
+            !Array.isArray(expressionPath) &&
+            expressionPath.isExpression()) {
+            const sourceInfo = await buildExpressionSourceInfo({
+                expression: expressionPath.node,
+                scope: expressionPath.scope,
+                source: params.fileCache.get(params.currentFile)?.source,
+                currentFile: params.currentFile,
+                readFile: params.readFile,
+                exists: params.exists,
+                fileCache: params.fileCache,
+                visited: params.visited,
+            });
+            if (sourceInfo) {
+                const upstream = await resolveSourceInfoProvenance({
+                    ...params,
+                    expressionPath,
+                    sourceInfo,
+                });
+                if (upstream && upstream.kind === "value") {
+                    return {
+                        ...upstream,
+                        displayExpression: sourceInfo.expression,
+                        editMode: "readonly",
+                        diagnostics: [
+                            {
+                                code: "unsupported-expression",
+                                message: "Mixed expressions are recognized but remain readonly until a safer composition editing strategy is available",
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+    }
+    return await resolvePureHelperExpression(params);
+}
+async function resolvePureHelperExpression(params) {
+    if (!params.expressionPath.isCallExpression()) {
+        return null;
+    }
+    const helperName = getCallExpressionHelperName(params.expressionPath.node);
+    if (!helperName) {
+        return null;
+    }
+    const contract = getFunctionCallContract(helperName, params.functionCallContracts);
+    if (!contract || contract.purity !== "pure") {
+        return null;
+    }
+    const sourceArgIndex = contract.sourceArgIndex ?? 0;
+    const argumentPath = params.expressionPath.get(`arguments.${sourceArgIndex}`);
+    if (!argumentPath ||
+        Array.isArray(argumentPath) ||
+        !argumentPath.isExpression()) {
+        return null;
+    }
+    return await resolveHelperSourceArgumentProvenance({
+        currentFile: params.currentFile,
+        argumentPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+}
+async function resolveHelperSourceArgumentProvenance(params) {
+    const directExternal = await resolveExternalExpression({
+        currentFile: params.currentFile,
+        expressionPath: params.argumentPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (directExternal) {
+        return directExternal;
+    }
+    const sourceInfo = await buildExpressionSourceInfo({
+        expression: params.argumentPath.node,
+        scope: params.argumentPath.scope,
+        source: params.fileCache.get(params.currentFile)?.source,
+        currentFile: params.currentFile,
+        readFile: params.readFile,
+        exists: params.exists,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (sourceInfo) {
+        const upstream = await resolveSourceInfoProvenance({
+            currentFile: params.currentFile,
+            expressionPath: params.argumentPath,
+            sourceInfo,
+            readFile: params.readFile,
+            exists: params.exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache: params.fileCache,
+            visited: params.visited,
+        });
+        if (!upstream || upstream.kind === "external") {
+            return upstream;
+        }
+        return {
+            ...upstream,
+            displayExpression: sourceInfo.expression,
+        };
+    }
+    return await resolveDirectExpressionProvenance({
+        currentFile: params.currentFile,
+        expressionPath: params.argumentPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+}
+async function resolvePureHelperBinding(params) {
+    if (!params.binding.path.isVariableDeclarator()) {
+        return null;
+    }
+    const init = params.binding.path.node.init;
+    if (!init || !t.isCallExpression(init)) {
+        return null;
+    }
+    const callee = init.callee;
+    if (!t.isIdentifier(callee)) {
+        return null;
+    }
+    const contract = getFunctionCallContract(callee.name, params.functionCallContracts);
+    if (!contract || contract.purity !== "pure") {
+        return null;
+    }
+    const sourceArgIndex = contract.sourceArgIndex ?? 0;
+    const initPath = params.binding.path.get("init");
+    if (!initPath || Array.isArray(initPath) || !initPath.isCallExpression()) {
+        return null;
+    }
+    const argumentPath = initPath.get(`arguments.${sourceArgIndex}`);
+    if (!argumentPath ||
+        Array.isArray(argumentPath) ||
+        !argumentPath.isExpression()) {
+        return null;
+    }
+    const upstream = await resolveHelperSourceArgumentProvenance({
+        currentFile: params.currentFile,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+        argumentPath,
+    });
+    return upstream;
+}
+function describeConfigEntry(provenance) {
+    if (provenance.sourceKind !== "imported-binding") {
+        return null;
+    }
+    const rootName = provenance.root.kind === "binding" ||
+        provenance.root.kind === "named-export"
+        ? provenance.root.name
+        : provenance.root.kind === "default-export"
+            ? "default"
+            : null;
+    if (!rootName) {
+        return null;
+    }
+    const isConfigFile = /(^|[\/.-])(config|settings)([\/.-]|$)/i.test(provenance.file);
+    const isConfigRoot = /config|settings/i.test(rootName);
+    if (!isConfigFile && !isConfigRoot) {
+        return null;
+    }
+    const displayPath = appendExpressionPath(rootName, provenance.path);
+    return {
+        sourceId: displayPath,
+        displayPath,
+    };
+}
+async function resolveSegmentProvenance(ctx) {
+    const sourceInfo = ctx.segment.source;
+    if (!sourceInfo) {
+        return null;
+    }
+    return resolveSourceInfoProvenance({
+        currentFile: ctx.currentFile,
+        expressionPath: ctx.expressionPath,
+        sourceInfo,
+        readFile: ctx.readFile,
+        exists: ctx.exists,
+        graph: ctx.graph,
+        externalSourceResolvers: ctx.externalSourceResolvers,
+        externalAdapters: ctx.externalAdapters,
+        functionCallContracts: ctx.functionCallContracts,
+        fileCache: ctx.fileCache,
+        visited: ctx.visited,
+    });
+}
+async function resolveSourceInfoProvenance(ctx) {
+    const sourceInfo = ctx.sourceInfo;
+    const repeatContext = findRepeatContext(ctx.expressionPath, sourceInfo.base);
+    if (repeatContext &&
+        (sourceInfo.path.length > 0 || repeatContext.basePath.length > 0)) {
+        const collectionTarget = await resolveRepeatCollectionTarget({
+            currentFile: ctx.currentFile,
+            callPath: repeatContext.callPath,
+            readFile: ctx.readFile,
+            exists: ctx.exists,
+            graph: ctx.graph,
+            externalSourceResolvers: ctx.externalSourceResolvers,
+            externalAdapters: ctx.externalAdapters,
+            fileCache: ctx.fileCache,
+            visited: ctx.visited,
+        });
+        if (!collectionTarget) {
+            const apiSource = classifyRepeatCollectionSource(repeatContext.callPath, [
+                ...repeatContext.basePath,
+                ...sourceInfo.path,
+            ]);
+            return isApiSource(apiSource)
+                ? buildApiExternalProvenance(ctx.currentFile, apiSource.sourceId, apiSource.displayPath)
+                : null;
+        }
+        const itemPathMap = buildRepeatItemPathMap(collectionTarget, [
+            ...repeatContext.basePath,
+            ...sourceInfo.path,
+        ]);
+        const sourceIndex = collectionTarget.collectionIndexMap?.[0] ?? 0;
+        const path = [
+            ...(collectionTarget.pathPrefix ?? []),
+            { kind: "index", index: sourceIndex },
+            ...repeatContext.basePath,
+            ...sourceInfo.path,
+        ];
+        const visibleValuePath = [
+            { kind: "index", index: 0 },
+            ...repeatContext.basePath,
+            ...sourceInfo.path,
+        ];
+        const value = followStaticPath(collectionTarget.value, visibleValuePath);
+        if (value === undefined) {
+            return null;
+        }
+        return {
+            kind: "value",
+            file: collectionTarget.file,
+            root: collectionTarget.root,
+            path: itemPathMap?.[0] ?? path,
+            sourceKind: "repeat-template",
+            collectionIndexMap: collectionTarget.collectionIndexMap,
+            ...(itemPathMap ? { collectionPathMap: itemPathMap } : {}),
+        };
+    }
+    if (repeatContext) {
+        const apiSource = classifyRepeatCollectionSource(repeatContext.callPath, []);
+        return isApiSource(apiSource)
+            ? buildApiExternalProvenance(ctx.currentFile, apiSource.sourceId, apiSource.displayPath)
+            : null;
+    }
+    const binding = ctx.expressionPath.scope.getBinding(sourceInfo.base);
+    if (!binding) {
+        return null;
+    }
+    const aliasInitializer = findAliasInitializer(binding);
+    if (aliasInitializer) {
+        const initPath = aliasInitializer.expressionPath;
+        const aliasSourceInfo = await buildExpressionSourceInfo({
+            expression: initPath.node,
+            scope: initPath.scope,
+            currentFile: ctx.currentFile,
+            readFile: ctx.readFile,
+            exists: ctx.exists,
+            fileCache: ctx.fileCache,
+            visited: ctx.visited,
+        });
+        if (aliasSourceInfo) {
+            const resolvedAlias = await resolveSourceInfoProvenance({
+                ...ctx,
+                expressionPath: initPath,
+                sourceInfo: {
+                    ...aliasSourceInfo,
+                    expression: appendExpressionPath(aliasSourceInfo.expression, sourceInfo.path),
+                    path: [...aliasSourceInfo.path, ...sourceInfo.path],
+                },
+            });
+            if (resolvedAlias) {
+                return resolvedAlias;
+            }
+        }
+    }
+    if (binding.kind === "param") {
+        return resolveComponentPropBinding({
+            currentFile: ctx.currentFile,
+            binding,
+            sourceInfo,
+            graph: ctx.graph,
+            readFile: ctx.readFile,
+            exists: ctx.exists,
+            externalSourceResolvers: ctx.externalSourceResolvers,
+            externalAdapters: ctx.externalAdapters,
+            functionCallContracts: ctx.functionCallContracts,
+            fileCache: ctx.fileCache,
+            visited: ctx.visited,
+        });
+    }
+    const pureHelperProvenance = await resolvePureHelperBinding({
+        currentFile: ctx.currentFile,
+        binding,
+        readFile: ctx.readFile,
+        exists: ctx.exists,
+        graph: ctx.graph,
+        externalSourceResolvers: ctx.externalSourceResolvers,
+        externalAdapters: ctx.externalAdapters,
+        functionCallContracts: ctx.functionCallContracts,
+        fileCache: ctx.fileCache,
+        visited: ctx.visited,
+    });
+    if (pureHelperProvenance) {
+        return pureHelperProvenance;
+    }
+    const dataSource = classifyBindingDataSource(binding, sourceInfo.path);
+    if (isApiSource(dataSource)) {
+        return buildApiExternalProvenance(ctx.currentFile, dataSource.sourceId, dataSource.displayPath);
+    }
+    const provenance = await resolveBindingTarget({
+        currentFile: ctx.currentFile,
+        binding,
+        readFile: ctx.readFile,
+        exists: ctx.exists,
+        graph: ctx.graph,
+        externalSourceResolvers: ctx.externalSourceResolvers,
+        externalAdapters: ctx.externalAdapters,
+        functionCallContracts: ctx.functionCallContracts,
+        fileCache: ctx.fileCache,
+        visited: ctx.visited,
+    });
+    if (!provenance) {
+        return null;
+    }
+    if (provenance.kind === "external") {
+        return sourceInfo.path.length === 0 ? provenance : null;
+    }
+    const value = followStaticPath(provenance.value, sourceInfo.path);
+    if (value === undefined) {
+        return null;
+    }
+    return {
+        kind: "value",
+        file: provenance.file,
+        root: provenance.root,
+        path: sourceInfo.path,
+        sourceKind: provenance.sourceKind,
+        collectionIndexMap: provenance.collectionIndexMap,
+    };
+}
+function findRepeatContext(expressionPath, baseName) {
+    const binding = expressionPath.scope.getBinding(baseName);
+    if (!binding) {
+        return null;
+    }
+    const functionPath = binding.path.getFunctionParent();
+    if (!functionPath ||
+        (!functionPath.isArrowFunctionExpression() &&
+            !functionPath.isFunctionExpression())) {
+        return null;
+    }
+    const firstParam = functionPath.node.params[0];
+    const basePath = findPatternBindingPath(firstParam, baseName);
+    if (!basePath) {
+        return null;
+    }
+    const callPath = functionPath.parentPath;
+    if (!callPath || !callPath.isCallExpression()) {
+        return null;
+    }
+    if (!isMapCallback(callPath, functionPath)) {
+        return null;
+    }
+    return { callPath, basePath };
+}
+function isMapCallback(callPath, functionPath) {
+    const callee = callPath.node.callee;
+    if (!t.isMemberExpression(callee)) {
+        return false;
+    }
+    if (!t.isIdentifier(callee.property) || callee.property.name !== "map") {
+        return false;
+    }
+    return callPath.node.arguments.some((argument) => argument === functionPath.node);
+}
+async function resolveRepeatCollectionTarget(params) {
+    const { currentFile, callPath, readFile, exists, fileCache, visited } = params;
+    const callee = callPath.node.callee;
+    if (!t.isMemberExpression(callee) ||
+        !t.isIdentifier(callee.property) ||
+        callee.property.name !== "map") {
+        return null;
+    }
+    const calleePath = callPath.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        return null;
+    }
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+        return null;
+    }
+    const provenance = await resolveStaticCollectionExpression({
+        currentFile,
+        expressionPath: objectPath,
+        readFile,
+        exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    if (!provenance) {
+        return null;
+    }
+    if (!Array.isArray(provenance.value) || provenance.value.length === 0) {
+        return null;
+    }
+    return provenance;
+}
+function classifyRepeatCollectionSource(callPath, valuePath) {
+    const calleePath = callPath.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        return null;
+    }
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+        return null;
+    }
+    return classifyExpressionDataSource(objectPath, valuePath);
+}
+async function resolveStaticCollectionExpression(params) {
+    const { currentFile, expressionPath, readFile, exists, fileCache, visited } = params;
+    if (expressionPath.isIdentifier()) {
+        const binding = expressionPath.scope.getBinding(expressionPath.node.name);
+        if (!binding) {
+            return null;
+        }
+        const provenance = await resolveBindingTarget({
+            currentFile,
+            binding,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+        return provenance?.kind === "static" ? provenance : null;
+    }
+    if (expressionPath.isCallExpression()) {
+        return resolveCollectionCallTarget({
+            currentFile,
+            callPath: expressionPath,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+    }
+    if (expressionPath.isTSAsExpression() ||
+        expressionPath.isTSSatisfiesExpression() ||
+        expressionPath.isTSNonNullExpression()) {
+        const innerPath = expressionPath.get("expression");
+        if (!Array.isArray(innerPath) && innerPath.isExpression()) {
+            return resolveStaticCollectionExpression({
+                ...params,
+                expressionPath: innerPath,
+            });
+        }
+    }
+    if (expressionPath.isArrayExpression()) {
+        const sourceRange = toValueSourceRange(expressionPath.node);
+        if (!sourceRange) {
+            return null;
+        }
+        const value = await evaluateStaticExpression(expressionPath.node, expressionPath.scope, currentFile, readFile, exists, fileCache, visited);
+        if (!Array.isArray(value)) {
+            return null;
+        }
+        return {
+            kind: "static",
+            file: currentFile,
+            root: { kind: "expression", sourceRange },
+            value,
+            sourceKind: "binding",
+        };
+    }
+    if (expressionPath.isMemberExpression()) {
+        const sourceInfo = await buildExpressionSourceInfo({
+            expression: expressionPath.node,
+            scope: expressionPath.scope,
+            currentFile,
+            readFile,
+            exists,
+            fileCache,
+            visited,
+        });
+        if (!sourceInfo) {
+            return null;
+        }
+        const provenance = await resolveSourceInfoProvenance({
+            currentFile,
+            expressionPath,
+            sourceInfo,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+        if (!provenance || provenance.kind === "external") {
+            return null;
+        }
+        const rootTarget = await resolveStaticRootTarget({
+            currentFile,
+            expressionPath,
+            provenance,
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+        if (!rootTarget || rootTarget.kind !== "static") {
+            return null;
+        }
+        if (provenance.collectionPathMap?.length) {
+            const flattened = flattenCollectionPathMap(rootTarget.value, provenance.collectionPathMap);
+            if (flattened) {
+                return {
+                    kind: "static",
+                    file: provenance.file,
+                    root: provenance.root,
+                    value: flattened.value,
+                    sourceKind: provenance.sourceKind,
+                    collectionPathMap: flattened.collectionPathMap,
+                };
+            }
+        }
+        const value = followStaticPath(rootTarget.value, provenance.path);
+        if (!Array.isArray(value)) {
+            return null;
+        }
+        return {
+            kind: "static",
+            file: provenance.file,
+            root: provenance.root,
+            value,
+            sourceKind: provenance.sourceKind,
+            pathPrefix: provenance.path,
+            collectionIndexMap: provenance.collectionIndexMap,
+            collectionPathMap: provenance.collectionPathMap,
+        };
+    }
+    return null;
+}
+async function resolveStaticRootTarget(params) {
+    const { provenance } = params;
+    if (provenance.root.kind === "binding") {
+        const rootBinding = params.expressionPath.scope.getBinding(provenance.root.name);
+        if (!rootBinding) {
+            return null;
+        }
+        return await resolveBindingTarget({
+            currentFile: params.currentFile,
+            binding: rootBinding,
+            readFile: params.readFile,
+            exists: params.exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache: params.fileCache,
+            visited: params.visited,
+        });
+    }
+    if (provenance.root.kind !== "expression") {
+        return null;
+    }
+    const loaded = await loadFile(provenance.file, params.readFile, params.fileCache);
+    if (!loaded.ast) {
+        return null;
+    }
+    const rootExpressionPath = findExpressionPathByExactRange(loaded.ast, provenance.root.sourceRange);
+    if (!rootExpressionPath) {
+        return null;
+    }
+    const value = await evaluateStaticExpression(rootExpressionPath.node, rootExpressionPath.scope, provenance.file, params.readFile, params.exists, params.fileCache, params.visited);
+    if (value === undefined) {
+        return null;
+    }
+    return {
+        kind: "static",
+        file: provenance.file,
+        root: provenance.root,
+        value,
+        sourceKind: provenance.sourceKind,
+    };
+}
+async function resolveCollectionCallTarget(params) {
+    return ((await resolveFilterCallTarget(params)) ??
+        (await resolveSliceCallTarget(params)) ??
+        (await resolveSortCallTarget(params)));
+}
+async function resolveFilterCallTarget(params) {
+    const { callPath } = params;
+    const callee = callPath.node.callee;
+    if (!t.isMemberExpression(callee) ||
+        !t.isIdentifier(callee.property) ||
+        callee.property.name !== "filter") {
+        return null;
+    }
+    const calleePath = callPath.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        return null;
+    }
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+        return null;
+    }
+    const upstream = await resolveStaticCollectionExpression({
+        currentFile: params.currentFile,
+        expressionPath: objectPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (!upstream || !Array.isArray(upstream.value)) {
+        return null;
+    }
+    const [callback] = callPath.node.arguments;
+    if (!t.isArrowFunctionExpression(callback) &&
+        !t.isFunctionExpression(callback)) {
+        return null;
+    }
+    const firstParam = callback.params[0];
+    if (!t.isIdentifier(firstParam)) {
+        return null;
+    }
+    const predicate = getFilterPredicateExpression(callback);
+    if (!predicate) {
+        return null;
+    }
+    const filteredValue = [];
+    const collectionIndexMap = [];
+    const collectionPathMap = [];
+    for (const [index, value] of upstream.value.entries()) {
+        const keep = evaluateStaticFilterPredicate(predicate, firstParam.name, value);
+        if (typeof keep !== "boolean") {
+            return null;
+        }
+        if (keep) {
+            filteredValue.push(value);
+            collectionIndexMap.push(upstream.collectionIndexMap?.[index] ?? index);
+            const itemPath = upstream.collectionPathMap?.[index];
+            if (itemPath) {
+                collectionPathMap.push(itemPath);
+            }
+        }
+    }
+    return {
+        ...upstream,
+        value: filteredValue,
+        pathPrefix: upstream.pathPrefix,
+        collectionIndexMap,
+        ...(collectionPathMap.length > 0 ? { collectionPathMap } : {}),
+    };
+}
+async function resolveSliceCallTarget(params) {
+    const { callPath } = params;
+    const callee = callPath.node.callee;
+    if (!t.isMemberExpression(callee) ||
+        !t.isIdentifier(callee.property) ||
+        callee.property.name !== "slice") {
+        return null;
+    }
+    const calleePath = callPath.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        return null;
+    }
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+        return null;
+    }
+    const upstream = await resolveStaticCollectionExpression({
+        currentFile: params.currentFile,
+        expressionPath: objectPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (!upstream || !Array.isArray(upstream.value)) {
+        return null;
+    }
+    const [startArg, endArg] = callPath.node.arguments;
+    const start = getStaticSliceIndex(startArg, 0);
+    const end = getStaticSliceIndex(endArg, upstream.value.length);
+    if (start === null || end === null) {
+        return null;
+    }
+    const normalizedStart = Math.max(0, start < 0 ? upstream.value.length + start : start);
+    const normalizedEnd = Math.max(0, end < 0 ? upstream.value.length + end : end);
+    const collectionIndexMap = upstream.value
+        .map((_, index) => upstream.collectionIndexMap?.[index] ?? index)
+        .slice(normalizedStart, normalizedEnd);
+    const collectionPathMap = upstream.collectionPathMap?.slice(normalizedStart, normalizedEnd);
+    return {
+        ...upstream,
+        value: upstream.value.slice(normalizedStart, normalizedEnd),
+        pathPrefix: upstream.pathPrefix,
+        collectionIndexMap,
+        ...(collectionPathMap ? { collectionPathMap } : {}),
+    };
+}
+function getStaticSliceIndex(node, fallback) {
+    if (!node) {
+        return fallback;
+    }
+    return t.isNumericLiteral(node) && Number.isInteger(node.value)
+        ? node.value
+        : null;
+}
+async function resolveSortCallTarget(params) {
+    const { callPath } = params;
+    const callee = callPath.node.callee;
+    if (!t.isMemberExpression(callee) ||
+        !t.isIdentifier(callee.property) ||
+        (callee.property.name !== "sort" && callee.property.name !== "toSorted")) {
+        return null;
+    }
+    const calleePath = callPath.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        return null;
+    }
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+        return null;
+    }
+    const upstream = await resolveStaticCollectionExpression({
+        currentFile: params.currentFile,
+        expressionPath: objectPath,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (!upstream || !Array.isArray(upstream.value)) {
+        return null;
+    }
+    const [comparator] = callPath.node.arguments;
+    if (!t.isArrowFunctionExpression(comparator) &&
+        !t.isFunctionExpression(comparator)) {
+        return null;
+    }
+    const [leftParam, rightParam] = comparator.params;
+    if (!t.isIdentifier(leftParam) || !t.isIdentifier(rightParam)) {
+        return null;
+    }
+    const entries = upstream.value.map((value, index) => ({
+        value,
+        sourceIndex: upstream.collectionIndexMap?.[index] ?? index,
+        originalIndex: index,
+    }));
+    const sortedEntries = [...entries];
+    for (const left of entries) {
+        for (const right of entries) {
+            if (evaluateStaticSortComparator(comparator, leftParam.name, rightParam.name, left.value, right.value) === undefined) {
+                return null;
+            }
+        }
+    }
+    sortedEntries.sort((left, right) => {
+        const compared = evaluateStaticSortComparator(comparator, leftParam.name, rightParam.name, left.value, right.value) ?? 0;
+        return compared === 0 ? left.originalIndex - right.originalIndex : compared;
+    });
+    return {
+        ...upstream,
+        value: sortedEntries.map((entry) => entry.value),
+        pathPrefix: upstream.pathPrefix,
+        collectionIndexMap: sortedEntries.map((entry) => entry.sourceIndex),
+        ...(upstream.collectionPathMap
+            ? {
+                collectionPathMap: sortedEntries
+                    .map((entry) => upstream.collectionPathMap?.[entry.originalIndex])
+                    .filter((path) => Boolean(path)),
+            }
+            : {}),
+    };
+}
+function evaluateStaticSortComparator(comparator, leftName, rightName, leftValue, rightValue) {
+    const body = t.isExpression(comparator.body)
+        ? comparator.body
+        : comparator.body.body.find((statement) => t.isReturnStatement(statement))?.argument;
+    if (!body || !t.isExpression(body)) {
+        return undefined;
+    }
+    const value = evaluateStaticSortExpression(body, leftName, rightName, leftValue, rightValue);
+    return typeof value === "number" ? value : undefined;
+}
+function evaluateStaticSortExpression(expression, leftName, rightName, leftValue, rightValue) {
+    if (t.isNumericLiteral(expression) ||
+        t.isStringLiteral(expression) ||
+        t.isBooleanLiteral(expression)) {
+        return expression.value;
+    }
+    if (t.isIdentifier(expression)) {
+        if (expression.name === leftName) {
+            return leftValue;
+        }
+        if (expression.name === rightName) {
+            return rightValue;
+        }
+        return undefined;
+    }
+    if (t.isMemberExpression(expression)) {
+        const leftPath = normalizeParamMemberExpression(expression, leftName);
+        if (leftPath) {
+            return followStaticPath(leftValue, leftPath);
+        }
+        const rightPath = normalizeParamMemberExpression(expression, rightName);
+        return rightPath ? followStaticPath(rightValue, rightPath) : undefined;
+    }
+    if (t.isBinaryExpression(expression) && expression.operator === "-") {
+        const left = t.isExpression(expression.left)
+            ? evaluateStaticSortExpression(expression.left, leftName, rightName, leftValue, rightValue)
+            : undefined;
+        const right = t.isExpression(expression.right)
+            ? evaluateStaticSortExpression(expression.right, leftName, rightName, leftValue, rightValue)
+            : undefined;
+        return typeof left === "number" && typeof right === "number"
+            ? left - right
+            : undefined;
+    }
+    return undefined;
+}
+function getFilterPredicateExpression(callback) {
+    if (t.isExpression(callback.body)) {
+        return callback.body;
+    }
+    for (const statement of callback.body.body) {
+        if (t.isReturnStatement(statement) &&
+            statement.argument &&
+            t.isExpression(statement.argument)) {
+            return statement.argument;
+        }
+    }
+    return null;
+}
+function evaluateStaticFilterPredicate(expression, paramName, item) {
+    const value = evaluateStaticFilterExpression(expression, paramName, item);
+    return typeof value === "boolean" ? value : undefined;
+}
+function evaluateStaticFilterExpression(expression, paramName, item) {
+    if (t.isStringLiteral(expression) ||
+        t.isNumericLiteral(expression) ||
+        t.isBooleanLiteral(expression)) {
+        return expression.value;
+    }
+    if (t.isNullLiteral(expression)) {
+        return null;
+    }
+    if (t.isIdentifier(expression)) {
+        return expression.name === paramName ? item : undefined;
+    }
+    if (t.isMemberExpression(expression)) {
+        const normalized = normalizeParamMemberExpression(expression, paramName);
+        return normalized ? followStaticPath(item, normalized) : undefined;
+    }
+    if (t.isUnaryExpression(expression) && expression.operator === "!") {
+        const argument = evaluateStaticFilterExpression(expression.argument, paramName, item);
+        return argument === undefined ? undefined : !argument;
+    }
+    if (t.isLogicalExpression(expression)) {
+        const left = evaluateStaticFilterExpression(expression.left, paramName, item);
+        if (left === undefined) {
+            return undefined;
+        }
+        if (expression.operator === "&&") {
+            return left
+                ? evaluateStaticFilterExpression(expression.right, paramName, item)
+                : left;
+        }
+        if (expression.operator === "||") {
+            return left
+                ? left
+                : evaluateStaticFilterExpression(expression.right, paramName, item);
+        }
+    }
+    if (t.isBinaryExpression(expression)) {
+        const left = t.isExpression(expression.left)
+            ? evaluateStaticFilterExpression(expression.left, paramName, item)
+            : undefined;
+        const right = t.isExpression(expression.right)
+            ? evaluateStaticFilterExpression(expression.right, paramName, item)
+            : undefined;
+        if (left === undefined || right === undefined) {
+            return undefined;
+        }
+        switch (expression.operator) {
+            case "===":
+                return left === right;
+            case "!==":
+                return left !== right;
+            case "==":
+                return left == right;
+            case "!=":
+                return left != right;
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function normalizeParamMemberExpression(expression, paramName) {
+    const path = [];
+    let current = expression;
+    while (t.isMemberExpression(current)) {
+        if (current.computed) {
+            if (t.isNumericLiteral(current.property)) {
+                path.unshift({ kind: "index", index: current.property.value });
+            }
+            else if (t.isStringLiteral(current.property)) {
+                path.unshift({ kind: "property", name: current.property.value });
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            if (!t.isIdentifier(current.property)) {
+                return null;
+            }
+            path.unshift({ kind: "property", name: current.property.name });
+        }
+        current = current.object;
+    }
+    if (!t.isIdentifier(current) || current.name !== paramName) {
+        return null;
+    }
+    return path;
+}
+async function resolveBindingTarget(params) {
+    const { currentFile, binding, readFile, exists, fileCache, visited } = params;
+    const key = `${currentFile}::${binding.kind}::${binding.identifier.name}`;
+    if (visited.has(key)) {
+        return null;
+    }
+    visited.add(key);
+    try {
+        const hookStateBinding = await resolveHookStateBinding({
+            currentFile,
+            binding,
+            readFile,
+            exists,
+            fileCache,
+            visited,
+        });
+        if (hookStateBinding) {
+            return hookStateBinding;
+        }
+        if (binding.path.isImportSpecifier() ||
+            binding.path.isImportDefaultSpecifier()) {
+            return await resolveImportedBinding({
+                currentFile,
+                binding,
+                readFile,
+                exists,
+                graph: params.graph,
+                externalSourceResolvers: params.externalSourceResolvers,
+                externalAdapters: params.externalAdapters,
+                fileCache,
+                visited,
+            });
+        }
+        if (binding.kind === "param") {
+            return null;
+        }
+        if (binding.path.isVariableDeclarator()) {
+            const init = binding.path.node.init;
+            if (!init || !t.isExpression(init)) {
+                return null;
+            }
+            const initPath = binding.path.get("init");
+            if (initPath && !Array.isArray(initPath) && initPath.isExpression()) {
+                const external = await resolveExternalExpression({
+                    currentFile,
+                    expressionPath: initPath,
+                    readFile,
+                    exists,
+                    graph: params.graph,
+                    externalSourceResolvers: params.externalSourceResolvers,
+                    externalAdapters: params.externalAdapters,
+                    functionCallContracts: params.functionCallContracts,
+                    fileCache,
+                    visited,
+                });
+                if (external) {
+                    return external;
+                }
+                if (initPath.isCallExpression()) {
+                    const filtered = await resolveCollectionCallTarget({
+                        currentFile,
+                        callPath: initPath,
+                        readFile,
+                        exists,
+                        graph: params.graph,
+                        externalSourceResolvers: params.externalSourceResolvers,
+                        externalAdapters: params.externalAdapters,
+                        functionCallContracts: params.functionCallContracts,
+                        fileCache,
+                        visited,
+                    });
+                    if (filtered) {
+                        return filtered;
+                    }
+                }
+            }
+            const value = await evaluateStaticExpression(init, binding.path.scope, currentFile, readFile, exists, fileCache, visited);
+            if (value === undefined) {
+                return null;
+            }
+            return {
+                kind: "static",
+                file: currentFile,
+                root: { kind: "binding", name: binding.identifier.name },
+                value,
+                sourceKind: "binding",
+            };
+        }
+        if (binding.path.isIdentifier() &&
+            binding.path.parentPath?.isExportDefaultDeclaration()) {
+            const declaration = binding.path.parentPath.node.declaration;
+            if (!t.isExpression(declaration)) {
+                return null;
+            }
+            const value = await evaluateStaticExpression(declaration, binding.path.scope, currentFile, readFile, exists, fileCache, visited);
+            if (value === undefined) {
+                return null;
+            }
+            return {
+                kind: "static",
+                file: currentFile,
+                root: { kind: "binding", name: binding.identifier.name },
+                value,
+                sourceKind: "binding",
+            };
+        }
+        return null;
+    }
+    finally {
+        visited.delete(key);
+    }
+}
+async function resolveHookStateBinding(params) {
+    const { currentFile, binding, readFile, exists, fileCache, visited } = params;
+    if (!binding.path.isVariableDeclarator() ||
+        !binding.path.get("id").isArrayPattern()) {
+        return null;
+    }
+    const declarator = binding.path;
+    const init = declarator.node.init;
+    if (!init || !t.isCallExpression(init)) {
+        return null;
+    }
+    const hookName = getHookCallName(init);
+    if (!hookName) {
+        return null;
+    }
+    if (!t.isArrayPattern(declarator.node.id)) {
+        return null;
+    }
+    const stateIndex = declarator.node.id.elements.findIndex((element) => t.isIdentifier(element) && element.name === binding.identifier.name);
+    if (stateIndex !== 0) {
+        return null;
+    }
+    const argIndex = hookName === "useReducer" ? 1 : 0;
+    const initialArg = init.arguments[argIndex];
+    if (!initialArg || !t.isExpression(initialArg)) {
+        return null;
+    }
+    const value = await evaluateStaticExpression(initialArg, declarator.scope, currentFile, readFile, exists, fileCache, visited);
+    if (value === undefined) {
+        return null;
+    }
+    return {
+        kind: "static",
+        file: currentFile,
+        root: { kind: "hook-state", name: binding.identifier.name, hook: hookName },
+        value,
+        sourceKind: "binding",
+    };
+}
+function getHookCallName(call) {
+    if (t.isIdentifier(call.callee) &&
+        (call.callee.name === "useState" || call.callee.name === "useReducer")) {
+        return call.callee.name;
+    }
+    if (t.isMemberExpression(call.callee) &&
+        t.isIdentifier(call.callee.property) &&
+        (call.callee.property.name === "useState" ||
+            call.callee.property.name === "useReducer")) {
+        return call.callee.property.name;
+    }
+    return null;
+}
+function findEnclosingComponentInfo(startPath) {
+    const functionPath = startPath.getFunctionParent();
+    if (!functionPath) {
+        return null;
+    }
+    if (functionPath.isFunctionDeclaration()) {
+        const componentName = functionPath.node.id?.name;
+        if (!componentName) {
+            return null;
+        }
+        const exportName = functionPath.parentPath?.isExportDefaultDeclaration()
+            ? "default"
+            : functionPath.parentPath?.isExportNamedDeclaration()
+                ? componentName
+                : componentName;
+        return { componentName, exportName };
+    }
+    if (!functionPath.isArrowFunctionExpression() &&
+        !functionPath.isFunctionExpression()) {
+        return null;
+    }
+    const declaratorPath = functionPath.parentPath;
+    if (!declaratorPath?.isVariableDeclarator() ||
+        !t.isIdentifier(declaratorPath.node.id)) {
+        return null;
+    }
+    const componentName = declaratorPath.node.id.name;
+    const declarationPath = declaratorPath.parentPath;
+    const exportName = declarationPath?.parentPath?.isExportDefaultDeclaration()
+        ? "default"
+        : declarationPath?.parentPath?.isExportNamedDeclaration()
+            ? componentName
+            : componentName;
+    return { componentName, exportName };
+}
+function getParamPropReference(binding, sourceInfo) {
+    const component = findEnclosingComponentInfo(binding.path);
+    if (!component) {
+        return null;
+    }
+    const reference = getBindingParamPropReference(binding, sourceInfo);
+    return reference ? { ...component, ...reference } : null;
+}
+function appendExpressionPath(baseExpression, path) {
+    return path.reduce((expression, segment) => segment.kind === "property"
+        ? `${expression}.${segment.name}`
+        : `${expression}[${segment.index}]`, baseExpression);
+}
+function matchesComponentCallSite(element, currentFile, componentName, exportName) {
+    if (element.importedFrom === currentFile) {
+        if (!exportName) {
+            return true;
+        }
+        return element.exportName === exportName;
+    }
+    return element.sourceFile === currentFile && element.tag === componentName;
+}
+async function resolveComponentPropBinding(params) {
+    const propReference = getParamPropReference(params.binding, params.sourceInfo);
+    if (!propReference || !params.graph) {
+        return null;
+    }
+    const callers = [...params.graph.elements.values()].filter((element) => matchesComponentCallSite(element, params.currentFile, propReference.componentName, propReference.exportName));
+    if (callers.length !== 1) {
+        return null;
+    }
+    const caller = callers[0];
+    const attribute = caller.attributes?.find((item) => item.name === propReference.propName);
+    if (attribute && !attribute.source) {
+        const staticAttributeProvenance = await resolveStaticComponentAttributeBinding({
+            caller,
+            propName: propReference.propName,
+            remainingPath: propReference.remainingPath,
+            readFile: params.readFile,
+            fileCache: params.fileCache,
+        });
+        if (staticAttributeProvenance) {
+            return addComponentPropChain(staticAttributeProvenance, {
+                componentName: propReference.componentName,
+                propName: propReference.propName,
+                file: caller.sourceFile,
+            });
+        }
+    }
+    if (!attribute?.source) {
+        const spreadProvenance = await resolveSpreadComponentPropBinding({
+            caller,
+            propName: propReference.propName,
+            remainingPath: propReference.remainingPath,
+            readFile: params.readFile,
+            exists: params.exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache: params.fileCache,
+            visited: params.visited,
+        });
+        if (spreadProvenance) {
+            return addComponentPropChain(spreadProvenance, {
+                componentName: propReference.componentName,
+                propName: propReference.propName,
+                file: caller.sourceFile,
+            });
+        }
+        const defaultBinding = findPropDefaultBinding(params.binding, propReference.componentName, propReference.propName);
+        if (!defaultBinding || defaultBinding.propName !== propReference.propName) {
+            return null;
+        }
+        const value = await evaluateStaticExpression(defaultBinding.expressionPath.node, defaultBinding.expressionPath.scope, params.currentFile, params.readFile, params.exists, params.fileCache, params.visited);
+        if (value === undefined) {
+            return null;
+        }
+        const fullPath = propReference.remainingPath;
+        if (fullPath.length > 0 &&
+            followStaticPath(value, fullPath) === undefined) {
+            return null;
+        }
+        return {
+            kind: "value",
+            file: params.currentFile,
+            root: { kind: "binding", name: propReference.propName },
+            path: fullPath,
+            sourceKind: "binding",
+            semanticKind: "component-prop",
+            displayExpression: defaultBinding.displayPath,
+            chainPrefix: [
+                {
+                    kind: "component-prop",
+                    file: params.currentFile,
+                    displayName: defaultBinding.displayPath,
+                    canEditHere: true,
+                },
+            ],
+            editMode: "upstream",
+            diagnostics: [],
+        };
+    }
+    const loadedCaller = await loadFile(caller.sourceFile, params.readFile, params.fileCache);
+    if (!loadedCaller.ast) {
+        return null;
+    }
+    const callerExpressionPath = findExpressionPathByTextInRange(loadedCaller.ast, loadedCaller.source, attribute.source.expression, attribute.sourceRange) ??
+        findExpressionPathByText(loadedCaller.ast, loadedCaller.source, attribute.source.expression);
+    if (!callerExpressionPath) {
+        return null;
+    }
+    const upstreamSourceInfo = {
+        ...attribute.source,
+        expression: appendExpressionPath(attribute.source.expression, propReference.remainingPath),
+        path: [...attribute.source.path, ...propReference.remainingPath],
+    };
+    const upstream = await resolveSourceInfoProvenance({
+        currentFile: caller.sourceFile,
+        expressionPath: callerExpressionPath,
+        sourceInfo: upstreamSourceInfo,
+        readFile: params.readFile,
+        exists: params.exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache: params.fileCache,
+        visited: params.visited,
+    });
+    if (!upstream) {
+        return null;
+    }
+    return addComponentPropChain(upstream.kind === "external"
+        ? upstream
+        : {
+            ...upstream,
+            displayExpression: upstreamSourceInfo.expression,
+        }, {
+        componentName: propReference.componentName,
+        propName: propReference.propName,
+        file: caller.sourceFile,
+    });
+}
+async function resolveStaticComponentAttributeBinding(params) {
+    const loadedCaller = await loadFile(params.caller.sourceFile, params.readFile, params.fileCache);
+    if (!loadedCaller.ast) {
+        return null;
+    }
+    const elementPath = findJSXElementPathByRange(loadedCaller.ast, params.caller.sourceRange);
+    if (!elementPath) {
+        return null;
+    }
+    const attributePath = elementPath
+        .get("openingElement")
+        .get("attributes")
+        .find((candidate) => candidate.isJSXAttribute() &&
+        candidate.node.name.type === "JSXIdentifier" &&
+        candidate.node.name.name === params.propName);
+    if (!attributePath?.isJSXAttribute()) {
+        return null;
+    }
+    const valuePath = attributePath.get("value");
+    const rootExpressionPath = valuePath.isStringLiteral()
+        ? valuePath
+        : valuePath.isJSXExpressionContainer()
+            ? valuePath.get("expression")
+            : null;
+    if (!rootExpressionPath?.isExpression()) {
+        return null;
+    }
+    const sourceRange = toValueSourceRange(rootExpressionPath.node);
+    if (!sourceRange) {
+        return null;
+    }
+    return {
+        kind: "value",
+        file: params.caller.sourceFile,
+        root: { kind: "expression", sourceRange },
+        path: params.remainingPath,
+        sourceKind: "binding",
+        semanticKind: "component-prop",
+        displayExpression: params.propName,
+        editMode: "upstream",
+        diagnostics: [],
+    };
+}
+async function resolveSpreadComponentPropBinding(params) {
+    const loadedCaller = await loadFile(params.caller.sourceFile, params.readFile, params.fileCache);
+    if (!loadedCaller.ast) {
+        return null;
+    }
+    const elementPath = findJSXElementPathByRange(loadedCaller.ast, params.caller.sourceRange);
+    if (!elementPath) {
+        return null;
+    }
+    const openingPath = elementPath.get("openingElement");
+    for (const attributePath of openingPath.get("attributes")) {
+        if (!attributePath.isJSXSpreadAttribute()) {
+            continue;
+        }
+        const argumentPath = attributePath.get("argument");
+        if (!argumentPath.isExpression()) {
+            continue;
+        }
+        const spreadSourceInfo = await buildExpressionSourceInfo({
+            expression: argumentPath.node,
+            scope: argumentPath.scope,
+            source: loadedCaller.source,
+            currentFile: params.caller.sourceFile,
+            readFile: params.readFile,
+            exists: params.exists,
+            fileCache: params.fileCache,
+            visited: params.visited,
+        });
+        if (!spreadSourceInfo) {
+            continue;
+        }
+        const propPath = [
+            { kind: "property", name: params.propName },
+            ...params.remainingPath,
+        ];
+        const upstreamSourceInfo = {
+            ...spreadSourceInfo,
+            expression: appendExpressionPath(spreadSourceInfo.expression, propPath),
+            path: [...spreadSourceInfo.path, ...propPath],
+        };
+        const upstream = await resolveSourceInfoProvenance({
+            currentFile: params.caller.sourceFile,
+            expressionPath: argumentPath,
+            sourceInfo: upstreamSourceInfo,
+            readFile: params.readFile,
+            exists: params.exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache: params.fileCache,
+            visited: params.visited,
+        });
+        if (!upstream) {
+            continue;
+        }
+        return upstream.kind === "external"
+            ? upstream
+            : {
+                ...upstream,
+                displayExpression: upstreamSourceInfo.expression,
+            };
+    }
+    return null;
+}
+function addComponentPropChain(upstream, params) {
+    const chainPrefix = [
+        {
+            kind: "component-prop",
+            file: params.file,
+            displayName: `${params.componentName}.${params.propName}`,
+            canEditHere: true,
+        },
+    ];
+    return upstream.kind === "external"
+        ? {
+            ...upstream,
+            chainPrefix: [...chainPrefix, ...(upstream.chainPrefix ?? [])],
+            editMode: upstream.editMode === "readonly" ? "readonly" : "upstream",
+        }
+        : {
+            ...upstream,
+            chainPrefix: [...chainPrefix, ...(upstream.chainPrefix ?? [])],
+            editMode: "upstream",
+        };
+}
+async function resolveImportedBinding(params) {
+    const { currentFile, binding, readFile, exists, fileCache, visited } = params;
+    const importDeclaration = binding.path.parentPath;
+    if (!importDeclaration || !importDeclaration.isImportDeclaration()) {
+        return null;
+    }
+    const specifier = importDeclaration.node.source.value;
+    if (typeof specifier !== "string") {
+        return null;
+    }
+    const resolvedFile = await resolveLocalImport(currentFile, specifier, exists);
+    if (!resolvedFile) {
+        return null;
+    }
+    if (binding.path.isImportDefaultSpecifier()) {
+        const resolved = await resolveExportValue({
+            file: resolvedFile,
+            exportName: "default",
+            readFile,
+            exists,
+            graph: params.graph,
+            externalSourceResolvers: params.externalSourceResolvers,
+            externalAdapters: params.externalAdapters,
+            functionCallContracts: params.functionCallContracts,
+            fileCache,
+            visited,
+        });
+        if (!resolved || resolved.kind !== "static") {
+            return null;
+        }
+        return {
+            kind: "static",
+            file: resolvedFile,
+            root: { kind: "default-export" },
+            value: resolved.value,
+            sourceKind: "imported-binding",
+        };
+    }
+    if (!binding.path.isImportSpecifier()) {
+        return null;
+    }
+    const imported = binding.path.node.imported;
+    const importedName = t.isIdentifier(imported)
+        ? imported.name
+        : imported.value;
+    const resolved = await resolveExportValue({
+        file: resolvedFile,
+        exportName: importedName,
+        readFile,
+        exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    if (!resolved) {
+        return null;
+    }
+    if (resolved.kind === "external") {
+        return resolved;
+    }
+    return {
+        kind: "static",
+        file: resolvedFile,
+        root: { kind: "named-export", name: importedName },
+        value: resolved.value,
+        sourceKind: "imported-binding",
+    };
+}
+async function resolveExportValue(params) {
+    const { file, exportName, readFile, exists, fileCache, visited } = params;
+    const loaded = await loadFile(file, readFile, fileCache);
+    if (!loaded.ast) {
+        return undefined;
+    }
+    const exportEntry = getExportEntry(loaded.ast, exportName);
+    if (!exportEntry) {
+        return undefined;
+    }
+    if (exportEntry.kind === "default-expression") {
+        return undefined;
+    }
+    const bindingName = exportEntry.name;
+    if (!bindingName) {
+        return undefined;
+    }
+    const binding = getProgramScope(loaded.ast).getBinding(bindingName);
+    if (!binding) {
+        return undefined;
+    }
+    const resolved = await resolveBindingTarget({
+        currentFile: file,
+        binding,
+        readFile,
+        exists,
+        graph: params.graph,
+        externalSourceResolvers: params.externalSourceResolvers,
+        externalAdapters: params.externalAdapters,
+        functionCallContracts: params.functionCallContracts,
+        fileCache,
+        visited,
+    });
+    return resolved ?? undefined;
+}
+function getProgramScope(ast) {
+    let scope = null;
+    traverse(ast, {
+        Program(path) {
+            scope = path.scope;
+            path.stop();
+        },
+    });
+    if (!scope) {
+        throw new Error("Unable to determine program scope");
+    }
+    return scope;
+}
+function getExportEntry(ast, exportName) {
+    for (const statement of ast.program.body) {
+        if (exportName === "default" && t.isExportDefaultDeclaration(statement)) {
+            if (t.isExpression(statement.declaration)) {
+                return {
+                    kind: "default-expression",
+                    expression: statement.declaration,
+                };
+            }
+            if (t.isFunctionDeclaration(statement.declaration) ||
+                t.isClassDeclaration(statement.declaration)) {
+                if (statement.declaration.id) {
+                    return {
+                        kind: "default-binding",
+                        name: statement.declaration.id.name,
+                    };
+                }
+                return null;
+            }
+            return null;
+        }
+        if (!t.isExportNamedDeclaration(statement)) {
+            continue;
+        }
+        if (statement.declaration) {
+            if (t.isVariableDeclaration(statement.declaration)) {
+                for (const declarator of statement.declaration.declarations) {
+                    if (t.isIdentifier(declarator.id) &&
+                        declarator.id.name === exportName) {
+                        return { kind: "local-binding", name: declarator.id.name };
+                    }
+                }
+            }
+            if ((t.isFunctionDeclaration(statement.declaration) ||
+                t.isClassDeclaration(statement.declaration)) &&
+                statement.declaration.id &&
+                statement.declaration.id.name === exportName) {
+                return { kind: "local-binding", name: exportName };
+            }
+        }
+        for (const specifier of statement.specifiers) {
+            const exportedName = t.isIdentifier(specifier.exported)
+                ? specifier.exported.name
+                : specifier.exported.value;
+            if (exportedName === exportName && t.isExportSpecifier(specifier)) {
+                return { kind: "local-binding", name: specifier.local.name };
+            }
+        }
+    }
+    return null;
+}
+async function evaluateStaticExpression(expr, scope, currentFile, readFile, exists, fileCache, visited) {
+    if (t.isStringLiteral(expr) ||
+        t.isNumericLiteral(expr) ||
+        t.isBooleanLiteral(expr)) {
+        return expr.value;
+    }
+    if (t.isNullLiteral(expr)) {
+        return null;
+    }
+    if (t.isTemplateLiteral(expr)) {
+        if (expr.expressions.length === 0 && expr.quasis.length === 1) {
+            return expr.quasis[0].value.cooked ?? expr.quasis[0].value.raw;
+        }
+        return undefined;
+    }
+    if (t.isTSAsExpression(expr) ||
+        t.isTSSatisfiesExpression(expr) ||
+        t.isTSNonNullExpression(expr)) {
+        return await evaluateStaticExpression(expr.expression, scope, currentFile, readFile, exists, fileCache, visited);
+    }
+    if (t.isIdentifier(expr)) {
+        const binding = scope.getBinding(expr.name);
+        if (!binding) {
+            return undefined;
+        }
+        const resolved = await resolveBindingTarget({
+            currentFile,
+            binding,
+            readFile,
+            exists,
+            fileCache,
+            visited,
+        });
+        return resolved?.kind === "static" ? resolved.value : undefined;
+    }
+    if (t.isArrayExpression(expr)) {
+        const values = [];
+        for (const element of expr.elements) {
+            if (!element || t.isSpreadElement(element)) {
+                return undefined;
+            }
+            const value = await evaluateExpressionLike(element, scope, currentFile, readFile, exists, fileCache, visited);
+            if (value === undefined) {
+                return undefined;
+            }
+            values.push(value);
+        }
+        return values;
+    }
+    if (t.isObjectExpression(expr)) {
+        const result = {};
+        for (const property of expr.properties) {
+            if (!t.isObjectProperty(property) || property.computed) {
+                return undefined;
+            }
+            let keyName = null;
+            if (t.isIdentifier(property.key)) {
+                keyName = property.key.name;
+            }
+            else if (t.isStringLiteral(property.key)) {
+                keyName = property.key.value;
+            }
+            if (!keyName) {
+                return undefined;
+            }
+            if (property.shorthand) {
+                if (!t.isIdentifier(property.value)) {
+                    return undefined;
+                }
+                const shorthand = await evaluateExpressionLike(property.value, scope, currentFile, readFile, exists, fileCache, visited);
+                if (shorthand === undefined) {
+                    return undefined;
+                }
+                result[keyName] = shorthand;
+                continue;
+            }
+            if (!t.isExpression(property.value)) {
+                return undefined;
+            }
+            const value = await evaluateExpressionLike(property.value, scope, currentFile, readFile, exists, fileCache, visited);
+            if (value === undefined) {
+                continue;
+            }
+            result[keyName] = value;
+        }
+        return result;
+    }
+    if (t.isMemberExpression(expr)) {
+        const normalized = await normalizeExpressionWithScope(expr, scope, currentFile, readFile, exists, fileCache, visited);
+        if (!normalized) {
+            return undefined;
+        }
+        const baseBinding = scope.getBinding(normalized.base);
+        if (!baseBinding) {
+            return undefined;
+        }
+        const baseValue = await resolveBindingTarget({
+            currentFile,
+            binding: baseBinding,
+            readFile,
+            exists,
+            fileCache,
+            visited,
+        });
+        if (!baseValue || baseValue.kind !== "static") {
+            return undefined;
+        }
+        return followStaticPath(baseValue.value, normalized.path);
+    }
+    return undefined;
+}
+async function evaluateExpressionLike(node, scope, currentFile, readFile, exists, fileCache, visited) {
+    if (t.isSpreadElement(node)) {
+        return undefined;
+    }
+    return await evaluateStaticExpression(node, scope, currentFile, readFile, exists, fileCache, visited);
+}
+async function normalizeExpressionWithScope(expr, scope, currentFile, readFile, exists, fileCache, visited) {
+    if (t.isIdentifier(expr)) {
+        return {
+            base: expr.name,
+            path: [],
+        };
+    }
+    if (!t.isMemberExpression(expr)) {
+        return null;
+    }
+    const segments = [];
+    let current = expr;
+    while (t.isMemberExpression(current)) {
+        if (current.computed) {
+            const property = current.property;
+            if (t.isNumericLiteral(property)) {
+                segments.unshift({ kind: "index", index: property.value });
+            }
+            else if (t.isStringLiteral(property)) {
+                segments.unshift({ kind: "property", name: property.value });
+            }
+            else {
+                const computedValue = t.isExpression(property)
+                    ? await evaluateStaticExpression(property, scope, currentFile, readFile, exists, fileCache, visited)
+                    : undefined;
+                if (typeof computedValue === "string") {
+                    segments.unshift({ kind: "property", name: computedValue });
+                }
+                else if (Number.isInteger(computedValue)) {
+                    segments.unshift({ kind: "index", index: computedValue });
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        else {
+            if (!t.isIdentifier(current.property)) {
+                return null;
+            }
+            segments.unshift({ kind: "property", name: current.property.name });
+        }
+        current = current.object;
+    }
+    if (!t.isIdentifier(current)) {
+        return null;
+    }
+    return {
+        base: current.name,
+        path: segments,
+    };
+}
+function normalizeExpression(expr) {
+    if (t.isIdentifier(expr)) {
+        return {
+            base: expr.name,
+            path: [],
+        };
+    }
+    if (!t.isMemberExpression(expr)) {
+        return null;
+    }
+    const segments = [];
+    let current = expr;
+    while (t.isMemberExpression(current)) {
+        if (current.computed) {
+            if (t.isNumericLiteral(current.property)) {
+                segments.unshift({ kind: "index", index: current.property.value });
+            }
+            else if (t.isStringLiteral(current.property)) {
+                segments.unshift({ kind: "property", name: current.property.value });
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            if (!t.isIdentifier(current.property)) {
+                return null;
+            }
+            segments.unshift({ kind: "property", name: current.property.name });
+        }
+        current = current.object;
+    }
+    if (!t.isIdentifier(current)) {
+        return null;
+    }
+    return {
+        base: current.name,
+        path: segments,
+    };
+}
+function followStaticPath(value, path) {
+    let current = value;
+    for (const segment of path) {
+        if (segment.kind === "property") {
+            if (current === null ||
+                Array.isArray(current) ||
+                typeof current !== "object" ||
+                !(segment.name in current)) {
+                return undefined;
+            }
+            current = current[segment.name];
+            continue;
+        }
+        if (!Array.isArray(current) ||
+            segment.index < 0 ||
+            segment.index >= current.length) {
+            return undefined;
+        }
+        current = current[segment.index];
+    }
+    return current;
+}
+function buildRepeatItemPathMap(collectionTarget, itemPath) {
+    if (!Array.isArray(collectionTarget.value)) {
+        return null;
+    }
+    const paths = collectionTarget.collectionPathMap?.length
+        ? collectionTarget.collectionPathMap
+        : collectionTarget.value.map((_, index) => [
+            ...(collectionTarget.pathPrefix ?? []),
+            {
+                kind: "index",
+                index: collectionTarget.collectionIndexMap?.[index] ?? index,
+            },
+        ]);
+    return paths.length > 0
+        ? paths.map((path) => [...path, ...itemPath])
+        : null;
+}
+function flattenCollectionPathMap(rootValue, collectionPathMap) {
+    const value = [];
+    const flattenedPathMap = [];
+    for (const collectionPath of collectionPathMap) {
+        const collection = followStaticPath(rootValue, collectionPath);
+        if (!Array.isArray(collection)) {
+            return null;
+        }
+        for (const [index, item] of collection.entries()) {
+            value.push(item);
+            flattenedPathMap.push([
+                ...collectionPath,
+                { kind: "index", index },
+            ]);
+        }
+    }
+    return { value, collectionPathMap: flattenedPathMap };
+}
+async function loadFile(file, readFile, fileCache) {
+    const cached = fileCache.get(file);
+    if (cached) {
+        return cached;
+    }
+    const source = await readFile(file);
+    const ast = parseSource(source);
+    const loaded = { source, ast };
+    fileCache.set(file, loaded);
+    return loaded;
+}