Edward Langley
36ade35240
E2E and integration tests are rare and pin boundary contracts; unit tests assume those contracts and test between them (user, 2026-09-20). The browser half has four boundaries — RenderModel→DOM, JS→wasm, page→peer, worker→OPFS — and everything between them needed no browser at all. `web/shell.js` and `web/serial.js` are the seams: pure modules that RETURN A DESCRIPTION rather than take a DOM double. `gridPlan(model)` answers every question `gridTable` used to answer while creating elements — the data-row index across group headers, what a group header spans, a null group label against an empty one, an empty edit buffer against no editor — and `app.js` is now a loop that builds elements from it. Painting stays untested by Node; what to paint stopped being untestable. 26 tests in `node --test web/tests` (0.12s, no Rust toolchain, no wasm bundle, no npm install), plus three in `web/tests/bundle/` that read the generated .d.ts and so run in the browser job. Playwright goes from 29 tests/36.9s to 16/15.5s on one machine: `widgets.spec.js` and `pointer.spec.js` are gone, replaced by `contract.spec.js`, which asserts that EVERY field the render model projects reaches the screen. The four widgets those specs were written for were one failure at one boundary, and one assertion catches the fifth. It caught it: `doc_name`/`doc_dirty`/`doc_stored_as` reach no element (improvise-5jna, already open). They are named in `UNPAINTED` with the ticket, so the list is the debt written down rather than an exemption. Thirteen faults injected into the Node suite and eight into the served page, each watched to fail the test it names; the last of those was strengthened because the first version passed. `web/assemble.sh` grew an import-completeness guard whose own first version was blind to the multi-line import it exists for. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
20 lines
953 B
JavaScript
20 lines
953 B
JavaScript
// The one rule `web/worker.js` exists to keep: one frame at a time, in arrival
|
|
// order. No DOM, no worker globals — context/code/clients.md.
|
|
|
|
/** Chain every arrival onto one tail promise, starting from `head`.
|
|
*
|
|
* 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
|
|
* handler runs interleave and a later frame's replies can be posted before an
|
|
* earlier frame's — which the client's fold answers by DROPPING the overtaken
|
|
* update, not by replaying it. Chaining is also what makes "frames that
|
|
* arrived before `start()` finished" an ordinary case of this rule rather
|
|
* than a drain loop with the race in it twice over. */
|
|
export function serialize(head, handler, onError) {
|
|
let tail = head.catch(() => {});
|
|
return (value) => {
|
|
tail = tail.then(() => handler(value)).catch((err) => onError(err, value));
|
|
return tail;
|
|
};
|
|
}
|