PubSub class

const msg = await room.pubsub.publish('chat', { text: 'hello' });
console.log(msg.id, msg.timestamp);
// Render in your own UI — subscribe does NOT echo own messages

await room.pubsub.publish('cursor', { x: 120, y: 340 }, { persist: false });
// Not stored in history; subscribers receive it but getHistory won't return it later

await room.pubsub.publish('chat', { text: 'private hi' }, {
  to: ['alice'],   // only Alice's subscribe handlers fire
});

await room.pubsub.publish('events', { action: 'click' }, {
  metadata: { priority: 'low', source: 'main-app' },
});

// Subscriber side
sub.handler = (msg) => {
  if (msg.metadata?.priority === 'high') showToast(msg);
};

async function sendChat(text) {
  const uiKey = appendToUI({ text, status: 'pending' });
  try {
    const real = await room.pubsub.publish('chat', { text });
    upgradeUI(uiKey, real);
  } catch (err) {
    markFailedUI(uiKey, err);
  }
}

const sub = await room.pubsub.subscribe('chat', (msg) => {
  console.log(msg.from, msg.payload, msg.timestamp);
});

// Later
await sub.unsubscribe();

interface ChatPayload { text: string; }

const sub = await room.pubsub.subscribe<ChatPayload>('chat', (msg) => {
  msg.payload.text;   // ← typed
});

// subscribe (live) and getHistory (backlog) are independent — run them together
const [sub, page] = await Promise.all([
  room.pubsub.subscribe('chat', appendToView),
  room.pubsub.getHistory('chat'),
]);

prependToView(page.messages);   // backlog — [] if the topic is empty, harmless
// sub now delivers every new message via appendToView

// Cap to 30 msg/sec for human-readable UI
const sub = await room.pubsub.subscribe('chat', renderMessage, { limit: 30 });
// SDK drops oldest messages in window when burst exceeds 30/sec

// PageA.tsx
const subA = await room.pubsub.subscribe('chat', renderMessage);
// On unmount: subA.unsubscribe()

// PageB.tsx (different file — doesn't need subA)
const subB = await room.pubsub.subscribe('chat', notifyOnMention);
// On unmount: subB.unsubscribe()

// SDK: refcount = 2 → 1 wire subscription. Both handlers fire per message.

useEffect(() => {
  let sub: PubSubSubscription | null = null;

  (async () => {
    sub = await room.pubsub.subscribe('chat', handler);
  })();

  return () => { sub?.unsubscribe(); };   // idempotent — safe in strict mode
}, []);

const page = await room.pubsub.getHistory('chat');
render(page.messages);                       // oldest-first — render top to bottom
// page.messages === [] on an empty topic — no error

let page = await room.pubsub.getHistory('chat');
render(page.messages);

async function loadOlder() {
  if (!page.hasMore) return;                 // no older history
  page = await room.pubsub.getHistory('chat', {
    before: page.messages[0].id,             // oldest id in the current page
  });
  prepend(page.messages);
}

// While connected, capture the id of the last live message
let lastSeenId = null;
await room.pubsub.subscribe('chat', (msg) => {
  append(msg);
  lastSeenId = msg.id;                       // every message carries its own id
});

// ── after a disconnect, then reconnect ──

// Fetch everything published during the outage
let page = await room.pubsub.getHistory('chat', { after: lastSeenId });
append(page.messages);

while (page.hasMore) {                       // more newer messages to catch up on
  page = await room.pubsub.getHistory('chat', {
    after: page.messages.at(-1).id,          // newest id in the current page
  });
  append(page.messages);
}

// Only messages from Alice or Bob — filtered server-side, then paged
let page = await room.pubsub.getHistory('chat', { from: ['alice', 'bob'] });
render(page.messages);

if (page.hasMore) {                          // hasMore reflects the FILTERED set
  page = await room.pubsub.getHistory('chat', {
    from:   ['alice', 'bob'],
    before: page.messages[0].id,
  });
}