Build experiences people share together.

You build a normal web app. Cya runs it for everyone at once and keeps them in sync. A room is simply where that shared experience happens — a live session with a host, promoted participants, and an audience, from a few people to thousands. When the host launches your app, every participant's client mounts your bundle in a sandboxed iframe and hands it a session token over the Cya App Bridge (CAB, a typed postMessage contract). From there, the SDK is your entire backend:

┌─ Cya Room (host + audience) ─────────────────────────────┐
│  ┌─ your iframe: <appId>.apps.cya.live/<version>/ ──────┐  │
│  │  @cya/app-sdk                                        │  │
│  │   ├─ app.sync    documents · signals · counters      │  │
│  │   ├─ app.roles   participants · consent invites      │  │
│  │   ├─ app.storage R2 assets + JSON KV (quota'd)       │  │
│  │   └─ app.clock   server clock for drift-free timing  │  │
│  └───────────────────────────────────────────────────────┘  │
│        ▲ CAB handshake + 5-min capability tokens            │
└──────────────────────────────────────────────────────────────┘

Every write lands on one server-side instance and fans out to all participants in order, so everyone converges on the same state — late joiners included. You don't stand up servers, sockets, or a database, and assets get server-enforced storage out of the box. Building synchronized software feels like building a normal web app.

npm i -g @cya/cli
cya app init my-app     # scaffold with @cya/app-sdk wired up
cd my-app && npm install
cya app dev             # local host simulator

One call. The SDK handles the handshake, token refresh, and reconnection:

import { connectCyaApp } from "@cya/app-sdk";

const app = await connectCyaApp();      // CAB handshake → ready
const { self, event } = app.context;
console.log(event.eventId, self.userId, self.platformRole);

// shared, synchronized state — every participant sees this
const game = app.sync.doc("game");
game.on("change", ({ value }) => render(value));
if (app.roles.has("host")) {
  await game.set({ round: 1, phase: "lobby" });
}

Validate, bundle and submit:

cya check               # manifest + scope lint (same checks as review)
cya pack                # produce the uploadable bundle
# then: cya publish, or upload via the developer portal UI

Prefer the UI? The developer portal mirrors the CLI: add your listing, icon, and screenshots, paste your manifest, pick your built dist/ folder, and submit. Build with a relative base (vite base: './') — bundles are served under a versioned path.

connectCyaApp() resolves after the CAB connect → init → joined handshake with a ready CyaApp. The host may pause, resume or tear your app down at any time.

Tokens are scoped to your manifest and expire in ~5 minutes; the SDK refreshes them for you. Nothing your app can do outlives the session.

Four primitives, all synchronized for you. Writes are ordered server-side and every participant converges on the same state — late joiners included, via snapshot plus replay. This is the core of Cya: shared state that just works.

Documents — shared mutable state

const game = app.sync.doc("game");
try {
  await game.set({ "players.u42.score": 10 }, { ifRev: game.rev });
} catch {
  // someone wrote first — doc.value is already fresh, retry your patch
}

Signals — fire-and-forget events

Counters — server-tallied numbers

Playback — synced media clock

Promote participants into roles — contestants, co-hosts, panelists. Promotion is consent-based: invite() asks, the user accepts in Cya's own UI, and only then does the grant land (assign() grants directly where your policy allows it). Role-scoped channels carry private state, like a contestant's hidden prompt.

R2-backed assets and a small JSON KV, scoped per app and per user with server-enforced quotas. Declare the scopes you need:

The manifest is your capability contract. A namespace exists on the SDK only if you declare it, and the server enforces the same set on every call (E_SCOPE otherwise). Reviewers see exactly what you ask for.

{
  "appId": "my-poker-app",
  "name": "Poker Night",
  "apiVersion": "1",
  "entry": "index.html",
  "policy": {
    "docs":     { "game": {}, "hand": { "perUser": true } },
    "roles":    { "player": { "max": 6 } },
    "signals":  ["buzz"],
    "counters": ["pot"]
  },
  "storage": { "scopes": ["room:shared", "room:self"] }
}

Submission runs automated checks first (blocking):

• manifest schema + scope lint (undeclared API usage fails)
• bundle sanity — entry file present, no root-absolute asset paths
• size and content-type limits

Then Cya runs your app in a staging room with synthetic participants — lifecycle, role flows, and storage. Track status in the portal — submitted → in review → approved / rejected. Approved versions go live in the Apps Center; creators install once, and your app reaches every audience they bring. New versions ship through the same pipeline while your current one keeps serving.