Let go of idle browser objects while the server is asking

Objects are registered so that the server can keep reading them, and nothing else
is coming to take them away. Pruning only happened when a new event was
dispatched, so a page which went quiet held every object it had ever handed over
- detached nodes included - for the whole of its idle time.

The registry is now swept whenever the server asks it anything, not only when
something is added to it. An object which is being read is not idle, and is kept
as before.

Author: Archmonger

src/js/packages/@reactpy/client/src/event-proxy.ts

@@ -436,6 +436,11 @@ export class EventProxyRegistry {
    *
    * Whatever is dropped here is gone for good as far as the server is concerned: the id
    * it holds keeps working, and keeps answering "not-found".
+   *
+   * This runs whenever the registry is used, not only when something is added to it.
+   * Objects are kept for the server's benefit, so a page which stops dispatching events
+   * still lets go of the ones which have gone idle rather than holding them for their
+   * whole idle time.
    */
   prune(): void {
     const now = this.clock();
@@ -462,6 +467,12 @@ export class EventProxyRegistry {
   handleMessage(message: EventProxyRequest | EventProxyRequestBatch): void {
     if (!message || message.type !== EVENT_PROXY_REQUEST_TYPE) return;
 
+    // Whatever is registered here is being kept alive for the server's benefit, and
+    // nobody else is coming to take it away - so the moment the server asks about them
+    // is the moment to notice which of them have gone stale. Waiting for the next event
+    // to be dispatched would leave detached objects held for their whole idle time.
+    this.prune();
+
     const requests = (message as EventProxyRequestBatch).requests;
     if (!Array.isArray(requests)) {
       const request = message as EventProxyRequest;

src/js/packages/@reactpy/client/tests/event-proxy.test.ts

@@ -906,6 +906,31 @@ test("an object which aged out is answered as not-found", () => {
   expect(replies[0].code).toBe("not-found");
 });
 
+test("answering a request takes the idle objects out with it", () => {
+  // Objects are registered for the server's benefit and nothing else is coming to take
+  // them away, so a page which stops dispatching events used to hold every one of them
+  // for their whole idle time - a detached node is no less detached for nobody having
+  // asked about it in the last minute.
+  const { registry, replies, now } = make_registry();
+  const idle = registry.register(make_event());
+
+  now.value = LIVE_OBJECT_TTL_MS - 1;
+  const busy = registry.register(make_event());
+
+  now.value = LIVE_OBJECT_TTL_MS + 5;
+  registry.handleMessage(
+    request({ requestId: "ask", eventId: busy, path: [] }),
+  );
+
+  expect(replies).toHaveLength(1);
+  expect(replies[0].ok).toBe(true);
+  expect(registry.has(idle)).toBe(
+    false,
+    "the idle one went while nobody watched",
+  );
+  expect(registry.has(busy)).toBe(true, "the one being read is not idle");
+});
+
 test("the cap leaves room for every event a busy page can have in flight", () => {
   const { registry } = make_registry();
   const ids: string[] = [];