Networking

Use namespaced JSON messages with host-resolved callers and bounded transport policy.

Message contract

Type or member	Contract
`LitherarpAddonNetworkDirection`	Flags: `ClientToHost`, `HostToClient`, `Both`.
`LitherarpAddonNetworkOptions.MaxPayloadBytes`	Receiver limit, clamped from 1 to 16,384 UTF-8 bytes. Default 4,096.
`MaxCallsPerWindow`	Per-caller host limit, clamped from 1 to 100. Default 20.
`RateLimitWindowSeconds`	Window clamped from 0.25 to 60 seconds. Default 5.
`PermissionNode`	Optional local node resolved as `addon.<id>.<node>` on every client-to-host message.
`LitherarpAddonNetworkMessageContext`	`AddonId`, `MessageName`, cloned JSON `Payload`, nullable `Caller`, nullable host-resolved `Player`, and `TryRead<T>`.

Request and response

1public sealed record PurchaseRequest( string ItemId );
2public sealed record PurchaseResult( bool Success, string Message );
3
4public void OnHostLoaded( LitherarpAddonContext context )
5{
  context.RegisterNetworkMessage(
      "purchase.request",
      LitherarpAddonNetworkDirection.ClientToHost,
      message =>
      {
          if ( !message.TryRead<PurchaseRequest>( out var request ) || request is null )
              return;
13
          // The permission option below requires an existing caller pawn.
          var player = message.Player;
          if ( player is null )
              return;
18
          var result = ValidatePurchase( player, request.ItemId );
          context.SendNetworkToPlayer(
              player,
              "purchase.result",
              new PurchaseResult( result.Success, result.Message ) );
      },
      new LitherarpAddonNetworkOptions
      {
          MaxPayloadBytes = 1024,
          MaxCallsPerWindow = 6,
          RateLimitWindowSeconds = 5f,
          PermissionNode = "shop.use"
      } );
32
  // No PermissionNode: this handshake is accepted before pawn creation.
  context.RegisterNetworkMessage(
      "ready.hello",
      LitherarpAddonNetworkDirection.ClientToHost,
      message => context.SendNetworkToConnection(
          message.Caller,
          "ready.reply",
          new { accepted = true } ) );
41}
42
43public void OnClientLoaded( LitherarpAddonContext context )
44{
  context.RegisterNetworkMessage(
      "purchase.result",
      LitherarpAddonNetworkDirection.HostToClient,
      message =>
      {
          if ( message.TryRead<PurchaseResult>( out var result ) )
              ShowResult( result! );
      } );
53}

Host validation

For client-to-host traffic, the platform validates addon id, message name, registered direction and a positive caller Steam id first. It then spends the caller's rate-limit token and checks any configured permission before measuring or parsing the JSON. Malformed traffic cannot avoid throttling. The client cannot supply Caller or Player.

A message without PermissionNode can run before pawn creation. In that case Caller is set and Player is null. A permission-gated message requires an existing pawn because the host must evaluate addon.<id>.<node> for that player. Use SendNetworkToConnection to answer an active connection before its pawn exists, and SendNetworkToPlayer after it does.

Host-to-client traffic is accepted only from the host RPC path. On a listen server, direct delivery uses the same registered handler.

Limits and failures

At most 64 distinct message names per addon.
Message names are at most 48 characters and are normalized to lowercase. Allowed characters are ASCII letters, digits, dot, underscore and hyphen.
The sender-wide serialization ceiling is 16,384 UTF-8 bytes. The receiver can set a lower limit.
Three consecutive recoverable handler failures quarantine that handler for the activation.
Nested synchronous dispatch is rejected after a depth of eight.
All payloads must be JSON serializable. A false return means registration, validation or send failed.

Raw RPC methods are your responsibility

A custom addon [Rpc.Host] method does not inherit these caller, permission, payload and rate checks. Use the addon network service unless you implement every guard yourself.