perf(ext/websocket): efficient event kind serialization (#18509)

Use u16 to represent the kind of event (0 - 6) & event code > 6 is
treated as the close code. This way we can represent all events + the
close code in a single JS number. This is safe because (as per RFC 6455)
close code from 0-999 are reserved & not used.

| name | avg msg/sec/core |
| --- | --- |
| deno_main | `127820.750000` |
| deno #18506 | `140079.000000` |
| deno #18506 + this | `150104.250000` |

1 files changed, 29 insertions, 14 deletions

diff --git a/ext/websocket/02_websocketstream.js b/ext/websocket/02_websocketstream.js
index 0a3aeb192..6e487f0b7 100644
--- a/ext/websocket/02_websocketstream.js
+++ b/ext/websocket/02_websocketstream.js
@@ -167,12 +167,13 @@ class WebSocketStream {
                 PromisePrototypeThen(
                   (async () => {
                     while (true) {
-                      const { kind } = await core.opAsync(
+                      const { 0: kind } = await core.opAsync(
                         "op_ws_next_event",
                         create.rid,
                       );
 
-                      if (kind === "close") {
+                      if (kind > 6) {
+                        /* close */
                         break;
                       }
                     }
@@ -237,37 +238,51 @@ class WebSocketStream {
               },
             });
             const pull = async (controller) => {
-              const { kind, value } = await core.opAsync(
+              const { 0: kind, 1: value } = await core.opAsync(
                 "op_ws_next_event",
                 this[_rid],
               );
 
               switch (kind) {
-                case "string": {
+                case 0:
+                case 1: {
+                  /* string */
+                  /* binary */
                   controller.enqueue(value);
                   break;
                 }
-                case "binary": {
-                  controller.enqueue(value);
+                case 5: {
+                  /* error */
+                  const err = new Error(value);
+                  this[_closed].reject(err);
+                  controller.error(err);
+                  core.tryClose(this[_rid]);
                   break;
                 }
-                case "ping": {
+                case 3: {
+                  /* ping */
                   await core.opAsync("op_ws_send", this[_rid], {
                     kind: "pong",
                   });
                   await pull(controller);
                   break;
                 }
-                case "closed":
-                case "close": {
-                  this[_closed].resolve(value);
+                case 2: {
+                  /* pong */
+                  break;
+                }
+                case 6: {
+                  /* closed */
+                  this[_closed].resolve(undefined);
                   core.tryClose(this[_rid]);
                   break;
                 }
-                case "error": {
-                  const err = new Error(value);
-                  this[_closed].reject(err);
-                  controller.error(err);
+                default: {
+                  /* close */
+                  this[_closed].resolve({
+                    code: kind,
+                    reason: value,
+                  });
                   core.tryClose(this[_rid]);
                   break;
                 }