client

type Client struct {
	// contains filtered or unexported fields
}

type Options struct {
	// URL is the server base, e.g. "ws://localhost:8080" or
	// "wss://collab.example.com". The document name is appended as
	// the URL path (y-websocket convention).
	URL string

	// DocName addresses the document on the server.
	DocName string

	// Doc is the local document the client syncs. When nil a fresh
	// Doc is created; retrieve it via Client.Doc.
	Doc *doc.Doc

	// Awareness optionally carries per-client ephemeral state
	// (cursor, name). When nil a fresh Awareness bound to the Doc's
	// clientID is created.
	Awareness *awareness.Awareness

	// OnSynced fires on synced-state transitions: true after each
	// completed handshake, false on every disconnect. Called from the
	// client's goroutines; keep it fast and do not call back into
	// blocking Client methods.
	OnSynced func(synced bool)

	// OnError observes non-fatal connection errors (dial failures,
	// dropped connections). The client keeps reconnecting regardless.
	//
	// OnError and OnSynced may be invoked concurrently from different
	// goroutines (e.g. a local-store write failure overlapping a dial
	// failure), so a callback that mutates shared state must guard it.
	OnError func(err error)

	// MinBackoff / MaxBackoff bound the reconnect backoff. Defaults:
	// 250ms / 10s.
	MinBackoff time.Duration
	MaxBackoff time.Duration

	// LocalStore, when set, makes the client offline-first: on Connect
	// the document loads its persisted state from the store (so it is
	// usable before any network), every subsequent change (local edit
	// or applied remote update) is persisted, and on reconnect the
	// handshake carries any edits made while offline up to the server.
	// Keyed by DocName. A pure-Go on-device sqlite store
	// (persist/sqlite) is the typical mobile choice. nil disables
	// local persistence; the document lives only in memory.
	LocalStore persist.Store
}