malice

<script lang="ts">

  import { onMount, tick } from 'svelte';

  import LoginPanel from './lib/LoginPanel.svelte';

  import MessageRow from './lib/MessageRow.svelte';

  import MxcAvatar from './lib/MxcAvatar.svelte';

  import SecurityPanel from './lib/SecurityPanel.svelte';

  import {

    closeRoom,

    createRoom,

    getEncryption,

    getMembers,

    getProfile,

    getRooms,

    getSession,

    getSpaceChildren,

    joinRoom,

    leaveRoom,

    logout,

    markRead,

    openRoom,

    paginateRoom,

    reactToMessage,

    uploadAttachment

  } from './lib/api';

  import {

    banners,

    blocked,

    connectEvents,

    connection,

    disconnectEvents,

    dismissBanner,

    encryption,

    membersByRoom,

    membersLoading,

    pushBanner,

    imagePacks,

    resetClientState,

    rooms,

    selectedRoomId,

    sessionUser,

    softLogout,

    timelines,

    verification

  } from './lib/store';

  import { discardPending, pendingByRoom, queueSend, resetPending, retryPending } from './lib/pending';

  import type { PendingMessage } from './lib/pending';

  import { loadQuickReactions, quickReactions, saveQuickReactions } from './lib/quick-reactions';

  import {

    linkPreviews,

    loadUrlPreviewSettings,

    requestLinkPreview,

    saveUrlPreviewSettings,

    urlPreviewSettings

  } from './lib/link-previews';

  import { notifyTyping, stopTyping } from './lib/typing';

  import { formatDay } from './lib/format';

  import { lineHeight, messageSpacing, navFolded } from './lib/appearance';

  import SettingsPanel from './lib/SettingsPanel.svelte';

  import { packsForRoom, parseEncryptionState, parseOwnProfile, parseVerificationState, contentPreview, senderLabel } from './lib/types';

  import type { MemberSummary, OwnProfile, Person, QuickReaction, ReplyReference, RoomSummary, SendState, TimelineEvent, TimelineItem } from './lib/types';

  let roomsLoading = false;

  let booted = false;

  let wasOnline = false;

  let search = '';

  let sidebarOpen = false;

  let membersOpen = false;

  let replyingTo: ReplyReference | null = null;

  let dialog: 'join' | 'create' | 'security' | 'settings' | null = null;

  let joinTarget = '';

  let joinBusy = false;

  let createName = '';

  let createTopic = '';

  let createBusy = false;

  let leaveBusy = false;

  let paginateBusy = false;

  let reacting = false;

  let composer = '';

  let drafts: Record<string, string> = {};

  let stickToBottom = true;

  let timelineEl: HTMLElement | null = null;

  let composerEl: HTMLTextAreaElement | null = null;

  let fileInput: HTMLInputElement | null = null;

  let uploadBusy = false;

  let uploadName: string | null = null;

  let openedRoom: string | null = null;

  let openReady: Record<string, boolean> = {};

  let openFailed: Record<string, string> = {};

  let membersFor: string | null = null;

  let lastReadKey = '';

  let readTimer: number | null = null;

  let profile: OwnProfile | null = null;

  let profileMxc: string | null = null;

  let selectedSpaceId: string | null = null;

  let spaceChildIds: string[] | null = null;

  let spaceChildrenLoading = false;

  let spaceChildrenError: string | null = null;

  let avatarByUser: Record<string, string | null> = {};

  // account data is read from the local cache, which is empty on a fresh device until the first sync lands

  $: {

    const online = $connection === 'online';

    if (online && !wasOnline) {

      void loadQuickReactions();

      void loadUrlPreviewSettings();

    }

    wasOnline = online;

  }

  $: selectedRoom = $rooms.find((r) => r.room_id === $selectedRoomId) ?? null;

  $: roomPacks = packsForRoom($imagePacks, $selectedRoomId);

  $: previewsAllowed = selectedRoom !== null && (!selectedRoom.encrypted || $urlPreviewSettings.encrypted_rooms);

  $: loadPreview = previewsAllowed && $selectedRoomId ? previewLoader($selectedRoomId) : null;

  $: spaceRooms = $rooms.filter((r) => r.space);

  $: invites = $rooms.filter((r) => r.membership === 'Invited');

  $: query = search.trim().toLowerCase();

  $: selectedSpace = selectedSpaceId ? ($rooms.find((r) => r.room_id === selectedSpaceId) ?? null) : null;

  // While a space's children load (or fail), show no channels rather than the

  // full list — listing everything would falsely imply it belongs to the space.

  $: baseRooms = selectedSpaceId ? (spaceChildIds ? $rooms.filter((r) => spaceChildIds.includes(r.room_id)) : []) : $rooms;

  $: visibleRooms = query

    ? baseRooms.filter(

        (r) =>

          r.name.toLowerCase().includes(query) || r.room_id.toLowerCase().includes(query)

      )

    : baseRooms;

  $: directRooms = visibleRooms.filter((r) => r.direct && !r.space && r.membership !== 'Invited');

  $: groupRooms = visibleRooms.filter(

    (r) => !r.direct && !r.space && r.membership !== 'Invited'

  );

  $: spaceList = visibleRooms.filter((r) => r.space && r.membership !== 'Invited');

  $: channelRooms = baseRooms.filter((r) => !r.space && r.membership !== 'Invited');

  $: recoveryBanner = $encryption && ($encryption.recovery === 'Disabled' || $encryption.recovery === 'Incomplete') ? $encryption : null;

  $: verificationBanner = $verification && $verification.kind !== 'Done' ? $verification : null;

  $: items = $selectedRoomId ? ($timelines[$selectedRoomId] ?? []) : [];

  $: members = $selectedRoomId ? ($membersByRoom[$selectedRoomId] ?? []) : [];

  $: people = peopleIn(items, members);

  $: hasStart = items.some((i) => i.kind === 'start');

  $: grouped = buildGroups(items);

  $: lastSentId = lastOwnSent(items);

  $: pendingItems = $selectedRoomId ? ($pendingByRoom[$selectedRoomId] ?? []) : [];

  $: lastRealOwn = lastSenderIsOwn(items);

  function lastSenderIsOwn(list: TimelineItem[]): boolean {

    for (let i = list.length - 1; i >= 0; i -= 1) {

      const it = list[i];

      if (it.kind === 'event') return it.event.sender.user_id === $sessionUser;

    }

    return false;

  }

  function pendingShowSender(index: number): boolean {

    return index === 0 ? !lastRealOwn : false;

  }

  function pendingToEvent(p: PendingMessage): TimelineEvent {

    const state: SendState = p.status === 'failed' ? { kind: 'Failed', will_retry: false } : { kind: 'Sending' };

    return {

      item_id: `pending-${p.id}`,

      event_id: null,

      transaction_id: p.id,

      sender: {

        user_id: $sessionUser ?? '',

        display_name: profile?.display_name ?? null,

        avatar: null,

        name_ambiguous: false

      },

      timestamp_ms: p.createdAt,

      own: true,

      send_state: state,

      content: {

        kind: 'Message',

        message: { kind: 'Text', body: p.body, geo_uri: null, formatted_body: null, edited: false, media: null }

      },

      reply_to: p.replyTo,

      thread_root: null,

      thread_summary: null,

      reactions: [],

      read_by: [],

      editable: false

    };

  }

  interface Group {

    key: string;

    item: TimelineItem;

    showSender: boolean;

  }

  function lastOwnSent(list: TimelineItem[]): string | null {

    for (let i = list.length - 1; i >= 0; i--) {

      const item = list[i];

      if (item.kind === 'event' && item.event.own && item.event.send_state.kind === 'Sent') return item.event.item_id;

    }

    return null;

  }

  function buildGroups(list: TimelineItem[]): Group[] {

    const out: Group[] = [];

    let prevSender: string | null = null;

    let prevTs = 0;

    list.forEach((item, index) => {

      let showSender = true;

      if (item.kind === 'event') {

        const e = item.event;

        showSender =

          prevSender !== e.sender.user_id || Math.abs(e.timestamp_ms - prevTs) > 5 * 60 * 1000;

        prevSender = e.sender.user_id;

        prevTs = e.timestamp_ms;

        out.push({ key: e.item_id || e.event_id || `m-${index}`, item, showSender });

      } else {

        prevSender = null;

        out.push({ key: `${item.kind}-${index}`, item, showSender });

      }

    });

    return out;

  }

  function roomUnread(r: RoomSummary): number {

    return r.unread_messages + r.unread_mentions;

  }

  onMount(() => {

    void boot();

    return () => {

      disconnectEvents();

      stopTyping();

      if (readTimer !== null) window.clearTimeout(readTimer);

    };

  });

  async function boot(): Promise<void> {

    try {

      const session = await getSession();

      blocked.set(session.blocked ?? false);

      sessionUser.set(session.user_id);

      if (session.user_id) {

        softLogout.set(null);

        await refreshRooms();

        connectEvents();

        void loadProfile();

        void loadEncryption();

        void loadQuickReactions();

        void loadUrlPreviewSettings();

      } else {

        softLogout.set(session.soft_logout ?? null);

      }

    } catch (e) {

      pushBanner(e instanceof Error ? `Session check failed: ${e.message}` : 'Session check failed');

      sessionUser.set(null);

    } finally {

      booted = true;

    }

  }

  async function refreshRooms(): Promise<void> {

    roomsLoading = true;

    try {

      const res = await getRooms();

      rooms.set(res.rooms);

      pruneSpaceFilter();

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not load rooms');

    } finally {

      roomsLoading = false;

    }

  }

  async function loadProfile(): Promise<void> {

    try {

      const raw = await getProfile();

      profile = parseOwnProfile(raw);

      profileMxc = profile.avatar_url;

    } catch {

      profile = null;

    }

  }

  async function loadEncryption(): Promise<void> {

    try {

      const res = await getEncryption();

      const state = parseEncryptionState(res.state);

      if (state) encryption.set(state);

      const verificationState = parseVerificationState(res.verification);

      if (verificationState) verification.set(verificationState);

    } catch {

      // Encryption status also arrives over SSE; a failed first fetch is not fatal.

    }

  }

  function afterLogin(userId: string): void {

    sessionUser.set(userId);

    softLogout.set(null);

    blocked.set(false);

    void refreshRooms();

    connectEvents();

    void loadProfile();

    void loadEncryption();

    void loadQuickReactions();

    void loadUrlPreviewSettings();

  }

  async function doLogout(): Promise<void> {

    stopTyping();

    try {

      await logout();

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Logout failed');

      return;

    }

    disconnectEvents();

    resetClientState();

    softLogout.set(null);

    blocked.set(false);

    sessionUser.set(null);

    composer = '';

    drafts = {};

    dialog = null;

    membersOpen = false;

    sidebarOpen = false;

    profile = null;

    profileMxc = null;

    selectedSpaceId = null;

    spaceChildIds = null;

    spaceChildrenError = null;

    openReady = {};

    openFailed = {};

    avatarByUser = {};

    resetPending();

  }

  function pruneSpaceFilter(): void {

    if (!selectedSpaceId) return;

    if (!$rooms.some((r) => r.room_id === selectedSpaceId)) {

      selectedSpaceId = null;

      spaceChildIds = null;

      spaceChildrenError = null;

    }

  }

  async function selectHome(): Promise<void> {

    selectedSpaceId = null;

    spaceChildIds = null;

    spaceChildrenError = null;

    sidebarOpen = true;

  }

  async function selectSpace(spaceId: string): Promise<void> {

    if ($selectedRoomId && composer.trim()) drafts[$selectedRoomId] = composer;

    stopTyping();

    const prev = openedRoom;

    if (prev) {

      openedRoom = null;

      closeRoom(prev).catch(() => undefined);

    }

    selectedSpaceId = spaceId;

    spaceChildIds = null;

    spaceChildrenError = null;

    spaceChildrenLoading = true;

    sidebarOpen = true;

    // A space is navigation, not a message timeline.

    selectedRoomId.set(null);

    try {

      const res = await getSpaceChildren(spaceId);

      if (selectedSpaceId === spaceId) spaceChildIds = res.room_ids ?? [];

    } catch (e) {

      if (selectedSpaceId === spaceId) {

        spaceChildrenError = e instanceof Error ? e.message : 'Could not load rooms in this space';

        spaceChildIds = [];

      }

    } finally {

      if (selectedSpaceId === spaceId) spaceChildrenLoading = false;

    }

  }

  async function selectRoom(roomId: string): Promise<void> {

    if ($selectedRoomId && composer.trim()) drafts[$selectedRoomId] = composer;

    if (roomId === $selectedRoomId && openReady[roomId]) {

      sidebarOpen = false;

      return;

    }

    stopTyping();

    const prev = openedRoom;

    openedRoom = roomId;

    selectedRoomId.set(roomId);

    composer = drafts[roomId] ?? '';

    replyingTo = null;

    stickToBottom = true;

    lastReadKey = '';

    sidebarOpen = false;

    openReady = { ...openReady, [roomId]: false };

    if (openFailed[roomId]) {

      const nextFailed = { ...openFailed };

      delete nextFailed[roomId];

      openFailed = nextFailed;

    }

    try {

      await openRoom(roomId);

      openReady = { ...openReady, [roomId]: true };

    } catch (e) {

      const message = e instanceof Error ? e.message : `Could not open room ${roomId}`;

      openFailed = { ...openFailed, [roomId]: message };

      pushBanner(message);

    }

    if (membersOpen) void loadMembers(roomId);

    await tick();

    scrollToBottom();

    queueReadReceipt();

    composerEl?.focus();

  }

  function scrollToBottom(): void {

    if (timelineEl) timelineEl.scrollTop = timelineEl.scrollHeight;

  }

  function onTimelineScroll(): void {

    if (!timelineEl) return;

    const gap = timelineEl.scrollHeight - timelineEl.scrollTop - timelineEl.clientHeight;

    stickToBottom = gap < 80;

  }

  $: void trackTimeline($selectedRoomId, items);

  async function trackTimeline(roomId: string | null, list: TimelineItem[]): Promise<void> {

    if (!roomId || list.length === 0) return;

    if (roomId !== $selectedRoomId) return;

    await tick();

    if (stickToBottom) scrollToBottom();

    queueReadReceipt();

  }

  function queueReadReceipt(): void {

    if (readTimer !== null) window.clearTimeout(readTimer);

    readTimer = window.setTimeout(() => {

      readTimer = null;

      void sendReadReceipt();

    }, 800);

  }

  async function sendReadReceipt(): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId) return;

    const list = $timelines[roomId] ?? [];

    for (let i = list.length - 1; i >= 0; i -= 1) {

      const entry = list[i];

      if (entry.kind === 'event' && entry.event.event_id) {

        const key = `${roomId}:${entry.event.event_id}`;

        if (key === lastReadKey) return;

        lastReadKey = key;

        try {

          await markRead(roomId, entry.event.event_id);

        } catch {

          return;

        }

        return;

      }

    }

  }

  function send(): void {

    const roomId = $selectedRoomId;

    const body = composer.trim();

    if (!roomId || !body) return;

    if (!openReady[roomId]) {

      pushBanner('Still opening this room — sending is disabled until the room is ready.');

      return;

    }

    composer = '';

    if (roomId in drafts) delete drafts[roomId];

    stickToBottom = true;

    queueSend(roomId, body, replyingTo);

    replyingTo = null;

    composerEl?.focus();

  }

  function startReply(target: ReplyReference): void {

    replyingTo = target;

    composerEl?.focus();

  }

  function jumpTo(eventId: string): void {

    const el = timelineEl?.querySelector<HTMLElement>(`[data-event="${CSS.escape(eventId)}"]`);

    if (!el) {

      pushBanner('The original message is not loaded. Scroll up to load older messages.');

      return;

    }

    stickToBottom = false;

    el.scrollIntoView({ block: 'center', behavior: 'smooth' });

    el.classList.remove('flash');

    void el.offsetWidth;

    el.classList.add('flash');

  }

  let typedText = '';

  let typedRoom: string | null = null;

  $: trackTypingInput(composer, $selectedRoomId, openReady);

  function trackTypingInput(text: string, roomId: string | null, ready: Record<string, boolean>): void {

    const edited = roomId === typedRoom && text !== typedText;

    typedText = text;

    typedRoom = roomId;

    if (!roomId || !ready[roomId] || !text.trim()) {

      stopTyping();

    } else if (edited) {

      notifyTyping(roomId);

    }

  }

  $: void trackPending($selectedRoomId, pendingItems);

  async function trackPending(roomId: string | null, list: PendingMessage[]): Promise<void> {

    if (!roomId || list.length === 0) return;

    if (roomId !== $selectedRoomId) return;

    await tick();

    if (stickToBottom) scrollToBottom();

  }

  function onComposerKey(ev: KeyboardEvent): void {

    if (ev.key === 'Enter' && !ev.shiftKey) {

      ev.preventDefault();

      send();

    } else if (ev.key === 'Escape' && replyingTo) {

      ev.stopPropagation();

      replyingTo = null;

    }

  }

  async function upload(): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId || uploadBusy || !openReady[roomId]) return;

    fileInput?.click();

  }

  async function onFileChosen(): Promise<void> {

    const file = fileInput?.files?.[0];

    if (file) await uploadFile(file);

    if (fileInput) fileInput.value = '';

  }

  function onComposerPaste(ev: ClipboardEvent): void {

    const data = ev.clipboardData;

    // Office apps put a rendered image next to the copied text, so only take the image when there is no plain text.

    if (!data || data.types.includes('text/plain')) return;

    const image = Array.from(data.files).find((f) => f.type.startsWith('image/'));

    if (!image) return;

    ev.preventDefault();

    void uploadFile(image);

  }

  async function uploadFile(file: File): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId || uploadBusy || !openReady[roomId]) return;

    if (file.size === 0 || file.size > 20 * 1024 * 1024) {

      pushBanner('File must be between 1 byte and 20 MiB.');

      return;

    }

    uploadBusy = true;

    uploadName = file.name || 'attachment';

    try {

      await uploadAttachment(roomId, file);

      stickToBottom = true;

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Upload failed');

    } finally {

      uploadBusy = false;

      uploadName = null;

    }

  }

  async function react(eventId: string, key: string, shortcode?: string): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId || !eventId || reacting) return;

    reacting = true;

    try {

      await reactToMessage(roomId, eventId, key, shortcode);

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Reaction failed');

    } finally {

      reacting = false;

    }

  }

  function previewLoader(roomId: string): (url: string) => void {

    return (url) => requestLinkPreview(roomId, url);

  }

  async function changeEncryptedPreviews(enabled: boolean): Promise<void> {

    try {

      await saveUrlPreviewSettings({ encrypted_rooms: enabled });

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not save link preview setting');

    }

  }

  async function changeQuickReactions(list: QuickReaction[]): Promise<void> {

    try {

      await saveQuickReactions(list);

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not save quick reactions');

    }

  }

  async function paginate(): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId || paginateBusy) return;

    paginateBusy = true;

    try {

      await paginateRoom(roomId);

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Loading older messages failed');

    } finally {

      paginateBusy = false;

    }

  }

  async function loadMembers(roomId: string): Promise<void> {

    if (membersFor === roomId && $membersLoading) return;

    membersFor = roomId;

    membersLoading.set(true);

    try {

      const res = await getMembers(roomId);

      membersByRoom.update((all) => ({ ...all, [roomId]: res.members }));

      avatarByUser = { ...avatarByUser, ...avatarMap(res.members) };

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not load members');

    } finally {

      if (membersFor === roomId) membersLoading.set(false);

    }

  }

  function avatarMap(list: MemberSummary[]): Record<string, string | null> {

    const next: Record<string, string | null> = {};

    for (const member of list) next[member.user_id] = member.avatar;

    return next;

  }

  function peopleIn(list: TimelineItem[], roster: MemberSummary[]): Record<string, Person> {

    const out: Record<string, Person> = {};

    for (const item of list) {

      if (item.kind !== 'event') continue;

      const s = item.event.sender;

      out[s.user_id] = { user_id: s.user_id, name: senderLabel(s), avatar: s.avatar };

    }

    for (const m of roster) out[m.user_id] = { user_id: m.user_id, name: m.name, avatar: m.avatar };

    return out;

  }

  function senderAvatarFor(userId: string): string | null {

    return avatarByUser[userId] ?? null;

  }

  function toggleMembers(): void {

    membersOpen = !membersOpen;

    if (membersOpen && $selectedRoomId) void loadMembers($selectedRoomId);

  }

  async function join(target: string): Promise<void> {

    const room = target.trim();

    if (!room || joinBusy) return;

    joinBusy = true;

    try {

      const res = await joinRoom(room);

      joinTarget = '';

      dialog = null;

      await refreshRooms();

      await selectRoom(res.room_id);

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Join failed');

    } finally {

      joinBusy = false;

    }

  }

  async function create(): Promise<void> {

    const name = createName.trim();

    if (!name || createBusy) return;

    createBusy = true;

    try {

      const res = await createRoom(name, createTopic.trim() || undefined);

      createName = '';

      createTopic = '';

      dialog = null;

      await refreshRooms();

      await selectRoom(res.room_id);

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Create room failed');

    } finally {

      createBusy = false;

    }

  }

  async function leave(): Promise<void> {

    const roomId = $selectedRoomId;

    if (!roomId || leaveBusy) return;

    leaveBusy = true;

    stopTyping();

    try {

      await leaveRoom(roomId);

      const prev = openedRoom;

      if (prev === roomId) openedRoom = null;

      if ($selectedRoomId === roomId) selectedRoomId.set(null);

      if (prev) closeRoom(prev).catch(() => undefined);

      await refreshRooms();

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Leave failed');

    } finally {

      leaveBusy = false;

    }

  }

  function connectionClass(state: string): string {

    if (state === 'online') return 'dot-online';

    if (state === 'connecting' || state === 'reconnecting') return 'dot-busy';

    return 'dot-off';

  }

  function onKeydown(ev: KeyboardEvent): void {

    if (ev.key === 'Escape') {

      if (dialog) dialog = null;

      else if (membersOpen && window.innerWidth < 1100) membersOpen = false;

      else if (sidebarOpen) sidebarOpen = false;

    }

  }

</script>

<svelte:window on:keydown={onKeydown} />

{#if !booted}

  <div class="splash" role="status" aria-label="Loading Malice">

    <div class="splash-mark" aria-hidden="true">M</div>

    <p>Loading Malice…</p>

  </div>

{:else if $blocked}

  <div class="splash" role="status" aria-label="Malice is open in another tab">

    <div class="splash-mark" aria-hidden="true">M</div>

    <p>Malice is open in another tab. Close this tab or use that one instead.</p>

  </div>

{:else if $sessionUser == null}

  <LoginPanel softLogout={$softLogout} on:done={(ev) => afterLogin(ev.detail)} />

{:else}

  <div class="app" class:nav-folded={$navFolded && selectedRoom} style:--msg-gap={`${$messageSpacing}px`} style:--msg-line-height={$lineHeight}>

    <nav class="rail" aria-label="Servers and spaces">

      <button

        type="button"

        class="rail-btn"

        class:active={selectedSpaceId === null}

        title="Home — all channels"

        aria-label="Home — all channels"

        aria-pressed={selectedSpaceId === null}

        on:click={() => void selectHome()}

      >

        <span aria-hidden="true">⌂</span>

      </button>

      <div class="rail-sep" aria-hidden="true"></div>

      {#each spaceRooms as space (space.room_id)}

        <button

          type="button"

          class="rail-btn rail-space"

          class:active={selectedSpaceId === space.room_id}

          title={space.name}

          aria-label={`Show channels in space ${space.name}`}

          aria-pressed={selectedSpaceId === space.room_id}

          on:click={() => void selectSpace(space.room_id)}

        >

          <MxcAvatar mxc={space.avatar} label={space.name} size={44} shape="rounded" />

        </button>

      {/each}

      <button

        type="button"

        class="rail-btn rail-add"

        aria-label="Join or create a room"

        on:click={() => {

          dialog = 'join';

        }}

      >

        <span aria-hidden="true">＋</span>

      </button>

    </nav>

    <aside class="sidebar" class:open={sidebarOpen} aria-label="Rooms">

      <div class="side-search">

        <label class="visually-hidden" for="room-search">Search rooms</label>

        <input

          id="room-search"

          type="search"

          placeholder="Search rooms"

          bind:value={search}

          autocomplete="off"

        />

        <button

          type="button"

          class="icon-btn"

          title="Refresh rooms"

          aria-label="Refresh rooms"

          disabled={roomsLoading}

          on:click={() => void refreshRooms()}

        >

          <span aria-hidden="true">⟳</span>

        </button>

      </div>

      <div class="side-scroll">

        {#if selectedSpace}

          <div class="space-context">

            <MxcAvatar mxc={selectedSpace.avatar} label={selectedSpace.name} size={28} shape="rounded" />

            <div class="space-context-text">

              <strong>{selectedSpace.name}</strong>

              <span>Space — channels below</span>

            </div>

          </div>

        {:else}

          <div class="space-context">

            <div class="space-context-text">

              <strong>Home</strong>

              <span>All channels</span>

            </div>

          </div>

        {/if}

        {#if roomsLoading && $rooms.length === 0}

          <p class="side-note">Loading rooms…</p>

        {:else if $rooms.length === 0}

          <p class="side-note">No rooms yet. Join one or create your own.</p>

          <div class="side-cta">

            <button type="button" on:click={() => (dialog = 'join')}>Join a room</button>

            <button type="button" on:click={() => (dialog = 'create')}>Create one</button>

          </div>

        {:else}

          {#if selectedSpaceId && spaceChildrenLoading}

            <p class="side-note">Loading channels in this space…</p>

          {:else if selectedSpaceId && spaceChildrenError}

            <p class="side-note" role="alert">{spaceChildrenError}</p>

            <div class="side-cta">

              <button type="button" on:click={() => selectedSpaceId && void selectSpace(selectedSpaceId)}>Retry</button>

              <button type="button" on:click={() => void selectHome()}>Back to Home</button>

            </div>

          {:else if selectedSpaceId && spaceChildIds && channelRooms.length === 0}

            <p class="side-note">No channels found in this space yet.</p>

            <div class="side-cta">

              <button type="button" on:click={() => void selectHome()}>Back to Home</button>

            </div>

          {:else}

            {#if invites.length > 0 && !selectedSpaceId}

              <h2 class="side-h">Invites</h2>

              <ul class="room-list">

                {#each invites as room (room.room_id)}

                  <li>

                    <button

                      type="button"

                      class="room-row"

                      class:active={$selectedRoomId === room.room_id}

                      on:click={() => void selectRoom(room.room_id)}

                    >

                      <MxcAvatar mxc={room.avatar} label={room.name} size={26} shape="rounded" />

                      <span class="room-name">{room.name}</span>

                      <span

                        class="invite-join"

                        role="button"

                        tabindex="0"

                        aria-label={`Join ${room.name}`}

                        on:click|stopPropagation={() => void join(room.room_id)}

                        on:keydown|stopPropagation={(ev) => {

                          if (ev.key === 'Enter' || ev.key === ' ') {

                            ev.preventDefault();

                            void join(room.room_id);

                          }

                        }}

                      >

                        Join

                      </span>

                    </button>

                  </li>

                {/each}

              </ul>

            {/if}

            {#if directRooms.length > 0}

              <h2 class="side-h">Direct messages</h2>

              <ul class="room-list">

                {#each directRooms as room (room.room_id)}

                  <li>

                    <button

                      type="button"

                      class="room-row"

                      class:active={$selectedRoomId === room.room_id}

                      aria-current={$selectedRoomId === room.room_id ? 'true' : undefined}

                      on:click={() => void selectRoom(room.room_id)}

                    >

                      <MxcAvatar mxc={room.avatar} label={room.name} size={26} />

                      <span class="room-name">{room.name}</span>

                      {#if roomUnread(room) > 0}

                        <span

                          class="badge"

                          class:mention={room.unread_mentions > 0}

                          aria-label={`${roomUnread(room)} unread`}

                        >

                          {roomUnread(room) > 99 ? '99+' : roomUnread(room)}

                        </span>

                      {/if}

                    </button>

                  </li>

                {/each}

              </ul>

            {/if}

            {#if groupRooms.length > 0}

              <h2 class="side-h">{selectedSpace ? 'Channels in this space' : 'Rooms'}</h2>

              <ul class="room-list">

                {#each groupRooms as room (room.room_id)}

                  <li>

                    <button

                      type="button"

                      class="room-row"

                      class:active={$selectedRoomId === room.room_id}

                      aria-current={$selectedRoomId === room.room_id ? 'true' : undefined}

                      on:click={() => void selectRoom(room.room_id)}

                    >

                      <MxcAvatar mxc={room.avatar} label={room.name} size={26} shape="rounded" />

                      <span class="room-hash" aria-hidden="true">#</span>

                      <span class="room-name">{room.name}</span>

                      {#if roomUnread(room) > 0}

                        <span

                          class="badge"

                          class:mention={room.unread_mentions > 0}

                          aria-label={`${roomUnread(room)} unread`}

                        >

                          {roomUnread(room) > 99 ? '99+' : roomUnread(room)}

                        </span>

                      {/if}

                    </button>

                  </li>

                {/each}

              </ul>

            {/if}

            {#if !selectedSpaceId && spaceList.length > 0}

              <h2 class="side-h">Spaces</h2>

              <ul class="room-list">

                {#each spaceList as room (room.room_id)}

                  <li>

                    <button

                      type="button"

                      class="room-row"

                      class:active={selectedSpaceId === room.room_id}

                      aria-label={`Show channels in space ${room.name}`}

                      on:click={() => void selectSpace(room.room_id)}

                    >

                      <MxcAvatar mxc={room.avatar} label={room.name} size={26} shape="rounded" />

                      <span class="room-hash" aria-hidden="true">◇</span>

                      <span class="room-name">{room.name}</span>

                    </button>

                  </li>

                {/each}

              </ul>

            {/if}

            {#if query && visibleRooms.length === 0}

              <p class="side-note">No rooms match “{search.trim()}”.</p>

            {/if}

          {/if}

        {/if}

      </div>

      <div class="side-footer">

        <div class="me" title={$sessionUser}>

          {#if profileMxc}

            <MxcAvatar mxc={profileMxc} label={profile?.display_name ?? $sessionUser} size={30} />

          {:else}

            <span class="me-avatar" aria-hidden="true">{$sessionUser.slice(1, 2).toUpperCase()}</span>

          {/if}

          <span class="me-id">{profile?.display_name && profile.display_name !== $sessionUser ? `${profile.display_name} (${$sessionUser})` : $sessionUser}</span>

        </div>

        <button

          type="button"

          class="icon-btn"

          title="Encryption and verification"

          aria-label="Encryption and verification"

          on:click={() => (dialog = 'security')}

        >

          <span aria-hidden="true">🛡</span>

        </button>

        <button

          type="button"

          class="icon-btn"

          title="Settings"

          aria-label="Settings"

          on:click={() => (dialog = 'settings')}

        >

          <span aria-hidden="true">⚙</span>

        </button>

        <button type="button" class="icon-btn" title="Log out" aria-label="Log out" on:click={() => void doLogout()}>

          <span aria-hidden="true">⏻</span>

        </button>

      </div>

    </aside>

    {#if sidebarOpen}

      <button type="button" class="scrim" aria-label="Close room list" on:click={() => (sidebarOpen = false)}></button>

    {/if}

    <main class="chat">

        {#if $banners.length > 0}

          <div class="banners" aria-live="polite">

            {#each $banners as banner (banner.id)}

              <div class="banner" role="alert">

                <span>{banner.message}</span>

                <button

                  type="button"

                  aria-label="Dismiss error"

                  on:click={() => dismissBanner(banner.id)}

                >

                  ✕

                </button>

              </div>

            {/each}

          </div>

        {/if}

      {#if !selectedRoom}

        <div class="empty">

          <div class="empty-mark" aria-hidden="true">◈</div>

          {#if selectedSpace}

            <h1>{selectedSpace.name}</h1>

            <p>Select a channel below to start chatting. Spaces group channels — they are not chat rooms.</p>

          {:else}

            <h1>Welcome to Malice</h1>

            <p>Pick a room from the sidebar, or join one to get started.</p>

          {/if}

          <div class="empty-cta">

            <button type="button" class="primary-btn" on:click={() => (dialog = 'join')}>Join a room</button>

            <button type="button" class="ghost-btn" on:click={() => (dialog = 'create')}>Create a room</button>

          </div>

          <p class="conn-line">

            <span class="dot {connectionClass($connection)}" aria-hidden="true"></span>

            {$connection}

          </p>

        </div>

      {:else}

        <header class="chat-head">

          <button

            type="button"

            class="icon-btn only-mobile"

            aria-label="Open room list"

            on:click={() => (sidebarOpen = true)}

          >

            <span aria-hidden="true">☰</span>

          </button>

          <button

            type="button"

            class="icon-btn only-desktop"

            aria-pressed={!$navFolded}

            aria-label={$navFolded ? 'Show spaces and rooms' : 'Hide spaces and rooms'}

            title={$navFolded ? 'Show spaces and rooms' : 'Hide spaces and rooms'}

            on:click={() => navFolded.update((v) => !v)}

          >

            <span aria-hidden="true">{$navFolded ? '»' : '«'}</span>

          </button>

          <div class="head-title">

            <div class="head-room">

              <MxcAvatar mxc={selectedRoom.avatar} label={selectedRoom.name} size={36} shape={selectedRoom.space ? 'rounded' : 'circle'} />

              <div class="head-room-text">

                <h1>{selectedRoom.name}</h1>

                <div class="head-meta">

                  {#if selectedRoom.space}

                    <span class="pill">space</span>

                  {/if}

                  {#if selectedRoom.encrypted}

                    <span class="pill" title="End-to-end encrypted">🔒 encrypted</span>

                  {/if}

                  {#if selectedRoom.direct}

                    <span class="pill">direct</span>

                  {/if}

                  <span class="conn" title={`Sync state: ${$connection}`}>

                    <span class="dot {connectionClass($connection)}" aria-hidden="true"></span>

                    {$connection}

                  </span>

                </div>

              </div>

            </div>

          </div>

          <div class="head-actions">

            <button

              type="button"

              class="ghost-btn"

              aria-label="Encryption and verification"

              title="Encryption and verification"

              on:click={() => (dialog = 'security')}

            >

              🛡 Security

            </button>

            <button

              type="button"

              class="ghost-btn"

              aria-pressed={membersOpen}

              aria-label={membersOpen ? 'Hide members' : 'Show members'}

              on:click={toggleMembers}

            >

              Members

            </button>

            {#if selectedRoom.membership === 'Joined'}

              <button

                type="button"

                class="ghost-btn danger"

                disabled={leaveBusy}

                on:click={() => void leave()}

              >

                {leaveBusy ? 'Leaving…' : 'Leave'}

              </button>

            {:else}

              <button

                type="button"

                class="primary-btn"

                disabled={joinBusy}

                on:click={() => void join(selectedRoom.room_id)}

              >

                {joinBusy ? 'Joining…' : 'Join'}

              </button>

            {/if}

            <button

              type="button"

              class="icon-btn only-mobile"

              aria-label="Toggle members"

              on:click={toggleMembers}

            >

              <span aria-hidden="true">ⓘ</span>

            </button>

          </div>

        </header>

        {#if recoveryBanner}

          <div class="sec-banner warn" role="status">

            <span>Message history is locked — recovery is {recoveryBanner.recovery}. Enter your recovery key to decrypt.</span>

            <button type="button" on:click={() => (dialog = 'security')}>Recover</button>

          </div>

        {/if}

        {#if verificationBanner}

          <div class="sec-banner" role="status">

            {#if verificationBanner.kind === 'Incoming'}

              <span>A device wants to verify this session. Review the request to accept it.</span>

              <button type="button" on:click={() => (dialog = 'security')}>Review request</button>

            {:else if verificationBanner.kind === 'Comparison'}

              <span>Verification codes are ready — compare emojis and numbers.</span>

              <button type="button" on:click={() => (dialog = 'security')}>Compare codes</button>

            {:else if verificationBanner.kind === 'Waiting'}

              <span>Verification started — approve on your other device, then compare codes here.</span>

              <button type="button" on:click={() => (dialog = 'security')}>Open verification</button>

            {:else if verificationBanner.kind === 'Failed'}

              <span>Verification failed: {verificationBanner.message}</span>

              <button type="button" on:click={() => (dialog = 'security')}>Try again</button>

            {:else if verificationBanner.kind === 'Cancelled'}

              <span>Verification cancelled: {verificationBanner.reason}</span>

              <button type="button" on:click={() => (dialog = 'security')}>Open security</button>

            {:else}

              <span>Verification in progress.</span>

              <button type="button" on:click={() => (dialog = 'security')}>Open security</button>

            {/if}

          </div>

        {/if}

        {#if $connection !== 'online'}

          <p class="conn-banner" role="status">

            Sync is {$connection}. New messages will appear when the connection recovers.

          </p>

        {/if}

        {#if $selectedRoomId && !openReady[$selectedRoomId] && !openFailed[$selectedRoomId]}

          <p class="conn-banner" role="status">Opening {selectedRoom.name}… sending is disabled until the room is ready.</p>

        {/if}

        {#if $selectedRoomId && openFailed[$selectedRoomId]}

          <p class="conn-banner error" role="alert">{openFailed[$selectedRoomId]}</p>

        {/if}

        <div class="timeline" bind:this={timelineEl} on:scroll={onTimelineScroll} aria-label={`Messages in ${selectedRoom.name}`}>

          <div class="timeline-top">

            {#if hasStart}

              <p class="start-note">This is the beginning of the visible history.</p>

            {:else}

              <button type="button" class="ghost-btn" disabled={paginateBusy} on:click={() => void paginate()}>

                {paginateBusy ? 'Loading…' : 'Load older messages'}

              </button>

            {/if}

          </div>

          {#if grouped.length === 0}

            <p class="side-note timeline-empty">No messages yet. Say hello!</p>

          {:else}

            {#each grouped as g (g.key)}

              {#if g.item.kind === 'day'}

                <div class="day-row"><span>{formatDay(g.item.timestamp_ms)}</span></div>

              {:else if g.item.kind === 'readMarker'}

                <div class="new-row"><span>New</span></div>

              {:else if g.item.kind === 'start'}

                <p class="start-note">This is the beginning of the visible history.</p>

              {:else if g.item.kind === 'unknown'}

                <p class="unknown-note">Unsupported event ({g.item.label})</p>

              {:else}

                <MessageRow

                  itemId={g.key}

                  event={g.item.event}

                  showSender={g.showSender}

                  senderAvatar={senderAvatarFor(g.item.event.sender.user_id)}

                  {reacting}

                  onReact={(eventId, key, shortcode) => void react(eventId, key, shortcode)}

                  quickReactions={$quickReactions}

                  packs={roomPacks}

                  linkPreviews={$linkPreviews}

                  {loadPreview}

                  onQuickChange={(list) => void changeQuickReactions(list)}

                  {people}

                  onReply={selectedRoom.membership === 'Joined' ? startReply : null}

                  onJump={jumpTo}

                  showSent={g.item.event.item_id === lastSentId && pendingItems.length === 0}

                />

              {/if}

            {/each}

          {/if}

          {#each pendingItems as p, i (p.id)}

            <MessageRow

              itemId={`pending-${p.id}`}

              event={pendingToEvent(p)}

              onJump={jumpTo}

              showSender={pendingShowSender(i)}

              senderAvatar={senderAvatarFor($sessionUser ?? '')}

              {reacting}

              onReact={(eventId, key, shortcode) => void react(eventId, key, shortcode)}

              quickReactions={$quickReactions}

              packs={roomPacks}

              linkPreviews={$linkPreviews}

              {loadPreview}

              onQuickChange={(list) => void changeQuickReactions(list)}

            />

            {#if p.status === 'failed'}

              <div class="pending-actions">

                <span class="pending-error" role="alert">{p.error}</span>

                <button type="button" class="ghost-btn" on:click={() => retryPending(p.id)}>Retry</button>

                <button type="button" class="ghost-btn danger" on:click={() => discardPending(p.id)}>Discard</button>

              </div>

            {/if}

          {/each}

        </div>

        {#if selectedRoom.membership === 'Joined'}

          {#if replyingTo && replyingTo.details.kind === 'Ready'}

            <div class="reply-bar" role="status">

              <span class="reply-bar-label">

                Replying to <strong>{senderLabel(replyingTo.details.sender)}</strong>

                <span class="reply-bar-text">{contentPreview(replyingTo.details.content)}</span>

              </span>

              <button type="button" class="icon-btn" aria-label="Cancel reply" title="Cancel reply (Esc)" on:click={() => (replyingTo = null)}>

                <span aria-hidden="true">✕</span>

              </button>

            </div>

          {/if}

          <form class="composer" class:replying={replyingTo} on:submit|preventDefault={() => send()}>

            <label class="visually-hidden" for="composer">Message {selectedRoom.name}</label>

            <input

              type="file"

              bind:this={fileInput}

              class="visually-hidden"

              aria-label="Attach a file"

              on:change={() => void onFileChosen()}

            />

            <button

              type="button"

              class="ghost-btn"

              title="Attach an image or file"

              aria-label="Attach an image or file"

              disabled={!($selectedRoomId && openReady[$selectedRoomId]) || uploadBusy}

              on:click={() => void upload()}

            >

              {uploadBusy ? `Uploading ${uploadName ?? 'file'}…` : '📎'}

            </button>

            <textarea

              id="composer"

              bind:this={composerEl}

              bind:value={composer}

              rows="1"

              placeholder={`Message ${selectedRoom.name}`}

              aria-label={`Message ${selectedRoom.name}. Enter to send, Shift Enter for a new line.`}

              on:keydown={onComposerKey}

              on:paste={onComposerPaste}

              disabled={!($selectedRoomId && openReady[$selectedRoomId])}

            ></textarea>

            <button

              type="submit"

              class="primary-btn"

              disabled={!composer.trim() || !($selectedRoomId && openReady[$selectedRoomId])}

              title={!($selectedRoomId && openReady[$selectedRoomId]) ? 'Waiting for the room to open' : 'Send message'}

            >

              Send

            </button>

          </form>

          <p class="composer-note">Sending and failed states show under your message.</p>

        {:else}

          <div class="join-bar">

            <p>You are not a member of this room.</p>

            <button type="button" class="primary-btn" disabled={joinBusy} on:click={() => void join(selectedRoom.room_id)}>

              {joinBusy ? 'Joining…' : `Join ${selectedRoom.name}`}

            </button>

          </div>

        {/if}

      {/if}

    </main>

    {#if selectedRoom && membersOpen}

      <aside class="members" aria-label={`Members of ${selectedRoom.name}`}>

        <div class="members-head">

          <h2>Members</h2>

          <button type="button" class="icon-btn" aria-label="Close members" on:click={() => (membersOpen = false)}>

            <span aria-hidden="true">✕</span>

          </button>

        </div>

        {#if $membersLoading && members.length === 0}

          <p class="side-note">Loading members…</p>

        {:else if members.length === 0}

          <p class="side-note">No members loaded.</p>

          {#if $selectedRoomId}

            <button type="button" class="ghost-btn" on:click={() => $selectedRoomId && void loadMembers($selectedRoomId)}>

              Retry

            </button>

          {/if}

        {:else}

          <ul class="member-list">

            {#each members as member (member.user_id)}

              <li class="member">

                <MxcAvatar mxc={member.avatar} label={member.display_name || member.name || member.user_id} size={30} />

                <span class="member-names">

                  <span class="member-name">{member.display_name || member.name}</span>

                  <span class="member-id">{member.user_id}</span>

                </span>

              </li>

            {/each}

          </ul>

        {/if}

      </aside>

    {/if}

    {#if dialog}

      <div class="modal-wrap" role="presentation" on:click|self={() => (dialog = null)}>

        {#if dialog === 'security'}

          <SecurityPanel

            encryptionState={$encryption}

            verificationState={$verification}

            onAction={() => void loadEncryption()}

            encryptedPreviews={$urlPreviewSettings.encrypted_rooms}

            onEncryptedPreviews={(enabled) => void changeEncryptedPreviews(enabled)}

            on:close={() => (dialog = null)}

          />

        {:else if dialog === 'settings'}

          <SettingsPanel

            quick={$quickReactions}

            packs={roomPacks}

            onQuickChange={(list) => void changeQuickReactions(list)}

            on:close={() => (dialog = null)}

          />

        {:else}

          <div class="modal" role="dialog" aria-modal="true" aria-label={dialog === 'join' ? 'Join a room' : 'Create a room'}>

            <div class="modal-tabs" role="tablist" aria-label="Room actions">

              <button

                type="button"

                role="tab"

                aria-selected={dialog === 'join'}

                class:active={dialog === 'join'}

                on:click={() => (dialog = 'join')}

              >

                Join

              </button>

              <button

                type="button"

                role="tab"

                aria-selected={dialog === 'create'}

                class:active={dialog === 'create'}

                on:click={() => (dialog = 'create')}

              >

                Create

              </button>

              <button

                type="button"

                class="icon-btn modal-x"

                aria-label="Close dialog"

                on:click={() => (dialog = null)}

              >

                <span aria-hidden="true">✕</span>

              </button>

            </div>

            {#if dialog === 'join'}

              <form on:submit|preventDefault={() => void join(joinTarget)}>

                <label class="field">

                  <span>Room ID or alias</span>

                  <input

                    type="text"

                    placeholder="!room:example.org or #alias:example.org"

                    bind:value={joinTarget}

                    required

                    disabled={joinBusy}

                  />

                </label>

                <button type="submit" class="primary-btn wide" disabled={joinBusy || !joinTarget.trim()}>

                  {joinBusy ? 'Joining…' : 'Join room'}

                </button>

              </form>

            {:else}

            <form on:submit|preventDefault={() => void create()}>

              <label class="field">

                <span>Room name</span>

                <input

                  type="text"

                  placeholder="Weekend plans"

                  bind:value={createName}

                  required

                  disabled={createBusy}

                />

              </label>

              <label class="field">

                <span>Topic (optional)</span>

                <input

                  type="text"

                  placeholder="What should this room be about?"

                  bind:value={createTopic}

                  disabled={createBusy}

                />

              </label>

              <button type="submit" class="primary-btn wide" disabled={createBusy || !createName.trim()}>

                {createBusy ? 'Creating…' : 'Create room'}

              </button>

            </form>

            {/if}

          </div>

        {/if}

      </div>

    {/if}

  </div>

{/if}