Function substituteRef

packages/lang-core/src/runtime/evaluator.ts:371–437

* Substitute all Ref(varName) nodes in an AST tree with a literal value. * This pre-resolves loop variables so deferred expressions (like Action steps) * don't lose scope when evaluated later at click time.

(node: ASTNode, varName: string, value: unknown)

 * don't lose scope when evaluated later at click time.
 */
function substituteRef(node: ASTNode, varName: string, value: unknown): ASTNode {
  switch (node.k) {
    case "Ref":
      return node.n === varName ? toLiteralAST(value) : node;
    case "Member": {
      // Member access on the loop var: t.id → resolve t, then access .id
      if (isASTNode(node.obj)) {
        const subObj = substituteRef(node.obj as ASTNode, varName, value);
        // If obj resolved to a literal, we can inline the member access result
        if (subObj.k === "Obj") {
          const entry = subObj.entries.find(([k]) => k === node.field);
          if (entry) return entry[1];
        }
        return { ...node, obj: subObj };
      }
      return node;
    }
    case "Index":
      return {
        ...node,
        obj: isASTNode(node.obj) ? substituteRef(node.obj as ASTNode, varName, value) : node.obj,
        index: isASTNode(node.index)
          ? substituteRef(node.index as ASTNode, varName, value)
          : node.index,
      };
    case "BinOp":
      return {
        ...node,
        left: substituteRef(node.left, varName, value),
        right: substituteRef(node.right, varName, value),
      };
    case "UnaryOp":
      return { ...node, operand: substituteRef(node.operand, varName, value) };
    case "Ternary":
      return {
        ...node,
        cond: substituteRef(node.cond, varName, value),
        then: substituteRef(node.then, varName, value),
        else: substituteRef(node.else, varName, value),
      };
    case "Arr":
      return { ...node, els: node.els.map((e) => substituteRef(e, varName, value)) };
    case "Obj":
      return {
        ...node,
        entries: node.entries.map(
          ([k, v]) => [k, substituteRef(v, varName, value)] as [string, ASTNode],
        ),
      };
    case "Comp": {
      const result = { ...node, args: node.args.map((a) => substituteRef(a, varName, value)) };
      // Also substitute in mappedProps (added by materializer for catalog components)
      if (node.mappedProps) {
        const subProps: Record<string, ASTNode> = {};
        for (const [k, v] of Object.entries(node.mappedProps)) {
          subProps[k] = substituteRef(v, varName, value);
        }
        (result as any).mappedProps = subProps;