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

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

@@ -1,1371 +0,0 @@
-// ─── 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;
-}