PARSE TIME  (Dag processor, serialization/stub_arg_bindings.py)
   build_mapped_arg_bindings(transform)  one "param" per parameter, in declaration order
   build_arg_bindings(report)            "literal", "xcom", "sequence", or "param" for a group's expand argument
   rejects: map() not outermost, zip() inside zip(), a whole map()/zip()/concat() result,
            a literal dict expand value, a non-JSON zip() fillvalue, a strict expand_kwargs()
            key that partial() also sets, a mapped task's whole output as an expand_kwargs()
            item, and a producer mapped again inside a shared mapped task group
        |
        v
 SERIALIZED DAG  (metadata DB)
   transform
     "_arg_bindings": [
       {"name": "region", "kind": "param", "value_schema": {"type": "string"}},
       {"name": "row", "kind": "param", "value_schema": {"type": "string"}},
       {"name": "scale", "kind": "param", "value_schema": {"format": "int64", "type": "integer"},
        "default": 2}
     ]
     "partial_kwargs": {"queue": "typescript", "op_kwargs": {"__var": {"region": "eu"}, "__type": "dict"},
       "op_args": []}
     "op_kwargs_expand_input": {"type": "dict-of-lists", "value": {"__var": {
       "row": {"__var": {"type": "map",
         "arg": {"task_id": "extract", "key": "return_value"},
         "callables": ["def clean(row: str) -> str:\n    return row.strip()\n"]}, "__type": "xcomref"}},
       "__type": "dict"}}
   report
     "_arg_bindings": [
       {"name": "totals", "kind": "sequence", "task_id": "transform",
        "value_schema": {"items": {"format": "int64", "type": "integer"}, "type": "array"}}
     ]
        |
        |  ti_run reads the entries and the fields Python already writes
        v
 API SERVER  (execution_api/services/stub_arg_bindings.py)
   param             group_arg -> expand input element -> partial() value -> default
                     (expand_keys orders the expand() cross product)
   xcom / sequence   narrowed to one row when the producer shares the stub's mapped task group
   reads TaskMap lengths only, never an XCom value
        |
        v
 TIRunContext.arg_bindings  (Execution API 2027-02-28)
   transform, map index 2
     {"name": "region", "kind": "literal", "value_schema": {"type": "string"}, "value": "eu"}
     {"name": "row", "kind": "xcom", "value_schema": {"type": "string"}, "task_id": "extract",
      "element_index": 2, "apply_map": true}
     {"name": "scale", "kind": "literal", "value_schema": {"format": "int64", "type": "integer"},
      "value": 2, "from_default": true}
   report
     {"name": "totals", "kind": "sequence", "task_id": "transform",
      "value_schema": {"items": {"format": "int64", "type": "integer"}, "type": "array"}}

 build_arg_bindings(op)              unmapped stub, including a member of a mapped task group
   bind the call to the stub signature, then apply defaults
   for each parameter, in declaration order:
     group's expand argument  -> _build_group_arg_binding     -> param {group_arg: {group_id, key}}
     XComArg                  -> _validate_whole_xcom_value   plain output only
                                 _validate_group_relative     no producer mapped again in a shared group
                                 _build_xcom_binding          -> xcom | sequence (mapped producer)
     anything else            -> _ensure_json_literal         -> literal {value, from_default}
   + value_schema from _infer_value_schema

 build_mapped_arg_bindings(op)       mapped stub, .expand() or .expand_kwargs()
   partial() values         -> _validate_whole_value         whole map/zip/concat rejected
   expand() values          -> _validate_expand_value -> _validate_expand_shape   literal dict rejected
   expand_kwargs() value    -> _validate_expand_kwargs       unknown key, strict overlap with partial()
                               _validate_kwarg_fallbacks     strict=False over an upstream output
   for each parameter       -> _build_param_binding          -> param {default, value_schema, expand_keys}
                               (the values stay in partial_kwargs and op_kwargs_expand_input)

 _validate_expand_shape walks the XComArg tree:
   map()     only as the outermost call
   zip()     never under another zip(), fillvalue must be JSON
   concat()  recurses into its arguments

 get_arg_bindings(task, ti)          services/task_instances.py
   not a stub, or no _arg_bindings          -> None
   mapped, client older than 2027-02-28     -> None
   mapped, or in a mapped task group        -> derive_mapped_arg_bindings
   unmapped and in no mapped task group     -> the stored entries as they are
   client older than 2027-02-28 and a binding has a new kind or field
                                            -> UndeliverableMappedArgBindingsError
   UndeliverableMappedArgBindingsError      -> 422 invalid_arg_bindings + warning log

 _bind_entry, per stored entry:
   param + group_arg    -> _bind_group_arg     the group's expand argument at this index
   param, mapped stub   -> _bind_mapped_param  1. expand():        _bind_element
                                               2. expand_kwargs(): _bind_mapping_entry
                                                  (skipped for a strict key partial() sets)
                                               3. partial():       _bind_whole
                                               4. default:         _bind_default
   xcom / sequence      -> _bind_upstream      one row when the producer shares the mapped group
   literal              -> as stored

 building blocks:
   _bind_element    literal list or dict  -> literal (a dict item is [key, value])
                    map(f)                -> _locate(inner) + apply_map
                    other XComArg         -> _locate
   _locate          zip()     -> tuple {parts: [XComRef | LiteralValue (fillvalue)]}
                    concat()  -> the argument owning this index
                    plain     -> xcom {map_index of the producer's row at that offset (mapped)
                                       | element_index (unmapped)}
   _bind_mapping_entry / _get_fallback
                    literal dict          -> the key's value now
                    upstream dict         -> xcom + kwarg + fallback (partial() value or default)
   _get_sub_indexes / _get_length
                    expand() cross product in expand_keys order, and lengths from TaskMap and
                    XCom row counts, never an XCom value