Add Realtime

Realtime in Kizaki is query-based. You do not create a separate subscription schema or duplicate your access rules.

That design is deliberate. A read that is worth rendering once is often worth keeping current, and Kizaki tries to make those two cases feel like the same model rather than two different systems.

Start With A Normal Query

import { select } from "@kizaki/sdk/browser";
import { useQuery } from "@kizaki/react";
import { Message } from "@kizaki/schema";

const messagesQuery = select(Message)
  .fields(Message.id, Message.body, Message.createdAt)
  .orderBy("createdAt", "desc");

export function Messages() {
  const messages = useQuery(messagesQuery);
  // renders initial fetch + live updates
}

That same query object:

• fetches immediately
• subscribes for live updates
• stays filtered by the same read policies as every other read

This is why the browser stack works well with the rest of the platform. The same query object describes:

• what the UI wants
• what the user is allowed to see
• what should stay current over time

How To Think About It

The recommended mental model is simple:

• if a user can read a row now, they can receive updates about that row
• if a user loses access, the live query is invalidated and refetched safely
• authorization stays in Inspire, not in client-side subscription code

Recommended Usage Pattern

• use live queries for lists, dashboards, and activity-heavy screens
• keep writes behind exposed functions and generated client calls
• let invalidation and live updates refresh the UI instead of rebuilding your own subscription architecture

What To Do Next

After the browser loop is working, learn the safe schema workflow in Evolve Your Schema.