refactor: rename Server → Space across entire codebase

Renames all domain terminology from "Server" to "Space" throughout the
application — database schema, API routes, shared types, stores, components,
and UI strings. Files renamed: ServerSidebar → SpaceSidebar, CreateServer →
CreateSpace, JoinServer → JoinSpace, ServerSettings → SpaceSettings,
serverStore → spaceStore, routes/servers → routes/spaces.

packages/server/src/db/index.ts

@@ -29,7 +29,7 @@ function createTables(db: Database.Database): void {
       created_at INTEGER NOT NULL
     );
 
-    CREATE TABLE IF NOT EXISTS servers (
+    CREATE TABLE IF NOT EXISTS spaces (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
       icon TEXT,
@@ -38,17 +38,17 @@ function createTables(db: Database.Database): void {
       created_at INTEGER NOT NULL
     );
 
-    CREATE TABLE IF NOT EXISTS server_members (
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+    CREATE TABLE IF NOT EXISTS space_members (
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
       user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
       nickname TEXT,
       joined_at INTEGER NOT NULL,
-      PRIMARY KEY (server_id, user_id)
+      PRIMARY KEY (space_id, user_id)
     );
 
     CREATE TABLE IF NOT EXISTS channels (
       id TEXT PRIMARY KEY,
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
       name TEXT NOT NULL,
       type TEXT NOT NULL,
       topic TEXT,
@@ -131,7 +131,7 @@ function createTables(db: Database.Database): void {
 
     CREATE TABLE IF NOT EXISTS roles (
       id TEXT PRIMARY KEY,
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
       name TEXT NOT NULL,
       color TEXT DEFAULT '#b9bbbe',
       position INTEGER DEFAULT 0,
@@ -140,10 +140,10 @@ function createTables(db: Database.Database): void {
     );
 
     CREATE TABLE IF NOT EXISTS member_roles (
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
       user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
       role_id TEXT NOT NULL REFERENCES roles(id) ON DELETE CASCADE,
-      PRIMARY KEY (server_id, user_id, role_id)
+      PRIMARY KEY (space_id, user_id, role_id)
     );
 
     CREATE TABLE IF NOT EXISTS channel_overrides (
@@ -163,7 +163,7 @@ function createTables(db: Database.Database): void {
       PRIMARY KEY (user_id, channel_id)
     );
 
-    CREATE TABLE IF NOT EXISTS server_folders (
+    CREATE TABLE IF NOT EXISTS space_folders (
       id TEXT PRIMARY KEY,
       user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
       name TEXT,
@@ -172,10 +172,10 @@ function createTables(db: Database.Database): void {
       created_at INTEGER NOT NULL
     );
 
-    CREATE TABLE IF NOT EXISTS server_folder_members (
-      folder_id TEXT NOT NULL REFERENCES server_folders(id) ON DELETE CASCADE,
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
-      PRIMARY KEY (folder_id, server_id)
+    CREATE TABLE IF NOT EXISTS space_folder_members (
+      folder_id TEXT NOT NULL REFERENCES space_folders(id) ON DELETE CASCADE,
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+      PRIMARY KEY (folder_id, space_id)
     );
 
     CREATE TABLE IF NOT EXISTS instance_settings (

packages/server/src/db/migrate.ts

@@ -73,7 +73,7 @@ export function runMigrations(db: Database.Database): void {
       ]
     },
     {
-      name: 'servers',
+      name: 'spaces',
       columns: [
         { name: 'visibility', type: "TEXT DEFAULT 'private'" },
         { name: 'description', type: 'TEXT' }
@@ -113,7 +113,7 @@ export function runMigrations(db: Database.Database): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS join_requests (
       id TEXT PRIMARY KEY,
-      server_id TEXT NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
+      space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
       user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
       message TEXT,
       status TEXT NOT NULL DEFAULT 'pending',
@@ -123,7 +123,7 @@ export function runMigrations(db: Database.Database): void {
     );
   `);
 
-  // ─── RBAC Migration: Ensure @everyone roles exist for all servers ─────────
+  // ─── RBAC Migration: Ensure @everyone roles exist for all spaces ─────────
   migrateEveryoneRoles(db);
 
   // ─── Instance settings: ensure default row exists ──────────────────────────
@@ -182,58 +182,58 @@ function migrateWorkerId(db: Database.Database): void {
   }
 }
 
-/** For each server, ensure an @everyone role exists with id === server.id */
+/** For each space, ensure an @everyone role exists with id === space.id */
 function migrateEveryoneRoles(db: Database.Database): void {
-  const servers = db.prepare('SELECT id FROM servers').all() as { id: string }[];
+  const spaces = db.prepare('SELECT id FROM spaces').all() as { id: string }[];
   const now = Date.now();
   const defaultPerms = permissionsToString(DEFAULT_EVERYONE_PERMISSIONS);
   const adminPerms = permissionsToString(ALL_PERMISSIONS);
 
   const insertRole = db.prepare(
-    'INSERT OR IGNORE INTO roles (id, server_id, name, color, position, permissions, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    'INSERT OR IGNORE INTO roles (id, space_id, name, color, position, permissions, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)'
   );
 
-  for (const server of servers) {
-    // Create @everyone role if it doesn't exist (id = server.id)
-    insertRole.run(server.id, server.id, '@everyone', '#b9bbbe', 0, defaultPerms, now);
+  for (const space of spaces) {
+    // Create @everyone role if it doesn't exist (id = space.id)
+    insertRole.run(space.id, space.id, '@everyone', '#b9bbbe', 0, defaultPerms, now);
   }
 
   // Migrate existing admin members: ensure an Admin role exists and assign it
-  // Only run if the old `role` column still exists on server_members
-  const smColumns = db.pragma('table_info(server_members)') as { name: string }[];
+  // Only run if the old `role` column still exists on space_members
+  const smColumns = db.pragma('table_info(space_members)') as { name: string }[];
   const hasRoleColumn = smColumns.some(c => c.name === 'role');
   const adminMembers = hasRoleColumn
-    ? db.prepare("SELECT server_id, user_id FROM server_members WHERE role = 'admin'").all() as { server_id: string; user_id: string }[]
+    ? db.prepare("SELECT space_id, user_id FROM space_members WHERE role = 'admin'").all() as { space_id: string; user_id: string }[]
     : [];
 
   if (adminMembers.length > 0) {
-    // Group by server
-    const serverAdmins = new Map<string, string[]>();
+    // Group by space
+    const spaceAdmins = new Map<string, string[]>();
     for (const row of adminMembers) {
-      let arr = serverAdmins.get(row.server_id);
-      if (!arr) { arr = []; serverAdmins.set(row.server_id, arr); }
+      let arr = spaceAdmins.get(row.space_id);
+      if (!arr) { arr = []; spaceAdmins.set(row.space_id, arr); }
       arr.push(row.user_id);
     }
 
     const checkAdminRole = db.prepare(
-      "SELECT id FROM roles WHERE server_id = ? AND name = 'Admin' AND permissions = ?"
+      "SELECT id FROM roles WHERE space_id = ? AND name = 'Admin' AND permissions = ?"
     );
     const insertMemberRole = db.prepare(
-      'INSERT OR IGNORE INTO member_roles (server_id, user_id, role_id) VALUES (?, ?, ?)'
+      'INSERT OR IGNORE INTO member_roles (space_id, user_id, role_id) VALUES (?, ?, ?)'
     );
 
-    for (const [serverId, userIds] of serverAdmins) {
-      // Find or create Admin role for this server
-      let adminRole = checkAdminRole.get(serverId, adminPerms) as { id: string } | undefined;
+    for (const [spaceId, userIds] of spaceAdmins) {
+      // Find or create Admin role for this space
+      let adminRole = checkAdminRole.get(spaceId, adminPerms) as { id: string } | undefined;
       if (!adminRole) {
         // Generate a simple unique ID for the admin role
-        const adminRoleId = `${serverId}-admin`;
-        insertRole.run(adminRoleId, serverId, 'Admin', '#e74c3c', 1, adminPerms, now);
+        const adminRoleId = `${spaceId}-admin`;
+        insertRole.run(adminRoleId, spaceId, 'Admin', '#e74c3c', 1, adminPerms, now);
         adminRole = { id: adminRoleId };
       }
 
       for (const userId of userIds) {
-        insertMemberRole.run(serverId, userId, adminRole.id);
+        insertMemberRole.run(spaceId, userId, adminRole.id);
       }
     }
   }

packages/server/src/db/schema.ts

@@ -15,7 +15,7 @@ export const users = sqliteTable('users', {
   createdAt: integer('created_at').notNull(),
 });
 
-export const servers = sqliteTable('servers', {
+export const spaces = sqliteTable('spaces', {
   id: text('id').primaryKey(),
   name: text('name').notNull(),
   icon: text('icon'),
@@ -26,18 +26,18 @@ export const servers = sqliteTable('servers', {
   createdAt: integer('created_at').notNull(),
 });
 
-export const serverMembers = sqliteTable('server_members', {
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+export const spaceMembers = sqliteTable('space_members', {
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
   userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
   nickname: text('nickname'),
   joinedAt: integer('joined_at').notNull(),
 }, (table) => ({
-  pk: primaryKey({ columns: [table.serverId, table.userId] }),
+  pk: primaryKey({ columns: [table.spaceId, table.userId] }),
 }));
 
 export const channels = sqliteTable('channels', {
   id: text('id').primaryKey(),
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
   name: text('name').notNull(),
   type: text('type').notNull(),
   topic: text('topic'),
@@ -129,7 +129,7 @@ export const dmReactions = sqliteTable('dm_reactions', {
 
 export const roles = sqliteTable('roles', {
   id: text('id').primaryKey(),
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
   name: text('name').notNull(),
   color: text('color').default('#b9bbbe'),
   position: integer('position').default(0),
@@ -138,11 +138,11 @@ export const roles = sqliteTable('roles', {
 });
 
 export const memberRoles = sqliteTable('member_roles', {
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
   userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
   roleId: text('role_id').notNull().references(() => roles.id, { onDelete: 'cascade' }),
 }, (table) => ({
-  pk: primaryKey({ columns: [table.serverId, table.userId, table.roleId] }),
+  pk: primaryKey({ columns: [table.spaceId, table.userId, table.roleId] }),
 }));
 
 export const channelOverrides = sqliteTable('channel_overrides', {
@@ -164,7 +164,7 @@ export const readStates = sqliteTable('read_states', {
   pk: primaryKey({ columns: [table.userId, table.channelId] }),
 }));
 
-export const serverFolders = sqliteTable('server_folders', {
+export const spaceFolders = sqliteTable('space_folders', {
   id: text('id').primaryKey(),
   userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
   name: text('name'),
@@ -173,11 +173,11 @@ export const serverFolders = sqliteTable('server_folders', {
   createdAt: integer('created_at').notNull(),
 });
 
-export const serverFolderMembers = sqliteTable('server_folder_members', {
-  folderId: text('folder_id').notNull().references(() => serverFolders.id, { onDelete: 'cascade' }),
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+export const spaceFolderMembers = sqliteTable('space_folder_members', {
+  folderId: text('folder_id').notNull().references(() => spaceFolders.id, { onDelete: 'cascade' }),
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
 }, (table) => ({
-  pk: primaryKey({ columns: [table.folderId, table.serverId] }),
+  pk: primaryKey({ columns: [table.folderId, table.spaceId] }),
 }));
 
 export const instanceSettings = sqliteTable('instance_settings', {
@@ -197,7 +197,7 @@ export const instanceSettings = sqliteTable('instance_settings', {
 
 export const joinRequests = sqliteTable('join_requests', {
   id: text('id').primaryKey(),
-  serverId: text('server_id').notNull().references(() => servers.id, { onDelete: 'cascade' }),
+  spaceId: text('space_id').notNull().references(() => spaces.id, { onDelete: 'cascade' }),
   userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
   message: text('message'),
   status: text('status').notNull().default('pending'),

packages/server/src/db/seed.ts

@@ -7,8 +7,8 @@ import { DEFAULT_EVERYONE_PERMISSIONS, permissionsToString } from '@backspace/sh
 export async function seedDatabase(): Promise<void> {
   const db = getDb();
 
-  const existingServers = db.select().from(schema.servers).all();
-  if (existingServers.length > 0) {
+  const existingSpaces = db.select().from(schema.spaces).all();
+  if (existingSpaces.length > 0) {
     console.log('Database already has data, skipping seed');
     return;
   }
@@ -28,17 +28,17 @@ export async function seedDatabase(): Promise<void> {
     createdAt: Date.now(),
   }).run();
 
-  const serverId = generateSnowflake();
-  db.insert(schema.servers).values({
-    id: serverId,
+  const spaceId = generateSnowflake();
+  db.insert(schema.spaces).values({
+    id: spaceId,
     name: 'Backspace',
     ownerId: adminId,
     inviteCode: 'backspace',
     createdAt: Date.now(),
   }).run();
 
-  db.insert(schema.serverMembers).values({
-    serverId: serverId,
+  db.insert(schema.spaceMembers).values({
+    spaceId: spaceId,
     userId: adminId,
     joinedAt: Date.now(),
   }).run();
@@ -46,7 +46,7 @@ export async function seedDatabase(): Promise<void> {
   const generalChannelId = generateSnowflake();
   db.insert(schema.channels).values({
     id: generalChannelId,
-    serverId: serverId,
+    spaceId: spaceId,
     name: 'general',
     type: 'text',
     topic: 'General discussion',
@@ -57,17 +57,17 @@ export async function seedDatabase(): Promise<void> {
   const voiceChannelId = generateSnowflake();
   db.insert(schema.channels).values({
     id: voiceChannelId,
-    serverId: serverId,
+    spaceId: spaceId,
     name: 'General Voice',
     type: 'voice',
     position: 1,
     createdAt: Date.now(),
   }).run();
 
-  // Create @everyone role (id === serverId convention)
+  // Create @everyone role (id === spaceId convention)
   db.insert(schema.roles).values({
-    id: serverId,
-    serverId: serverId,
+    id: spaceId,
+    spaceId: spaceId,
     name: '@everyone',
     color: '#b9bbbe',
     position: 0,
@@ -76,6 +76,6 @@ export async function seedDatabase(): Promise<void> {
   }).run();
 
   console.log('Database seeded successfully');
-  console.log(`  Default server: Backspace (invite code: backspace)`);
+  console.log(`  Default space: Backspace (invite code: backspace)`);
   console.log(`  Admin user: admin / admin123`);
 }

packages/server/src/index.ts

@@ -9,7 +9,7 @@ import { getDb } from './db/index.js';
 import { seedDatabase } from './db/seed.js';
 import { authRoutes } from './routes/auth.js';
 import { userRoutes } from './routes/users.js';
-import { serverRoutes } from './routes/servers.js';
+import { spaceRoutes } from './routes/spaces.js';
 import { channelRoutes } from './routes/channels.js';
 import { messageRoutes } from './routes/messages.js';
 import { uploadRoutes } from './routes/uploads.js';
@@ -68,7 +68,7 @@ async function main(): Promise<void> {
 
   await app.register(authRoutes);
   await app.register(userRoutes);
-  await app.register(serverRoutes);
+  await app.register(spaceRoutes);
   await app.register(channelRoutes);
   await app.register(messageRoutes);
   await app.register(uploadRoutes);

packages/server/src/routes/channels.ts

@@ -3,7 +3,7 @@ import { eq, and } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { authenticate } from '../utils/auth.js';
 import { generateSnowflake } from '../utils/snowflake.js';
-import { isMember, hasPermission, getChannelServerId, PermissionBits, computePermissions } from '../utils/permissions.js';
+import { isMember, hasPermission, getChannelSpaceId, PermissionBits, computePermissions } from '../utils/permissions.js';
 import { permissionsToString } from '@backspace/shared/src/permissions.js';
 import { connectionManager } from '../ws/handler.js';
 import type {
@@ -15,7 +15,7 @@ import type {
 function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
   return {
     id: row.id,
-    serverId: row.serverId,
+    spaceId: row.spaceId,
     name: row.name,
     type: row.type as Channel['type'],
     topic: row.topic,
@@ -25,57 +25,57 @@ function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
 }
 
 /**
- * After a channel override changes, notify each server member:
+ * After a channel override changes, notify each space member:
  * - VIEW_CHANNEL holders receive channel_updated (with their myPermissions)
  * - Non-viewers receive channel_deleted to remove the channel from their UI
  */
-function broadcastOverrideChange(serverId: string, channelId: string): void {
+function broadcastOverrideChange(spaceId: string, channelId: string): void {
   const db = getDb();
   const channel = db.select().from(schema.channels).where(eq(schema.channels.id, channelId)).get();
   if (!channel) return;
 
   const channelData = rowToChannel(channel);
 
-  for (const [userId, serverIds] of connectionManager.getUserServerEntries()) {
-    if (!serverIds.has(serverId)) continue;
+  for (const [userId, spaceIds] of connectionManager.getUserSpaceEntries()) {
+    if (!spaceIds.has(spaceId)) continue;
 
-    const perms = computePermissions(userId, serverId, channelId);
+    const perms = computePermissions(userId, spaceId, channelId);
     if ((perms & PermissionBits.VIEW_CHANNEL) !== 0n) {
       connectionManager.sendToUser(userId, {
         type: 'channel_updated',
         channel: { ...channelData, myPermissions: permissionsToString(perms) },
-        serverId,
+        spaceId,
       });
     } else {
       connectionManager.sendToUser(userId, {
         type: 'channel_deleted',
         channelId,
-        serverId,
+        spaceId,
       });
     }
   }
 }
 
 export async function channelRoutes(app: FastifyInstance): Promise<void> {
-  // GET /api/servers/:id/channels - List channels in a server
-  app.get<{ Params: { id: string } }>('/api/servers/:id/channels', {
+  // GET /api/spaces/:id/channels - List channels in a space
+  app.get<{ Params: { id: string } }>('/api/spaces/:id/channels', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!isMember(id, request.userId)) {
-      return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
+      return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
     }
 
     const allChannels = db.select()
       .from(schema.channels)
-      .where(eq(schema.channels.serverId, id))
+      .where(eq(schema.channels.spaceId, id))
       .all();
 
     // Filter by VIEW_CHANNEL permission per channel
@@ -90,17 +90,17 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send(visibleChannels.map(rowToChannel));
   });
 
-  // POST /api/servers/:id/channels - Create a channel (admin+)
-  app.post<{ Params: { id: string }; Body: CreateChannelRequest }>('/api/servers/:id/channels', {
+  // POST /api/spaces/:id/channels - Create a channel (admin+)
+  app.post<{ Params: { id: string }; Body: CreateChannelRequest }>('/api/spaces/:id/channels', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const { name, type, topic } = request.body;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!hasPermission(request.userId, id, PermissionBits.MANAGE_CHANNELS)) {
@@ -123,7 +123,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
     // Get max position for ordering
     const existingChannels = db.select()
       .from(schema.channels)
-      .where(eq(schema.channels.serverId, id))
+      .where(eq(schema.channels.spaceId, id))
       .all();
 
     const maxPosition = existingChannels.reduce((max, ch) => Math.max(max, ch.position ?? 0), -1);
@@ -133,7 +133,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
 
     db.insert(schema.channels).values({
       id: channelId,
-      serverId: id,
+      spaceId: id,
       name: trimmedName,
       type,
       topic: topic?.trim() || null,
@@ -148,11 +148,11 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
 
     const channelData = rowToChannel(channel);
 
-    // Broadcast channel_created to all server members
-    connectionManager.sendToServer(id, {
+    // Broadcast channel_created to all space members
+    connectionManager.sendToSpace(id, {
       type: 'channel_created',
       channel: channelData,
-      serverId: id,
+      spaceId: id,
     });
 
     return reply.code(201).send(channelData);
@@ -171,8 +171,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    const serverId = channel.serverId;
-    if (!hasPermission(request.userId, serverId, PermissionBits.MANAGE_CHANNELS, id)) {
+    const spaceId = channel.spaceId;
+    if (!hasPermission(request.userId, spaceId, PermissionBits.MANAGE_CHANNELS, id)) {
       return reply.code(403).send({ error: 'Missing MANAGE_CHANNELS permission', statusCode: 403 });
     }
 
@@ -211,10 +211,10 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
     const channelData = rowToChannel(updated);
 
     // Broadcast channel_updated to members with VIEW_CHANNEL
-    connectionManager.sendToChannel(serverId, id, {
+    connectionManager.sendToChannel(spaceId, id, {
       type: 'channel_updated',
       channel: channelData,
-      serverId,
+      spaceId,
     });
 
     return reply.code(200).send(channelData);
@@ -232,16 +232,16 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    const serverId = channel.serverId;
-    if (!hasPermission(request.userId, serverId, PermissionBits.MANAGE_CHANNELS, id)) {
+    const spaceId = channel.spaceId;
+    if (!hasPermission(request.userId, spaceId, PermissionBits.MANAGE_CHANNELS, id)) {
       return reply.code(403).send({ error: 'Missing MANAGE_CHANNELS permission', statusCode: 403 });
     }
 
     // Collect viewers BEFORE deleting (overrides CASCADE-delete with the channel)
     const viewerIds: string[] = [];
-    for (const [uid, serverIds] of connectionManager.getUserServerEntries()) {
-      if (serverIds.has(serverId)) {
-        const perms = computePermissions(uid, serverId, id);
+    for (const [uid, spaceIds] of connectionManager.getUserSpaceEntries()) {
+      if (spaceIds.has(spaceId)) {
+        const perms = computePermissions(uid, spaceId, id);
         if ((perms & PermissionBits.VIEW_CHANNEL) !== 0n) {
           viewerIds.push(uid);
         }
@@ -253,7 +253,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
     db.delete(schema.channels).where(eq(schema.channels.id, id)).run();
 
     // Broadcast channel_deleted only to users who could see the channel
-    const deleteEvent = { type: 'channel_deleted' as const, channelId: id, serverId };
+    const deleteEvent = { type: 'channel_deleted' as const, channelId: id, spaceId };
     for (const uid of viewerIds) {
       connectionManager.sendToUser(uid, deleteEvent);
     }
@@ -275,7 +275,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
+    if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
       return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
     }
 
@@ -315,7 +315,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
+    if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
       return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
     }
 
@@ -346,8 +346,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
       }).run();
     });
 
-    // Notify all server members of the permission change
-    broadcastOverrideChange(channel.serverId, id);
+    // Notify all space members of the permission change
+    broadcastOverrideChange(channel.spaceId, id);
 
     return reply.code(200).send({ success: true });
   });
@@ -365,7 +365,7 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
         return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
       }
 
-      if (!hasPermission(request.userId, channel.serverId, PermissionBits.MANAGE_ROLES)) {
+      if (!hasPermission(request.userId, channel.spaceId, PermissionBits.MANAGE_ROLES)) {
         return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
       }
 
@@ -377,8 +377,8 @@ export async function channelRoutes(app: FastifyInstance): Promise<void> {
         )
       ).run();
 
-      // Notify all server members of the permission change
-      broadcastOverrideChange(channel.serverId, id);
+      // Notify all space members of the permission change
+      broadcastOverrideChange(channel.spaceId, id);
 
       return reply.code(200).send({ success: true });
     },

packages/server/src/routes/explore.ts

@@ -3,14 +3,14 @@ import { eq, and, sql, inArray } from 'drizzle-orm';
 import { getDb, getRawDb, schema } from '../db/index.js';
 import { authenticate } from '../utils/auth.js';
 import { generateSnowflake } from '../utils/snowflake.js';
-import { isMember, isServerOwner, hasPermission, computePermissions, PermissionBits, permissionsToString } from '../utils/permissions.js';
+import { isMember, isSpaceOwner, hasPermission, computePermissions, PermissionBits, permissionsToString } from '../utils/permissions.js';
 import { connectionManager } from '../ws/handler.js';
 import { sanitizeUser } from '../utils/sanitize.js';
 import type {
-  ExploreServer,
+  ExploreSpace,
   JoinRequest,
   MemberWithUser,
-  ServerWithChannelsAndMembers,
+  SpaceWithChannelsAndMembers,
   Channel,
 } from '@backspace/shared';
 
@@ -20,7 +20,7 @@ function rowToJoinRequest(
 ): JoinRequest {
   return {
     id: row.id,
-    serverId: row.serverId,
+    spaceId: row.spaceId,
     userId: row.userId,
     message: row.message,
     status: row.status as JoinRequest['status'],
@@ -32,22 +32,22 @@ function rowToJoinRequest(
 }
 
 /**
- * Find all online users for a server who have MANAGE_SERVER or are the owner.
+ * Find all online users for a space who have MANAGE_SPACE or are the owner.
  * Used to route join_request_received events.
  */
-function getServerManagers(serverId: string): string[] {
+function getSpaceManagers(spaceId: string): string[] {
   const db = getDb();
-  const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
-  if (!server) return [];
+  const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
+  if (!space) return [];
 
   const memberRows = db.select()
-    .from(schema.serverMembers)
-    .where(eq(schema.serverMembers.serverId, serverId))
+    .from(schema.spaceMembers)
+    .where(eq(schema.spaceMembers.spaceId, spaceId))
     .all();
 
   const managers: string[] = [];
   for (const member of memberRows) {
-    if (member.userId === server.ownerId || hasPermission(member.userId, serverId, PermissionBits.MANAGE_SERVER)) {
+    if (member.userId === space.ownerId || hasPermission(member.userId, spaceId, PermissionBits.MANAGE_SPACE)) {
       managers.push(member.userId);
     }
   }
@@ -55,28 +55,28 @@ function getServerManagers(serverId: string): string[] {
 }
 
 /**
- * Build a full ServerWithChannelsAndMembers for a newly joined user.
+ * Build a full SpaceWithChannelsAndMembers for a newly joined user.
  * Used after accepting a join request or public join.
  */
-function buildFullServer(serverId: string, forUserId: string): ServerWithChannelsAndMembers | null {
+function buildFullSpace(spaceId: string, forUserId: string): SpaceWithChannelsAndMembers | null {
   const db = getDb();
-  const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
-  if (!server) return null;
+  const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
+  if (!space) return null;
 
   const channels = db.select()
     .from(schema.channels)
-    .where(eq(schema.channels.serverId, serverId))
+    .where(eq(schema.channels.spaceId, spaceId))
     .all();
 
   const roles = db.select()
     .from(schema.roles)
-    .where(eq(schema.roles.serverId, serverId))
+    .where(eq(schema.roles.spaceId, spaceId))
     .orderBy(schema.roles.position)
     .all();
 
   const memberRows = db.select()
-    .from(schema.serverMembers)
-    .where(eq(schema.serverMembers.serverId, serverId))
+    .from(schema.spaceMembers)
+    .where(eq(schema.spaceMembers.spaceId, spaceId))
     .all();
 
   const memberUserIds = memberRows.map(m => m.userId);
@@ -87,7 +87,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
 
   const memberRoleRows = db.select()
     .from(schema.memberRoles)
-    .where(eq(schema.memberRoles.serverId, serverId))
+    .where(eq(schema.memberRoles.spaceId, spaceId))
     .all();
 
   const members: MemberWithUser[] = memberRows
@@ -103,7 +103,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
         .filter(r => assignedRoleIds.includes(r.id))
         .map(r => ({
           id: r.id,
-          serverId: r.serverId,
+          spaceId: r.spaceId,
           name: r.name,
           color: r.color ?? '#b9bbbe',
           position: r.position ?? 0,
@@ -111,7 +111,7 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
         }));
 
       return {
-        serverId: m.serverId,
+        spaceId: m.spaceId,
         userId: m.userId,
         nickname: m.nickname,
         joinedAt: m.joinedAt,
@@ -121,16 +121,16 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
     })
     .filter((m): m is MemberWithUser => m !== null);
 
-  const serverPerms = computePermissions(forUserId, serverId);
+  const spacePerms = computePermissions(forUserId, spaceId);
 
   const visibleChannels: Channel[] = [];
   for (const ch of channels) {
-    const chPerms = computePermissions(forUserId, serverId, ch.id);
+    const chPerms = computePermissions(forUserId, spaceId, ch.id);
     const hasView = (chPerms & PermissionBits.VIEW_CHANNEL) !== 0n || (chPerms & PermissionBits.ADMINISTRATOR) !== 0n;
     if (hasView) {
       visibleChannels.push({
         id: ch.id,
-        serverId: ch.serverId,
+        spaceId: ch.spaceId,
         name: ch.name,
         type: ch.type as Channel['type'],
         topic: ch.topic,
@@ -142,34 +142,34 @@ function buildFullServer(serverId: string, forUserId: string): ServerWithChannel
   }
 
   return {
-    id: server.id,
-    name: server.name,
-    icon: server.icon,
-    ownerId: server.ownerId,
-    inviteCode: server.inviteCode,
-    visibility: (server.visibility ?? 'private') as ServerWithChannelsAndMembers['visibility'],
-    description: server.description ?? null,
-    createdAt: server.createdAt,
+    id: space.id,
+    name: space.name,
+    icon: space.icon,
+    ownerId: space.ownerId,
+    inviteCode: space.inviteCode,
+    visibility: (space.visibility ?? 'private') as SpaceWithChannelsAndMembers['visibility'],
+    description: space.description ?? null,
+    createdAt: space.createdAt,
     channels: visibleChannels,
     members,
     roles: roles.map(r => ({
       id: r.id,
-      serverId: r.serverId,
+      spaceId: r.spaceId,
       name: r.name,
       color: r.color ?? '#b9bbbe',
       position: r.position ?? 0,
       permissions: r.permissions ?? undefined,
-      isEveryone: r.id === serverId,
+      isEveryone: r.id === spaceId,
       createdAt: r.createdAt,
     })),
-    myPermissions: permissionsToString(serverPerms),
+    myPermissions: permissionsToString(spacePerms),
   };
 }
 
 export async function exploreRoutes(app: FastifyInstance): Promise<void> {
 
-  // GET /api/servers/explore — list discoverable servers
-  app.get<{ Querystring: { q?: string; limit?: string; offset?: string } }>('/api/servers/explore', {
+  // GET /api/spaces/explore — list discoverable spaces
+  app.get<{ Querystring: { q?: string; limit?: string; offset?: string } }>('/api/spaces/explore', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const db = getDb();
@@ -177,35 +177,35 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
     // Check instance-level discovery toggle
     const settings = db.select().from(schema.instanceSettings).where(eq(schema.instanceSettings.id, 1)).get();
     if (!settings || settings.discoveryEnabled === 0) {
-      return reply.code(200).send({ servers: [], total: 0, discoveryEnabled: false });
+      return reply.code(200).send({ spaces: [], total: 0, discoveryEnabled: false });
     }
 
     const q = request.query.q?.trim() ?? '';
     const limit = Math.min(Math.max(parseInt(request.query.limit ?? '50', 10) || 50, 1), 100);
     const offset = Math.max(parseInt(request.query.offset ?? '0', 10) || 0, 0);
 
-    // Get user's current server memberships to exclude
-    const myMemberships = db.select({ serverId: schema.serverMembers.serverId })
-      .from(schema.serverMembers)
-      .where(eq(schema.serverMembers.userId, request.userId))
+    // Get user's current space memberships to exclude
+    const myMemberships = db.select({ spaceId: schema.spaceMembers.spaceId })
+      .from(schema.spaceMembers)
+      .where(eq(schema.spaceMembers.userId, request.userId))
       .all();
-    const myServerIds = new Set(myMemberships.map(m => m.serverId));
+    const mySpaceIds = new Set(myMemberships.map(m => m.spaceId));
 
     // Build raw SQL query for explore — we need a LEFT JOIN for member count
     // which is more efficient to do with raw SQL
     const rawDb = getRawDb();
 
-    // Count ALL discoverable servers (including ones the user has joined) for context
+    // Count ALL discoverable spaces (including ones the user has joined) for context
     const totalAllRow = rawDb.prepare(
-      `SELECT COUNT(DISTINCT s.id) as total FROM servers s WHERE s.visibility IN ('public', 'request')`
+      `SELECT COUNT(DISTINCT s.id) as total FROM spaces s WHERE s.visibility IN ('public', 'request')`
     ).get() as { total: number };
 
-    let countSql = `SELECT COUNT(DISTINCT s.id) as total FROM servers s WHERE s.visibility IN ('public', 'request')`;
+    let countSql = `SELECT COUNT(DISTINCT s.id) as total FROM spaces s WHERE s.visibility IN ('public', 'request')`;
     let querySql = `
       SELECT s.id, s.name, s.icon, s.description, s.visibility, s.created_at,
              COUNT(sm.user_id) as member_count
-      FROM servers s
-      LEFT JOIN server_members sm ON sm.server_id = s.id
+      FROM spaces s
+      LEFT JOIN space_members sm ON sm.space_id = s.id
       WHERE s.visibility IN ('public', 'request')
     `;
 
@@ -231,79 +231,79 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
       member_count: number;
     }[];
 
-    const servers: ExploreServer[] = rows.map(r => ({
+    const spaces: ExploreSpace[] = rows.map(r => ({
       id: r.id,
       name: r.name,
       icon: r.icon,
       description: r.description,
-      visibility: r.visibility as ExploreServer['visibility'],
+      visibility: r.visibility as ExploreSpace['visibility'],
       memberCount: r.member_count,
       createdAt: r.created_at,
-      joined: myServerIds.has(r.id),
+      joined: mySpaceIds.has(r.id),
     }));
 
-    return reply.code(200).send({ servers, total: totalRow.total, totalAll: totalAllRow.total, discoveryEnabled: true });
+    return reply.code(200).send({ spaces, total: totalRow.total, totalAll: totalAllRow.total, discoveryEnabled: true });
   });
 
-  // POST /api/servers/:id/public-join — join a public server without invite
-  app.post<{ Params: { id: string } }>('/api/servers/:id/public-join', {
+  // POST /api/spaces/:id/public-join — join a public space without invite
+  app.post<{ Params: { id: string } }>('/api/spaces/:id/public-join', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (server.visibility !== 'public') {
-      return reply.code(403).send({ error: 'This server does not allow public joins', statusCode: 403 });
+    if (space.visibility !== 'public') {
+      return reply.code(403).send({ error: 'This space does not allow public joins', statusCode: 403 });
     }
 
     if (isMember(id, request.userId)) {
-      return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
+      return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
     }
 
     const now = Date.now();
-    db.insert(schema.serverMembers).values({
-      serverId: id,
+    db.insert(schema.spaceMembers).values({
+      spaceId: id,
       userId: request.userId,
       joinedAt: now,
     }).run();
 
     // Register in connectionManager for WS broadcasts
-    connectionManager.addUserServer(request.userId, id);
+    connectionManager.addUserSpace(request.userId, id);
 
-    // Broadcast member_joined to existing server members
+    // Broadcast member_joined to existing space members
     const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
     if (joiningUser) {
       const memberPayload: MemberWithUser = {
-        serverId: id,
+        spaceId: id,
         userId: request.userId,
         nickname: null,
         joinedAt: now,
         user: sanitizeUser(joiningUser),
         roles: [],
       };
-      connectionManager.sendToServer(id, {
+      connectionManager.sendToSpace(id, {
         type: 'member_joined',
-        serverId: id,
+        spaceId: id,
         member: memberPayload,
       });
     }
 
-    // Return full server data
-    const fullServer = buildFullServer(id, request.userId);
-    if (!fullServer) {
-      return reply.code(500).send({ error: 'Failed to load server', statusCode: 500 });
+    // Return full space data
+    const fullSpace = buildFullSpace(id, request.userId);
+    if (!fullSpace) {
+      return reply.code(500).send({ error: 'Failed to load space', statusCode: 500 });
     }
 
-    return reply.code(200).send(fullServer);
+    return reply.code(200).send(fullSpace);
   });
 
-  // POST /api/servers/:id/request-join — request to join a request-only server
-  app.post<{ Params: { id: string }; Body: { message?: string } }>('/api/servers/:id/request-join', {
+  // POST /api/spaces/:id/request-join — request to join a request-only space
+  app.post<{ Params: { id: string }; Body: { message?: string } }>('/api/spaces/:id/request-join', {
     preHandler: authenticate,
     config: {
       rateLimit: {
@@ -315,30 +315,30 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (server.visibility !== 'request') {
-      return reply.code(403).send({ error: 'This server does not accept join requests', statusCode: 403 });
+    if (space.visibility !== 'request') {
+      return reply.code(403).send({ error: 'This space does not accept join requests', statusCode: 403 });
     }
 
     if (isMember(id, request.userId)) {
-      return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
+      return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
     }
 
     // Check for existing pending request
     const existingRequest = db.select().from(schema.joinRequests)
       .where(and(
-        eq(schema.joinRequests.serverId, id),
+        eq(schema.joinRequests.spaceId, id),
         eq(schema.joinRequests.userId, request.userId),
         eq(schema.joinRequests.status, 'pending'),
       ))
       .get();
 
     if (existingRequest) {
-      return reply.code(409).send({ error: 'You already have a pending request for this server', statusCode: 409 });
+      return reply.code(409).send({ error: 'You already have a pending request for this space', statusCode: 409 });
     }
 
     const requestId = generateSnowflake();
@@ -347,7 +347,7 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
 
     db.insert(schema.joinRequests).values({
       id: requestId,
-      serverId: id,
+      spaceId: id,
       userId: request.userId,
       message: msgText,
       status: 'pending',
@@ -360,8 +360,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
       joiningUser ? sanitizeUser(joiningUser) : undefined,
     );
 
-    // Send WS event to server managers (owner + MANAGE_SERVER users)
-    const managers = getServerManagers(id);
+    // Send WS event to space managers (owner + MANAGE_SPACE users)
+    const managers = getSpaceManagers(id);
     for (const managerId of managers) {
       connectionManager.sendToUser(managerId, {
         type: 'join_request_received',
@@ -372,26 +372,26 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(201).send(joinRequest);
   });
 
-  // GET /api/servers/:id/join-requests — list join requests for a server
-  app.get<{ Params: { id: string }; Querystring: { status?: string } }>('/api/servers/:id/join-requests', {
+  // GET /api/spaces/:id/join-requests — list join requests for a space
+  app.get<{ Params: { id: string }; Querystring: { status?: string } }>('/api/spaces/:id/join-requests', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (!isServerOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
-      return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
+    if (!isSpaceOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
+      return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
     }
 
     const statusFilter = request.query.status ?? 'pending';
     const rows = db.select().from(schema.joinRequests)
       .where(and(
-        eq(schema.joinRequests.serverId, id),
+        eq(schema.joinRequests.spaceId, id),
         eq(schema.joinRequests.status, statusFilter),
       ))
       .all();
@@ -408,8 +408,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send({ requests });
   });
 
-  // PATCH /api/servers/:id/join-requests/:requestId — accept or decline
-  app.patch<{ Params: { id: string; requestId: string }; Body: { action: 'accept' | 'decline' } }>('/api/servers/:id/join-requests/:requestId', {
+  // PATCH /api/spaces/:id/join-requests/:requestId — accept or decline
+  app.patch<{ Params: { id: string; requestId: string }; Body: { action: 'accept' | 'decline' } }>('/api/spaces/:id/join-requests/:requestId', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, requestId } = request.params;
@@ -420,17 +420,17 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(400).send({ error: 'Action must be "accept" or "decline"', statusCode: 400 });
     }
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
-    if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+    const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
+    if (!space) {
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (!isServerOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
-      return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
+    if (!isSpaceOwner(id, request.userId) && !hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
+      return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
     }
 
     const joinReq = db.select().from(schema.joinRequests).where(eq(schema.joinRequests.id, requestId)).get();
-    if (!joinReq || joinReq.serverId !== id) {
+    if (!joinReq || joinReq.spaceId !== id) {
       return reply.code(404).send({ error: 'Join request not found', statusCode: 404 });
     }
 
@@ -443,8 +443,8 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
     if (action === 'accept') {
       // Insert member and update request atomically
       db.transaction((tx) => {
-        tx.insert(schema.serverMembers).values({
-          serverId: id,
+        tx.insert(schema.spaceMembers).values({
+          spaceId: id,
           userId: joinReq.userId,
           joinedAt: now,
         }).run();
@@ -457,38 +457,38 @@ export async function exploreRoutes(app: FastifyInstance): Promise<void> {
       });
 
       // Register in connectionManager
-      connectionManager.addUserServer(joinReq.userId, id);
+      connectionManager.addUserSpace(joinReq.userId, id);
 
-      // Broadcast member_joined to server
+      // Broadcast member_joined to space
       const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, joinReq.userId)).get();
       if (joiningUser) {
         const memberPayload: MemberWithUser = {
-          serverId: id,
+          spaceId: id,
           userId: joinReq.userId,
           nickname: null,
           joinedAt: now,
           user: sanitizeUser(joiningUser),
           roles: [],
         };
-        connectionManager.sendToServer(id, {
+        connectionManager.sendToSpace(id, {
           type: 'member_joined',
-          serverId: id,
+          spaceId: id,
           member: memberPayload,
         });
       }
 
-      // Build full server for the accepted user
-      const fullServer = buildFullServer(id, joinReq.userId);
+      // Build full space for the accepted user
+      const fullSpace = buildFullSpace(id, joinReq.userId);
 
       const updatedRow = db.select().from(schema.joinRequests).where(eq(schema.joinRequests.id, requestId)).get()!;
       const updatedRequest = rowToJoinRequest(updatedRow, joiningUser ? sanitizeUser(joiningUser) : undefined);
 
       // Send join_request_accepted to the requesting user
-      if (fullServer) {
+      if (fullSpace) {
         connectionManager.sendToUser(joinReq.userId, {
           type: 'join_request_accepted',
           request: updatedRequest,
-          server: fullServer,
+          space: fullSpace,
         });
       }
 

packages/server/src/routes/livekit.ts

@@ -2,7 +2,7 @@ import type { FastifyInstance } from 'fastify';
 import { AccessToken } from 'livekit-server-sdk';
 import { authenticate } from '../utils/auth.js';
 import { config } from '../config.js';
-import { getChannelServerId, hasPermission, isDmMember, PermissionBits } from '../utils/permissions.js';
+import { getChannelSpaceId, hasPermission, isDmMember, PermissionBits } from '../utils/permissions.js';
 import type { LiveKitTokenRequest, LiveKitTokenResponse } from '@backspace/shared';
 
 export async function livekitRoutes(app: FastifyInstance): Promise<void> {
@@ -25,12 +25,12 @@ export async function livekitRoutes(app: FastifyInstance): Promise<void> {
       }
       roomName = `dm-${dmChannelId}`;
     } else if (channelId && typeof channelId === 'string') {
-      // Server voice channel token
-      const serverId = getChannelServerId(channelId);
-      if (!serverId) {
+      // Space voice channel token
+      const spaceId = getChannelSpaceId(channelId);
+      if (!spaceId) {
         return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
       }
-      if (!hasPermission(request.userId, serverId, PermissionBits.CONNECT, channelId)) {
+      if (!hasPermission(request.userId, spaceId, PermissionBits.CONNECT, channelId)) {
         return reply.code(403).send({ error: 'Missing CONNECT permission', statusCode: 403 });
       }
       roomName = channelId;

packages/server/src/routes/messages.ts

@@ -3,7 +3,7 @@ import { eq, and, desc, lt, inArray } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { authenticate } from '../utils/auth.js';
 import { generateSnowflake } from '../utils/snowflake.js';
-import { hasPermission, getChannelServerId, PermissionBits } from '../utils/permissions.js';
+import { hasPermission, getChannelSpaceId, PermissionBits } from '../utils/permissions.js';
 import { connectionManager } from '../ws/handler.js';
 import type {
   CreateMessageRequest,
@@ -158,12 +158,12 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
     const before = request.query.before;
     const limit = Math.min(Math.max(Number(request.query.limit) || 50, 1), 100);
 
-    const serverId = getChannelServerId(id);
-    if (!serverId) {
+    const spaceId = getChannelSpaceId(id);
+    if (!spaceId) {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    if (!hasPermission(request.userId, serverId, PermissionBits.VIEW_CHANNEL | PermissionBits.READ_MESSAGE_HISTORY, id)) {
+    if (!hasPermission(request.userId, spaceId, PermissionBits.VIEW_CHANNEL | PermissionBits.READ_MESSAGE_HISTORY, id)) {
       return reply.code(403).send({ error: 'Missing VIEW_CHANNEL or READ_MESSAGE_HISTORY permission', statusCode: 403 });
     }
 
@@ -251,12 +251,12 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
     const { id } = request.params;
     const { content, attachments: attachmentIds, replyToId } = request.body;
 
-    const serverId = getChannelServerId(id);
-    if (!serverId) {
+    const spaceId = getChannelSpaceId(id);
+    if (!spaceId) {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
-    if (!hasPermission(request.userId, serverId, PermissionBits.SEND_MESSAGES, id)) {
+    if (!hasPermission(request.userId, spaceId, PermissionBits.SEND_MESSAGES, id)) {
       return reply.code(403).send({ error: 'Missing SEND_MESSAGES permission', statusCode: 403 });
     }
 
@@ -315,7 +315,7 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
     const messageWithUser = buildMessageWithUser(message, user, attachmentRows, [], replyTo);
 
     // Broadcast via WebSocket
-    connectionManager.sendToServer(serverId, {
+    connectionManager.sendToSpace(spaceId, {
       type: 'message_created',
       message: messageWithUser,
     });
@@ -377,9 +377,9 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
     const messageWithUser = buildMessageWithUser(updatedMessage, user, attachmentRows, reactions, replyTo);
 
     // Broadcast edit
-    const serverId = getChannelServerId(message.channelId);
-    if (serverId) {
-      connectionManager.sendToServer(serverId, {
+    const spaceId = getChannelSpaceId(message.channelId);
+    if (spaceId) {
+      connectionManager.sendToSpace(spaceId, {
         type: 'message_updated',
         message: messageWithUser,
       });
@@ -400,13 +400,13 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(404).send({ error: 'Message not found', statusCode: 404 });
     }
 
-    const serverId = getChannelServerId(message.channelId);
-    if (!serverId) {
+    const spaceId = getChannelSpaceId(message.channelId);
+    if (!spaceId) {
       return reply.code(404).send({ error: 'Channel not found', statusCode: 404 });
     }
 
     const isAuthor = message.userId === request.userId;
-    const canManageMessages = hasPermission(request.userId, serverId, PermissionBits.MANAGE_MESSAGES, message.channelId);
+    const canManageMessages = hasPermission(request.userId, spaceId, PermissionBits.MANAGE_MESSAGES, message.channelId);
 
     if (!isAuthor && !canManageMessages) {
       return reply.code(403).send({ error: 'You cannot delete this message', statusCode: 403 });
@@ -419,7 +419,7 @@ export async function messageRoutes(app: FastifyInstance): Promise<void> {
     });
 
     // Broadcast deletion
-    connectionManager.sendToServer(serverId, {
+    connectionManager.sendToSpace(spaceId, {
       type: 'message_deleted',
       messageId: id,
       channelId: message.channelId,

packages/server/src/routes/spaces.ts

@@ -3,31 +3,31 @@ import { eq, and, inArray } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { authenticate } from '../utils/auth.js';
 import { generateSnowflake } from '../utils/snowflake.js';
-import { isMember, isServerOwner, hasPermission, computePermissions, PermissionBits } from '../utils/permissions.js';
+import { isMember, isSpaceOwner, hasPermission, computePermissions, PermissionBits } from '../utils/permissions.js';
 import { DEFAULT_EVERYONE_PERMISSIONS, ALL_PERMISSIONS, permissionsToString } from '@backspace/shared/src/permissions.js';
 import crypto from 'crypto';
 import { connectionManager } from '../ws/handler.js';
 import type {
-  CreateServerRequest,
-  UpdateServerRequest,
-  JoinServerRequest,
+  CreateSpaceRequest,
+  UpdateSpaceRequest,
+  JoinSpaceRequest,
   UpdateMemberRequest,
-  Server,
+  Space,
   Channel,
   MemberWithUser,
-  ServerWithChannelsAndMembers,
+  SpaceWithChannelsAndMembers,
   Role,
 } from '@backspace/shared';
 import { sanitizeUser } from '../utils/sanitize.js';
 
-function rowToServer(row: typeof schema.servers.$inferSelect): Server {
+function rowToSpace(row: typeof schema.spaces.$inferSelect): Space {
   return {
     id: row.id,
     name: row.name,
     icon: row.icon,
     ownerId: row.ownerId,
     inviteCode: row.inviteCode,
-    visibility: (row.visibility ?? 'private') as Server['visibility'],
+    visibility: (row.visibility ?? 'private') as Space['visibility'],
     description: row.description ?? null,
     createdAt: row.createdAt,
   };
@@ -36,7 +36,7 @@ function rowToServer(row: typeof schema.servers.$inferSelect): Server {
 function rowToChannel(row: typeof schema.channels.$inferSelect): Channel {
   return {
     id: row.id,
-    serverId: row.serverId,
+    spaceId: row.spaceId,
     name: row.name,
     type: row.type as Channel['type'],
     topic: row.topic,
@@ -49,32 +49,32 @@ function generateInviteCode(): string {
   return crypto.randomBytes(4).toString('hex');
 }
 
-export async function serverRoutes(app: FastifyInstance): Promise<void> {
-  // POST /api/servers - Create a new server
-  app.post<{ Body: CreateServerRequest }>('/api/servers', {
+export async function spaceRoutes(app: FastifyInstance): Promise<void> {
+  // POST /api/spaces - Create a new server
+  app.post<{ Body: CreateSpaceRequest }>('/api/spaces', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { name, icon } = request.body;
 
     if (!name || typeof name !== 'string') {
-      return reply.code(400).send({ error: 'Server name is required', statusCode: 400 });
+      return reply.code(400).send({ error: 'Space name is required', statusCode: 400 });
     }
 
     const trimmedName = name.trim();
     if (trimmedName.length < 1 || trimmedName.length > 100) {
-      return reply.code(400).send({ error: 'Server name must be between 1 and 100 characters', statusCode: 400 });
+      return reply.code(400).send({ error: 'Space name must be between 1 and 100 characters', statusCode: 400 });
     }
 
     const db = getDb();
-    const serverId = generateSnowflake();
+    const spaceId = generateSnowflake();
     const channelId = generateSnowflake();
     const now = Date.now();
     const inviteCode = generateInviteCode();
 
     // Create server, owner membership, default channel, and @everyone role atomically
     db.transaction((tx) => {
-      tx.insert(schema.servers).values({
-        id: serverId,
+      tx.insert(schema.spaces).values({
+        id: spaceId,
         name: trimmedName,
         icon: icon ?? null,
         ownerId: request.userId,
@@ -82,25 +82,25 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
         createdAt: now,
       }).run();
 
-      tx.insert(schema.serverMembers).values({
-        serverId,
+      tx.insert(schema.spaceMembers).values({
+        spaceId,
         userId: request.userId,
         joinedAt: now,
       }).run();
 
       tx.insert(schema.channels).values({
         id: channelId,
-        serverId,
+        spaceId,
         name: 'general',
         type: 'text',
         position: 0,
         createdAt: now,
       }).run();
 
-      // Auto-create @everyone role (id = serverId)
+      // Auto-create @everyone role (id = spaceId)
       tx.insert(schema.roles).values({
-        id: serverId,
-        serverId,
+        id: spaceId,
+        spaceId,
         name: '@everyone',
         color: '#b9bbbe',
         position: 0,
@@ -109,68 +109,68 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       }).run();
     });
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
     if (!server) {
-      return reply.code(500).send({ error: 'Failed to create server', statusCode: 500 });
+      return reply.code(500).send({ error: 'Failed to create space', statusCode: 500 });
     }
 
-    return reply.code(201).send(rowToServer(server));
+    return reply.code(201).send(rowToSpace(server));
   });
 
-  // GET /api/servers - List user's servers
-  app.get('/api/servers', {
+  // GET /api/spaces - List user's servers
+  app.get('/api/spaces', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const db = getDb();
 
     const memberships = db.select()
-      .from(schema.serverMembers)
-      .where(eq(schema.serverMembers.userId, request.userId))
+      .from(schema.spaceMembers)
+      .where(eq(schema.spaceMembers.userId, request.userId))
       .all();
 
     if (memberships.length === 0) {
       return reply.code(200).send([]);
     }
 
-    const serverIds = memberships.map(m => m.serverId);
+    const spaceIds = memberships.map(m => m.spaceId);
     const servers = db.select()
-      .from(schema.servers)
-      .where(inArray(schema.servers.id, serverIds))
+      .from(schema.spaces)
+      .where(inArray(schema.spaces.id, spaceIds))
       .all();
 
-    return reply.code(200).send(servers.map(rowToServer));
+    return reply.code(200).send(servers.map(rowToSpace));
   });
 
-  // GET /api/servers/:id - Get server detail with channels and members
-  app.get<{ Params: { id: string } }>('/api/servers/:id', {
+  // GET /api/spaces/:id - Get server detail with channels and members
+  app.get<{ Params: { id: string } }>('/api/spaces/:id', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!isMember(id, request.userId)) {
-      return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
+      return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
     }
 
     const channels = db.select()
       .from(schema.channels)
-      .where(eq(schema.channels.serverId, id))
+      .where(eq(schema.channels.spaceId, id))
       .all();
 
     const roles = db.select()
       .from(schema.roles)
-      .where(eq(schema.roles.serverId, id))
+      .where(eq(schema.roles.spaceId, id))
       .orderBy(schema.roles.position)
       .all();
 
     const memberRows = db.select()
-      .from(schema.serverMembers)
-      .where(eq(schema.serverMembers.serverId, id))
+      .from(schema.spaceMembers)
+      .where(eq(schema.spaceMembers.spaceId, id))
       .all();
 
     const memberUserIds = memberRows.map(m => m.userId);
@@ -182,7 +182,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     const memberRoleRows = db.select()
       .from(schema.memberRoles)
-      .where(eq(schema.memberRoles.serverId, id))
+      .where(eq(schema.memberRoles.spaceId, id))
       .all();
 
     const members: MemberWithUser[] = memberRows
@@ -198,7 +198,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
           .filter(r => assignedRoleIds.includes(r.id))
           .map(r => ({
             id: r.id,
-            serverId: r.serverId,
+            spaceId: r.spaceId,
             name: r.name,
             color: r.color ?? '#b9bbbe',
             position: r.position ?? 0,
@@ -206,7 +206,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
           }));
 
         return {
-          serverId: m.serverId,
+          spaceId: m.spaceId,
           userId: m.userId,
           nickname: m.nickname,
           joinedAt: m.joinedAt,
@@ -222,13 +222,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       return (perms & PermissionBits.VIEW_CHANNEL) !== 0n;
     });
 
-    const result: ServerWithChannelsAndMembers = {
-      ...rowToServer(server),
+    const result: SpaceWithChannelsAndMembers = {
+      ...rowToSpace(server),
       channels: visibleChannels.map(rowToChannel),
       members,
       roles: roles.map(r => ({
         id: r.id,
-        serverId: r.serverId,
+        spaceId: r.spaceId,
         name: r.name,
         color: r.color ?? '#b9bbbe',
         position: r.position ?? 0,
@@ -239,29 +239,29 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send(result);
   });
 
-  // PATCH /api/servers/:id - Update server (owner only)
-  app.patch<{ Params: { id: string }; Body: UpdateServerRequest }>('/api/servers/:id', {
+  // PATCH /api/spaces/:id - Update server (owner only)
+  app.patch<{ Params: { id: string }; Body: UpdateSpaceRequest }>('/api/spaces/:id', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const { name, icon, visibility, description } = request.body;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (!hasPermission(request.userId, id, PermissionBits.MANAGE_SERVER)) {
-      return reply.code(403).send({ error: 'Missing MANAGE_SERVER permission', statusCode: 403 });
+    if (!hasPermission(request.userId, id, PermissionBits.MANAGE_SPACE)) {
+      return reply.code(403).send({ error: 'Missing MANAGE_SPACE permission', statusCode: 403 });
     }
 
-    const updates: Partial<typeof schema.servers.$inferInsert> = {};
+    const updates: Partial<typeof schema.spaces.$inferInsert> = {};
 
     if (name !== undefined) {
       const trimmedName = name.trim();
       if (trimmedName.length < 1 || trimmedName.length > 100) {
-        return reply.code(400).send({ error: 'Server name must be between 1 and 100 characters', statusCode: 400 });
+        return reply.code(400).send({ error: 'Space name must be between 1 and 100 characters', statusCode: 400 });
       }
       updates.name = trimmedName;
     }
@@ -287,60 +287,60 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(400).send({ error: 'No fields to update', statusCode: 400 });
     }
 
-    db.update(schema.servers).set(updates).where(eq(schema.servers.id, id)).run();
+    db.update(schema.spaces).set(updates).where(eq(schema.spaces.id, id)).run();
 
-    const updated = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const updated = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!updated) {
-      return reply.code(500).send({ error: 'Failed to update server', statusCode: 500 });
+      return reply.code(500).send({ error: 'Failed to update space', statusCode: 500 });
     }
 
-    const serverData = rowToServer(updated);
+    const spaceData = rowToSpace(updated);
 
-    // Broadcast server_updated to all server members
-    connectionManager.sendToServer(id, {
-      type: 'server_updated',
-      server: serverData,
+    // Broadcast space_updated to all space members
+    connectionManager.sendToSpace(id, {
+      type: 'space_updated',
+      space: spaceData,
     });
 
-    return reply.code(200).send(serverData);
+    return reply.code(200).send(spaceData);
   });
 
-  // DELETE /api/servers/:id - Delete server (owner only)
-  app.delete<{ Params: { id: string } }>('/api/servers/:id', {
+  // DELETE /api/spaces/:id - Delete server (owner only)
+  app.delete<{ Params: { id: string } }>('/api/spaces/:id', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
-    if (!isServerOwner(id, request.userId)) {
-      return reply.code(403).send({ error: 'Only the server owner can delete the server', statusCode: 403 });
+    if (!isSpaceOwner(id, request.userId)) {
+      return reply.code(403).send({ error: 'Only the space owner can delete the space', statusCode: 403 });
     }
 
     // Delete all channels (messages cascade), members, then server atomically
     db.transaction((tx) => {
-      tx.delete(schema.channels).where(eq(schema.channels.serverId, id)).run();
-      tx.delete(schema.serverMembers).where(eq(schema.serverMembers.serverId, id)).run();
-      tx.delete(schema.servers).where(eq(schema.servers.id, id)).run();
+      tx.delete(schema.channels).where(eq(schema.channels.spaceId, id)).run();
+      tx.delete(schema.spaceMembers).where(eq(schema.spaceMembers.spaceId, id)).run();
+      tx.delete(schema.spaces).where(eq(schema.spaces.id, id)).run();
     });
 
     return reply.code(200).send({ success: true });
   });
 
-  // POST /api/servers/:id/invite - Generate invite code (admin+)
-  app.post<{ Params: { id: string } }>('/api/servers/:id/invite', {
+  // POST /api/spaces/:id/invite - Generate invite code (admin+)
+  app.post<{ Params: { id: string } }>('/api/spaces/:id/invite', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!hasPermission(request.userId, id, PermissionBits.CREATE_INVITE)) {
@@ -353,13 +353,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     const inviteCode = generateInviteCode();
-    db.update(schema.servers).set({ inviteCode }).where(eq(schema.servers.id, id)).run();
+    db.update(schema.spaces).set({ inviteCode }).where(eq(schema.spaces.id, id)).run();
 
     return reply.code(200).send({ inviteCode });
   });
 
-  // POST /api/servers/:id/join - Join server by invite code
-  app.post<{ Params: { id: string }; Body: JoinServerRequest }>('/api/servers/:id/join', {
+  // POST /api/spaces/:id/join - Join server by invite code
+  app.post<{ Params: { id: string }; Body: JoinSpaceRequest }>('/api/spaces/:id/join', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
@@ -371,9 +371,9 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (server.inviteCode !== inviteCode) {
@@ -381,42 +381,42 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     if (isMember(id, request.userId)) {
-      return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
+      return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
     }
 
     const now = Date.now();
-    db.insert(schema.serverMembers).values({
-      serverId: id,
+    db.insert(schema.spaceMembers).values({
+      spaceId: id,
       userId: request.userId,
       joinedAt: now,
     }).run();
 
     // Register the user in connectionManager so they receive WS broadcasts for this server
-    connectionManager.addUserServer(request.userId, id);
+    connectionManager.addUserSpace(request.userId, id);
 
     // Broadcast member_joined to existing server members
     const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
     if (joiningUser) {
       const memberPayload: MemberWithUser = {
-        serverId: id,
+        spaceId: id,
         userId: request.userId,
         nickname: null,
         joinedAt: now,
         user: sanitizeUser(joiningUser),
         roles: [],
       };
-      connectionManager.sendToServer(id, {
+      connectionManager.sendToSpace(id, {
         type: 'member_joined',
-        serverId: id,
+        spaceId: id,
         member: memberPayload,
       });
     }
 
-    return reply.code(200).send(rowToServer(server));
+    return reply.code(200).send(rowToSpace(server));
   });
 
-  // POST /api/servers/join - Join server by invite code (no server ID needed)
-  app.post<{ Body: JoinServerRequest }>('/api/servers/join', {
+  // POST /api/spaces/join - Join server by invite code (no server ID needed)
+  app.post<{ Body: JoinSpaceRequest }>('/api/spaces/join', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { inviteCode } = request.body;
@@ -427,65 +427,65 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.inviteCode, inviteCode)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.inviteCode, inviteCode)).get();
     if (!server) {
       return reply.code(404).send({ error: 'Invalid invite code', statusCode: 404 });
     }
 
     if (isMember(server.id, request.userId)) {
-      return reply.code(409).send({ error: 'You are already a member of this server', statusCode: 409 });
+      return reply.code(409).send({ error: 'You are already a member of this space', statusCode: 409 });
     }
 
     const now = Date.now();
-    db.insert(schema.serverMembers).values({
-      serverId: server.id,
+    db.insert(schema.spaceMembers).values({
+      spaceId: server.id,
       userId: request.userId,
       joinedAt: now,
     }).run();
 
     // Register the user in connectionManager so they receive WS broadcasts for this server
-    connectionManager.addUserServer(request.userId, server.id);
+    connectionManager.addUserSpace(request.userId, server.id);
 
     // Broadcast member_joined to existing server members
     const joiningUser = db.select().from(schema.users).where(eq(schema.users.id, request.userId)).get();
     if (joiningUser) {
       const memberPayload: MemberWithUser = {
-        serverId: server.id,
+        spaceId: server.id,
         userId: request.userId,
         nickname: null,
         joinedAt: now,
         user: sanitizeUser(joiningUser),
         roles: [],
       };
-      connectionManager.sendToServer(server.id, {
+      connectionManager.sendToSpace(server.id, {
         type: 'member_joined',
-        serverId: server.id,
+        spaceId: server.id,
         member: memberPayload,
       });
     }
 
-    return reply.code(200).send(rowToServer(server));
+    return reply.code(200).send(rowToSpace(server));
   });
 
-  // GET /api/servers/:id/members - List server members
-  app.get<{ Params: { id: string } }>('/api/servers/:id/members', {
+  // GET /api/spaces/:id/members - List server members
+  app.get<{ Params: { id: string } }>('/api/spaces/:id/members', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!isMember(id, request.userId)) {
-      return reply.code(403).send({ error: 'You are not a member of this server', statusCode: 403 });
+      return reply.code(403).send({ error: 'You are not a member of this space', statusCode: 403 });
     }
 
     const memberRows = db.select()
-      .from(schema.serverMembers)
-      .where(eq(schema.serverMembers.serverId, id))
+      .from(schema.spaceMembers)
+      .where(eq(schema.spaceMembers.spaceId, id))
       .all();
 
     const memberUserIds = memberRows.map(m => m.userId);
@@ -497,13 +497,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     const roles = db.select()
       .from(schema.roles)
-      .where(eq(schema.roles.serverId, id))
+      .where(eq(schema.roles.spaceId, id))
       .orderBy(schema.roles.position)
       .all();
 
     const memberRoleRows = db.select()
       .from(schema.memberRoles)
-      .where(eq(schema.memberRoles.serverId, id))
+      .where(eq(schema.memberRoles.spaceId, id))
       .all();
 
     const members: MemberWithUser[] = memberRows
@@ -519,7 +519,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
           .filter(r => assignedRoleIds.includes(r.id))
           .map(r => ({
             id: r.id,
-            serverId: r.serverId,
+            spaceId: r.spaceId,
             name: r.name,
             color: r.color ?? '#b9bbbe',
             position: r.position ?? 0,
@@ -527,7 +527,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
           }));
 
         return {
-          serverId: m.serverId,
+          spaceId: m.spaceId,
           userId: m.userId,
           nickname: m.nickname,
           joinedAt: m.joinedAt,
@@ -540,17 +540,17 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send(members);
   });
 
-  // PATCH /api/servers/:id/members/:uid - Update member roles
-  app.patch<{ Params: { id: string; uid: string }; Body: UpdateMemberRequest }>('/api/servers/:id/members/:uid', {
+  // PATCH /api/spaces/:id/members/:uid - Update member roles
+  app.patch<{ Params: { id: string; uid: string }; Body: UpdateMemberRequest }>('/api/spaces/:id/members/:uid', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, uid } = request.params;
     const { roleIds } = request.body;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     if (!hasPermission(request.userId, id, PermissionBits.MANAGE_ROLES)) {
@@ -566,15 +566,15 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     // Cannot modify the server owner's roles unless you are the owner
-    if (isServerOwner(id, uid) && !isServerOwner(id, request.userId)) {
-      return reply.code(403).send({ error: 'Only the server owner can modify their own roles', statusCode: 403 });
+    if (isSpaceOwner(id, uid) && !isSpaceOwner(id, request.userId)) {
+      return reply.code(403).send({ error: 'Only the space owner can modify their own roles', statusCode: 403 });
     }
 
     const member = db.select()
-      .from(schema.serverMembers)
+      .from(schema.spaceMembers)
       .where(and(
-        eq(schema.serverMembers.serverId, id),
-        eq(schema.serverMembers.userId, uid),
+        eq(schema.spaceMembers.spaceId, id),
+        eq(schema.spaceMembers.userId, uid),
       ))
       .get();
 
@@ -584,16 +584,16 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     // Validate all roleIds belong to this server and are not @everyone
     if (roleIds.length > 0) {
-      const serverRoles = db.select()
+      const spaceRoles = db.select()
         .from(schema.roles)
-        .where(eq(schema.roles.serverId, id))
+        .where(eq(schema.roles.spaceId, id))
         .all();
 
-      const serverRoleIds = new Set(serverRoles.map(r => r.id));
+      const spaceRoleIds = new Set(spaceRoles.map(r => r.id));
 
       for (const roleId of roleIds) {
-        if (!serverRoleIds.has(roleId)) {
-          return reply.code(400).send({ error: `Role ${roleId} does not belong to this server`, statusCode: 400 });
+        if (!spaceRoleIds.has(roleId)) {
+          return reply.code(400).send({ error: `Role ${roleId} does not belong to this space`, statusCode: 400 });
         }
         if (roleId === id) {
           return reply.code(400).send({ error: '@everyone role is implicit and cannot be assigned', statusCode: 400 });
@@ -606,7 +606,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       // Remove all existing role assignments for this member in this server
       tx.delete(schema.memberRoles)
         .where(and(
-          eq(schema.memberRoles.serverId, id),
+          eq(schema.memberRoles.spaceId, id),
           eq(schema.memberRoles.userId, uid),
         ))
         .run();
@@ -614,7 +614,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       // Insert new role assignments
       for (const roleId of roleIds) {
         tx.insert(schema.memberRoles).values({
-          serverId: id,
+          spaceId: id,
           userId: uid,
           roleId,
         }).run();
@@ -626,10 +626,10 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     // Build response with populated roles
     const updatedMember = db.select()
-      .from(schema.serverMembers)
+      .from(schema.spaceMembers)
       .where(and(
-        eq(schema.serverMembers.serverId, id),
-        eq(schema.serverMembers.userId, uid),
+        eq(schema.spaceMembers.spaceId, id),
+        eq(schema.spaceMembers.userId, uid),
       ))
       .get();
 
@@ -645,7 +645,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     const updatedRoleRows = db.select()
       .from(schema.memberRoles)
       .where(and(
-        eq(schema.memberRoles.serverId, id),
+        eq(schema.memberRoles.spaceId, id),
         eq(schema.memberRoles.userId, uid),
       ))
       .all();
@@ -653,7 +653,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     const updatedRoleIds = updatedRoleRows.map(r => r.roleId);
     const allRoles = db.select()
       .from(schema.roles)
-      .where(eq(schema.roles.serverId, id))
+      .where(eq(schema.roles.spaceId, id))
       .orderBy(schema.roles.position)
       .all();
 
@@ -661,7 +661,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       .filter(r => updatedRoleIds.includes(r.id))
       .map(r => ({
         id: r.id,
-        serverId: r.serverId,
+        spaceId: r.spaceId,
         name: r.name,
         color: r.color ?? '#b9bbbe',
         position: r.position ?? 0,
@@ -669,7 +669,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       }));
 
     const result: MemberWithUser = {
-      serverId: updatedMember.serverId,
+      spaceId: updatedMember.spaceId,
       userId: updatedMember.userId,
       nickname: updatedMember.nickname,
       joinedAt: updatedMember.joinedAt,
@@ -680,20 +680,20 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send(result);
   });
 
-  // DELETE /api/servers/:id/members/:uid - Kick member (owner) or leave (self)
-  app.delete<{ Params: { id: string; uid: string } }>('/api/servers/:id/members/:uid', {
+  // DELETE /api/spaces/:id/members/:uid - Kick member (owner) or leave (self)
+  app.delete<{ Params: { id: string; uid: string } }>('/api/spaces/:id/members/:uid', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, uid } = request.params;
     const db = getDb();
 
-    const server = db.select().from(schema.servers).where(eq(schema.servers.id, id)).get();
+    const server = db.select().from(schema.spaces).where(eq(schema.spaces.id, id)).get();
     if (!server) {
-      return reply.code(404).send({ error: 'Server not found', statusCode: 404 });
+      return reply.code(404).send({ error: 'Space not found', statusCode: 404 });
     }
 
     const isSelf = uid === request.userId;
-    const isOwnerUser = isServerOwner(id, request.userId);
+    const isOwnerUser = isSpaceOwner(id, request.userId);
     const canKick = hasPermission(request.userId, id, PermissionBits.KICK_MEMBERS);
 
     if (!isSelf && !canKick) {
@@ -702,14 +702,14 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
     // Owner cannot leave their own server - they must delete it
     if (isSelf && isOwnerUser) {
-      return reply.code(400).send({ error: 'Server owner cannot leave. Transfer ownership or delete the server.', statusCode: 400 });
+      return reply.code(400).send({ error: 'Space owner cannot leave. Transfer ownership or delete the space.', statusCode: 400 });
     }
 
     const member = db.select()
-      .from(schema.serverMembers)
+      .from(schema.spaceMembers)
       .where(and(
-        eq(schema.serverMembers.serverId, id),
-        eq(schema.serverMembers.userId, uid),
+        eq(schema.spaceMembers.spaceId, id),
+        eq(schema.spaceMembers.userId, uid),
       ))
       .get();
 
@@ -718,21 +718,21 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     // Cannot kick the owner
-    if (isServerOwner(id, uid)) {
-      return reply.code(400).send({ error: 'Cannot remove the server owner', statusCode: 400 });
+    if (isSpaceOwner(id, uid)) {
+      return reply.code(400).send({ error: 'Cannot remove the space owner', statusCode: 400 });
     }
 
-    db.delete(schema.serverMembers)
+    db.delete(schema.spaceMembers)
       .where(and(
-        eq(schema.serverMembers.serverId, id),
-        eq(schema.serverMembers.userId, uid),
+        eq(schema.spaceMembers.spaceId, id),
+        eq(schema.spaceMembers.userId, uid),
       ))
       .run();
 
     // Broadcast member_left event
-    connectionManager.sendToServer(id, {
+    connectionManager.sendToSpace(id, {
       type: 'member_left',
-      serverId: id,
+      spaceId: id,
       userId: uid,
     });
 
@@ -741,8 +741,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
 
   // Role Management
   
-  // POST /api/servers/:id/roles - Create a new role
-  app.post<{ Params: { id: string }; Body: { name: string; color?: string } }>('/api/servers/:id/roles', {
+  // POST /api/spaces/:id/roles - Create a new role
+  app.post<{ Params: { id: string }; Body: { name: string; color?: string } }>('/api/spaces/:id/roles', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id } = request.params;
@@ -756,7 +756,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     const roleId = generateSnowflake();
     db.insert(schema.roles).values({
       id: roleId,
-      serverId: id,
+      spaceId: id,
       name: name || 'new role',
       color: color || '#b9bbbe',
       position: 0,
@@ -767,8 +767,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(201).send(role);
   });
 
-  // PATCH /api/servers/:id/roles/:roleId - Update a role
-  app.patch<{ Params: { id: string; roleId: string }; Body: { name?: string; color?: string; position?: number } }>('/api/servers/:id/roles/:roleId', {
+  // PATCH /api/spaces/:id/roles/:roleId - Update a role
+  app.patch<{ Params: { id: string; roleId: string }; Body: { name?: string; color?: string; position?: number } }>('/api/spaces/:id/roles/:roleId', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, roleId } = request.params;
@@ -779,13 +779,13 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       return reply.code(403).send({ error: 'Missing MANAGE_ROLES permission', statusCode: 403 });
     }
 
-    db.update(schema.roles).set(updates).where(and(eq(schema.roles.id, roleId), eq(schema.roles.serverId, id))).run();
+    db.update(schema.roles).set(updates).where(and(eq(schema.roles.id, roleId), eq(schema.roles.spaceId, id))).run();
     const updated = db.select().from(schema.roles).where(eq(schema.roles.id, roleId)).get();
     return reply.code(200).send(updated);
   });
 
-  // DELETE /api/servers/:id/roles/:roleId - Delete a role
-  app.delete<{ Params: { id: string; roleId: string } }>('/api/servers/:id/roles/:roleId', {
+  // DELETE /api/spaces/:id/roles/:roleId - Delete a role
+  app.delete<{ Params: { id: string; roleId: string } }>('/api/spaces/:id/roles/:roleId', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, roleId } = request.params;
@@ -805,12 +805,12 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
       and(eq(schema.channelOverrides.targetType, 'role'), eq(schema.channelOverrides.targetId, roleId))
     ).run();
 
-    db.delete(schema.roles).where(and(eq(schema.roles.id, roleId), eq(schema.roles.serverId, id))).run();
+    db.delete(schema.roles).where(and(eq(schema.roles.id, roleId), eq(schema.roles.spaceId, id))).run();
     return reply.code(200).send({ success: true });
   });
 
-  // POST /api/servers/:id/members/:uid/roles - Add role to member
-  app.post<{ Params: { id: string; uid: string }; Body: { roleId: string } }>('/api/servers/:id/members/:uid/roles', {
+  // POST /api/spaces/:id/members/:uid/roles - Add role to member
+  app.post<{ Params: { id: string; uid: string }; Body: { roleId: string } }>('/api/spaces/:id/members/:uid/roles', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, uid } = request.params;
@@ -822,7 +822,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     db.insert(schema.memberRoles).values({
-      serverId: id,
+      spaceId: id,
       userId: uid,
       roleId,
     }).run();
@@ -830,8 +830,8 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     return reply.code(200).send({ success: true });
   });
 
-  // DELETE /api/servers/:id/members/:uid/roles/:roleId - Remove role from member
-  app.delete<{ Params: { id: string; uid: string; roleId: string } }>('/api/servers/:id/members/:uid/roles/:roleId', {
+  // DELETE /api/spaces/:id/members/:uid/roles/:roleId - Remove role from member
+  app.delete<{ Params: { id: string; uid: string; roleId: string } }>('/api/spaces/:id/members/:uid/roles/:roleId', {
     preHandler: authenticate,
   }, async (request, reply) => {
     const { id, uid, roleId } = request.params;
@@ -842,7 +842,7 @@ export async function serverRoutes(app: FastifyInstance): Promise<void> {
     }
 
     db.delete(schema.memberRoles).where(and(
-      eq(schema.memberRoles.serverId, id),
+      eq(schema.memberRoles.spaceId, id),
       eq(schema.memberRoles.userId, uid),
       eq(schema.memberRoles.roleId, roleId)
     )).run();

packages/server/src/routes/users.ts

@@ -120,9 +120,9 @@ export async function userRoutes(app: FastifyInstance): Promise<void> {
 
     // Broadcast presence update if status changed
     if (status !== undefined) {
-      const userServers = connectionManager.getUserServers(sanitized.id);
-      for (const serverId of userServers) {
-        connectionManager.sendToServer(serverId, {
+      const userSpaces = connectionManager.getUserSpaces(sanitized.id);
+      for (const spaceId of userSpaces) {
+        connectionManager.sendToSpace(spaceId, {
           type: 'presence_update',
           userId: sanitized.id,
           status: status,

packages/server/src/utils/permissions.ts

@@ -13,7 +13,7 @@ export { PermissionBits, ALL_PERMISSIONS, permissionsToString, stringToPermissio
 // ─── Core Resolution Engine ─────────────────────────────────────────────────
 
 /**
- * Compute the effective permissions for a user in a server, optionally scoped
+ * Compute the effective permissions for a user in a space, optionally scoped
  * to a specific channel. Follows Discord's resolution order:
  *
  * 1. Owner → ALL_PERMISSIONS
@@ -24,24 +24,24 @@ export { PermissionBits, ALL_PERMISSIONS, permissionsToString, stringToPermissio
  *    b. Role overrides (combined)
  *    c. Member-specific override
  */
-export function computePermissions(userId: string, serverId: string, channelId?: string): bigint {
+export function computePermissions(userId: string, spaceId: string, channelId?: string): bigint {
   const db = getDb();
 
   // 1. Owner check
-  const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
-  if (!server) return 0n;
-  if (server.ownerId === userId) return ALL_PERMISSIONS;
+  const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
+  if (!space) return 0n;
+  if (space.ownerId === userId) return ALL_PERMISSIONS;
 
-  // 2. Base permissions from @everyone role (id === serverId)
+  // 2. Base permissions from @everyone role (id === spaceId)
   const everyoneRole = db.select().from(schema.roles)
-    .where(and(eq(schema.roles.id, serverId), eq(schema.roles.serverId, serverId)))
+    .where(and(eq(schema.roles.id, spaceId), eq(schema.roles.spaceId, spaceId)))
     .get();
   let base = everyoneRole ? stringToPermissions(everyoneRole.permissions) : 0n;
 
   // Get user's assigned roles via member_roles
   const memberRoleRows = db.select().from(schema.memberRoles)
     .where(and(
-      eq(schema.memberRoles.serverId, serverId),
+      eq(schema.memberRoles.spaceId, spaceId),
       eq(schema.memberRoles.userId, userId),
     ))
     .all();
@@ -61,7 +61,7 @@ export function computePermissions(userId: string, serverId: string, channelId?:
   // 3. Admin shortcut
   if ((base & PermissionBits.ADMINISTRATOR) !== 0n) return ALL_PERMISSIONS;
 
-  // If no channel, return server-level perms
+  // If no channel, return space-level perms
   if (!channelId) return base;
 
   // 4. Channel overrides
@@ -71,8 +71,8 @@ export function computePermissions(userId: string, serverId: string, channelId?:
 
   if (overrides.length === 0) return base;
 
-  // 4a. @everyone role override (target_type='role', target_id=serverId)
-  const everyoneOverride = overrides.find(o => o.targetType === 'role' && o.targetId === serverId);
+  // 4a. @everyone role override (target_type='role', target_id=spaceId)
+  const everyoneOverride = overrides.find(o => o.targetType === 'role' && o.targetId === spaceId);
   if (everyoneOverride) {
     const deny = stringToPermissions(everyoneOverride.deny);
     const allow = stringToPermissions(everyoneOverride.allow);
@@ -103,46 +103,46 @@ export function computePermissions(userId: string, serverId: string, channelId?:
 }
 
 /**
- * Check if a user has a specific permission in a server/channel.
+ * Check if a user has a specific permission in a space/channel.
  */
 export function hasPermission(
   userId: string,
-  serverId: string,
+  spaceId: string,
   permission: bigint,
   channelId?: string,
 ): boolean {
-  const perms = computePermissions(userId, serverId, channelId);
+  const perms = computePermissions(userId, spaceId, channelId);
   // ADMINISTRATOR grants everything
   if ((perms & PermissionBits.ADMINISTRATOR) !== 0n) return true;
   return (perms & permission) === permission;
 }
 
-// ─── Existing helpers (kept for backward compat) ────────────────────────────
+// ─── Existing helpers ───────────────────────────────────────────────────────
 
-export function getMember(serverId: string, userId: string) {
+export function getMember(spaceId: string, userId: string) {
   const db = getDb();
-  return db.select().from(schema.serverMembers)
+  return db.select().from(schema.spaceMembers)
     .where(and(
-      eq(schema.serverMembers.serverId, serverId),
-      eq(schema.serverMembers.userId, userId),
+      eq(schema.spaceMembers.spaceId, spaceId),
+      eq(schema.spaceMembers.userId, userId),
     ))
     .get();
 }
 
-export function isMember(serverId: string, userId: string): boolean {
-  return getMember(serverId, userId) !== undefined;
+export function isMember(spaceId: string, userId: string): boolean {
+  return getMember(spaceId, userId) !== undefined;
 }
 
-export function isServerOwner(serverId: string, userId: string): boolean {
+export function isSpaceOwner(spaceId: string, userId: string): boolean {
   const db = getDb();
-  const server = db.select().from(schema.servers).where(eq(schema.servers.id, serverId)).get();
-  return server?.ownerId === userId;
+  const space = db.select().from(schema.spaces).where(eq(schema.spaces.id, spaceId)).get();
+  return space?.ownerId === userId;
 }
 
-export function getChannelServerId(channelId: string): string | null {
+export function getChannelSpaceId(channelId: string): string | null {
   const db = getDb();
   const channel = db.select().from(schema.channels).where(eq(schema.channels.id, channelId)).get();
-  return channel?.serverId ?? null;
+  return channel?.spaceId ?? null;
 }
 
 export function isDmMember(dmChannelId: string, userId: string): boolean {

packages/server/src/ws/events.ts

@@ -2,8 +2,8 @@ import { eq, inArray, and } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { generateSnowflake } from '../utils/snowflake.js';
 import { connectionManager } from './handler.js';
-import type { VoiceRoom, DmRoomMeta, ServerRoomMeta } from './handler.js';
-import { isMember, getChannelServerId, isDmMember, hasPermission, PermissionBits } from '../utils/permissions.js';
+import type { VoiceRoom, DmRoomMeta, SpaceRoomMeta } from './handler.js';
+import { isMember, getChannelSpaceId, isDmMember, hasPermission, PermissionBits } from '../utils/permissions.js';
 import { broadcastDmMessage, getDmMessageWithUser } from '../routes/dm.js';
 import type { MessageWithUser, Attachment, DmMessageWithUser } from '@backspace/shared';
 import { sanitizeUser } from '../utils/sanitize.js';
@@ -173,13 +173,13 @@ function handleMessageCreate(event: Record<string, unknown>, userId: string): vo
     return;
   }
 
-  const serverId = getChannelServerId(channelId);
-  if (!serverId) {
+  const spaceId = getChannelSpaceId(channelId);
+  if (!spaceId) {
     connectionManager.sendToUser(userId, { type: 'error', message: 'Channel not found' });
     return;
   }
 
-  if (!hasPermission(userId, serverId, PermissionBits.SEND_MESSAGES, channelId)) {
+  if (!hasPermission(userId, spaceId, PermissionBits.SEND_MESSAGES, channelId)) {
     connectionManager.sendToUser(userId, { type: 'error', message: 'Missing SEND_MESSAGES permission' });
     return;
   }
@@ -200,7 +200,7 @@ function handleMessageCreate(event: Record<string, unknown>, userId: string): vo
   const messageWithUser = getMessageWithUser(messageId);
   if (messageWithUser) {
     // Broadcast to members with VIEW_CHANNEL on this channel
-    connectionManager.sendToChannel(serverId, channelId, {
+    connectionManager.sendToChannel(spaceId, channelId, {
       type: 'message_created',
       message: messageWithUser,
     });
@@ -239,12 +239,12 @@ function handleMessageEdit(event: Record<string, unknown>, userId: string): void
     .where(eq(schema.messages.id, messageId))
     .run();
 
-  const serverId = getChannelServerId(message.channelId);
-  if (!serverId) return;
+  const spaceId = getChannelSpaceId(message.channelId);
+  if (!spaceId) return;
 
   const updatedMessage = getMessageWithUser(messageId);
   if (updatedMessage) {
-    connectionManager.sendToChannel(serverId, message.channelId, {
+    connectionManager.sendToChannel(spaceId, message.channelId, {
       type: 'message_updated',
       message: updatedMessage,
     });
@@ -266,12 +266,12 @@ function handleMessageDelete(event: Record<string, unknown>, userId: string): vo
     return;
   }
 
-  const serverId = getChannelServerId(message.channelId);
-  if (!serverId) return;
+  const spaceId = getChannelSpaceId(message.channelId);
+  if (!spaceId) return;
 
   // Allow author or MANAGE_MESSAGES permission holder to delete
   const isAuthor = message.userId === userId;
-  const canManageMessages = hasPermission(userId, serverId, PermissionBits.MANAGE_MESSAGES, message.channelId);
+  const canManageMessages = hasPermission(userId, spaceId, PermissionBits.MANAGE_MESSAGES, message.channelId);
 
   if (!isAuthor && !canManageMessages) {
     connectionManager.sendToUser(userId, { type: 'error', message: 'You cannot delete this message' });
@@ -282,7 +282,7 @@ function handleMessageDelete(event: Record<string, unknown>, userId: string): vo
   db.delete(schema.attachments).where(eq(schema.attachments.messageId, messageId)).run();
   db.delete(schema.messages).where(eq(schema.messages.id, messageId)).run();
 
-  connectionManager.sendToChannel(serverId, message.channelId, {
+  connectionManager.sendToChannel(spaceId, message.channelId, {
     type: 'message_deleted',
     messageId,
     channelId: message.channelId,
@@ -294,10 +294,10 @@ function handleTypingStart(event: Record<string, unknown>, userId: string, usern
 
   if (!channelId || typeof channelId !== 'string') return;
 
-  const serverId = getChannelServerId(channelId);
-  if (!serverId) return;
+  const spaceId = getChannelSpaceId(channelId);
+  if (!spaceId) return;
 
-  if (!hasPermission(userId, serverId, PermissionBits.SEND_MESSAGES, channelId)) return;
+  if (!hasPermission(userId, spaceId, PermissionBits.SEND_MESSAGES, channelId)) return;
 
   // Clear previous typing timeout for this user+channel
   const key = `${userId}:${channelId}`;
@@ -307,7 +307,7 @@ function handleTypingStart(event: Record<string, unknown>, userId: string, usern
   }
 
   // Broadcast typing event to channel viewers (exclude sender)
-  connectionManager.sendToChannel(serverId, channelId, {
+  connectionManager.sendToChannel(spaceId, channelId, {
     type: 'typing',
     channelId,
     userId,
@@ -332,10 +332,10 @@ function handlePresenceUpdate(event: Record<string, unknown>, userId: string): v
   const db = getDb();
   db.update(schema.users).set({ status }).where(eq(schema.users.id, userId)).run();
 
-  // Broadcast to all servers user is in
-  const userServers = connectionManager.getUserServers(userId);
-  for (const serverId of userServers) {
-    connectionManager.sendToServer(serverId, {
+  // Broadcast to all spaces user is in
+  const userSpaces = connectionManager.getUserSpaces(userId);
+  for (const spaceId of userSpaces) {
+    connectionManager.sendToSpace(spaceId, {
       type: 'presence_update',
       userId,
       status,
@@ -354,9 +354,9 @@ function handlePresenceUpdate(event: Record<string, unknown>, userId: string): v
 
 /** Helper: broadcast a voice leave and auto-end empty DM calls. */
 function broadcastRoomLeave(roomId: string, room: VoiceRoom, userId: string): void {
-  if (room.roomType === 'server') {
-    const meta = room.metadata as ServerRoomMeta;
-    connectionManager.sendToServer(meta.serverId, {
+  if (room.roomType === 'space') {
+    const meta = room.metadata as SpaceRoomMeta;
+    connectionManager.sendToSpace(meta.spaceId, {
       type: 'voice_state_update',
       channelId: roomId,
       userId,
@@ -389,13 +389,13 @@ function handleVoiceJoin(event: Record<string, unknown>, userId: string): void {
     return;
   }
 
-  const serverId = getChannelServerId(channelId);
-  if (!serverId) {
+  const spaceId = getChannelSpaceId(channelId);
+  if (!spaceId) {
     connectionManager.sendToUser(userId, { type: 'error', message: 'Channel not found' });
     return;
   }
 
-  if (!hasPermission(userId, serverId, PermissionBits.CONNECT, channelId)) {
+  if (!hasPermission(userId, spaceId, PermissionBits.CONNECT, channelId)) {
     connectionManager.sendToUser(userId, { type: 'error', message: 'Missing CONNECT permission' });
     return;
   }
@@ -419,7 +419,7 @@ function handleVoiceJoin(event: Record<string, unknown>, userId: string): void {
     return;
   }
 
-  // Leave current room (server OR DM)
+  // Leave current room (space OR DM)
   const left = connectionManager.leaveCurrentRoom(userId);
   if (left) {
     broadcastRoomLeave(left.roomId, left.room, userId);
@@ -440,8 +440,8 @@ function handleVoiceJoin(event: Record<string, unknown>, userId: string): void {
     }
   }
 
-  // Lazy-create server room
-  connectionManager.createRoom(channelId, 'server', { type: 'server', serverId });
+  // Lazy-create space room
+  connectionManager.createRoom(channelId, 'space', { type: 'space', spaceId });
 
   // Join room
   connectionManager.joinRoom(channelId, userId);
@@ -490,7 +490,7 @@ function handleVoiceStatus(event: Record<string, unknown>, userId: string): void
 
   connectionManager.setVoiceUserStatus(userId, isMuted, isDeafened, isCameraOn, isScreenSharing);
 
-  // sendToRoom routes to sendToServer for server rooms, sendToDmMembers for DM rooms
+  // sendToRoom routes to sendToSpace for space rooms, sendToDmMembers for DM rooms
   connectionManager.sendToRoom(userRoom.roomId, {
     type: 'voice_status_update',
     userId,
@@ -702,11 +702,11 @@ function handleReactionAdd(event: Record<string, unknown>, userId: string): void
 
   const db = getDb();
 
-  // Try server message first
+  // Try space message first
   const message = db.select().from(schema.messages).where(eq(schema.messages.id, messageId)).get();
   if (message) {
-    const serverId = getChannelServerId(message.channelId);
-    if (!serverId || !isMember(serverId, userId)) return;
+    const spaceId = getChannelSpaceId(message.channelId);
+    if (!spaceId || !isMember(spaceId, userId)) return;
 
     const reactionId = generateSnowflake();
     const now = Date.now();
@@ -723,7 +723,7 @@ function handleReactionAdd(event: Record<string, unknown>, userId: string): void
       const reactionUser = db.select().from(schema.users).where(eq(schema.users.id, userId)).get();
       const userObj = reactionUser ? sanitizeUser(reactionUser) : undefined;
 
-      connectionManager.sendToChannel(serverId, message.channelId, {
+      connectionManager.sendToChannel(spaceId, message.channelId, {
         type: 'reaction_added',
         messageId,
         reaction: { id: reactionId, messageId, userId, emoji, createdAt: now, user: userObj },
@@ -771,11 +771,11 @@ function handleReactionRemove(event: Record<string, unknown>, userId: string): v
 
   const db = getDb();
 
-  // Try server message first
+  // Try space message first
   const message = db.select().from(schema.messages).where(eq(schema.messages.id, messageId)).get();
   if (message) {
-    const serverId = getChannelServerId(message.channelId);
-    if (!serverId || !isMember(serverId, userId)) return;
+    const spaceId = getChannelSpaceId(message.channelId);
+    if (!spaceId || !isMember(spaceId, userId)) return;
 
     const result = db.delete(schema.reactions)
       .where(and(
@@ -786,7 +786,7 @@ function handleReactionRemove(event: Record<string, unknown>, userId: string): v
       .run();
 
     if (result.changes > 0) {
-      connectionManager.sendToChannel(serverId, message.channelId, {
+      connectionManager.sendToChannel(spaceId, message.channelId, {
         type: 'reaction_removed',
         messageId,
         userId,

packages/server/src/ws/handler.ts

@@ -7,12 +7,12 @@ import { handleClientEvent } from './events.js';
 import { computePermissions, PermissionBits, permissionsToString } from '../utils/permissions.js';
 import type {
   User,
-  ServerWithChannelsAndMembers,
+  SpaceWithChannelsAndMembers,
   MemberWithUser,
   Channel,
   DmChannel,
   ServerEvent,
-  ServerFolder,
+  SpaceFolder,
   ReadState,
   ActiveCallInfo,
 } from '@backspace/shared';
@@ -39,9 +39,9 @@ export interface AuthenticatedSocket {
 
 // ─── VoiceRoom Abstraction ─────────────────────────────────────────────────
 
-export interface ServerRoomMeta {
-  type: 'server';
-  serverId: string;
+export interface SpaceRoomMeta {
+  type: 'space';
+  spaceId: string;
 }
 
 export interface DmRoomMeta {
@@ -52,9 +52,9 @@ export interface DmRoomMeta {
 
 export interface VoiceRoom {
   roomId: string;
-  roomType: 'server' | 'dm';
+  roomType: 'space' | 'dm';
   participants: Set<string>;
-  metadata: ServerRoomMeta | DmRoomMeta;
+  metadata: SpaceRoomMeta | DmRoomMeta;
   startedAt: number;
 }
 
@@ -63,8 +63,8 @@ export interface VoiceRoom {
 class ConnectionManager {
   // userId → Set of WebSocket connections (multiple tabs)
   private connections: Map<string, Set<WebSocket>> = new Map();
-  // userId → Set of server IDs the user belongs to
-  private userServers: Map<string, Set<string>> = new Map();
+  // userId → Set of space IDs the user belongs to
+  private userSpaces: Map<string, Set<string>> = new Map();
   // ws → userId (reverse lookup)
   private wsToUser: Map<WebSocket, string> = new Map();
   // Unified voice room tracking (replaces voiceStates + activeCalls)
@@ -134,13 +134,13 @@ class ConnectionManager {
     const db = getDb();
     db.update(schema.users).set({ status: 'offline' }).where(eq(schema.users.id, userId)).run();
 
-    // Leave voice room if in one (handles both server and DM rooms)
+    // Leave voice room if in one (handles both space and DM rooms)
     const left = this.leaveCurrentRoom(userId);
     this.clearVoiceUserStatus(userId);
     if (left) {
-      if (left.room.roomType === 'server') {
-        const meta = left.room.metadata as ServerRoomMeta;
-        this.sendToServer(meta.serverId, {
+      if (left.room.roomType === 'space') {
+        const meta = left.room.metadata as SpaceRoomMeta;
+        this.sendToSpace(meta.spaceId, {
           type: 'voice_state_update',
           channelId: left.roomId,
           userId: userId,
@@ -179,10 +179,10 @@ class ConnectionManager {
       }
     }
 
-    // Broadcast offline to all servers
-    const userServers = this.getUserServers(userId);
-    for (const serverId of userServers) {
-      this.sendToServer(serverId, {
+    // Broadcast offline to all spaces
+    const userSpaces = this.getUserSpaces(userId);
+    for (const spaceId of userSpaces) {
+      this.sendToSpace(spaceId, {
         type: 'presence_update',
         userId: userId,
         status: 'offline',
@@ -199,25 +199,25 @@ class ConnectionManager {
     return conns !== undefined && conns.size > 0;
   }
 
-  setUserServers(userId: string, serverIds: string[]): void {
-    this.userServers.set(userId, new Set(serverIds));
+  setUserSpaces(userId: string, spaceIds: string[]): void {
+    this.userSpaces.set(userId, new Set(spaceIds));
   }
 
-  addUserServer(userId: string, serverId: string): void {
-    if (!this.userServers.has(userId)) {
-      this.userServers.set(userId, new Set());
+  addUserSpace(userId: string, spaceId: string): void {
+    if (!this.userSpaces.has(userId)) {
+      this.userSpaces.set(userId, new Set());
     }
-    this.userServers.get(userId)!.add(serverId);
+    this.userSpaces.get(userId)!.add(spaceId);
   }
 
-  getUserServers(userId: string): Set<string> {
-    return this.userServers.get(userId) ?? new Set();
+  getUserSpaces(userId: string): Set<string> {
+    return this.userSpaces.get(userId) ?? new Set();
   }
 
   // ─── Unified VoiceRoom API ─────────────────────────────────────────────────
 
   /** Create a room. Returns false if room already exists. */
-  createRoom(roomId: string, roomType: 'server' | 'dm', metadata: ServerRoomMeta | DmRoomMeta): boolean {
+  createRoom(roomId: string, roomType: 'space' | 'dm', metadata: SpaceRoomMeta | DmRoomMeta): boolean {
     if (this.voiceRooms.has(roomId)) return false;
     this.voiceRooms.set(roomId, {
       roomId,
@@ -283,7 +283,7 @@ class ConnectionManager {
       const oldRoom = this.voiceRooms.get(currentRoomId);
       if (oldRoom) {
         oldRoom.participants.delete(userId);
-        if (oldRoom.participants.size === 0 && oldRoom.roomType === 'server') {
+        if (oldRoom.participants.size === 0 && oldRoom.roomType === 'space') {
           this.voiceRooms.delete(currentRoomId);
         }
       }
@@ -302,8 +302,8 @@ class ConnectionManager {
     room.participants.delete(userId);
     this.userToRoom.delete(userId);
 
-    // Auto-cleanup empty server rooms (they're lazy-created)
-    if (room.participants.size === 0 && room.roomType === 'server') {
+    // Auto-cleanup empty space rooms (they're lazy-created)
+    if (room.participants.size === 0 && room.roomType === 'space') {
       this.voiceRooms.delete(roomId);
     }
 
@@ -399,11 +399,11 @@ class ConnectionManager {
     }
   }
 
-  /** Send to all members of a server. */
-  sendToServer(serverId: string, event: ServerEvent, excludeUserId?: string): void {
+  /** Send to all members of a space. */
+  sendToSpace(spaceId: string, event: ServerEvent, excludeUserId?: string): void {
     const message = JSON.stringify(event);
-    for (const [userId, serverIds] of this.userServers) {
-      if (serverIds.has(serverId) && userId !== excludeUserId) {
+    for (const [userId, spaceIds] of this.userSpaces) {
+      if (spaceIds.has(spaceId) && userId !== excludeUserId) {
         const connections = this.getUserConnections(userId);
         for (const ws of connections) {
           if (ws.readyState === 1) {
@@ -414,12 +414,12 @@ class ConnectionManager {
     }
   }
 
-  /** Send to server members who have VIEW_CHANNEL on the given channel. */
-  sendToChannel(serverId: string, channelId: string, event: ServerEvent, excludeUserId?: string): void {
+  /** Send to space members who have VIEW_CHANNEL on the given channel. */
+  sendToChannel(spaceId: string, channelId: string, event: ServerEvent, excludeUserId?: string): void {
     const message = JSON.stringify(event);
-    for (const [userId, serverIds] of this.userServers) {
-      if (serverIds.has(serverId) && userId !== excludeUserId) {
-        const perms = computePermissions(userId, serverId, channelId);
+    for (const [userId, spaceIds] of this.userSpaces) {
+      if (spaceIds.has(spaceId) && userId !== excludeUserId) {
+        const perms = computePermissions(userId, spaceId, channelId);
         if ((perms & PermissionBits.VIEW_CHANNEL) !== 0n) {
           const connections = this.getUserConnections(userId);
           for (const ws of connections) {
@@ -432,9 +432,9 @@ class ConnectionManager {
     }
   }
 
-  /** Expose userServers iterator for pre-delete viewer collection. */
-  getUserServerEntries(): IterableIterator<[string, Set<string>]> {
-    return this.userServers.entries();
+  /** Expose userSpaces iterator for pre-delete viewer collection. */
+  getUserSpaceEntries(): IterableIterator<[string, Set<string>]> {
+    return this.userSpaces.entries();
   }
 
   /** Send to all DM channel members (queries dm_members table). */
@@ -452,14 +452,14 @@ class ConnectionManager {
     }
   }
 
-  /** Send to a room — routes to sendToServer (server rooms) or sendToDmMembers (DM rooms). */
+  /** Send to a room — routes to sendToSpace (space rooms) or sendToDmMembers (DM rooms). */
   sendToRoom(roomId: string, event: ServerEvent, excludeUserId?: string): void {
     const room = this.voiceRooms.get(roomId);
     if (!room) return;
 
-    if (room.roomType === 'server') {
-      const meta = room.metadata as ServerRoomMeta;
-      this.sendToServer(meta.serverId, event, excludeUserId);
+    if (room.roomType === 'space') {
+      const meta = room.metadata as SpaceRoomMeta;
+      this.sendToSpace(meta.spaceId, event, excludeUserId);
     } else {
       this.sendToDmMembers(roomId, event, excludeUserId);
     }
@@ -531,9 +531,9 @@ class WsRateLimiter {
 
 function buildReadyPayload(userId: string): {
   user: User;
-  servers: ServerWithChannelsAndMembers[];
+  spaces: SpaceWithChannelsAndMembers[];
   dmChannels: DmChannel[];
-  folders: ServerFolder[];
+  folders: SpaceFolder[];
   voiceStates: Record<string, string[]>;
   voiceUserStates: Record<string, { isMuted: boolean; isDeafened: boolean; isCameraOn: boolean; isScreenSharing: boolean }>;
   readStates: ReadState[];
@@ -548,31 +548,31 @@ function buildReadyPayload(userId: string): {
   }
   const user = sanitizeUser(userRow);
 
-  // Get user's server memberships
+  // Get user's space memberships
   const memberships = db.select()
-    .from(schema.serverMembers)
-    .where(eq(schema.serverMembers.userId, userId))
+    .from(schema.spaceMembers)
+    .where(eq(schema.spaceMembers.userId, userId))
     .all();
 
-  const serverIds = memberships.map(m => m.serverId);
+  const spaceIds = memberships.map(m => m.spaceId);
 
-  const servers: ServerWithChannelsAndMembers[] = [];
+  const spaces: SpaceWithChannelsAndMembers[] = [];
 
-  if (serverIds.length > 0) {
-    const serverRows = db.select()
-      .from(schema.servers)
-      .where(inArray(schema.servers.id, serverIds))
+  if (spaceIds.length > 0) {
+    const spaceRows = db.select()
+      .from(schema.spaces)
+      .where(inArray(schema.spaces.id, spaceIds))
       .all();
 
-    // Batch: all channels for all servers (1 query instead of N)
+    // Batch: all channels for all spaces (1 query instead of N)
     const allChannels = batchInArray(
-      serverIds,
-      ids => db.select().from(schema.channels).where(inArray(schema.channels.serverId, ids)).all(),
+      spaceIds,
+      ids => db.select().from(schema.channels).where(inArray(schema.channels.spaceId, ids)).all(),
     );
-    const channelsByServer = new Map<string, (typeof allChannels)>();
+    const channelsBySpace = new Map<string, (typeof allChannels)>();
     for (const ch of allChannels) {
-      let arr = channelsByServer.get(ch.serverId);
-      if (!arr) { arr = []; channelsByServer.set(ch.serverId, arr); }
+      let arr = channelsBySpace.get(ch.spaceId);
+      if (!arr) { arr = []; channelsBySpace.set(ch.spaceId, arr); }
       arr.push(ch);
     }
 
@@ -592,18 +592,18 @@ function buildReadyPayload(userId: string): {
       }
     }
 
-    for (const serverRow of serverRows) {
-      const channels = channelsByServer.get(serverRow.id) ?? [];
+    for (const spaceRow of spaceRows) {
+      const channels = channelsBySpace.get(spaceRow.id) ?? [];
 
       const roles = db.select()
         .from(schema.roles)
-        .where(eq(schema.roles.serverId, serverRow.id))
+        .where(eq(schema.roles.spaceId, spaceRow.id))
         .orderBy(schema.roles.position)
         .all();
 
       const memberRows = db.select()
-        .from(schema.serverMembers)
-        .where(eq(schema.serverMembers.serverId, serverRow.id))
+        .from(schema.spaceMembers)
+        .where(eq(schema.spaceMembers.spaceId, spaceRow.id))
         .all();
 
       const memberUserIds = memberRows.map(m => m.userId);
@@ -614,7 +614,7 @@ function buildReadyPayload(userId: string): {
 
       const memberRoleRows = db.select()
         .from(schema.memberRoles)
-        .where(eq(schema.memberRoles.serverId, serverRow.id))
+        .where(eq(schema.memberRoles.spaceId, spaceRow.id))
         .all();
 
       const members: MemberWithUser[] = memberRows
@@ -630,7 +630,7 @@ function buildReadyPayload(userId: string): {
             .filter(r => assignedRoleIds.includes(r.id))
             .map(r => ({
               id: r.id,
-              serverId: r.serverId,
+              spaceId: r.spaceId,
               name: r.name,
               color: r.color ?? '#b9bbbe',
               position: r.position ?? 0,
@@ -638,7 +638,7 @@ function buildReadyPayload(userId: string): {
             }));
 
           return {
-            serverId: m.serverId,
+            spaceId: m.spaceId,
             userId: m.userId,
             nickname: m.nickname,
             joinedAt: m.joinedAt,
@@ -648,18 +648,18 @@ function buildReadyPayload(userId: string): {
         })
         .filter((m): m is MemberWithUser => m !== null);
 
-      // Compute server-level permissions for this user
-      const serverPerms = computePermissions(userId, serverRow.id);
+      // Compute space-level permissions for this user
+      const spacePerms = computePermissions(userId, spaceRow.id);
 
       // Filter channels by VIEW_CHANNEL and attach per-channel permissions
       const visibleChannels: Channel[] = [];
       for (const ch of channels) {
-        const chPerms = computePermissions(userId, serverRow.id, ch.id);
+        const chPerms = computePermissions(userId, spaceRow.id, ch.id);
         const hasView = (chPerms & PermissionBits.VIEW_CHANNEL) !== 0n || (chPerms & PermissionBits.ADMINISTRATOR) !== 0n;
         if (hasView) {
           visibleChannels.push({
             id: ch.id,
-            serverId: ch.serverId,
+            spaceId: ch.spaceId,
             name: ch.name,
             type: ch.type as Channel['type'],
             topic: ch.topic,
@@ -671,34 +671,34 @@ function buildReadyPayload(userId: string): {
         }
       }
 
-      servers.push({
-        id: serverRow.id,
-        name: serverRow.name,
-        icon: serverRow.icon,
-        ownerId: serverRow.ownerId,
-        inviteCode: serverRow.inviteCode,
-        visibility: (serverRow.visibility ?? 'private') as ServerWithChannelsAndMembers['visibility'],
-        description: serverRow.description ?? null,
-        createdAt: serverRow.createdAt,
+      spaces.push({
+        id: spaceRow.id,
+        name: spaceRow.name,
+        icon: spaceRow.icon,
+        ownerId: spaceRow.ownerId,
+        inviteCode: spaceRow.inviteCode,
+        visibility: (spaceRow.visibility ?? 'private') as SpaceWithChannelsAndMembers['visibility'],
+        description: spaceRow.description ?? null,
+        createdAt: spaceRow.createdAt,
         channels: visibleChannels,
         members,
         roles: roles.map(r => ({
           id: r.id,
-          serverId: r.serverId,
+          spaceId: r.spaceId,
           name: r.name,
           color: r.color ?? '#b9bbbe',
           position: r.position ?? 0,
           permissions: r.permissions ?? undefined,
-          isEveryone: r.id === serverRow.id,
+          isEveryone: r.id === spaceRow.id,
           createdAt: r.createdAt,
         })),
-        myPermissions: permissionsToString(serverPerms),
+        myPermissions: permissionsToString(spacePerms),
       });
     }
   }
 
-  // Store user's server IDs for broadcasting
-  connectionManager.setUserServers(userId, serverIds);
+  // Store user's space IDs for broadcasting
+  connectionManager.setUserSpaces(userId, spaceIds);
 
   // Get DM channels
   const dmMemberships = db.select()
@@ -773,36 +773,36 @@ function buildReadyPayload(userId: string): {
     }
   }
 
-  // Get Server Folders
+  // Get Space Folders
   const folderRows = db.select()
-    .from(schema.serverFolders)
-    .where(eq(schema.serverFolders.userId, userId))
-    .orderBy(schema.serverFolders.position)
+    .from(schema.spaceFolders)
+    .where(eq(schema.spaceFolders.userId, userId))
+    .orderBy(schema.spaceFolders.position)
     .all();
 
-  const folders: any[] = [];
+  const folders: SpaceFolder[] = [];
   for (const folder of folderRows) {
-    const serverIds = db.select()
-      .from(schema.serverFolderMembers)
-      .where(eq(schema.serverFolderMembers.folderId, folder.id))
+    const folderSpaceIds = db.select()
+      .from(schema.spaceFolderMembers)
+      .where(eq(schema.spaceFolderMembers.folderId, folder.id))
       .all()
-      .map(m => m.serverId);
+      .map(m => m.spaceId);
 
     folders.push({
       id: folder.id,
       userId: folder.userId,
       name: folder.name,
       color: folder.color,
-      position: folder.position,
-      serverIds,
+      position: folder.position ?? 0,
+      spaceIds: folderSpaceIds,
     });
   }
 
   // Build voice states — tell the client who is currently in voice channels
-  // across all their servers
+  // across all their spaces
   const voiceStates: Record<string, string[]> = {};
-  for (const srv of servers) {
-    for (const ch of srv.channels) {
+  for (const space of spaces) {
+    for (const ch of space.channels) {
       if (ch.type === 'voice' || ch.type === 'video') {
         const participants = connectionManager.getRoomParticipants(ch.id);
         if (participants.size > 0) {
@@ -832,7 +832,7 @@ function buildReadyPayload(userId: string): {
     }
   }
 
-  // Build voice user states — includes both server and DM participants now
+  // Build voice user states — includes both space and DM participants now
   const voiceUserStates: Record<string, { isMuted: boolean; isDeafened: boolean; isCameraOn: boolean; isScreenSharing: boolean }> = {};
   for (const chId of Object.keys(voiceStates)) {
     const usersInChannel = voiceStates[chId];
@@ -857,7 +857,7 @@ function buildReadyPayload(userId: string): {
     lastReadMessageId: rs.lastReadMessageId,
   }));
 
-  return { user, servers, dmChannels, folders, voiceStates, voiceUserStates, readStates, activeCalls };
+  return { user, spaces, dmChannels, folders, voiceStates, voiceUserStates, readStates, activeCalls };
 }
 
 export async function registerWebSocket(app: FastifyInstance): Promise<void> {
@@ -915,10 +915,10 @@ export async function registerWebSocket(app: FastifyInstance): Promise<void> {
             ...readyData,
           }));
 
-          // Broadcast presence update to all servers
-          const userServers = connectionManager.getUserServers(userId);
-          for (const serverId of userServers) {
-            connectionManager.sendToServer(serverId, {
+          // Broadcast presence update to all spaces
+          const userSpaces = connectionManager.getUserSpaces(userId);
+          for (const spaceId of userSpaces) {
+            connectionManager.sendToSpace(spaceId, {
               type: 'presence_update',
               userId,
               status: 'online',