fix: Drop events raised before the vtree is mounted (hydration race)

## Problem

On server-rendered pages (e.g. haskell-miso.org) the browser console
fills with repeated errors while the wasm app is hydrating:

    Uncaught TypeError: Cannot read properties of null (reading 'type')
        at delegateEvent (ghc_wasm_jsffi.js:1038:13)
        at dispatch (ghc_wasm_jsffi.js:1016:5)

`delegateEvent` reads `obj.type`, where `obj` is the vtree -- and the
vtree is `null`.

## The race

`Miso.Runtime.initialize` does, in program order:

1. `_componentVTree <- newIORef (VTree (Object jsNull))` -- the vtree
   ref starts out null.
2. `delegator _componentDOMRef _componentVTree events ...` -- DOM
   listeners for every delegated event attach to the mount point,
   synchronously, via the FFI.
3. `initialDraw` -- only now is the vtree built and `Hydrate.hydrate`
   run, and only after hydration succeeds is the ref written.

Steps 2 and 3 are not one atomic JS task. The wasm backend runs Haskell
as promise continuations on the browser event loop, yielding at every
JSFFI round-trip and scheduler timeslice. `initialDraw` builds the whole
vtree and walks the whole server-rendered DOM, so the window between
"listeners live" and "vtree written" spans many event-loop turns.

Meanwhile SSR means the page is painted and interactive-looking before
the wasm even finishes loading -- the user is already mousing and
clicking. Every event delivered inside that window runs:

    listener -> getVTree -> readIORef (still jsNull)
             -> delegateEvent(event, null, stack, ...) -> null.type

Mouse events fire in bursts as the cursor crosses elements, hence the
flood of identical errors. The invariant the delegator assumed -- "if my
listeners are installed, the vtree exists" -- only holds in the non-SSR
path, where the first draw paints the DOM before the user can interact.
Hydration breaks it because the DOM (and the user's input stream) exists
before miso does.

## Fix

Short-circuit upstream in `listener` (ts/miso/event.ts): if the vtree
has not been stored yet, drop the event, with a warning in debug mode.
Dropping is semantically correct -- pre-hydration there are no handlers
in the vtree, so those events had no observable behavior to lose.

The Lynx BTS delegator (ts/miso/native/bts/context.ts) bypasses
`listener` and calls `delegateEvent` directly against the same
jsNull-initialized ref, so it gets the identical guard.

Installing the delegator before hydration is kept intentionally:
installing it after would drop the same events anyway (silently, at the
browser level, since no listener exists yet), and early installation
leaves the door open to queueing and replaying pre-hydration events
later.

## Testing

- New regression test in ts/spec/event.spec.ts installs the delegator
  with `getVTree` yielding null and clicks server-rendered markup.
  Listener exceptions do not propagate to the dispatching `.click()` --
  they surface as `error` events on `window` -- so the test captures
  those and asserts none fire. Verified the test fails with exactly the
  reported TypeError when the guard is removed.
- `bun test ts/spec/event.spec.ts ts/spec/native-bts.spec.ts`: 43 pass,
  0 fail.
- `bun run js`: all four shipped bundles (js/miso.js, js/miso.prod.js,
  js/miso-native.js, js/miso-native.prod.js) regenerated and each now
  contains the guard.

Author: dmjio

js/miso-native.js

@@ -865,6 +865,12 @@ function delegator(mount, events, getVTree, debug, context) {
 }
 function listener(e, mount, getVTree, debug, context) {
   getVTree(function(vtree) {
+    if (!vtree) {
+      if (debug) {
+        console.warn("Event received before vtree was mounted, dropping", e);
+      }
+      return;
+    }
     if (Array.isArray(e)) {
       for (const key of e) {
         dispatch(key, vtree, mount, debug, context);

js/miso-native.prod.js

@@ -28,6 +28,15 @@ export function delegator<T> (
 /* the event listener shared by both delegator and undelegator */
 function listener<T>(e: Event | [Event], mount: T, getVTree: ((callback: (vtree: VTree<T>) => void) => void), debug: boolean, context: EventContext<T>): void {
   getVTree(function (vtree: VTree<T>) {
+      /* The delegator's listeners attach before the initial draw / hydration
+         has stored the vtree, so events raised in that window see a null
+         vtree. Drop them: there is nothing to dispatch on yet. */
+      if (!vtree) {
+        if (debug) {
+          console.warn('Event received before vtree was mounted, dropping', e);
+        }
+        return;
+      }
       if (Array.isArray(e)) {
           for (const key of e) {
             dispatch (key, vtree, mount, debug, context);

js/miso.js

@@ -45,6 +45,15 @@ const eventContext : EventContext<NodeId> = {
     context.addEventListener('Miso.events', (m : MessageEvent<ProcessEvent>) => {
       let stack : Array<NodeId> = m.data.stack.map (function (x) { return { nodeId : x }});
       getVTree((vtree: VTree<NodeId>) => {
+        /* The delegator's listeners attach before the initial draw has stored
+           the vtree, so events raised in that window see a null vtree. Drop
+           them: there is nothing to dispatch on yet. */
+        if (!vtree) {
+          if (debug) {
+            console.warn('Event received before vtree was mounted, dropping', m.data.event);
+          }
+          return;
+        }
         return delegateEvent(m.data.event as Event, vtree, stack, debug, eventContext);
       });
     });

js/miso.prod.js

@@ -73,6 +73,31 @@ describe ('Event tests', () => {
 
   });
 
+  test('Should drop events raised before the vtree is mounted (hydration race)', () => {
+    const body = document.body;
+    /* server-rendered markup exists before hydration has produced a vtree */
+    body.innerHTML = '<div><button></button></div>';
+
+    /* exceptions in event listeners don't propagate to the dispatching
+       click(), they surface as 'error' events on window, so capture those */
+    const errors: Array<string> = [];
+    const onError = (e: any) => { errors.push(e.message); };
+    window.addEventListener('error', onError);
+
+    /* the delegator is installed before initialDraw / hydration has written
+       the vtree ref, so getVTree yields null for events in that window */
+    const getVTree = (cb: any) => cb(null);
+    const delegatedEvents: Array<EventCapture> = [{ name: 'click', capture: true }];
+    delegator(body, delegatedEvents, getVTree, true, eventContext);
+
+    (body.querySelector('button') as HTMLElement).click();
+
+    window.removeEventListener('error', onError);
+    /* without the null-vtree guard this captures:
+       "Cannot read properties of null (reading 'type')" */
+    expect(errors).toEqual([]);
+  });
+
   test('Should warn when clicking mount with no target handler (empty stack)', () => {
     const body = document.body;
     const parent = vnode({ tag: 'div', children: [vnode({ tag: 'span' })], events: { captures: {}, bubbles: {} } });