malice

public

Star0

Fork 0

Watch0

108 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `00ca0561eced`

tarball

atagen <boss@atagen.co>2026-10-26 05:50 UTC

5 files changed+373-0

web: mute rooms, DMs and spaces

Matrix has no space-level push rule, so a muted space is kept in dev.malice.muted_spaces account data and its rooms get room-level mute rules, recording which rooms the space muted so unmuting it never unmutes rooms muted individually.

Added file: web/src/lib/MutedIcon.svelte+6

@@ -0,0 +1,6 @@

1+<script lang="ts">

2+</script>

3+

4+<svg class="muted-icon" viewBox="0 0 24 24" width="13" height="13" aria-label="Muted" role="img">

+  <path d="M6 16V11a6 6 0 0 1 9-5.2M18 10v6l2 2H4l2-2M10 21h4M4 4l16 16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />

6+</svg>

Added file: web/src/lib/mute-model.ts+163 additions@@ -0,0 +1,163 @@
+import type { RoomSummary } from './types';
+
+export type RoomMode = 'AllMessages' | 'MentionsAndKeywordsOnly' | 'Mute';
+
+export interface MutedSpaces {
+  spaces: string[];
+  applied: Record<string, Record<string, RoomMode | null>>;
+}
+
+export const NO_MUTED_SPACES: MutedSpaces = { spaces: [], applied: {} };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isMode(value: unknown): value is RoomMode {
+  return value === 'AllMessages' || value === 'MentionsAndKeywordsOnly' || value === 'Mute';
+}
+
+export function parseMutedSpaces(raw: unknown): MutedSpaces {
+  if (!isRecord(raw)) return NO_MUTED_SPACES;
+  const spaces = Array.isArray(raw['spaces']) ? [...new Set(raw['spaces'].filter((s): s is string => typeof s === 'string'))] : [];
+  const applied: MutedSpaces['applied'] = {};
+  if (isRecord(raw['applied'])) {
+    for (const [spaceId, rooms] of Object.entries(raw['applied'])) {
+      if (!spaces.includes(spaceId) || !isRecord(rooms)) continue;
+      const entry: Record<string, RoomMode | null> = {};
+      for (const [roomId, mode] of Object.entries(rooms)) if (mode === null || isMode(mode)) entry[roomId] = mode;
+      applied[spaceId] = entry;
+    }
+  }
+  return { spaces, applied };
+}
+
+function childMap(rooms: RoomSummary[]): Map<string, Set<string>> {
+  const map = new Map<string, Set<string>>();
+  const add = (space: string, child: string) => {
+    let set = map.get(space);
+    if (!set) map.set(space, (set = new Set()));
+    set.add(child);
+  };
+  for (const room of rooms) {
+    for (const child of room.children) add(room.room_id, child);
+    for (const parent of room.parent_spaces) add(parent, room.room_id);
+  }
+  return map;
+}
+
+function descendants(spaceId: string, children: Map<string, Set<string>>, spaceIds: Set<string>): Set<string> {
+  const out = new Set<string>();
+  const seen = new Set<string>([spaceId]);
+  const queue = [spaceId];
+  for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+    for (const child of children.get(at) ?? []) {
+      if (spaceIds.has(child)) {
+        if (!seen.has(child)) {
+          seen.add(child);
+          queue.push(child);
+        }
+      } else out.add(child);
+    }
+  }
+  return out;
+}
+
+export function roomsUnderSpace(spaceId: string, rooms: RoomSummary[]): Set<string> {
+  const spaceIds = new Set(rooms.filter((r) => r.space).map((r) => r.room_id));
+  return descendants(spaceId, childMap(rooms), spaceIds);
+}
+
+export function spaceMutedRoomIds(rooms: RoomSummary[], mutedSpaces: string[]): Set<string> {
+  const out = new Set<string>();
+  if (mutedSpaces.length === 0) return out;
+  const children = childMap(rooms);
+  const spaceIds = new Set(rooms.filter((r) => r.space).map((r) => r.room_id));
+  for (const id of mutedSpaces) for (const room of descendants(id, children, spaceIds)) out.add(room);
+  return out;
+}
+
+export function isRoomMuted(room: RoomSummary, spaceMuted: Set<string>): boolean {
+  return room.notification_mode === 'Mute' || spaceMuted.has(room.room_id);
+}
+
+export function withSpaceMutes(rooms: RoomSummary[], spaceMuted: Set<string>): RoomSummary[] {
+  if (spaceMuted.size === 0) return rooms;
+  return rooms.map((room) => (spaceMuted.has(room.room_id) && room.notification_mode !== 'Mute' ? { ...room, notification_mode: 'Mute' } : room));
+}
+
+export interface RoomChange {
+  roomId: string;
+  mode: RoomMode | null;
+}
+
+export interface Plan {
+  state: MutedSpaces;
+  changes: RoomChange[];
+}
+
+function priorMode(room: RoomSummary): RoomMode | null {
+  const mode = room.notification_mode;
+  return room.notification_mode_custom && (mode === 'AllMessages' || mode === 'MentionsAndKeywordsOnly') ? mode : null;
+}
+
+function claimed(state: MutedSpaces): Set<string> {
+  const out = new Set<string>();
+  for (const entry of Object.values(state.applied)) for (const roomId of Object.keys(entry)) out.add(roomId);
+  return out;
+}
+
+function claim(state: MutedSpaces, spaceId: string, targets: RoomSummary[]): Plan {
+  const skip = claimed(state);
+  const fresh = targets.filter((room) => room.notification_mode !== 'Mute' && room.notification_mode !== null && !skip.has(room.room_id));
+  const entry = { ...state.applied[spaceId] };
+  for (const room of fresh) entry[room.room_id] = priorMode(room);
+  return {
+    state: fresh.length === 0 ? state : { ...state, applied: { ...state.applied, [spaceId]: entry } },
+    changes: fresh.map((room) => ({ roomId: room.room_id, mode: 'Mute' }))
+  };
+}
+
+function joinedUnder(spaceId: string, rooms: RoomSummary[]): RoomSummary[] {
+  const ids = roomsUnderSpace(spaceId, rooms);
+  return rooms.filter((r) => ids.has(r.room_id) && !r.space && r.membership === 'Joined');
+}
+
+export function muteSpacePlan(state: MutedSpaces, spaceId: string, rooms: RoomSummary[]): Plan {
+  const base = state.spaces.includes(spaceId) ? state : { ...state, spaces: [...state.spaces, spaceId] };
+  return claim(base, spaceId, joinedUnder(spaceId, rooms));
+}
+
+export function reconcilePlan(state: MutedSpaces, rooms: RoomSummary[]): Plan {
+  let current = state;
+  const changes: RoomChange[] = [];
+  for (const spaceId of state.spaces) {
+    const plan = claim(current, spaceId, joinedUnder(spaceId, rooms));
+    current = plan.state;
+    changes.push(...plan.changes);
+  }
+  return { state: current, changes };
+}
+
+export function unmuteSpacePlan(state: MutedSpaces, spaceId: string, rooms: RoomSummary[]): Plan {
+  const spaces = state.spaces.filter((s) => s !== spaceId);
+  const { [spaceId]: released = {}, ...applied } = state.applied;
+  const next: MutedSpaces = { spaces, applied };
+  const byId = new Map(rooms.map((r) => [r.room_id, r]));
+  const changes: RoomChange[] = [];
+  for (const [roomId, prior] of Object.entries(released)) {
+    const room = byId.get(roomId);
+    if (!room || room.notification_mode !== 'Mute') continue;
+    const heir = spaces.find((s) => roomsUnderSpace(s, rooms).has(roomId));
+    if (heir) {
+      next.applied = { ...next.applied, [heir]: { ...next.applied[heir], [roomId]: prior } };
+      continue;
+    }
+    changes.push({ roomId, mode: prior });
+  }
+  return { state: next, changes };
+}
+
+export function mutingSpace(state: MutedSpaces, rooms: RoomSummary[], roomId: string): string | null {
+  return state.spaces.find((id) => roomsUnderSpace(id, rooms).has(roomId)) ?? null;
+}

Added file: web/src/lib/mute.ts+61 additions@@ -0,0 +1,61 @@
+import { derived, get } from 'svelte/store';
+import { runCommand, setAccountData } from './api';
+import {
+  muteSpacePlan,
+  reconcilePlan,
+  spaceMutedRoomIds,
+  unmuteSpacePlan,
+  withSpaceMutes,
+  type Plan,
+  type RoomMode
+} from './mute-model';
+import { MUTED_SPACES_EVENT, mutedSpaces, mutedSpacesLoaded } from './muted-spaces';
+import { rooms } from './store';
+
+export const spaceMutedRooms = derived([rooms, mutedSpaces], ([$rooms, $muted]) => spaceMutedRoomIds($rooms, $muted.spaces));
+
+export const effectiveRooms = derived([rooms, spaceMutedRooms], ([$rooms, $muted]) => withSpaceMutes($rooms, $muted));
+
+let queue: Promise<void> = Promise.resolve();
+
+export function setRoomMode(roomId: string, mode: RoomMode | null): Promise<void> {
+  return runCommand({ op: 'set_room_notification_mode', room_id: roomId, mode }).then(() => undefined);
+}
+
+async function apply(plan: Plan): Promise<void> {
+  await setAccountData(MUTED_SPACES_EVENT, { ...plan.state });
+  mutedSpaces.set(plan.state);
+  const results = await Promise.allSettled(plan.changes.map((c) => setRoomMode(c.roomId, c.mode)));
+  const failed = results.find((r): r is PromiseRejectedResult => r.status === 'rejected');
+  if (failed) throw failed.reason;
+}
+
+function enqueue(job: () => Promise<void>): Promise<void> {
+  const run = queue.then(job);
+  queue = run.catch(() => undefined);
+  return run;
+}
+
+export function setSpaceMuted(spaceId: string, muted: boolean): Promise<void> {
+  return enqueue(async () => {
+    const state = get(mutedSpaces);
+    const all = get(rooms);
+    await apply(muted ? muteSpacePlan(state, spaceId, all) : unmuteSpacePlan(state, spaceId, all));
+  });
+}
+
+export function startMuteSync(): () => void {
+  const reconcile = () => {
+    if (!mutedSpacesLoaded() || get(mutedSpaces).spaces.length === 0) return;
+    void enqueue(async () => {
+      const plan = reconcilePlan(get(mutedSpaces), get(rooms));
+      if (plan.changes.length > 0) await apply(plan);
+    }).catch(() => undefined);
+  };
+  const stopRooms = rooms.subscribe(reconcile);
+  const stopMuted = mutedSpaces.subscribe(reconcile);
+  return () => {
+    stopRooms();
+    stopMuted();
+  };
+}

Added file: web/src/lib/muted-spaces.ts+23 additions@@ -0,0 +1,23 @@
+import { writable } from 'svelte/store';
+import { getAccountData } from './api';
+import { NO_MUTED_SPACES, parseMutedSpaces, type MutedSpaces } from './mute-model';
+
+export const MUTED_SPACES_EVENT = 'dev.malice.muted_spaces';
+
+export const mutedSpaces = writable<MutedSpaces>(NO_MUTED_SPACES);
+
+let loaded = false;
+
+export const mutedSpacesLoaded = () => loaded;
+
+export async function loadMutedSpaces(): Promise<void> {
+  try {
+    mutedSpaces.set(parseMutedSpaces(await getAccountData(MUTED_SPACES_EVENT)));
+    loaded = true;
+  } catch {}
+}
+
+export function resetMutedSpaces(): void {
+  loaded = false;
+  mutedSpaces.set(NO_MUTED_SPACES);
+}

Added file: web/test/mute.test.ts+120 additions@@ -0,0 +1,120 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import {
+  isRoomMuted,
+  muteSpacePlan,
+  mutingSpace,
+  parseMutedSpaces,
+  reconcilePlan,
+  spaceMutedRoomIds,
+  unmuteSpacePlan,
+  withSpaceMutes,
+  type MutedSpaces
+} from '../src/lib/mute-model.ts';
+import { badgeTotal } from '../src/lib/notification-model.ts';
+import type { RoomSummary } from '../src/lib/types.ts';
+
+function room(id: string, extra: Partial<RoomSummary> = {}): RoomSummary {
+  return {
+    room_id: id,
+    name: id,
+    membership: 'Joined',
+    space: false,
+    direct: false,
+    unread_messages: 0,
+    unread_mentions: 0,
+    notification_mode: 'AllMessages',
+    notification_mode_custom: false,
+    parent_spaces: [],
+    children: [],
+    ...extra
+  } as RoomSummary;
+}
+
+const empty: MutedSpaces = { spaces: [], applied: {} };
+
+const rooms = [
+  room('!top', { space: true, children: ['!a', '!sub'] }),
+  room('!sub', { space: true, parent_spaces: ['!top'], children: ['!b'] }),
+  room('!a', { parent_spaces: ['!top'], unread_messages: 3 }),
+  room('!b', { parent_spaces: ['!sub'], unread_messages: 2, notification_mode: 'MentionsAndKeywordsOnly', notification_mode_custom: true }),
+  room('!c', { notification_mode: 'Mute', notification_mode_custom: true, parent_spaces: ['!top'] }),
+  room('!other', { unread_messages: 1 })
+];
+
+test('space mute covers nested rooms but not rooms elsewhere', () => {
+  assert.deepEqual([...spaceMutedRoomIds(rooms, ['!top'])].sort(), ['!a', '!b', '!c']);
+  assert.equal(spaceMutedRoomIds(rooms, []).size, 0);
+});
+
+test('space mute silences the badge total and leaves other rooms', () => {
+  const muted = withSpaceMutes(rooms, spaceMutedRoomIds(rooms, ['!top']));
+  assert.equal(badgeTotal(muted), 1);
+  assert.equal(badgeTotal(rooms), 4);
+  assert.equal(withSpaceMutes(rooms, new Set()), rooms);
+});
+
+test('isRoomMuted covers explicit and inherited mute', () => {
+  const inherited = spaceMutedRoomIds(rooms, ['!top']);
+  assert.equal(isRoomMuted(rooms[2], inherited), true);
+  assert.equal(isRoomMuted(rooms[5], inherited), false);
+  assert.equal(isRoomMuted(rooms[4], new Set()), true);
+});
+
+test('muting a space claims unmuted children with their prior mode', () => {
+  const plan = muteSpacePlan(empty, '!top', rooms);
+  assert.deepEqual(plan.state.spaces, ['!top']);
+  assert.deepEqual(plan.state.applied['!top'], { '!a': null, '!b': 'MentionsAndKeywordsOnly' });
+  assert.deepEqual(plan.changes.map((c) => c.roomId).sort(), ['!a', '!b']);
+});
+
+test('unmuting restores prior modes and leaves individual mutes alone', () => {
+  const muted = muteSpacePlan(empty, '!top', rooms).state;
+  const after = rooms.map((r) => (r.room_id === '!a' || r.room_id === '!b' ? { ...r, notification_mode: 'Mute' as const } : r));
+  const plan = unmuteSpacePlan(muted, '!top', after);
+  assert.deepEqual(plan.state, empty);
+  assert.deepEqual(plan.changes, [
+    { roomId: '!a', mode: null },
+    { roomId: '!b', mode: 'MentionsAndKeywordsOnly' }
+  ]);
+  assert.equal(plan.changes.some((c) => c.roomId === '!c'), false);
+});
+
+test('a room a user unmuted inside a muted space is not reclaimed', () => {
+  const muted = muteSpacePlan(empty, '!top', rooms).state;
+  const after = rooms.map((r) => (r.room_id === '!a' ? { ...r, notification_mode: 'AllMessages' as const } : r));
+  assert.deepEqual(reconcilePlan(muted, after).changes, []);
+});
+
+test('reconcile mutes children that joined later', () => {
+  const muted = muteSpacePlan(empty, '!top', rooms).state;
+  const joined = [...rooms, room('!new', { parent_spaces: ['!top'] })];
+  const plan = reconcilePlan(muted, joined);
+  assert.deepEqual(plan.changes, [{ roomId: '!new', mode: 'Mute' }]);
+  assert.equal(reconcilePlan(plan.state, joined).changes.length, 0);
+});
+
+test('reconcile ignores rooms whose mode has not loaded', () => {
+  const muted: MutedSpaces = { spaces: ['!top'], applied: {} };
+  const pending = rooms.map((r) => (r.room_id === '!a' ? { ...r, notification_mode: null } : r));
+  assert.equal(reconcilePlan(muted, pending).changes.some((c) => c.roomId === '!a'), false);
+});
+
+test('overlapping muted spaces hand the room to the remaining space on unmute', () => {
+  const both = [...rooms, room('!shared', { parent_spaces: ['!top', '!x'] }), room('!x', { space: true, children: ['!shared'] })];
+  let state = muteSpacePlan(empty, '!top', both).state;
+  state = muteSpacePlan(state, '!x', both).state;
+  const after = both.map((r) => (r.notification_mode === 'AllMessages' ? { ...r, notification_mode: 'Mute' as const } : r));
+  const plan = unmuteSpacePlan(state, '!top', after);
+  assert.equal(plan.changes.some((c) => c.roomId === '!shared'), false);
+  assert.ok('!shared' in (plan.state.applied['!x'] ?? {}));
+  assert.equal(mutingSpace(plan.state, after, '!shared'), '!x');
+});
+
+test('parseMutedSpaces tolerates junk', () => {
+  assert.deepEqual(parseMutedSpaces(null), empty);
+  assert.deepEqual(parseMutedSpaces({ spaces: ['!a', 3], applied: { '!a': { '!r': 'Mute', '!q': 'Bogus' }, '!gone': { '!r': null } } }), {
+    spaces: ['!a'],
+    applied: { '!a': { '!r': 'Mute' } }
+  });
+});

malice

Commit 00ca0561eced

Commit `00ca0561eced`