API reference

Every exported name, generated from the source by go generate; a test fails when this page and the code disagree. Each name links to its pkg.go.dev entry, and each row has an anchor: /reference#via.WithSessionTTL. To install, see Getting started.

via 97 · h 170 · on 39 · expr 23 · topic 13 · vt 30 · vtbrowser 20

On this page

via
- Lifecycle hooks
h
- Datastar attributes
on
expr
topic
vt
vtbrowser

#via

The router, the pages mounted on it, the state handles a page renders, via.Ctx, sessions and the error surface. Router options are policy passed to via.NewRouter or via.Handler: a page cannot change them, which is why none of them is a method on a composition. Match a sentinel error with errors.Is and switch on PageError.Reason with a default: a status via does not emit today maps to ReasonInternal or ReasonBadRequest.

#Types

Symbol	Does
#`Assets` `type Assets struct{ … }`	Assets is the CSP-governed half of the document head: everything that loads or executes.
#`Ctx` `type Ctx struct{ … }`	The per-request binder, handed to every callback but View. It is not safe for concurrent use: call it only from the via callback it was given to.
#`Ctx.Context` `func (c *Ctx) Context() context.Context`	The context bounding this unit's work: the stream's on a live unit, the request's otherwise. Never nil. Watch it in a Tick or Listen handler to abandon a slow call against a dead socket.
#`Ctx.Listen` `func (c Ctx) Listen[T any](t topic.Topic[T], handler func(*Ctx, T))`	Subscribes the unit to a topic and runs the handler on the unit's own goroutine for every value, unsubscribing on disconnect. Makes the unit live. OnInit only.
#`Ctx.OnConnect` `func (c *Ctx) OnConnect(fn func())`	Runs once, when this unit's stream opens, after every Listen has subscribed. OnInit only; on a unit nothing made live it never runs.
#`Ctx.OnDispose` `func (c *Ctx) OnDispose(fn func())`	Runs when the unit's connection closes — stop subscriptions, release producers. OnInit only, and only meaningful on a unit something has made live.
#`Ctx.Param` `func (c *Ctx) Param[T any](name string) T`	The mount pattern's named segment, decoded into T. A segment that will not decode answers 404 rather than a zero value, and naming a segment the pattern does not have panics.
#`Ctx.Redirect` `func (c *Ctx) Redirect(path string)`	Navigates the browser after the current handler returns, from OnInit, OnReload, a PostForm submit or an action alike. The render that called it ships nothing. Only a relative path or a URL on this site's host or a trusted origin is followed; anything else is dropped and logged.
#`Ctx.RedirectExternal` `func (c *Ctx) RedirectExternal(target string)`	Redirect to any http(s) URL, for a hand-off that leaves the site (OAuth, payment). Other schemes are still dropped. Build the target yourself; one taken from the request is an open redirect.
#`Ctx.Request` `func (c Ctx) Request() http.Request`	The request behind this render. Its query string is populated on the GET and empty on every action, because an action's URL is the mount pattern and nothing else.
#`Ctx.Session` `func (c Ctx) Session() Session`	The browser session — one value, Get/Put/Delete, ID and Rotate — resolved from the signed cookie and created lazily on the first write.
#`Ctx.Tick` `func (c Ctx) Tick(d time.Duration, fn func(Ctx))`	Runs the handler every d for the life of the connection and re-renders the unit after each run; a d of 0 or less runs every second, with one warning. Makes the unit live. OnInit only.
#`Head` `type Head struct{ … }`	Head describes the router-wide document shell: the <html lang>, raw head markup, and the assets every page of the app carries.
#`List` `type List[E any] struct{ … }`	A State over a slice, with Append, Remove and Each.
#`List.Append` `func (l *List[E]) Append(v E)`	Append adds v to the end of this connection's list and schedules the push, like any Set.
#`List.Each` `func (l *List[E]) Each(row func(E) h.H) h.H`	Each renders row(item) for every element, in order — sugar over via.Each(l.Get(), row), and like State.Display it marks the unit live.
#`List.Remove` `func (l *List[E]) Remove(i int)`	Remove deletes the element at i, shifting the rest left, and panics if i is out of range.
#`MemorySessionStore` `type MemorySessionStore struct{ … }`	MemorySessionStore is the process-local default store — a map guarded by a mutex, with CAS support (VersionedSessionStore).
#`MemorySessionStore.Delete` `func (s *MemorySessionStore) Delete(_ context.Context, id string) error`	Delete implements SessionStore.
#`MemorySessionStore.Load` `func (s *MemorySessionStore) Load(_ context.Context, id string) ([]byte, bool, error)`	Load implements SessionStore.
#`MemorySessionStore.LoadVersion` `func (s *MemorySessionStore) LoadVersion(_ context.Context, id string) ([]byte, uint64, bool, error)`	LoadVersion implements VersionedSessionStore.
#`MemorySessionStore.Save` `func (s *MemorySessionStore) Save(_ context.Context, id string, data []byte, ttl time.Duration) error`	Save implements SessionStore.
#`MemorySessionStore.SaveIf` `func (s *MemorySessionStore) SaveIf(_ context.Context, id string, data []byte, ttl time.Duration, version uint64) (bool, error)`	SaveIf implements VersionedSessionStore.
#`Meta` `type Meta struct{ … }`	Meta is what a mounted page declares about its own document, via the PageMeta() Meta hook on the mounted root.
#`MountOption` `type MountOption func(*mountConfig)`	MountOption configures a single Mount call, as opposed to Option which configures the whole Router.
#`Option` `type Option func(*config)`	Option configures a Handler or a NewRouter.
#`PageError` `type PageError struct{ … }`	Everything via knows about a failure it is about to answer, handed to the WithErrorPage handler. Status and Reason are the contract; Detail and Err are for logs and dev builds.
#`Preload` `type Preload struct{ … }`	Preload is one <link rel="preload">.
#`Reason` `type Reason string`	The stable code an error page switches on: bad_request, forbidden, not_found, method_not_allowed, gone, too_large, internal, unavailable. One per status class, so a switch with a default is exhaustive.
#`Router` `type Router struct{ … }`	Router serves several via pages, each Mounted at its own path, behind one http.Handler.
#`Router.Close` `func (r *Router) Close()`	Shutdown with no deadline.
#`Router.ServeHTTP` `func (r Router) ServeHTTP(w http.ResponseWriter, req http.Request)`	ServeHTTP lazily runs r.init on first use, so a zero Router (var r via.Router) is ready to Mount and serve without an explicit constructor call.
#`Router.Shutdown` `func (r *Router) Shutdown(ctx context.Context) error`	Drains the live half — stream goroutines, Tick timers, Listen subscriptions — and returns once it is quiet, or with ctx's error at its deadline, logging the tabs whose handler is still blocked. Call it before http.Server.Shutdown, which does not cancel the router's own context.
#`Script` `type Script struct{ … }`	Script is one <script>.
#`Session` `type Session struct{ … }`	Session is a browser session's value bag, resolved from the signed cookie, created lazily on the first write — an app that never stores anything stays cookieless.
#`Session.Delete` `func (s *Session) Delete()`	Delete clears the stored value; the session id and cookie survive, so a later Put on this same session starts from nothing rather than minting a new id.
#`Session.Ensure` `func (s *Session) Ensure() string`	Ensure mints the session and issues its cookie if there is none yet, storing no value, and returns Session.ID.
#`Session.Get` `func (s *Session) Get[T any]() (T, bool)`	Get reads the session's value as T, returning the zero value and false when nothing is stored or the stored bytes no longer decode into T.
#`Session.ID` `func (s *Session) ID() string`	ID is the session's stable identity: minted once, unchanged by Session.Rotate, "" when there is no session yet.
#`Session.Put` `func (s *Session) Put(v any)`	Put stores v as the session's value.
#`Session.Rotate` `func (s *Session) Rotate() string`	Rotate issues a fresh session id, carries the existing data to it, and re-sets the cookie — call it after every auth-state change (login, privilege elevation) so a fixed pre-auth id is invalidated.
#`SessionStore` `type SessionStore interface{ … }`	SessionStore is where session state lives between requests.
#`Signal` `type Signal[T any] struct{ … }`	Client-resident state that round-trips per request.
#`Signal.Bind` `func (s *Signal[T]) Bind() h.Attr`	Bind returns a two-way data-bind="<slot>" attribute for an input, sharing the signal's name with Display regardless of source order.
#`Signal.Display` `func (s *Signal[T]) Display() h.H`	Display renders the signal as a Datastar text-bound span.
#`Signal.Get` `func (s *Signal[T]) Get() T`	Get returns the server-side value: what the last Set wrote, or what the client posted back for a Bind()ed signal on this request.
#`Signal.Ref` `func (s *Signal[T]) Ref() expr.Expr`	Ref returns the signal's Datastar expression — "$count" for a field Count, "$chat__draft" for a Draft inside an embedded Chat (the double underscore marks the child boundary; a plain nested struct joins with a single one) — for hand-written Datastar attributes the typed API does not cover:
#`Signal.Set` `func (s *Signal[T]) Set(v T)`	Set assigns the value and declares the slot, which is what carries the change to the client: a live action pushes a patch-signals frame, a plain action's element patch carries a data-signals restricted to the slots it wrote.
#`SignalCS` `type SignalCS[T any] struct{ … }`	Client-only state. Its name is _-prefixed, which Datastar's fetch filter drops, so the server never sees it.
#`SignalCS.Bind` `func (s *SignalCS[T]) Bind() h.Attr`	Bind returns a two-way data-bind="<slot>" attribute for an input.
#`SignalCS.Display` `func (s *SignalCS[T]) Display() h.H`	Display renders the signal as a Datastar text-bound span, showing the seed value until the client changes it.
#`SignalCS.Ref` `func (s *SignalCS[T]) Ref() expr.Expr`	Ref returns the signal's Datastar expression — "$_open" for a field Open.
#`State` `type State[T any] struct{ … }`	Server-authoritative per-tab state, rendered as text and morphed when it changes. Rendering one makes its unit live.
#`State.Display` `func (s *State[T]) Display() h.H`	Display renders the current value as literal, escaped server text and marks its unit live, so server-held state alone earns a connection.
#`State.Get` `func (s *State[T]) Get() T`	Get returns this connection's value.
#`State.Set` `func (s *State[T]) Set(v T)`	Set assigns the value on this unit instance.
#`State.Track` `func (s State[T]) Track(ctx Ctx, t *topic.Topic[T], load func() T)`	Track keeps s equal to a store announced on t: it seeds s from load now, seeds it again once the stream has subscribed, and then applies every publish.
#`Style` `type Style struct{ … }`	Style is one stylesheet — Href for a <link rel="stylesheet">, Inline for a <style> admitted by the sha256 of its exact bytes.
#`VersionedSessionStore` `type VersionedSessionStore interface{ … }`	VersionedSessionStore is the optional half of SessionStore, for a backend that can make a write conditional on the revision it read.

#Functions

Symbol	Does
#`Child` `func Child[C any](child C) h.H`	Renders a struct field as its own child, keyed by its position among the parent's Child calls. The argument must be a field selector: a composite literal would re-seed the child on every render.
#`Each` `func Each[T any](items []T, row func(T) h.H) h.H`	Renders row(item) for every item, in order, in place. Rows morph by position, so give a row a stable id when the order can change.
#`Handler` `func Handler[T any, PT ptrViewer[T]](root T, opts ...Option) *Router`	A one-page app: a Router with root mounted at "/". It returns the Router rather than an http.Handler so the live half stays reachable.
#`ListOf` `func ListOf[E any](v ...E) List[E]`	Seeds a List from a parent's composite literal, for a child that has no OnInit of its own to Set it in.
#`Mount` `func Mount[T any, PT ptrViewer[T]](r *Router, path string, root T, opts ...MountOption)`	Registers a page composition at an http.ServeMux pattern, serving that exact path and never a subtree: "/docs/" does not answer /docs/intro. root is taken by value, and the page's actions post to {path}/_via/a/{child}/{act}, so a {name...} or {$} wildcard, or one named child or act, panics.
#`NewMemorySessionStore` `func NewMemorySessionStore() *MemorySessionStore`	NewMemorySessionStore returns the default process-local store: a map that is lost on restart and invisible to every other pod.
#`NewRouter` `func NewRouter(opts ...Option) *Router`	An empty router. Mount pages onto it, serve it, and Shutdown it when the server shuts down.
#`PostForm` `func PostForm(handler func(*Ctx), children ...h.H) h.H`	A native multipart form whose submit is a real navigation, read back with ctx.Request().FormValue.
#`StateOf` `func StateOf[T any](v T) State[T]`	Seeds a State from a parent's composite literal, for a child that has no OnInit of its own to Set it in.
#`StateTrack` `func StateTrack[T any](t *topic.Topic[T], load func() T) State[T]`	A State that seeds from load at every init of its unit, re-seeds once the stream has subscribed, then follows the topic. For a source fixed at mount; State.Track in OnInit is for one that depends on the request.
#`When` `func When(cond bool, build func() h.H) h.H`	Renders build() when cond holds and does not call it otherwise. cond decides what is dispatchable as well as what is drawn, so a handler inside a closed branch answers 410.

#Options

Symbol	Does
#`WithErrorPage` `func WithErrorPage(fn func(*Ctx, PageError) h.H) Option`	Renders via's failures as HTML documents instead of plain text. It applies to document responses only.
#`WithHead` `func WithHead(head Head) Option`	The router-wide document shell: lang, raw head markup, and the assets every page carries. An invalid head panics at startup.
#`WithLogger` `func WithLogger(l *slog.Logger) Option`	Routes via's own diagnostics to l. Default is slog.Default().
#`WithMaxBody` `func WithMaxBody(bytes int64) Option`	Caps an action POST body, and how much of a form submit stays in RAM before spilling to a temp file (default 1 MiB). Over the cap answers 413.
#`WithMaxSSEConn` `func WithMaxSSEConn(n int) Option`	Caps how many live streams this router serves at once (default 10000; 0 or less panics); past the cap a connect is refused 503. The same number, up to 1024, caps actions parked waiting for their tab's stream; past it an action answers 503.
#`WithMaxUpload` `func WithMaxUpload(bytes int64) Option`	Caps a native form submit's whole multipart body (default 8 MiB). Over the cap answers 413.
#`WithPinnedDeadline` `func WithPinnedDeadline(d time.Duration) Option`	How long an action POST waits for the tab's stream goroutine to pick it up before answering 503 and logging the tab as pinned (default 5s; 0 or less panics). An action that has started is waited for, since it writes the POST's own response. The same deadline covers the wait for a tab's stream that has not connected yet, capped at 2s: 410 if it has not come by then, and at once if via itself ended it.
#`WithSecureCookies` `func WithSecureCookies() Option`	Forces Secure on the session cookie. Without it Secure follows TLS or the proxy's X-Forwarded-Proto / Forwarded header, so it is for a proxy that sends neither.
#`WithSessionCookieName` `func WithSessionCookieName(name string) Option`	Overrides the cookie name (default "via_session"). Set a distinct one per app when two via apps share a host. A name net/http would drop panics.
#`WithSessionKey` `func WithSessionKey(key []byte) Option`	The HMAC key signing the session cookie id; at least 16 bytes, or it panics, as an empty key or a second WithSessionKey does. Without the option, via falls back to the VIA_SESSION_KEY environment variable, and failing that mints a random per-process key, so those cookies survive neither a restart nor a second process.
#`WithSessionStore` `func WithSessionStore(s SessionStore) Option`	Points sessions at a shared, durable store instead of the default process-local map. Pair it with WithSessionKey; both are required past one pod, see Deploy. A second WithSessionStore panics.
#`WithSessionStoreTimeout` `func WithSessionStoreTimeout(d time.Duration) Option`	Caps one session store round-trip (default 5s); 0 or less panics. Without it a hung backend pins the request goroutine, since session calls survive client cancellation.
#`WithSessionTTL` `func WithSessionTTL(d time.Duration) Option`	How long a session may sit idle before it expires (default 24h); 0 or less panics. The window slides at one write per half-TTL, so a session can expire as little as half the TTL after its last request.
#`WithTrustedOrigin` `func WithTrustedOrigin(origin string) Option`	Turns on origin enforcement for the action endpoint and the stream connect and allowlists one origin. Without any set, every action and the stream connect accept any origin and via logs a warning at startup — set this in production. Host case, a default port and a trailing "/" don't matter; a value with a path, query, fragment or userinfo panics.
#`WithUnsafeEval` `func WithUnsafeEval() Option`	Adds 'unsafe-eval' to every page's script-src, for a library that compiles code from strings. The nonce and hashes stay. While set, via logs a warning at startup: a string that reaches eval, Function or setTimeout(string) runs as script.

#Constants and variables

Symbol	Does
#`ErrForbidden` `var ErrForbidden = errors.New("via: forbidden")`	Denies with a 403. For "you may not do this"; queue a ctx.Redirect instead for "please sign in".
#`ErrNotFound` `var ErrNotFound = errors.New("via: not found")`	Return it from OnInit when the data the page needs no longer exists: the request was honest, so the answer is 404, not 500. Wrap it freely; errors.Is matches.
#`ErrStaleTab` `var ErrStaleTab = errors.New("via: stale tab")`	The tab that would have bound this action is gone: its stream closed, or the id belongs to a render that no longer exists. The one failure a reload fixes.
#`ErrStoreDown` `var ErrStoreDown = errors.New("via: session store unavailable")`	The session store could not be read for this request. The request was fine, a dependency is not; answer it like an outage.
#`ReasonBadRequest` `const ReasonBadRequest Reason = "bad_request"`	400 — unusable action arg, malformed form or body
#`ReasonForbidden` `const ReasonForbidden Reason = "forbidden"`	403 — untrusted origin, session mismatch, ErrForbidden
#`ReasonGone` `const ReasonGone Reason = "gone"`	410 — the render that would bind this action is gone
#`ReasonInternal` `const ReasonInternal Reason = "internal"`	500 — a hook or render failed
#`ReasonMethodNotAllowed` `const ReasonMethodNotAllowed Reason = "method_not_allowed"`	405 — the route exists, this method does not (a GET of an action URL)
#`ReasonNotFound` `const ReasonNotFound Reason = "not_found"`	404 — no such route, ErrNotFound, undecodable Param
#`ReasonTooLarge` `const ReasonTooLarge Reason = "too_large"`	413 — body over the cap
#`ReasonUnavailable` `const ReasonUnavailable Reason = "unavailable"`	503 — the session store could not answer, or a live tab could not take the action

#Lifecycle hooks

Four methods on your own type, duck-typed: a unit opts in by having one. A hook-named method with the wrong signature panics at Mount, and a near-miss name carrying a hook's exact signature is logged once.

Method	Does
`View() h.H`	The unit's markup, and the one required method. It takes no Ctx: whatever it draws was loaded into fields by OnInit. A missing or mistyped View on a mounted root is a compile error.
`OnInit(*via.Ctx) error`	Loads request and session data, and registers the timers and subscriptions that make the unit live. It runs on every request that renders the unit — the GET, the stream connect, and each action on a page that is not streaming.
`OnReload(*via.Ctx) error`	Runs after one of the unit's actions and before the render that answers it, so a handler that mutated a store re-reads here. Skipped behind a Redirect.
`PageMeta() via.Meta`	The mounted root's own document: title, description, social cards, assets. Read after OnInit, on a render that writes a document, never on an SSE push.

#h

Markup as Go calls: one function per HTML element and one per attribute, all returning h.H. Text and attribute values are escaped at render time, and URL attributes are scheme-checked.

#Types

Symbol	Does
#`Attr` `type Attr = render.Attr`	Attr is an H that renders inside the opening tag instead of the element body: h.Class, h.Href, h.Data, RawAttr, on.Click and Signal.Bind all return one.
#`H` `type H = render.H`	H is every node of a view: elements, text and attributes alike.
#`Stringish` `type Stringish = render.Stringish`	Stringish is what Str accepts: ~string plus every built-in integer and float type, including named types whose underlying type is one of those.

#Functions

Symbol	Does
#`A` `func A(kids ...H) H`
#`Abbr` `func Abbr(kids ...H) H`
#`Accept` `func Accept(s string) Attr`	Accept is the accepted file types for a file input — ".png,image/jpeg".
#`Action` `func Action(u string) Attr`	Action is the typed form-action attribute, gated like Src.
#`Address` `func Address(kids ...H) H`
#`Alt` `func Alt(s string) Attr`	Alt is the alternative text for an image or area.
#`Area` `func Area(kids ...H) H`
#`Aria` `func Aria(name, val string) Attr`	Aria builds an aria-<name> attribute — Aria("label", s) is aria-label.
#`Article` `func Article(kids ...H) H`
#`Aside` `func Aside(kids ...H) H`
#`Async` `func Async(on bool) Attr`
#`Audio` `func Audio(kids ...H) H`
#`AutoComplete` `func AutoComplete(s string) Attr`	AutoComplete is the autocomplete hint — "off", "current-password".
#`AutoFocus` `func AutoFocus(on bool) Attr`	AutoFocus focuses the control on load when on.
#`B` `func B(kids ...H) H`
#`Bdi` `func Bdi(kids ...H) H`
#`Bdo` `func Bdo(kids ...H) H`
#`Blockquote` `func Blockquote(kids ...H) H`
#`Br` `func Br(kids ...H) H`
#`Button` `func Button(kids ...H) H`
#`Canvas` `func Canvas(kids ...H) H`
#`Caption` `func Caption(kids ...H) H`
#`Checked` `func Checked(on bool) Attr`
#`Cite` `func Cite(kids ...H) H`
#`Class` `func Class(names ...string) Attr`	Class joins the given class names with spaces, skipping empty ones, and renders nothing at all when none survive — so Class(a, b) with both empty leaves no stray class="" behind, and a conditional class is just an empty string at the call site.
#`Code` `func Code(kids ...H) H`
#`Col` `func Col(kids ...H) H`
#`ColSpan` `func ColSpan(n int) Attr`
#`Colgroup` `func Colgroup(kids ...H) H`
#`Cols` `func Cols(n int) Attr`
#`Controls` `func Controls(on bool) Attr`
#`Data` `func Data(name, val string) Attr`	Data builds a data-<name>="val" attribute; val is HTML-escaped at render.
#`DataAttr` `func DataAttr[V ~string](name string, e V) Attr`	DataAttr sets the named attribute from the expression.
#`DataClass` `func DataClass[V ~string](name string, e V) Attr`	DataClass toggles the named class while the expression is truthy.
#`DataComputed` `func DataComputed[V ~string](name string, e V) Attr`	DataComputed declares a read-only signal derived from the expression.
#`DataEffect` `func DataEffect[V ~string](stmts ...V) Attr`	DataEffect runs the statements whenever a signal they read changes.
#`DataIgnoreMorph` `func DataIgnoreMorph() Attr`	DataIgnoreMorph renders a bare data-ignore-morph.
#`DataIndicator` `func DataIndicator[V ~string](sig V) Attr`	DataIndicator names the signal Datastar holds true while a request from this element is in flight.
#`DataOn` `func DataOn[V ~string](event string, stmts ...V) Attr`	DataOn runs the statements on the named DOM event.
#`DataRef` `func DataRef[V ~string](sig V) Attr`	DataRef names the signal Datastar puts this element into.
#`DataShow` `func DataShow[V ~string](e V) Attr`	DataShow shows the element while the expression is truthy.
#`DataStyle` `func DataStyle[V ~string](prop string, e V) Attr`	DataStyle sets the named CSS property from the expression.
#`DataText` `func DataText[V ~string](e V) Attr`	DataText replaces the element's text with the expression's value.
#`Datalist` `func Datalist(kids ...H) H`
#`Dd` `func Dd(kids ...H) H`
#`Defer` `func Defer(on bool) Attr`
#`Del` `func Del(kids ...H) H`
#`Details` `func Details(kids ...H) H`
#`Dfn` `func Dfn(kids ...H) H`
#`Dialog` `func Dialog(kids ...H) H`
#`Disabled` `func Disabled(on bool) Attr`
#`Div` `func Div(kids ...H) H`
#`Dl` `func Dl(kids ...H) H`
#`Dt` `func Dt(kids ...H) H`
#`El` `func El(tag string, kids ...H) H`	El builds an element with an arbitrary tag, for the handful of tags h has no named constructor for (a custom element, an SVG child).
#`Em` `func Em(kids ...H) H`
#`Embed` `func Embed(kids ...H) H`
#`Enctype` `func Enctype(s string) Attr`	Enctype is the form encoding.
#`Fieldset` `func Fieldset(kids ...H) H`
#`Figcaption` `func Figcaption(kids ...H) H`
#`Figure` `func Figure(kids ...H) H`
#`Footer` `func Footer(kids ...H) H`
#`For` `func For(id string) Attr`	For binds a label to the id of the control it labels.
#`Form` `func Form(kids ...H) H`
#`H1` `func H1(kids ...H) H`
#`H2` `func H2(kids ...H) H`
#`H3` `func H3(kids ...H) H`
#`H4` `func H4(kids ...H) H`
#`H5` `func H5(kids ...H) H`
#`H6` `func H6(kids ...H) H`
#`Header` `func Header(kids ...H) H`
#`Height` `func Height[T Stringish](v T) Attr`
#`Hgroup` `func Hgroup(kids ...H) H`
#`Hidden` `func Hidden(on bool) Attr`
#`Hr` `func Hr(kids ...H) H`
#`Href` `func Href(u string) Attr`	Href is the typed href attribute: http, https, mailto, tel and relative URLs pass through, any other scheme is neutralized to "#" and logged — a link must never become a script gadget.
#`I` `func I(kids ...H) H`
#`ID` `func ID(id string) Attr`	ID is the element id.
#`Iframe` `func Iframe(kids ...H) H`
#`Img` `func Img(kids ...H) H`
#`Inert` `func Inert(on bool) Attr`
#`Input` `func Input(kids ...H) H`
#`Ins` `func Ins(kids ...H) H`
#`Kbd` `func Kbd(kids ...H) H`
#`Label` `func Label(kids ...H) H`
#`Lang` `func Lang(s string) Attr`
#`Legend` `func Legend(kids ...H) H`
#`Li` `func Li(kids ...H) H`
#`Loop` `func Loop(on bool) Attr`	Loop restarts media playback when on.
#`Main` `func Main(kids ...H) H`
#`Map` `func Map(kids ...H) H`
#`Mark` `func Mark(kids ...H) H`
#`Max` `func Max[T Stringish](v T) Attr`	Max is the maximum for a number, range or date input.
#`MaxLength` `func MaxLength(n int) Attr`	MaxLength is the maximum accepted input length.
#`Menu` `func Menu(kids ...H) H`
#`Meter` `func Meter(kids ...H) H`
#`Method` `func Method(s string) Attr`	Method is the form submission method — "get" or "post".
#`Min` `func Min[T Stringish](v T) Attr`	Min is the minimum for a number, range or date input.
#`MinLength` `func MinLength(n int) Attr`	MinLength is the minimum accepted input length, with the same caveat.
#`Multiple` `func Multiple(on bool) Attr`	Multiple allows multiple values on a select or file input when on.
#`Muted` `func Muted(on bool) Attr`
#`Name` `func Name(n string) Attr`	Name is the form field name, the key the value arrives under in a POST.
#`Nav` `func Nav(kids ...H) H`
#`NoValidate` `func NoValidate(on bool) Attr`	NoValidate skips the browser's own form validation when on.
#`Noscript` `func Noscript(kids ...H) H`
#`Object` `func Object(kids ...H) H`
#`Ol` `func Ol(kids ...H) H`
#`Open` `func Open(on bool) Attr`
#`Optgroup` `func Optgroup(kids ...H) H`
#`Option` `func Option(kids ...H) H`
#`Output` `func Output(kids ...H) H`
#`P` `func P(kids ...H) H`
#`Picture` `func Picture(kids ...H) H`
#`Placeholder` `func Placeholder(s string) Attr`
#`PlaysInline` `func PlaysInline(on bool) Attr`	PlaysInline plays video inline rather than fullscreen when on.
#`Pre` `func Pre(kids ...H) H`
#`Progress` `func Progress(kids ...H) H`
#`Q` `func Q(kids ...H) H`
#`RawAttr` `func RawAttr(name, val string) Attr`	RawAttr builds a name="val" attribute; val is HTML-escaped at render.
#`ReadOnly` `func ReadOnly(on bool) Attr`	ReadOnly makes a control read-only when on.
#`Rel` `func Rel(s string) Attr`	Rel is the link relationship — "stylesheet", "noopener noreferrer".
#`Required` `func Required(on bool) Attr`	Required marks a control required when on.
#`Reversed` `func Reversed(on bool) Attr`	Reversed numbers an ordered list descending when on.
#`Role` `func Role(s string) Attr`
#`RowSpan` `func RowSpan(n int) Attr`
#`Rows` `func Rows(n int) Attr`
#`Rp` `func Rp(kids ...H) H`
#`Rt` `func Rt(kids ...H) H`
#`Ruby` `func Ruby(kids ...H) H`
#`S` `func S(kids ...H) H`
#`Samp` `func Samp(kids ...H) H`
#`Search` `func Search(kids ...H) H`
#`Section` `func Section(kids ...H) H`
#`Select` `func Select(kids ...H) H`
#`Selected` `func Selected(on bool) Attr`
#`Small` `func Small(kids ...H) H`
#`Source` `func Source(kids ...H) H`
#`Span` `func Span(kids ...H) H`
#`Src` `func Src(u string) Attr`	Src is the typed src attribute, gated like Href but without mailto: and tel:.
#`Step` `func Step[T Stringish](v T) Attr`	Step is the granularity for a number, range or date input.
#`Str` `func Str[T Stringish](v T) H`	Str is the only way to put text in a view.
#`Strong` `func Strong(kids ...H) H`
#`Style` `func Style(css string) Attr`	Style is an inline style declaration.
#`Sub` `func Sub(kids ...H) H`
#`Summary` `func Summary(kids ...H) H`
#`Sup` `func Sup(kids ...H) H`
#`TabIndex` `func TabIndex(n int) Attr`	TabIndex is the tab order position.
#`Table` `func Table(kids ...H) H`
#`Target` `func Target(s string) Attr`	Target is the browsing context a link or form opens in.
#`Tbody` `func Tbody(kids ...H) H`
#`Td` `func Td(kids ...H) H`
#`Textarea` `func Textarea(kids ...H) H`
#`Tfoot` `func Tfoot(kids ...H) H`
#`Th` `func Th(kids ...H) H`
#`Thead` `func Thead(kids ...H) H`
#`Time` `func Time(kids ...H) H`
#`Title` `func Title(s string) Attr`	Title is the advisory title, shown as a tooltip.
#`Tr` `func Tr(kids ...H) H`
#`Track` `func Track(kids ...H) H`
#`Type` `func Type(t string) Attr`
#`U` `func U(kids ...H) H`
#`Ul` `func Ul(kids ...H) H`
#`Value` `func Value[T Stringish](v T) Attr`	Value is the form field value, from any Stringish value.
#`Var` `func Var(kids ...H) H`
#`Video` `func Video(kids ...H) H`
#`Wbr` `func Wbr(kids ...H) H`
#`Width` `func Width[T Stringish](v T) Attr`

#Datastar attributes

One typed helper per Datastar plugin, so the attribute key is spelled once. The helpers take an expr.Expr, and h.Data writes a plugin attribute h has no helper for.

Helper	Attribute	Does
`h.DataShow(e)`	`data-show`	Shows the element while the expression is truthy.
`h.DataText(e)`	`data-text`	Replaces the element's text with the expression's value.
`h.DataClass(name, e)`	`data-class:<name>`	Toggles the named class while the expression is truthy.
`h.DataAttr(name, e)`	`data-attr:<name>`	Sets the named attribute from the expression.
`h.DataStyle(prop, e)`	`data-style:<prop>`	Sets the named CSS property from the expression.
`h.DataOn(event, stmts…)`	`data-on:<event>`	Runs the statements on that DOM event. Package on writes the same attribute.
`h.DataEffect(stmts…)`	`data-effect`	Runs the statements whenever a signal they read changes.
`h.DataComputed(name, e)`	`data-computed:<name>`	Declares a read-only signal derived from the expression.
`h.DataIndicator(sig)`	`data-indicator`	Names the signal held true while a request from this element is in flight.
`h.DataRef(sig)`	`data-ref`	Names the signal Datastar puts this element into.
`h.DataIgnoreMorph()`	`data-ignore-morph`	Marks a subtree some JavaScript owns, so a live patch leaves it alone.

#on

Each DOM event as a function, so a misspelled event or modifier does not compile. Each has a server form that posts a method and a CS twin that runs an expression in the browser.

#Types

Symbol	Does
#`Bound` `type Bound struct{ … }`	Bound is an action with its argument attached, made by Bind.
#`Option` `type Option func(*config)`	Option is a Datastar event modifier.

#Functions

Symbol	Does
#`Bind` `func Bind[T any](fn func(*via.Ctx, T), arg T) Bound`	Attaches a typed value to the method, so the row's own datum rides with the event. Only an argument the render bound is dispatchable.
#`Blur` `func Blur[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Blur posts fn on blur.
#`BlurCS` `func BlurCS(e expr.Expr, opts ...Option) h.Attr`	BlurCS runs e in the browser on blur.
#`Change` `func Change[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Change posts fn on change.
#`ChangeCS` `func ChangeCS(e expr.Expr, opts ...Option) h.Attr`	ChangeCS runs e in the browser on change.
#`Click` `func Click[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Binds a DOM event to a method: the click posts to the method, not to a URL you invented. Takes a method value or an on.Bind, then options.
#`ClickCS` `func ClickCS(e expr.Expr, opts ...Option) h.Attr`	The client-only twin of Click: runs the expression in the browser and posts nothing.
#`DblClick` `func DblClick[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	DblClick posts fn on dblclick.
#`DblClickCS` `func DblClickCS(e expr.Expr, opts ...Option) h.Attr`	DblClickCS runs e in the browser on dblclick.
#`Event` `func Event[F func(*via.Ctx) \| Bound](name string, fn F, opts ...Option) h.Attr`	Posts a method on an event with no function of its own. The name must be lower-case, such as "pointerdown" or "via:patch"; anything else panics.
#`EventCS` `func EventCS(name string, e expr.Expr, opts ...Option) h.Attr`	The client-only twin of Event: runs the expression in the browser and posts nothing.
#`Focus` `func Focus[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Focus posts fn on focus.
#`FocusCS` `func FocusCS(e expr.Expr, opts ...Option) h.Attr`	FocusCS runs e in the browser on focus.
#`Input` `func Input[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Input posts fn on input, which fires on every keystroke; pair it with WithDebounce.
#`InputCS` `func InputCS(e expr.Expr, opts ...Option) h.Attr`	InputCS runs e in the browser on input.
#`Keydown` `func Keydown[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Keydown posts fn on keydown.
#`KeydownCS` `func KeydownCS(e expr.Expr, opts ...Option) h.Attr`	KeydownCS runs e in the browser on keydown.
#`Keyup` `func Keyup[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Keyup posts fn on keyup.
#`KeyupCS` `func KeyupCS(e expr.Expr, opts ...Option) h.Attr`	KeyupCS runs e in the browser on keyup.
#`Load` `func Load[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Load posts fn on load.
#`LoadCS` `func LoadCS(e expr.Expr, opts ...Option) h.Attr`	LoadCS runs e in the browser on load.
#`MouseEnter` `func MouseEnter[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	MouseEnter posts fn on mouseenter.
#`MouseEnterCS` `func MouseEnterCS(e expr.Expr, opts ...Option) h.Attr`	MouseEnterCS runs e in the browser on mouseenter.
#`MouseLeave` `func MouseLeave[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	MouseLeave posts fn on mouseleave.
#`MouseLeaveCS` `func MouseLeaveCS(e expr.Expr, opts ...Option) h.Attr`	MouseLeaveCS runs e in the browser on mouseleave.
#`Scroll` `func Scroll[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Scroll posts fn on scroll; pair it with WithThrottle.
#`ScrollCS` `func ScrollCS(e expr.Expr, opts ...Option) h.Attr`	ScrollCS runs e in the browser on scroll.
#`Submit` `func Submit[F func(*via.Ctx) \| Bound](fn F, opts ...Option) h.Attr`	Submit posts fn on submit.
#`SubmitCS` `func SubmitCS(e expr.Expr, opts ...Option) h.Attr`	SubmitCS runs e in the browser on submit.

#Options

Symbol	Does
#`WithDebounce` `func WithDebounce(d time.Duration) Option`	Runs the handler once the event stops firing for d. A non-positive d panics.
#`WithModifier` `func WithModifier(raw string) Option`	Appends a Datastar modifier the typed options do not cover, such as "delay.300ms". A malformed or covered one panics.
#`WithOnce` `func WithOnce() Option`	Runs the handler once.
#`WithOutside` `func WithOutside() Option`	Fires only for targets outside the element.
#`WithPrevent` `func WithPrevent() Option`	Calls preventDefault.
#`WithStop` `func WithStop() Option`	Calls stopPropagation.
#`WithThrottle` `func WithThrottle(d time.Duration) Option`	Runs the handler at most once per d. A non-positive d panics.
#`WithWindow` `func WithWindow() Option`	Listens on window.

#expr

The small JavaScript expressions Datastar evaluates in the browser. Signal.Ref() is where one starts: it returns the signal's $name as an expr.Expr. Everything is checked except expr.Raw and the text of expr.Rawf.

#Types

Symbol	Does
#`Expr` `type Expr string`	Expr is a Datastar client expression.
#`Expr.Add` `func (e Expr) Add(v any) Expr`	Adds v to the signal in place. The receiver must be a bare $name.
#`Expr.Assign` `func (e Expr) Assign(v any) Expr`	Writes v to the signal in place. The receiver must be a bare $name.
#`Expr.Eq` `func (e Expr) Eq(v any) Expr`	Comparison with JavaScript's strict ===.
#`Expr.Ge` `func (e Expr) Ge(v any) Expr`	Ge is >=.
#`Expr.Gt` `func (e Expr) Gt(v any) Expr`	Gt is >.
#`Expr.Le` `func (e Expr) Le(v any) Expr`	Le is <=.
#`Expr.Lt` `func (e Expr) Lt(v any) Expr`	Lt is <.
#`Expr.Ne` `func (e Expr) Ne(v any) Expr`	Comparison with JavaScript's strict !==.
#`Expr.Not` `func (e Expr) Not() Expr`	Negates the expression.
#`Expr.String` `func (e Expr) String() string`	The expression source.
#`Expr.Toggle` `func (e Expr) Toggle() Expr`	Negates the signal in place. The receiver must be a bare $name.

#Functions

Symbol	Does
#`All` `func All(es ...Expr) Expr`	Joins the expressions with &&. A single one is returned unchanged; none panics.
#`Any` `func Any(es ...Expr) Expr`	Joins the expressions with \|\|. A single one is returned unchanged; none panics.
#`Call` `func Call(name string, args ...Expr) Expr`	Applies a function by name, which may be a dotted path ("console.log"). An invalid name panics.
#`Class` `func Class(name string, on bool) Expr`	Adds or removes a class on the handler element, for feedback not worth a signal. A morph of the element resets it.
#`CopyTextOf` `func CopyTextOf(sel string) Expr`	Copies the text of the first element matching sel inside the handler element's parent, so a button copies the block beside it.
#`CopyToClipboard` `func CopyToClipboard(text Expr) Expr`	Writes text to the clipboard. Browsers allow it only in a secure context and from a user gesture, so bind it to a click.
#`Do` `func Do(es ...Expr) Expr`	Sequences statements, for an attribute that runs more than one.
#`Raw` `func Raw(js string) Expr`	Emits js verbatim and unchecked. Never build one from user input.
#`Rawf` `func Rawf(format string, args ...Expr) Expr`	Splices checked expressions into unchecked text: each %s takes the next Expr verbatim. The text itself is emitted as written, like Raw.
#`Val` `func Val(v any) Expr`	Encodes v as a JavaScript literal; an Expr passes through unchanged. An @ is escaped so Datastar does not read an @name( in it as an action call.

#Constants and variables

Symbol	Does
#`El` `const El Expr = "el"`	The element the attribute is written on.

#topic

An in-process fan-out broker: one Publish reaches every subscriber. It is one process's memory, with no durability, replay or cross-pod delivery; put a real bus behind a Topic for those.

#Types

Symbol	Does
#`Sub` `type Sub[T any] struct{ … }`	Sub is a subscription.
#`Sub.Drain` `func (s *Sub[T]) Drain() (batch []T, ok bool)`	Drain removes and returns every queued value in publish order.
#`Sub.Dropped` `func (s *Sub[T]) Dropped() int`	Dropped reports how many values this subscription lost to its queue limit.
#`Sub.Ready` `func (s *Sub[T]) Ready() <-chan struct{}`	Ready fires whenever the queue goes from empty to non-empty, and is closed by Stop.
#`Sub.Stop` `func (s *Sub[T]) Stop()`	Stop unsubscribes and closes Ready, ending the reader's loop.
#`Sub.WakeOn` `func (s *Sub[T]) WakeOn(ch chan<- struct{})`	WakeOn routes this subscription's wake-ups to ch as well as to Ready, so one reader can multiplex many subscriptions on a single channel — a live connection drives every ctx.Listen from its own select loop instead of spending a goroutine per subscription.
#`Topic` `type Topic[T any] struct{ … }`	Topic is a typed fan-out broker.
#`Topic.NumSubs` `func (t *Topic[T]) NumSubs() int`	NumSubs returns the number of live subscriptions — the head-count an app publishes as presence, and the number that must fall back to zero once every tab has disconnected.
#`Topic.Publish` `func (t *Topic[T]) Publish(v T)`	Publish queues v for every current subscriber and returns without blocking: no subscriber can stall the publisher or starve the others, and a unit may safely Publish to a topic it also listens to.
#`Topic.Subscribe` `func (t Topic[T]) Subscribe() Sub[T]`	Subscribe registers a new subscriber with DefaultLimit queue capacity.
#`Topic.SubscribeLimit` `func (t Topic[T]) SubscribeLimit(limit int) Sub[T]`	SubscribeLimit registers a new subscriber holding at most limit undelivered values.

#Functions

Symbol	Does
#`New` `func New[T any]() *Topic[T]`	New builds a Topic with no subscribers.

#Constants and variables

Symbol	Does
#`DefaultLimit` `const DefaultLimit = 100_000`	DefaultLimit bounds how many undelivered values one subscriber may hold.

#vt

A black-box test harness: drives a handler over real HTTP through via's public surface, so a test can fire an action or read a live stream without request plumbing.

#Types

Symbol	Does
#`Action` `type Action struct{ … }`	Action is a builder for an action POST.
#`Action.Body` `func (a Action) Body(json string) Action`	Body sets the raw JSON signal body (defaults to "{}").
#`Action.Fire` `func (a *Action) Fire() (int, string)`	Fire issues the POST and returns the status code and the response body.
#`Action.Header` `func (a Action) Header(k, v string) Action`	Header sets any other request header, such as the X-Forwarded-Proto a TLS-terminating proxy adds.
#`Action.Host` `func (a Action) Host(h string) Action`	Host overrides the request Host header (the authority the origin floor compares an Origin against).
#`Action.NoOrigin` `func (a Action) NoOrigin() Action`	NoOrigin sends no origin signal at all, as a non-browser client does: the origin check admits it by default and refuses it under WithTrustedOrigin.
#`Action.Origin` `func (a Action) Origin(o string) Action`	Origin sets the Origin header and suppresses the default Sec-Fetch-Site, so the floor falls through to its Origin-host comparison.
#`Action.Over` `func (a Action) Over(c Conn) *Action`	Over routes this action over c's stream: its viatab signal is set to c's tab id, and — unless Raw overrides it — Fire reads the action's URL off c's own pushed markup (see Conn.ActionURL) instead of a separate plain GET's render.
#`Action.Raw` `func (a Action) Raw(path string) Action`	Raw overrides the URL Fire posts to, bypassing the page-read lookup — for a test that deliberately wants a hand-built or stale URL (e.g.
#`Action.SecFetch` `func (a Action) SecFetch(s string) Action`	SecFetch sets the Sec-Fetch-Site header explicitly.
#`Action.Tab` `func (a Action) Tab(id string) Action`	Tab sets the viatab signal in the POST body, routing a live action to a connection's child — the same channel the real client uses, since Datastar ships the whole (underscore-filtered) signal store with every @post.
#`App` `type App struct{ … }`	App wraps a via handler under an httptest server, registered for cleanup.
#`App.Action` `func (a App) Action(n int) Action`	Action builds a POST to the n-th action the root renders, in document order (the root is child "r").
#`App.ChildAction` `func (a App) ChildAction(child string, n int) Action`	ChildAction builds a POST to the n-th action a child renders, in document order.
#`App.Client` `func (a App) Client() http.Client`	Client returns the server's http.Client, wired to reach it (over the in-memory network for Serve, or trusting the self-signed cert for ServeTLS).
#`App.Connect` `func (a App) Connect() Conn`	Connect opens the per-tab SSE stream and reads the connect-time signals frame that carries the tab id, so the returned Conn is ready to route actions.
#`App.ConnectAt` `func (a App) ConnectAt(path, body string) Conn`	ConnectAt is ConnectWith on a mount other than the root, for a Router with several pages.
#`App.ConnectWith` `func (a App) ConnectWith(body string) Conn`	ConnectWith is Connect with a hand-written connect body — the page signals a real client ships with its @post('/_via/sse').
#`App.Get` `func (a *App) Get(path string) (int, string)`	Get fetches path and returns the status code and body.
#`App.URL` `func (a *App) URL() string`	URL is the server's base URL — the origin a test hand-rolls a request against when the builder methods above don't fit.
#`Conn` `type Conn struct{ … }`	Conn is an open SSE stream to a live child, carrying its per-connection tab id.
#`Conn.ActionURL` `func (c *Conn) ActionURL(child string, n int) string`	ActionURL returns the currently-rendered URL of child's n-th action, in document order — read off the latest datastar-patch-elements frame that carries one, the same markup a browser's DOM would hold at this point, not a separate plain GET's render.
#`Conn.Await` `func (c *Conn) Await(needle string) string`	Await blocks until a frame line containing needle arrives and returns that line, failing the test after 2s otherwise.
#`Conn.AwaitClose` `func (c *Conn) AwaitClose() error`	AwaitClose blocks until the server ends the stream and returns the error that ended it — nil when the response terminated cleanly, which is what a graceful shutdown owes the client; a non-nil error means the client saw a truncated stream.
#`Conn.Close` `func (c *Conn) Close()`	Close cancels the stream.
#`Conn.Peek` `func (c *Conn) Peek() (string, bool)`	Peek takes the next buffered frame without blocking.
#`Conn.TabID` `func (c *Conn) TabID() string`	TabID is the credential a live action must carry to route to this connection; Action.Over splices it in for you.

#Functions

Symbol	Does
#`Logger` `func Logger(t testing.TB) *slog.Logger`	Logger returns a logger that writes each record to t.Log, so via's diagnostics land in the test's own output.
#`Serve` `func Serve(t testing.TB, handler http.Handler) *App`	Serve mounts handler on an in-memory httptest server (req.TLS is nil), so the live-runtime suite can run under testing/synctest without touching a real socket.
#`ServeTLS` `func ServeTLS(t testing.TB, handler http.Handler) *App`	ServeTLS mounts handler on a TLS httptest server, so the action endpoint sees req.TLS != nil and the origin floor enforces the https scheme.

#vtbrowser

Drives a handler in a real headless Chromium, for the bugs httptest cannot see. A separate module, so chromedp stays out of via's dependency graph; a test skips when no browser is found.

#Types

Symbol	Does
#`Session` `type Session struct{ … }`	Session is a live headless-browser tab bound to an httptest server running the handler.
#`Session.Click` `func (s *Session) Click(selector string)`	Click dispatches a real mouse click on the first node matching the CSS selector, waiting for it to become visible first.
#`Session.ConsoleErrors` `func (s *Session) ConsoleErrors() []string`	ConsoleErrors returns every console.error and uncaught exception the tab has produced.
#`Session.Eval` `func (s *Session) Eval(js string, out any)`	Eval runs a JavaScript expression and unmarshals its result into out — the escape hatch for assertions the named helpers don't cover.
#`Session.NewTab` `func (s Session) NewTab() Session`	NewTab opens a second tab in the same browser, pointed at the same server — the way to drive multi-user behavior (fan-out, presence) where two live connections must coexist.
#`Session.Reload` `func (s *Session) Reload()`	Reload re-navigates the tab to the app root — a fresh document load, so a cookie set on the prior load (e.g.
#`Session.RequireCleanConsole` `func (s *Session) RequireCleanConsole()`	RequireCleanConsole fails the test if the tab logged any console error or threw any uncaught exception.
#`Session.Restart` `func (s *Session) Restart(gap time.Duration, handler http.Handler)`	Restart is a deploy: it takes the app's server off the air, leaves it down for the given gap, then serves handler again on the same host:port the tab is still pointed at.
#`Session.Sleep` `func (s *Session) Sleep(d time.Duration)`	Sleep settles for d.
#`Session.Text` `func (s *Session) Text(selector string) string`	Text returns the trimmed textContent of the first node matching the selector (empty string if none).
#`Session.Type` `func (s *Session) Type(selector, text string)`	Type focuses the first node matching the selector and sends text as real key events, so input/keydown listeners (and Datastar binds) fire as for a human.
#`Session.Value` `func (s *Session) Value(selector string) string`	Value returns the value of the first input matching the selector.
#`Session.WaitBoundSignal` `func (s *Session) WaitBoundSignal(selector, want string)`	WaitBoundSignal blocks until the Datastar signal bound to selector (the slot named by its data-bind attribute) holds want.
#`Session.WaitEvalTrue` `func (s *Session) WaitEvalTrue(js, desc string)`	WaitEvalTrue polls a JavaScript boolean expression until it evaluates true, failing after defaultTimeout.
#`Session.WaitFor` `func (s *Session) WaitFor(selector string, ok func(text string) bool, desc string)`	WaitFor polls the trimmed textContent of selector until ok reports true, failing after defaultTimeout with the last observed text.
#`Session.WaitLiveConnected` `func (s *Session) WaitLiveConnected()`	WaitLiveConnected blocks until this tab's SSE stream has delivered its first frame.
#`Session.WaitLoaded` `func (s *Session) WaitLoaded()`	WaitLoaded blocks until the document has fully loaded, i.e.
#`Session.WaitTextContains` `func (s *Session) WaitTextContains(selector, want string)`	WaitTextContains polls until the first node matching selector has textContent containing want, absorbing SSE patch latency without a fixed sleep.
#`Session.WaitValue` `func (s *Session) WaitValue(selector, want string)`	WaitValue polls until the first input matching selector has value want.

#Functions

Symbol	Does
#`Open` `func Open(t testing.TB, handler http.Handler) *Session`	Open starts an httptest server for handler, launches headless Chromium, navigates to the app root, and returns the bound Session.