improvise/web/worker.js

// The worker half of the standalone deployment (improvise-9x6).
//
// It hosts the authoritative App. Everything it decides is decided in Rust —
// this file only moves strings between `self.onmessage`/`self.postMessage` and
// `WorkerServer::on_message`, which is the same shape `web/app.js` has on the
// main thread and for the same reason: JS here is untested (there is no
// browser in this repository), so the less of it there is, the less can be
// silently wrong.
//
// Two rules it must not break:
//
//   1. Post every reply, in the order the Rust returned them, one message per
//      frame. A `GridUpdate::Cells` that overtakes the labels framing it is
//      DROPPED by the client's fold, not replayed (gotcha 33). Never batch two
//      calls' replies together and never reorder them.
//   2. Await `flush()` after each message. `Storage::delete` is visible to
//      `read`/`list` immediately but only reaches OPFS here (gotcha 28).
//
// Rule 1 is about frames within one call's replies AND about the calls
// themselves, which is why every message is chained onto one tail promise
// below rather than handled by an `async` listener: an `async` listener does
// not serialize. The event loop is free to start the next `message` while an
// earlier one is suspended at an `await`, so two `on_message`/`flush` pairs
// interleave and a later frame's replies can be posted before an earlier
// frame's. The chain is also what makes "frames that arrived before start()
// finished" an ordinary case of the same rule instead of a second code path
// with its own drain loop — and that loop had the race in it twice over,
// since `server` was set before it ran.
//
// The document is named in this worker's own URL — `new
// Worker('worker.js?doc=demo.improv')` — the analogue of the socket server
// naming it in the ws:// path. It is deliberately not a `ClientFrame`: the
// envelope pair is shared with the socket deployment and stays exactly as it
// is (improvise-xks6).

import init, { start } from "./worker-pkg/improvise_worker_server.js";

const params = new URLSearchParams(self.location.search);
const DOC = params.get("doc") || "demo.improv";
// Where the first copy of the document comes from on an origin that has never
// seen one. It is fetched and handed to Rust, which WRITES it through the VFS
// and then reads it back like any other document — not injected past storage.
const SEED = params.get("seed") || "demo.improv";

// Fetch the seed if there is one to fetch. A missing seed is not an error:
// with none, the worker creates an empty model under DOC instead.
async function seedBytes() {
  try {
    const res = await fetch(SEED);
    if (!res.ok) return undefined;
    return new Uint8Array(await res.arrayBuffer());
  } catch (_) {
    return undefined;
  }
}

let server = null;

function post(replies) {
  for (const reply of replies) self.postMessage(reply);
}

async function handle(data) {
  const replies = server.on_message(data);
  post(replies);
  await server.flush();
}

// Startup, and the head of the chain. The client sends its `Viewport` as soon
// as it loads, so frames arrive before this settles; chaining onto it is what
// holds them, in arrival order, without a queue to drain.
const started = (async () => {
  await init();
  server = await start(DOC, await seedBytes());
})();
started.catch((err) => {
  console.error("improvise worker: failed to start", err);
});

// One frame at a time, in arrival order: the listener is deliberately NOT
// `async`. It appends to the chain and returns, so the ordering does not
// depend on when the event loop chooses to resume a suspended listener.
let tail = started.catch(() => {});

self.onmessage = (event) => {
  tail = tail
    .then(async () => {
      // `start()` failed. There is nothing to answer with, and the main
      // thread's handshake watchdog is what tells the user.
      if (!server) return;
      await handle(event.data);
    })
    .catch((err) => {
      // An unhandled rejection inside a `message` listener reaches the
      // devtools console and nothing else. Say which frame it was; the main
      // thread cannot see this and has no way to ask. Caught here rather than
      // left on the chain so one bad frame does not poison every later one.
      console.error("improvise worker: frame rejected", event.data, err);
    });
};