malice

public

Star0

Fork 0

Watch0

144 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `5d6f6e2eb5a5`

tarball

atagen <boss@atagen.co>2026-10-27 05:48 UTC

6 files changed+91-19

web: stop the engine cleanly before an update reload

Reloading for an update took the old SharedWorker's last client away, so Chrome killed it mid-sync about a second after the click, before the new build's hello could make it step down. Reload now asks the engine to step down and waits up to 5s for it to release before activating the new service worker. A hidden superseded tab also no longer reloads ahead of that, which could kill the worker in the middle of its shutdown.

Modified file: web/src/lib/engine-build.ts+13 additions@@ -42,3 +42,16 @@ export function mayAutoReload(now: number, lastReload: number | null): boolean {
 export function retryDelay(attempt: number): number {
   return Math.min(1000 * 2 ** attempt, 8000);
 }
+
+export const RELEASE_TIMEOUT_MS = 5_000;
+
+export function within(promise: Promise<unknown>, ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    const done = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    promise.then(done, done);
+  });
+}

Modified file: web/src/lib/engine-state.ts+17 additions−2 deletions@@ -6,17 +6,32 @@ const ENGINE_RELOAD_GUARD = 'malice-engine-reload';
 export const engineStale = writable(false);
 export const engineRecovered = writable(0);
 
+let release: () => Promise<void> = () => Promise.resolve();
+
+export function setEngineRelease(fn: () => Promise<void>): void {
+  release = fn;
+}
+
+export function releaseEngine(): Promise<void> {
+  return release();
+}
+
 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();
+  void releaseEngine().then(() => window.location.reload());
 }
 
-export function markEngineStale(): void {
+/**
+ * Tabs in a handover leave the reload to the service worker activation. A hidden tab reloading
+ * ahead of it lands on the new build under the old service worker and gets reloaded again.
+ */
+export function markEngineStale(autoReload = true): void {
   engineStale.set(true);
+  if (!autoReload) return;
   document.addEventListener('visibilitychange', reloadWhenHidden);
   reloadWhenHidden();
 }

Modified file: web/src/lib/sw-register.ts+25 additions−8 deletions@@ -1,22 +1,38 @@
 import { writable } from 'svelte/store';
+import { releaseEngine } from './engine-state';
 
 const SW_RELOAD_GUARD = 'malice-sw-reload';
+const ACTIVATE_TIMEOUT_MS = 10_000;
 
 export const updateReady = writable(false);
 
-let waiting: ServiceWorker | null = null;
+let registered: ServiceWorkerRegistration | null = null;
+let applying: Promise<void> | null = null;
 
-export function applyUpdate(): void {
-  if (waiting) waiting.postMessage({ type: 'SKIP_WAITING' });
-  else window.location.reload();
+export function applyUpdate(): Promise<void> {
+  applying ??= handOver();
+  return applying;
+}
+
+/**
+ * The engine stops before SKIP_WAITING because activation reloads every tab, and the last one to
+ * unload takes the old SharedWorker down mid-sync. The timeout covers a waiting worker that went
+ * redundant and so never fires controllerchange.
+ */
+async function handOver(): Promise<void> {
+  await releaseEngine();
+  const waiting = registered?.waiting;
+  if (!waiting) {
+    window.location.reload();
+    return;
+  }
+  waiting.postMessage({ type: 'SKIP_WAITING' });
+  window.setTimeout(() => window.location.reload(), ACTIVATE_TIMEOUT_MS);
 }
 
 function watchForUpdates(registration: ServiceWorkerRegistration): void {
   const check = () => {
-    if (registration.waiting && navigator.serviceWorker.controller) {
-      waiting = registration.waiting;
-      updateReady.set(true);
-    }
+    if (registration.waiting && navigator.serviceWorker.controller) updateReady.set(true);
   };
   check();
   registration.addEventListener('updatefound', () => {
@@ -54,6 +70,7 @@ export function registerServiceWorker(): void {
   void navigator.serviceWorker
     .register('/sw.js', { type: 'module', updateViaCache: 'none' })
     .then((registration) => {
+      registered = registration;
       watchForUpdates(registration);
       if (!__MALICE_DEVICE__) return;
       return navigator.serviceWorker.ready.then(recoverUncontrolled);

Modified file: web/src/lib/transport-worker.ts+21 additions−6 deletions@@ -5,7 +5,8 @@ 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 { markEngineStale, engineRecovered, setEngineRelease } from './engine-state';
+import { RELEASE_TIMEOUT_MS, within } from './engine-build';
 import workerUrl from '../worker/worker.ts?worker&url';
 
 function toApiError(error: { kind: string; message: string }): ApiError {
@@ -29,13 +30,26 @@ class WorkerClient {
   private fatalHandlers = new Set<() => void>();
   private subscribed = new Set<string>();
   private superseded = false;
+  private releaseRequested = false;
+  private markReleased!: () => void;
+  private released = new Promise<void>((resolve) => (this.markReleased = resolve));
 
   constructor() {
+    setEngineRelease(() => this.releaseEngine());
     window.addEventListener('pagehide', () => {
       if (this.port) this.post({ kind: 'bye' });
     });
   }
 
+  releaseEngine(): Promise<void> {
+    if (!this.port) return Promise.resolve();
+    if (!this.superseded && !this.releaseRequested) {
+      this.releaseRequested = true;
+      this.port.postMessage({ kind: 'step_down' });
+    }
+    return within(this.released, RELEASE_TIMEOUT_MS);
+  }
+
   get accountId(): string | null {
     return this.account;
   }
@@ -102,20 +116,20 @@ class WorkerClient {
       return;
     }
     if (msg['kind'] === 'fatal') this.handleFatal(String(msg['message'] ?? ''));
-    else if (msg['kind'] === 'superseded') this.handleSuperseded();
+    else if (msg['kind'] === 'superseded') this.handleSuperseded(msg['handover'] === true);
+    else if (msg['kind'] === 'released') this.markReleased();
     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 {
+  private handleSuperseded(handover: boolean): 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();
+    markEngineStale(!handover);
   }
 
   /** The worker crashed and closed every port; every tab respawns it after a beat. */
@@ -127,7 +141,8 @@ class WorkerClient {
     }
     this.pending.clear();
     for (const handler of this.fatalHandlers) handler();
-    window.setTimeout(() => this.connect(), 1000);
+    if (this.superseded || this.releaseRequested) this.markReleased();
+    else window.setTimeout(() => this.connect(), 1000);
   }
 
   async getSession(): Promise<SessionInfo> {

Modified file: web/src/worker/worker.ts+6 additions−2 deletions@@ -279,6 +279,9 @@ async function dispatch(port: PortLike, data: unknown): Promise<void> {
     case 'bye':
       dropPort(port);
       return;
+    case 'step_down':
+      await stepDown(true);
+      return;
   }
 }
 
@@ -383,13 +386,14 @@ async function retryBlockedWithBackoff(): Promise<void> {
   }
 }
 
-async function stepDown(): Promise<void> {
+async function stepDown(handover = false): Promise<void> {
   if (superseded) return;
   superseded = true;
   await ready.catch(() => undefined);
   coalescer.flush();
-  for (const port of ports) postTo(port, { kind: 'superseded' });
+  for (const port of ports) postTo(port, { kind: 'superseded', handover });
   await host?.shutdown().catch(() => undefined);
+  for (const port of ports) postTo(port, { kind: 'released' });
   engineChannel.postMessage({ type: 'released', build: __MALICE_BUILD__ });
   close();
 }

Modified file: web/test/engine-build.test.ts+9 additions−1 deletions@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
-import { compareBuilds, helloAction, mayAutoReload, retryDelay } from '../src/lib/engine-build.ts';
+import { compareBuilds, helloAction, mayAutoReload, retryDelay, within } from '../src/lib/engine-build.ts';
 
 test('builds order by timestamp then tag', () => {
   assert.ok((compareBuilds('200-aaa', '100-zzz') ?? 0) > 0);
@@ -48,3 +48,11 @@ test('auto reload is limited to once per guard window', () => {
 test('retry delay backs off and caps', () => {
   assert.deepEqual([0, 1, 2, 3, 4, 10].map(retryDelay), [1000, 2000, 4000, 8000, 8000, 8000]);
 });
+
+test('a release wait ends when the engine answers, fails, or goes quiet', async () => {
+  const start = Date.now();
+  await within(Promise.resolve(), 5_000);
+  await within(Promise.reject(new Error('gone')), 5_000);
+  assert.ok(Date.now() - start < 1_000);
+  await within(new Promise(() => undefined), 20);
+});

malice

Commit 5d6f6e2eb5a5

Commit `5d6f6e2eb5a5`