# Liminal

> Effect x Actors

## Docs

- [Quickstart](/start): Liminal is a typed actor framework built on Effect. A minimal app has five pieces:
- [Audition](/state/audition): `Audition` combines multiple clients into one state stream, call surface, and event stream.
- [Client State](/state/client-state): Client state is part of the `Client.Service(...)` definition. When a client connects, the actor runtime sends an initial
state value during audition. After that, client-side reducers fold incoming events into the current state.
- [Snapshot and Delta Events](/state/snapshot-delta-events): Client state depends on a deliberate snapshot-and-delta pattern:
- [Browser Setup](/instrumentation/browser-setup): For Cloudflare and browsers, the simplest setup is Effect's lightweight OTLP exporter from
`effect/unstable/observability`. It works with `FetchHttpClient` and does not require the Node OpenTelemetry SDK.
- [Cloudflare Setup](/instrumentation/cloudflare-setup): The Worker runtime and Durable Object actor runtime both need telemetry in their Effect layers. Both runtimes flush the
OTLP exporter after Worker fetches and Durable Object fetch/message/close/error callbacks, so short-lived Worker
executions can export the spans they just produced.
- [Collectors](/instrumentation/collectors): For local development, run any OTLP HTTP collector and point both browser and Worker telemetry at it.
- [Instrumentation](/instrumentation): Liminal is instrumented with Effect spans and logs at the runtime boundaries where a client, transport, Worker, Durable
Object, or actor handler hands work to the next layer.
- [Propagation](/instrumentation/propagation): There are two propagation paths.
- [Session Continuity](/instrumentation/session-continuity): Cloudflare Durable Objects can hibernate. Because an object can sleep between messages, Liminal does not model a
WebSocket connection as one long live span.
- [Trace Story](/instrumentation/trace-story): A typical browser-to-actor method call produces a connected trace across client, transport, actor, and event handling.
- [Actor Context](/core/actor-context): Handlers and lifecycle hooks read actor runtime context by yielding the actor tag.
- [Actor Handlers](/core/actor-handlers): Handlers implement client methods inside actor context.
- [Actor Namespace](/core/actor-namespace): `WorkerdActorNamespace` is the Worker-side handle for a Cloudflare Durable Object actor.
- [Actors](/core/actors): Actors are the server-side runtime for a client definition.
- [Client Calls](/core/client-calls): `Client.fn(...)` invokes a named external method from the client protocol.
- [Client Handles](/core/client-handles): Attachments are per-client state. Client handles are the per-socket API actors use to communicate with connected
clients.
- [Client Layer](/core/client-layer): `Client.layerSocket(...)` turns a `Client` protocol into a live Effect layer backed by a WebSocket.
- [Clients](/core/clients): A `Client` defines the wire contract between browser clients and actors.
- [Events](/core/events): `Client.events` is the event stream for a client protocol.
- [Lifecycle](/core/lifecycle): `hydrate` runs when a client socket is newly upgraded into an actor.
- [Methods](/core/methods): Methods describe request-response calls in a protocol.
- [Prelude vs Layer](/core/prelude-vs-layer): The `prelude` and `layer` fields in `WorkerdActorRuntime.make(...)` serve different lifetimes.
- [HTTP Upgrades](/actor-routing/upgrades): `Namespace.bind(name).upgrade(attachments)` is the handoff from HTTP to the Durable Object.
- [Worker Entrypoint](/actor-routing/worker-entrypoint): The Worker entrypoint usually exports: