@panyam/tsappkit 0.6.3 → 0.6.9

package/src/wasmhost/cache.ts

@@ -0,0 +1,111 @@
+/**
+ * The worker side of wasmhost's Cache (BrowserCache in Go): blobs by key in a directory of the
+ * Origin Private File System, which outlives a reload. worker.ts installs it as
+ * globalThis.wasmhostCache before the Go program starts.
+ *
+ * Only the parts of the File System Access types it uses are named here, so tests can hand it a
+ * fake directory and the package doesn't depend on the DOM lib having them.
+ */
+
+/** What Go's BrowserCache calls. get resolves to null for a key with nothing under it. */
+export interface BlobCache {
+  get(key: string): Promise<Uint8Array | null>;
+  put(key: string, bytes: Uint8Array): Promise<void>;
+}
+
+export interface CacheFile {
+  getFile(): Promise<{ arrayBuffer(): Promise<ArrayBuffer> }>;
+  createSyncAccessHandle?(): Promise<{
+    truncate(size: number): void;
+    write(buf: Uint8Array, opts?: { at: number }): number;
+    flush(): void;
+    close(): void;
+  }>;
+  createWritable?(): Promise<{ write(data: Uint8Array): Promise<void>; close(): Promise<void> }>;
+  move?(dir: CacheDirectory, name: string): Promise<void>;
+}
+
+export interface CacheDirectory {
+  getFileHandle(name: string, opts?: { create?: boolean }): Promise<CacheFile>;
+  removeEntry(name: string): Promise<void>;
+}
+
+/**
+ * A BlobCache over dir, one file per key. put writes a temporary file and moves it over the key
+ * where the browser can move files, so get never sees half a blob; elsewhere it writes in place.
+ * In a dedicated worker the write goes through a SyncAccessHandle, which every browser with OPFS
+ * offers there.
+ */
+export function opfsCache(dir: CacheDirectory): BlobCache {
+  return {
+    async get(key) {
+      let file: CacheFile;
+      try {
+        file = await dir.getFileHandle(key);
+      } catch (err) {
+        if (isNotFound(err)) return null;
+        throw err;
+      }
+      return new Uint8Array(await (await file.getFile()).arrayBuffer());
+    },
+    async put(key, bytes) {
+      const tmp = `.put-${key}-${Math.random().toString(36).slice(2)}`;
+      const file = await dir.getFileHandle(tmp, { create: true });
+      if (!file.move) {
+        await dir.removeEntry(tmp).catch(() => {});
+        await write(await dir.getFileHandle(key, { create: true }), bytes);
+        return;
+      }
+      try {
+        await write(file, bytes);
+        await file.move(dir, key);
+      } catch (err) {
+        await dir.removeEntry(tmp).catch(() => {});
+        throw err;
+      }
+    },
+  };
+}
+
+async function write(file: CacheFile, bytes: Uint8Array) {
+  if (file.createSyncAccessHandle) {
+    const h = await file.createSyncAccessHandle();
+    try {
+      h.truncate(0);
+      h.write(bytes, { at: 0 });
+      h.flush();
+    } finally {
+      h.close();
+    }
+  } else if (file.createWritable) {
+    const w = await file.createWritable();
+    await w.write(bytes);
+    await w.close();
+  } else {
+    throw new Error("this browser can't write to the origin private file system");
+  }
+}
+
+function isNotFound(err: unknown): boolean {
+  return typeof err === "object" && err !== null && (err as { name?: unknown }).name === "NotFoundError";
+}
+
+/**
+ * The cache for namespace ns under wasmhost/<ns>/ in the origin's private file system, or undefined
+ * where there's none (navigator.storage.getDirectory missing). The directory is opened on first use.
+ */
+export function workerCache(ns: string, storage: { getDirectory?: () => Promise<unknown> } | undefined): BlobCache | undefined {
+  if (!storage?.getDirectory) return undefined;
+  const getDirectory = storage.getDirectory.bind(storage);
+  let dir: Promise<BlobCache> | undefined;
+  const open = () =>
+    (dir ??= (async () => {
+      const root = (await getDirectory()) as { getDirectoryHandle(n: string, o: { create: boolean }): Promise<unknown> };
+      const base = (await root.getDirectoryHandle("wasmhost", { create: true })) as typeof root;
+      return opfsCache((await base.getDirectoryHandle(ns, { create: true })) as CacheDirectory);
+    })());
+  return {
+    get: async (key) => (await open()).get(key),
+    put: async (key, bytes) => (await open()).put(key, bytes),
+  };
+}

package/src/wasmhost/client.ts

@@ -2,7 +2,7 @@
 // a Web Worker; workerFetch is a fetch to hand a Connect transport, so the app's generated clients
 // talk to the worker exactly as they would to a server; mountFiles pushes files in before the
 // requests that read them.
-import type { Files, HostReply, HostRequest, HostStatus } from "./protocol";
+import type { Files, HostChunk, HostReply, HostRequest, HostStatus } from "./protocol";
 
 export type { Files } from "./protocol";
 
@@ -22,14 +22,19 @@ type Unsent = HostRequest extends infer R ? (R extends HostRequest ? Omit<R, "id
 
 class Channel {
   private next = 1;
-  private pending = new Map<number, { resolve: (r: HostReply) => void; reject: (e: Error) => void }>();
+  private pending = new Map<
+    number,
+    { resolve: (r: HostReply) => void; reject: (e: Error) => void; onChunk?: (c: HostChunk) => void }
+  >();
   private dead: Error | null = null;
 
   constructor(private worker: Worker) {
-    worker.addEventListener("message", (ev: MessageEvent<HostReply | HostStatus>) => {
+    worker.addEventListener("message", (ev: MessageEvent<HostReply | HostStatus | HostChunk>) => {
       const m = ev.data;
       if ("exited" in m) {
         this.fail(new Error(`wasm host: ${m.exited}`));
+      } else if ("chunk" in m) {
+        this.pending.get(m.id)?.onChunk?.(m);
       } else if ("id" in m) {
         this.pending.get(m.id)?.resolve(m);
         this.pending.delete(m.id);
@@ -38,16 +43,22 @@ class Channel {
     worker.addEventListener("error", (ev: ErrorEvent) => this.fail(new Error(`wasm host worker: ${ev.message}`)));
   }
 
-  call(req: Unsent, transfer: Transferable[]): Promise<HostReply> {
-    if (this.dead) return Promise.reject(this.dead);
-    return new Promise((resolve, reject) => {
-      const id = this.next++;
-      this.pending.set(id, { resolve, reject });
+  /** Sends req and returns its id with the final reply; chunks before it go to onChunk. */
+  start(req: Unsent, transfer: Transferable[], onChunk?: (c: HostChunk) => void): { id: number; done: Promise<HostReply> } {
+    const id = this.next++;
+    if (this.dead) return { id, done: Promise.reject(this.dead) };
+    const done = new Promise<HostReply>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, onChunk });
       this.worker.postMessage({ ...req, id }, transfer);
     });
+    return { id, done };
+  }
+
+  call(req: Unsent, transfer: Transferable[]): Promise<HostReply> {
+    return this.start(req, transfer).done;
   }
 
-  private fail(err: Error) {
+  fail(err: Error) {
     this.dead = err;
     for (const p of this.pending.values()) p.reject(err);
     this.pending.clear();
@@ -56,6 +67,16 @@ class Channel {
 
 const channels = new WeakMap<Worker, Channel>();
 
+/**
+ * Terminates worker and rejects every request still waiting on it with `err`, which terminate
+ * alone wouldn't do: a terminated worker never replies, so its pending requests would wait forever.
+ * For lane.ts; not exported from the package.
+ */
+export function endWorker(worker: Worker, err: Error): void {
+  channels.get(worker)?.fail(err);
+  worker.terminate();
+}
+
 function channel(worker: Worker): Channel {
   let c = channels.get(worker);
   if (!c) {
@@ -67,7 +88,8 @@ function channel(worker: Worker): Channel {
 
 /**
  * Starts the worker and resolves with it once the Go program has installed its exports, or rejects
- * with why it couldn't load. Relative URLs resolve against the page, not the worker script.
+ * with why it couldn't load (and terminates it, since it can't answer anything). Relative URLs
+ * resolve against the page, not the worker script.
  */
 export function startWorker(opts: StartWorkerOptions): Promise<Worker> {
   const abs = (u: string | URL) => new URL(u, location.href).href;
@@ -82,13 +104,22 @@ export function startWorker(opts: StartWorkerOptions): Promise<Worker> {
       const m = ev.data;
       if (!("ready" in m)) return;
       worker.removeEventListener("message", onMessage);
-      if (m.ready) resolve(worker);
-      else reject(new Error(`wasm host failed to load: ${m.error}`));
+      if (m.ready) {
+        resolve(worker);
+        return;
+      }
+      worker.terminate();
+      reject(new Error(`wasm host failed to load: ${m.error}`));
     };
     worker.addEventListener("message", onMessage);
-    worker.addEventListener("error", (ev: ErrorEvent) => reject(new Error(`wasm host worker: ${ev.message}`)), {
-      once: true,
-    });
+    worker.addEventListener(
+      "error",
+      (ev: ErrorEvent) => {
+        worker.terminate();
+        reject(new Error(`wasm host worker: ${ev.message}`));
+      },
+      { once: true },
+    );
   });
 }
 
@@ -100,27 +131,144 @@ const NULL_BODY = new Set([101, 103, 204, 205, 304]);
  * Only the path and query reach the worker, so baseUrl can be anything absolute, such as
  * location.origin. It rejects if the worker reports an error (no handler, a failed build, a handler
  * panic) and resolves with any HTTP status the handler chose.
+ *
+ * A handler that flushes (http.Flusher) streams: the Response resolves at its first flush, and its
+ * body delivers each flush as it happens, even from a Go loop that never yields, then the rest
+ * when the handler returns. Aborting the request (init.signal) rejects it, or errors a body that's
+ * already streaming, and cancels the handler's context; a handler sees that the next time it checks
+ * ctx, which a loop that never yields to JS doesn't get to do (a lane ends such a worker instead).
+ * Once the body is streaming, Chrome's text() and json() report the abort as "TypeError: Failed to
+ * fetch" rather than an AbortError, so tell an abort from a failure by signal.aborted.
  */
 export function workerFetch(worker: Worker): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
   const c = channel(worker);
   return async (input, init) => {
     const req = new Request(input, init);
+    const signal = req.signal;
+    if (signal.aborted) throw abortReason(signal);
     const buf = new Uint8Array(await req.arrayBuffer());
     const body = buf.byteLength ? buf : null;
     const headers: Record<string, string> = {};
     req.headers.forEach((v, k) => (headers[k] = v));
     const u = new URL(req.url);
-    const reply = await c.call(
-      { kind: "http", method: req.method, url: u.pathname + u.search, headers, body },
-      body ? [body.buffer] : [],
-    );
-    if (!reply.ok) throw new Error(reply.error);
-    const status = reply.status ?? 200;
-    const resBody = NULL_BODY.has(status) ? null : ((reply.body ?? null) as BodyInit | null);
-    return new Response(resBody, { status, headers: reply.headers });
+
+    return new Promise<Response>((resolve, reject) => {
+      let stream: ReadableStreamDefaultController<Uint8Array> | undefined;
+      let settled = false;
+      const fail = (err: unknown) => {
+        if (settled) return;
+        settled = true;
+        if (stream) stream.error(err);
+        else reject(err);
+      };
+      const { id, done } = c.start(
+        { kind: "http", method: req.method, url: u.pathname + u.search, headers, body },
+        body ? [body.buffer] : [],
+        (chunk) => {
+          if (settled) return;
+          if (!stream) {
+            const status = chunk.status ?? 200;
+            const rs = new ReadableStream<Uint8Array>({ start: (ctl) => void (stream = ctl) });
+            resolve(new Response(NULL_BODY.has(status) ? null : rs, { status, headers: chunk.headers }));
+          }
+          if (chunk.body.byteLength) stream!.enqueue(chunk.body);
+        },
+      );
+      const onAbort = () => {
+        void c.call({ kind: "cancel", target: id }, []).catch(() => {});
+        fail(abortReason(signal));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      done.then(
+        (reply) => {
+          signal.removeEventListener("abort", onAbort);
+          if (!reply.ok) return fail(new Error(reply.error));
+          if (settled) return;
+          settled = true;
+          if (stream) {
+            if (reply.body?.byteLength) stream.enqueue(reply.body);
+            stream.close();
+            return;
+          }
+          const status = reply.status ?? 200;
+          const resBody = NULL_BODY.has(status) ? null : ((reply.body ?? null) as BodyInit | null);
+          resolve(new Response(resBody, { status, headers: reply.headers }));
+        },
+        (err) => {
+          signal.removeEventListener("abort", onAbort);
+          fail(err);
+        },
+      );
+    });
   };
 }
 
+function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("This request was aborted.", "AbortError");
+}
+
+/**
+ * A fetch like workerFetch's, except that each call starts a fresh worker from `opts`, sends it that
+ * one request, and terminates it once the response is in, whether the request succeeded or not.
+ * Ending the worker is the only way to give its wasm memory back to the browser, since wasm memory
+ * never shrinks, so route a request with a big transient peak (an ingest that parses a large input
+ * on the way to a small result) through this, and have it leave its result in the shared Cache
+ * (Go's wasmhost.BrowserCache) for the long-lived worker to load. Every worker for the same `ns`
+ * sees the same cache.
+ *
+ * Each call pays for a worker start and a wasm instantiate, a few hundred ms, so it's for jobs
+ * that take seconds, not for ordinary requests. The worker ends when the response's body has been
+ * read to the end, fails, or is cancelled, so a streamed body isn't cut short; read or cancel the
+ * body, or the worker stays up.
+ */
+export function oneShotFetch(opts: StartWorkerOptions): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
+  return async (input, init) => {
+    const worker = await startWorker(opts);
+    let res: Response;
+    try {
+      res = await workerFetch(worker)(input, init);
+    } catch (err) {
+      worker.terminate();
+      throw err;
+    }
+    return untilBodyEnds(res, () => worker.terminate());
+  };
+}
+
+/**
+ * res with `end` called once its body has been read to the end, has failed, or has been
+ * cancelled (or at once, for a response without a body). For oneShotFetch and lanes, which must
+ * not let go of a worker while its streamed body is still arriving. Not exported from the package.
+ */
+export function untilBodyEnds(res: Response, end: () => void): Response {
+  if (!res.body) {
+    end();
+    return res;
+  }
+  const reader = res.body.getReader();
+  const body = new ReadableStream<Uint8Array>({
+    async pull(ctl) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          ctl.close();
+          end();
+        } else {
+          ctl.enqueue(value);
+        }
+      } catch (err) {
+        end();
+        ctl.error(err);
+      }
+    },
+    cancel(reason) {
+      end();
+      return reader.cancel(reason);
+    },
+  });
+  return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+}
+
 /**
  * Replaces the mount `name` with `files`. The buffers are transferred to the worker, not copied, so
  * each Uint8Array is empty here afterwards; copy first anything the page still needs. Resolves once

package/src/wasmhost/index.ts

@@ -1,3 +1,5 @@
-export { startWorker, workerFetch, mountFiles, addFiles, unmountFiles, workerMemory } from "./client";
+export { startWorker, workerFetch, oneShotFetch, mountFiles, addFiles, unmountFiles, workerMemory } from "./client";
 export type { StartWorkerOptions, Files } from "./client";
 export { filesFromDrop, filesFromFileList } from "./drop";
+export { startLane } from "./lane";
+export type { Lane, LaneOptions } from "./lane";

package/src/wasmhost/lane.ts

@@ -0,0 +1,171 @@
+// Lanes (goapplib issue 80): more than one worker for one wasm service, with the app routing
+// requests by kind, so a quick request never waits behind a long one. Go's wasm target runs one
+// thread per worker, and a job that never yields keeps that thread busy, so neither a second
+// request nor an abort can reach it. A lane holds one worker it can replace: aborting a request
+// on it terminates the worker, which is the only way to stop a job that never yields, and starts
+// a fresh one, warmed from the shared Cache by the app's warm function.
+import { endWorker, startWorker, untilBodyEnds, workerFetch, workerMemory, type StartWorkerOptions } from "./client";
+
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+export interface LaneOptions {
+  /**
+   * Runs on each new worker before the lane hands it a request: typically a request that loads
+   * the service's state from the cache (wasmhost.BrowserCache), so a replacement worker answers
+   * like the one it replaced. A warm that throws ends that worker, and the error is what the next
+   * request gets; the request after it starts another worker.
+   */
+  warm?: (fetch: Fetch) => Promise<unknown>;
+  /**
+   * A memory limit for the lane's worker, in bytes of wasm memory (workerMemory). Wasm memory never
+   * shrinks, so a long-lived worker creeps up through requests that each allocate and drop some.
+   * When a request finishes (its body read to the end, or failed) and the lane has nothing else
+   * in flight, the lane asks the worker how much it holds, and past this limit replaces it with a
+   * fresh one, warmed as on an abort. It never interrupts a request, so a lane that's never idle
+   * never restarts, and a response whose body nobody reads keeps the lane busy. Size it above what
+   * the warmed state needs, or the lane restarts after every request.
+   */
+  maxMemoryBytes?: number;
+  /** Called when the lane replaces its worker for passing maxMemoryBytes, with what it held. */
+  onRestart?: (why: { memoryBytes: number }) => void;
+}
+
+/** One replaceable worker. See startLane. */
+export interface Lane {
+  /**
+   * A fetch for a Connect transport, like workerFetch, answered by the lane's current worker.
+   * Aborting a request (init.signal) rejects it with the signal's reason at once (or errors its
+   * body, if it's already streaming), terminates the worker, and starts and warms a new one; other
+   * requests still waiting on the old worker are rejected too. A request made meanwhile waits for
+   * the new worker.
+   */
+  fetch: Fetch;
+  /** The lane's current worker, once it's started and warmed. */
+  worker(): Promise<Worker>;
+  /** Replaces the worker, as an abort does, and resolves once the new one is warm. */
+  restart(): Promise<void>;
+  /** Terminates the worker. Requests after this reject. */
+  close(): void;
+}
+
+/**
+ * Starts a lane: a worker from `opts`, warmed with `lane.warm`, that the lane replaces whenever a
+ * request on it is aborted. Give each kind of request its own lane (a "serve" lane for quick
+ * queries, a "jobs" lane for long jobs) by building each client's transport on that lane's fetch.
+ * Every lane of one ns shares the same Cache, which is how a replacement or a second lane gets the
+ * state without rebuilding it.
+ */
+export function startLane(opts: StartWorkerOptions, lane: LaneOptions = {}): Lane {
+  let closed = false;
+  let current!: Promise<Worker>;
+  let failed = false;
+
+  const boot = () => {
+    failed = false;
+    const p: Promise<Worker> = startWorker(opts).then(async (w) => {
+      if (lane.warm) {
+        try {
+          await lane.warm(workerFetch(w));
+        } catch (err) {
+          endWorker(w, err instanceof Error ? err : new Error(String(err)));
+          throw err;
+        }
+      }
+      return w;
+    });
+    p.catch(() => {
+      if (current === p) failed = true;
+    });
+    current = p;
+    return p;
+  };
+
+  const replace = (old: Worker, why: Error) => {
+    endWorker(old, why);
+    return boot();
+  };
+
+  let inFlight = 0;
+  // Runs when the lane goes idle. A request that starts while workerMemory is out means the lane
+  // isn't idle any more, so the restart waits for the next idle moment.
+  const checkMemory = async (w: Worker, of: Promise<Worker>) => {
+    let bytes: number;
+    try {
+      bytes = await workerMemory(w);
+    } catch {
+      return;
+    }
+    if (bytes <= lane.maxMemoryBytes! || inFlight !== 0 || current !== of || closed) return;
+    lane.onRestart?.({ memoryBytes: bytes });
+    void replace(w, new Error("wasm host lane: restarted past its memory limit")).catch(() => {});
+  };
+
+  boot();
+
+  return {
+    async fetch(input, init) {
+      if (closed) throw new Error("wasm host lane: closed");
+      const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+      if (signal?.aborted) throw abortReason(signal);
+      if (failed) boot();
+      const booting = current;
+      const w = await booting;
+      if (signal?.aborted) throw abortReason(signal);
+      inFlight++;
+      let ended = false;
+      const end = () => {
+        if (ended) return;
+        ended = true;
+        inFlight--;
+        if (inFlight === 0 && lane.maxMemoryBytes !== undefined && current === booting) void checkMemory(w, booting);
+      };
+      const run = workerFetch(w)(input, init);
+      if (!signal) {
+        return run.then(
+          (res) => untilBodyEnds(res, end),
+          (err) => {
+            end();
+            throw err;
+          },
+        );
+      }
+      return new Promise<Response>((resolve, reject) => {
+        const onAbort = () => {
+          end();
+          reject(abortReason(signal));
+          if (current === booting) void replace(w, new Error("wasm host lane: restarted after an abort")).catch(() => {});
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        run.then(
+          // A streamed body is still coming from the busy worker, so an abort until it ends must
+          // still end the worker.
+          (res) =>
+            resolve(
+              untilBodyEnds(res, () => {
+                signal.removeEventListener("abort", onAbort);
+                end();
+              }),
+            ),
+          (err) => {
+            signal.removeEventListener("abort", onAbort);
+            end();
+            reject(err);
+          },
+        );
+      });
+    },
+    worker: () => current,
+    async restart() {
+      const old = await current.catch(() => undefined);
+      await (old ? replace(old, new Error("wasm host lane: restarted")) : boot());
+    },
+    close() {
+      closed = true;
+      void current.then((w) => endWorker(w, new Error("wasm host lane: closed")), () => {});
+    },
+  };
+}
+
+function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("This request was aborted.", "AbortError");
+}

package/src/wasmhost/protocol.ts

@@ -16,7 +16,21 @@ export type HostRequest =
   | { id: number; kind: "mount"; name: string; files: Files }
   | { id: number; kind: "add"; name: string; files: Files }
   | { id: number; kind: "stats" }
-  | { id: number; kind: "unmount"; name: string };
+  | { id: number; kind: "unmount"; name: string }
+  /** Cancels the Go context of http request `target`, if it's still running. */
+  | { id: number; kind: "cancel"; target: number };
+
+/**
+ * Part of an http response, sent when the Go handler flushes (wasmhost's Host.DoStream), before the
+ * request's final HostReply. The first chunk of a response carries its status and headers.
+ */
+export type HostChunk = {
+  id: number;
+  chunk: true;
+  status?: number;
+  headers?: Record<string, string>;
+  body: Uint8Array;
+};
 
 export type HostReply =
   | {

package/src/wasmhost/worker.ts

@@ -6,7 +6,8 @@
 // It is a classic worker, built as an IIFE, because Go's wasm_exec.js is a plain script defining
 // globalThis.Go, which importScripts can load and a module worker cannot. The asset URLs and the
 // namespace come in the worker's query string (?wasm=&exec=&ns=), which startWorker writes.
-import type { Files, HostReply, HostRequest, HostStatus } from "./protocol";
+import type { Files, HostChunk, HostReply, HostRequest, HostStatus } from "./protocol";
+import { workerCache } from "./cache";
 
 interface Exports {
   ready?: () => void;
@@ -15,7 +16,11 @@ interface Exports {
     url: string,
     headers: Record<string, string>,
     body: Uint8Array | null,
+    onChunk?: (c: { status?: number; headers?: Record<string, string>; body: Uint8Array }) => void,
+    id?: number,
   ): Promise<{ status: number; headers: Record<string, string>; body: Uint8Array }>;
+  /** Missing in a wasm built against goapplib before 0.6.7; cancelling is then a no-op. */
+  cancel?(id: number): Promise<void>;
   mount(name: string, files: Files): Promise<void>;
   add(name: string, files: Files): Promise<void>;
   unmount(name: string): Promise<void>;
@@ -39,7 +44,11 @@ const ns = params.get("ns") ?? "wasmhost";
 // The wasm's linear memory, exported by Go as `mem`. It only grows, so its size is the peak so far.
 let memory: WebAssembly.Memory | undefined;
 
-const post = (m: HostStatus | HostReply, transfer: Transferable[] = []) => self.postMessage(m, transfer);
+const post = (m: HostStatus | HostReply | HostChunk, transfer: Transferable[] = []) => self.postMessage(m, transfer);
+
+// Go's wasmhost.BrowserCache finds the cache here (cache.ts).
+const cache = workerCache(ns, (self as unknown as { navigator?: { storage?: { getDirectory?: () => Promise<unknown> } } }).navigator?.storage);
+if (cache) self.wasmhostCache = cache;
 
 async function boot(): Promise<Exports> {
   importScripts(execUrl);
@@ -71,7 +80,14 @@ self.onmessage = async (ev) => {
   try {
     const host = await booted;
     if (req.kind === "http") {
-      const res = await host.http(req.method, req.url, req.headers, req.body);
+      const res = await host.http(
+        req.method,
+        req.url,
+        req.headers,
+        req.body,
+        (c) => post({ id: req.id, chunk: true, ...c }, [c.body.buffer]),
+        req.id,
+      );
       post({ id: req.id, ok: true, status: res.status, headers: res.headers, body: res.body }, [res.body.buffer]);
     } else if (req.kind === "mount") {
       await host.mount(req.name, req.files);
@@ -81,6 +97,9 @@ self.onmessage = async (ev) => {
       post({ id: req.id, ok: true });
     } else if (req.kind === "stats") {
       post({ id: req.id, ok: true, memoryBytes: memory?.buffer.byteLength ?? 0 });
+    } else if (req.kind === "cancel") {
+      await host.cancel?.(req.target);
+      post({ id: req.id, ok: true });
     } else if (req.kind === "unmount") {
       await host.unmount(req.name);
       post({ id: req.id, ok: true });