Clients

A Client defines the wire contract between browser clients and actors.

Everything else in Liminal hangs off that contract:

• actors point at a client definition
• external handlers implement the methods callable by connected clients
• Auditions can merge multiple clients into one event stream and call surface
• reducers derive local state from events after the initial hydration

Define a client

A client is a named state schema, external method table, and event table.

import { Schema as S } from "effect"
import { Client } from "liminal"
 
export const Player = S.Literals(["X", "O"])
export const Coordinate = S.Literals([0, 1, 2])
export const Coordinates = S.Tuple([Coordinate, Coordinate])
 
export class TicTacToeClient extends Client.Service<TicTacToeClient>()("examples/TicTacToeClient", {
  events: {
    GameStarted: {},
    MoveMade: {
      player: Player,
      position: Coordinates,
    },
    GameEnded: {
      winner: S.optional(Player),
    },
  },
  external: {
    Move: {
      payload: S.Struct({
        position: Coordinates,
      }),
      success: S.Void,
      failure: S.Never,
    },
  },
  state: {
    awaitingPartner: S.Boolean,
    name: Player,
  },
}) {}

Shape

• state is the struct-fields record hydrated when the client connects.
• external is a record of { payload, success, failure } methods callable through Client.fn(...).
• events is a record of plain struct fields.
• Liminal tags events automatically with _tag.

Next concepts

• Methods covers reusable method definitions.
• Client Calls covers Client.fn(...).
• Events covers Client.events and replay.
• Client State covers hydration and reducers.
• Actors covers the server-side runtime for this protocol.