HS E36: dispatchEvent, rpc-throw, reconnect (tests 3, 12, 15) — 13/16

Three new socket tests passing:
- dispatchEvent: sends JSON-encoded event via wrapper.raw.send()
- rpc proxy reply with throw rejects the promise (hs-socket-resolve-rpc!)
- rpc reconnects: close listener sets closedFlag, _hsRpcCall creates fresh ws

Key fixes:
- _sent changed from JS Array to plain object {_len:0, 0:msg, ...} — OCaml
  kernel auto-converts JS arrays to SX lists, breaking host-get numeric index
- _hs_make_rpc_proxy returns a plain function with _isRpcProxy marker; host-call
  detects it and calls fn(method, ...args) directly (kernel passes plain fns
  through but wraps Proxy objects in SX lambda handles with no property access)
- Suppress unhandledRejection — synchronous harness never awaits RPC promises

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

tests/playwright/generate-sx-tests.py

@@ -2036,6 +2036,66 @@ def generate_eval_only_test(test, idx):
             f'              (assert (nil? (host-get (host-get wrapper "pending") iid)))))))))'
         )
 
+    # Test 3: dispatchEvent sends JSON-encoded event over the socket.
+    # Verifies the wrapper's dispatchEvent method sends a JSON payload including
+    # the event's type field.
+    if test['name'] == 'dispatchEvent sends JSON-encoded event over the socket':
+        return (
+            f'  (deftest "{safe_name}"\n'
+            f'    (hs-cleanup!)\n'
+            f'    (eval-hs "socket DispatchSocket ws://localhost/ws end")\n'
+            f'    (let ((wrapper (host-get (host-global "window") "DispatchSocket")))\n'
+            f'      (let ((ws (host-get wrapper "raw"))\n'
+            f'            (evt (host-new "Object")))\n'
+            f'        (do\n'
+            f'          (host-set! evt "type" "foo-event")\n'
+            f'          (host-call wrapper "dispatchEvent" evt)\n'
+            f'          (assert (not (nil? (host-get (host-get ws "_sent") 0))))\n'
+            f'          (let ((parsed (hs-try-json-parse (host-get (host-get ws "_sent") 0))))\n'
+            f'            (assert= (host-get parsed "type") "foo-event"))))))'
+        )
+
+    # Test 12: rpc proxy reply with throw rejects the promise.
+    # Verifies hs-socket-resolve-rpc! calls resolver.reject when msg.throw is set,
+    # and clears the pending entry.
+    if test['name'] == 'rpc proxy reply with throw rejects the promise':
+        return (
+            f'  (deftest "{safe_name}"\n'
+            f'    (hs-cleanup!)\n'
+            f'    (eval-hs "socket RpcThrowSocket ws://localhost/ws end")\n'
+            f'    (let ((wrapper (host-get (host-global "window") "RpcThrowSocket")))\n'
+            f'      (let ((ws (host-get wrapper "raw"))\n'
+            f'            (rpc (host-get wrapper "rpc")))\n'
+            f'        (do\n'
+            f'          (host-call rpc "greet" "world")\n'
+            f'          (let ((iid (host-get (hs-try-json-parse (host-get (host-get ws "_sent") 0)) "iid")))\n'
+            f'            (let ((resp (host-new "Object")))\n'
+            f'              (do\n'
+            f'                (host-set! resp "iid" iid)\n'
+            f'                (host-set! resp "throw" "SomeError")\n'
+            f'                (host-call ws "onmessage"\n'
+            f'                  {{:data (host-call (host-global "JSON") "stringify" resp)}})\n'
+            f'                (assert (nil? (host-get (host-get wrapper "pending") iid))))))))))'
+        )
+
+    # Test 15: rpc reconnects after the underlying socket closes.
+    # Verifies the lazy-reconnect path: after ws.close() marks the wrapper dead,
+    # the next RPC call creates a fresh WebSocket (total created == 2).
+    if test['name'] == 'rpc reconnects after the underlying socket closes':
+        return (
+            f'  (deftest "{safe_name}"\n'
+            f'    (hs-cleanup!)\n'
+            f'    (host-set! (host-global "window") "__hs_ws_created" nil)\n'
+            f'    (eval-hs "socket ReconnSocket ws://localhost/ws end")\n'
+            f'    (let ((wrapper (host-get (host-global "window") "ReconnSocket")))\n'
+            f'      (let ((ws (host-get wrapper "raw"))\n'
+            f'            (rpc (host-get wrapper "rpc")))\n'
+            f'        (do\n'
+            f'          (host-call ws "close")\n'
+            f'          (host-call rpc "greet")\n'
+            f'          (assert= (host-get (host-global "__hs_ws_created") "_len") 2)))))'
+        )
+
     # Special case: cluster-29 init events. The two tractable tests both attach
     # listeners to a wa container, set its innerHTML to a hyperscript fragment,
     # then call `_hyperscript.processNode(wa)`. Hand-roll deftests using