android2harmony 0.1.6 → 0.1.8

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

@@ -0,0 +1,1066 @@
+import { createStableId } from "../../core/stable-id.js";
+import { componentIdentifierName } from "../names/policy.js";
+function graphId(namespace, caseId, entityKind, identity) {
+  return createStableId({
+    namespace,
+    caseId,
+    entityKind,
+    identity: [{ kind: "semantic-key", value: identity }],
+  });
+}
+function display(value, fallback) {
+  return value.status === "resolved" ? value.value : fallback;
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function resolved(value, supportRefs, confidence = "high") {
+  return {
+    status: "resolved",
+    value,
+    confidence,
+    supportRefs: uniqueSorted(supportRefs),
+  };
+}
+function targetKey(target) {
+  return "status" in target
+    ? `unresolved:${target.unresolvedRef}`
+    : `${target.kind}:${target.ref}`;
+}
+function targetBranchConditions(action, branchKey, branchEdges, graph, source) {
+  const rawAlternatives = branchEdges.flatMap((edge) =>
+    edge.conditionAlternatives && edge.conditionAlternatives.length > 0
+      ? edge.conditionAlternatives
+      : [
+          {
+            conditionRefs: edge.conditions,
+            sourceFactRefs: edge.sourceFactRefs,
+          },
+        ],
+  );
+  const alternativesByConditions = new Map();
+  for (const alternative of rawAlternatives) {
+    const conditionRefs = uniqueSorted(alternative.conditionRefs);
+    const key = conditionRefs.join("\u0000");
+    const existing = alternativesByConditions.get(key);
+    alternativesByConditions.set(key, {
+      conditionRefs,
+      sourceFactRefs: uniqueSorted([
+        ...(existing?.sourceFactRefs ?? []),
+        ...alternative.sourceFactRefs,
+      ]),
+    });
+  }
+  const conditionAlternatives = [...alternativesByConditions.values()]
+    .sort((left, right) =>
+      left.conditionRefs
+        .join("\u0000")
+        .localeCompare(right.conditionRefs.join("\u0000"), "en"),
+    )
+    .map((alternative, alternativeIndex) => {
+      const conditions = alternative.conditionRefs.map((conditionRef) =>
+        textItem(
+          graph.caseId,
+          "target-branch-condition",
+          `${action.id}:${branchKey}:${alternativeIndex}:${conditionRef}`,
+          conditionText(conditionRef, source),
+          [conditionRef],
+        ),
+      );
+      return {
+        conditions,
+        supportRefs: uniqueSorted([
+          ...alternative.sourceFactRefs,
+          ...conditions.flatMap((condition) => condition.supportRefs),
+        ]),
+      };
+    });
+  const conditionsByText = new Map();
+  for (const alternative of conditionAlternatives) {
+    for (const condition of alternative.conditions) {
+      const existing = conditionsByText.get(condition.text);
+      conditionsByText.set(
+        condition.text,
+        existing
+          ? {
+              ...existing,
+              supportRefs: uniqueSorted([
+                ...existing.supportRefs,
+                ...condition.supportRefs,
+              ]),
+            }
+          : condition,
+      );
+    }
+  }
+  return {
+    conditions: [...conditionsByText.values()].sort((left, right) =>
+      left.id.localeCompare(right.id, "en"),
+    ),
+    conditionAlternatives,
+    supportRefs: uniqueSorted(
+      branchEdges.flatMap((edge) => edge.sourceFactRefs),
+    ),
+  };
+}
+function resolvedReqTarget(action, target, supportRefs, graph) {
+  if (target.kind === "area") {
+    const area = graph.areas.find((item) => item.id === target.ref);
+    if (!area) {
+      throw new Error(
+        `Req-model target invariant for Action ${action.id}: ` +
+          `missing target Area ${target.ref}.`,
+      );
+    }
+    return {
+      kind: "area",
+      ref: area.id,
+      displayName: area.name,
+      supportRefs: uniqueSorted(supportRefs),
+    };
+  }
+  const endpoint = graph.externalEndpoints.find(
+    (item) => item.id === target.ref,
+  );
+  if (!endpoint) {
+    throw new Error(
+      `Req-model target invariant for Action ${action.id}: ` +
+        `missing external endpoint ${target.ref}.`,
+    );
+  }
+  return {
+    kind: "external",
+    ref: endpoint.id,
+    displayName: endpoint.name,
+    ...(endpoint.presentation ? { presentation: endpoint.presentation } : {}),
+    ...(endpoint.intentAction ? { intentAction: endpoint.intentAction } : {}),
+    ...(endpoint.mimeType ? { mimeType: endpoint.mimeType } : {}),
+    ...(endpoint.uri ? { uri: endpoint.uri } : {}),
+    supportRefs: uniqueSorted(supportRefs),
+  };
+}
+function textItem(caseId, kind, identity, text, supportRefs) {
+  return {
+    id: graphId("text", caseId, kind, identity),
+    text,
+    supportRefs: [...new Set(supportRefs)].sort(),
+  };
+}
+function conditionText(ref, source) {
+  const fact = source.facts.find(
+    (item) => item.id === ref && item.kind === "condition",
+  );
+  return fact?.kind === "condition"
+    ? fact.data.plainLanguage
+    : `满足条件 ${ref}`;
+}
+function canonicalPath(area, graph) {
+  const path = area.canonicalPathRef
+    ? graph.paths.find((item) => item.id === area.canonicalPathRef)
+    : undefined;
+  if (!path) {
+    const unresolvedRef = area.unresolvedRefs[0];
+    if (unresolvedRef) {
+      return { status: "unresolved", unresolvedRef };
+    }
+    throw new Error(`Area ${area.id} has no canonical path`);
+  }
+  if (path.kind === "unreachable") {
+    return {
+      status: "unreachable",
+      reachability: "unreachable",
+      pathRef: path.id,
+      alternatePathRefs: graph.paths
+        .filter(
+          (item) => item.kind === "alternate" && item.targetAreaRef === area.id,
+        )
+        .map((item) => item.id)
+        .sort(),
+    };
+  }
+  const entry = path.rootEntryRef
+    ? graph.entryPoints.find((item) => item.id === path.rootEntryRef)
+    : undefined;
+  const rootRef =
+    path.steps[0]?.sourceAreaRef ??
+    (entry?.rootAreaRefs.includes(area.id) === true ? area.id : undefined) ??
+    entry?.rootAreaRefs[0] ??
+    area.id;
+  const root = graph.areas.find((item) => item.id === rootRef);
+  const segments = [
+    {
+      areaRef: rootRef,
+      areaName: root ? display(root.name, "Area 名称待确认") : rootRef,
+    },
+  ];
+  for (const step of path.steps) {
+    const action = graph.actions.find((item) => item.id === step.actionRef);
+    const control = graph.controls.find((item) => item.id === step.controlRef);
+    const target = graph.areas.find((item) => item.id === step.targetAreaRef);
+    const sourceSegment = segments[segments.length - 1];
+    if (!sourceSegment || sourceSegment.areaRef !== step.sourceAreaRef) {
+      throw new Error(
+        `Canonical path ${path.id} is discontinuous at ${step.edgeRef}`,
+      );
+    }
+    segments[segments.length - 1] = {
+      ...sourceSegment,
+      ...(action ? { action: action.trigger } : {}),
+      ...(control
+        ? { controlName: display(control.name, "控件名称待确认") }
+        : {}),
+      ...(target
+        ? { targetAreaName: display(target.name, "Area 名称待确认") }
+        : {}),
+    };
+    segments.push({
+      areaRef: step.targetAreaRef,
+      areaName: target
+        ? display(target.name, "Area 名称待确认")
+        : step.targetAreaRef,
+    });
+  }
+  return {
+    status: "resolved",
+    reachability:
+      path.reachability === "conditional" ? "conditional" : "unconditional",
+    pathRef: path.id,
+    segments,
+  };
+}
+function targetFor(action, control, actionEffects, graph, source) {
+  const actionEdges = graph.edges
+    .filter((item) => item.actionRef === action.id)
+    .sort((left, right) => left.id.localeCompare(right.id, "en"));
+  const closeEffects = actionEffects.filter(
+    (effect) => effect.kind === "close-surface",
+  );
+  const returnsToHistory =
+    (action.trigger === "back" &&
+      !closeEffects.some((effect) => effect.closePolicy === "host-exit")) ||
+    closeEffects.some(
+      (effect) =>
+        effect.kind === "close-surface" && effect.closePolicy !== "host-exit",
+    );
+  const hasExplicitTransition = actionEffects.some(
+    (effect) =>
+      effect.kind === "navigate-area" ||
+      effect.kind === "show-surface" ||
+      effect.kind === "open-external",
+  );
+  const historyTargets = actionEdges.flatMap((edge) =>
+    !("status" in edge.target) && edge.target.kind === "area"
+      ? [edge.target.ref]
+      : [],
+  );
+  if (
+    returnsToHistory &&
+    !hasExplicitTransition &&
+    actionEdges.length > 0 &&
+    historyTargets.length === actionEdges.length
+  ) {
+    const supportRefs = uniqueSorted([
+      ...actionEdges.flatMap((edge) => edge.sourceFactRefs),
+      ...action.sourceFactRefs,
+      ...actionEffects
+        .filter((effect) => effect.kind === "close-surface")
+        .flatMap((effect) => effect.sourceFactRefs),
+    ]);
+    return {
+      kind: "history-back",
+      refs: uniqueSorted(historyTargets),
+      displayName: resolved("返回进入当前区域前的区域", supportRefs, "medium"),
+      supportRefs,
+    };
+  }
+  if (actionEdges.length === 0) {
+    if (!returnsToHistory) return undefined;
+    /*
+     * A close API alone does not prove an in-app history destination:
+     * dismissing an externally opened dialog or finishing the root Activity
+     * may leave the app. Resolved incoming Area edges are the proof that the
+     * current Area was entered from an in-app predecessor.
+     */
+    const incoming = graph.edges
+      .filter(
+        (edge) =>
+          !("status" in edge.target) &&
+          edge.target.kind === "area" &&
+          edge.target.ref === control.areaRef &&
+          edge.sourceAreaRef !== control.areaRef,
+      )
+      .sort((left, right) => left.id.localeCompare(right.id, "en"));
+    const refs = uniqueSorted(incoming.map((edge) => edge.sourceAreaRef));
+    if (refs.length === 0) return undefined;
+    const supportRefs = uniqueSorted([
+      ...incoming.flatMap((edge) => edge.sourceFactRefs),
+      ...action.sourceFactRefs,
+      ...actionEffects
+        .filter((effect) => effect.kind === "close-surface")
+        .flatMap((effect) => effect.sourceFactRefs),
+    ]);
+    return {
+      kind: "history-back",
+      refs,
+      displayName: resolved("返回进入当前区域前的区域", supportRefs, "medium"),
+      supportRefs,
+    };
+  }
+  const unresolvedEdges = actionEdges.filter((edge) => "status" in edge.target);
+  if (unresolvedEdges.length > 0) {
+    const refs = uniqueSorted(
+      unresolvedEdges.map((edge) => {
+        if (!("status" in edge.target)) {
+          throw new Error("Expected an unresolved edge target");
+        }
+        return edge.target.unresolvedRef;
+      }),
+    );
+    if (unresolvedEdges.length === actionEdges.length && refs.length === 1) {
+      return { status: "unresolved", unresolvedRef: refs[0] };
+    }
+  }
+  const resolvedEdges = actionEdges.flatMap((edge) =>
+    "status" in edge.target ? [] : [{ edge, target: edge.target }],
+  );
+  const targets = new Map();
+  for (const { target } of resolvedEdges) {
+    targets.set(`${target.kind}:${target.ref}`, target);
+  }
+  const uniqueTargets = [...targets.values()].sort(
+    (left, right) =>
+      left.kind.localeCompare(right.kind, "en") ||
+      left.ref.localeCompare(right.ref, "en"),
+  );
+  const targetKinds = new Set(uniqueTargets.map((target) => target.kind));
+  const supportRefs = uniqueSorted(
+    actionEdges.flatMap((edge) => edge.sourceFactRefs),
+  );
+  if (unresolvedEdges.length === 0 && uniqueTargets.length === 1) {
+    const target = uniqueTargets[0];
+    return resolvedReqTarget(action, target, supportRefs, graph);
+  }
+  if (
+    unresolvedEdges.length === 0 &&
+    targetKinds.size === 1 &&
+    uniqueTargets[0]?.kind === "area"
+  ) {
+    const refs = uniqueTargets.map((target) => target.ref);
+    const branches = refs.map((ref) => {
+      const branchEdges = resolvedEdges.filter(
+        ({ target }) => target.kind === "area" && target.ref === ref,
+      );
+      return {
+        ref,
+        ...targetBranchConditions(
+          action,
+          `area:${ref}`,
+          branchEdges.map(({ edge }) => edge),
+          graph,
+          source,
+        ),
+      };
+    });
+    return {
+      kind: "conditional-area-set",
+      refs,
+      branches,
+      displayName: resolved("根据条件进入不同区域", supportRefs),
+      supportRefs,
+    };
+  }
+  const edgesByTarget = new Map();
+  for (const edge of actionEdges) {
+    const key = targetKey(edge.target);
+    const grouped = edgesByTarget.get(key) ?? [];
+    grouped.push(edge);
+    edgesByTarget.set(key, grouped);
+  }
+  const branches = [...edgesByTarget.entries()]
+    .sort(([left], [right]) => left.localeCompare(right, "en"))
+    .map(([key, branchEdges]) => {
+      const edgeTarget = branchEdges[0]?.target;
+      if (!edgeTarget) {
+        throw new Error(
+          `Req-model target invariant for Action ${action.id}: ` +
+            `target branch ${key} has no Edge.`,
+        );
+      }
+      const branchSupportRefs = uniqueSorted(
+        branchEdges.flatMap((edge) => edge.sourceFactRefs),
+      );
+      const target =
+        "status" in edgeTarget
+          ? {
+              status: "unresolved",
+              unresolvedRef: edgeTarget.unresolvedRef,
+            }
+          : resolvedReqTarget(action, edgeTarget, branchSupportRefs, graph);
+      return {
+        target,
+        ...targetBranchConditions(action, key, branchEdges, graph, source),
+      };
+    });
+  return {
+    kind: "alternative-target-set",
+    branches,
+    displayName: resolved("根据条件进入不同目标", supportRefs),
+    supportRefs,
+  };
+}
+function normalizedPropertyName(property) {
+  const leaf = property.trim().split(/[.:/]/u).at(-1) ?? property;
+  return leaf.replace(/[^a-z0-9]/giu, "").toLowerCase();
+}
+function jsonKey(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(jsonKey).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value)
+      .sort(([left], [right]) => left.localeCompare(right, "en"))
+      .map(([key, child]) => `${JSON.stringify(key)}:${jsonKey(child)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function weakestConfidence(facts) {
+  const rank = { high: 2, medium: 1, low: 0 };
+  return facts.reduce(
+    (weakest, fact) =>
+      rank[fact.confidence] < rank[weakest] ? fact.confidence : weakest,
+    "high",
+  );
+}
+function propertiesFor(control, source) {
+  const uiElementRefs = new Set(
+    control.sourceFactRefs.filter((ref) =>
+      source.facts.some(
+        (fact) => fact.id === ref && fact.kind === "ui-element",
+      ),
+    ),
+  );
+  if (uiElementRefs.size === 0) {
+    return { options: [], supportRefs: [] };
+  }
+  const properties = source.facts
+    .filter(
+      (fact) =>
+        fact.kind === "ui-property" && uiElementRefs.has(fact.data.ownerKey),
+    )
+    .sort((left, right) => left.id.localeCompare(right.id, "en"));
+  const enabledFacts = properties.filter(
+    (fact) =>
+      normalizedPropertyName(fact.data.property) === "enabled" &&
+      typeof fact.data.value === "boolean",
+  );
+  let enabled = control.enabled;
+  if (enabledFacts.length > 0) {
+    const values = new Set(enabledFacts.map((fact) => fact.data.value));
+    if (values.size > 1) {
+      throw new Error(
+        `Req-model property invariant for Control ${control.id}: ` +
+          "static enabled properties disagree.",
+      );
+    }
+    const sourceEnabled = resolved(
+      enabledFacts[0].data.value,
+      enabledFacts.map((fact) => fact.id),
+      weakestConfidence(enabledFacts),
+    );
+    if (
+      enabled?.status === "resolved" &&
+      sourceEnabled.status === "resolved" &&
+      enabled.value !== sourceEnabled.value
+    ) {
+      throw new Error(
+        `Req-model property invariant for Control ${control.id}: ` +
+          "Area Graph and Source Facts enabled values disagree.",
+      );
+    }
+    enabled ??= sourceEnabled;
+  }
+  const defaultPriority = new Map([
+    ["defaultvalue", 0],
+    ["default", 0],
+    ["value", 1],
+    ["checked", 2],
+  ]);
+  const defaultCandidates = properties
+    .map((fact) => ({
+      fact,
+      priority: defaultPriority.get(normalizedPropertyName(fact.data.property)),
+    }))
+    .filter((candidate) => candidate.priority !== undefined);
+  const bestPriority = defaultCandidates.reduce(
+    (best, candidate) => Math.min(best, candidate.priority),
+    Number.POSITIVE_INFINITY,
+  );
+  const selectedDefaults = defaultCandidates
+    .filter((candidate) => candidate.priority === bestPriority)
+    .map((candidate) => candidate.fact);
+  let defaultValue;
+  if (selectedDefaults.length > 0) {
+    const values = new Map(
+      selectedDefaults.map((fact) => [
+        jsonKey(fact.data.value),
+        fact.data.value,
+      ]),
+    );
+    if (values.size > 1) {
+      throw new Error(
+        `Req-model property invariant for Control ${control.id}: ` +
+          "equally preferred default properties disagree.",
+      );
+    }
+    defaultValue = resolved(
+      values.values().next().value,
+      selectedDefaults.map((fact) => fact.id),
+      weakestConfidence(selectedDefaults),
+    );
+  }
+  const optionFacts = properties.filter(
+    (fact) =>
+      /^(options|choices|items)$/u.test(
+        normalizedPropertyName(fact.data.property),
+      ) &&
+      Array.isArray(fact.data.value) &&
+      fact.data.value.every(
+        (value) =>
+          typeof value === "string" ||
+          typeof value === "number" ||
+          typeof value === "boolean",
+      ),
+  );
+  const optionSupportByValue = new Map();
+  for (const fact of optionFacts) {
+    if (!Array.isArray(fact.data.value)) continue;
+    for (const item of fact.data.value) {
+      if (
+        typeof item !== "string" &&
+        typeof item !== "number" &&
+        typeof item !== "boolean"
+      )
+        continue;
+      const value = String(item);
+      if (value.trim().length === 0) continue;
+      optionSupportByValue.set(
+        value,
+        uniqueSorted([...(optionSupportByValue.get(value) ?? []), fact.id]),
+      );
+    }
+  }
+  const options = [...optionSupportByValue].map(([value, supportRefs]) => ({
+    value,
+    supportRefs,
+  }));
+  const supportRefs = uniqueSorted([
+    ...(enabled?.status === "resolved" ? enabled.supportRefs : []),
+    ...selectedDefaults.map((fact) => fact.id),
+    ...optionFacts.flatMap((fact) =>
+      Array.isArray(fact.data.value) &&
+      fact.data.value.some(
+        (value) =>
+          (typeof value === "string" && value.trim().length > 0) ||
+          typeof value === "number" ||
+          typeof value === "boolean",
+      )
+        ? [fact.id]
+        : [],
+    ),
+  ]);
+  return {
+    ...(enabled ? { enabled } : {}),
+    ...(defaultValue ? { defaultValue } : {}),
+    options,
+    supportRefs,
+  };
+}
+function supportedUnresolvedRefs(value) {
+  return value?.status === "unresolved" ? [value.unresolvedRef] : [];
+}
+function supportedSupportRefs(value) {
+  return value?.status === "resolved" ? [...value.supportRefs] : [];
+}
+function unresolvedRefsForReqTarget(target) {
+  if ("status" in target) return [target.unresolvedRef];
+  return uniqueSorted([
+    ...supportedUnresolvedRefs(target.displayName),
+    ...(target.kind === "external"
+      ? [
+          ...supportedUnresolvedRefs(target.intentAction),
+          ...supportedUnresolvedRefs(target.mimeType),
+          ...supportedUnresolvedRefs(target.uri),
+        ]
+      : []),
+    ...(target.kind === "alternative-target-set"
+      ? target.branches.flatMap((branch) =>
+          unresolvedRefsForReqTarget(branch.target),
+        )
+      : []),
+  ]);
+}
+function supportRefsForReqTarget(target) {
+  if ("status" in target) return [];
+  return uniqueSorted([
+    ...target.supportRefs,
+    ...supportedSupportRefs(target.displayName),
+    ...(target.kind === "external"
+      ? [
+          ...supportedSupportRefs(target.intentAction),
+          ...supportedSupportRefs(target.mimeType),
+          ...supportedSupportRefs(target.uri),
+        ]
+      : []),
+    ...(target.kind === "conditional-area-set"
+      ? (target.branches ?? []).flatMap((branch) => [
+          ...branch.supportRefs,
+          ...branch.conditions.flatMap((condition) => condition.supportRefs),
+          ...branch.conditionAlternatives.flatMap(
+            (alternative) => alternative.supportRefs,
+          ),
+        ])
+      : []),
+    ...(target.kind === "alternative-target-set"
+      ? target.branches.flatMap((branch) => [
+          ...branch.supportRefs,
+          ...branch.conditions.flatMap((condition) => condition.supportRefs),
+          ...branch.conditionAlternatives.flatMap(
+            (alternative) => alternative.supportRefs,
+          ),
+          ...supportRefsForReqTarget(branch.target),
+        ])
+      : []),
+  ]);
+}
+function interactionFor(control, actionId, graph, source) {
+  const action = graph.actions.find((item) => item.id === actionId);
+  if (!action) throw new Error(`Missing action ${actionId}`);
+  const actionEffects = action.effectRefs.map((effectRef) => {
+    const effect = graph.effects.find((item) => item.id === effectRef);
+    if (!effect) throw new Error(`Missing effect ${effectRef}`);
+    return effect;
+  });
+  const actionEdges = graph.edges.filter(
+    (edge) => edge.actionRef === action.id,
+  );
+  const distinctResolvedTargets = new Set(
+    actionEdges.flatMap((edge) =>
+      "status" in edge.target ? [] : [`${edge.target.kind}:${edge.target.ref}`],
+    ),
+  );
+  const conditionRefs = uniqueSorted([
+    ...action.preconditionRefs,
+    ...actionEdges.flatMap((edge) => edge.preconditions),
+  ]);
+  const baseConditions = conditionRefs.map((conditionRef) =>
+    textItem(
+      graph.caseId,
+      "feature-condition",
+      `${action.id}:${conditionRef}`,
+      conditionText(conditionRef, source),
+      [conditionRef],
+    ),
+  );
+  const alternativeConditions = action.preconditionAlternatives ?? [];
+  const disjunctiveCondition =
+    alternativeConditions.length > 1 &&
+    alternativeConditions.every(
+      (alternative) => alternative.conditionRefs.length > 0,
+    )
+      ? [
+          textItem(
+            graph.caseId,
+            "feature-condition-alternatives",
+            action.id,
+            `满足以下任一条件组合：${alternativeConditions
+              .map((alternative) =>
+                alternative.conditionRefs
+                  .map((conditionRef) => conditionText(conditionRef, source))
+                  .join(" 且 "),
+              )
+              .join("；")}`,
+            uniqueSorted(
+              alternativeConditions.flatMap((alternative) => [
+                ...alternative.conditionRefs,
+                ...alternative.sourceFactRefs,
+              ]),
+            ),
+          ),
+        ]
+      : [];
+  const branchConditions =
+    distinctResolvedTargets.size > 1
+      ? actionEdges.flatMap((edge) => {
+          if ("status" in edge.target || edge.target.kind !== "area") {
+            return [];
+          }
+          const targetRef = edge.target.ref;
+          const targetArea = graph.areas.find((area) => area.id === targetRef);
+          const targetName = targetArea
+            ? display(targetArea.name, targetRef)
+            : targetRef;
+          return edge.conditions.map((conditionRef) =>
+            textItem(
+              graph.caseId,
+              "feature-target-condition",
+              `${action.id}:${targetRef}:${edge.id}:${conditionRef}`,
+              `进入“${targetName}”时：${conditionText(conditionRef, source)}`,
+              [conditionRef],
+            ),
+          );
+        })
+      : [];
+  branchConditions.sort(
+    (left, right) =>
+      left.text.localeCompare(right.text, "en") ||
+      left.id.localeCompare(right.id, "en"),
+  );
+  const conditions = [
+    ...baseConditions,
+    ...disjunctiveCondition,
+    ...branchConditions,
+  ];
+  const effects = actionEffects.map((effect) => {
+    const item = textItem(
+      graph.caseId,
+      "feature-effect",
+      effect.id,
+      effect.description.status === "resolved"
+        ? effect.description.value
+        : "操作结果待确认",
+      effect.sourceFactRefs,
+    );
+    const alternatives = (effect.conditionAlternatives ?? []).map(
+      (alternative, alternativeIndex) => {
+        const alternativeConditions = alternative.conditionRefs.map(
+          (conditionRef) =>
+            textItem(
+              graph.caseId,
+              "effect-condition",
+              `${effect.id}:${alternativeIndex}:${conditionRef}`,
+              conditionText(conditionRef, source),
+              [conditionRef],
+            ),
+        );
+        return {
+          conditions: alternativeConditions,
+          supportRefs: uniqueSorted([
+            ...alternative.sourceFactRefs,
+            ...alternativeConditions.flatMap(
+              (condition) => condition.supportRefs,
+            ),
+          ]),
+        };
+      },
+    );
+    return {
+      ...item,
+      kind: effect.kind,
+      conditionAlternatives: alternatives,
+      ...(effect.stateKey ? { stateKey: effect.stateKey } : {}),
+      ...(effect.value ? { value: effect.value } : {}),
+    };
+  });
+  const target = targetFor(action, control, actionEffects, graph, source);
+  const targetUnresolvedRefs = target ? unresolvedRefsForReqTarget(target) : [];
+  const targetSupportRefs = target ? supportRefsForReqTarget(target) : [];
+  const actionEdgeSupportRefs = graph.edges
+    .filter((edge) => edge.actionRef === action.id)
+    .flatMap((edge) => edge.sourceFactRefs);
+  return {
+    id: graphId(
+      "interaction",
+      graph.caseId,
+      action.trigger,
+      `${control.id}:${action.id}`,
+    ),
+    actionRef: action.id,
+    trigger: action.trigger,
+    conditions,
+    effects,
+    ...(target ? { target } : {}),
+    unresolvedRefs: [
+      ...new Set([
+        ...actionEffects.flatMap((effect) => effect.unresolvedRefs ?? []),
+        ...targetUnresolvedRefs,
+      ]),
+    ].sort(),
+    supportRefs: uniqueSorted([
+      ...action.sourceFactRefs,
+      ...actionEffects.flatMap((effect) => effect.sourceFactRefs),
+      ...conditions.flatMap((condition) => condition.supportRefs),
+      ...effects.flatMap((effect) => effect.supportRefs),
+      ...actionEdgeSupportRefs,
+      ...targetSupportRefs,
+    ]),
+  };
+}
+function featureFor(control, graph, source) {
+  if (control.actionRefs.length === 0) {
+    throw new Error(
+      `Req-model feature invariant for Control ${control.id}: ` +
+        "a Feature requires at least one Action.",
+    );
+  }
+  const interactions = control.actionRefs.map((actionRef) =>
+    interactionFor(control, actionRef, graph, source),
+  );
+  const properties = propertiesFor(control, source);
+  const propertyUnresolvedRefs =
+    properties.defaultValue?.status === "unresolved"
+      ? [properties.defaultValue.unresolvedRef]
+      : [];
+  const onlyInteraction =
+    interactions.length === 1 ? interactions[0] : undefined;
+  return {
+    id: graphId("feature", graph.caseId, "control", control.id),
+    controlRef: control.id,
+    displayName: control.name,
+    interactions,
+    /*
+     * These summary fields keep pre-interaction in-process consumers source
+     * compatible. Draft generation uses interactions exclusively. For a
+     * multi-action Control, the sentinel makes it impossible to mistake the
+     * first callback for the whole physical Control.
+     */
+    trigger: onlyInteraction?.trigger ?? "multiple-interactions",
+    ...(properties.enabled ? { enabled: properties.enabled } : {}),
+    ...(properties.defaultValue
+      ? { defaultValue: properties.defaultValue }
+      : {}),
+    options: properties.options,
+    conditions: interactions.flatMap((interaction) => interaction.conditions),
+    effects: interactions.flatMap((interaction) => interaction.effects),
+    ...(onlyInteraction?.target ? { target: onlyInteraction.target } : {}),
+    unresolvedRefs: uniqueSorted([
+      ...control.unresolvedRefs,
+      ...(control.name.status === "unresolved"
+        ? [control.name.unresolvedRef]
+        : []),
+      ...propertyUnresolvedRefs,
+      ...interactions.flatMap((interaction) => interaction.unresolvedRefs),
+    ]),
+    supportRefs: uniqueSorted([
+      ...control.sourceFactRefs,
+      ...properties.supportRefs,
+      ...interactions.flatMap((interaction) => interaction.supportRefs),
+    ]),
+  };
+}
+function descriptionItems(area, caseId) {
+  if (area.descriptionFacts.length > 0) {
+    return area.descriptionFacts.map((fact) =>
+      textItem(
+        caseId,
+        "area-description",
+        fact.id,
+        fact.value.status === "resolved"
+          ? String(fact.value.value)
+          : "区域说明待确认",
+        fact.sourceFactRefs,
+      ),
+    );
+  }
+  return [
+    textItem(
+      caseId,
+      "area-description",
+      area.id,
+      `${display(area.name, "该区域")}是一个 ${area.kind} 类型的交互区域。`,
+      area.sourceFactRefs,
+    ),
+  ];
+}
+/** Disambiguates Areas that resolve to the exact same displayName (e.g. two
+ * unrelated composables/routes sharing one string resource) using their
+ * identityAnchors — deterministic, no LLM involved (ADR-0001). Runs against
+ * the graph's own Area[] and must run before canonicalPath()/featureFor()
+ * read Area.name, so every downstream consumer (path segments, navigation
+ * target descriptions, feature titles) sees the same disambiguated name from
+ * one source of truth. Winner selection within a collision group is
+ * intentionally asymmetric (whichever Area's own identityAnchors happen not
+ * to yield a differing candidate keeps the bare name) — not a principled
+ * choice, just the first-found one; not worth the complexity to fix. Areas
+ * a suffix can't be found for, or whose suffix still collides with a sibling
+ * after assignment, are marked unresolved (AMBIGUOUS_AREA_DISPLAY_NAME) and
+ * left for the Stage 2 render Agent via the existing
+ * hasUnresolvedPathSegmentNames/renderPathNameCompletionLaw machinery —
+ * same mechanism already used for any other unresolved Area name. */
+function disambiguateAreaDisplayNames(areas, caseId) {
+  const byName = new Map();
+  for (let i = 0; i < areas.length; i++) {
+    const area = areas[i];
+    if (area.name.status !== "resolved") continue;
+    const indices = byName.get(area.name.value) ?? [];
+    indices.push(i);
+    byName.set(area.name.value, indices);
+  }
+  const collisionGroups = [...byName.values()].filter(
+    (indices) => indices.length > 1,
+  );
+  if (collisionGroups.length === 0) return { areas, newUnresolved: [] };
+  const groupNameByIndex = new Map();
+  // Only set for an area whose candidate final string (bare groupName if no
+  // distinguishing anchor was found, or `groupName (suffix)` otherwise) is
+  // unique within its collision group — an area with no distinguishing
+  // anchor legitimately keeps the bare name (the asymmetric "winner") as
+  // long as no sibling also ends up bare; a collision on the *candidate*
+  // final (whether two bare members or two identical suffixes) demotes every
+  // colliding member to unresolved instead of silently keeping duplicates
+  // under a "resolved" status.
+  const finalNameByIndex = new Map();
+  for (const indices of collisionGroups) {
+    const groupName = display(areas[indices[0]].name, "");
+    const suffixByIndex = new Map();
+    for (const idx of indices) {
+      groupNameByIndex.set(idx, groupName);
+      for (const anchor of areas[idx].identityAnchors) {
+        const candidate = componentIdentifierName(anchor);
+        if (candidate === undefined || candidate.trim().length === 0) continue;
+        if (candidate === groupName) continue;
+        suffixByIndex.set(idx, candidate);
+        break;
+      }
+    }
+    const candidateFinalByIndex = new Map();
+    for (const idx of indices) {
+      const suffix = suffixByIndex.get(idx);
+      candidateFinalByIndex.set(
+        idx,
+        suffix === undefined ? groupName : `${groupName} (${suffix})`,
+      );
+    }
+    const finalCounts = new Map();
+    for (const value of candidateFinalByIndex.values()) {
+      finalCounts.set(value, (finalCounts.get(value) ?? 0) + 1);
+    }
+    for (const idx of indices) {
+      const value = candidateFinalByIndex.get(idx);
+      if ((finalCounts.get(value) ?? 0) === 1) finalNameByIndex.set(idx, value);
+    }
+  }
+  const newUnresolved = [];
+  const disambiguated = areas.map((area, i) => {
+    const groupName = groupNameByIndex.get(i);
+    if (groupName === undefined) return area;
+    const finalName = finalNameByIndex.get(i);
+    const original = area.name;
+    if (finalName !== undefined) {
+      return {
+        ...area,
+        name: resolved(finalName, original.supportRefs, original.confidence),
+      };
+    }
+    const unresolvedId = graphId(
+      "unresolved",
+      caseId,
+      "area-display-name",
+      area.id,
+    );
+    newUnresolved.push({
+      id: unresolvedId,
+      ownerRef: area.id,
+      fieldPath: "displayName",
+      reasonCode: "AMBIGUOUS_AREA_DISPLAY_NAME",
+      message:
+        `区域显示名称"${groupName}"与其他区域重复，` +
+        "且 identityAnchors 中无可用区分后缀（或候选后缀仍与同组内其他区域冲突）。",
+      evidenceRefs: area.identityAnchors,
+      candidates: [],
+      impact: ["area-display-name"],
+    });
+    return {
+      ...area,
+      name: { status: "unresolved", unresolvedRef: unresolvedId },
+      unresolvedRefs: [...new Set([...area.unresolvedRefs, unresolvedId])],
+    };
+  });
+  return { areas: disambiguated, newUnresolved };
+}
+export function buildReqModel(graph, source) {
+  if (
+    graph.caseId !== source.caseId ||
+    JSON.stringify(graph.analysisContext) !==
+      JSON.stringify(source.analysisContext)
+  ) {
+    throw new Error("Area graph and source facts use different contexts");
+  }
+  // Disambiguate collided Area names before anything below reads Area.name,
+  // so canonicalPath()/featureFor() bake the disambiguated (or unresolved)
+  // name into every downstream string — see disambiguateAreaDisplayNames.
+  const {
+    areas: disambiguatedGraphAreas,
+    newUnresolved: displayNameUnresolved,
+  } = disambiguateAreaDisplayNames(graph.areas, graph.caseId);
+  const workingGraph = {
+    ...graph,
+    areas: disambiguatedGraphAreas,
+    unresolved: [...graph.unresolved, ...displayNameUnresolved],
+  };
+  const areas = workingGraph.areas.map((area) => {
+    const path = area.canonicalPathRef
+      ? workingGraph.paths.find((item) => item.id === area.canonicalPathRef)
+      : undefined;
+    const controls = area.controlRefs.map((controlRef) => {
+      const control = workingGraph.controls.find(
+        (item) => item.id === controlRef,
+      );
+      if (!control) throw new Error(`Missing control ${controlRef}`);
+      return control;
+    });
+    return {
+      id: graphId("req-area", workingGraph.caseId, area.kind, area.id),
+      areaRef: area.id,
+      displayName: area.name,
+      canonicalPath: canonicalPath(area, workingGraph),
+      preconditions: [...new Set([...(path?.preconditions ?? [])])]
+        .sort()
+        .map((conditionRef) =>
+          textItem(
+            workingGraph.caseId,
+            "area-precondition",
+            `${area.id}:${conditionRef}`,
+            conditionText(conditionRef, source),
+            [conditionRef],
+          ),
+        ),
+      descriptionItems: descriptionItems(area, workingGraph.caseId),
+      features: controls.flatMap((control) =>
+        control.actionRefs.length === 0
+          ? []
+          : [featureFor(control, workingGraph, source)],
+      ),
+      unresolvedRefs: [
+        ...new Set([
+          ...area.unresolvedRefs,
+          ...controls.flatMap((control) => control.unresolvedRefs),
+        ]),
+      ].sort(),
+      supportRefs: [
+        ...new Set([
+          ...area.sourceFactRefs,
+          ...controls.flatMap((control) => control.sourceFactRefs),
+        ]),
+      ].sort(),
+    };
+  });
+  return {
+    schemaVersion: "1.0.0",
+    artifactKind: "req-model",
+    caseId: workingGraph.caseId,
+    analysisContext: workingGraph.analysisContext,
+    ...(workingGraph.semanticCompleteness
+      ? { semanticCompleteness: workingGraph.semanticCompleteness }
+      : source.semanticCompleteness
+        ? { semanticCompleteness: source.semanticCompleteness }
+        : {}),
+    ...((workingGraph.limitations ?? source.limitations)
+      ? { limitations: workingGraph.limitations ?? source.limitations }
+      : {}),
+    areas,
+    unresolved: workingGraph.unresolved,
+  };
+}