android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/graph/build.js

@@ -0,0 +1,1995 @@
+import { createStableId } from "../../core/stable-id.js";
+import { computePaths } from "../../graph/paths.js";
+import { validateAreaGraph } from "../../validation/index.js";
+import {
+  codeNameCandidate,
+  componentIdentifierName,
+  controlNameCandidates,
+  literalNameCandidate,
+  resolveNameCandidates,
+} from "../names/policy.js";
+import { CallbackFlowTraversal } from "./callback-flow.js";
+import {
+  resolveComposeRouteArea,
+  resolveAreaOwnership,
+} from "./area-ownership.js";
+import { applyComponentVariants } from "./component-variants.js";
+function factsOfKind(artifact, kind) {
+  return artifact.facts.filter((fact) => fact.kind === kind);
+}
+function resolved(value, supportRefs, confidence = "high") {
+  return {
+    status: "resolved",
+    value,
+    confidence,
+    supportRefs: [...new Set(supportRefs)].sort(),
+  };
+}
+function graphId(namespace, caseId, entityKind, identity) {
+  return createStableId({
+    namespace,
+    caseId,
+    entityKind,
+    identity: [{ kind: "semantic-key", value: identity }],
+  });
+}
+function inferredTrigger(data) {
+  if (
+    data.elementType === "toggle" ||
+    data.elementType === "switch" ||
+    data.elementType === "checkbox" ||
+    data.elementType === "radio-button" ||
+    data.elementType === "toggle-button"
+  )
+    return "toggle";
+  if (data.elementType === "text-input" || data.elementType === "text-field")
+    return "text-input";
+  return "click";
+}
+function repeatedControlName(areaName) {
+  if (!areaName) return "List item";
+  return /\p{Script=Han}/u.test(areaName)
+    ? `${areaName}列表项`
+    : `${areaName} item`;
+}
+function genericMenuOpenerName(value) {
+  const compact = value
+    .replace(/[^\p{Letter}\p{Number}]/gu, "")
+    .toLocaleLowerCase("en-US");
+  return new Set([
+    "menu",
+    "more",
+    "morehorizontal",
+    "morehoriz",
+    "morevertical",
+    "morevert",
+    "overflow",
+    "更多",
+    "菜单",
+  ]).has(compact);
+}
+function contextualMenuName(value) {
+  const normalized = value.trim();
+  if (/菜单$/u.test(normalized) || /(?:^|\s)menu$/iu.test(normalized)) {
+    return normalized;
+  }
+  return /\p{Script=Han}/u.test(normalized)
+    ? `${normalized}菜单`
+    : `${normalized} menu`;
+}
+function androidExternalTargetName(intentAction) {
+  switch (intentAction) {
+    case "android.intent.action.OPEN_DOCUMENT":
+    case "android.intent.action.GET_CONTENT":
+      return "Android 系统文件选择器";
+    case "android.intent.action.OPEN_DOCUMENT_TREE":
+      return "Android 系统文件夹选择器";
+    case "android.intent.action.CREATE_DOCUMENT":
+      return "Android 系统文件保存界面";
+    default:
+      return undefined;
+  }
+}
+function effectText(data, targetName) {
+  const scalarValue =
+    data.value === null ||
+    typeof data.value === "string" ||
+    typeof data.value === "number" ||
+    typeof data.value === "boolean"
+      ? String(data.value)
+      : undefined;
+  switch (data.effectKind) {
+    case "navigate-area":
+      return targetName ? `进入 ${targetName}` : "进入目标区域";
+    case "open-external":
+      return targetName ? `打开 ${targetName}` : "打开 App 外目标";
+    case "update-state":
+      if (data.stateKey?.split("\u0000").includes("preference-key")) {
+        return "更新该设置的选中值";
+      }
+      return scalarValue === undefined
+        ? "更新当前状态"
+        : `将当前状态更新为“${scalarValue}”`;
+    case "show-feedback":
+      return scalarValue === undefined
+        ? "显示短暂提示"
+        : `显示短暂提示“${scalarValue}”`;
+    case "business-action":
+      return "执行对应业务操作";
+    case "show-surface":
+      return targetName ? `显示 ${targetName}` : "显示交互区域";
+    case "close-surface":
+      return "关闭当前区域";
+    case "input":
+      return "接收并处理用户输入";
+    case "unknown":
+      return "操作结果待确认";
+  }
+}
+function sorted(values) {
+  return values.sort((left, right) => left.id.localeCompare(right.id, "en"));
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function canonicalSemanticValue(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalSemanticValue).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value)
+      .sort(([left], [right]) => left.localeCompare(right, "en"))
+      .map(
+        ([key, child]) =>
+          `${JSON.stringify(key)}:${canonicalSemanticValue(child)}`,
+      )
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stateKeyDisplayName(value) {
+  const parts = value.split("\u0000");
+  const preferenceKeyIndex = parts.indexOf("preference-key");
+  if (preferenceKeyIndex >= 0 && parts[preferenceKeyIndex + 1]?.trim()) {
+    return parts[preferenceKeyIndex + 1].trim();
+  }
+  if (parts[0] === "receiver" && parts[3]?.trim()) {
+    return parts[3].trim();
+  }
+  if (parts[2]?.trim()) return parts[2].trim();
+  if (parts[1]?.trim()) return parts[1].trim();
+  return value;
+}
+function normalizedUiPropertyName(property) {
+  const leaf = property.trim().split(/[.:/]/u).at(-1) ?? property;
+  return leaf.replace(/[^a-z0-9]/giu, "").toLowerCase();
+}
+function staticEnabledFor(uiFactRef, propertyFacts) {
+  const enabledFacts = propertyFacts.filter(
+    (property) =>
+      property.data.ownerKey === uiFactRef &&
+      normalizedUiPropertyName(property.data.property) === "enabled" &&
+      typeof property.data.value === "boolean",
+  );
+  if (enabledFacts.length === 0) return undefined;
+  const values = new Set(enabledFacts.map((property) => property.data.value));
+  if (values.size !== 1) {
+    throw new Error(
+      `Area graph property invariant for UI Element ${uiFactRef}: ` +
+        "static enabled properties disagree.",
+    );
+  }
+  const confidenceRank = { high: 2, medium: 1, low: 0 };
+  const confidence = enabledFacts.reduce(
+    (weakest, property) =>
+      confidenceRank[property.confidence] < confidenceRank[weakest]
+        ? property.confidence
+        : weakest,
+    "high",
+  );
+  return resolved(
+    enabledFacts[0].data.value,
+    enabledFacts.map((property) => property.id),
+    confidence,
+  );
+}
+function descriptionText(value) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().replace(/\s+/gu, " ");
+  return normalized.length > 0 && /[\p{Letter}\p{Number}]/u.test(normalized)
+    ? normalized
+    : undefined;
+}
+function sameDescriptionText(left, right) {
+  return left.toLocaleLowerCase("en-US") === right.toLocaleLowerCase("en-US");
+}
+function weakestDescriptionConfidence(candidates) {
+  const rank = { high: 2, medium: 1, low: 0 };
+  return candidates.reduce(
+    (weakest, candidate) =>
+      rank[candidate.confidence] < rank[weakest]
+        ? candidate.confidence
+        : weakest,
+    "high",
+  );
+}
+function stableDescriptionFacts(
+  caseId,
+  areaRef,
+  componentRefs,
+  areaName,
+  uiFacts,
+  propertyFacts,
+  boundUiFactRefs,
+) {
+  const uiById = new Map(uiFacts.map((fact) => [fact.id, fact]));
+  const runtimeContentOwners = new Set(
+    propertyFacts.flatMap((property) =>
+      normalizedUiPropertyName(property.data.property) === "runtimecontent" &&
+      property.data.value === true
+        ? [property.data.ownerKey]
+        : [],
+    ),
+  );
+  const candidates = [];
+  for (const fact of uiFacts) {
+    const value = descriptionText(fact.data.visibleText);
+    if (
+      !value ||
+      fact.data.actionable ||
+      boundUiFactRefs.has(fact.id) ||
+      !componentRefs.has(fact.data.ownerKey) ||
+      runtimeContentOwners.has(fact.id)
+    )
+      continue;
+    candidates.push({
+      value,
+      sourceFactRefs: [fact.id],
+      confidence: fact.confidence,
+    });
+  }
+  for (const property of propertyFacts) {
+    const value = descriptionText(property.data.value);
+    if (!value) continue;
+    const normalizedProperty = normalizedUiPropertyName(property.data.property);
+    const stableProperty =
+      property.data.property.startsWith("stable-content:") ||
+      normalizedProperty === "stablecontent";
+    if (!stableProperty && normalizedProperty !== "message") continue;
+    const ownedUi = uiById.get(property.data.ownerKey);
+    const ownedByArea =
+      componentRefs.has(property.data.ownerKey) ||
+      (ownedUi !== undefined &&
+        !ownedUi.data.actionable &&
+        !boundUiFactRefs.has(ownedUi.id) &&
+        componentRefs.has(ownedUi.data.ownerKey));
+    if (!ownedByArea) continue;
+    candidates.push({
+      value,
+      sourceFactRefs: [property.id],
+      confidence: property.confidence,
+    });
+  }
+  const areaNameValue =
+    areaName.status === "resolved"
+      ? descriptionText(areaName.value)
+      : undefined;
+  const grouped = new Map();
+  for (const candidate of candidates) {
+    if (areaNameValue && sameDescriptionText(candidate.value, areaNameValue))
+      continue;
+    const key = candidate.value.toLocaleLowerCase("en-US");
+    const matches = grouped.get(key) ?? [];
+    matches.push(candidate);
+    grouped.set(key, matches);
+  }
+  return [...grouped.values()].map((matching) => {
+    const value = matching[0].value;
+    const sourceFactRefs = uniqueSorted(
+      matching.flatMap((candidate) => candidate.sourceFactRefs),
+    );
+    return {
+      id: graphId(
+        "description",
+        caseId,
+        "stable-content",
+        `${areaRef}\u0000${value.toLocaleLowerCase("en-US")}`,
+      ),
+      kind: "stable-content",
+      value: resolved(
+        value,
+        sourceFactRefs,
+        weakestDescriptionConfidence(matching),
+      ),
+      sourceFactRefs,
+    };
+  });
+}
+const controlNameUnknownReasonCodes = new Set([
+  "INTRINSIC_CONTROL_NAME_UNKNOWN",
+  "INTRINSIC_COMPOSE_CONTROL_NAME_UNKNOWN",
+]);
+function sourceControlNameUnresolvedItems(fact, unresolvedById) {
+  return uniqueSorted(fact.unresolvedRefs ?? [])
+    .map((ref) => unresolvedById.get(ref))
+    .filter(
+      (item) =>
+        item !== undefined &&
+        item.ownerRef === fact.id &&
+        /^(?:data\.)?(?:controlName|name)$/u.test(item.fieldPath) &&
+        controlNameUnknownReasonCodes.has(item.reasonCode),
+    );
+}
+function sourceControlNameUnresolvedRef(fact, unresolvedById) {
+  const matches = sourceControlNameUnresolvedItems(fact, unresolvedById);
+  return matches.length === 1 ? matches[0].id : undefined;
+}
+export function buildAreaGraph(source, options = {}) {
+  const componentFacts = factsOfKind(source, "component");
+  const componentVariantFacts = factsOfKind(source, "component-variant");
+  const uiFacts = factsOfKind(source, "ui-element").filter(
+    (fact) => fact.data.analysisRole !== "declaration-template",
+  );
+  const bindingFacts = factsOfKind(source, "interaction-binding");
+  const boundUiFactRefs = new Set(
+    bindingFacts.map((binding) => binding.data.elementKey),
+  );
+  const callbackFacts = factsOfKind(source, "callback");
+  const callbackFlowFacts = factsOfKind(source, "callback-flow");
+  const effectFacts = factsOfKind(source, "behavior-effect");
+  const navigationFacts = factsOfKind(source, "navigation-target");
+  const conditionFacts = factsOfKind(source, "condition");
+  const conditionById = new Map(
+    conditionFacts.map((condition) => [condition.id, condition]),
+  );
+  const uniqueConditionRefs = (refs) => {
+    const selectedByEvidence = new Map();
+    for (const ref of refs) {
+      const condition = conditionById.get(ref);
+      const key = condition
+        ? JSON.stringify({
+            expression: condition.data.expressionAnchor,
+            evidence: condition.support
+              .map((support) => support.evidenceRef)
+              .sort(),
+          })
+        : ref;
+      if (!selectedByEvidence.has(key)) {
+        selectedByEvidence.set(key, ref);
+      }
+    }
+    return [...selectedByEvidence.values()].sort((left, right) =>
+      left.localeCompare(right, "en"),
+    );
+  };
+  const normalizeConditionAlternatives = (alternatives) => {
+    const byConditions = new Map();
+    for (const alternative of alternatives) {
+      const conditionRefs = uniqueConditionRefs(alternative.conditionRefs);
+      const key = conditionRefs.join("\u0000");
+      const existing = byConditions.get(key);
+      byConditions.set(key, {
+        conditionRefs,
+        sourceFactRefs: uniqueSorted([
+          ...(existing?.sourceFactRefs ?? []),
+          ...alternative.sourceFactRefs,
+        ]),
+      });
+    }
+    return [...byConditions.values()].sort((left, right) =>
+      left.conditionRefs
+        .join("\u0000")
+        .localeCompare(right.conditionRefs.join("\u0000"), "en"),
+    );
+  };
+  const entryFacts = factsOfKind(source, "entry-point");
+  const propertyFacts = factsOfKind(source, "ui-property");
+  const containerFacts = factsOfKind(source, "container-binding");
+  const unresolved = [...source.unresolved];
+  const sourceUnresolvedById = new Map(
+    source.unresolved.map((item) => [item.id, item]),
+  );
+  const callbackTraversal = new CallbackFlowTraversal(callbackFlowFacts, {
+    maxCallDepth: options.maxCallDepth,
+    maxCallbackIterations: options.maxCallbackIterations,
+    conditionFacts,
+  });
+  const areaByComponent = new Map();
+  const areaById = new Map();
+  const componentById = new Map(
+    componentFacts.map((component) => [component.id, component]),
+  );
+  const sourceFactById = new Map(source.facts.map((fact) => [fact.id, fact]));
+  const sourceEvidenceById = new Map(
+    source.evidence.map((item) => [item.id, item]),
+  );
+  const evidenceRefsForNameSupport = (supportRefs) =>
+    uniqueSorted(
+      supportRefs.flatMap((supportRef) => {
+        const fact = sourceFactById.get(supportRef);
+        if (fact) return fact.support.map((support) => support.evidenceRef);
+        return sourceEvidenceById.has(supportRef) ? [supportRef] : [];
+      }),
+    );
+  const explicitAppEntryComponentRefs = new Set([
+    ...componentFacts.flatMap((component) =>
+      component.support.some(
+        (support) =>
+          sourceEvidenceById.get(support.evidenceRef)?.sourceKind === "java" ||
+          sourceEvidenceById.get(support.evidenceRef)?.sourceKind === "kotlin",
+      )
+        ? [component.id]
+        : [],
+    ),
+    ...navigationFacts.flatMap((navigation) =>
+      navigation.data.targetKind === "component" && navigation.data.targetKey
+        ? [navigation.data.targetKey]
+        : [],
+    ),
+    ...effectFacts.flatMap((effect) =>
+      effect.data.effectKind === "navigate-area" && effect.data.targetKey
+        ? [effect.data.targetKey]
+        : [],
+    ),
+  ]);
+  const ownership = resolveAreaOwnership(componentFacts, containerFacts, {
+    explicitAppEntryComponentRefs,
+  });
+  for (const group of ownership.groups) {
+    const fact = group.anchor;
+    const id = graphId("area", source.caseId, group.kind, fact.id);
+    group.componentRefs.forEach((componentRef) =>
+      areaByComponent.set(componentRef, id),
+    );
+    const componentRefs = new Set(group.componentRefs);
+    const titleFacts = propertyFacts
+      .filter(
+        (property) =>
+          componentRefs.has(property.data.ownerKey) &&
+          /^(title|label|name)$/iu.test(property.data.property) &&
+          typeof property.data.value === "string",
+      )
+      .sort(
+        (left, right) =>
+          Number(right.data.ownerKey === fact.id) -
+            Number(left.data.ownerKey === fact.id) ||
+          left.id.localeCompare(right.id, "en"),
+      );
+    const nameDecision = resolveNameCandidates([
+      ...titleFacts.map((title) =>
+        literalNameCandidate(
+          "visible-title",
+          typeof title.data.value === "string" ? title.data.value : undefined,
+          [title.id],
+          title.confidence,
+          {
+            frameworkGeneric: title.support.some(
+              (support) => support.role === "resolved Compose surface API name",
+            ),
+          },
+        ),
+      ),
+      codeNameCandidate(
+        "component-identifier",
+        fact.data.qualifiedName,
+        [fact.id],
+        componentIdentifierName,
+      ),
+    ]);
+    let areaName;
+    const areaUnresolvedRefs = uniqueSorted(
+      group.componentRefs.flatMap(
+        (componentRef) => componentById.get(componentRef)?.unresolvedRefs ?? [],
+      ),
+    );
+    if (
+      nameDecision.value !== undefined &&
+      nameDecision.confidence !== undefined
+    ) {
+      areaName = resolved(
+        nameDecision.value,
+        nameDecision.supportRefs,
+        nameDecision.confidence,
+      );
+    } else {
+      const unresolvedId = graphId(
+        "unresolved",
+        source.caseId,
+        "area-name",
+        fact.id,
+      );
+      unresolved.push({
+        id: unresolvedId,
+        ownerRef: id,
+        fieldPath: "name",
+        reasonCode: "INTRINSIC_AREA_NAME_UNKNOWN",
+        message:
+          "区域没有可用标题；类名、路由和 Surface 身份候选也均为 raw/hash、抽象 Base 或框架泛称。",
+        evidenceRefs: uniqueSorted([
+          ...fact.support.map((support) => support.evidenceRef),
+          ...titleFacts.flatMap((title) =>
+            title.support.map((support) => support.evidenceRef),
+          ),
+        ]),
+        candidates: nameDecision.attempts.flatMap((attempt) =>
+          attempt.outcome === "rejected" && attempt.rawValue !== undefined
+            ? [
+                {
+                  value: attempt.rawValue,
+                  supportRefs: evidenceRefsForNameSupport(attempt.supportRefs),
+                  ...(attempt.reason ? { note: attempt.reason } : {}),
+                },
+              ]
+            : [],
+        ),
+        impact: ["req-area-name"],
+        originRef: fact.id,
+      });
+      areaUnresolvedRefs.push(unresolvedId);
+      areaName = { status: "unresolved", unresolvedRef: unresolvedId };
+    }
+    areaById.set(id, {
+      id,
+      identityAnchors: uniqueSorted(
+        group.componentRefs.flatMap((componentRef) => {
+          const component = componentById.get(componentRef);
+          return component ? [component.id, component.data.qualifiedName] : [];
+        }),
+      ),
+      kind: group.kind,
+      name: areaName,
+      descriptionFacts: stableDescriptionFacts(
+        source.caseId,
+        id,
+        componentRefs,
+        areaName,
+        uiFacts,
+        propertyFacts,
+        boundUiFactRefs,
+      ),
+      controlRefs: [],
+      conditions: conditionFacts
+        .filter((condition) => componentRefs.has(condition.data.ownerKey))
+        .map((condition) => condition.id)
+        .sort(),
+      sourceFactRefs: uniqueSorted([
+        ...group.componentRefs,
+        ...group.containerBindingRefs,
+      ]),
+      unresolvedRefs: uniqueSorted(areaUnresolvedRefs),
+    });
+  }
+  const controls = [];
+  const controlByUi = new Map();
+  for (const fact of uiFacts) {
+    if (!fact.data.actionable && !boundUiFactRefs.has(fact.id)) continue;
+    const areaRef = areaByComponent.get(fact.data.ownerKey);
+    if (!areaRef) continue;
+    const id = graphId(
+      "control",
+      source.caseId,
+      fact.data.elementType,
+      fact.id,
+    );
+    controlByUi.set(fact.id, id);
+    const ownerArea = areaById.get(areaRef);
+    const areaName =
+      ownerArea?.name.status === "resolved" ? ownerArea.name.value : undefined;
+    const areaNameSupport =
+      ownerArea?.name.status === "resolved" ? ownerArea.name.supportRefs : [];
+    const repeatedItemName =
+      (fact.data.elementType === "list-item" ||
+        fact.data.elementType === "repeated-row") &&
+      fact.data.dynamicIdentity
+        ? repeatedControlName(areaName)
+        : undefined;
+    const nameDecision = resolveNameCandidates(
+      controlNameCandidates(
+        fact.data,
+        fact.id,
+        fact.confidence,
+        repeatedItemName,
+        areaNameSupport,
+      ),
+    );
+    const sourceNameUnresolvedItems = sourceControlNameUnresolvedItems(
+      fact,
+      sourceUnresolvedById,
+    );
+    const resolvedSourceNameUnresolvedRefs = new Set(
+      nameDecision.value !== undefined
+        ? sourceNameUnresolvedItems.map((item) => item.id)
+        : [],
+    );
+    const unresolvedRefs = (fact.unresolvedRefs ?? []).filter(
+      (ref) => !resolvedSourceNameUnresolvedRefs.has(ref),
+    );
+    let supportedName;
+    if (
+      nameDecision.value !== undefined &&
+      nameDecision.confidence !== undefined
+    ) {
+      for (let index = unresolved.length - 1; index >= 0; index -= 1) {
+        if (resolvedSourceNameUnresolvedRefs.has(unresolved[index].id)) {
+          unresolved.splice(index, 1);
+        }
+      }
+      supportedName = resolved(
+        nameDecision.value,
+        nameDecision.supportRefs,
+        nameDecision.confidence,
+      );
+    } else {
+      const sourceUnresolvedRef = sourceControlNameUnresolvedRef(
+        fact,
+        sourceUnresolvedById,
+      );
+      const unresolvedId =
+        sourceUnresolvedRef ??
+        graphId("unresolved", source.caseId, "control-name", fact.id);
+      if (!sourceUnresolvedRef) {
+        unresolved.push({
+          id: unresolvedId,
+          ownerRef: id,
+          fieldPath: "name",
+          reasonCode: "INTRINSIC_CONTROL_NAME_UNKNOWN",
+          message: "控件没有可见文字、无障碍标签或可证明的图标语义。",
+          evidenceRefs: fact.support.map((item) => item.evidenceRef),
+          candidates: nameDecision.attempts.flatMap((attempt) =>
+            attempt.outcome === "rejected" && attempt.rawValue !== undefined
+              ? [
+                  {
+                    value: attempt.rawValue,
+                    supportRefs: evidenceRefsForNameSupport(
+                      attempt.supportRefs,
+                    ),
+                    ...(attempt.reason ? { note: attempt.reason } : {}),
+                  },
+                ]
+              : [],
+          ),
+          impact: ["req-feature-name"],
+          originRef: fact.id,
+        });
+        unresolvedRefs.push(unresolvedId);
+      }
+      supportedName = { status: "unresolved", unresolvedRef: unresolvedId };
+    }
+    const ownedControlConditions = conditionFacts.filter(
+      (condition) => condition.data.ownerKey === fact.id,
+    );
+    const visibilityConditions = ownedControlConditions
+      .filter((condition) => condition.data.conditionRole === "visibility")
+      .map((condition) => condition.id)
+      .sort((left, right) => left.localeCompare(right, "en"));
+    const enabledConditions = ownedControlConditions
+      .filter((condition) => condition.data.conditionRole !== "visibility")
+      .map((condition) => condition.id)
+      .sort((left, right) => left.localeCompare(right, "en"));
+    const enabled = staticEnabledFor(fact.id, propertyFacts);
+    const control = {
+      id,
+      areaRef,
+      kind: fact.data.elementType,
+      name: supportedName,
+      ...(enabled ? { enabled } : {}),
+      actionRefs: [],
+      visibilityConditions,
+      enabledConditions,
+      sourceFactRefs: uniqueSorted([
+        fact.id,
+        ...visibilityConditions,
+        ...enabledConditions,
+        ...(enabled?.status === "resolved" ? enabled.supportRefs : []),
+      ]),
+      unresolvedRefs: [...new Set(unresolvedRefs)].sort(),
+    };
+    controls.push(control);
+    const area = areaById.get(areaRef);
+    if (area) {
+      areaById.set(areaRef, {
+        ...area,
+        controlRefs: [...area.controlRefs, id].sort(),
+      });
+    }
+  }
+  const actions = [];
+  const effects = [];
+  const edges = [];
+  const externalEndpoints = [];
+  const actionByBinding = new Map();
+  const effectGraphByFact = new Map();
+  const navigationByEffect = new Map(
+    navigationFacts.map((fact) => [fact.data.effectKey, fact]),
+  );
+  const exactTargetEffectSemanticKey = (effect) => {
+    if (!effect.data.targetKey) return undefined;
+    const effectData = Object.fromEntries(
+      Object.entries(effect.data).filter(([key]) => key !== "conditionKeys"),
+    );
+    const navigation = navigationByEffect.get(effect.id);
+    const navigationData = navigation
+      ? Object.fromEntries(
+          Object.entries(navigation.data).filter(
+            ([key]) => key !== "effectKey",
+          ),
+        )
+      : undefined;
+    return canonicalSemanticValue({
+      effectData,
+      confidence: effect.confidence,
+      unresolvedRefs: uniqueSorted(effect.unresolvedRefs ?? []),
+      ...(navigation
+        ? {
+            navigation: {
+              data: navigationData,
+              confidence: navigation.confidence,
+              unresolvedRefs: uniqueSorted(navigation.unresolvedRefs ?? []),
+            },
+          }
+        : {}),
+    });
+  };
+  const hasResolvedAreaTarget = (effect) => {
+    if (effect.data.targetKey && areaByComponent.has(effect.data.targetKey))
+      return true;
+    const navigation = navigationByEffect.get(effect.id);
+    if (
+      navigation?.data.targetKind === "component" &&
+      navigation.data.targetKey &&
+      areaByComponent.has(navigation.data.targetKey)
+    )
+      return true;
+    return Boolean(
+      navigation?.data.targetKind === "route" &&
+      navigation.data.uri &&
+      resolveComposeRouteArea(
+        navigation.data.uri,
+        componentFacts,
+        areaByComponent,
+      ).areaRef,
+    );
+  };
+  const addUnknownEffectForAction = (
+    action,
+    originRef,
+    sourceFactRefs,
+    evidenceRefs,
+    message,
+  ) => {
+    const effectId = graphId("effect", source.caseId, "unknown", action.id);
+    const unresolvedId = graphId(
+      "unresolved",
+      source.caseId,
+      "control-action",
+      originRef,
+    );
+    unresolved.push({
+      id: unresolvedId,
+      ownerRef: action.id,
+      fieldPath: "effectRefs",
+      reasonCode: "INTRINSIC_CONTROL_ACTION_UNKNOWN",
+      message,
+      evidenceRefs: uniqueSorted(evidenceRefs),
+      candidates: [],
+      impact: ["req-feature-effect"],
+      originRef,
+    });
+    effects.push({
+      id: effectId,
+      actionRef: action.id,
+      kind: "unknown",
+      description: { status: "unresolved", unresolvedRef: unresolvedId },
+      sourceFactRefs: uniqueSorted(sourceFactRefs),
+      unresolvedRefs: [unresolvedId],
+    });
+    return { effectId, unresolvedId };
+  };
+  const addEffectForAction = (
+    action,
+    sourceEffect,
+    alternatives,
+    equivalentSourceEffects = [sourceEffect],
+  ) => {
+    const equivalentEffectRefs = uniqueSorted(
+      equivalentSourceEffects.map((effect) => effect.id),
+    );
+    const equivalentNavigations = equivalentSourceEffects.flatMap((effect) => {
+      const candidate = navigationByEffect.get(effect.id);
+      return candidate ? [candidate] : [];
+    });
+    const equivalentNavigationRefs = uniqueSorted(
+      equivalentNavigations.map((candidate) => candidate.id),
+    );
+    const normalizedAlternatives = normalizeConditionAlternatives(alternatives);
+    const flowFactRefs = uniqueSorted(
+      normalizedAlternatives.flatMap(
+        (alternative) => alternative.sourceFactRefs,
+      ),
+    );
+    const conditionRefs = uniqueConditionRefs(
+      normalizedAlternatives.flatMap(
+        (alternative) => alternative.conditionRefs,
+      ),
+    );
+    const id = graphId(
+      "effect",
+      source.caseId,
+      sourceEffect.data.effectKind,
+      `${action.id}:${sourceEffect.id}`,
+    );
+    for (const equivalent of equivalentSourceEffects) {
+      effectGraphByFact.set(equivalent.id, id);
+    }
+    const navigation = navigationByEffect.get(sourceEffect.id);
+    const routeResolution =
+      !sourceEffect.data.targetKey &&
+      navigation?.data.targetKind === "route" &&
+      navigation.data.uri
+        ? resolveComposeRouteArea(
+            navigation.data.uri,
+            componentFacts,
+            areaByComponent,
+          )
+        : undefined;
+    const targetArea = sourceEffect.data.targetKey
+      ? areaByComponent.get(sourceEffect.data.targetKey)
+      : routeResolution?.areaRef;
+    const targetComponent = sourceEffect.data.targetKey
+      ? componentFacts.find((fact) => fact.id === sourceEffect.data.targetKey)
+      : undefined;
+    const targetComponentName = targetComponent
+      ? resolveNameCandidates([
+          codeNameCandidate(
+            "component-identifier",
+            targetComponent.data.qualifiedName,
+            [targetComponent.id],
+            componentIdentifierName,
+          ),
+        ])
+      : undefined;
+    const externalTargetName = androidExternalTargetName(
+      navigation?.data.intentAction,
+    );
+    const targetName = targetArea
+      ? areaById.get(targetArea)?.name
+      : targetComponentName?.value !== undefined &&
+          targetComponentName.confidence !== undefined
+        ? resolved(
+            targetComponentName.value,
+            targetComponentName.supportRefs,
+            targetComponentName.confidence,
+          )
+        : navigation?.data.presentation === "chooser"
+          ? resolved(
+              "Android 系统选择器",
+              [navigation.id],
+              navigation.confidence,
+            )
+          : externalTargetName && navigation
+            ? resolved(
+                externalTargetName,
+                [navigation.id],
+                navigation.confidence,
+              )
+            : undefined;
+    const inheritedNavigationUnresolvedRefs = uniqueSorted([
+      ...equivalentSourceEffects.flatMap(
+        (effect) => effect.unresolvedRefs ?? [],
+      ),
+      ...equivalentNavigations.flatMap(
+        (candidate) => candidate.unresolvedRefs ?? [],
+      ),
+    ]);
+    const effectUnresolvedRefs = [...inheritedNavigationUnresolvedRefs];
+    const hasResolvedValue = Object.prototype.hasOwnProperty.call(
+      sourceEffect.data,
+      "value",
+    );
+    const hasInheritedFeedbackValueUnknown =
+      inheritedNavigationUnresolvedRefs.some((unresolvedRef) => {
+        const item = sourceUnresolvedById.get(unresolvedRef);
+        return (
+          item !== undefined &&
+          (/feedback|snackbar|toast/iu.test(item.reasonCode) ||
+            /(?:value|text|message)$/iu.test(item.fieldPath))
+        );
+      });
+    if (
+      sourceEffect.data.effectKind === "show-feedback" &&
+      !hasResolvedValue &&
+      !hasInheritedFeedbackValueUnknown
+    ) {
+      const unresolvedId = graphId(
+        "unresolved",
+        source.caseId,
+        "feedback-value",
+        sourceEffect.id,
+      );
+      if (!unresolved.some((item) => item.id === unresolvedId)) {
+        unresolved.push({
+          id: unresolvedId,
+          ownerRef: id,
+          fieldPath: "value",
+          reasonCode: "INTRINSIC_FEEDBACK_VALUE_UNKNOWN",
+          message: "已确认会显示短暂提示，但静态源码不能确定提示内容。",
+          evidenceRefs: sourceEffect.support.map((item) => item.evidenceRef),
+          candidates: [],
+          impact: ["req-feature-effect"],
+          originRef: sourceEffect.id,
+        });
+      }
+      effectUnresolvedRefs.push(unresolvedId);
+    }
+    const supportRefs = uniqueSorted([
+      ...equivalentEffectRefs,
+      ...flowFactRefs,
+      ...equivalentNavigationRefs,
+    ]);
+    effects.push({
+      id,
+      actionRef: action.id,
+      kind: sourceEffect.data.effectKind,
+      description: resolved(
+        effectText(
+          sourceEffect.data,
+          targetName?.status === "resolved" ? targetName.value : undefined,
+        ),
+        uniqueSorted([...equivalentEffectRefs, ...equivalentNavigationRefs]),
+        sourceEffect.confidence,
+      ),
+      ...(normalizedAlternatives.some(
+        (alternative) => alternative.conditionRefs.length > 0,
+      )
+        ? { conditionAlternatives: normalizedAlternatives }
+        : {}),
+      ...(sourceEffect.data.closePolicy
+        ? { closePolicy: sourceEffect.data.closePolicy }
+        : {}),
+      ...(sourceEffect.data.transitionMode
+        ? { transitionMode: sourceEffect.data.transitionMode }
+        : {}),
+      ...(sourceEffect.data.stateKey
+        ? {
+            stateKey: resolved(
+              stateKeyDisplayName(sourceEffect.data.stateKey),
+              equivalentEffectRefs,
+              sourceEffect.confidence,
+            ),
+          }
+        : {}),
+      ...(hasResolvedValue
+        ? {
+            value: resolved(
+              sourceEffect.data.value ?? null,
+              equivalentEffectRefs,
+              sourceEffect.confidence,
+            ),
+          }
+        : {}),
+      sourceFactRefs: supportRefs,
+      unresolvedRefs: uniqueSorted(effectUnresolvedRefs),
+    });
+    if (
+      sourceEffect.data.effectKind !== "navigate-area" &&
+      sourceEffect.data.effectKind !== "show-surface" &&
+      sourceEffect.data.effectKind !== "open-external" &&
+      navigation?.data.targetKind !== "external"
+    ) {
+      return id;
+    }
+    let target;
+    if (targetArea) {
+      target = { kind: "area", ref: targetArea };
+    } else if (
+      sourceEffect.data.effectKind === "open-external" ||
+      navigation?.data.targetKind === "external"
+    ) {
+      const endpointSemanticKey = [
+        navigation?.data.presentation ?? "direct",
+        navigation?.data.intentAction ?? "external",
+        navigation?.data.mimeType ?? "",
+        navigation?.data.uri ?? targetComponent?.data.qualifiedName ?? "",
+      ].join("\u0000");
+      const endpointId = graphId(
+        "external",
+        source.caseId,
+        "endpoint",
+        endpointSemanticKey,
+      );
+      const existingEndpoint = externalEndpoints.findIndex(
+        (item) => item.id === endpointId,
+      );
+      if (existingEndpoint < 0) {
+        externalEndpoints.push({
+          id: endpointId,
+          kind:
+            navigation?.data.presentation === "chooser"
+              ? "android-intent-chooser"
+              : (navigation?.data.intentAction ?? "external"),
+          name:
+            targetName ??
+            resolved(
+              navigation?.data.uri ?? "App 外目标",
+              [navigation?.id ?? sourceEffect.id],
+              "medium",
+            ),
+          ...(navigation?.data.presentation
+            ? { presentation: navigation.data.presentation }
+            : {}),
+          ...(navigation?.data.intentAction
+            ? {
+                intentAction: resolved(
+                  navigation.data.intentAction,
+                  [navigation.id],
+                  navigation.confidence,
+                ),
+              }
+            : {}),
+          ...(navigation?.data.mimeType
+            ? {
+                mimeType: resolved(
+                  navigation.data.mimeType,
+                  [navigation.id],
+                  navigation.confidence,
+                ),
+              }
+            : {}),
+          ...(navigation?.data.uri
+            ? {
+                uri: resolved(
+                  navigation.data.uri,
+                  [navigation.id],
+                  navigation.confidence,
+                ),
+              }
+            : {}),
+          sourceFactRefs: [
+            ...equivalentEffectRefs,
+            ...equivalentNavigationRefs,
+          ].sort(),
+          unresolvedRefs: [],
+        });
+      } else {
+        externalEndpoints[existingEndpoint] = {
+          ...externalEndpoints[existingEndpoint],
+          sourceFactRefs: uniqueSorted([
+            ...externalEndpoints[existingEndpoint].sourceFactRefs,
+            ...equivalentEffectRefs,
+            ...equivalentNavigationRefs,
+          ]),
+        };
+      }
+      target = { kind: "external", ref: endpointId };
+    } else {
+      const inheritedUnresolvedId =
+        inheritedNavigationUnresolvedRefs.length === 1
+          ? inheritedNavigationUnresolvedRefs[0]
+          : undefined;
+      const unresolvedId =
+        inheritedUnresolvedId ??
+        graphId("unresolved", source.caseId, "edge-target", sourceEffect.id);
+      if (!inheritedUnresolvedId) {
+        unresolved.push({
+          id: unresolvedId,
+          ownerRef: id,
+          fieldPath: "target",
+          reasonCode: "INTRINSIC_NAVIGATION_TARGET_UNKNOWN",
+          message: "静态源码不能确定该导航效果的目标。",
+          evidenceRefs: sourceEffect.support.map((item) => item.evidenceRef),
+          candidates: (routeResolution?.candidateAreaRefs ?? []).map(
+            (value) => ({
+              value,
+              supportRefs: navigation
+                ? navigation.support.map((item) => item.evidenceRef)
+                : [],
+            }),
+          ),
+          impact: ["area-path"],
+          originRef: sourceEffect.id,
+        });
+      }
+      target = { status: "unresolved", unresolvedRef: unresolvedId };
+    }
+    const control = controls.find((item) => item.id === action.controlRef);
+    if (control) {
+      edges.push({
+        id: graphId(
+          "edge",
+          source.caseId,
+          sourceEffect.data.effectKind,
+          `${control.areaRef}:${id}`,
+        ),
+        sourceAreaRef: control.areaRef,
+        controlRef: control.id,
+        actionRef: action.id,
+        target,
+        conditions: uniqueConditionRefs([
+          ...conditionRefs,
+          ...(areaById.get(control.areaRef)?.conditions ?? []),
+        ]),
+        ...(normalizedAlternatives.some(
+          (alternative) => alternative.conditionRefs.length > 0,
+        )
+          ? { conditionAlternatives: normalizedAlternatives }
+          : {}),
+        preconditions: uniqueConditionRefs([
+          ...control.visibilityConditions.filter(
+            (conditionRef) =>
+              conditionById.get(conditionRef)?.data.pathRequirement ===
+              "runtime-availability",
+          ),
+          ...control.enabledConditions,
+        ]),
+        sourceFactRefs: uniqueSorted([
+          ...equivalentEffectRefs,
+          ...flowFactRefs,
+          ...equivalentNavigationRefs,
+        ]),
+      });
+    }
+    return id;
+  };
+  for (const binding of [...bindingFacts].sort((left, right) =>
+    left.id.localeCompare(right.id, "en"),
+  )) {
+    const controlRef = controlByUi.get(binding.data.elementKey);
+    if (!controlRef) continue;
+    const reachableCallbacks = callbackTraversal.resolve(
+      binding.id,
+      binding.data.callbackKey,
+    );
+    const reachableByCallback = new Map();
+    for (const callback of reachableCallbacks) {
+      const alternatives = reachableByCallback.get(callback.callbackKey) ?? [];
+      alternatives.push(callback);
+      reachableByCallback.set(callback.callbackKey, alternatives);
+    }
+    const callbackKeys = new Set(reachableByCallback.keys());
+    const flowFactRefs = uniqueSorted(
+      reachableCallbacks.flatMap((callback) => callback.flowFactRefs),
+    );
+    const actionId = graphId(
+      "action",
+      source.caseId,
+      binding.data.trigger,
+      binding.id,
+    );
+    actionByBinding.set(binding.id, actionId);
+    const owningControl = controls.find((control) => control.id === controlRef);
+    const controlEnabledConditions = owningControl?.enabledConditions ?? [];
+    const ownerArea = owningControl
+      ? areaById.get(owningControl.areaRef)
+      : undefined;
+    const activationScopedAreaKinds = new Set([
+      "bottom-sheet",
+      "dialog",
+      "drawer",
+      "overlay",
+      "pager-page",
+      "popup",
+    ]);
+    const areaActivationExpressions =
+      ownerArea && activationScopedAreaKinds.has(ownerArea.kind)
+        ? new Set(
+            ownerArea.conditions.flatMap((conditionRef) => {
+              const expression = conditionById
+                .get(conditionRef)
+                ?.data.expressionAnchor.trim();
+              return expression ? [expression] : [];
+            }),
+          )
+        : new Set();
+    const compatibleReachabilitiesByEffect = new Map();
+    const compatibleActionEffects = effectFacts.filter((effect) => {
+      if (!callbackKeys.has(effect.data.callbackKey)) return false;
+      const compatible = (
+        reachableByCallback.get(effect.data.callbackKey) ?? []
+      ).filter((reachable) =>
+        callbackTraversal.isCompatibleWithConditions(
+          reachable,
+          effect.data.conditionKeys ?? [],
+        ),
+      );
+      if (compatible.length === 0) return false;
+      compatibleReachabilitiesByEffect.set(effect.id, compatible);
+      return true;
+    });
+    const compatibleEffectById = new Map(
+      compatibleActionEffects.map((effect) => [effect.id, effect]),
+    );
+    const supersededImplementationEffects = new Set();
+    for (const summary of compatibleActionEffects) {
+      if (
+        summary.data.effectKind !== "navigate-area" ||
+        !hasResolvedAreaTarget(summary)
+      )
+        continue;
+      for (const relatedRef of summary.relatedFactRefs ?? []) {
+        const implementation = compatibleEffectById.get(relatedRef);
+        if (
+          implementation?.data.effectKind === "navigate-area" &&
+          !hasResolvedAreaTarget(implementation)
+        ) {
+          supersededImplementationEffects.add(implementation.id);
+        }
+      }
+    }
+    const actionEffects = compatibleActionEffects
+      .filter((effect) => !supersededImplementationEffects.has(effect.id))
+      .sort((left, right) => left.id.localeCompare(right.id, "en"));
+    const alternativesByEffect = new Map();
+    for (const effect of actionEffects) {
+      const reachabilities =
+        compatibleReachabilitiesByEffect.get(effect.id) ?? [];
+      const rawAlternatives = reachabilities.map((reachability) => {
+        const callbackPath = new Set(reachability.callbackPath);
+        const conditionRefs =
+          effect.data.conditionKeys !== undefined
+            ? uniqueConditionRefs([
+                ...reachability.conditionRefs,
+                ...effect.data.conditionKeys,
+              ]).filter((conditionRef) => {
+                const expression = conditionById
+                  .get(conditionRef)
+                  ?.data.expressionAnchor.trim();
+                return (
+                  !expression || !areaActivationExpressions.has(expression)
+                );
+              })
+            : uniqueConditionRefs([
+                ...conditionFacts
+                  .filter((condition) =>
+                    callbackPath.has(condition.data.ownerKey),
+                  )
+                  .map((condition) => condition.id),
+                ...reachability.conditionRefs,
+              ]).filter((conditionRef) => {
+                const expression = conditionById
+                  .get(conditionRef)
+                  ?.data.expressionAnchor.trim();
+                return (
+                  !expression || !areaActivationExpressions.has(expression)
+                );
+              });
+        return {
+          conditionRefs,
+          sourceFactRefs: reachability.flowFactRefs,
+        };
+      });
+      alternativesByEffect.set(
+        effect.id,
+        normalizeConditionAlternatives(rawAlternatives),
+      );
+    }
+    const action = {
+      id: actionId,
+      controlRef,
+      trigger: binding.data.trigger,
+      effectRefs: [],
+      /*
+       * Callback-path guards describe whether an individual downstream effect
+       * executes after the interaction. They are not prerequisites for the
+       * user being able to trigger the control. Keep those guards on effects
+       * (and navigation edges); Action preconditions are UI availability only.
+       */
+      preconditionRefs: uniqueConditionRefs(controlEnabledConditions),
+      sourceFactRefs: uniqueSorted([binding.id, ...flowFactRefs]),
+    };
+    const equivalentEffectGroups = new Map();
+    for (const effect of actionEffects) {
+      const semanticKey = exactTargetEffectSemanticKey(effect);
+      const groupKey =
+        semanticKey === undefined
+          ? `fact:${effect.id}`
+          : `exact-target:${semanticKey}`;
+      const group = equivalentEffectGroups.get(groupKey) ?? [];
+      group.push(effect);
+      equivalentEffectGroups.set(groupKey, group);
+    }
+    let effectRefs = [...equivalentEffectGroups.values()].map((group) => {
+      const representative = group[0];
+      return addEffectForAction(
+        action,
+        representative,
+        normalizeConditionAlternatives(
+          group.flatMap((effect) => alternativesByEffect.get(effect.id) ?? []),
+        ),
+        group,
+      );
+    });
+    let actionUnresolvedRef;
+    if (effectRefs.length === 0) {
+      const unknown = addUnknownEffectForAction(
+        action,
+        binding.id,
+        action.sourceFactRefs,
+        binding.support.map((item) => item.evidenceRef),
+        "控件已绑定回调，但沿回调调用链没有解析到对应效果。",
+      );
+      effectRefs = [unknown.effectId];
+      actionUnresolvedRef = unknown.unresolvedId;
+    }
+    actions.push({ ...action, effectRefs });
+    const controlIndex = controls.findIndex((item) => item.id === controlRef);
+    if (controlIndex >= 0) {
+      controls[controlIndex] = {
+        ...controls[controlIndex],
+        actionRefs: [...controls[controlIndex].actionRefs, actionId].sort(),
+        ...(actionUnresolvedRef
+          ? {
+              unresolvedRefs: uniqueSorted([
+                ...controls[controlIndex].unresolvedRefs,
+                actionUnresolvedRef,
+              ]),
+            }
+          : {}),
+      };
+    }
+  }
+  /*
+   * Editable text has one intrinsic user interaction even when source code
+   * only binds a separate submit/editor callback. This is an Android UI
+   * contract, not a guessed business effect: typing changes the field value.
+   */
+  for (const control of [...controls]) {
+    if (control.kind !== "text-input") continue;
+    const alreadyHasInput = control.actionRefs.some((actionRef) =>
+      actions.some(
+        (action) => action.id === actionRef && action.trigger === "text-input",
+      ),
+    );
+    if (alreadyHasInput) continue;
+    const uiFact = uiFacts.find(
+      (fact) => controlByUi.get(fact.id) === control.id,
+    );
+    if (!uiFact) continue;
+    const actionId = graphId(
+      "action",
+      source.caseId,
+      "text-input",
+      `${uiFact.id}:intrinsic-input`,
+    );
+    const effectId = graphId("effect", source.caseId, "input", actionId);
+    actions.push({
+      id: actionId,
+      controlRef: control.id,
+      trigger: "text-input",
+      effectRefs: [effectId],
+      preconditionRefs: [...control.enabledConditions],
+      sourceFactRefs: [uiFact.id],
+    });
+    effects.push({
+      id: effectId,
+      actionRef: actionId,
+      kind: "input",
+      description: resolved(
+        "接收并处理用户输入",
+        [uiFact.id],
+        uiFact.confidence,
+      ),
+      sourceFactRefs: [uiFact.id],
+      unresolvedRefs: [],
+    });
+    const index = controls.findIndex((item) => item.id === control.id);
+    controls[index] = {
+      ...controls[index],
+      actionRefs: uniqueSorted([...controls[index].actionRefs, actionId]),
+    };
+  }
+  for (const control of [...controls]) {
+    if (control.actionRefs.length > 0) continue;
+    const uiFact = uiFacts.find(
+      (fact) => controlByUi.get(fact.id) === control.id,
+    );
+    if (!uiFact) continue;
+    const actionId = graphId(
+      "action",
+      source.caseId,
+      inferredTrigger(uiFact.data),
+      `${uiFact.id}:unbound`,
+    );
+    const action = {
+      id: actionId,
+      controlRef: control.id,
+      trigger: inferredTrigger(uiFact.data),
+      effectRefs: [],
+      preconditionRefs: [...control.enabledConditions],
+      sourceFactRefs: [uiFact.id],
+    };
+    const unknown = addUnknownEffectForAction(
+      action,
+      uiFact.id,
+      action.sourceFactRefs,
+      uiFact.support.map((item) => item.evidenceRef),
+      "控件可操作，但在所选源码中没有解析到对应回调效果。",
+    );
+    actions.push({ ...action, effectRefs: [unknown.effectId] });
+    const index = controls.findIndex((item) => item.id === control.id);
+    controls[index] = {
+      ...controls[index],
+      actionRefs: [actionId],
+      unresolvedRefs: uniqueSorted([
+        ...controls[index].unresolvedRefs,
+        unknown.unresolvedId,
+      ]),
+    };
+  }
+  applyComponentVariants({
+    caseId: source.caseId,
+    variants: componentVariantFacts,
+    areaByComponent,
+    areasById: areaById,
+    controls,
+    actions,
+    effects,
+    edges,
+    unresolved,
+    bindings: bindingFacts,
+    conditions: conditionFacts,
+    id: graphId,
+  });
+  /*
+   * A user action that resolves back to its own Area is still a real control
+   * with a real effect, but it is not a transition between graph nodes. This
+   * commonly occurs when the selected Pager tab is clicked again. Remove the
+   * self-loop only after component variants have been expanded so the check
+   * uses final Area identities. Startup settling is derived independently
+   * from source effects below and therefore remains unaffected.
+   */
+  for (let index = edges.length - 1; index >= 0; index -= 1) {
+    const edge = edges[index];
+    if (
+      !("status" in edge.target) &&
+      edge.target.kind === "area" &&
+      edge.target.ref === edge.sourceAreaRef
+    ) {
+      edges.splice(index, 1);
+    }
+  }
+  /*
+   * A close/back API carries no literal destination. When the static graph
+   * proves one or more in-app predecessors, materialize the possible history
+   * transitions from that evidence. Use a snapshot of forward edges so a
+   * generated back edge can never become proof for another generated edge.
+   *
+   * An action can atomically close the current surface and show another one.
+   * That is a replacement transition: it must not also emit a return edge,
+   * and the new surface inherits the replaced surface's predecessors rather
+   * than treating the replaced surface as its back destination.
+   */
+  const forwardEdges = [...edges];
+  const actionById = new Map(actions.map((action) => [action.id, action]));
+  const effectById = new Map(effects.map((effect) => [effect.id, effect]));
+  const actionHasEffect = (action, kinds) =>
+    action.effectRefs.some((effectRef) => {
+      const effect = effectById.get(effectRef);
+      return effect !== undefined && kinds.has(effect.kind);
+    });
+  const closeKinds = new Set(["close-surface"]);
+  const transitionKinds = new Set([
+    "navigate-area",
+    "show-surface",
+    "open-external",
+  ]);
+  const historyProofsFor = (targetAreaRef, visiting = new Set()) => {
+    if (visiting.has(targetAreaRef)) return [];
+    const nextVisiting = new Set([...visiting, targetAreaRef]);
+    const proofs = [];
+    for (const edge of forwardEdges) {
+      if (
+        "status" in edge.target ||
+        edge.target.kind !== "area" ||
+        edge.target.ref !== targetAreaRef ||
+        edge.sourceAreaRef === targetAreaRef
+      )
+        continue;
+      const incomingAction = actionById.get(edge.actionRef);
+      if (incomingAction && actionHasEffect(incomingAction, closeKinds)) {
+        for (const inherited of historyProofsFor(
+          edge.sourceAreaRef,
+          nextVisiting,
+        )) {
+          proofs.push({
+            predecessorAreaRef: inherited.predecessorAreaRef,
+            edges: [...inherited.edges, edge],
+          });
+        }
+      } else {
+        proofs.push({
+          predecessorAreaRef: edge.sourceAreaRef,
+          edges: [edge],
+        });
+      }
+    }
+    const unique = new Map();
+    for (const proof of proofs) {
+      const key = [
+        proof.predecessorAreaRef,
+        ...proof.edges.map((edge) => edge.id),
+      ].join("\u0000");
+      unique.set(key, proof);
+    }
+    return [...unique.values()];
+  };
+  const closeEffectsByAction = new Map();
+  for (const closeEffect of effects.filter(
+    (effect) =>
+      effect.kind === "close-surface" && effect.closePolicy !== "host-exit",
+  )) {
+    const grouped = closeEffectsByAction.get(closeEffect.actionRef) ?? [];
+    grouped.push(closeEffect);
+    closeEffectsByAction.set(closeEffect.actionRef, grouped);
+  }
+  // One user event may reach several implementation callbacks that all close
+  // the same surface. They remain separate effect evidence, but history has
+  // only one transition for that Action and predecessor Area.
+  for (const [closeActionRef, closeEffects] of closeEffectsByAction) {
+    const action = actions.find((candidate) => candidate.id === closeActionRef);
+    const control = action
+      ? controls.find((candidate) => candidate.id === action.controlRef)
+      : undefined;
+    if (!action || !control) continue;
+    if (actionHasEffect(action, transitionKinds)) {
+      continue;
+    }
+    const proofByPredecessor = new Map();
+    for (const proof of historyProofsFor(control.areaRef)) {
+      const edgesForArea =
+        proofByPredecessor.get(proof.predecessorAreaRef) ?? [];
+      edgesForArea.push(...proof.edges);
+      proofByPredecessor.set(proof.predecessorAreaRef, edgesForArea);
+    }
+    for (const [predecessorAreaRef, proofs] of proofByPredecessor) {
+      edges.push({
+        id: graphId(
+          "edge",
+          source.caseId,
+          "history-back",
+          `${control.areaRef}:${action.id}:${predecessorAreaRef}`,
+        ),
+        sourceAreaRef: control.areaRef,
+        controlRef: control.id,
+        actionRef: action.id,
+        target: { kind: "area", ref: predecessorAreaRef },
+        conditions: uniqueConditionRefs(
+          proofs.flatMap((proof) => proof.conditions),
+        ),
+        preconditions: uniqueSorted(
+          proofs.flatMap((proof) => proof.preconditions),
+        ),
+        sourceFactRefs: uniqueSorted([
+          ...closeEffects.flatMap((effect) => effect.sourceFactRefs),
+          ...proofs.flatMap((proof) => proof.sourceFactRefs),
+        ]),
+      });
+    }
+  }
+  const entryPoints = [];
+  const startupPromotedAreaRefs = new Set();
+  const entryFactById = new Map(entryFacts.map((fact) => [fact.id, fact]));
+  const launcherFactsWithDerivedDefault = new Set(
+    entryFacts.flatMap((fact) =>
+      fact.data.startupRole === "default" && fact.data.parentEntryKey
+        ? [fact.data.parentEntryKey]
+        : [],
+    ),
+  );
+  const callbackById = new Map(
+    callbackFacts.map((callback) => [callback.id, callback]),
+  );
+  for (const fact of entryFacts) {
+    /*
+     * A finite startup resolver replaces its technical Activity/shell root
+     * with the proven visible default Area. Keeping both roots would make the
+     * shell compete with its own content and reintroduce arbitrary paths.
+     */
+    if (launcherFactsWithDerivedDefault.has(fact.id)) continue;
+    const root = areaByComponent.get(fact.data.componentKey);
+    if (!root || !areaById.has(root)) {
+      unresolved.push({
+        id: graphId("unresolved", source.caseId, "entry-root", fact.id),
+        ownerRef: fact.id,
+        fieldPath: "rootAreaRefs",
+        reasonCode: "INTRINSIC_ENTRY_ROOT_UNKNOWN",
+        message: "入口组件无法映射到可遍历 Area；该入口未参与路径计算。",
+        evidenceRefs: fact.support.map((item) => item.evidenceRef),
+        candidates: [],
+        impact: ["area-path"],
+        originRef: fact.id,
+      });
+      continue;
+    }
+    const rootArea = areaById.get(root);
+    const rootConditions = rootArea?.conditions ?? [];
+    if (fact.data.entryKind === "launcher" && fact.data.category === "normal") {
+      const startupCallbacks = callbackFacts.filter(
+        (callback) =>
+          callback.data.ownerKey === fact.data.componentKey &&
+          callback.data.callbackKind === "function" &&
+          /#onCreate\(/u.test(callback.data.callableSymbol),
+      );
+      const lifecyclePagerTransitions = effectFacts.flatMap((effect) => {
+        if (
+          effect.data.effectKind !== "navigate-area" ||
+          effect.data.transitionMode !== "startup-auto" ||
+          !effect.data.targetKey
+        )
+          return [];
+        const callback = callbackById.get(effect.data.callbackKey);
+        const callbackAreaRef = callback
+          ? areaByComponent.get(callback.data.ownerKey)
+          : undefined;
+        const targetAreaRef = areaByComponent.get(effect.data.targetKey);
+        if (
+          callbackAreaRef !== root ||
+          !targetAreaRef ||
+          targetAreaRef === root
+        )
+          return [];
+        const transitionConditions = uniqueConditionRefs(
+          effect.data.conditionKeys ?? [],
+        );
+        return [
+          {
+            effect,
+            targetAreaRef,
+            transitionConditions,
+            conditions: uniqueConditionRefs([
+              ...fact.data.conditionKeys,
+              ...transitionConditions,
+            ]),
+            flowFactRefs: [],
+          },
+        ];
+      });
+      const callbackStartupTransitions = startupCallbacks.flatMap(
+        (startupCallback) =>
+          callbackTraversal
+            .resolve(
+              `${fact.id}:startup:${startupCallback.id}`,
+              startupCallback.id,
+            )
+            .flatMap((reachability) =>
+              effectFacts
+                .filter(
+                  (effect) =>
+                    effect.data.effectKind === "navigate-area" &&
+                    effect.data.targetKey !== undefined &&
+                    effect.data.callbackKey === reachability.callbackKey,
+                )
+                .flatMap((effect) => {
+                  const targetAreaRef = effect.data.targetKey
+                    ? areaByComponent.get(effect.data.targetKey)
+                    : undefined;
+                  const transitionConditions = uniqueConditionRefs([
+                    ...reachability.conditionRefs,
+                    ...(effect.data.conditionKeys ?? []),
+                  ]);
+                  return targetAreaRef &&
+                    targetAreaRef !== root &&
+                    transitionConditions.length > 0
+                    ? [
+                        {
+                          effect,
+                          targetAreaRef,
+                          transitionConditions,
+                          conditions: uniqueConditionRefs([
+                            ...fact.data.conditionKeys,
+                            ...transitionConditions,
+                          ]),
+                          flowFactRefs: reachability.flowFactRefs,
+                        },
+                      ]
+                    : [];
+                }),
+            ),
+      );
+      const startupTransitions = [
+        ...lifecyclePagerTransitions,
+        ...callbackStartupTransitions,
+      ];
+      const seenTransitions = new Set();
+      for (const transition of startupTransitions) {
+        const conditions = transition.conditions;
+        const transitionKey = `${transition.targetAreaRef}\u0000${conditions.join("|")}`;
+        if (seenTransitions.has(transitionKey)) continue;
+        seenTransitions.add(transitionKey);
+        const targetArea = areaById.get(transition.targetAreaRef);
+        if (targetArea) {
+          startupPromotedAreaRefs.add(transition.targetAreaRef);
+          areaById.set(transition.targetAreaRef, {
+            ...targetArea,
+            conditions: uniqueConditionRefs([
+              ...targetArea.conditions,
+              ...conditions,
+            ]),
+            sourceFactRefs: uniqueSorted([
+              ...targetArea.sourceFactRefs,
+              transition.effect.id,
+              ...transition.flowFactRefs,
+              ...conditions,
+            ]),
+          });
+        }
+        entryPoints.push({
+          id: graphId(
+            "entry",
+            source.caseId,
+            fact.data.entryKind,
+            `${fact.id}:${transitionKey}`,
+          ),
+          kind: fact.data.entryKind,
+          category: fact.data.category,
+          rootAreaRefs: [transition.targetAreaRef],
+          conditions,
+          preconditions: conditions,
+          startupRole: "conditional",
+          launcherAreaRef: root,
+          sourceFactRefs: uniqueSorted([
+            fact.id,
+            transition.effect.id,
+            ...transition.flowFactRefs,
+            ...conditions,
+          ]),
+        });
+      }
+      const deterministicStartupTarget = (() => {
+        const unique = [
+          ...new Map(
+            startupTransitions.map((transition) => [
+              [
+                transition.targetAreaRef,
+                ...transition.transitionConditions,
+              ].join("\u0000"),
+              transition,
+            ]),
+          ).values(),
+        ];
+        return unique.length === 1 &&
+          unique[0].transitionConditions.length === 0
+          ? unique[0].targetAreaRef
+          : undefined;
+      })();
+      if (deterministicStartupTarget) {
+        continue;
+      }
+    }
+    const parentEntry = fact.data.parentEntryKey
+      ? entryFactById.get(fact.data.parentEntryKey)
+      : undefined;
+    const parentRoot = parentEntry
+      ? areaByComponent.get(parentEntry.data.componentKey)
+      : undefined;
+    const launcherAreaRef = parentRoot ?? root;
+    entryPoints.push({
+      id: graphId("entry", source.caseId, fact.data.entryKind, fact.id),
+      kind: fact.data.entryKind,
+      category: fact.data.category,
+      rootAreaRefs: uniqueSorted([
+        root,
+        ...(fact.data.parentEntryKey && launcherAreaRef !== root
+          ? [launcherAreaRef]
+          : []),
+      ]),
+      conditions: uniqueConditionRefs([
+        ...fact.data.conditionKeys,
+        ...rootConditions.filter(
+          (conditionRef) =>
+            conditionById.get(conditionRef)?.data.ownerKey ===
+            fact.data.componentKey,
+        ),
+      ]),
+      preconditions: uniqueConditionRefs(
+        fact.data.preconditionKeys ?? fact.data.conditionKeys,
+      ),
+      startupRole:
+        fact.data.startupRole ??
+        (fact.data.entryKind === "launcher" &&
+        fact.data.category === "normal" &&
+        fact.data.conditionKeys.length === 0
+          ? "default"
+          : "conditional"),
+      launcherAreaRef,
+      sourceFactRefs: uniqueSorted([
+        fact.id,
+        ...fact.data.conditionKeys,
+        ...(fact.data.preconditionKeys ?? []),
+        ...(fact.data.parentEntryKey ? [fact.data.parentEntryKey] : []),
+        ...rootConditions.filter(
+          (conditionRef) =>
+            conditionById.get(conditionRef)?.data.ownerKey ===
+            fact.data.componentKey,
+        ),
+      ]),
+    });
+  }
+  /*
+   * Startup branch analysis can promote a redirect target to a conditioned
+   * launcher root after controls and forward edges have already been built.
+   * Re-apply the final source-Area conditions to outgoing edges so paths and
+   * REQ descriptions do not lose that proven entry predicate.
+   */
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = edges[index];
+    if (!startupPromotedAreaRefs.has(edge.sourceAreaRef)) continue;
+    const updated = {
+      ...edge,
+      conditions: uniqueConditionRefs([
+        ...(areaById.get(edge.sourceAreaRef)?.conditions ?? []),
+        ...edge.conditions,
+      ]),
+    };
+    edges[index] = updated;
+    const forwardIndex = forwardEdges.findIndex(
+      (candidate) => candidate.id === edge.id,
+    );
+    if (forwardIndex >= 0) forwardEdges[forwardIndex] = updated;
+  }
+  /*
+   * A title-less popup is perceived in the context of the control that opens
+   * it. Derive that contextual product label only after the show edge is
+   * proven. Generic overflow/menu openers use the host Area name (for example
+   * "Playlist menu"); a semantic opener such as "Choose language" names its
+   * own menu. No framework class name or application-specific vocabulary is
+   * involved.
+   */
+  for (const area of areaById.values()) {
+    if (area.kind !== "popup" || area.name.status !== "unresolved") continue;
+    const incoming = edges.filter((edge) => {
+      if (
+        "status" in edge.target ||
+        edge.target.kind !== "area" ||
+        edge.target.ref !== area.id
+      )
+        return false;
+      const action = actionById.get(edge.actionRef);
+      return (
+        action?.effectRefs.some(
+          (effectRef) => effectById.get(effectRef)?.kind === "show-surface",
+        ) === true
+      );
+    });
+    const sourceAreaRefs = [
+      ...new Set(incoming.map((edge) => edge.sourceAreaRef)),
+    ];
+    if (incoming.length === 0 || sourceAreaRefs.length !== 1) continue;
+    const sourceArea = areaById.get(sourceAreaRefs[0]);
+    const openerNames = [
+      ...new Set(
+        incoming.flatMap((edge) => {
+          const control = controls.find(
+            (candidate) => candidate.id === edge.controlRef,
+          );
+          return control?.name.status === "resolved"
+            ? [control.name.value]
+            : [];
+        }),
+      ),
+    ];
+    const openerName = openerNames.length === 1 ? openerNames[0] : undefined;
+    const hostName =
+      sourceArea?.name.status === "resolved"
+        ? sourceArea.name.value
+        : undefined;
+    const baseName =
+      openerName && !genericMenuOpenerName(openerName)
+        ? openerName
+        : (hostName ?? openerName);
+    if (!baseName) continue;
+    const supportRefs = uniqueSorted([
+      ...incoming.flatMap((edge) => edge.sourceFactRefs),
+      ...incoming.flatMap((edge) => {
+        const control = controls.find(
+          (candidate) => candidate.id === edge.controlRef,
+        );
+        return control?.name.status === "resolved"
+          ? control.name.supportRefs
+          : [];
+      }),
+      ...(sourceArea?.name.status === "resolved"
+        ? sourceArea.name.supportRefs
+        : []),
+    ]);
+    const oldUnresolvedRef = area.name.unresolvedRef;
+    const unresolvedIndex = unresolved.findIndex(
+      (candidate) => candidate.id === oldUnresolvedRef,
+    );
+    if (unresolvedIndex >= 0) unresolved.splice(unresolvedIndex, 1);
+    areaById.set(area.id, {
+      ...area,
+      name: resolved(contextualMenuName(baseName), supportRefs, "medium"),
+      unresolvedRefs: area.unresolvedRefs.filter(
+        (ref) => ref !== oldUnresolvedRef,
+      ),
+    });
+  }
+  const controlById = new Map(controls.map((control) => [control.id, control]));
+  const pathEdges = forwardEdges.filter((edge) => {
+    const enabled = controlById.get(edge.controlRef)?.enabled;
+    return enabled?.status !== "resolved" || enabled.value !== false;
+  });
+  const pathDrafts = computePaths(
+    {
+      areas: [...areaById.values()],
+      edges: pathEdges,
+      entryPoints,
+    },
+    {
+      maxGraphStates: options.maxGraphStates,
+      conditionExpressions: new Map(
+        conditionFacts.map((condition) => [
+          condition.id,
+          condition.data.expressionAnchor,
+        ]),
+      ),
+    },
+  );
+  const paths = pathDrafts.map((path) => ({
+    ...path,
+    id: graphId(
+      "path",
+      source.caseId,
+      path.kind,
+      [
+        path.targetAreaRef,
+        path.rootEntryRef ?? "none",
+        ...path.steps.map((step) => step.edgeRef),
+      ].join("|"),
+    ),
+    selectionReasons:
+      path.kind === "canonical"
+        ? ["shortest normal-launcher path"]
+        : path.kind === "equivalent"
+          ? ["equal-cost normal-launcher path"]
+          : path.kind === "alternate"
+            ? ["alternate entry path"]
+            : ["not reachable from a normal launcher"],
+    unresolvedRefs: [],
+  }));
+  const canonicalByArea = new Map(
+    paths
+      .filter(
+        (path) => path.kind === "canonical" || path.kind === "unreachable",
+      )
+      .map((path) => [path.targetAreaRef, path.id]),
+  );
+  const areas = sorted(
+    [...areaById.values()].map((area) => ({
+      ...area,
+      ...(canonicalByArea.has(area.id)
+        ? { canonicalPathRef: canonicalByArea.get(area.id) }
+        : {}),
+    })),
+  );
+  const graph = {
+    schemaVersion: "1.0.0",
+    artifactKind: "area-graph",
+    caseId: source.caseId,
+    analysisContext: source.analysisContext,
+    areas,
+    controls: sorted(controls),
+    actions: sorted(actions),
+    effects: sorted(effects),
+    edges: sorted(edges),
+    externalEndpoints: sorted(externalEndpoints),
+    entryPoints: sorted(entryPoints),
+    paths: sorted(paths),
+    excludedAreaCandidates: ownership.exclusions.map((exclusion) => ({
+      ...exclusion,
+      sourceFactRefs: [exclusion.componentRef],
+    })),
+    unresolved: sorted([
+      ...new Map(unresolved.map((item) => [item.id, item])).values(),
+    ]),
+  };
+  const validation = validateAreaGraph(graph);
+  if (!validation.ok) {
+    throw new Error(
+      `Area graph invariants failed: ${validation.issues.map((item) => `${item.code}@${item.path}: ${item.message}`).join(", ")}`,
+    );
+  }
+  return graph;
+}