android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/route-state-variants.js

@@ -0,0 +1,781 @@
+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 objectText(value, key) {
+  const item = value?.[key];
+  return typeof item === "string" && item.trim().length > 0
+    ? item.trim()
+    : undefined;
+}
+function number(record, key) {
+  const value = record.data[key];
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+function expression(binding) {
+  return object(binding.data.expression);
+}
+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 append(map, key, record) {
+  const values = map.get(key) ?? [];
+  values.push(record);
+  map.set(key, values);
+}
+function sourceApiName(record) {
+  return (text(record, "targetName") ?? "").replace(/-.*$/u, "");
+}
+function methodKey(owner, name) {
+  return `${owner}\u0000${name}`;
+}
+function buildIndex(jvm) {
+  const recordsById = new Map();
+  const calls = [];
+  const bindings = [];
+  const mutableBindingsByCall = new Map();
+  const callablesById = new Map();
+  const callableParent = new Map();
+  const methodsBySignature = new Map();
+  const mutableMethodsByOwnerAndName = 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") {
+      bindings.push(record);
+      const callRef = text(record, "callRef");
+      if (callRef) append(mutableBindingsByCall, callRef, record);
+    }
+    if (
+      record.kind === "method-declaration" ||
+      record.kind === "lambda-declaration"
+    ) {
+      callablesById.set(record.id, record);
+      const parent = text(record, "enclosingCallableRef");
+      if (parent) callableParent.set(record.id, parent);
+    }
+    if (record.kind === "method-declaration") {
+      const signature = text(record, "signature");
+      const owner = text(record, "ownerQualifiedName");
+      const name = text(record, "name");
+      if (signature) methodsBySignature.set(signature, record);
+      if (owner && name) {
+        append(mutableMethodsByOwnerAndName, methodKey(owner, name), record);
+      }
+    }
+  }
+  return {
+    recordsById,
+    calls: calls.sort((left, right) => left.id.localeCompare(right.id, "en")),
+    bindings,
+    bindingsByCall: new Map(
+      [...mutableBindingsByCall].map(([key, values]) => [
+        key,
+        values.sort(
+          (left, right) =>
+            (number(left, "argumentIndex") ?? Number.MAX_SAFE_INTEGER) -
+              (number(right, "argumentIndex") ?? Number.MAX_SAFE_INTEGER) ||
+            left.id.localeCompare(right.id, "en"),
+        ),
+      ]),
+    ),
+    callablesById,
+    callableParent,
+    methodsBySignature,
+    methodsByOwnerAndName: new Map(
+      [...mutableMethodsByOwnerAndName].map(([key, values]) => [
+        key,
+        values.sort((left, right) => left.id.localeCompare(right.id, "en")),
+      ]),
+    ),
+  };
+}
+function bindingsFor(index, callRef) {
+  return index.bindingsByCall.get(callRef) ?? [];
+}
+function parameterName(binding) {
+  return (
+    text(binding, "parameterName") ??
+    objectText(expression(binding), "namedArgument")
+  );
+}
+function bindingForParameter(index, callRef, name) {
+  return bindingsFor(index, callRef).find(
+    (binding) => parameterName(binding) === name,
+  );
+}
+function callableWithin(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;
+}
+function targetMethod(index, call) {
+  const signature = text(call, "targetSignature");
+  const exact = signature ? index.methodsBySignature.get(signature) : undefined;
+  if (exact) return exact;
+  const owner = text(call, "targetOwnerQualifiedName");
+  const name = sourceApiName(call);
+  if (!owner || !name) return undefined;
+  const candidates =
+    index.methodsByOwnerAndName.get(methodKey(owner, name)) ?? [];
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function methodParameters(method) {
+  const raw = method.data.parameters;
+  return Array.isArray(raw)
+    ? raw.flatMap((candidate, index) => {
+        const item = object(candidate);
+        const name = objectText(item, "name");
+        const type = objectText(item, "type");
+        return name && type ? [{ name, type, index }] : [];
+      })
+    : [];
+}
+function normalizedType(value) {
+  return (value ?? "")
+    .replace(/[?!]+$/gu, "")
+    .replace(/^java\.lang\./u, "")
+    .replace(/^kotlin\./u, "")
+    .toLowerCase();
+}
+function normalizedStateName(value) {
+  return value.replace(/[^a-z0-9]/giu, "").toLowerCase();
+}
+function staticScalar(summary) {
+  if (!summary || !Object.hasOwn(summary, "constantValue")) {
+    return { present: false };
+  }
+  const value = summary.constantValue;
+  return value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean" ||
+    (typeof value === "number" && Number.isFinite(value))
+    ? { present: true, value: value }
+    : { present: false };
+}
+function resolvedSymbol(summary) {
+  return object(summary?.resolvedSymbol);
+}
+function routeSubjectCandidates(summary, depth = 0) {
+  if (!summary || depth > 16) return [];
+  const symbol = resolvedSymbol(summary);
+  const qualifiedName = objectText(symbol, "qualifiedName");
+  const direct =
+    objectText(symbol, "kind") === "class" && qualifiedName
+      ? [{ value: qualifiedName, depth }]
+      : [];
+  return [
+    ...direct,
+    ...routeSubjectCandidates(object(summary.receiverExpression), depth + 1),
+    ...routeSubjectCandidates(object(summary.selectorExpression), depth + 1),
+  ];
+}
+function destinationForRouteBinding(state, binding) {
+  const subjects = routeSubjectCandidates(expression(binding)).sort(
+    (left, right) =>
+      right.depth - left.depth || right.value.length - left.value.length,
+  );
+  for (const { value } of subjects) {
+    const matches = state.builder.facts("component").flatMap((fact) => {
+      if (
+        fact.kind !== "component" ||
+        fact.data.componentType !== "compose-destination" ||
+        !fact.data.qualifiedName.includes("#route-symbol:")
+      )
+        return [];
+      const encoded = fact.data.qualifiedName.slice(
+        fact.data.qualifiedName.lastIndexOf("#route-symbol:") +
+          "#route-symbol:".length,
+      );
+      let identity;
+      try {
+        identity = decodeURIComponent(encoded);
+      } catch {
+        return [];
+      }
+      return identity.includes(value) ? [fact.id] : [];
+    });
+    if (matches.length === 1) {
+      return { destinationRef: matches[0], routeSubject: value };
+    }
+  }
+  return undefined;
+}
+function bundleGetterType(call) {
+  const owner = text(call, "targetOwnerQualifiedName") ?? "";
+  if (!/(?:^|\.)(?:BaseBundle|Bundle)$/u.test(owner)) return undefined;
+  switch (sourceApiName(call)) {
+    case "getBoolean":
+      return "boolean";
+    case "getInt":
+    case "getLong":
+    case "getFloat":
+    case "getDouble":
+      return "number";
+    case "getString":
+      return "string";
+    default:
+      return undefined;
+  }
+}
+function bundleGetterKey(index, call) {
+  const binding =
+    bindingForParameter(index, call.id, "key") ??
+    bindingsFor(index, call.id)[0];
+  const scalar = binding
+    ? staticScalar(expression(binding))
+    : { present: false };
+  return scalar.present && typeof scalar.value === "string"
+    ? scalar.value
+    : undefined;
+}
+function expressionType(summary) {
+  const raw =
+    objectText(summary, "expressionType") ??
+    objectText(resolvedSymbol(summary), "type");
+  const normalized = normalizedType(raw);
+  if (normalized === "boolean") return "boolean";
+  if (["byte", "short", "int", "long", "float", "double"].includes(normalized))
+    return "number";
+  if (normalized === "string") return "string";
+  return normalized;
+}
+function slotForDestinationGetter(index, contentCallableRef, getter) {
+  const getterType = bundleGetterType(getter);
+  if (!getterType) return undefined;
+  const getterCount = index.calls.filter(
+    (call) =>
+      callableWithin(
+        index,
+        text(call, "enclosingCallableRef"),
+        contentCallableRef,
+      ) && bundleGetterType(call) === getterType,
+  ).length;
+  if (getterCount !== 1) return undefined;
+  const candidates = index.calls.flatMap((call) => {
+    if (
+      !callableWithin(
+        index,
+        text(call, "enclosingCallableRef"),
+        contentCallableRef,
+      )
+    )
+      return [];
+    const method = targetMethod(index, call);
+    if (!method || method.data.composable !== true) return [];
+    return bindingsFor(index, call.id).flatMap((binding) => {
+      const summary = expression(binding);
+      const symbol = resolvedSymbol(summary);
+      if (
+        objectText(symbol, "kind") !== "variable" ||
+        expressionType(summary) !== getterType
+      )
+        return [];
+      const name = parameterName(binding);
+      const parameter = methodParameters(method).find(
+        (candidate) =>
+          candidate.name === name ||
+          candidate.index === number(binding, "parameterIndex"),
+      );
+      return parameter
+        ? [{ method, name: parameter.name, type: parameter.type }]
+        : [];
+    });
+  });
+  const unique = new Map(
+    candidates.map((slot) => [`${slot.method.id}\u0000${slot.name}`, slot]),
+  );
+  return unique.size === 1 ? [...unique.values()][0] : undefined;
+}
+function expressionIsSlot(summary, slot) {
+  const symbol = resolvedSymbol(summary);
+  return (
+    objectText(symbol, "kind") === "parameter" &&
+    objectText(symbol, "name") === slot.name &&
+    normalizedType(objectText(symbol, "type")) === normalizedType(slot.type)
+  );
+}
+function propagatedSlots(index, initial) {
+  const result = new Map();
+  const queue = [initial];
+  for (let cursor = 0; cursor < queue.length && cursor < 128; cursor += 1) {
+    const slot = queue[cursor];
+    const slotKey = `${slot.method.id}\u0000${slot.name}`;
+    if (result.has(slotKey)) continue;
+    result.set(slotKey, slot);
+    for (const call of index.calls) {
+      if (
+        !callableWithin(
+          index,
+          text(call, "enclosingCallableRef"),
+          slot.method.id,
+        )
+      )
+        continue;
+      const target = targetMethod(index, call);
+      if (!target) continue;
+      for (const binding of bindingsFor(index, call.id)) {
+        if (!expressionIsSlot(expression(binding), slot)) continue;
+        const boundName = parameterName(binding);
+        const parameter = methodParameters(target).find(
+          (candidate) =>
+            candidate.name === boundName ||
+            candidate.index === number(binding, "parameterIndex"),
+        );
+        if (parameter) {
+          queue.push({
+            method: target,
+            name: parameter.name,
+            type: parameter.type,
+          });
+        }
+      }
+    }
+  }
+  return [...result.values()];
+}
+function conditionSlot(index, condition, slots) {
+  const structure = object(condition.data.expressionStructure);
+  return slots.find(
+    (slot) =>
+      callableWithin(
+        index,
+        text(condition, "enclosingCallableRef"),
+        slot.method.id,
+      ) && expressionIsSlot(structure, slot),
+  );
+}
+function conditionPolarity(call, conditionRef) {
+  const contexts = call.data.conditionContexts;
+  if (!Array.isArray(contexts)) return undefined;
+  for (const raw of contexts) {
+    const context = object(raw);
+    if (context?.conditionRef !== conditionRef) continue;
+    if (context.polarity === "true") return true;
+    if (context.polarity === "false") return false;
+  }
+  return undefined;
+}
+function visibleBranchCalls(index, condition, polarity) {
+  return index.calls.filter((call) => {
+    if (conditionPolarity(call, condition.id) !== polarity) return false;
+    const target = targetMethod(index, call);
+    return (
+      target?.data.composable === true ||
+      (text(call, "targetSignature") ?? "").includes(
+        "androidx.compose.runtime.Composer",
+      )
+    );
+  });
+}
+function materiallyDifferentBranches(left, right) {
+  if (left.length === 0 || right.length === 0) return false;
+  const semanticCalls = (values) =>
+    new Set(
+      values.map(
+        (call) =>
+          `${text(call, "targetOwnerQualifiedName") ?? ""}#${sourceApiName(call)}`,
+      ),
+    );
+  const a = semanticCalls(left);
+  const b = semanticCalls(right);
+  return (
+    [...a].some((value) => !b.has(value)) ||
+    [...b].some((value) => !a.has(value))
+  );
+}
+function destinationStates(index, state) {
+  const result = [];
+  for (const destinationCall of index.calls) {
+    if (
+      sourceApiName(destinationCall) !== "composable" ||
+      !(text(destinationCall, "targetOwnerQualifiedName") ?? "").startsWith(
+        "androidx.navigation.compose.",
+      )
+    )
+      continue;
+    const routeBinding =
+      bindingForParameter(index, destinationCall.id, "route") ??
+      bindingsFor(index, destinationCall.id)[0];
+    const destination = routeBinding
+      ? destinationForRouteBinding(state, routeBinding)
+      : undefined;
+    const content =
+      bindingForParameter(index, destinationCall.id, "content") ??
+      [...bindingsFor(index, destinationCall.id)]
+        .reverse()
+        .find(
+          (binding) => objectText(expression(binding), "kind") === "lambda",
+        );
+    const contentCallable = content
+      ? objectText(expression(content), "callableRef")
+      : undefined;
+    if (!destination || !contentCallable) continue;
+    const getters = index.calls.filter(
+      (call) =>
+        callableWithin(
+          index,
+          text(call, "enclosingCallableRef"),
+          contentCallable,
+        ) &&
+        bundleGetterType(call) !== undefined &&
+        bundleGetterKey(index, call) !== undefined,
+    );
+    for (const getter of getters) {
+      const initialSlot = slotForDestinationGetter(
+        index,
+        contentCallable,
+        getter,
+      );
+      if (!initialSlot) continue;
+      const slots = propagatedSlots(index, initialSlot);
+      for (const condition of index.recordsById.values()) {
+        if (condition.kind !== "condition") continue;
+        const slot = conditionSlot(index, condition, slots);
+        if (!slot) continue;
+        const trueCalls = visibleBranchCalls(index, condition, true);
+        const falseCalls = visibleBranchCalls(index, condition, false);
+        if (!materiallyDifferentBranches(trueCalls, falseCalls)) continue;
+        result.push({
+          destinationRef: destination.destinationRef,
+          routeSubject: destination.routeSubject,
+          stateKey: initialSlot.name,
+          routeKey: bundleGetterKey(index, getter),
+          getter,
+          condition,
+          conditionSlot: slot,
+          branchCalls: new Map([
+            [true, trueCalls],
+            [false, falseCalls],
+          ]),
+        });
+      }
+    }
+  }
+  const unique = new Map();
+  for (const item of result) {
+    unique.set(
+      `${item.destinationRef}\u0000${normalizedStateName(item.stateKey)}`,
+      item,
+    );
+  }
+  return [...unique.values()];
+}
+function callSitesForMethod(index, method) {
+  return index.calls.filter(
+    (call) => targetMethod(index, call)?.id === method.id,
+  );
+}
+function callableArgumentBindings(index, callableRef) {
+  return index.bindings.filter(
+    (binding) => objectText(expression(binding), "callableRef") === callableRef,
+  );
+}
+function callbackInvocationOrigins(
+  index,
+  lambdaRef,
+  parameter,
+  depth,
+  visited,
+) {
+  const result = [];
+  for (const actual of callableArgumentBindings(index, lambdaRef)) {
+    const parentRef = text(actual, "callRef");
+    const parent = parentRef ? index.recordsById.get(parentRef) : undefined;
+    const target = parent ? targetMethod(index, parent) : undefined;
+    const formal = parameterName(actual);
+    if (!parent || !target || !formal) continue;
+    for (const invocation of index.calls) {
+      if (
+        sourceApiName(invocation) !== "invoke" ||
+        !callableWithin(
+          index,
+          text(invocation, "enclosingCallableRef"),
+          target.id,
+        )
+      )
+        continue;
+      const receiver = object(invocation.data.receiverResolvedSymbol);
+      if (
+        objectText(receiver, "kind") !== "parameter" ||
+        objectText(receiver, "name") !== formal
+      )
+        continue;
+      const argument = bindingsFor(index, invocation.id)[0];
+      const callableRef = text(invocation, "enclosingCallableRef");
+      if (!argument || !callableRef) continue;
+      result.push(
+        ...resolveStaticOrigins(
+          index,
+          expression(argument),
+          invocation,
+          callableRef,
+          depth + 1,
+          visited,
+          [actual, parent, invocation, argument],
+        ),
+      );
+    }
+  }
+  return result;
+}
+function resolveStaticOrigins(
+  index,
+  summary,
+  context,
+  callableRef,
+  depth = 0,
+  visited = new Set(),
+  support = [],
+) {
+  if (!summary || depth > 16) return [];
+  const visitKey = [callableRef, context.id, JSON.stringify(summary)].join(
+    "\u0000",
+  );
+  if (visited.has(visitKey)) return [];
+  const nextVisited = new Set(visited).add(visitKey);
+  const scalar = staticScalar(summary);
+  if (scalar.present) {
+    return [
+      {
+        value: scalar.value,
+        callableRef,
+        support: [...support, context],
+      },
+    ];
+  }
+  const symbol = resolvedSymbol(summary);
+  const initializer = object(symbol?.initializer);
+  if (initializer) {
+    const initialized = resolveStaticOrigins(
+      index,
+      initializer,
+      context,
+      callableRef,
+      depth + 1,
+      nextVisited,
+      support,
+    );
+    if (initialized.length > 0) return initialized;
+  }
+  if (objectText(symbol, "kind") !== "parameter") return [];
+  const name = objectText(symbol, "name");
+  const callable = index.callablesById.get(callableRef);
+  if (!name || !callable) return [];
+  if (callable.kind === "lambda-declaration") {
+    return callbackInvocationOrigins(
+      index,
+      callableRef,
+      name,
+      depth,
+      nextVisited,
+    );
+  }
+  const parameter = methodParameters(callable).find(
+    (candidate) => candidate.name === name,
+  );
+  if (!parameter) return [];
+  return callSitesForMethod(index, callable).flatMap((call) => {
+    const actual = bindingsFor(index, call.id).find(
+      (binding) =>
+        parameterName(binding) === parameter.name ||
+        number(binding, "parameterIndex") === parameter.index,
+    );
+    const parentCallable = text(call, "enclosingCallableRef");
+    return actual && parentCallable
+      ? resolveStaticOrigins(
+          index,
+          expression(actual),
+          call,
+          parentCallable,
+          depth + 1,
+          nextVisited,
+          [...support, actual, call],
+        )
+      : [];
+  });
+}
+function routeBuilderOrigins(index, destination) {
+  const result = [];
+  for (const call of index.calls) {
+    if (text(call, "targetOwnerQualifiedName") !== destination.routeSubject) {
+      continue;
+    }
+    const method = targetMethod(index, call);
+    if (!method || normalizedType(text(method, "returnType")) !== "string") {
+      continue;
+    }
+    const parameter = methodParameters(method).find(
+      (candidate) =>
+        normalizedStateName(candidate.name) ===
+          normalizedStateName(destination.stateKey) ||
+        normalizedStateName(candidate.name) ===
+          normalizedStateName(destination.routeKey),
+    );
+    if (!parameter) continue;
+    const binding = bindingsFor(index, call.id).find(
+      (candidate) =>
+        parameterName(candidate) === parameter.name ||
+        number(candidate, "parameterIndex") === parameter.index,
+    );
+    const callableRef = text(call, "enclosingCallableRef");
+    if (!binding || !callableRef) continue;
+    result.push(
+      ...resolveStaticOrigins(
+        index,
+        expression(binding),
+        call,
+        callableRef,
+        0,
+        new Set(),
+        [method, binding, call],
+      ),
+    );
+  }
+  const unique = new Map();
+  for (const origin of result) {
+    unique.set(
+      `${JSON.stringify(origin.value)}\u0000${origin.callableRef}`,
+      origin,
+    );
+  }
+  return [...unique.values()];
+}
+function uniqueSupport(records, anchor, role) {
+  const result = [
+    ...new Map(records.map((record) => [record.id, record])).values(),
+  ].flatMap((record) => {
+    const location = recordLocation(
+      record,
+      anchor,
+      text(record, "enclosingMethod") ?? text(record, "targetSignature"),
+    );
+    return location ? [{ location, role }] : [];
+  });
+  return result.length > 0 ? result : undefined;
+}
+/**
+ * Proves finite page variants only when all of these structured facts align:
+ * a Navigation Compose destination reads one typed Bundle argument, that
+ * value reaches a composable branch with materially different UI calls, and
+ * local route-builder call chains supply at least two concrete scalar values.
+ */
+export function normalizeRouteStateVariants(jvm, state) {
+  if (!jvm) return;
+  const index = buildIndex(jvm);
+  for (const destination of destinationStates(index, state)) {
+    const origins = routeBuilderOrigins(index, destination);
+    const byValue = new Map();
+    for (const origin of origins) {
+      const callbackRef = state.callbackForRawCallable(origin.callableRef);
+      if (!callbackRef) continue;
+      const key = JSON.stringify(origin.value);
+      const values = byValue.get(key) ?? [];
+      values.push(origin);
+      byValue.set(key, values);
+    }
+    if (byValue.size < 2) continue;
+    for (const [valueKey, valueOrigins] of byValue) {
+      const value = JSON.parse(valueKey);
+      if (typeof value !== "boolean") continue;
+      const callbacks = [
+        ...new Set(
+          valueOrigins.flatMap((origin) => {
+            const callback = state.callbackForRawCallable(origin.callableRef);
+            return callback ? [callback] : [];
+          }),
+        ),
+      ].sort();
+      if (callbacks.length === 0) continue;
+      const expressionAnchor = `${destination.stateKey} = ${String(value)}`;
+      const branchCalls = destination.branchCalls.get(value) ?? [];
+      const supports = uniqueSupport(
+        [
+          destination.getter,
+          destination.condition,
+          ...branchCalls,
+          ...valueOrigins.flatMap((origin) => origin.support),
+        ],
+        `component-variant:${expressionAnchor}`,
+        "structured route scalar and mutually exclusive Compose UI branch",
+      );
+      if (!supports) continue;
+      const conditionRef = state.builder.addFact("condition", {
+        identity: [
+          { kind: "component", value: destination.destinationRef },
+          { kind: "semantic-key", value: expressionAnchor },
+        ],
+        confidence: "high",
+        support: supports,
+        data: {
+          ownerKey: destination.destinationRef,
+          expressionAnchor,
+          plainLanguage: `导航状态 ${destination.stateKey} 的值为 ${String(value)}`,
+          valueKind: "static",
+        },
+        relatedFactRefs: [destination.destinationRef],
+      });
+      state.builder.addFact("component-variant", {
+        identity: [
+          { kind: "component", value: destination.destinationRef },
+          { kind: "semantic-key", value: destination.stateKey },
+          { kind: "semantic-key", value: valueKey },
+        ],
+        confidence: "high",
+        support: supports,
+        data: {
+          componentKey: destination.destinationRef,
+          stateKey: `${destination.routeSubject}#${destination.stateKey}`,
+          value,
+          conditionKeys: [conditionRef],
+          entryCallbackKeys: callbacks,
+        },
+        relatedFactRefs: [
+          destination.destinationRef,
+          conditionRef,
+          ...callbacks,
+        ],
+      });
+    }
+  }
+}