malice

public

Star0

Fork 0

Watch0

59 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `9f996e377406`

tarball

atagen <boss@atagen.co>2026-10-25 03:34 UTC

10 files changed+607-5

history: add room repair controls and saved policy settings

Modified file: web/src/App.svelte+150 additions−5 deletions@@ -4,6 +4,8 @@
   import LoginPanel from './lib/LoginPanel.svelte';
   import MessageRow from './lib/MessageRow.svelte';
   import MentionsInbox from './lib/MentionsInbox.svelte';
+  import HistoryRepairPanel from './lib/HistoryRepairPanel.svelte';
+  import type { HistoryRepairPolicy, HistoryRepairReport } from './lib/repair-model';
   import MxcAvatar from './lib/MxcAvatar.svelte';
   import PinButton from './lib/PinButton.svelte';
   import ContextMenu, { type MenuItem } from './lib/ContextMenu.svelte';
@@ -26,6 +28,10 @@
     getRooms,
     getSession,
     getSpaceChildren,
+    historyRepair,
+    continueHistoryRepair,
+    cancelHistoryRepair,
+    startRecentHistory,
     joinRoom,
     leaveRoom,
     logout,
@@ -60,6 +66,8 @@
     mentionsSnapshot,
     pushBanner,
     imagePacks,
+    historyRepairs,
+    publishHistoryRepair,
     resetClientState,
     rooms,
     selectedRoomId,
@@ -67,6 +75,7 @@
     softLogout,
     timelines,
     pinnedTimelines,
+    pinnedTimelineVersions,
     verification
   } from './lib/store';
   import { discardPending, pendingByRoom, queueSend, resetPending, retryPending } from './lib/pending';
@@ -165,6 +174,115 @@
   let spaceChildrenError: string | null = null;
   let avatarByUser: Record<string, string | null> = {};
   let restoringRoute = false;
+  let repairPanels: Record<string, boolean> = {};
+  let repairBusy: Record<string, boolean> = {};
+  let repairCancelling: Record<string, boolean> = {};
+  let repairErrors: Record<string, string | null> = {};
+  let repairJumps: Record<string, { previous: HistoryRepairReport | null }> = {};
+  let repairAccount: string | null | undefined;
+  let repairEpoch = 0;
+  $: if ($sessionUser !== repairAccount) {
+    repairAccount = $sessionUser;
+    repairEpoch++;
+    repairPanels = {};
+    repairBusy = {};
+    repairCancelling = {};
+    repairErrors = {};
+    repairJumps = {};
+  }
+  $: currentRepair = $selectedRoomId ? $historyRepairs[$selectedRoomId] ?? null : null;
+  $: currentRepairActive = !!($selectedRoomId && repairBusy[$selectedRoomId]) || repairActive(currentRepair);
+  $: maybeJumpAfterRepair($selectedRoomId, currentRepair, repairJumps);
+  $: settleRepairCancellation($historyRepairs, repairBusy);
+
+  function repairActive(report: HistoryRepairReport | null | undefined): boolean {
+    return report?.phase === 'FetchingRecent' || report?.phase === 'Bridging';
+  }
+
+  function settleRepairCancellation(reports: Record<string, HistoryRepairReport>, busy: Record<string, boolean>): void {
+    for (const [roomId, report] of Object.entries(reports)) {
+      if (repairCancelling[roomId] && !busy[roomId] && !repairActive(report)) {
+        repairCancelling = { ...repairCancelling, [roomId]: false };
+      }
+    }
+  }
+
+  function maybeJumpAfterRepair(roomId: string | null, report: HistoryRepairReport | null, jumps: typeof repairJumps): void {
+    if (!roomId || roomId !== $selectedRoomId || !report?.recent_available || !jumps[roomId] || report === jumps[roomId].previous) return;
+    const next = { ...repairJumps };
+    delete next[roomId];
+    repairJumps = next;
+    stickToBottom = true;
+    const epoch = repairEpoch;
+    void tick().then(() => {
+      if (epoch === repairEpoch && $selectedRoomId === roomId) scrollToBottom();
+    });
+  }
+
+  async function showHistoryRepair(roomId: string): Promise<void> {
+    if ($selectedRoomId !== roomId) await selectRoom(roomId);
+    if ($selectedRoomId === roomId) repairPanels = { ...repairPanels, [roomId]: true };
+  }
+
+  async function runHistoryRepair(roomId: string, action: 'start' | 'continue' | 'recent', policy: HistoryRepairPolicy | null = null): Promise<void> {
+    if (!$sessionUser || repairBusy[roomId] || repairActive($historyRepairs[roomId]) || repairCancelling[roomId]) return;
+    const account = $sessionUser;
+    const epoch = repairEpoch;
+    repairPanels = { ...repairPanels, [roomId]: true };
+    repairBusy = { ...repairBusy, [roomId]: true };
+    repairErrors = { ...repairErrors, [roomId]: null };
+    if (action !== 'continue') repairJumps = { ...repairJumps, [roomId]: { previous: $historyRepairs[roomId] ?? null } };
+    try {
+      if (!openReady[roomId]) {
+        await openRoom(roomId);
+        if ($sessionUser !== account || epoch !== repairEpoch) return;
+        openReady = { ...openReady, [roomId]: true };
+        const failures = { ...openFailed };
+        delete failures[roomId];
+        openFailed = failures;
+        touchWarmRoom(roomId);
+      }
+      if (repairCancelling[roomId]) return;
+      const report = action === 'continue' ? await continueHistoryRepair(roomId)
+        : action === 'recent' ? await startRecentHistory(roomId) : await historyRepair(roomId, policy);
+      if ($sessionUser !== account || epoch !== repairEpoch) return;
+      if (report.room_id !== roomId) throw new Error('History repair returned a different room');
+      publishHistoryRepair(report, account);
+      maybeJumpAfterRepair(roomId, report, repairJumps);
+    } catch (cause) {
+      if ($sessionUser === account && epoch === repairEpoch) {
+        repairErrors = { ...repairErrors, [roomId]: cause instanceof Error ? cause.message : 'Could not repair history' };
+      }
+    } finally {
+      if ($sessionUser === account && epoch === repairEpoch) {
+        repairBusy = { ...repairBusy, [roomId]: false };
+        repairCancelling = { ...repairCancelling, [roomId]: false };
+        if (repairJumps[roomId]) {
+          const next = { ...repairJumps };
+          delete next[roomId];
+          repairJumps = next;
+        }
+      }
+    }
+  }
+
+  async function cancelRoomRepair(roomId: string): Promise<void> {
+    if (!$sessionUser || repairCancelling[roomId]) return;
+    const account = $sessionUser;
+    const epoch = repairEpoch;
+    repairCancelling = { ...repairCancelling, [roomId]: true };
+    try {
+      await cancelHistoryRepair(roomId);
+      if ($sessionUser === account && epoch === repairEpoch && !repairBusy[roomId] && !repairActive($historyRepairs[roomId])) {
+        repairCancelling = { ...repairCancelling, [roomId]: false };
+      }
+    } catch (cause) {
+      if ($sessionUser === account && epoch === repairEpoch) {
+        repairCancelling = { ...repairCancelling, [roomId]: false };
+        repairErrors = { ...repairErrors, [roomId]: cause instanceof Error ? cause.message : 'Could not cancel history repair' };
+      }
+    }
+  }
 
   function motionDuration(ms: number): number {
     return typeof window !== 'undefined' && window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 0 : ms;
@@ -643,6 +761,11 @@
 
   function noteUserScroll(): void {
     timelineViewport?.releaseScroll();
+    if ($selectedRoomId && repairJumps[$selectedRoomId]) {
+      const next = { ...repairJumps };
+      delete next[$selectedRoomId];
+      repairJumps = next;
+    }
   }
 
   function syncComposer(node: HTMLTextAreaElement) {
@@ -1025,15 +1148,18 @@
   }
 
   let pinnedOpenFor: string | null = null;
+  let pinnedCloseVersion = 0;
   let pinsExpanded = false;
   let pinPreview: TimelineEvent | null = null;
   let pinJumpBusy = false;
-  $: syncPinned(selectedRoom?.room_id ?? null, (selectedRoom?.pinned_events.length ?? 0) > 0);
-  function syncPinned(roomId: string | null, hasPins: boolean): void {
+  $: syncPinned(selectedRoom?.room_id ?? null, (selectedRoom?.pinned_events.length ?? 0) > 0, $selectedRoomId ? $pinnedTimelineVersions[$selectedRoomId] ?? 0 : 0, currentRepairActive);
+  function syncPinned(roomId: string | null, hasPins: boolean, version: number, repairing: boolean): void {
     const want = hasPins ? roomId : null;
-    if (want === pinnedOpenFor) return;
+    if (want === pinnedOpenFor && version === pinnedCloseVersion) return;
+    if (want && repairing) return;
     if (pinnedOpenFor) runCommand({ op: 'close_pinned', room_id: pinnedOpenFor }).catch(() => undefined);
     pinnedOpenFor = want;
+    pinnedCloseVersion = version;
     pinsExpanded = false;
     if (want) runCommand({ op: 'open_pinned', room_id: want }).catch(() => undefined);
   }
@@ -1331,7 +1457,7 @@
 
   async function paginate(): Promise<void> {
     const roomId = $selectedRoomId;
-    if (!roomId || paginateBusy) return;
+    if (!roomId || paginateBusy || currentRepairActive) return;
     paginateBusy = true;
     try {
       await paginateRoom(roomId);
@@ -1579,6 +1705,9 @@
     items.push({ label: room.favourite ? 'Unpin' : room.space ? 'Pin to top' : 'Pin', action: () => void togglePin(room) });
     items.push({ label: 'Copy link', action: () => copyText(`https://matrix.to/#/${room.canonical_alias ?? room.room_id}`) });
     items.push({ label: 'Copy room ID', action: () => copyText(room.room_id) });
+    if (!room.space && room.membership === 'Joined') {
+      items.push({ label: 'Repair message history', action: () => void showHistoryRepair(room.room_id) });
+    }
     if (room.membership === 'Joined') items.push({ label: 'Leave', danger: true, divider: true, action: () => void leave(room.room_id) });
     return items;
   }
@@ -1976,6 +2105,9 @@
           {#if roomMenuOpen}
             <div class="room-menu" role="menu">
               {#if selectedRoom.membership === 'Joined'}
+                <button type="button" role="menuitem" on:click={() => roomMenuAction(() => void showHistoryRepair(selectedRoom.room_id))}>
+                  Repair message history
+                </button>
                 <button
                   type="button"
                   role="menuitem"
@@ -2328,6 +2460,19 @@
           </p>
         </div>
       {:else}
+        {#if repairPanels[selectedRoom.room_id] ?? !!currentRepair}
+          <HistoryRepairPanel
+            report={currentRepair}
+            busy={!!repairBusy[selectedRoom.room_id]}
+            cancelling={!!repairCancelling[selectedRoom.room_id]}
+            error={repairErrors[selectedRoom.room_id] ?? null}
+            onStart={(policy) => void runHistoryRepair(selectedRoom.room_id, 'start', policy)}
+            onCancel={() => void cancelRoomRepair(selectedRoom.room_id)}
+            onContinue={() => void runHistoryRepair(selectedRoom.room_id, 'continue')}
+            onRecent={() => void runHistoryRepair(selectedRoom.room_id, 'recent')}
+            onClose={() => (repairPanels = { ...repairPanels, [selectedRoom.room_id]: false })}
+          />
+        {/if}
         {#if pins.length}
           <div class="pinned-strip" class:open={pinsExpanded}>
             <div class="pinned-head">
@@ -2431,7 +2576,7 @@
               {#if hasStart}
                 <p class="start-note">Beginning of history</p>
               {:else}
-                <button type="button" class="ghost-btn" disabled={paginateBusy} on:click={() => void paginate()}>
+                <button type="button" class="ghost-btn" disabled={paginateBusy || currentRepairActive} on:click={() => void paginate()}>
                   {paginateBusy ? 'Loading…' : 'Load older messages'}
                 </button>
               {/if}

Added file: web/src/lib/HistoryRepairPanel.svelte+148 additions@@ -0,0 +1,148 @@
+<script lang="ts">
+  import EmojiText from './EmojiText.svelte';
+  import type { HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
+
+  export let report: HistoryRepairReport | null = null;
+  export let busy = false;
+  export let cancelling = false;
+  export let error: string | null = null;
+  export let onStart: (policy: HistoryRepairPolicy | null) => void;
+  export let onCancel: () => void;
+  export let onContinue: () => void;
+  export let onRecent: () => void;
+  export let onClose: () => void;
+
+  let expanded = true;
+  let choice: 'saved' | 'StartRecent' | 'Bridge' | 'BridgeShortGaps' = 'saved';
+  let threshold: number | undefined = 15000;
+
+  $: active = busy || cancelling || report?.phase === 'FetchingRecent' || report?.phase === 'Bridging';
+  $: canRepair = choice !== 'BridgeShortGaps' || (threshold !== undefined && Number.isSafeInteger(threshold) && threshold >= 0);
+  $: serverFailure = serverError(report?.failure?.server);
+  $: paused = !active && report?.phase === 'Paused';
+  $: canContinue = paused && report?.strategy === 'Bridge';
+
+  function serverError(value: unknown): string {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return '';
+    const server = value as Record<string, unknown>;
+    const status = server.status;
+    const code = server.errcode;
+    const message = server.message;
+    if ((typeof status !== 'number' || !Number.isFinite(status)) && typeof code !== 'string' && typeof message !== 'string') return '';
+    const parts = [typeof status === 'number' ? `HTTP ${status}` : '', typeof code === 'string' ? code : '', typeof message === 'string' ? message : ''];
+    return parts.filter(Boolean).join(' · ');
+  }
+
+  function policy(): HistoryRepairPolicy | null {
+    if (choice === 'saved') return null;
+    if (choice === 'BridgeShortGaps') return { BridgeShortGaps: { threshold_ms: threshold! } };
+    return choice;
+  }
+
+  function stopLabel(value: NonNullable<HistoryRepairReport['stop']>): string {
+    const labels: Record<string, string> = {
+      Budget: 'Paused at the repair budget',
+      Cancelled: 'Repair cancelled',
+      NoAnchor: 'No retained history anchor was found',
+      HistoryUnavailable: 'History is unavailable',
+      CursorStalled: 'Repair made no progress'
+    };
+    return labels[value];
+  }
+
+  function continuityLabel(value: HistoryRepairReport['continuity']): string {
+    if (value === 'Unresolved') return 'Continuity unresolved';
+    if (value === 'Verified') return 'Continuity verified';
+    if (value === 'AccessibleStart') return 'Beginning of accessible history reached';
+    return value;
+  }
+
+  function start(): void {
+    if (canRepair) onStart(policy());
+  }
+</script>
+
+<section class="repair" aria-label="History repair">
+  <div class="banner">
+    <button type="button" class="summary" aria-expanded={expanded} on:click={() => expanded = !expanded}>
+      <span>History repair</span>
+      {#if active}<span class="muted">{cancelling ? 'Cancelling…' : report?.phase === 'Bridging' ? 'Bridging history…' : 'Loading recent messages…'}</span>{/if}
+      {#if report?.recent_available === true}<span class="recent">Recent messages available</span>
+      {:else if report?.recent_available === false}<span class="muted">Recent messages unavailable</span>
+      {:else}<span class="muted">{active ? 'Repair in progress' : 'History recovery'}</span>{/if}
+      {#if report?.recent_available === true && report.continuity === 'Unresolved'}<span class="muted">Continuity unresolved</span>{/if}
+      <span aria-hidden="true">{expanded ? '▴' : '▾'}</span>
+    </button>
+    <button type="button" class="close" aria-label="Close history repair" on:click={onClose}>✕</button>
+  </div>
+  {#if expanded}
+    <div class="details" aria-live="polite">
+      {#if report}
+        <p class="state">{#if active}{report.phase === 'FetchingRecent' ? 'Loading recent messages' : 'Bridging retained history'}{:else if report.recent_available}Recent messages are available{:else}Recent messages could not be restored{/if}</p>
+        <p>{continuityLabel(report.continuity)}{report.continuity === 'Unresolved' ? '. The missing interval has not been linked to retained history.' : '.'}</p>
+        <p>{report.strategy === 'Recent' ? 'Recent history' : report.strategy === 'Overlap' ? 'Retained overlap' : 'Bridge progress'} · {report.pages} pages and {report.events} events</p>
+        {#if report.coverage_duration_ms !== null}<p>Gap duration {report.coverage_duration_ms} ms</p>{/if}
+        {#if report.stop}<p>{stopLabel(report.stop)}</p>{/if}
+        {#if report.phase === 'Paused' && report.strategy === 'Bridge'}<p class="muted">Keep this room open to continue bridging. Closing it or restarting the app clears unfinished progress.</p>{/if}
+        {#if report.failure}
+          <p class="failure"><EmojiText text={report.failure.message} /></p>
+          {#if serverFailure}<p class="server-error"><EmojiText text={serverFailure} /></p>{/if}
+        {/if}
+        {#if !report.threshold_evaluated && typeof report.requested_policy !== 'string'}
+          <p>The requested threshold of {report.requested_policy.BridgeShortGaps.threshold_ms} ms was not evaluated. Recent messages were used.</p>
+        {/if}
+      {/if}
+      {#if error}<p class="failure" role="alert"><EmojiText text={error} /></p>{/if}
+      {#if !active}
+        <label class="field">Repair policy
+          <select bind:value={choice}>
+            <option value="saved">Use saved policy</option>
+            <option value="StartRecent">Start recent</option>
+            <option value="Bridge">Bridge retained history</option>
+            <option value="BridgeShortGaps">Bridge short gaps</option>
+          </select>
+        </label>
+        {#if choice === 'BridgeShortGaps'}
+          <label class="field">Threshold in milliseconds
+          <input type="number" min="0" step="1" bind:value={threshold} />
+          </label>
+          <p class="muted">The threshold cannot yet be evaluated, so this currently starts at recent messages. A threshold of zero disables automatic bridging. Bridge retained history remains available.</p>
+        {/if}
+      {/if}
+      <div class="actions">
+        {#if active}
+          <button type="button" class="ghost-btn" disabled={cancelling} on:click={onCancel}>{cancelling ? 'Cancelling…' : 'Cancel repair'}</button>
+          {#if cancelling}<span role="status">Waiting for the active repair to stop</span>{/if}
+        {:else}
+          <button type="button" class="primary-btn" disabled={!canRepair} on:click={start}>Repair history</button>
+        {#if canContinue}
+            <button type="button" class="ghost-btn" on:click={onContinue}>Continue bridging</button>
+        {/if}
+        {#if paused}
+            <button type="button" class="ghost-btn" on:click={onRecent}>Use recent window</button>
+          {/if}
+        {/if}
+        <button type="button" class="ghost-btn" on:click={onClose}>Close</button>
+      </div>
+    </div>
+  {/if}
+</section>
+
+<style>
+  .repair { max-height: min(42vh, 320px); overflow: auto; border: 1px solid var(--border); border-radius: var(--r-md); background: var(--panel); color: var(--text); }
+  .banner { display: flex; align-items: center; gap: 6px; padding: 6px; }
+  .summary { display: flex; flex: 1; min-width: 0; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 8px; padding: 5px 7px; border: 0; background: transparent; color: inherit; text-align: left; cursor: pointer; }
+  .summary span:first-child { font-weight: 600; }
+  .recent { color: var(--ok-text); font-size: 12px; }
+  .muted { color: var(--muted); font-size: 12px; }
+  .close { border: 0; background: transparent; color: var(--muted); cursor: pointer; }
+  .details { overflow: auto; padding: 0 12px 12px; font-size: 13px; }
+  .details p { margin: 7px 0; }
+  .state { font-weight: 600; }
+  .field { display: flex; flex-direction: column; gap: 5px; margin-top: 10px; }
+  select, input { width: 100%; min-height: var(--ctl-h); padding: 5px 7px; border: 1px solid var(--border); border-radius: var(--r-sm); background: var(--bg-soft); color: var(--text); font: inherit; }
+  .actions { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-top: 10px; }
+  .actions [role='status'] { color: var(--muted); }
+  .failure { color: var(--danger-text); }
+  @media (max-width: 520px) { .summary { flex-wrap: wrap; justify-content: flex-start; } }
+</style>

Added file: web/src/lib/HistoryRepairSettings.svelte+103 additions@@ -0,0 +1,103 @@
+<script lang="ts">
+  import { get } from 'svelte/store';
+  import { onMount } from 'svelte';
+  import { historyRepairPolicy, setHistoryRepairPolicy } from './api';
+  import { sessionUser } from './store';
+  import type { HistoryRepairPolicy } from './repair-model';
+
+  let selected: 'StartRecent' | 'Bridge' | 'BridgeShortGaps' = 'StartRecent';
+  let threshold: number | undefined = 15000;
+  let loading = true;
+  let loaded = false;
+  let busy = false;
+  let error = '';
+  let notice = '';
+  let alive = true;
+
+  async function loadPolicy(): Promise<void> {
+    const account = get(sessionUser);
+    if (!account) {
+      loading = false;
+      loaded = false;
+      error = 'Sign in to load the saved history repair policy.';
+      return;
+    }
+    loading = true;
+    loaded = false;
+    error = '';
+    try {
+      const policy = await historyRepairPolicy();
+      if (!alive || get(sessionUser) !== account) return;
+      if (policy === 'StartRecent' || policy === 'Bridge') selected = policy;
+      else {
+        selected = 'BridgeShortGaps';
+        threshold = policy.BridgeShortGaps.threshold_ms;
+      }
+      loaded = true;
+    } catch (cause) {
+      if (alive && get(sessionUser) === account) error = cause instanceof Error ? cause.message : 'Could not load the saved history repair policy.';
+    } finally {
+      if (alive && get(sessionUser) === account) loading = false;
+    }
+  }
+
+  onMount(() => {
+    void loadPolicy();
+    return () => { alive = false; };
+  });
+
+  async function save(): Promise<void> {
+    error = '';
+    notice = '';
+    const ms = threshold;
+    if (!loaded || busy || loading) return;
+    if (selected === 'BridgeShortGaps' && (ms === undefined || !Number.isSafeInteger(ms) || ms < 0)) {
+      error = 'Enter a whole number of milliseconds that is zero or greater.';
+      return;
+    }
+    const account = get(sessionUser);
+    if (!account) return;
+    const policy: HistoryRepairPolicy = selected === 'BridgeShortGaps'
+      ? { BridgeShortGaps: { threshold_ms: ms! } }
+      : selected;
+    busy = true;
+    try {
+      await setHistoryRepairPolicy(policy);
+      if (alive && get(sessionUser) === account) notice = 'History repair policy saved.';
+    } catch (cause) {
+      if (alive && get(sessionUser) === account) error = cause instanceof Error ? cause.message : 'Could not save the history repair policy.';
+    } finally {
+      if (alive && get(sessionUser) === account) busy = false;
+    }
+  }
+</script>
+
+<section aria-label="History repair settings">
+  <h3 class="sec-h">History repair</h3>
+  <label class="field">Saved policy
+    <select bind:value={selected} disabled={loading || busy}>
+      <option value="StartRecent">Start recent</option>
+      <option value="Bridge">Bridge retained history</option>
+      <option value="BridgeShortGaps">Bridge short gaps</option>
+    </select>
+  </label>
+  {#if selected === 'BridgeShortGaps'}
+    <label class="field">Gap threshold in milliseconds
+      <input type="number" min="0" step="1" bind:value={threshold} disabled={loading || busy} />
+    </label>
+    <p class="note">The threshold cannot yet be evaluated, so this policy currently starts at recent messages. A threshold of zero disables automatic bridging. Choose Bridge retained history to bridge explicitly.</p>
+  {/if}
+  <button type="button" class="primary-btn" disabled={!loaded || loading || busy || (selected === 'BridgeShortGaps' && (threshold === undefined || !Number.isSafeInteger(threshold) || threshold < 0))} on:click={save}>{busy ? 'Saving…' : 'Save'}</button>
+  {#if !loaded && !loading}<button type="button" class="ghost-btn" disabled={busy} on:click={() => void loadPolicy()}>Retry loading saved policy</button>{/if}
+  {#if error}<p class="error" role="alert">{error}</p>{/if}
+  {#if notice}<p class="notice" role="status">{notice}</p>{/if}
+</section>
+
+<style>
+  section { margin-top: 18px; }
+  .sec-h { margin: 0 0 8px; color: var(--muted); font-size: 12px; letter-spacing: .08em; text-transform: uppercase; }
+  .field { display: flex; flex-direction: column; gap: 6px; margin: 10px 0; font-size: 13px; }
+  select, input { width: 100%; min-height: var(--ctl-h); padding: 6px 8px; border: 1px solid var(--border); border-radius: var(--r-sm); background: var(--bg-soft); color: var(--text); font: inherit; }
+  .note, .notice { color: var(--muted); font-size: 13px; }
+  .error { color: var(--danger-text); background: var(--danger-bg); padding: 8px; border-radius: var(--r-sm); }
+</style>

Modified file: web/src/lib/SettingsPanel.svelte+2 additions@@ -13,6 +13,7 @@
   import { DEFAULT_QUICK_REACTIONS } from './quick-reactions';
   import ReactionPicker from './ReactionPicker.svelte';
   import ThemeSettings from './ThemeSettings.svelte';
+  import HistoryRepairSettings from './HistoryRepairSettings.svelte';
   import type { ImagePack, QuickReaction } from './types';
 
   export let quick: QuickReaction[];
@@ -35,6 +36,7 @@
   </div>
 
   <ThemeSettings />
+  <HistoryRepairSettings />
 
   <section aria-label="Message spacing">
     <h3 class="sec-h">Space between messages</h3>

Modified file: web/src/lib/api.ts+12 additions@@ -3,12 +3,16 @@
 import type { EventContext, EventContextPage, MemberSummary, RoomSummary } from './types';
 import type { Emote } from './emotes';
 import type { MentionKey, MentionsBoundary, MentionsPage, SavedMentionContext } from './mentions-model';
+import type { HistoryRepairBudget, HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
+export { parseHistoryRepairPolicy, parseHistoryRepairReport } from './repair-model';
+export type { HistoryRepairBudget, HistoryRepairFailure, HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
 export { mentionKey, parseMentionsPage, parseSavedMentionContext, parseMentionsUpdate } from './mentions-model';
 export type { MentionKey, MentionReason, MentionCaptureState, MentionEntry, MentionCoverage, MentionGap, MentionsBoundary, MentionsPage, SavedMentionContext, MentionsUpdate } from './mentions-model';
 import { formatBody } from './markdown';
 import { mentionedUserIds, type Mention } from './mentions';
 import { HttpTransport } from './transport-http';
 import type { CommandRequest, SendKind, SessionInfo, Transport, VerifyAction } from './transport';
+export type { HistoryRepairRequest } from './transport';
 import { createDeviceTransport } from 'malice:device-transport';
 
 export { ApiError } from './transport';
@@ -64,6 +68,14 @@ export const retryMentionContext = (room_id: string, event_id: string): Promise<
 export const setMentionsRead = (keys: MentionKey[], read: boolean) => transport.setMentionsRead(keys, read);
 export const markMentionsReadThrough = (boundary: MentionsBoundary) => transport.markMentionsReadThrough(boundary);
 export const recoverMentions = () => transport.recoverMentions();
+export const historyRepair = (room_id: string, policy: HistoryRepairPolicy | null = null, budget?: HistoryRepairBudget): Promise<HistoryRepairReport> =>
+  transport.historyRepair(room_id, policy, budget);
+export const continueHistoryRepair = (room_id: string, budget?: HistoryRepairBudget): Promise<HistoryRepairReport> =>
+  transport.continueHistoryRepair(room_id, budget);
+export const cancelHistoryRepair = (room_id: string): Promise<void> => transport.cancelHistoryRepair(room_id);
+export const startRecentHistory = (room_id: string): Promise<HistoryRepairReport> => transport.startRecentHistory(room_id);
+export const historyRepairPolicy = (): Promise<HistoryRepairPolicy> => transport.historyRepairPolicy();
+export const setHistoryRepairPolicy = (policy: HistoryRepairPolicy): Promise<void> => transport.setHistoryRepairPolicy(policy);
 export const setTyping = (room_id: string, typing: boolean) => transport.setTyping(room_id, typing);
 export const getAccountData = (eventType: string) => transport.getAccountData(eventType);
 export const getUrlPreview = (room_id: string, url: string) => transport.getUrlPreview(room_id, url);

Added file: web/src/lib/repair-model.ts+94 additions@@ -0,0 +1,94 @@
+export type HistoryRepairPolicy =
+  | 'StartRecent'
+  | 'Bridge'
+  | { BridgeShortGaps: { threshold_ms: number } };
+
+export interface HistoryRepairBudget {
+  max_pages: number;
+  max_events: number;
+  max_duration_ms: number;
+}
+
+export interface HistoryRepairFailure {
+  kind: string;
+  message: string;
+  server?: { status: number; errcode: string; message: string } | null;
+  [key: string]: unknown;
+}
+
+export interface HistoryRepairReport {
+  room_id: string;
+  requested_policy: HistoryRepairPolicy;
+  strategy: 'Recent' | 'Overlap' | 'Bridge';
+  coverage_duration_ms: number | null;
+  threshold_evaluated: boolean;
+  pages: number;
+  events: number;
+  phase: 'FetchingRecent' | 'Bridging' | 'Ready' | 'Paused';
+  continuity: 'Unresolved' | 'Verified' | 'AccessibleStart';
+  recent_available: boolean;
+  stop: 'Cancelled' | 'Budget' | 'HistoryUnavailable' | 'NoAnchor' | 'CursorStalled' | null;
+  failure: HistoryRepairFailure | null;
+}
+
+export const DEFAULT_HISTORY_REPAIR_BUDGET: HistoryRepairBudget = {
+  max_pages: 10,
+  max_events: 1000,
+  max_duration_ms: 15000
+};
+
+function record(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function safeNonnegativeInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+
+export function parseHistoryRepairPolicy(value: unknown): HistoryRepairPolicy | null {
+  if (value === 'StartRecent' || value === 'Bridge') return value;
+  const outer = record(value);
+  const details = outer && record(outer['BridgeShortGaps']);
+  if (!outer || Object.keys(outer).length !== 1 || !details || Object.keys(details).length !== 1 || !safeNonnegativeInteger(details['threshold_ms'])) return null;
+  return { BridgeShortGaps: { threshold_ms: details['threshold_ms'] } };
+}
+
+function isOneOf<T extends string>(value: unknown, values: readonly T[]): value is T {
+  return typeof value === 'string' && (values as readonly string[]).includes(value);
+}
+
+export function parseHistoryRepairReport(value: unknown): HistoryRepairReport | null {
+  const data = record(value);
+  if (!data) return null;
+  const policy = parseHistoryRepairPolicy(data['requested_policy']);
+  const failure = data['failure'];
+  const failureData = failure === null ? null : record(failure);
+  if (
+    typeof data['room_id'] !== 'string' || !policy ||
+    !isOneOf(data['strategy'], ['Recent', 'Overlap', 'Bridge']) ||
+    !(data['coverage_duration_ms'] === null || safeNonnegativeInteger(data['coverage_duration_ms'])) ||
+    typeof data['threshold_evaluated'] !== 'boolean' ||
+    !safeNonnegativeInteger(data['pages']) || !safeNonnegativeInteger(data['events']) ||
+    !isOneOf(data['phase'], ['FetchingRecent', 'Bridging', 'Ready', 'Paused']) ||
+    !isOneOf(data['continuity'], ['Unresolved', 'Verified', 'AccessibleStart']) ||
+    typeof data['recent_available'] !== 'boolean' ||
+    !(data['stop'] === null || isOneOf(data['stop'], ['Cancelled', 'Budget', 'HistoryUnavailable', 'NoAnchor', 'CursorStalled'])) ||
+    !(failure === null || (failureData && typeof failureData['kind'] === 'string' && typeof failureData['message'] === 'string'))
+  ) return null;
+  return {
+    room_id: data['room_id'],
+    requested_policy: policy,
+    strategy: data['strategy'],
+    coverage_duration_ms: data['coverage_duration_ms'],
+    threshold_evaluated: data['threshold_evaluated'],
+    pages: data['pages'],
+    events: data['events'],
+    phase: data['phase'],
+    continuity: data['continuity'],
+    recent_available: data['recent_available'],
+    stop: data['stop'],
+    failure: failureData as HistoryRepairFailure | null
+  };
+}

Modified file: web/src/lib/store.ts+26 additions@@ -1,6 +1,8 @@
 import { get, writable } from 'svelte/store';
 import { parseMentionsPage, parseMentionsUpdate } from './mentions-model';
 import type { MentionsPage } from './mentions-model';
+import { parseHistoryRepairReport } from './repair-model';
+import type { HistoryRepairReport } from './repair-model';
 import { getSession, subscribeEvents } from './api';
 import type { SoftLogout } from './api';
 import { isRecord } from './guards';
@@ -40,6 +42,13 @@ export const blocked = writable<boolean>(false);
 export const rooms = writable<RoomSummary[]>([]);
 export const timelines = writable<Record<string, TimelineItem[]>>({});
 export const pinnedTimelines = writable<Record<string, TimelineItem[]>>({});
+export const pinnedTimelineVersions = writable<Record<string, number>>({});
+export const historyRepairs = writable<Record<string, HistoryRepairReport>>({});
+
+export function publishHistoryRepair(report: HistoryRepairReport, account: string): void {
+  if (account !== get(sessionUser)) return;
+  historyRepairs.update((all) => ({ ...all, [report.room_id]: report }));
+}
 export interface EventContextState {
   room_id: string;
   request_id: string;
@@ -76,6 +85,8 @@ export function resetClientState(): void {
   rooms.set([]);
   timelines.set({});
   pinnedTimelines.set({});
+  pinnedTimelineVersions.set({});
+  historyRepairs.set({});
   eventContexts.set({});
   connection.set('connecting');
   selectedRoomId.set(null);
@@ -125,6 +136,14 @@ function handlePayload(text: string): void {
   if (!isRecord(data)) return;
   const kind = data['type'];
   if (kind === 'snapshot') {
+    const repairs: Record<string, HistoryRepairReport> = {};
+    if (isRecord(data['repairs'])) {
+      for (const [roomId, value] of Object.entries(data['repairs'])) {
+        const report = parseHistoryRepairReport(value);
+        if (report && report.room_id === roomId) repairs[roomId] = report;
+      }
+    }
+    historyRepairs.set(repairs);
     const mentions = parseMentionsPage(data['mentions']);
     if (mentions) publishMentionsPage(mentions);
     setRooms(data['rooms']);
@@ -155,6 +174,12 @@ function handlePayload(text: string): void {
     if (update) publishMentionsPage(update.snapshot);
     return;
   }
+  if (kind === 'history_repair') {
+    const report = parseHistoryRepairReport(data['report']);
+    const account = get(sessionUser);
+    if (report && account) publishHistoryRepair(report, account);
+    return;
+  }
   if (kind === 'image_packs') {
     imagePacks.set(parseImagePacks(data['packs']));
     return;
@@ -179,6 +204,7 @@ function handlePayload(text: string): void {
   if (kind === 'pinned_closed') {
     const roomId = data['room_id'];
     if (typeof roomId === 'string') {
+      pinnedTimelineVersions.update((all) => ({ ...all, [roomId]: (all[roomId] ?? 0) + 1 }));
       pinnedTimelines.update((all) => {
         const { [roomId]: _closed, ...rest } = all;
         return rest;

Modified file: web/src/lib/transport-http.ts+28 additions@@ -2,6 +2,8 @@ import type { EventContext, EventContextPage, MemberSummary, RoomSummary } from 
 import { parseEventContext, parseEventContextPage } from './types';
 import { parseMentionsPage, parseSavedMentionContext } from './mentions-model';
 import type { MentionKey, MentionsBoundary, MentionsPage, SavedMentionContext } from './mentions-model';
+import { DEFAULT_HISTORY_REPAIR_BUDGET, parseHistoryRepairPolicy, parseHistoryRepairReport } from './repair-model';
+import type { HistoryRepairBudget, HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
 import { ApiError, type CommandRequest, type SendKind, type SessionInfo, type Transport, type UploadExtras, type VerifyAction } from './transport';
 
 async function parseFailure(res: Response, fallback: string): Promise<never> {
@@ -140,6 +142,32 @@ export class HttpTransport implements Transport {
     await this.command({ op: 'mark_mentions_read_through', boundary });
   }
   async recoverMentions(): Promise<void> { await this.command({ op: 'recover_mentions' }); }
+  async historyRepair(room_id: string, policy: HistoryRepairPolicy | null = null, budget: HistoryRepairBudget = DEFAULT_HISTORY_REPAIR_BUDGET): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.command({ op: 'history_repair', room_id, policy, budget }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async continueHistoryRepair(room_id: string, budget: HistoryRepairBudget = DEFAULT_HISTORY_REPAIR_BUDGET): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.command({ op: 'continue_history_repair', room_id, budget }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async cancelHistoryRepair(room_id: string): Promise<void> {
+    await this.command({ op: 'cancel_history_repair', room_id });
+  }
+  async startRecentHistory(room_id: string): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.command({ op: 'start_recent_history', room_id }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async historyRepairPolicy(): Promise<HistoryRepairPolicy> {
+    const parsed = parseHistoryRepairPolicy(await this.command({ op: 'history_repair_policy' }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair policy response');
+    return parsed;
+  }
+  async setHistoryRepairPolicy(policy: HistoryRepairPolicy): Promise<void> {
+    await this.command({ op: 'set_history_repair_policy', policy });
+  }
   async eventContextBefore(room_id: string, event_id: string, from: string, limit = 20): Promise<EventContextPage> {
     return this.eventContextPage('before', room_id, event_id, from, limit);
   }

Modified file: web/src/lib/transport-worker.ts+28 additions@@ -1,6 +1,8 @@
 import { parseEventContext, parseEventContextPage } from './types';
 import { parseMentionsPage, parseSavedMentionContext } from './mentions-model';
 import type { MentionKey, MentionsBoundary, MentionsPage, SavedMentionContext } from './mentions-model';
+import { DEFAULT_HISTORY_REPAIR_BUDGET, parseHistoryRepairPolicy, parseHistoryRepairReport } from './repair-model';
+import type { HistoryRepairBudget, HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
 import type { EventContext, EventContextPage, MemberSummary, RoomSummary } from './types';
 import { ApiError, type CommandRequest, type SendKind, type SessionInfo, type SoftLogout, type Transport, type UploadExtras, type VerifyAction } from './transport';
 import { statusForKind } from './wire-status';
@@ -247,6 +249,32 @@ export class WorkerTransport implements Transport {
   async setMentionsRead(keys: MentionKey[], read: boolean): Promise<void> { await this.client.call('set_mentions_read', { keys, read }); }
   async markMentionsReadThrough(boundary: MentionsBoundary): Promise<void> { await this.client.call('mark_mentions_read_through', { boundary }); }
   async recoverMentions(): Promise<void> { await this.client.call('recover_mentions'); }
+  async historyRepair(room_id: string, policy: HistoryRepairPolicy | null = null, budget: HistoryRepairBudget = DEFAULT_HISTORY_REPAIR_BUDGET): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.client.call('history_repair', { room_id, policy, budget }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async continueHistoryRepair(room_id: string, budget: HistoryRepairBudget = DEFAULT_HISTORY_REPAIR_BUDGET): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.client.call('continue_history_repair', { room_id, budget }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async cancelHistoryRepair(room_id: string): Promise<void> {
+    await this.client.call('cancel_history_repair', { room_id });
+  }
+  async startRecentHistory(room_id: string): Promise<HistoryRepairReport> {
+    const parsed = parseHistoryRepairReport(await this.client.call('start_recent_history', { room_id }));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair response');
+    return parsed;
+  }
+  async historyRepairPolicy(): Promise<HistoryRepairPolicy> {
+    const parsed = parseHistoryRepairPolicy(await this.client.call('history_repair_policy'));
+    if (!parsed) throw new ApiError(502, 'Invalid history repair policy response');
+    return parsed;
+  }
+  async setHistoryRepairPolicy(policy: HistoryRepairPolicy): Promise<void> {
+    await this.client.call('set_history_repair_policy', { policy });
+  }
   eventContext(room_id: string, event_id: string, limit = 20): Promise<EventContext> {
     return this.contextCall('event_context', { room_id, event_id, limit });
   }

Modified file: web/src/lib/transport.ts+16 additions@@ -1,5 +1,6 @@
 import type { EventContext, EventContextPage, MemberSummary, PackUsage, RoomSummary } from './types';
 import type { MentionKey, MentionsBoundary, MentionsPage, SavedMentionContext } from './mentions-model';
+import type { HistoryRepairBudget, HistoryRepairPolicy, HistoryRepairReport } from './repair-model';
 
 export class ApiError extends Error {
   status: number;
@@ -64,8 +65,17 @@ export type CommandRequest =
   | { op: 'clone_pack_image'; from_pack: string; shortcode: string; to: PackTarget }
   | { op: 'clone_sticker'; room_id: string; event_id: string; to: PackTarget; shortcode: string }
   | { op: 'clone_pack'; from_pack: string; to: PackTarget; display_name: string | null }
+  | HistoryRepairRequest
   | MentionsRequest;
 
+export type HistoryRepairRequest =
+  | { op: 'history_repair'; room_id: string; policy: HistoryRepairPolicy | null; budget: HistoryRepairBudget }
+  | { op: 'continue_history_repair'; room_id: string; budget: HistoryRepairBudget }
+  | { op: 'cancel_history_repair'; room_id: string }
+  | { op: 'start_recent_history'; room_id: string }
+  | { op: 'history_repair_policy' }
+  | { op: 'set_history_repair_policy'; policy: HistoryRepairPolicy };
+
 export type MentionsRequest =
   | { op: 'mentions_page'; cursor: string | null; limit: number }
   | { op: 'mention_context' | 'retry_mention_context'; room_id: string; event_id: string }
@@ -116,6 +126,12 @@ export interface Transport {
   setMentionsRead(keys: MentionKey[], read: boolean): Promise<void>;
   markMentionsReadThrough(boundary: MentionsBoundary): Promise<void>;
   recoverMentions(): Promise<void>;
+  historyRepair(room_id: string, policy?: HistoryRepairPolicy | null, budget?: HistoryRepairBudget): Promise<HistoryRepairReport>;
+  continueHistoryRepair(room_id: string, budget?: HistoryRepairBudget): Promise<HistoryRepairReport>;
+  cancelHistoryRepair(room_id: string): Promise<void>;
+  startRecentHistory(room_id: string): Promise<HistoryRepairReport>;
+  historyRepairPolicy(): Promise<HistoryRepairPolicy>;
+  setHistoryRepairPolicy(policy: HistoryRepairPolicy): Promise<void>;
   setTyping(room_id: string, typing: boolean): Promise<void>;
   getAccountData(eventType: string): Promise<unknown | null>;
   getUrlPreview(room_id: string, url: string): Promise<unknown | null>;

malice

Commit 9f996e377406

Commit `9f996e377406`