android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/compose-call-sites.js

@@ -0,0 +1,2008 @@
+import {
+  advanceCallSiteStack,
+  executionFlowsForward,
+  isCallSiteArgumentStep,
+} from "../callback-call-sites.js";
+import { dynamicRepeatedCallSiteContexts } from "./dynamic-repeated-call-sites.js";
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+}
+function text(record, key) {
+  const value = record.data[key];
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+function expression(binding) {
+  return object(binding.data.expression) ?? {};
+}
+function expressionText(binding, key) {
+  const value = expression(binding)[key];
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+function structuredSymbolKey(summary) {
+  const symbol = object(summary?.resolvedSymbol);
+  if (!symbol) return undefined;
+  const part = (key) =>
+    typeof symbol[key] === "string" ? symbol[key].trim() : "";
+  const name = part("name");
+  const signature = part("signature");
+  if (!name && !signature) return undefined;
+  const initializer = object(symbol.initializer);
+  const declarationIdentity =
+    part("declarationRef") ||
+    part("declarationId") ||
+    (typeof initializer?.callRef === "string"
+      ? initializer.callRef.trim()
+      : "");
+  return [
+    part("kind"),
+    part("ownerQualifiedName"),
+    signature || name,
+    part("type"),
+    ...(declarationIdentity ? [declarationIdentity] : []),
+  ].join("\u0000");
+}
+function stateRecordSymbol(record) {
+  if (record.kind === "condition") {
+    return structuredSymbolKey(object(record.data.expressionStructure));
+  }
+  if (record.kind === "assignment") {
+    return structuredSymbolKey(object(record.data.left));
+  }
+  return undefined;
+}
+function stateRecordScope(index, record) {
+  const enclosingMethod = text(record, "enclosingMethod");
+  if (enclosingMethod) return enclosingMethod;
+  const visited = new Set();
+  let callableRef = text(record, "enclosingCallableRef");
+  while (callableRef && !visited.has(callableRef)) {
+    visited.add(callableRef);
+    const callable = index.recordsById.get(callableRef);
+    if (callable?.kind === "method-declaration") {
+      return text(callable, "signature") ?? callable.id;
+    }
+    callableRef = index.callableParent.get(callableRef);
+  }
+  return undefined;
+}
+function directBooleanCallGuard(index, call) {
+  const rawContexts = call.data.conditionContexts;
+  if (!Array.isArray(rawContexts) || rawContexts.length !== 1) {
+    return undefined;
+  }
+  const context = object(rawContexts[0]);
+  const conditionRef =
+    typeof context?.conditionRef === "string"
+      ? context.conditionRef.trim()
+      : "";
+  if (
+    !conditionRef ||
+    context?.branchKind !== "then" ||
+    context.polarity !== "true" ||
+    (Array.isArray(context.caseValues) && context.caseValues.length > 0)
+  )
+    return undefined;
+  const condition = index.recordsById.get(conditionRef);
+  const structure = object(condition?.data.expressionStructure);
+  const symbol = object(structure?.resolvedSymbol);
+  const expressionValue = condition ? text(condition, "expression") : undefined;
+  const booleanTypes = new Set([
+    "boolean",
+    "java.lang.Boolean",
+    "kotlin.Boolean",
+  ]);
+  const isBoolean = [
+    condition?.data.expressionType,
+    structure?.expressionType,
+    symbol?.type,
+  ].some(
+    (value) => typeof value === "string" && booleanTypes.has(value.trim()),
+  );
+  const stateSymbol = structuredSymbolKey(structure);
+  if (
+    !condition ||
+    !structure ||
+    !symbol ||
+    !expressionValue ||
+    !isBoolean ||
+    !stateSymbol
+  )
+    return undefined;
+  const matches = [...index.recordsById.values()].filter(
+    (record) =>
+      (record.kind === "condition" || record.kind === "assignment") &&
+      stateRecordSymbol(record) === stateSymbol,
+  );
+  const scopes = new Set(
+    matches.map((record) => stateRecordScope(index, record)),
+  );
+  if (matches.length === 0 || scopes.has(undefined) || scopes.size !== 1) {
+    return undefined;
+  }
+  return { condition, stateSymbol, expression: expressionValue };
+}
+/**
+ * Returns the complete structured branch context of one exact local
+ * Composable invocation. Unlike surface-state inference this does not try to
+ * identify a mutable state slot: the narrower claim is simply that controls
+ * materialized for this call site exist only while every enclosing branch
+ * guard holds.
+ */
+function callSiteVisibilityGuards(index, call, inlineGuardsByCall = new Map()) {
+  const inline = inlineGuardsByCall.get(call.id) ?? [];
+  const rawContexts = call.data.conditionContexts;
+  if (!Array.isArray(rawContexts) || rawContexts.length === 0) return inline;
+  const guards = rawContexts.flatMap((rawContext) => {
+    const context = object(rawContext);
+    const conditionRef =
+      typeof context?.conditionRef === "string"
+        ? context.conditionRef.trim()
+        : "";
+    const polarity = context?.polarity;
+    const branchKind = context?.branchKind;
+    const caseValues = Array.isArray(context?.caseValues)
+      ? context.caseValues.filter((value) => typeof value === "string")
+      : [];
+    if (
+      !conditionRef ||
+      !["then", "else", "fallthrough", "case"].includes(
+        typeof branchKind === "string" ? branchKind : "",
+      ) ||
+      !["true", "false", "case"].includes(
+        typeof polarity === "string" ? polarity : "",
+      )
+    )
+      return [];
+    const condition = index.recordsById.get(conditionRef);
+    const expressionValue = condition
+      ? text(condition, "expression")
+      : undefined;
+    if (
+      !condition ||
+      !expressionValue ||
+      !object(condition.data.expressionStructure)
+    )
+      return [];
+    const expressionAnchor =
+      polarity === "false"
+        ? `!(${expressionValue})`
+        : polarity === "case"
+          ? `${expressionValue} in (${caseValues.join(", ")})`
+          : expressionValue;
+    const plainLanguage =
+      polarity === "false"
+        ? `不满足条件：${expressionValue}`
+        : polarity === "case"
+          ? `条件 ${expressionValue} 匹配：${caseValues.join("、")}`
+          : `满足条件：${expressionValue}`;
+    return [{ condition, expressionAnchor, plainLanguage }];
+  });
+  const structured = guards.length === rawContexts.length ? guards : [];
+  return [
+    ...new Map(
+      [...structured, ...inline].map((guard) => [
+        `${guard.expressionAnchor}\u0000${guard.condition.id}`,
+        guard,
+      ]),
+    ).values(),
+  ];
+}
+function bindingCallableRef(binding) {
+  return (
+    expressionText(binding, "callableRef") ??
+    expressionText(binding, "callableReferenceRef")
+  );
+}
+function booleanExpressionBinding(binding) {
+  const summary = expression(binding);
+  const symbol = object(summary.resolvedSymbol);
+  return [summary.expressionType, symbol?.type].some(
+    (value) =>
+      typeof value === "string" &&
+      /(?:^|\.)(?:Boolean|boolean)$/u.test(value.trim()),
+  );
+}
+function normalizedExpressionSource(binding) {
+  const summary = expression(binding);
+  const source =
+    typeof summary.source === "string"
+      ? summary.source.trim()
+      : text(binding, "argumentSource");
+  return source && source.length > 0 ? source : undefined;
+}
+function animatedVisibilityBoundary(index, call) {
+  if (
+    call.kind !== "resolved-call" ||
+    sourceApiName(call) !== "AnimatedVisibility" ||
+    !(text(call, "targetOwnerQualifiedName") ?? "").startsWith(
+      "androidx.compose.animation.",
+    )
+  )
+    return undefined;
+  const bindings = bindingsFor(index, call.id);
+  const visible = bindings.filter(
+    (binding) =>
+      !bindingCallableRef(binding) && booleanExpressionBinding(binding),
+  );
+  const content = bindings.filter(
+    (binding) => bindingCallableRef(binding) !== undefined,
+  );
+  if (visible.length !== 1 || content.length !== 1) return undefined;
+  const scopeRef = bindingCallableRef(content[0]);
+  const expressionAnchor = normalizedExpressionSource(visible[0]);
+  if (!scopeRef || !expressionAnchor) return undefined;
+  const symbol = structuredSymbolKey(expression(visible[0]));
+  return {
+    scopeRef,
+    canonicalKey: `${symbol ?? expressionAnchor}\u0000${expressionAnchor}`,
+    guard: {
+      condition: visible[0],
+      expressionAnchor,
+      plainLanguage: `仅在 ${expressionAnchor} 为 true 时显示`,
+    },
+  };
+}
+function enclosingComposable(index, callableRef) {
+  const visited = new Set();
+  let current = callableRef;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const method = index.methodsByCallable.get(current);
+    if (method) return method;
+    current = index.callableParent.get(current);
+  }
+  return undefined;
+}
+function sameVisibilityGuards(left, right) {
+  return (
+    left.length === right.length &&
+    left.every(
+      (guard, index) => guard.canonicalKey === right[index].canonicalKey,
+    )
+  );
+}
+/**
+ * Propagates an AnimatedVisibility boolean guard through exact local
+ * Composable calls only when every runtime invocation of the declaration has
+ * the same complete guard set. AnimatedVisibility remains inline UI; this map
+ * annotates controls and never creates a Surface/Area.
+ */
+function animatedVisibilityGuardsByCall(index) {
+  const boundaries = index.calls.flatMap((call) => {
+    const boundary = animatedVisibilityBoundary(index, call);
+    return boundary ? [boundary] : [];
+  });
+  const lexicalGuards = (call) =>
+    boundaries
+      .filter((boundary) =>
+        scopeIsWithin(
+          index,
+          text(call, "enclosingCallableRef"),
+          boundary.scopeRef,
+        ),
+      )
+      .sort((left, right) =>
+        left.canonicalKey.localeCompare(right.canonicalKey, "en"),
+      );
+  const inheritedByMethod = new Map();
+  const effective = (call) => {
+    const method = enclosingComposable(
+      index,
+      text(call, "enclosingCallableRef"),
+    );
+    const inherited = method
+      ? (inheritedByMethod.get(method.record.id) ?? [])
+      : [];
+    return [
+      ...new Map(
+        [...lexicalGuards(call), ...inherited].map((guard) => [
+          guard.canonicalKey,
+          guard,
+        ]),
+      ).values(),
+    ].sort((left, right) =>
+      left.canonicalKey.localeCompare(right.canonicalKey, "en"),
+    );
+  };
+  for (
+    let iteration = 0;
+    iteration < index.methodsByCallable.size;
+    iteration += 1
+  ) {
+    let changed = false;
+    for (const target of index.methodsByCallable.values()) {
+      const invocations = index.calls.filter(
+        (call) =>
+          targetForCall(index, call)?.record.id === target.record.id &&
+          !scopeIsWithinPreview(index, text(call, "enclosingCallableRef")),
+      );
+      if (invocations.length === 0) continue;
+      const guards = invocations.map(effective);
+      if (
+        guards[0].length === 0 ||
+        !guards.every((candidate) => sameVisibilityGuards(candidate, guards[0]))
+      )
+        continue;
+      const previous = inheritedByMethod.get(target.record.id) ?? [];
+      if (sameVisibilityGuards(previous, guards[0])) continue;
+      inheritedByMethod.set(target.record.id, guards[0]);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return new Map(
+    index.calls.flatMap((call) => {
+      const guards = effective(call);
+      return guards.length > 0
+        ? [[call.id, guards.map((item) => item.guard)]]
+        : [];
+    }),
+  );
+}
+function sourceApiName(record) {
+  return text(record, "targetName")?.replace(/-.*$/u, "");
+}
+function composableQualifiedName(record) {
+  const owner = text(record, "ownerQualifiedName");
+  const name = text(record, "name");
+  return name ? (owner ? `${owner}#${name}` : name) : undefined;
+}
+function isComposableDeclaration(record) {
+  if (record.kind !== "method-declaration") return false;
+  if (record.data.composable === true) return true;
+  return (
+    Array.isArray(record.data.annotations) &&
+    record.data.annotations.includes("androidx.compose.runtime.Composable")
+  );
+}
+function append(map, key, value) {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+function buildIndex(android, jvm, state) {
+  const recordsById = new Map();
+  const calls = [];
+  const mutableBindings = new Map();
+  const callableParent = new Map();
+  const methodsBySignature = new Map();
+  const methodsByCallable = new Map();
+  const mutableByName = new Map();
+  for (const record of jvm.body) {
+    recordsById.set(record.id, record);
+    if (record.kind === "resolved-call") calls.push(record);
+    if (record.kind === "call-argument-binding") {
+      const callRef = text(record, "callRef");
+      if (callRef) append(mutableBindings, callRef, record);
+    }
+    if (
+      record.kind === "method-declaration" ||
+      record.kind === "lambda-declaration"
+    ) {
+      const parent = text(record, "enclosingCallableRef");
+      if (parent) callableParent.set(record.id, parent);
+    }
+  }
+  for (const record of jvm.body) {
+    if (!isComposableDeclaration(record)) continue;
+    const qualifiedName = composableQualifiedName(record);
+    const signature = text(record, "signature") ?? qualifiedName;
+    const componentRef = qualifiedName
+      ? state.componentByQualifiedName.get(qualifiedName)
+      : undefined;
+    if (!qualifiedName || !signature || !componentRef) continue;
+    const method = { record, componentRef, qualifiedName, signature };
+    methodsByCallable.set(record.id, method);
+    methodsBySignature.set(signature, method);
+    const candidates = mutableByName.get(qualifiedName) ?? [];
+    candidates.push(method);
+    mutableByName.set(qualifiedName, candidates);
+  }
+  const resourceValues = new Map();
+  for (const value of android.values) {
+    if (typeof value.value !== "string" || value.value.trim().length === 0) {
+      continue;
+    }
+    const key = `${value.resourceType}/${value.name}`;
+    const values = resourceValues.get(key) ?? new Set();
+    values.add(value.value);
+    resourceValues.set(key, values);
+  }
+  return {
+    recordsById,
+    calls: calls.sort((left, right) => left.id.localeCompare(right.id, "en")),
+    bindingsByCall: new Map(
+      [...mutableBindings].map(([key, values]) => [
+        key,
+        values.sort((left, right) => left.id.localeCompare(right.id, "en")),
+      ]),
+    ),
+    callableParent,
+    methodsByCallable,
+    methodsBySignature,
+    methodsByQualifiedName: new Map(
+      [...mutableByName].map(([key, values]) => [
+        key,
+        values.sort((left, right) =>
+          left.signature.localeCompare(right.signature, "en"),
+        ),
+      ]),
+    ),
+    resourceValues: new Map(
+      [...resourceValues].map(([key, values]) => [
+        key,
+        [...values].sort((left, right) => left.localeCompare(right, "en")),
+      ]),
+    ),
+  };
+}
+function targetForCall(index, call) {
+  const signature = text(call, "targetSignature");
+  const exact = signature ? index.methodsBySignature.get(signature) : undefined;
+  if (exact) return exact;
+  if (!signature?.includes("androidx.compose.runtime.Composer")) {
+    return undefined;
+  }
+  const owner = text(call, "targetOwnerQualifiedName");
+  const name = sourceApiName(call);
+  if (!owner || !name) return undefined;
+  const candidates = index.methodsByQualifiedName.get(`${owner}#${name}`) ?? [];
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function bindingsFor(index, callRef) {
+  return index.bindingsByCall.get(callRef) ?? [];
+}
+function parameterName(binding) {
+  return (
+    text(binding, "parameterName") ?? expressionText(binding, "namedArgument")
+  );
+}
+function scopeIsWithin(index, candidate, ancestor) {
+  const visited = new Set();
+  let current = candidate;
+  while (current && !visited.has(current)) {
+    if (current === ancestor) return true;
+    visited.add(current);
+    current = index.callableParent.get(current);
+  }
+  return false;
+}
+const composePreviewAnnotations = new Set([
+  "androidx.compose.ui.tooling.preview.Preview",
+  "org.jetbrains.compose.ui.tooling.preview.Preview",
+]);
+function scopeIsWithinPreview(index, candidate) {
+  const visited = new Set();
+  let current = candidate;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const callable = index.recordsById.get(current);
+    const annotations = Array.isArray(callable?.data.annotations)
+      ? callable.data.annotations
+      : [];
+    if (
+      annotations.some(
+        (annotation) =>
+          typeof annotation === "string" &&
+          composePreviewAnnotations.has(annotation),
+      )
+    )
+      return true;
+    current = index.callableParent.get(current);
+  }
+  return false;
+}
+function reachableComponents(index, root) {
+  const methods = new Map([[root.record.id, root]]);
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.shift();
+    for (const call of index.calls) {
+      if (
+        !scopeIsWithin(
+          index,
+          text(call, "enclosingCallableRef"),
+          current.record.id,
+        )
+      )
+        continue;
+      const target = targetForCall(index, call);
+      if (!target || methods.has(target.record.id)) continue;
+      methods.set(target.record.id, target);
+      pending.push(target);
+    }
+  }
+  return new Set([...methods.values()].map((method) => method.componentRef));
+}
+function sourceKind(record) {
+  const language = text(record, "language");
+  if (language === "kotlin" || record.location?.path.endsWith(".kt")) {
+    return "kotlin";
+  }
+  if (language === "java" || record.location?.path.endsWith(".java")) {
+    return "java";
+  }
+  return "other";
+}
+function recordLocation(record, anchor, symbol) {
+  if (!record.location) return undefined;
+  return {
+    sourceKind: sourceKind(record),
+    path: record.location.path,
+    anchor,
+    range: {
+      startLine: Math.max(1, record.location.startLine),
+      endLine: Math.max(record.location.startLine, record.location.endLine),
+      ...(record.location.startColumn >= 1
+        ? { startColumn: record.location.startColumn }
+        : {}),
+      ...(record.location.endColumn >= 1
+        ? { endColumn: record.location.endColumn }
+        : {}),
+    },
+    ...(symbol ? { symbol } : {}),
+  };
+}
+function resourceValue(index, summary) {
+  const reference = object(summary.resourceReference);
+  const type = reference?.resourceType;
+  const name = reference?.resourceName;
+  if (typeof type !== "string" || typeof name !== "string") return undefined;
+  const values = index.resourceValues.get(`${type}/${name}`) ?? [];
+  return values.length === 1 ? values[0] : undefined;
+}
+function staticLabel(index, binding, visited = new Set()) {
+  const summary = expression(binding);
+  const constant = summary.constantValue;
+  if (typeof constant === "string" && constant.trim().length > 0) {
+    return { value: constant, support: [binding] };
+  }
+  const selected = resourceValue(index, summary);
+  if (selected) return { value: selected, support: [binding] };
+  const initializer = object(object(summary.resolvedSymbol)?.initializer);
+  if (initializer) {
+    const value = initializer.constantValue;
+    if (typeof value === "string" && value.trim().length > 0) {
+      return { value, support: [binding] };
+    }
+    const initializedResource = resourceValue(index, initializer);
+    if (initializedResource) {
+      return { value: initializedResource, support: [binding] };
+    }
+  }
+  const nestedRef = expressionText(binding, "callRef");
+  if (!nestedRef || visited.has(nestedRef)) return { support: [] };
+  const nested = index.recordsById.get(nestedRef);
+  if (!nested) return { support: [] };
+  const nextVisited = new Set(visited).add(nestedRef);
+  const candidates = bindingsFor(index, nestedRef)
+    .map((candidate) => staticLabel(index, candidate, nextVisited))
+    .filter((candidate) => candidate.value !== undefined);
+  const values = [...new Set(candidates.map((candidate) => candidate.value))];
+  return values.length === 1
+    ? {
+        value: values[0],
+        support: [
+          binding,
+          nested,
+          ...candidates.flatMap((item) => item.support),
+        ],
+      }
+    : { support: [] };
+}
+function namingRole(name) {
+  const normalized = name.replace(/[^A-Za-z0-9]/gu, "").toLowerCase();
+  if (["text", "title", "label"].includes(normalized)) return "visibleText";
+  if (
+    ["contentdescription", "accessibilitylabel", "semanticslabel"].includes(
+      normalized,
+    )
+  )
+    return "contentDescription";
+  if (["hint", "placeholder"].includes(normalized)) return "associatedLabel";
+  return undefined;
+}
+function normalizedSemanticParameterName(name) {
+  return name.replace(/[^A-Za-z0-9]/gu, "").toLowerCase();
+}
+function callSiteNaming(
+  index,
+  call,
+  callbackParameterName,
+  allowOrdinaryLabel,
+) {
+  const grouped = new Map();
+  const callbackSpecific = [];
+  const callbackLabel = `${normalizedSemanticParameterName(callbackParameterName)}label`;
+  for (const binding of bindingsFor(index, call.id)) {
+    const name = parameterName(binding);
+    if (!name) continue;
+    const normalized = normalizedSemanticParameterName(name);
+    if (normalized === callbackLabel) {
+      callbackSpecific.push(binding);
+      continue;
+    }
+    const role = allowOrdinaryLabel ? namingRole(name) : undefined;
+    if (!role) continue;
+    const values = grouped.get(role) ?? [];
+    values.push(binding);
+    grouped.set(role, values);
+  }
+  const resolveBindings = (bindings) => {
+    const candidates = bindings.map((binding) => ({
+      binding,
+      resolution: staticLabel(index, binding),
+    }));
+    const values = [
+      ...new Set(
+        candidates.flatMap(({ resolution }) =>
+          resolution.value ? [resolution.value] : [],
+        ),
+      ),
+    ];
+    if (values.length !== 1) return { support: [] };
+    return {
+      value: values[0],
+      support: candidates
+        .filter(({ resolution }) => resolution.value === values[0])
+        .flatMap(({ binding, resolution }) => [binding, ...resolution.support]),
+    };
+  };
+  const specific = resolveBindings(callbackSpecific);
+  if (callbackSpecific.length > 0) {
+    return specific.value
+      ? {
+          contentDescription: specific.value,
+          support: [
+            ...new Map(
+              specific.support.map((record) => [record.id, record]),
+            ).values(),
+          ],
+        }
+      : { support: [] };
+  }
+  const visible = resolveBindings(grouped.get("visibleText") ?? []);
+  const description = resolveBindings(grouped.get("contentDescription") ?? []);
+  const associated = resolveBindings(grouped.get("associatedLabel") ?? []);
+  return {
+    ...(visible.value ? { visibleText: visible.value } : {}),
+    ...(description.value ? { contentDescription: description.value } : {}),
+    ...(associated.value ? { associatedLabel: associated.value } : {}),
+    support: [
+      ...new Map(
+        [...visible.support, ...description.support, ...associated.support].map(
+          (record) => [record.id, record],
+        ),
+      ).values(),
+    ],
+  };
+}
+function exactParameterReference(summary, parameterName) {
+  const symbol = object(summary?.resolvedSymbol);
+  return symbol?.kind === "parameter" && symbol.name === parameterName;
+}
+function exactLambdaParameter(record, ordinal) {
+  const parameters = Array.isArray(record?.data.parameters)
+    ? record.data.parameters
+    : [];
+  const parameter = object(parameters[ordinal]);
+  const name = typeof parameter?.name === "string" ? parameter.name.trim() : "";
+  const type = typeof parameter?.type === "string" ? parameter.type.trim() : "";
+  return name && type ? { name, type } : undefined;
+}
+function enumEntriesType(summary) {
+  const receiver = object(summary?.receiverExpression);
+  const receiverSymbol = object(receiver?.resolvedSymbol);
+  const qualifiedName = receiverSymbol?.qualifiedName;
+  if (
+    receiverSymbol?.kind !== "class" ||
+    typeof qualifiedName !== "string" ||
+    qualifiedName.trim().length === 0
+  )
+    return undefined;
+  const enumType = qualifiedName.trim();
+  const selector = object(summary?.selectorExpression);
+  const selectorSymbol =
+    object(selector?.resolvedSymbol) ?? object(summary?.resolvedSymbol);
+  if (
+    selectorSymbol?.name === "getEntries" ||
+    selectorSymbol?.name === "entries"
+  )
+    return enumType;
+  /*
+   * Kotlin UAST can resolve the synthetic `entries` selector back to the enum
+   * class instead of its generated getter. Accept that malformed symbol only
+   * when the remaining structured facts prove the same operation: the exact
+   * class receiver, the single selector token, and EnumEntries of that class.
+   * The conjunction keeps this a language-level compatibility path rather
+   * than a source-text or product-specific guess.
+   */
+  const selectorSource =
+    typeof selector?.source === "string" ? selector.source.trim() : "";
+  const expressionType =
+    typeof summary?.expressionType === "string"
+      ? summary.expressionType.replace(/\s+/gu, "").trim()
+      : "";
+  return selectorSource === "entries" &&
+    expressionType === `kotlin.enums.EnumEntries<${enumType}>` &&
+    selectorSymbol?.kind === "class" &&
+    selectorSymbol.qualifiedName === enumType
+    ? enumType
+    : undefined;
+}
+function locationContains(container, nested) {
+  if (
+    !container.location ||
+    !nested.location ||
+    container.location.path !== nested.location.path
+  )
+    return false;
+  return (
+    nested.location.startOffset >= container.location.startOffset &&
+    nested.location.endOffset <= container.location.endOffset
+  );
+}
+function finiteEnumLoopForCall(index, child) {
+  const childScope = text(child, "enclosingCallableRef");
+  const candidates = index.calls.flatMap((call) => {
+    if (
+      call.kind !== "resolved-call" ||
+      sourceApiName(call) !== "forEach" ||
+      !(text(call, "targetOwnerQualifiedName") ?? "").startsWith(
+        "kotlin.collections.",
+      )
+    )
+      return [];
+    const actionBindings = bindingsFor(index, call.id).filter(
+      (binding) =>
+        parameterName(binding) === "action" &&
+        bindingCallableRef(binding) !== undefined,
+    );
+    if (actionBindings.length !== 1) return [];
+    const actionRef = bindingCallableRef(actionBindings[0]);
+    const action = index.recordsById.get(actionRef);
+    const parameter = exactLambdaParameter(action, 0);
+    const enumType = enumEntriesType(object(call.data.receiverExpression));
+    return action &&
+      parameter &&
+      enumType &&
+      parameter.type === enumType &&
+      scopeIsWithin(index, childScope, actionRef)
+      ? [
+          {
+            call,
+            actionBinding: actionBindings[0],
+            action,
+            parameter,
+            enumType,
+          },
+        ]
+      : [];
+  });
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function caseContextsForCondition(record, conditionRef) {
+  const contexts = Array.isArray(record.data.conditionContexts)
+    ? record.data.conditionContexts
+    : [];
+  return contexts.flatMap((value) => {
+    const context = object(value);
+    return context?.conditionRef === conditionRef ? [context] : [];
+  });
+}
+/**
+ * Expands one exact enum.entries/forEach invocation only when a source-level
+ * `when(loopParameter)` provides a complete set of static, uniquely named
+ * case branches for the call-site label. Dynamic/else/multiple-loop shapes
+ * remain one unresolved control instead of being guessed.
+ */
+function finiteCallSiteNamingVariants(index, call) {
+  const loop = finiteEnumLoopForCall(index, call);
+  if (!loop) return undefined;
+  const labelBindings = bindingsFor(index, call.id).filter((binding) => {
+    const name = parameterName(binding);
+    return (
+      name !== undefined &&
+      namingRole(name) === "visibleText" &&
+      bindingCallableRef(binding) === undefined
+    );
+  });
+  if (labelBindings.length !== 1) return undefined;
+  const labelBinding = labelBindings[0];
+  const conditions = [...index.recordsById.values()].filter(
+    (record) =>
+      record.kind === "condition" &&
+      record.data.conditionKind === "switch-or-when" &&
+      text(record, "enclosingCallableRef") === loop.action.id &&
+      exactParameterReference(
+        object(record.data.expressionStructure),
+        loop.parameter.name,
+      ) &&
+      locationContains(labelBinding, record),
+  );
+  if (conditions.length !== 1) return undefined;
+  const condition = conditions[0];
+  const caseCalls = index.calls.filter(
+    (candidate) =>
+      locationContains(labelBinding, candidate) &&
+      caseContextsForCondition(candidate, condition.id).length > 0,
+  );
+  if (caseCalls.length < 2) return undefined;
+  const labelsByField = new Map();
+  for (const caseCall of caseCalls) {
+    const contexts = caseContextsForCondition(caseCall, condition.id);
+    if (
+      contexts.length !== 1 ||
+      contexts[0].branchKind !== "case" ||
+      contexts[0].polarity !== "case"
+    )
+      return undefined;
+    const structures = Array.isArray(contexts[0].caseValueStructures)
+      ? contexts[0].caseValueStructures.flatMap((value) => {
+          const structure = object(value);
+          return structure ? [structure] : [];
+        })
+      : [];
+    if (structures.length === 0) return undefined;
+    const candidates = bindingsFor(index, caseCall.id)
+      .map((binding) => ({ binding, label: staticLabel(index, binding) }))
+      .filter((candidate) => candidate.label.value !== undefined);
+    const values = [
+      ...new Set(candidates.map((candidate) => candidate.label.value)),
+    ];
+    if (values.length !== 1) return undefined;
+    for (const structure of structures) {
+      const symbol = object(structure.resolvedSymbol);
+      const field = typeof symbol?.name === "string" ? symbol.name.trim() : "";
+      if (
+        symbol?.kind !== "field" ||
+        symbol.ownerQualifiedName !== loop.enumType ||
+        !field ||
+        labelsByField.has(field)
+      )
+        return undefined;
+      labelsByField.set(field, {
+        visibleText: values[0],
+        support: [
+          loop.call,
+          loop.actionBinding,
+          condition,
+          caseCall,
+          labelBinding,
+          ...candidates.flatMap((candidate) => [
+            candidate.binding,
+            ...candidate.label.support,
+          ]),
+        ],
+      });
+    }
+  }
+  const variants = [...labelsByField.values()];
+  if (
+    variants.length < 2 ||
+    variants.length > 64 ||
+    new Set(variants.map((variant) => variant.visibleText)).size !==
+      variants.length
+  )
+    return undefined;
+  return variants;
+}
+function hasMoreSpecificFiniteInvocation(index, target, templateOwnerRef) {
+  return index.calls.some((candidate) => {
+    if (
+      !scopeIsWithin(
+        index,
+        text(candidate, "enclosingCallableRef"),
+        target.record.id,
+      )
+    )
+      return false;
+    const nestedTarget = targetForCall(index, candidate);
+    return (
+      nestedTarget !== undefined &&
+      reachableComponents(index, nestedTarget).has(templateOwnerRef) &&
+      finiteCallSiteNamingVariants(index, candidate) !== undefined
+    );
+  });
+}
+function declaredParameterNames(record) {
+  const parameters = Array.isArray(record.data.parameters)
+    ? record.data.parameters
+    : [];
+  return new Set(
+    parameters.flatMap((value) => {
+      const parameter = object(value);
+      const name = parameter?.name;
+      return typeof name === "string" && name.trim().length > 0
+        ? [name.trim()]
+        : [];
+    }),
+  );
+}
+/**
+ * Finds the lexical declaration that owns a referenced parameter. Merely
+ * knowing the enclosing method is insufficient: a nested lambda may declare
+ * a same-named parameter and must shadow the outer slot.
+ */
+function nearestParameterDeclaration(index, callableRef, parameterName) {
+  const visited = new Set();
+  let current = callableRef;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const declaration = index.recordsById.get(current);
+    if (!declaration) return undefined;
+    if (declaredParameterNames(declaration).has(parameterName)) {
+      return declaration;
+    }
+    current = index.callableParent.get(current);
+  }
+  return undefined;
+}
+function concreteCallback(state, index, binding) {
+  const callable = expressionText(binding, "callableRef");
+  if (callable) return state.callbackForRawCallable(callable);
+  const referenceRef = expressionText(binding, "callableReferenceRef");
+  const reference = referenceRef
+    ? index.recordsById.get(referenceRef)
+    : undefined;
+  const targetCallable = reference
+    ? text(reference, "targetCallableRef")
+    : undefined;
+  if (targetCallable) return state.callbackForRawCallable(targetCallable);
+  const signature = reference ? text(reference, "targetSignature") : undefined;
+  if (!signature) return undefined;
+  const matches = state.builder
+    .facts("callback")
+    .filter(
+      (fact) =>
+        fact.kind === "callback" && fact.data.callableSymbol === signature,
+    );
+  return matches.length === 1 ? matches[0].id : undefined;
+}
+function executionAdjacency(facts, index, callbacks, state) {
+  const mutable = new Map();
+  const add = (from, step) => {
+    const targets = mutable.get(from) ?? new Map();
+    const key = [
+      step.callbackKey,
+      step.flowKind,
+      step.parameterName ?? "",
+      step.callSiteKey ?? "",
+    ].join("\u0000");
+    targets.set(key, step);
+    mutable.set(from, targets);
+  };
+  for (const fact of facts) {
+    const forward = executionFlowsForward(fact.data.flowKind);
+    const from = forward ? fact.data.fromCallbackKey : fact.data.toCallbackKey;
+    const to = forward ? fact.data.toCallbackKey : fact.data.fromCallbackKey;
+    add(from, {
+      callbackKey: to,
+      flowKind: fact.data.flowKind,
+      ...(fact.data.parameterName
+        ? { parameterName: fact.data.parameterName }
+        : {}),
+      ...(fact.data.callSiteKey ? { callSiteKey: fact.data.callSiteKey } : {}),
+    });
+  }
+  /*
+   * Callback facts deliberately share source callable identities, while the
+   * JVM invocation normalizer can conservatively reject some `invoke()`
+   * records. This compensation is still lexical: it connects only the nearest
+   * declaration that actually owns the receiver parameter. A lambda-owned
+   * parameter therefore shadows, rather than aliases, an outer formal slot.
+   */
+  for (const call of index.calls) {
+    if (
+      sourceApiName(call) !== "invoke" ||
+      !/(?:^|\.)Function\d+$/u.test(
+        text(call, "targetOwnerQualifiedName") ?? "",
+      )
+    )
+      continue;
+    const receiver = object(call.data.receiverResolvedSymbol);
+    const name = typeof receiver?.name === "string" ? receiver.name.trim() : "";
+    if (receiver?.kind !== "parameter" || name.length === 0) continue;
+    const rawCaller = text(call, "enclosingCallableRef");
+    const caller = rawCaller
+      ? state.callbackForRawCallable(rawCaller)
+      : undefined;
+    if (!caller || !rawCaller) continue;
+    const declaration = nearestParameterDeclaration(index, rawCaller, name);
+    if (!declaration || declaration.kind !== "method-declaration") continue;
+    const signature = text(declaration, "signature");
+    const qualified = composableQualifiedName(declaration);
+    if (!signature && !qualified) continue;
+    const symbols = new Set([
+      ...(signature ? [`${signature}#parameter:${name}`] : []),
+      ...(qualified ? [`${qualified}#parameter:${name}`] : []),
+    ]);
+    for (const formal of callbacks) {
+      if (symbols.has(formal.data.callableSymbol)) {
+        add(caller, {
+          callbackKey: formal.id,
+          flowKind: "listener-invocation",
+          parameterName: name,
+        });
+      }
+    }
+  }
+  return new Map(
+    [...mutable].map(([key, values]) => [
+      key,
+      [...values.values()].sort(
+        (left, right) =>
+          left.callbackKey.localeCompare(right.callbackKey, "en") ||
+          left.flowKind.localeCompare(right.flowKind, "en") ||
+          (left.callSiteKey ?? "").localeCompare(right.callSiteKey ?? "", "en"),
+      ),
+    ]),
+  );
+}
+function copyTemplateSemantics(
+  state,
+  templateRef,
+  instanceRef,
+  properties,
+  conditions,
+  location,
+) {
+  for (const property of properties) {
+    if (property.data.ownerKey !== templateRef) continue;
+    state.builder.addFact("ui-property", {
+      identity: [
+        { kind: "control", value: instanceRef },
+        { kind: "semantic-key", value: property.data.property },
+      ],
+      confidence: property.confidence,
+      support: [
+        {
+          location,
+          role: "call-site-specialized Compose control property",
+        },
+      ],
+      data: {
+        ...property.data,
+        ownerKey: instanceRef,
+      },
+      relatedFactRefs: [instanceRef],
+    });
+  }
+  for (const condition of conditions) {
+    if (condition.data.ownerKey !== templateRef) continue;
+    state.builder.addFact("condition", {
+      identity: [
+        { kind: "control", value: instanceRef },
+        {
+          kind: "semantic-key",
+          value: condition.data.conditionRole ?? "enabled",
+        },
+        { kind: "semantic-key", value: condition.data.expressionAnchor },
+      ],
+      confidence: condition.confidence,
+      support: [
+        {
+          location,
+          role: "call-site-specialized Compose control condition",
+        },
+      ],
+      data: {
+        ...condition.data,
+        ownerKey: instanceRef,
+      },
+      relatedFactRefs: [instanceRef],
+    });
+  }
+}
+function specializeCallSiteSurfaces(
+  state,
+  index,
+  call,
+  target,
+  actions,
+  directSurfaceCount,
+  componentById,
+  properties,
+  conditions,
+  location,
+) {
+  const instances = new Map();
+  const templateRefs = [
+    ...new Set(
+      actions.flatMap((action) =>
+        action.surfaceTemplateRef ? [action.surfaceTemplateRef] : [],
+      ),
+    ),
+  ].sort((left, right) => left.localeCompare(right, "en"));
+  // One guard controlling multiple distinct surfaces does not identify which
+  // surface the state activates. Preserve that ambiguity instead of adding
+  // the same activation to every target.
+  const directGuard =
+    templateRefs.length === 1 && directSurfaceCount === 1
+      ? directBooleanCallGuard(index, call)
+      : undefined;
+  for (const templateRef of templateRefs) {
+    const template = componentById.get(templateRef);
+    if (!template) continue;
+    const hostRefs = [
+      ...new Set(
+        actions
+          .filter((action) => action.surfaceTemplateRef === templateRef)
+          .map((action) => action.actualFact.data.ownerKey),
+      ),
+    ];
+    if (hostRefs.length !== 1) continue;
+    const [hostRef] = hostRefs;
+    const host = componentById.get(hostRef);
+    const anchor = state.builder
+      .stableId("fact", "compose-call-site-surface-anchor", [
+        { kind: "component", value: hostRef },
+        { kind: "component", value: templateRef },
+        { kind: "symbol", value: target.signature },
+        // Source text is not a call-site identity: two invocations can be
+        // byte-for-byte identical. The JVM extractor record id includes the
+        // deterministic source path/range and therefore keeps those physical
+        // invocations as distinct surface instances.
+        { kind: "semantic-key", value: call.id },
+      ])
+      .split("/")
+      .at(-1);
+    const qualifiedName =
+      `${host?.data.qualifiedName ?? hostRef}` +
+      `#surface-call:${template.data.componentType}:${anchor}`;
+    const instanceRef = state.ensureComponent(
+      qualifiedName,
+      template.data.componentType,
+      location,
+      "exact invocation of a reusable Compose surface",
+      "high",
+      {
+        uiTechnology: template.data.uiTechnology ?? "compose",
+        analysisRole: "call-site-instance",
+      },
+    );
+    state.builder.mergeFactData("component", templateRef, {
+      analysisRole: "declaration-template",
+    });
+    state.builder.addFact("container-binding", {
+      identity: [
+        { kind: "component", value: hostRef },
+        { kind: "container", value: "surface" },
+        { kind: "component", value: instanceRef },
+      ],
+      confidence: "high",
+      support: [
+        {
+          location,
+          role: "call-site-specialized Compose surface ownership",
+        },
+      ],
+      data: {
+        bindingKind: "surface",
+        hostKey: hostRef,
+        contentKeys: [instanceRef],
+      },
+      relatedFactRefs: [hostRef, instanceRef],
+    });
+    const naming = callSiteNaming(index, call, "__surface", true);
+    if (naming.visibleText) {
+      state.builder.addFact("ui-property", {
+        identity: [
+          { kind: "component", value: instanceRef },
+          { kind: "semantic-key", value: "title" },
+        ],
+        confidence: "high",
+        support: [
+          {
+            location,
+            role: "statically resolved call-site surface title",
+          },
+        ],
+        data: {
+          ownerKey: instanceRef,
+          property: "title",
+          value: naming.visibleText,
+        },
+        relatedFactRefs: [instanceRef],
+      });
+    } else {
+      for (const property of properties) {
+        if (property.data.ownerKey !== templateRef) continue;
+        state.builder.addFact("ui-property", {
+          identity: [
+            { kind: "component", value: instanceRef },
+            { kind: "semantic-key", value: property.data.property },
+          ],
+          confidence: property.confidence,
+          support: [
+            {
+              location,
+              role: "call-site-specialized Compose surface property",
+            },
+          ],
+          data: { ...property.data, ownerKey: instanceRef },
+          relatedFactRefs: [instanceRef],
+        });
+      }
+    }
+    for (const condition of conditions) {
+      if (condition.data.ownerKey !== templateRef) continue;
+      state.builder.addFact("condition", {
+        identity: [
+          { kind: "component", value: instanceRef },
+          { kind: "semantic-key", value: condition.data.expressionAnchor },
+        ],
+        confidence: condition.confidence,
+        support: [
+          {
+            location,
+            role: "structured condition guarding exact local @Composable surface invocation",
+          },
+        ],
+        data: { ...condition.data, ownerKey: instanceRef },
+        relatedFactRefs: [instanceRef],
+      });
+    }
+    if (directGuard) {
+      const guardLocation =
+        recordLocation(
+          directGuard.condition,
+          `compose-call-site-surface-condition:${call.id}`,
+          target.signature,
+        ) ?? location;
+      state.builder.addFact("condition", {
+        identity: [
+          { kind: "component", value: instanceRef },
+          { kind: "semantic-key", value: directGuard.expression },
+        ],
+        confidence: "high",
+        support: [
+          {
+            location: guardLocation,
+            role: "direct positive boolean guard at exact surface invocation",
+          },
+        ],
+        data: {
+          ownerKey: instanceRef,
+          expressionAnchor: directGuard.expression,
+          plainLanguage: `满足条件：${directGuard.expression}`,
+          valueKind: "runtime",
+        },
+        relatedFactRefs: [instanceRef],
+      });
+      state.registerConditionalSurfaceState(
+        directGuard.stateSymbol,
+        instanceRef,
+        "boolean-true",
+      );
+    }
+    for (const [
+      stateSymbol,
+      surfaces,
+    ] of state.conditionalSurfacesByStateSymbol) {
+      const activation = surfaces.get(templateRef);
+      if (activation) {
+        state.registerConditionalSurfaceState(
+          stateSymbol,
+          instanceRef,
+          activation,
+        );
+      }
+    }
+    instances.set(templateRef, instanceRef);
+  }
+  return instances;
+}
+function reachesAny(adjacency, root, targets) {
+  const stateKey = (state) =>
+    [state.callbackKey, state.callSiteStack.join("\u0000")].join("\u0001");
+  const initial = {
+    callbackKey: root,
+    callbackPath: [root],
+    callSiteStack: [],
+  };
+  const visited = new Set([stateKey(initial)]);
+  const pending = [initial];
+  while (pending.length > 0) {
+    const current = pending.shift();
+    if (targets.has(current.callbackKey)) return true;
+    const steps = adjacency.get(current.callbackKey) ?? [];
+    const reverseArgumentCandidateCount = new Set(
+      steps.filter(isCallSiteArgumentStep).map((step) => step.callbackKey),
+    ).size;
+    for (const step of steps) {
+      if (current.callbackPath.includes(step.callbackKey)) continue;
+      const transition = advanceCallSiteStack(
+        current.callSiteStack,
+        step,
+        reverseArgumentCandidateCount,
+      );
+      if (!transition.accepted) continue;
+      const next = {
+        callbackKey: step.callbackKey,
+        callbackPath: [...current.callbackPath, step.callbackKey],
+        callSiteStack: transition.callSiteStack,
+      };
+      const key = stateKey(next);
+      if (visited.has(key)) continue;
+      visited.add(key);
+      pending.push(next);
+    }
+  }
+  return false;
+}
+function formalCallbacks(callbacks, target, parameter) {
+  const symbols = new Set([
+    `${target.qualifiedName}#parameter:${parameter}`,
+    `${target.signature}#parameter:${parameter}`,
+  ]);
+  return new Set(
+    callbacks.flatMap((callback) =>
+      callback.data.parameterName === parameter &&
+      symbols.has(callback.data.callableSymbol)
+        ? [callback.id]
+        : [],
+    ),
+  );
+}
+function hasFunctionalFormalParameter(target) {
+  const parameters = Array.isArray(target.record.data.parameters)
+    ? target.record.data.parameters
+    : [];
+  return parameters.some((value) => {
+    const parameter = object(value);
+    const type = typeof parameter?.type === "string" ? parameter.type : "";
+    return /(?:kotlin\.jvm\.functions\.Function|->|java\.util\.function\.)/u.test(
+      type,
+    );
+  });
+}
+function enclosingComposableForCall(index, call) {
+  const visited = new Set();
+  let current = text(call, "enclosingCallableRef");
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const method = index.methodsByCallable.get(current);
+    if (method) return method;
+    current = index.callableParent.get(current);
+  }
+  return undefined;
+}
+/**
+ * A self-contained reusable Composable can own an internal action without an
+ * `onX` formal parameter (for example, an icon that reads shared state and
+ * opens a drawer). When that declaration is invoked from several pages, its
+ * declaration component has several parents and cannot itself be assigned to
+ * one Area. Clone only statically named, directly-owned action controls onto
+ * each exact caller. Reusing the internal callback is correct because its
+ * implementation and effect are declaration-invariant; the call record is
+ * used solely to prove the visual owner for each instance.
+ */
+function specializeSelfContainedReusableControls(
+  state,
+  index,
+  inlineVisibilityGuards,
+) {
+  const elements = state.builder
+    .facts("ui-element")
+    .filter((fact) => fact.kind === "ui-element");
+  const interactions = state.builder
+    .facts("interaction-binding")
+    .filter((fact) => fact.kind === "interaction-binding");
+  const properties = state.builder
+    .facts("ui-property")
+    .filter((fact) => fact.kind === "ui-property");
+  const conditions = state.builder
+    .facts("condition")
+    .filter((fact) => fact.kind === "condition");
+  const callsByTarget = new Map();
+  for (const call of index.calls) {
+    const target = targetForCall(index, call);
+    if (!target || hasFunctionalFormalParameter(target)) continue;
+    const entry = callsByTarget.get(target.componentRef) ?? {
+      target,
+      calls: [],
+    };
+    entry.calls.push(call);
+    callsByTarget.set(target.componentRef, entry);
+  }
+  for (const { target, calls } of callsByTarget.values()) {
+    if (calls.length < 2) continue;
+    const templates = elements.filter(
+      (element) =>
+        element.data.ownerKey === target.componentRef &&
+        element.data.actionable &&
+        element.data.analysisRole !== "call-site-instance" &&
+        Boolean(
+          element.data.visibleText ??
+          element.data.contentDescription ??
+          element.data.associatedLabel,
+        ) &&
+        interactions.some(
+          (interaction) => interaction.data.elementKey === element.id,
+        ),
+    );
+    for (const template of templates) {
+      const templateInteractions = interactions.filter(
+        (interaction) => interaction.data.elementKey === template.id,
+      );
+      for (const call of calls) {
+        const caller = enclosingComposableForCall(index, call);
+        const location = recordLocation(
+          call,
+          `compose-self-contained-call-site:${target.signature}:${call.id}`,
+          target.signature,
+        );
+        if (
+          !caller ||
+          caller.componentRef === target.componentRef ||
+          !location
+        ) {
+          continue;
+        }
+        const elementRef = state.builder.addFact("ui-element", {
+          identity: [
+            { kind: "component", value: caller.componentRef },
+            { kind: "symbol", value: target.signature },
+            {
+              kind: "control",
+              value: `self-contained-call-site:${call.id}:${template.id}`,
+            },
+          ],
+          confidence: template.confidence,
+          support: [
+            {
+              location,
+              role: "exact invocation of a self-contained reusable Composable",
+            },
+          ],
+          data: {
+            ...template.data,
+            ownerKey: caller.componentRef,
+            analysisRole: "call-site-instance",
+          },
+          relatedFactRefs: [
+            caller.componentRef,
+            ...templateInteractions.map(
+              (interaction) => interaction.data.callbackKey,
+            ),
+          ],
+        });
+        state.uiOwnerById.set(elementRef, caller.componentRef);
+        copyTemplateSemantics(
+          state,
+          template.id,
+          elementRef,
+          properties,
+          conditions,
+          location,
+        );
+        for (const guard of callSiteVisibilityGuards(
+          index,
+          call,
+          inlineVisibilityGuards,
+        )) {
+          const guardLocation =
+            recordLocation(
+              guard.condition,
+              `compose-self-contained-visibility:${guard.expressionAnchor}`,
+              target.signature,
+            ) ?? location;
+          state.builder.addFact("condition", {
+            identity: [
+              { kind: "control", value: elementRef },
+              { kind: "semantic-key", value: "visibility" },
+              { kind: "semantic-key", value: guard.expressionAnchor },
+            ],
+            confidence: "high",
+            support: [
+              {
+                location: guardLocation,
+                role: "structured call-site visibility guard",
+              },
+            ],
+            data: {
+              ownerKey: elementRef,
+              expressionAnchor: guard.expressionAnchor,
+              plainLanguage: guard.plainLanguage,
+              valueKind: "runtime",
+              conditionRole: "visibility",
+              pathRequirement: "runtime-availability",
+            },
+            relatedFactRefs: [elementRef],
+          });
+        }
+        for (const interaction of templateInteractions) {
+          state.builder.addFact("interaction-binding", {
+            identity: [
+              { kind: "control", value: elementRef },
+              { kind: "callback", value: interaction.data.callbackKey },
+              { kind: "semantic-key", value: interaction.data.trigger },
+            ],
+            confidence: interaction.confidence,
+            support: [
+              {
+                location,
+                role: "self-contained call-site Compose interaction",
+              },
+            ],
+            data: {
+              ...interaction.data,
+              elementKey: elementRef,
+            },
+            relatedFactRefs: [elementRef, interaction.data.callbackKey],
+          });
+        }
+      }
+      state.builder.mergeFactData("ui-element", template.id, {
+        analysisRole: "declaration-template",
+      });
+    }
+  }
+}
+/**
+ * Materializes one product control per exact invocation of a reusable local
+ * Composable. A declaration-level control is converted to a provenance-only
+ * template only after an actual callback and a proven implementation path to
+ * the matching formal callback both exist.
+ */
+export function normalizeComposeCallSiteFacts(android, jvm, state) {
+  if (!jvm) return;
+  const index = buildIndex(android, jvm, state);
+  const repeatedCallSites = dynamicRepeatedCallSiteContexts(jvm);
+  const inlineVisibilityGuards = animatedVisibilityGuardsByCall(index);
+  specializeSelfContainedReusableControls(state, index, inlineVisibilityGuards);
+  const callbacks = state.builder
+    .facts("callback")
+    .filter((fact) => fact.kind === "callback");
+  const flows = state.builder
+    .facts("callback-flow")
+    .filter((fact) => fact.kind === "callback-flow");
+  const surfaceTypes = new Set([
+    "dialog",
+    "drawer",
+    "bottom-sheet",
+    "overlay",
+    "popup",
+    "inline-detail-surface",
+  ]);
+  const specializedSurfaceTemplates = new Set();
+  const adjacency = executionAdjacency(flows, index, callbacks, state);
+  // Pass 1 materializes reusable child controls inside declaration-level
+  // surfaces. Pass 2 can then clone that exact child set when the reusable
+  // surface itself is invoked. Stable fact identities make the ordinary
+  // controls observed in both passes idempotent.
+  for (let pass = 0; pass < 2; pass += 1) {
+    const uiElements = state.builder
+      .facts("ui-element")
+      .filter((fact) => fact.kind === "ui-element");
+    const interactions = state.builder
+      .facts("interaction-binding")
+      .filter((fact) => fact.kind === "interaction-binding");
+    const properties = state.builder
+      .facts("ui-property")
+      .filter((fact) => fact.kind === "ui-property");
+    const conditions = state.builder
+      .facts("condition")
+      .filter((fact) => fact.kind === "condition");
+    const uiById = new Map(uiElements.map((fact) => [fact.id, fact]));
+    const componentById = new Map(
+      state.builder
+        .facts("component")
+        .filter((fact) => fact.kind === "component")
+        .map((fact) => [fact.id, fact]),
+    );
+    const surfaceHostByComponent = new Map();
+    for (const binding of state.builder
+      .facts("container-binding")
+      .filter((fact) => fact.kind === "container-binding")) {
+      if (binding.data.bindingKind !== "surface") continue;
+      for (const contentRef of binding.data.contentKeys) {
+        surfaceHostByComponent.set(contentRef, binding.data.hostKey);
+      }
+    }
+    for (const call of index.calls) {
+      if (scopeIsWithinPreview(index, text(call, "enclosingCallableRef")))
+        continue;
+      const target = targetForCall(index, call);
+      if (!target) continue;
+      const repeatedCallSite = repeatedCallSites.get(call.id);
+      if (repeatedCallSite?.population === "impossible") continue;
+      const location = recordLocation(
+        call,
+        `compose-call-site-control:${target.signature}:${call.id}`,
+        target.signature,
+      );
+      if (!location) continue;
+      const components = reachableComponents(index, target);
+      const actions = [];
+      for (const actualBinding of bindingsFor(index, call.id)) {
+        const name = parameterName(actualBinding);
+        if (!name || !/^on[A-Z][A-Za-z0-9]*$/u.test(name)) continue;
+        const actualCallback = concreteCallback(state, index, actualBinding);
+        if (!actualCallback) continue;
+        const actualFact = state.builder.fact(actualCallback);
+        if (!actualFact || actualFact.kind !== "callback") continue;
+        const formals = formalCallbacks(callbacks, target, name);
+        if (formals.size === 0) continue;
+        const matchingTemplates = interactions.filter((interaction) => {
+          const element = uiById.get(interaction.data.elementKey);
+          const surfaceHost = element
+            ? surfaceHostByComponent.get(element.data.ownerKey)
+            : undefined;
+          const elementOwner = element
+            ? componentById.get(element.data.ownerKey)
+            : undefined;
+          const elementIsSurfaceOwned =
+            elementOwner !== undefined &&
+            surfaceTypes.has(elementOwner.data.componentType);
+          const directlyOwnedSurfaceControl =
+            elementIsSurfaceOwned && surfaceHost === target.componentRef;
+          const eligibleTemplate =
+            element !== undefined &&
+            (element.data.analysisRole === "call-site-instance"
+              ? // Pass 2 may use a child control materialized inside this exact
+                // reusable surface, but never a final instance from its caller.
+                directlyOwnedSurfaceControl
+              : directlyOwnedSurfaceControl ||
+                (!elementIsSurfaceOwned &&
+                  components.has(element.data.ownerKey)));
+          return (
+            eligibleTemplate &&
+            reachesAny(adjacency, interaction.data.callbackKey, formals)
+          );
+        });
+        const directSurfaceTemplates = matchingTemplates.filter(
+          (interaction) => {
+            const element = uiById.get(interaction.data.elementKey);
+            return (
+              element !== undefined &&
+              surfaceTypes.has(
+                componentById.get(element.data.ownerKey)?.data.componentType ??
+                  "other",
+              ) &&
+              surfaceHostByComponent.get(element.data.ownerKey) ===
+                target.componentRef
+            );
+          },
+        );
+        // Once exact children have been materialized within the surface, the
+        // lower-level declaration controls are only implementation templates.
+        const templates =
+          directSurfaceTemplates.length > 0
+            ? directSurfaceTemplates
+            : matchingTemplates;
+        actions.push(
+          ...templates.map((templateBinding) => {
+            const template = uiById.get(templateBinding.data.elementKey);
+            const templateOwner = componentById.get(template.data.ownerKey);
+            const surfaceTemplateRef =
+              templateOwner &&
+              surfaceTypes.has(templateOwner.data.componentType)
+                ? template.data.ownerKey
+                : undefined;
+            const instanceOwnerRef =
+              surfaceTemplateRef ?? actualFact.data.ownerKey;
+            return {
+              parameterName: name,
+              actualCallback,
+              actualFact,
+              instanceOwnerRef,
+              ...(surfaceTemplateRef ? { surfaceTemplateRef } : {}),
+              templateBinding,
+              template,
+            };
+          }),
+        );
+      }
+      const mostSpecificActions = actions.filter(
+        (action) =>
+          action.surfaceTemplateRef !== undefined ||
+          !hasMoreSpecificFiniteInvocation(
+            index,
+            target,
+            action.template.data.ownerKey,
+          ),
+      );
+      /*
+       * A callback parameter is an event slot, not a control identity. Group
+       * every event that reaches the same declaration-level UI element before
+       * materialising the call-site instance. Distinct template elements stay
+       * distinct even when they share one callback; one combinedClickable or
+       * slider stays one element even when it exposes multiple event slots.
+       */
+      const surfaceInstances = specializeCallSiteSurfaces(
+        state,
+        index,
+        call,
+        target,
+        mostSpecificActions,
+        new Set(
+          [...surfaceHostByComponent]
+            .filter(([, hostRef]) => hostRef === target.componentRef)
+            .map(([surfaceRef]) => surfaceRef),
+        ).size,
+        componentById,
+        properties,
+        conditions,
+        location,
+      );
+      const materializedActions = mostSpecificActions.map((action) => ({
+        ...action,
+        instanceOwnerRef: action.surfaceTemplateRef
+          ? (surfaceInstances.get(action.surfaceTemplateRef) ??
+            action.instanceOwnerRef)
+          : action.instanceOwnerRef,
+      }));
+      for (const templateRef of surfaceInstances.keys()) {
+        specializedSurfaceTemplates.add(templateRef);
+      }
+      const groupedActions = new Map();
+      for (const action of materializedActions) {
+        const key = `${action.instanceOwnerRef}\u0000${action.template.id}`;
+        const grouped = groupedActions.get(key) ?? [];
+        grouped.push(action);
+        groupedActions.set(key, grouped);
+      }
+      const groups = [...groupedActions.values()].sort(
+        (left, right) =>
+          left[0].template.id.localeCompare(right[0].template.id, "en") ||
+          left[0].instanceOwnerRef.localeCompare(
+            right[0].instanceOwnerRef,
+            "en",
+          ),
+      );
+      const ordinaryLabelIsSafe = groups.length === 1;
+      for (const group of groups) {
+        const { actualFact, instanceOwnerRef, template } = group[0];
+        const fallbackNaming =
+          group.length === 1
+            ? callSiteNaming(
+                index,
+                call,
+                group[0].parameterName,
+                ordinaryLabelIsSafe,
+              )
+            : ordinaryLabelIsSafe
+              ? callSiteNaming(index, call, "__sharedControl", true)
+              : { support: [] };
+        const finiteVariants =
+          group.length === 1
+            ? finiteCallSiteNamingVariants(index, call)
+            : undefined;
+        const namingVariants = finiteVariants ?? [fallbackNaming];
+        for (const [variantIndex, naming] of namingVariants.entries()) {
+          const instanceVisibleText =
+            naming.visibleText ?? template.data.visibleText;
+          const instanceContentDescription =
+            naming.contentDescription ?? template.data.contentDescription;
+          const instanceAssociatedLabel =
+            naming.associatedLabel ?? template.data.associatedLabel;
+          const semanticName =
+            instanceVisibleText ??
+            instanceContentDescription ??
+            instanceAssociatedLabel;
+          const elementRef = state.builder.addFact("ui-element", {
+            identity: [
+              { kind: "component", value: instanceOwnerRef },
+              { kind: "symbol", value: target.signature },
+              {
+                kind: "control",
+                value:
+                  `call-site:${call.id}:${template.id}` +
+                  (namingVariants.length > 1
+                    ? `:finite:${variantIndex}:${instanceVisibleText ?? ""}`
+                    : ""),
+              },
+            ],
+            confidence: semanticName ? "high" : template.confidence,
+            support: [
+              {
+                location,
+                role: "exact local @Composable control invocation",
+              },
+              ...naming.support.flatMap((record) => {
+                const supportLocation = recordLocation(
+                  record,
+                  `compose-call-site-label:${record.id}`,
+                  target.signature,
+                );
+                return supportLocation
+                  ? [
+                      {
+                        location: supportLocation,
+                        role: "statically resolved call-site naming argument",
+                      },
+                    ]
+                  : [];
+              }),
+              ...(repeatedCallSite?.support ?? []).flatMap((record) => {
+                const repeatedLocation = recordLocation(
+                  record,
+                  `compose-call-site-repeated:${record.id}`,
+                  target.signature,
+                );
+                return repeatedLocation
+                  ? [
+                      {
+                        location: repeatedLocation,
+                        role: "resolved Kotlin collection iteration provenance",
+                      },
+                    ]
+                  : [];
+              }),
+            ],
+            data: {
+              ownerKey: instanceOwnerRef,
+              elementType: repeatedCallSite
+                ? "list-item"
+                : template.data.elementType,
+              actionable: template.data.actionable,
+              analysisRole: "call-site-instance",
+              ...(template.data.resourceId
+                ? { resourceId: template.data.resourceId }
+                : {}),
+              ...(template.data.symbol ? { symbol: template.data.symbol } : {}),
+              ...(instanceVisibleText
+                ? { visibleText: instanceVisibleText }
+                : {}),
+              ...(instanceContentDescription
+                ? { contentDescription: instanceContentDescription }
+                : {}),
+              ...(instanceAssociatedLabel
+                ? { associatedLabel: instanceAssociatedLabel }
+                : {}),
+              ...(template.data.iconResource
+                ? { iconResource: template.data.iconResource }
+                : {}),
+              ...(!semanticName && template.data.dynamicIdentity
+                ? { dynamicIdentity: template.data.dynamicIdentity }
+                : {}),
+            },
+            relatedFactRefs: [
+              instanceOwnerRef,
+              ...new Set(group.map((action) => action.actualCallback)),
+            ],
+          });
+          state.uiOwnerById.set(elementRef, instanceOwnerRef);
+          copyTemplateSemantics(
+            state,
+            template.id,
+            elementRef,
+            properties,
+            conditions,
+            location,
+          );
+          for (const guard of callSiteVisibilityGuards(
+            index,
+            call,
+            inlineVisibilityGuards,
+          )) {
+            if (
+              state.builder
+                .facts("condition")
+                .some(
+                  (condition) =>
+                    condition.kind === "condition" &&
+                    condition.data.ownerKey === elementRef &&
+                    condition.data.conditionRole === "visibility" &&
+                    condition.data.expressionAnchor === guard.expressionAnchor,
+                )
+            )
+              continue;
+            const guardLocation =
+              recordLocation(
+                guard.condition,
+                `compose-call-site-control-visibility:${guard.expressionAnchor}`,
+                target.signature,
+              ) ?? location;
+            state.builder.addFact("condition", {
+              identity: [
+                { kind: "control", value: elementRef },
+                { kind: "semantic-key", value: "visibility" },
+                { kind: "semantic-key", value: guard.expressionAnchor },
+              ],
+              confidence: "high",
+              support: [
+                {
+                  location: guardLocation,
+                  role: "structured branch guarding exact local @Composable control invocation",
+                },
+              ],
+              data: {
+                ownerKey: elementRef,
+                expressionAnchor: guard.expressionAnchor,
+                plainLanguage: guard.plainLanguage,
+                valueKind: "runtime",
+                conditionRole: "visibility",
+              },
+              relatedFactRefs: [elementRef],
+            });
+          }
+          for (const availability of repeatedCallSite?.availabilities ?? []) {
+            const availabilityLocation =
+              recordLocation(
+                availability.record,
+                `compose-call-site-runtime-availability:` +
+                  availability.expressionAnchor,
+                target.signature,
+              ) ?? location;
+            state.builder.addFact("condition", {
+              identity: [
+                { kind: "control", value: elementRef },
+                { kind: "semantic-key", value: "visibility" },
+                {
+                  kind: "semantic-key",
+                  value: availability.expressionAnchor,
+                },
+              ],
+              confidence: "high",
+              support: [
+                {
+                  location: availabilityLocation,
+                  role: "resolved runtime collection-item availability",
+                },
+              ],
+              data: {
+                ownerKey: elementRef,
+                expressionAnchor: availability.expressionAnchor,
+                plainLanguage: availability.plainLanguage,
+                valueKind: "runtime",
+                conditionRole: "visibility",
+                pathRequirement: "runtime-availability",
+              },
+              relatedFactRefs: [elementRef],
+            });
+          }
+          for (const action of group) {
+            state.builder.addFact("interaction-binding", {
+              identity: [
+                { kind: "control", value: elementRef },
+                { kind: "callback", value: action.actualCallback },
+                {
+                  kind: "semantic-key",
+                  value: action.templateBinding.data.trigger,
+                },
+              ],
+              confidence: action.templateBinding.confidence,
+              support: [
+                {
+                  location,
+                  role: "call-site-specialized Compose interaction",
+                },
+              ],
+              data: {
+                elementKey: elementRef,
+                callbackKey: action.actualCallback,
+                trigger: action.templateBinding.data.trigger,
+                bindingApi: action.templateBinding.data.bindingApi,
+              },
+              relatedFactRefs: [elementRef, action.actualCallback],
+            });
+          }
+          state.builder.mergeFactData("ui-element", template.id, {
+            analysisRole: "declaration-template",
+          });
+          state.builder.removeUnresolvedOwnedBy(
+            template.id,
+            new Set([
+              "INTRINSIC_CONTROL_NAME_UNKNOWN",
+              "INTRINSIC_COMPOSE_CONTROL_NAME_UNKNOWN",
+            ]),
+          );
+        }
+      }
+    }
+  }
+  for (const surfaces of state.conditionalSurfacesByStateSymbol.values()) {
+    for (const templateRef of specializedSurfaceTemplates) {
+      surfaces.delete(templateRef);
+    }
+  }
+}