Realtime for SvelteKit, running live

Five rapid RPCs, one effect. live.idempotent.

Drop network 10s, reconnect, no refetch. Session resume + replay buffer.

live.room bundles messages and presence; live.idempotent on send; FORBIDDEN banner on the members-only room.

rpc.createOptimistic + force-fail toggle. Spam x5 with force-fail on; placeholders roll back independently.

Two orgs (Acme / Globex), one identity cookie. Cross-org subscribes return FORBIDDEN at the wire gate.

A log feed with 200 entries served in pages of 25. Loader returns { data, hasMore, cursor }; client store exposes loadMore(). Live 'created' publishes merge into the visible list regardless of which pages have been loaded.

A 1Hz event ticker; tab unsubscribes mid-flight; on resubscribe the server's bounded replay buffer covers short gaps and delta.fromSeq(sinceSeq) bridges to the durable store for older gaps. Each event is tagged with the tier that delivered it.

One stream at version: 2 with migrate: { 1: v1ToV2 }. Two panels: a normal subscribe and one via subscribeAt(stream, { schemaVersion: 1 }) from svelte-realtime/testing/client - the wire envelope claims v1, the server runs migrate[1] end-to-end, the migrated badge flips back to loader on each live publish.

An orders stream's publishes trigger a live.effect(['orders'], handler) that fans out to an audit feed and a notifications feed. Three streams in one page; the effect handler is fire-and-forget.

Drive a stream's attach machine by hand - attach() holds it open with no UI subscriber, detach() means done - with the phase badge live. Then prove ctx.batch(fn) drops every buffered publish on a throw, even across an await boundary.

Live platform.pressure readout + sparkline + load generator + shed log.

Seed + drop rate, fully reproducible. Same inputs, same green/red pattern.

live.push request/reply across users, cluster registry wiring, and a 6-field live.cron tick draining the schedule queue.

Postgres-backed createTaskRunner with Redis fence, retry policy, idempotency cache, and force-takeover. live.cron tick polls the table and fans out the row list + status counts.

Redis-backed leader election visualised. createLeader + configureCron({ leader }) gate a 1Hz live.cron so it fires once cluster-wide instead of once per worker.

Three products, limited stock, multi-tab race. live.lock({ key, maxWaitMs }, ...) serializes per-item buys FIFO so stock never goes negative; bursts past the bound surface as LOCK_TIMEOUT. Coupon claim rides live.idempotent keyed on userId for one-per-user enforcement.

List a lot, server fans out live.push to every other tab in parallel, Promise.allSettled collects every reply by the deadline. Each accepted bid ctx.publishes 'updated' on the active stream so the waterfall fills in real time.

ctx.setAlarm(at) arms a per-room one-shot; onAlarm fires with a fresh server ctx even if every tab is closed. Redis-backed configureAlarm({ store, leader }) makes it survive worker restarts and fire exactly once cluster-wide; the fired log shows lateMs and a recovered badge when the recovery poll (not the precise timer) fired it.

live.room with meta + enumerable lights up a live lobby browser (lobby.rooms()); owner: true tracks the host role with deterministic succession and ownerOnly gates Close table server-side; shortCodes() mints each card's unguessable share code, decoded by a server RPC.

Two live.flag declarations plus a validated setFlag RPC. Operator card flips a promo banner and a dark-launch rollout slider; every client updates instantly and fresh connects to any replica replay the cluster-latest value.

Streaming file uploads via live.upload. SHA-256 chunk hashes go through redis/idempotency so re-uploads skip storage; live.notify({ userId }) fires a fire-and-forget push to the same user's other tabs when a file lands.

Two live.multiplayer rooms share one live.doc textarea. Select a word in tab A, type before it in tab B: the selections: 'offset' highlight drifts onto the wrong characters, the selections: 'crdt' one re-anchors via room.bindDoc(doc) and stays glued.

One live.multiplayer room with every surface on: live cursors over a shared canvas via room.move, presence roster, an advisory locks: ['headline'] input with lock-on-focus, room.setTyping indicator, and ephemeral emoji room.react emotes on a dedicated stream.

One live.doc, zero RPC handlers. A cards map + one order array per column; moves ride doc.transact() as one atomic wire update. Concurrent moves from two tabs both survive, offline edits merge on reconnect - the local replica IS the offline queue.

Guestbook whose posts survive losing the network. configure({ offline: { queue, persist, persistKey } }) queues to IndexedDB across reloads; replay carries synthesized idempotency keys that the server's live.idempotent wrapper dedups, so entries land exactly once. Live pendingMutations / uploading / offlineCheckpoint() readouts.

A 2400x1600 world with 150 server-driven NPCs, but each client only receives its 420-unit neighbourhood: live.smooth({ interest }) with LOD bands throttling the fringe. HUD shows the live receiving/total ratio; spectate mode pans the cull via view.reportCenter.

Click-to-shoot rays resolve against the world AS YOU RENDERED IT: live.smooth({ hitTest }) rewinds each candidate to the shot's render-time stamp (server-measured uplink + interp, capped at maxRewindMs: 400). A 0-400ms latency slider delays your sends; aimed shots still land.

live.aggregate({ windows }) with sliding, tumbling, and lifetime slices in parallel. Speed slider + bias controls drive the visual diff between window types.

Four primitives in one page. live.cron firehose feeds live.aggregate({ windows }); live.derived tracks stats; HMAC-signed Publish form round-trips through live.webhook.

One mood topic, two live.aggregate exports with identical reducers. Raw moves on every submission; the one with privacy: { k: 3, strategy: 'hybrid' } holds its last published value below 3 distinct contributors per round and publishes with seeded Laplace noise at k - the k-drop itself stays invisible.

Leave traces (app log, idempotency cache, presence, push), then live.forget(ctx.user.id) purges them cluster-wide and resolves only after the durable store confirms. The returned surfaces map renders as a per-surface erasure audit; the app-owned Redis half is deleted alongside.

One introspect() call rendered as an ops panel - connections, in-flight work, topic load, handlers by kind, push registry, admission posture, and the DLQ summary. Counts-only and PII-free by design, polled while visible; the auth-gated /__realtime admin plane serves the same snapshot over HTTP.

live.webhooks.outbound POSTs an HMAC-signed body with an idempotency-key to a sink on every publish - leader-gated, fleet-shared retry budget and breaker. Place a failing order to watch retries exhaust into the cluster-shared Redis DLQ, then replay the original payload.

One scratchpad on one literal topic; realtime({ tenant }) scopes everything the connection touches to @t/<id>/... at the wire layer. Handlers are byte-identical to a single-tenant app - only the app-owned Redis key names ctx.tenantId.