LAPLACE Chat

# Enter the Go module and run from source
cd packages/server
go run . --debug

# Or build a native binary
go build -o leb-server .
./leb-server --host 0.0.0.0 --auth "your-secure-token"

# Start the Bun server
bun run --cwd packages/server-bun start --debug --auth "your-secure-token"

You are helping me build an integration on top of LAPLACE Event Bridge, the WebSocket
bridge that relays real-time Bilibili live events — chat messages, gifts, super chats,
guard purchases, stream state — from LAPLACE Chat (https://chat.laplace.live) to local
clients.

Before writing any code, fetch the reference documents listed at the end — they are
the single source of truth for event types, payload fields and the client API. Do
not rely on memory and do not invent names.

## Setup

- Install `@laplace.live/event-bridge-sdk`. It runs anywhere with `WebSocket` and
  `fetch` globals: Node.js 22+, Bun and browsers. Event payload interfaces live in
  its dependency `@laplace.live/event-types`.
- A bridge server must be running: either the `leb-server` binary fed by LAPLACE Chat
  or an SDK v1.2.0+ producer using `role: 'server'`, or LAPLACE Event Fetcher v2.2.0+
  in bridge mode (standalone). Default endpoint: `ws://localhost:9696`.
- Auth is optional: when the server was started with `--auth`, pass the same string
  as `token`.

## Client

```ts
import { LaplaceEventBridgeClient } from "@laplace.live/event-bridge-sdk";

const bridge = new LaplaceEventBridgeClient({
  url: "ws://localhost:9696", // default
  token: "your-auth-token", // only when the server enables auth
});

bridge.on("message", (event) => {
  console.log(`${event.username}: ${event.message}`); // typed as Message
});
const offAny = bridge.onAny((event) => console.log(event.type, event.origin));

await bridge.connect();
// later: offAny(); bridge.disconnect();
```

## Producer (Server Role)

SDK v1.2.0+ can instead occupy the event-producing server role. This connects to
a running standalone Event Bridge server; it does not start the bridge server itself.

```ts
const producer = new LaplaceEventBridgeClient({
  url: "ws://localhost:9696",
  token: "your-auth-token",
  role: "server",
});

await producer.connect();
producer.send(event); // event must be a LaplaceEvent
```

Only server-role messages are broadcast. A client-role `send()` is acknowledged by
the bridge but is not relayed to other connections.

The bridge is one-way — servers broadcast, clients listen — and reconnection is
automatic. Handlers are typed from the event name. Every event carries `type`, `id`
and `origin` (the canonical room id — filter on it when one bridge serves several
rooms). The exact event names, payload fields and the rest of the client API live in
the reference below — look them up instead of guessing.

## Reference

Fetch these before writing code:

- https://laplace.live/chat/event-bridge.en.mdx — this page as raw Markdown: server
  setup, SDK client and producer roles, connection state, room discovery
- https://chat.laplace.live/event-types/ — every event type and payload field
- https://github.com/laplace-live/event-bridge — server and SDK source with runnable
  examples

import { LaplaceEventBridgeClient } from "@laplace.live/event-bridge-sdk";

const client = new LaplaceEventBridgeClient({
  url: "ws://localhost:9696",
  token: "your-auth-token", // If auth is enabled
});

// Connect to the bridge
await client.connect();

// Listen for specific events
client.on("message", (event) => {
  console.log("Received message:", event);
});

// Listen for all events
client.onAny((event) => {
  console.log("Received event:", event.type);
});

import { LaplaceEventBridgeClient } from "@laplace.live/event-bridge-sdk";

const producer = new LaplaceEventBridgeClient({
  url: "ws://localhost:9696",
  token: "your-auth-token",
  role: "server",
});

await producer.connect();

function broadcast(event: Parameters<typeof producer.send>[0]) {
  producer.send(event);
}

client.onConnectionStateChange((state, detail) => {
  console.log(state, detail?.reconnectAttempts);

  if (detail?.closeEvent) {
    console.log(detail.closeEvent.code, detail.closeEvent.reason);
  }
});

console.log(client.getReconnectAttempts());

const client = new LaplaceEventBridgeClient({
  url: "ws://localhost:9696",
  token,
});

const info = await client.getInfo();
if (info) {
  console.log(`Fetcher v${info.version} exposes ${info.rooms.length} room(s)`);
  for (const room of info.rooms) {
    console.log(`${room.roomId}: ${room.username ?? "unknown"}`);
  }
} else {
  // Plain Event Bridge server or an older fetcher — fall back to manual entry.
}

import { fetchInfo } from "@laplace.live/event-bridge-sdk";

const info = await fetchInfo({ url: "ws://localhost:9696", token, signal });

import type { FetcherInfo, FetcherRoom } from "@laplace.live/event-bridge-sdk";

interface FetcherRoom {
  status: number; // 0 when resolved, otherwise an error code (e.g. 404)
  uid: number;
  roomId: number; // Canonical room id; matches the `origin` field on incoming events
  shortRoomId: number;
  username: string | null;
}

interface FetcherInfo {
  version: string;
  uptime: string;
  connectedAt: number;
  websocketBridge: boolean;
  websocketClients: number;
  rooms: FetcherRoom[];
}