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

package/dist/internal/graph/graph-builder.js

@@ -0,0 +1,1371 @@
+// ─── Graph Builder ───────────────────────────────────
+// 来源: docs/06-development-checklist.md §4
+//
+// 从单个源文件 AST 构建 RenderSourceGraph。
+// 职责:
+//   - 解析文件 AST（Babel）
+//   - 遍历 JSX 树
+//   - 构建 ElementNode / RegionNode / TextSegment
+//   - 计算 SourceIdentity（使用 identity 模块）
+//   - 维护文件索引
+import * as parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { extractLocalImportsFromAst } from "./import-resolver.js";
+import { computeSourceIdentityKey } from "../protocol.js";
+// Handle ESM default import for @babel/traverse
+const traverse = (typeof _traverse === "function" ? _traverse : _traverse.default);
+// ── Helper: parse source ──
+function parseSource(source) {
+    try {
+        return parser.parse(source, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+// ── Helper: extract source range ──
+function toSourceRange(node) {
+    return {
+        startLine: node.loc?.start.line ?? 0,
+        startColumn: node.loc?.start.column ?? 0,
+        endLine: node.loc?.end.line ?? 0,
+        endColumn: node.loc?.end.column ?? 0,
+    };
+}
+// ── Helper: check if a tag is a component (PascalCase) ──
+function isComponentTag(tag) {
+    return /^[A-Z]/.test(tag);
+}
+// ── Helper: check if JSXElement is a Fragment ──
+function isFragment(node) {
+    const opening = node.openingElement;
+    if (t.isJSXIdentifier(opening.name)) {
+        return opening.name.name === "Fragment";
+    }
+    if (t.isJSXMemberExpression(opening.name)) {
+        return opening.name.property.name === "Fragment";
+    }
+    return false;
+}
+function isJSXFragment(node) {
+    return t.isJSXFragment(node);
+}
+// ── Helper: get tag name from JSX opening element ──
+function getTagName(opening) {
+    if (t.isJSXIdentifier(opening.name)) {
+        return opening.name.name;
+    }
+    if (t.isJSXMemberExpression(opening.name)) {
+        return getMemberExpressionName(opening.name);
+    }
+    if (t.isJSXNamespacedName(opening.name)) {
+        return `${opening.name.namespace.name}:${opening.name.name.name}`;
+    }
+    return "unknown";
+}
+function getMemberExpressionName(expr) {
+    if (t.isJSXIdentifier(expr.object)) {
+        return `${expr.object.name}.${expr.property.name}`;
+    }
+    if (t.isJSXMemberExpression(expr.object)) {
+        return `${getMemberExpressionName(expr.object)}.${expr.property.name}`;
+    }
+    return expr.property.name;
+}
+// ── Helper: find component name from function ──
+function findComponentName(path) {
+    // Check if we're inside a function declaration/expression
+    let current = path;
+    while (current) {
+        const node = current.node;
+        // export default function Name() {}
+        if (t.isFunctionDeclaration(node) && node.id) {
+            return node.id.name;
+        }
+        // const Name = () => {} or const Name = function() {}
+        if (t.isVariableDeclarator(node) && t.isIdentifier(node.id)) {
+            return node.id.name;
+        }
+        // export default function() {} — use 'default'
+        if (t.isExportDefaultDeclaration(node)) {
+            const decl = node.declaration;
+            if (t.isFunctionDeclaration(decl) && decl.id) {
+                return decl.id.name;
+            }
+            if (t.isFunctionDeclaration(decl) && !decl.id) {
+                return "default";
+            }
+        }
+        current = current.parentPath;
+    }
+    return null;
+}
+function createOrdinalTracker() {
+    const counters = new Map();
+    return {
+        getOrdinal(parentKey, tag) {
+            const pk = parentKey ?? "__root__";
+            if (!counters.has(pk)) {
+                counters.set(pk, new Map());
+            }
+            const tagMap = counters.get(pk);
+            const current = tagMap.get(tag) ?? 0;
+            tagMap.set(tag, current + 1);
+            return current;
+        },
+    };
+}
+/**
+ * 从已解析的 AST 构建 ImportMap。
+ * 只处理 ES import 声明，不处理 require()。
+ */
+function buildImportMap(ast) {
+    const map = new Map();
+    for (const node of ast.program.body) {
+        if (!t.isImportDeclaration(node))
+            continue;
+        const specifier = node.source.value;
+        for (const spec of node.specifiers) {
+            if (t.isImportDefaultSpecifier(spec)) {
+                map.set(spec.local.name, { specifier, exportName: "default" });
+            }
+            else if (t.isImportNamespaceSpecifier(spec)) {
+                map.set(spec.local.name, { specifier, exportName: "*" });
+            }
+            else if (t.isImportSpecifier(spec)) {
+                const imported = t.isIdentifier(spec.imported)
+                    ? spec.imported.name
+                    : spec.imported.value;
+                map.set(spec.local.name, { specifier, exportName: imported });
+            }
+        }
+    }
+    return map;
+}
+function collectBoundIdentifiers(pattern, names = []) {
+    if (t.isIdentifier(pattern)) {
+        names.push(pattern.name);
+        return names;
+    }
+    if (t.isObjectPattern(pattern)) {
+        for (const property of pattern.properties) {
+            if (t.isObjectProperty(property)) {
+                collectBoundIdentifiers(property.value, names);
+            }
+            else if (t.isRestElement(property)) {
+                collectBoundIdentifiers(property.argument, names);
+            }
+        }
+        return names;
+    }
+    if (t.isArrayPattern(pattern)) {
+        for (const element of pattern.elements) {
+            if (!element)
+                continue;
+            if (t.isRestElement(element)) {
+                collectBoundIdentifiers(element.argument, names);
+            }
+            else {
+                collectBoundIdentifiers(element, names);
+            }
+        }
+        return names;
+    }
+    if (t.isAssignmentPattern(pattern)) {
+        collectBoundIdentifiers(pattern.left, names);
+        return names;
+    }
+    if (t.isRestElement(pattern)) {
+        collectBoundIdentifiers(pattern.argument, names);
+        return names;
+    }
+    return names;
+}
+function getExpressionText(node, source) {
+    if (node.start == null || node.end == null) {
+        return "";
+    }
+    return source.slice(node.start, node.end);
+}
+function resolveStaticBinding(name, scopes) {
+    for (let index = scopes.length - 1; index >= 0; index -= 1) {
+        const slot = scopes[index].get(name);
+        if (slot) {
+            if (!slot.resolved) {
+                return { kind: "unresolved" };
+            }
+            return {
+                kind: "resolved",
+                value: slot.value,
+            };
+        }
+    }
+    return { kind: "unresolved" };
+}
+function setResolvedBinding(scope, name, value) {
+    scope.set(name, { resolved: true, value });
+}
+function setUnresolvedBinding(scope, name) {
+    scope.set(name, { resolved: false });
+}
+function readStaticValueAtPath(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 { kind: "known-empty" };
+            }
+            current = current[segment.name];
+            continue;
+        }
+        if (!Array.isArray(current) ||
+            segment.index < 0 ||
+            segment.index >= current.length) {
+            return { kind: "known-empty" };
+        }
+        current = current[segment.index];
+    }
+    return { kind: "resolved", value: current };
+}
+function getExpressionSourceInfo(expr, source, ctx) {
+    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 if (ctx && t.isExpression(current.property)) {
+                const computedValue = evaluateStaticValue(current.property, ctx);
+                if (typeof computedValue === "string") {
+                    path.unshift({ kind: "property", name: computedValue });
+                }
+                else if (Number.isInteger(computedValue)) {
+                    path.unshift({ kind: "index", index: computedValue });
+                }
+                else {
+                    return null;
+                }
+            }
+            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,
+    };
+}
+function evaluateStaticValue(expr, ctx) {
+    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.isIdentifier(expr)) {
+        const result = resolveStaticBinding(expr.name, ctx.valueScopes);
+        return result.kind === "resolved" ? result.value : undefined;
+    }
+    if (t.isArrayExpression(expr)) {
+        const values = [];
+        for (const element of expr.elements) {
+            if (!element || t.isSpreadElement(element)) {
+                return undefined;
+            }
+            const elementValue = evaluateStaticValue(element, ctx);
+            if (elementValue === undefined) {
+                return undefined;
+            }
+            values.push(elementValue);
+        }
+        return values;
+    }
+    if (t.isObjectExpression(expr)) {
+        const value = {};
+        for (const property of expr.properties) {
+            if (!t.isObjectProperty(property) ||
+                property.computed ||
+                !t.isExpression(property.value)) {
+                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;
+            }
+            let propertyValue;
+            if (property.shorthand) {
+                if (!t.isIdentifier(property.value)) {
+                    return undefined;
+                }
+                const shorthandResult = resolveStaticBinding(property.value.name, ctx.valueScopes);
+                if (shorthandResult.kind !== "resolved") {
+                    return undefined;
+                }
+                propertyValue = shorthandResult.value;
+            }
+            else {
+                propertyValue = evaluateStaticValue(property.value, ctx);
+            }
+            if (propertyValue === undefined) {
+                return undefined;
+            }
+            value[keyName] = propertyValue;
+        }
+        return value;
+    }
+    if (t.isMemberExpression(expr)) {
+        const sourceInfo = getExpressionSourceInfo(expr, "", ctx);
+        if (!sourceInfo) {
+            return undefined;
+        }
+        const bindingResult = resolveStaticBinding(sourceInfo.base, ctx.valueScopes);
+        if (bindingResult.kind !== "resolved") {
+            return undefined;
+        }
+        const pathResult = readStaticValueAtPath(bindingResult.value, sourceInfo.path);
+        return pathResult.kind === "resolved" ? pathResult.value : undefined;
+    }
+    if (t.isCallExpression(expr)) {
+        const classNameValue = evaluateClassNameExpression(expr, ctx);
+        return classNameValue ?? undefined;
+    }
+    return undefined;
+}
+function evaluateTextExpression(expr, ctx, source) {
+    const sourceInfo = getExpressionSourceInfo(expr, source, ctx);
+    if (!sourceInfo) {
+        if (t.isMemberExpression(expr) ||
+            t.isBinaryExpression(expr) ||
+            t.isLogicalExpression(expr) ||
+            t.isConditionalExpression(expr) ||
+            t.isCallExpression(expr)) {
+            return {
+                value: getExpressionText(expr, source),
+                source: null,
+            };
+        }
+        return null;
+    }
+    const bindingResult = resolveStaticBinding(sourceInfo.base, ctx.valueScopes);
+    const resolvedResult = sourceInfo.kind === "identifier"
+        ? bindingResult
+        : bindingResult.kind === "resolved"
+            ? readStaticValueAtPath(bindingResult.value, sourceInfo.path)
+            : bindingResult;
+    if (resolvedResult.kind === "resolved" &&
+        (typeof resolvedResult.value === "string" ||
+            typeof resolvedResult.value === "number")) {
+        return {
+            value: String(resolvedResult.value),
+            source: sourceInfo,
+        };
+    }
+    if (resolvedResult.kind === "resolved" &&
+        (typeof resolvedResult.value === "boolean" || resolvedResult.value === null)) {
+        return null;
+    }
+    if (resolvedResult.kind === "known-empty") {
+        return null;
+    }
+    return {
+        value: sourceInfo.expression,
+        source: sourceInfo,
+    };
+}
+function createEvaluationContext(file, componentName, elements, regions, importMap, valueScopes) {
+    return {
+        file,
+        componentName,
+        elements,
+        regions,
+        ordinalTracker: createOrdinalTracker(),
+        parentStack: [],
+        valueScopes,
+        importMap,
+    };
+}
+function collectStaticBindingsFromDeclarations(declarations, ctx, targetScope) {
+    for (const declaration of declarations) {
+        for (const declarator of declaration.declarations) {
+            for (const name of collectBoundIdentifiers(declarator.id)) {
+                setUnresolvedBinding(targetScope, name);
+            }
+            if (!t.isIdentifier(declarator.id) ||
+                !declarator.init ||
+                !t.isExpression(declarator.init)) {
+                continue;
+            }
+            const value = evaluateStaticValue(declarator.init, ctx);
+            if (value !== undefined) {
+                setResolvedBinding(targetScope, declarator.id.name, value);
+            }
+        }
+    }
+}
+function getFileScopeVariableDeclarations(programBody) {
+    const declarations = [];
+    for (const statement of programBody) {
+        if (t.isVariableDeclaration(statement)) {
+            declarations.push(statement);
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) &&
+            statement.declaration &&
+            t.isVariableDeclaration(statement.declaration)) {
+            declarations.push(statement.declaration);
+        }
+    }
+    return declarations;
+}
+function extractTextSegments(children, ctx, source) {
+    const segments = [];
+    let index = 0;
+    for (const child of children) {
+        if (t.isJSXText(child)) {
+            const text = child.value.trim();
+            if (text) {
+                segments.push({
+                    index: index++,
+                    value: text,
+                    sourceRange: toSourceRange(child),
+                    editable: true,
+                    source: null,
+                });
+            }
+        }
+        else if (t.isJSXExpressionContainer(child) &&
+            t.isStringLiteral(child.expression)) {
+            segments.push({
+                index: index++,
+                value: child.expression.value,
+                sourceRange: toSourceRange(child),
+                editable: true,
+                source: null,
+            });
+        }
+        else if (t.isJSXExpressionContainer(child) &&
+            t.isTemplateLiteral(child.expression)) {
+            // Template literal with no expressions = editable string
+            const expr = child.expression;
+            if (expr.expressions.length === 0 && expr.quasis.length === 1) {
+                segments.push({
+                    index: index++,
+                    value: expr.quasis[0].value.cooked ?? expr.quasis[0].value.raw,
+                    sourceRange: toSourceRange(child),
+                    editable: true,
+                    source: null,
+                });
+            }
+            else {
+                segments.push({
+                    index: index++,
+                    value: getExpressionText(expr, source),
+                    sourceRange: toSourceRange(child),
+                    editable: true,
+                    source: null,
+                });
+            }
+        }
+        else if (t.isJSXExpressionContainer(child) &&
+            t.isExpression(child.expression)) {
+            const result = evaluateTextExpression(child.expression, ctx, source);
+            if (result) {
+                segments.push({
+                    index: index++,
+                    value: result.value,
+                    sourceRange: toSourceRange(child),
+                    editable: true,
+                    source: result.source,
+                });
+            }
+        }
+    }
+    return segments;
+}
+function extractAttributeSources(opening, ctx, source) {
+    const attributes = [];
+    for (const attribute of opening.attributes) {
+        if (!t.isJSXAttribute(attribute) || !t.isJSXIdentifier(attribute.name)) {
+            continue;
+        }
+        if (t.isStringLiteral(attribute.value)) {
+            attributes.push({
+                name: attribute.name.name,
+                value: attribute.value.value,
+                sourceRange: toSourceRange(attribute),
+                source: null,
+            });
+            continue;
+        }
+        if (t.isJSXExpressionContainer(attribute.value) &&
+            t.isExpression(attribute.value.expression)) {
+            const staticValue = evaluateStaticValue(attribute.value.expression, ctx);
+            if (attribute.name.name === "className") {
+                const classNameValue = typeof staticValue === "string"
+                    ? staticValue
+                    : staticValue === undefined
+                        ? evaluateClassNameExpression(attribute.value.expression, ctx)
+                        : null;
+                if (classNameValue) {
+                    attributes.push({
+                        name: attribute.name.name,
+                        value: classNameValue,
+                        sourceRange: toSourceRange(attribute),
+                        source: null,
+                        resolvedValue: classNameValue,
+                    });
+                    continue;
+                }
+            }
+            const result = evaluateTextExpression(attribute.value.expression, ctx, source);
+            if (staticValue !== undefined &&
+                typeof staticValue !== "string" &&
+                typeof staticValue !== "number") {
+                attributes.push({
+                    name: attribute.name.name,
+                    value: formatStaticAttributeValue(staticValue),
+                    sourceRange: toSourceRange(attribute),
+                    source: getExpressionSourceInfo(attribute.value.expression, source, ctx),
+                    resolvedValue: staticValue,
+                });
+                continue;
+            }
+            if (!result) {
+                if (staticValue !== undefined) {
+                    attributes.push({
+                        name: attribute.name.name,
+                        value: formatStaticAttributeValue(staticValue),
+                        sourceRange: toSourceRange(attribute),
+                        source: getExpressionSourceInfo(attribute.value.expression, source, ctx),
+                        resolvedValue: staticValue,
+                    });
+                }
+                continue;
+            }
+            attributes.push({
+                name: attribute.name.name,
+                value: result.value,
+                sourceRange: toSourceRange(attribute),
+                source: result.source,
+            });
+        }
+    }
+    return attributes;
+}
+function evaluateClassNameExpression(expr, ctx) {
+    const segments = collectClassNameSegments(expr, ctx);
+    if (!segments) {
+        return null;
+    }
+    const value = segments
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .join(" ");
+    return value || null;
+}
+function collectClassNameSegments(expr, ctx) {
+    if (t.isStringLiteral(expr)) {
+        return [expr.value];
+    }
+    if (t.isTemplateLiteral(expr)) {
+        if (expr.expressions.length > 0) {
+            return null;
+        }
+        return [expr.quasis.map((quasi) => quasi.value.cooked ?? "").join("")];
+    }
+    if (t.isNullLiteral(expr)) {
+        return [];
+    }
+    if (t.isBooleanLiteral(expr)) {
+        return expr.value ? null : [];
+    }
+    if (t.isIdentifier(expr) || t.isMemberExpression(expr)) {
+        if (t.isIdentifier(expr) && expr.name === "undefined") {
+            return [];
+        }
+        const staticValue = evaluateStaticValue(expr, ctx);
+        return typeof staticValue === "string" ? [staticValue] : null;
+    }
+    if (t.isConditionalExpression(expr)) {
+        const consequent = collectClassNameSegments(expr.consequent, ctx);
+        const alternate = collectClassNameSegments(expr.alternate, ctx);
+        if (!consequent || !alternate) {
+            return null;
+        }
+        return [...consequent, ...alternate];
+    }
+    if (t.isLogicalExpression(expr)) {
+        if (expr.operator !== "&&") {
+            return null;
+        }
+        const leftValue = evaluateStaticValue(expr.left, ctx);
+        if (leftValue === false || leftValue === null) {
+            return [];
+        }
+        return collectClassNameSegments(expr.right, ctx);
+    }
+    if (t.isArrayExpression(expr)) {
+        const segments = [];
+        for (const element of expr.elements) {
+            if (!element || t.isSpreadElement(element)) {
+                return null;
+            }
+            const next = collectClassNameSegments(element, ctx);
+            if (!next) {
+                return null;
+            }
+            segments.push(...next);
+        }
+        return segments;
+    }
+    if (t.isObjectExpression(expr)) {
+        const segments = [];
+        for (const property of expr.properties) {
+            if (!t.isObjectProperty(property)) {
+                return null;
+            }
+            const key = getStaticClassObjectKey(property.key);
+            if (!key) {
+                return null;
+            }
+            segments.push(key);
+        }
+        return segments;
+    }
+    if (t.isCallExpression(expr)) {
+        const callee = getClassCallName(expr.callee);
+        if (!callee || !["cn", "clsx", "twMerge"].includes(callee)) {
+            return null;
+        }
+        const segments = [];
+        for (const argument of expr.arguments) {
+            if (!t.isExpression(argument)) {
+                return null;
+            }
+            const next = collectClassNameSegments(argument, ctx);
+            if (!next) {
+                return null;
+            }
+            segments.push(...next);
+        }
+        return segments;
+    }
+    return null;
+}
+function getClassCallName(callee) {
+    if (t.isIdentifier(callee)) {
+        return callee.name;
+    }
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+        return callee.property.name;
+    }
+    return null;
+}
+function getStaticClassObjectKey(key) {
+    if (t.isIdentifier(key)) {
+        return key.name;
+    }
+    if (t.isStringLiteral(key)) {
+        return key.value;
+    }
+    return null;
+}
+function getAttributeExpression(opening, name) {
+    const attribute = opening.attributes.find((item) => t.isJSXAttribute(item) &&
+        t.isJSXIdentifier(item.name) &&
+        item.name.name === name);
+    if (!attribute || !t.isJSXAttribute(attribute)) {
+        return null;
+    }
+    if (!t.isJSXExpressionContainer(attribute.value)) {
+        return null;
+    }
+    return attribute.value.expression;
+}
+function getFirstAttributeExpression(opening, names) {
+    for (const name of names) {
+        const expression = getAttributeExpression(opening, name);
+        if (expression) {
+            return expression;
+        }
+    }
+    return null;
+}
+function getAttributeName(attribute) {
+    return t.isJSXIdentifier(attribute.name) ? attribute.name.name : null;
+}
+function formatStaticAttributeValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    return JSON.stringify(value);
+}
+// ── Check for .map() call expression (repeat region detection) ──
+function isMapCallExpression(node) {
+    return (t.isCallExpression(node) &&
+        t.isMemberExpression(node.callee) &&
+        t.isIdentifier(node.callee.property) &&
+        node.callee.property.name === "map");
+}
+// ── Check for ternary / && conditional expression ──
+function isConditionalExpression(node) {
+    return t.isConditionalExpression(node) || t.isLogicalExpression(node);
+}
+function isFunctionLikeExpression(node) {
+    return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
+}
+function isListRenderPropName(name) {
+    return (name === "render" ||
+        name === "itemRender" ||
+        name === "rowRender" ||
+        name === "children");
+}
+function isStateRenderPropName(name) {
+    return (name === "empty" ||
+        name === "emptyRender" ||
+        name === "loading" ||
+        name === "loadingRender" ||
+        name === "error" ||
+        name === "errorRender" ||
+        name === "fallback" ||
+        name === "headerRender" ||
+        name === "footerRender");
+}
+function createRepeatCandidate(collectionExpression, callback, source, ctx) {
+    if (!collectionExpression || !t.isExpression(collectionExpression)) {
+        return null;
+    }
+    const candidate = {
+        kind: "repeat-template",
+        collectionExpression: getExpressionText(collectionExpression, source),
+        collectionSource: getExpressionSourceInfo(collectionExpression, source, ctx),
+    };
+    if (callback) {
+        const itemParam = callback.params[0];
+        const indexParam = callback.params[1];
+        if (t.isIdentifier(itemParam)) {
+            candidate.itemParamName = itemParam.name;
+        }
+        if (t.isIdentifier(indexParam)) {
+            candidate.indexParamName = indexParam.name;
+        }
+    }
+    return candidate;
+}
+function processRenderableNode(node, ctx, source) {
+    if (!node) {
+        return [];
+    }
+    if (t.isJSXElement(node)) {
+        const key = processJSXElement(node, ctx, source);
+        return key ? [key] : [];
+    }
+    if (isJSXFragment(node)) {
+        return processJSXFragment(node, ctx, source);
+    }
+    if (t.isParenthesizedExpression(node)) {
+        return processRenderableNode(node.expression, ctx, source);
+    }
+    if (t.isExpression(node)) {
+        const regionCountBefore = ctx.regions.length;
+        processExpression(node, ctx, source);
+        return ctx.regions
+            .slice(regionCountBefore)
+            .flatMap((region) => region.childKeys);
+    }
+    return [];
+}
+function processFunctionReturn(callback, ctx, source) {
+    const callbackScope = new Map();
+    for (const param of callback.params) {
+        for (const name of collectBoundIdentifiers(param)) {
+            setUnresolvedBinding(callbackScope, name);
+        }
+    }
+    ctx.valueScopes.push(callbackScope);
+    try {
+        if (!t.isBlockStatement(callback.body)) {
+            return processRenderableNode(callback.body, ctx, source);
+        }
+        const callbackLocalScope = new Map();
+        ctx.valueScopes.push(callbackLocalScope);
+        try {
+            for (const statement of callback.body.body) {
+                if (t.isVariableDeclaration(statement)) {
+                    collectStaticBindingsFromDeclarations([statement], ctx, callbackLocalScope);
+                    continue;
+                }
+                if (t.isReturnStatement(statement) && statement.argument) {
+                    return processRenderableNode(statement.argument, ctx, source);
+                }
+            }
+        }
+        finally {
+            ctx.valueScopes.pop();
+        }
+    }
+    finally {
+        ctx.valueScopes.pop();
+    }
+    return [];
+}
+function pushRegion(ctx, kind, ownerKey, sourceRangeNode, childKeys, sourceCandidates) {
+    if (childKeys.length === 0) {
+        return;
+    }
+    ctx.regions.push({
+        kind,
+        ownerKey,
+        childKeys,
+        sourceRange: toSourceRange(sourceRangeNode),
+        sourceCandidates: sourceCandidates && sourceCandidates.length > 0
+            ? sourceCandidates
+            : undefined,
+    });
+}
+function processJSXAttributeRenderProtocols(node, elementKey, ctx, source) {
+    const collectionExpression = getFirstAttributeExpression(node.openingElement, ["items", "dataSource", "data"]);
+    const parentEntry = { key: elementKey, tag: getTagName(node.openingElement) };
+    ctx.parentStack.push(parentEntry);
+    try {
+        for (const attribute of node.openingElement.attributes) {
+            if (!t.isJSXAttribute(attribute)) {
+                continue;
+            }
+            const name = getAttributeName(attribute);
+            if (!name || !t.isJSXExpressionContainer(attribute.value)) {
+                continue;
+            }
+            const expression = attribute.value.expression;
+            if (t.isJSXEmptyExpression(expression)) {
+                continue;
+            }
+            if (isListRenderPropName(name) && isFunctionLikeExpression(expression)) {
+                const childKeys = processFunctionReturn(expression, ctx, source);
+                const repeatCandidate = createRepeatCandidate(collectionExpression, expression, source, ctx);
+                pushRegion(ctx, "repeat-region", elementKey, attribute, childKeys, repeatCandidate ? [repeatCandidate] : undefined);
+                continue;
+            }
+            if (isStateRenderPropName(name)) {
+                const childKeys = isFunctionLikeExpression(expression)
+                    ? processFunctionReturn(expression, ctx, source)
+                    : processRenderableNode(expression, ctx, source);
+                pushRegion(ctx, "conditional-region", elementKey, attribute, childKeys);
+            }
+        }
+        if (collectionExpression) {
+            for (const child of node.children) {
+                if (!t.isJSXExpressionContainer(child) ||
+                    !isFunctionLikeExpression(child.expression)) {
+                    continue;
+                }
+                const childKeys = processFunctionReturn(child.expression, ctx, source);
+                const repeatCandidate = createRepeatCandidate(collectionExpression, child.expression, source, ctx);
+                pushRegion(ctx, "repeat-region", elementKey, child, childKeys, repeatCandidate ? [repeatCandidate] : undefined);
+            }
+        }
+    }
+    finally {
+        ctx.parentStack.pop();
+    }
+}
+// ── Process JSX element ──
+function processJSXElement(node, ctx, source) {
+    const tag = getTagName(node.openingElement);
+    // Fragment → transparent, process children directly
+    if (tag === "Fragment" || isFragment(node)) {
+        processChildren(node.children, ctx, source);
+        return null;
+    }
+    const parentInfo = ctx.parentStack[ctx.parentStack.length - 1] ?? null;
+    const parentKey = parentInfo?.key ?? null;
+    // Build structural path segment
+    const isComp = isComponentTag(tag);
+    let pathSegment;
+    if (isComp) {
+        const ordinal = ctx.ordinalTracker.getOrdinal(parentKey, tag);
+        pathSegment = `component:${tag}#${ordinal}`;
+    }
+    else {
+        const ordinal = ctx.ordinalTracker.getOrdinal(parentKey, tag);
+        pathSegment = `${tag}#${ordinal}`;
+    }
+    // Compute full structural path
+    const parentPath = parentInfo
+        ? ctx.elements.get(parentInfo.key)?.identity.structuralPath
+        : undefined;
+    const structuralPath = parentPath
+        ? `${parentPath}/${pathSegment}`
+        : pathSegment;
+    // Generate key
+    const key = computeSourceIdentityKey(ctx.file, ctx.componentName, structuralPath);
+    const identity = {
+        file: ctx.file,
+        component: ctx.componentName,
+        structuralPath,
+        key,
+    };
+    const boundaryKind = isComp
+        ? "component-boundary"
+        : null;
+    const textSegments = extractTextSegments(node.children, ctx, source);
+    const attributes = extractAttributeSources(node.openingElement, ctx, source);
+    // For component elements, look up import source info
+    let importedFrom;
+    let exportName;
+    if (isComp) {
+        const importInfo = ctx.importMap.get(tag);
+        if (importInfo) {
+            importedFrom = importInfo.specifier;
+            exportName = importInfo.exportName;
+        }
+    }
+    const elementNode = {
+        identity,
+        tag,
+        componentName: ctx.componentName,
+        sourceFile: ctx.file,
+        sourceRange: toSourceRange(node),
+        parentKey,
+        childKeys: [],
+        textSegments,
+        attributes: attributes.length > 0 ? attributes : undefined,
+        boundaryKind,
+        isOpaque: isComp, // external components are opaque by default
+        importedFrom,
+        exportName,
+    };
+    ctx.elements.set(key, elementNode);
+    // Register as child of parent
+    if (parentKey && ctx.elements.has(parentKey)) {
+        ctx.elements.get(parentKey).childKeys.push(key);
+    }
+    processJSXAttributeRenderProtocols(node, key, ctx, source);
+    // Preserve explicit component children as call-site slot content.
+    if (!isComp || node.children.length > 0) {
+        ctx.parentStack.push({ key, tag });
+        processChildren(node.children, ctx, source);
+        ctx.parentStack.pop();
+    }
+    return key;
+}
+// ── Process JSX Fragment ──
+function processJSXFragment(node, ctx, source) {
+    const topLevelKeys = [];
+    for (const child of node.children) {
+        if (t.isJSXElement(child)) {
+            const childKey = processJSXElement(child, ctx, source);
+            if (childKey) {
+                topLevelKeys.push(childKey);
+            }
+        }
+        else if (isJSXFragment(child)) {
+            topLevelKeys.push(...processJSXFragment(child, ctx, source));
+        }
+        else if (t.isJSXExpressionContainer(child)) {
+            processExpression(child.expression, ctx, source);
+        }
+    }
+    return topLevelKeys;
+}
+// ── Process children array ──
+function processChildren(children, ctx, source) {
+    for (const child of children) {
+        if (t.isJSXElement(child)) {
+            processJSXElement(child, ctx, source);
+        }
+        else if (isJSXFragment(child)) {
+            processJSXFragment(child, ctx, source);
+        }
+        else if (t.isJSXExpressionContainer(child)) {
+            processExpression(child.expression, ctx, source);
+        }
+    }
+}
+// ── Process expression (detects repeat/conditional) ──
+function processExpression(expr, ctx, source) {
+    if (t.isJSXEmptyExpression(expr))
+        return;
+    // .map() → repeat region
+    if (isMapCallExpression(expr)) {
+        const callExpr = expr;
+        const parentInfo = ctx.parentStack[ctx.parentStack.length - 1] ?? null;
+        const sourceCandidates = [];
+        if (t.isMemberExpression(callExpr.callee) &&
+            t.isExpression(callExpr.callee.object)) {
+            const callback = callExpr.arguments[0];
+            const repeatCandidate = {
+                kind: "repeat-template",
+                collectionExpression: getExpressionText(callExpr.callee.object, source),
+                collectionSource: getExpressionSourceInfo(callExpr.callee.object, source, ctx),
+            };
+            if (t.isArrowFunctionExpression(callback) ||
+                t.isFunctionExpression(callback)) {
+                const itemParam = callback.params[0];
+                const indexParam = callback.params[1];
+                if (t.isIdentifier(itemParam)) {
+                    repeatCandidate.itemParamName = itemParam.name;
+                }
+                if (t.isIdentifier(indexParam)) {
+                    repeatCandidate.indexParamName = indexParam.name;
+                }
+            }
+            sourceCandidates.push(repeatCandidate);
+        }
+        const region = {
+            kind: "repeat-region",
+            ownerKey: parentInfo?.key ?? "",
+            childKeys: [],
+            sourceRange: toSourceRange(callExpr),
+            sourceCandidates: sourceCandidates.length > 0 ? sourceCandidates : undefined,
+        };
+        ctx.regions.push(region);
+        // Process the callback body for JSX
+        const callback = callExpr.arguments[0];
+        if (t.isArrowFunctionExpression(callback) ||
+            t.isFunctionExpression(callback)) {
+            const callbackScope = new Map();
+            for (const param of callback.params) {
+                for (const name of collectBoundIdentifiers(param)) {
+                    setUnresolvedBinding(callbackScope, name);
+                }
+            }
+            ctx.valueScopes.push(callbackScope);
+            const body = callback.body;
+            if (t.isJSXElement(body)) {
+                const childKey = processJSXElement(body, ctx, source);
+                if (childKey)
+                    region.childKeys.push(childKey);
+            }
+            else if (isJSXFragment(body)) {
+                region.childKeys.push(...processJSXFragment(body, ctx, source));
+            }
+            else if (t.isBlockStatement(body)) {
+                const callbackLocalScope = new Map();
+                ctx.valueScopes.push(callbackLocalScope);
+                // Look for return statement
+                for (const stmt of body.body) {
+                    if (t.isVariableDeclaration(stmt)) {
+                        collectStaticBindingsFromDeclarations([stmt], ctx, callbackLocalScope);
+                    }
+                    if (t.isReturnStatement(stmt) && stmt.argument) {
+                        if (t.isJSXElement(stmt.argument)) {
+                            const childKey = processJSXElement(stmt.argument, ctx, source);
+                            if (childKey)
+                                region.childKeys.push(childKey);
+                        }
+                        else if (isJSXFragment(stmt.argument)) {
+                            region.childKeys.push(...processJSXFragment(stmt.argument, ctx, source));
+                        }
+                        else if (t.isParenthesizedExpression(stmt.argument) &&
+                            t.isJSXElement(stmt.argument.expression)) {
+                            const childKey = processJSXElement(stmt.argument.expression, ctx, source);
+                            if (childKey)
+                                region.childKeys.push(childKey);
+                        }
+                        else if (t.isParenthesizedExpression(stmt.argument) &&
+                            isJSXFragment(stmt.argument.expression)) {
+                            region.childKeys.push(...processJSXFragment(stmt.argument.expression, ctx, source));
+                        }
+                        break;
+                    }
+                }
+                ctx.valueScopes.pop();
+            }
+            else if (t.isParenthesizedExpression(body) &&
+                t.isJSXElement(body.expression)) {
+                const childKey = processJSXElement(body.expression, ctx, source);
+                if (childKey)
+                    region.childKeys.push(childKey);
+            }
+            ctx.valueScopes.pop();
+        }
+        return;
+    }
+    // Ternary → conditional region
+    if (t.isConditionalExpression(expr)) {
+        const parentInfo = ctx.parentStack[ctx.parentStack.length - 1] ?? null;
+        const conditionCandidate = {
+            kind: "conditional-branch",
+            conditionExpression: getExpressionText(expr.test, source),
+            conditionSource: getExpressionSourceInfo(expr.test, source, ctx),
+        };
+        const region = {
+            kind: "conditional-region",
+            ownerKey: parentInfo?.key ?? "",
+            childKeys: [],
+            sourceRange: toSourceRange(expr),
+            sourceCandidates: [conditionCandidate],
+        };
+        ctx.regions.push(region);
+        // Process consequent (then)
+        if (t.isJSXElement(expr.consequent)) {
+            const childKey = processJSXElement(expr.consequent, ctx, source);
+            if (childKey)
+                region.childKeys.push(childKey);
+        }
+        // Process alternate (else)
+        if (t.isJSXElement(expr.alternate)) {
+            const childKey = processJSXElement(expr.alternate, ctx, source);
+            if (childKey)
+                region.childKeys.push(childKey);
+        }
+        return;
+    }
+    // && logical expression → conditional region (single branch)
+    if (t.isLogicalExpression(expr) && expr.operator === "&&") {
+        const parentInfo = ctx.parentStack[ctx.parentStack.length - 1] ?? null;
+        const conditionCandidate = {
+            kind: "conditional-branch",
+            conditionExpression: getExpressionText(expr.left, source),
+            conditionSource: getExpressionSourceInfo(expr.left, source, ctx),
+        };
+        const region = {
+            kind: "conditional-region",
+            ownerKey: parentInfo?.key ?? "",
+            childKeys: [],
+            sourceRange: toSourceRange(expr),
+            sourceCandidates: [conditionCandidate],
+        };
+        ctx.regions.push(region);
+        if (t.isJSXElement(expr.right)) {
+            const childKey = processJSXElement(expr.right, ctx, source);
+            if (childKey)
+                region.childKeys.push(childKey);
+        }
+        return;
+    }
+    // Parenthesized expression
+    if (t.isParenthesizedExpression(expr)) {
+        processExpression(expr.expression, ctx, source);
+        return;
+    }
+    // Direct JSX in expression
+    if (t.isJSXElement(expr)) {
+        processJSXElement(expr, ctx, source);
+        return;
+    }
+    if (isJSXFragment(expr)) {
+        processJSXFragment(expr, ctx, source);
+        return;
+    }
+}
+function getJSXReturnArgument(statement) {
+    const argument = statement.argument;
+    if (!argument) {
+        return null;
+    }
+    if (t.isJSXElement(argument) || isJSXFragment(argument)) {
+        return argument;
+    }
+    if (t.isParenthesizedExpression(argument) &&
+        (t.isJSXElement(argument.expression) || isJSXFragment(argument.expression))) {
+        return argument.expression;
+    }
+    return null;
+}
+function collectReturnRecordsFromStatements(statements, inheritedCondition) {
+    const records = [];
+    for (const statement of statements) {
+        if (t.isReturnStatement(statement)) {
+            const argument = getJSXReturnArgument(statement);
+            if (argument) {
+                records.push({ argument, statement, condition: inheritedCondition });
+            }
+            continue;
+        }
+        if (t.isIfStatement(statement)) {
+            const consequentStatements = t.isBlockStatement(statement.consequent)
+                ? statement.consequent.body
+                : [statement.consequent];
+            records.push(...collectReturnRecordsFromStatements(consequentStatements, statement.test));
+            if (statement.alternate) {
+                const alternateStatements = t.isBlockStatement(statement.alternate)
+                    ? statement.alternate.body
+                    : [statement.alternate];
+                records.push(...collectReturnRecordsFromStatements(alternateStatements, statement.test));
+            }
+            continue;
+        }
+        if (t.isSwitchStatement(statement)) {
+            for (const switchCase of statement.cases) {
+                const condition = switchCase.test
+                    ? t.binaryExpression("===", statement.discriminant, switchCase.test)
+                    : statement.discriminant;
+                records.push(...collectReturnRecordsFromStatements(switchCase.consequent, condition));
+            }
+        }
+    }
+    return records;
+}
+// ── Main: build graph from single source file ──
+export function buildGraphFromSource(file, source) {
+    return buildGraphWithLocalImportsFromSource(file, source).graph;
+}
+export function buildGraphWithLocalImportsFromSource(file, source) {
+    const emptyGraph = {
+        routeId: file,
+        rootKeys: [],
+        elements: new Map(),
+        regions: [],
+        fileIndex: new Map(),
+        version: 1,
+    };
+    const ast = parseSource(source);
+    if (!ast)
+        return { graph: emptyGraph, localImports: [] };
+    const localImports = extractLocalImportsFromAst(ast);
+    const elements = new Map();
+    const regions = [];
+    const rootKeys = [];
+    const fileIndex = new Map();
+    // Build import map once for the whole file
+    const importMap = buildImportMap(ast);
+    // Find all React component functions and their JSX return values
+    traverse(ast, {
+        "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression"(path) {
+            const componentName = findComponentName(path);
+            if (!componentName)
+                return;
+            const node = path.node;
+            let returnRecords = [];
+            if (t.isArrowFunctionExpression(node)) {
+                if (t.isJSXElement(node.body) || isJSXFragment(node.body)) {
+                    returnRecords = [
+                        {
+                            argument: node.body,
+                            statement: t.returnStatement(node.body),
+                        },
+                    ];
+                }
+                else if (t.isBlockStatement(node.body)) {
+                    returnRecords = collectReturnRecordsFromStatements(node.body.body);
+                }
+            }
+            else {
+                const body = node.body;
+                if (t.isBlockStatement(body)) {
+                    returnRecords = collectReturnRecordsFromStatements(body.body);
+                }
+            }
+            if (returnRecords.length === 0)
+                return;
+            const fileScope = new Map();
+            collectStaticBindingsFromDeclarations(getFileScopeVariableDeclarations(ast.program.body), createEvaluationContext(file, componentName, elements, regions, importMap, [fileScope]), fileScope);
+            const componentScope = new Map();
+            for (const param of node.params) {
+                for (const name of collectBoundIdentifiers(param)) {
+                    setUnresolvedBinding(componentScope, name);
+                }
+            }
+            const componentBody = t.isBlockStatement(node.body) ? node.body.body : [];
+            const firstReturnStatement = returnRecords[0]?.statement ?? null;
+            for (const statement of componentBody) {
+                if (firstReturnStatement && statement === firstReturnStatement) {
+                    break;
+                }
+                if (t.isVariableDeclaration(statement)) {
+                    collectStaticBindingsFromDeclarations([statement], createEvaluationContext(file, componentName, elements, regions, importMap, [fileScope, componentScope]), componentScope);
+                }
+            }
+            const ctx = createEvaluationContext(file, componentName, elements, regions, importMap, [fileScope, componentScope]);
+            for (const record of returnRecords) {
+                const childKeys = processRenderableNode(record.argument, ctx, source);
+                for (const key of childKeys) {
+                    if (!rootKeys.includes(key)) {
+                        rootKeys.push(key);
+                    }
+                }
+                if (record.condition) {
+                    const conditionCandidate = {
+                        kind: "conditional-branch",
+                        conditionExpression: getExpressionText(record.condition, source),
+                        conditionSource: getExpressionSourceInfo(record.condition, source, ctx),
+                    };
+                    pushRegion(ctx, "conditional-region", "", record.statement, childKeys, [conditionCandidate]);
+                }
+            }
+            // Don't traverse into nested functions (they might be other components)
+            path.skip();
+        },
+    });
+    // Build file index
+    const keys = [...elements.keys()];
+    if (keys.length > 0) {
+        fileIndex.set(file, keys);
+    }
+    return {
+        graph: {
+            routeId: file,
+            rootKeys,
+            elements,
+            regions,
+            fileIndex,
+            version: 1,
+        },
+        localImports,
+    };
+}
+// ── Re-export for backward compatibility ──
+export { buildGraphFromSource as buildProjectSourceGraph };
+/**
+ * 从项目源图中提取单路由的渲染源图。
+ * 当前阶段直接返回单文件构建结果。
+ */
+export function extractRenderSourceGraph(graph, _routeId, _entryFile) {
+    return graph;
+}