Line Types Example, API Client, Host, and Remote Plugin Definitions

13th chunk of `runtime/doc/intro.txt`

324cd9a986361817b4f4dcc0258379bd822ef4ca9bbef15d0000000100000c03

 is also used for messages.  It scrolls up the screen when
there is not enough room in the command line.

A difference is made between four types of lines:

- buffer lines:  The lines in the buffer.  This is the same as the
                 lines as they are read from/written to a file.  They
                 can be thousands of characters long.
- logical lines: The buffer lines with folding applied.  Buffer lines
                 in a closed fold are changed to a single logical line:
                 "+-- 99 lines folded".  They can be thousands of
                 characters long.
- window lines:  The lines displayed in a window: A range of logical
                 lines with wrapping, line breaks, etc.  applied.  They
                 can only be as long as the width of the window allows,
                 longer lines are wrapped or truncated.
- screen lines:  The lines of the screen that Nvim uses.  Consists of
                 the window lines of all windows, with status lines
                 and the command line added.  They can only be as long
                 as the width of the screen allows.  When the command
                 line gets longer it wraps and lines are scrolled to
                 make room.

>
  buffer lines    logical lines   window lines    screen lines
  -----------------------------------------------------------------------
  1. one          1. one          1. +-- folded   1.  +-- folded
  2. two          2. +-- folded   2. five         2.  five
  3. three        3. five         3. six          3.  six
  4. four         4. six          4. seven        4.  seven
  5. five         5. seven                        5.  === status line ===
  6. six                                          6.  aaa
  7. seven                                        7.  bbb
                                                  8.  ccc ccc c
  1. aaa          1. aaa          1. aaa          9.  cc
  2. bbb          2. bbb          2. bbb          10. ddd
  3. ccc ccc ccc  3. ccc ccc ccc  3. ccc ccc c    11. ~
  4. ddd          4. ddd          4. cc           12. === status line ===
                                  5. ddd          13. (command line)
                                  6. ~
<

API client ~
All external UIs and remote plugins (as opposed to regular Vim plugins) are
"clients" in general; but we call something an "API client" if its purpose is
to abstract or wrap the RPC API for the convenience of other applications
(just like a REST client or SDK such as boto3 for AWS: you can speak AWS REST
using an HTTP client like curl, but boto3 wraps that in a convenient python
interface). For example, the Nvim node-client is an API client:
    https://github.com/neovim/node-client


Host ~
A plugin "host" is both a client (of the Nvim API) and a server (of an
external platform, e.g. python). It is a remote plugin that hosts other
plugins.


Remote plugin ~
Arbitrary code registered via |:UpdateRemotePlugins|, that runs in a separate
process and communicates with Nvim via the |api|.


 vim:tw=78:ts=8:et:sw=4:ft=help:norl:

Title: Line Types Example, API Client, Host, and Remote Plugin Definitions

Summary

This section provides an example illustrating the differences between buffer lines, logical lines, window lines, and screen lines. It then defines API Client, Host, and Remote Plugin in the context of Neovim, explaining their roles and relationships in the Neovim architecture and plugin ecosystem.