relaybrain 0.0.0-stage → 0.2.0

package/backend/lib/roomSignal.js

@@ -0,0 +1,265 @@
+const { spawn } = require("child_process");
+const { parseGithubRepo } = require("./githubRepo");
+const { inviteState, invitesOf, normLogin } = require("./roomAuth");
+
+const SIGNAL_PREFIX = "relay-room:";
+const SIGNAL_FILE = "relay-signal.json";
+const PROOF_FILE = "relay-proof.json";
+
+function repoKeyFromRemote(remoteUrl) {
+  const parsed = parseGithubRepo(remoteUrl);
+  return parsed ? `${parsed.owner}/${parsed.repo}` : null;
+}
+
+function signalDescription(repoKey) {
+  return `${SIGNAL_PREFIX}${repoKey}`;
+}
+
+function invitedLogins(room) {
+  return invitesOf(room)
+    .filter((i) => {
+      const state = inviteState(i);
+      return state === "pending" || state === "accepted";
+    })
+    .map((i) => normLogin(i.login))
+    .filter(Boolean);
+}
+
+function ghApi(pathname, { method = "GET", body } = {}) {
+  const args = ["api", pathname, "-H", "Accept: application/vnd.github+json"];
+  if (method && method !== "GET") args.push("-X", method);
+  if (body !== undefined) args.push("--input", "-");
+  return new Promise((resolve, reject) => {
+    const child = spawn("gh", args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, shell: false });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (c) => (out += c));
+    child.stderr.on("data", (c) => (err += c));
+    child.on("error", () => reject(new Error("gh_not_installed")));
+    child.on("exit", (code) => {
+      if (code !== 0) return reject(new Error(err.trim() || `gh exited ${code}`));
+      const text = out.trim();
+      if (!text) return resolve({});
+      try {
+        resolve(JSON.parse(text));
+      } catch {
+        resolve(text);
+      }
+    });
+    if (body !== undefined) child.stdin.write(JSON.stringify(body));
+    child.stdin.end();
+  });
+}
+
+async function readGist(id) {
+  if (!id) return null;
+  try {
+    return await ghApi(`gists/${id}`);
+  } catch {
+    try {
+      const res = await fetch(`https://api.github.com/gists/${id}`, {
+        headers: { "User-Agent": "relay-it", Accept: "application/vnd.github+json" },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) return null;
+      return res.json();
+    } catch {
+      return null;
+    }
+  }
+}
+
+function parseSignal(gist) {
+  if (!gist?.id) return null;
+  const desc = String(gist.description || "");
+  if (!desc.startsWith(SIGNAL_PREFIX)) return null;
+  const raw = gist.files?.[SIGNAL_FILE]?.content;
+  let body = {};
+  if (raw) {
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  return {
+    v: body.v || 1,
+    live: body.live !== false,
+    roomId: body.roomId || null,
+    url: body.url || null,
+    hostLogin: body.hostLogin || gist.owner?.login || null,
+    repoKey: body.repo || desc.slice(SIGNAL_PREFIX.length),
+    projectName: body.projectName || null,
+    nonce: body.nonce || null,
+    invited: Array.isArray(body.invited) ? body.invited.map(normLogin) : [],
+    updatedAt: body.updatedAt || null,
+    gistId: gist.id,
+  };
+}
+
+function signalPayload(room, { repoKey, hostLogin }) {
+  return {
+    v: 1,
+    live: room.live !== false,
+    roomId: room.roomId,
+    url: room.url || null,
+    hostLogin,
+    repo: repoKey,
+    projectName: room.hostProjectName || null,
+    nonce: room.nonce,
+    invited: invitedLogins(room),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+async function findOwnSignalGist(repoKey) {
+  try {
+    const mine = await ghApi("gists");
+    const description = signalDescription(repoKey);
+    return (Array.isArray(mine) ? mine : []).find((g) => g.description === description) || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Publishes the current tunnel URL under a well-known public gist so a guest
+ * can find the host again after ngrok recycles the URL. Membership credentials
+ * stay in room.json — the gist is only a pointer.
+ */
+async function publishSignal(room, { repoKey, hostLogin }) {
+  if (!room?.roomId || !repoKey || !hostLogin) {
+    return { ok: false, error: "signal_incomplete" };
+  }
+  const description = signalDescription(repoKey);
+  const files = { [SIGNAL_FILE]: { content: JSON.stringify(signalPayload(room, { repoKey, hostLogin }), null, 2) } };
+  const patch = async (id) => {
+    await ghApi(`gists/${id}`, { method: "PATCH", body: { description, files } });
+    return { ok: true, gistId: id };
+  };
+  if (room.signalGistId) {
+    try {
+      return await patch(room.signalGistId);
+    } catch {
+      /* gist was deleted — fall through and recreate */
+    }
+  }
+  const existing = await findOwnSignalGist(repoKey);
+  if (existing?.id) return patch(existing.id);
+  const created = await ghApi("gists", {
+    method: "POST",
+    body: { description, public: true, files },
+  });
+  if (!created?.id) return { ok: false, error: "gist_create_failed" };
+  return { ok: true, gistId: created.id };
+}
+
+async function findSignal({ gistId, hostLogin, repoKey, roomId } = {}) {
+  if (gistId) {
+    const signal = parseSignal(await readGist(gistId));
+    if (signal && (!roomId || signal.roomId === roomId) && (!repoKey || signal.repoKey === repoKey)) return signal;
+  }
+  if (!hostLogin || !repoKey) return null;
+  let gists = [];
+  try {
+    gists = await ghApi(`users/${encodeURIComponent(hostLogin)}/gists`);
+  } catch {
+    try {
+      const res = await fetch(`https://api.github.com/users/${encodeURIComponent(hostLogin)}/gists`, {
+        headers: { "User-Agent": "relay-it", Accept: "application/vnd.github+json" },
+        signal: AbortSignal.timeout(6000),
+      });
+      if (res.ok) gists = await res.json();
+    } catch {
+      gists = [];
+    }
+  }
+  const description = signalDescription(repoKey);
+  const match = (Array.isArray(gists) ? gists : []).find((g) => g.description === description);
+  if (!match?.id) return null;
+  const signal = parseSignal(await readGist(match.id));
+  if (!signal) return null;
+  if (roomId && signal.roomId !== roomId) return null;
+  return signal;
+}
+
+async function discoverRooms({ repoKey, logins, myLogin }) {
+  const me = normLogin(myLogin);
+  const hosts = [...new Set((logins || []).map(normLogin).filter((l) => l && l !== me))];
+  const rooms = [];
+  for (const hostLogin of hosts) {
+    try {
+      const signal = await findSignal({ hostLogin, repoKey });
+      if (!signal?.live || !signal.url) continue;
+      if (!signal.invited.includes(me)) continue;
+      rooms.push({
+        hostLogin: signal.hostLogin,
+        url: signal.url,
+        roomId: signal.roomId,
+        projectName: signal.projectName,
+        invited: true,
+        updatedAt: signal.updatedAt,
+        gistId: signal.gistId,
+      });
+    } catch {
+      /* one collaborator failing must not hide the others */
+    }
+  }
+  return rooms;
+}
+
+async function createProof({ roomId, nonce, login }) {
+  const gist = await ghApi("gists", {
+    method: "POST",
+    body: {
+      description: `relay-proof:${roomId}`,
+      public: false,
+      files: {
+        [PROOF_FILE]: {
+          content: JSON.stringify({ v: 1, roomId, nonce, login: normLogin(login), ts: Date.now() }),
+        },
+      },
+    },
+  });
+  if (!gist?.id) throw new Error("proof_create_failed");
+  return gist.id;
+}
+
+async function deleteGist(id) {
+  if (!id) return;
+  try {
+    await ghApi(`gists/${id}`, { method: "DELETE" });
+  } catch {
+    /* leftover proof gists are secret and expire from usefulness with the nonce */
+  }
+}
+
+async function verifyProof({ gistId, roomId, nonce, login }) {
+  const gist = await readGist(gistId);
+  if (!gist?.id) return { ok: false, reason: "proof_missing" };
+  if (normLogin(gist.owner?.login) !== normLogin(login)) return { ok: false, reason: "proof_wrong_user" };
+  const raw = gist.files?.[PROOF_FILE]?.content;
+  let body;
+  try {
+    body = JSON.parse(raw || "");
+  } catch {
+    return { ok: false, reason: "proof_invalid" };
+  }
+  if (!body || body.roomId !== roomId || body.nonce !== nonce) return { ok: false, reason: "proof_mismatch" };
+  return { ok: true };
+}
+
+const GIST_SCOPE_HINT =
+  "Sharing is up, but teammates cannot auto-find you yet. Run `gh auth refresh -s gist` once so Relay can publish a join signal. Until then, send them the invite link.";
+
+module.exports = {
+  repoKeyFromRemote,
+  invitedLogins,
+  publishSignal,
+  findSignal,
+  discoverRooms,
+  createProof,
+  deleteGist,
+  verifyProof,
+  GIST_SCOPE_HINT,
+};

package/backend/lib/roomSync.js

@@ -0,0 +1,194 @@
+const { loadMemory, saveMemory } = require("./store");
+const { loadLocalCollisions } = require("./collisionMetrics");
+
+// What one machine publishes to the room, and what it stores for every other
+// machine in the room. Kept in the same memory.json as local history so the
+// dashboard can merge both without a second store — but in a separate
+// `roomPeers` bucket, so a peer's history is never re-published as our own
+// (which would echo back and forth and grow without bound).
+const MAX_THREADS = 24;
+const MAX_MESSAGES = 80;
+const MAX_EDITS = 200;
+const MAX_ACTIVITY = 60;
+const MAX_TIMELINE = 40;
+// Transcript text is clipped to 8000 chars locally; at 24 threads x 80 messages
+// that is a 15MB request per poll over a home-broadband tunnel. Peers get a
+// shorter clip — enough to read the conversation, small enough to send often.
+const MAX_MESSAGE_CHARS = 3000;
+const PEER_TTL_MS = 6 * 60 * 60 * 1000;
+
+function trimThread(thread) {
+  return {
+    ...thread,
+    messages: (thread.messages || []).slice(-MAX_MESSAGES).map((m) => ({
+      ...m,
+      text: typeof m.text === "string" && m.text.length > MAX_MESSAGE_CHARS ? `${m.text.slice(0, MAX_MESSAGE_CHARS)}\n…` : m.text,
+    })),
+  };
+}
+
+/** The locally-owned slice of a workspace's memory, sized for the wire. */
+function localSnapshot(memory, login, projectId) {
+  const stats = { ...(memory.stats || {}) };
+  // Prefer file-backed collision counters so room peers see the durable totals.
+  if (projectId) stats.collisions = loadLocalCollisions(projectId);
+  return {
+    login,
+    updatedAt: Date.now(),
+    lastTranscriptSyncAt: memory.lastTranscriptSyncAt || 0,
+    chats: (memory.chats || []).slice(0, MAX_THREADS).map(trimThread),
+    timeline: (memory.timeline || []).slice(0, MAX_TIMELINE),
+    activity: (memory.activity || []).slice(0, MAX_ACTIVITY),
+    edits: (memory.edits || []).slice(0, MAX_EDITS),
+    agents: (memory.agents || []).filter((a) => a.status === "connected"),
+    stats,
+  };
+}
+
+function sanitize(snapshot, login) {
+  if (!snapshot || typeof snapshot !== "object") return null;
+  const owner = login || snapshot.login || "peer";
+  const stamp = (rows, cap) =>
+    (Array.isArray(rows) ? rows : []).slice(0, cap).map((row) => ({ ...row, ownerLogin: row.ownerLogin || owner, mine: false }));
+  return {
+    login: owner,
+    updatedAt: Date.now(),
+    lastTranscriptSyncAt: Number(snapshot.lastTranscriptSyncAt) || 0,
+    chats: stamp(snapshot.chats, MAX_THREADS).map(trimThread),
+    timeline: stamp(snapshot.timeline, MAX_TIMELINE),
+    activity: stamp(snapshot.activity, MAX_ACTIVITY),
+    edits: stamp(snapshot.edits, MAX_EDITS),
+    agents: Array.isArray(snapshot.agents) ? snapshot.agents.slice(0, 20).map((a) => ({ ...a, ownerLogin: owner })) : [],
+    stats: snapshot.stats && typeof snapshot.stats === "object" ? snapshot.stats : {},
+  };
+}
+
+/**
+ * Records what a peer reported. `key` is the peer's login on the host side and
+ * the literal "host" on a guest, so a guest holds exactly one aggregated bucket
+ * instead of one per room member.
+ */
+function savePeerSnapshot(projectId, key, snapshot, login) {
+  const clean = sanitize(snapshot, login || key);
+  if (!clean) return null;
+  const memory = loadMemory(projectId);
+  const peers = memory.roomPeers && typeof memory.roomPeers === "object" ? memory.roomPeers : {};
+  const now = Date.now();
+  for (const [name, row] of Object.entries(peers)) {
+    if (now - (row?.updatedAt || 0) > PEER_TTL_MS) delete peers[name];
+  }
+  peers[key] = clean;
+  memory.roomPeers = peers;
+  saveMemory(projectId, memory);
+  require("./falkor/bus").emit("peer", { projectId, key, login: clean.login, snapshot: clean });
+  return clean;
+}
+
+function clearPeers(projectId) {
+  const memory = loadMemory(projectId);
+  if (!memory.roomPeers) return;
+  delete memory.roomPeers;
+  saveMemory(projectId, memory);
+}
+
+function peerSnapshots(memory, { exclude } = {}) {
+  const peers = memory?.roomPeers && typeof memory.roomPeers === "object" ? memory.roomPeers : {};
+  return Object.entries(peers)
+    .filter(([key, row]) => row && key !== exclude && row.login !== exclude)
+    .map(([, row]) => row);
+}
+
+function dedupeById(rows, sortKey) {
+  const byId = new Map();
+  for (const row of rows) {
+    if (!row) continue;
+    const key = row.id || `${row.ownerLogin}:${row.ts || row.updatedAt}`;
+    const existing = byId.get(key);
+    // Two sides of a room can both hold a thread (the guest's own chats come
+    // back inside the host's aggregate). Keep the fuller copy rather than
+    // whichever arrived last, so merging never truncates a conversation.
+    if (!existing || (row.messages?.length || 0) > (existing.messages?.length || 0)) byId.set(key, row);
+  }
+  return [...byId.values()].sort((a, b) => (b[sortKey] || 0) - (a[sortKey] || 0));
+}
+
+// Room snapshots do not ship the raw history array (too large for the tunnel).
+// The Activity tab still reads history, so rebuild peer events from the chats
+// that did cross the wire — otherwise the joiner's feed is empty while Chat
+// and Code edits look fully synced.
+function historyFromChats(chats) {
+  const events = [];
+  for (const thread of chats || []) {
+    (thread.messages || []).forEach((m, i) => {
+      events.push({
+        id: `peer_${thread.ownerLogin || "peer"}_${thread.id}_${m.ts || 0}_${i}`,
+        ts: m.ts || thread.updatedAt || 0,
+        agent: thread.agent,
+        ownerLogin: thread.ownerLogin,
+        sessionId: thread.sessionId,
+        role: m.role,
+        kind: m.kind || "message",
+        text: m.text || "",
+        file: m.file || null,
+        path: m.file || null,
+        diff: "",
+      });
+    });
+  }
+  return events;
+}
+
+function mergeAgents(local, peers) {
+  const agents = [];
+  const seen = new Set();
+  const add = (agent, fallbackOwner) => {
+    if (!agent) return;
+    const ownerLogin = agent.ownerLogin || fallbackOwner || "";
+    const base = String(agent.id || agent.label || "agent")
+      .toLowerCase()
+      .replace(/\s+/g, "-");
+    const key = `${ownerLogin}::${agent.label || base}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    agents.push({
+      ...agent,
+      ownerLogin,
+      id: ownerLogin ? `${ownerLogin}:${base}` : base,
+    });
+  };
+  for (const agent of local || []) add(agent, agent.ownerLogin);
+  for (const peer of peers) {
+    for (const agent of peer.agents || []) add(agent, peer.login);
+  }
+  return agents;
+}
+
+/** Local view + every peer's view, deduped. Used for both the UI and the wire. */
+function mergeRoomViews(memory, opts = {}) {
+  const peers = peerSnapshots(memory, opts);
+  if (!peers.length) {
+    return {
+      chats: memory.chats || [],
+      timeline: memory.timeline || [],
+      activity: memory.activity || [],
+      edits: memory.edits || [],
+      history: memory.history || [],
+      agents: memory.agents || [],
+      peerLogins: [],
+    };
+  }
+  return {
+    chats: dedupeById([...(memory.chats || []), ...peers.flatMap((p) => p.chats || [])], "updatedAt"),
+    timeline: dedupeById([...(memory.timeline || []), ...peers.flatMap((p) => p.timeline || [])], "ts"),
+    activity: dedupeById([...(memory.activity || []), ...peers.flatMap((p) => p.activity || [])], "ts").slice(0, 120),
+    edits: dedupeById([...(memory.edits || []), ...peers.flatMap((p) => p.edits || [])], "ts").slice(0, 400),
+    history: dedupeById(
+      [...(memory.history || []), ...peers.flatMap((p) => historyFromChats(p.chats))],
+      "ts"
+    ).slice(0, 2000),
+    agents: mergeAgents(memory.agents, peers),
+    peerLogins: peers.map((p) => p.login).filter(Boolean),
+  };
+}
+
+module.exports = { localSnapshot, savePeerSnapshot, peerSnapshots, mergeRoomViews, clearPeers };

package/backend/lib/seed.js

@@ -0,0 +1,107 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { loadRegistry, saveRegistry, saveMemory, loadMemory, id } = require("./store");
+
+function avatar(seed, size = 80) {
+  const hash = crypto.createHash("md5").update(seed).digest("hex");
+  return `https://www.gravatar.com/avatar/${hash}?d=identicon&s=${size}`;
+}
+
+function initials(name) {
+  const parts = String(name).replace(/[./]/g, " ").trim().split(/\s+/);
+  if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+  return (parts[0][0] + parts[1][0]).toUpperCase();
+}
+
+function agent(label, status, extra = {}) {
+  return {
+    id: label.toLowerCase().replace(/\s+/g, "-"),
+    label,
+    status,
+    lastActiveAt: Date.now() - (extra.agoMs || 0),
+    sessionId: extra.sessionId,
+    ownerId: extra.ownerId,
+    ownerLogin: extra.ownerLogin,
+    ...extra,
+  };
+}
+
+function emptyMemory() {
+  return {
+    stats: { events: 0, agents: 0, patches: 0 },
+    agents: [
+      agent("Claude Code", "idle"),
+      agent("Cursor", "idle"),
+      agent("Codex", "idle"),
+      agent("Copilot", "idle"),
+      agent("Antigravity", "idle"),
+    ],
+    collaborators: [],
+    activity: [],
+    history: [],
+    timeline: [],
+    chats: [],
+    edits: [],
+  };
+}
+
+function looksLikeDemo(mem) {
+  if (!mem) return false;
+  if (mem.stats?.events === 186 || mem.stats?.events === 64) return true;
+  const ids = (mem.activity || []).map((a) => a.id);
+  return ids.includes("a1") || ids.includes("u1");
+}
+
+// Demo accounts used to be seeded here with `user_<login>` ids. Real accounts
+// come from GitHub and are `gh_<id>`, so anything still carrying the old id
+// scheme is a placeholder — drop it, unless it is the signed-in session.
+function dropDemoUsers() {
+  const reg = loadRegistry();
+  const users = reg.users || [];
+  let activeId = null;
+  try {
+    activeId = require("./store").loadSession?.().userId || null;
+  } catch {
+    /* no session helper: keep every account */
+  }
+  const kept = users.filter((u) => !String(u.id || "").startsWith("user_") || u.id === activeId);
+  if (kept.length !== users.length) {
+    reg.users = kept;
+    saveRegistry(reg);
+  }
+}
+
+function seedIfEmpty() {
+  dropDemoUsers();
+  const current = loadRegistry();
+  if (current.projects?.length) {
+    for (const p of current.projects) {
+      const mem = loadMemory(p.id);
+      if (looksLikeDemo(mem) || mem.ir) saveMemory(p.id, emptyMemory());
+    }
+    return loadRegistry();
+  }
+  const cwd = process.cwd();
+  const project = {
+    id: "proj_relay",
+    name: path.basename(cwd),
+    initials: initials(cwd),
+    color: "#f59e0b",
+    path: cwd,
+    remoteUrl: null,
+    apiKey: "rl_" + crypto.randomBytes(12).toString("hex"),
+    createdAt: Date.now(),
+    lastSyncAt: Date.now(),
+  };
+  try {
+    fs.mkdirSync(path.join(cwd, ".relay"), { recursive: true });
+  } catch {
+    /* ignore */
+  }
+  saveMemory(project.id, emptyMemory());
+  saveRegistry({ users: loadRegistry().users, projects: [project] });
+  return loadRegistry();
+}
+
+module.exports = { seedIfEmpty, avatar, initials, emptyMemory, id };

package/backend/lib/sseHub.js

@@ -0,0 +1,40 @@
+class SseHub {
+  constructor() {
+    this.clients = new Set();
+  }
+
+  subscribe(res, filter = {}) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders?.();
+    const client = { res, filter };
+    this.clients.add(client);
+    res.write(`event: hello\ndata: ${JSON.stringify({ ok: true, ts: Date.now() })}\n\n`);
+    res.on("close", () => this.clients.delete(client));
+    return client;
+  }
+
+  emit(event, payload) {
+    const data = `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+    for (const client of this.clients) {
+      const { workspaceId } = client.filter;
+      if (
+        event !== "notice" &&
+        workspaceId &&
+        payload.workspaceId &&
+        payload.workspaceId !== workspaceId
+      ) {
+        continue;
+      }
+      try {
+        client.res.write(data);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+}
+
+module.exports = { SseHub };

package/backend/lib/store.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { dataDir, registryPath, sessionPath } = require("./paths");
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2));
+}
+
+function id(prefix = "id") {
+  return `${prefix}_${crypto.randomBytes(6).toString("hex")}`;
+}
+
+function loadRegistry() {
+  return readJson(registryPath(), { projects: [], users: [] });
+}
+
+function saveRegistry(reg) {
+  writeJson(registryPath(), reg);
+}
+
+function loadSession() {
+  return readJson(sessionPath(), { userId: null });
+}
+
+function saveSession(session) {
+  writeJson(sessionPath(), session);
+}
+
+function projectDir(projectId) {
+  const dir = path.join(dataDir(), "projects", projectId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function memoryPath(projectId) {
+  return path.join(projectDir(projectId), "memory.json");
+}
+
+function loadMemory(projectId) {
+  return readJson(memoryPath(projectId), {
+    history: [],
+    timeline: [],
+    chats: [],
+    edits: [],
+    ir: {},
+    agents: [],
+    collaborators: [],
+    activity: [],
+  });
+}
+
+function saveMemory(projectId, memory) {
+  writeJson(memoryPath(projectId), memory);
+}
+
+module.exports = {
+  readJson,
+  writeJson,
+  id,
+  loadRegistry,
+  saveRegistry,
+  loadSession,
+  saveSession,
+  projectDir,
+  memoryPath,
+  loadMemory,
+  saveMemory,
+  dataDir,
+};