malice

public

Star0

Fork 0

Watch0

120 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `d9be72fdb393`

tarball

atagen <boss@atagen.co>2026-10-26 09:38 UTC

12 files changed+227-10

web: let a newer build's engine supersede a stale device worker

A content-hashed worker URL means an upgrade spawns a second SharedWorker while the old one still holds the IndexedDB stores, and both event caches then write the same rows uncoordinated. Workers now announce their build over BroadcastChannel and the older one shuts its Host down and closes, while store_in_use accounts retry on release or with backoff for workers that predate this protocol.

Modified file: flake.nix+1

@@ -86,6 +86,7 @@

8686 inherit pname postPatch;

8787 version = "0.1.0";

8888 src = cleanSrc ./web;

89+ MALICE_BUILD = "${toString self.lastModified}-${self.shortRev or self.dirtyShortRev or "dirty"}";

8990 npmDeps = webNodeModules pkgs;

9091 disallowedReferences = [

9192 (webNodeModules pkgs)

Modified file: web/src/App.svelte+5 additions−2 deletions@@ -60,6 +60,7 @@
   } from './lib/api';
   import EmojiText from './lib/EmojiText.svelte';
   import UpdateBanner from './lib/UpdateBanner.svelte';
+  import { engineRecovered } from './lib/engine-state';
   import { customEmotes, resolveEmotes } from './lib/emotes';
   import { isKnownCommand, parseCommand, splitTarget, unescapeCommand } from './lib/commands';
   import type { ParsedCommand } from './lib/commands';
@@ -354,6 +355,8 @@
     };
   });
 
+  $: if ($engineRecovered > 0 && $blocked) void boot();
+
   async function boot(): Promise<void> {
     try {
       const session = await getSession();
@@ -1968,9 +1971,9 @@
     <p>Loading Malice…</p>
   </div>
 {:else if $blocked}
-  <div class="splash" role="status" aria-label="Malice is open in another tab" in:fade={{ duration: motionDuration(220) }}>
+  <div class="splash" role="status" aria-label="Close other Malice tabs" in:fade={{ duration: motionDuration(220) }}>
     <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>
+    <p>Close other Malice tabs</p>
   </div>
 {:else if $sessionUser == null}
   <LoginPanel softLogout={$softLogout} on:done={(ev) => afterLogin(ev.detail)} />

Modified file: web/src/lib/UpdateBanner.svelte+2 additions−1 deletions@@ -1,8 +1,9 @@
 <script lang="ts">
+  import { engineStale } from './engine-state';
   import { applyUpdate, updateReady } from './sw-register';
 </script>
 
-{#if $updateReady}
+{#if $updateReady || $engineStale}
   <div class="sec-banner" role="status">
     <span>Update ready</span>
     <button type="button" on:click={applyUpdate}>Reload</button>

Added file: web/src/lib/engine-build.ts+44 additions@@ -0,0 +1,44 @@
+export const ENGINE_CHANNEL = 'malice-engine';
+
+export type HelloAction = 'ignore' | 'yield' | 'announce';
+
+interface BuildStamp {
+  seconds: number;
+  tag: string;
+}
+
+function parseBuild(build: string): BuildStamp | null {
+  const match = /^(\d+)-(.+)$/.exec(build);
+  return match ? { seconds: Number(match[1]), tag: match[2] } : null;
+}
+
+/** Positive when `a` is newer than `b`, null when either is not a build id. */
+export function compareBuilds(a: string, b: string): number | null {
+  const left = parseBuild(a);
+  const right = parseBuild(b);
+  if (!left || !right) return null;
+  if (left.seconds !== right.seconds) return left.seconds - right.seconds;
+  return left.tag < right.tag ? -1 : left.tag > right.tag ? 1 : 0;
+}
+
+/**
+ * What a worker of build `own` does on hearing a hello from build `other`.
+ * A newer peer wins the store lock, so the worker yields. An older peer is
+ * told to yield by repeating our own hello, which it will judge the same way.
+ */
+export function helloAction(own: string, other: string): HelloAction {
+  const order = compareBuilds(other, own);
+  if (order === null || order === 0) return 'ignore';
+  return order > 0 ? 'yield' : 'announce';
+}
+
+export const RELOAD_GUARD_MS = 60_000;
+
+/** A superseded tab reloads itself once, so a shell stuck on the old build cannot loop. */
+export function mayAutoReload(now: number, lastReload: number | null): boolean {
+  return lastReload === null || now - lastReload >= RELOAD_GUARD_MS;
+}
+
+export function retryDelay(attempt: number): number {
+  return Math.min(1000 * 2 ** attempt, 8000);
+}

Added file: web/src/lib/engine-state.ts+22 additions@@ -0,0 +1,22 @@
+import { writable } from 'svelte/store';
+import { mayAutoReload } from './engine-build';
+
+const ENGINE_RELOAD_GUARD = 'malice-engine-reload';
+
+export const engineStale = writable(false);
+export const engineRecovered = writable(0);
+
+function reloadWhenHidden(): void {
+  if (document.visibilityState !== 'hidden') return;
+  const last = Number(sessionStorage.getItem(ENGINE_RELOAD_GUARD)) || null;
+  const now = Date.now();
+  if (!mayAutoReload(now, last)) return;
+  sessionStorage.setItem(ENGINE_RELOAD_GUARD, String(now));
+  window.location.reload();
+}
+
+export function markEngineStale(): void {
+  engineStale.set(true);
+  document.addEventListener('visibilitychange', reloadWhenHidden);
+  reloadWhenHidden();
+}

Modified file: web/src/lib/sw-register.ts+2 additions−1 deletions@@ -7,7 +7,8 @@ export const updateReady = writable(false);
 let waiting: ServiceWorker | null = null;
 
 export function applyUpdate(): void {
-  waiting?.postMessage({ type: 'SKIP_WAITING' });
+  if (waiting) waiting.postMessage({ type: 'SKIP_WAITING' });
+  else window.location.reload();
 }
 
 function watchForUpdates(registration: ServiceWorkerRegistration): void {

Modified file: web/src/lib/transport-worker.ts+23 additions@@ -5,6 +5,7 @@ import { ApiError, type CommandRequest, type SendKind, type SessionInfo, type So
 import { statusForKind } from './wire-status';
 import { workerName } from './trace-name';
 import { pageTraceFilter } from './trace-page';
+import { markEngineStale, engineRecovered } from './engine-state';
 import workerUrl from '../worker/worker.ts?worker&url';
 
 function toApiError(error: { kind: string; message: string }): ApiError {
@@ -27,6 +28,7 @@ class WorkerClient {
   private listeners = new Set<(account: string, event: string) => void>();
   private fatalHandlers = new Set<() => void>();
   private subscribed = new Set<string>();
+  private superseded = false;
 
   constructor() {
     window.addEventListener('pagehide', () => {
@@ -59,6 +61,7 @@ class WorkerClient {
   }
 
   private post(message: Record<string, unknown>, transfer?: Transferable[]): void {
+    if (this.superseded) return;
     if (!this.port) this.connect();
     if (!this.port) return;
     if (transfer && transfer.length > 0) this.port.postMessage(message, transfer);
@@ -68,6 +71,10 @@ class WorkerClient {
   private rpc<T>(message: Record<string, unknown>, transfer?: Transferable[]): Promise<T> {
     const id = this.nextId++;
     return new Promise<T>((resolve, reject) => {
+      if (this.superseded) {
+        reject(new ApiError(502, 'the worker was replaced by a newer build'));
+        return;
+      }
       this.pending.set(id, { resolve: resolve as (value: unknown) => void, reject });
       this.post({ ...message, id }, transfer);
     });
@@ -95,6 +102,20 @@ class WorkerClient {
       return;
     }
     if (msg['kind'] === 'fatal') this.handleFatal();
+    else if (msg['kind'] === 'superseded') this.handleSuperseded();
+    else if (msg['kind'] === 'recovered') engineRecovered.update((count) => count + 1);
+  }
+
+  /** A newer build took over the engine, so this tab's JS can no longer drive it. */
+  private handleSuperseded(): void {
+    this.superseded = true;
+    this.port = null;
+    for (const pending of this.pending.values()) {
+      pending.reject(new ApiError(502, 'the worker was replaced by a newer build'));
+    }
+    this.pending.clear();
+    for (const handler of this.fatalHandlers) handler();
+    markEngineStale();
   }
 
   /** The worker crashed and closed every port; every tab respawns it after a beat. */
@@ -114,7 +135,9 @@ class WorkerClient {
       soft_logout?: SoftLogout;
       account?: string;
       blocked?: true;
+      build?: string;
     }>({ kind: 'session' });
+    if (reply.build && reply.build !== __MALICE_BUILD__) markEngineStale();
     if (reply.blocked) this.account = null;
     else if (reply.account) this.account = reply.account;
     return { user_id: reply.user_id, soft_logout: reply.soft_logout, blocked: reply.blocked };

Modified file: web/src/vite-env.d.ts+1

@@ -1,2 +1,3 @@

11 /// <reference types="vite/client" />

22 declare const __MALICE_DEVICE__: boolean;

3+declare const __MALICE_BUILD__: string;

Modified file: web/src/worker/worker.ts+63 additions−4 deletions@@ -2,6 +2,7 @@ import init, { Host, init_tracing } from './pkg/malice_worker.js';
 import { isRecord } from '../lib/guards';
 import { traceFilter } from '../lib/trace-name';
 import { PUSH_CHANNEL } from '../lib/push-model';
+import { ENGINE_CHANNEL, helloAction, retryDelay } from '../lib/engine-build';
 import { EventCoalescer } from './coalesce';
 import {
   createAccount,
@@ -41,7 +42,10 @@ const softAccounts = new Map<string, Identity>();
 const blockedAccounts = new Set<string>();
 const accountIdentity = new Map<string, Identity>();
 
+declare const __MALICE_BUILD__: string;
+
 let host: Host;
+let superseded = false;
 
 function postTo(port: PortLike, message: Record<string, unknown>): void {
   port.postMessage(message);
@@ -110,6 +114,7 @@ async function restoreAccount(account: AccountInfo): Promise<void> {
   try {
     const passphrase = await getPassphrase(account.key);
     const result = await host.restore(account.key, passphrase);
+    blockedAccounts.delete(account.key);
     if (result.status === 'resumed' && result.user_id) {
       accountIdentity.set(account.key, { user_id: result.user_id, homeserver: account.homeserver ?? '' });
       liveAccounts.add(account.key);
@@ -128,6 +133,7 @@ const ready = (async () => {
   init_tracing(traceFilter((self as unknown as { name: string }).name));
   host = new Host(onHostEvent, onHostFatal);
   for (const account of await listAccounts()) await restoreAccount(account);
+  void retryBlockedWithBackoff();
 })();
 
 interface SessionReply {
@@ -135,18 +141,19 @@ interface SessionReply {
   soft_logout?: Identity;
   account?: string;
   blocked?: true;
+  build: string;
 }
 
 function handleSession(): SessionReply {
   const liveKey = currentAccountKey();
   if (liveKey) {
     const identity = accountIdentity.get(liveKey);
-    return { user_id: identity?.user_id ?? null, account: liveKey };
+    return { user_id: identity?.user_id ?? null, account: liveKey, build: __MALICE_BUILD__ };
   }
-  if (blockedAccounts.size > 0) return { user_id: null, blocked: true };
+  if (blockedAccounts.size > 0) return { user_id: null, blocked: true, build: __MALICE_BUILD__ };
   const soft = softAccounts.values().next();
-  if (!soft.done) return { user_id: null, soft_logout: soft.value };
-  return { user_id: null };
+  if (!soft.done) return { user_id: null, soft_logout: soft.value, build: __MALICE_BUILD__ };
+  return { user_id: null, build: __MALICE_BUILD__ };
 }
 
 async function handleLogin(
@@ -294,6 +301,7 @@ mediaChannel.onmessage = (ev: MessageEvent) => void handleMediaRequest(ev.data);
 
 async function handleMediaRequest(msg: unknown): Promise<void> {
   await ready;
+  if (superseded) return;
   if (!isRecord(msg) || typeof msg['id'] !== 'string') return;
   const id = msg['id'];
   const account = currentAccountKey();
@@ -333,6 +341,7 @@ pushChannel.onmessage = (ev: MessageEvent) => void handlePushRequest(ev.data);
 
 async function handlePushRequest(msg: unknown): Promise<void> {
   await ready;
+  if (superseded) return;
   if (!isRecord(msg) || typeof msg['id'] !== 'string' || msg['kind'] !== 'resolve') return;
   const id = msg['id'];
   const account = currentAccountKey();
@@ -348,3 +357,53 @@ async function handlePushRequest(msg: unknown): Promise<void> {
     pushChannel.postMessage({ id, error: toWireError(error) });
   }
 }
+
+const engineChannel = new BroadcastChannel(ENGINE_CHANNEL);
+
+async function retryBlocked(): Promise<void> {
+  await ready;
+  if (superseded || blockedAccounts.size === 0) return;
+  const blocked = (await listAccounts()).filter((account) => blockedAccounts.has(account.key));
+  for (const account of blocked) await restoreAccount(account);
+  if (blockedAccounts.size < blocked.length) for (const port of ports) postTo(port, { kind: 'recovered' });
+}
+
+let retryChain: Promise<void> = Promise.resolve();
+
+function queueRetry(): Promise<void> {
+  retryChain = retryChain.then(retryBlocked, retryBlocked);
+  return retryChain;
+}
+
+async function retryBlockedWithBackoff(): Promise<void> {
+  for (let attempt = 0; blockedAccounts.size > 0 && !superseded; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
+    await queueRetry();
+  }
+}
+
+async function stepDown(): Promise<void> {
+  if (superseded) return;
+  superseded = true;
+  await ready.catch(() => undefined);
+  coalescer.flush();
+  for (const port of ports) postTo(port, { kind: 'superseded' });
+  await host?.shutdown().catch(() => undefined);
+  engineChannel.postMessage({ type: 'released', build: __MALICE_BUILD__ });
+  close();
+}
+
+engineChannel.onmessage = (ev: MessageEvent) => {
+  const msg: unknown = ev.data;
+  if (superseded || !isRecord(msg) || typeof msg['build'] !== 'string') return;
+  if (msg['type'] === 'released') {
+    if (msg['build'] !== __MALICE_BUILD__) void queueRetry();
+    return;
+  }
+  if (msg['type'] !== 'hello') return;
+  const action = helloAction(__MALICE_BUILD__, msg['build']);
+  if (action === 'yield') void stepDown();
+  else if (action === 'announce') engineChannel.postMessage({ type: 'hello', build: __MALICE_BUILD__ });
+};
+
+engineChannel.postMessage({ type: 'hello', build: __MALICE_BUILD__ });

Added file: web/test/engine-build.test.ts+50 additions@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { compareBuilds, helloAction, mayAutoReload, retryDelay } from '../src/lib/engine-build.ts';
+
+test('builds order by timestamp then tag', () => {
+  assert.ok((compareBuilds('200-aaa', '100-zzz') ?? 0) > 0);
+  assert.ok((compareBuilds('100-aaa', '200-aaa') ?? 0) < 0);
+  assert.ok((compareBuilds('100-abc', '100-abd') ?? 0) < 0);
+  assert.equal(compareBuilds('100-abc', '100-abc'), 0);
+});
+
+test('timestamps compare numerically, not as strings', () => {
+  assert.ok((compareBuilds('1000-a', '999-a') ?? 0) > 0);
+});
+
+test('malformed build ids never order', () => {
+  assert.equal(compareBuilds('dev', '100-a'), null);
+  assert.equal(compareBuilds('100-a', ''), null);
+  assert.equal(helloAction('100-a', 'garbage'), 'ignore');
+});
+
+test('a worker yields to a newer peer', () => {
+  assert.equal(helloAction('100-a', '200-b'), 'yield');
+});
+
+test('a worker announces itself to an older peer', () => {
+  assert.equal(helloAction('200-b', '100-a'), 'announce');
+});
+
+test('the same build coexists', () => {
+  assert.equal(helloAction('100-a', '100-a'), 'ignore');
+});
+
+test('two workers never both yield', () => {
+  const pairs: [string, string][] = [['100-a', '200-b'], ['100-b', '100-a'], ['5-x', '50-x']];
+  for (const [one, two] of pairs) {
+    const actions = [helloAction(one, two), helloAction(two, one)];
+    assert.equal(actions.filter((a) => a === 'yield').length, 1);
+  }
+});
+
+test('auto reload is limited to once per guard window', () => {
+  assert.equal(mayAutoReload(1_000_000, null), true);
+  assert.equal(mayAutoReload(1_030_000, 1_000_000), false);
+  assert.equal(mayAutoReload(1_060_000, 1_000_000), true);
+});
+
+test('retry delay backs off and caps', () => {
+  assert.deepEqual([0, 1, 2, 3, 4, 10].map(retryDelay), [1000, 2000, 4000, 8000, 8000, 8000]);
+});

Modified file: web/tsconfig.worker.json+1−1

@@ -11,5 +11,5 @@

1111 "types": ["vite/client"],

1212 "noEmit": true

1313 },

-  "include": ["src/worker/**/*.ts", "src/sw.ts", "src/sw-media.ts", "src/sw-push.ts", "src/lib/media-decrypt.ts", "src/lib/media-sniff.ts", "src/lib/avatar-cache.ts", "src/lib/wire-status.ts", "src/lib/guards.ts"]

+  "include": ["src/worker/**/*.ts", "src/sw.ts", "src/sw-media.ts", "src/sw-push.ts", "src/lib/media-decrypt.ts", "src/lib/media-sniff.ts", "src/lib/avatar-cache.ts", "src/lib/wire-status.ts", "src/lib/guards.ts", "src/lib/engine-build.ts"]

1515 }

Modified file: web/vite.config.ts+13 additions−1 deletions@@ -1,3 +1,4 @@
+import { execFileSync } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -54,11 +55,22 @@ function twemojiPlugin(): import('vite').Plugin {
   };
 }
 
+function buildId(): string {
+  if (process.env.MALICE_BUILD) return process.env.MALICE_BUILD;
+  let rev = 'dev';
+  try {
+    rev = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || rev;
+  } catch {
+  }
+  return `${Math.floor(Date.now() / 1000)}-${rev}`;
+}
+
 export default defineConfig(({ mode }) => {
   const device = mode === 'device';
+  const build = buildId();
   return {
     plugins: [svelte(), twemojiPlugin(), precacheManifestPlugin()],
-    define: { __MALICE_DEVICE__: JSON.stringify(device) },
+    define: { __MALICE_DEVICE__: JSON.stringify(device), __MALICE_BUILD__: JSON.stringify(build) },
     assetsInclude: ['**/*.wasm'],
     worker: { format: 'es' },
     resolve: {

malice

Commit d9be72fdb393

Commit `d9be72fdb393`