@owlmeans/server-socket 0.1.18-rc.20 → 0.1.18-rc.21

package/README.md

@@ -4,7 +4,7 @@ Server-side WebSocket connection handler and service for OwlMeans backends.
 
 ## Overview
 
-- `handleConnection()` wraps WebSocket business logic — analogous to `handleBody` but for WS connections
+- `connection(protocol, callback)` creates a typed WebSocket binding for one protocol
 - `appendSocketService()` + `createSocketMiddleware()` wire the WebSocket service into a server context
 - Used in viable for real-time thinking journal updates and file watching
 - The `Connection` interface (from `@owlmeans/socket`) is the runtime object passed to your handler
@@ -20,10 +20,12 @@ bun add @owlmeans/server-socket@^0.1.18-rc.17
 Handle a WebSocket connection on an entrypoint route:
 
 ```typescript
-import { handleConnection } from '@owlmeans/server-socket'
+import { connection } from '@owlmeans/server-socket'
+import { bind } from '@owlmeans/server-entrypoint'
 import type { Connection } from '@owlmeans/socket'
+import { appEntrypoints as protocols } from 'my-app-common'
 
-export const watch = handleConnection<Connection>(async (conn, context, req) => {
+const watch = connection(protocols.api.fileWatch, async (conn, context, req) => {
   const ctx = context as Context
   const projectId = req.params.id as string
 
@@ -37,13 +39,16 @@ export const watch = handleConnection<Connection>(async (conn, context, req) =>
     conn.notify('file-update', record)
   })
 })
+
+export const entrypoints = [bind(protocols.api.fileWatch, watch)]
 ```
 
 ## API
 
-### `handleConnection<T>(handler): RefedEntrypointHandler`
+### `connection(protocol, handler): BoundEntrypointHandler`
 
-Wraps a WebSocket handler. The handler receives `(conn: T, ctx, req, res)`.
+Creates a protocol-bound WebSocket handler. The callback receives `(conn, ctx, req, res)` with
+request and response types inferred from the protocol.
 
 ```typescript
 handler: (conn: T, ctx: Context, req: AbstractRequest, res: AbstractResponse) => Promise<void>
@@ -73,7 +78,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.14
+npx @owlmeans/agent-skills@^0.1.18-rc.15
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/server-socket",
-  "version": "0.1.18-rc.20",
-  "generatedAt": "2026-09-10T23:12:07.514Z",
+  "version": "0.1.18-rc.21",
+  "generatedAt": "2026-09-12T08:39:52.732Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/server-socket/SKILL.md

@@ -1,149 +1,27 @@
 ---
 name: server-socket
-description: How to use @owlmeans/server-socket — the Fastify WebSocket carrier that serves entrypoints whose route protocol is SOCKET, handleConnection, guard and gate enforcement on the upgrade, token-on-query authentication and the system close frame. Auto-invoked when importing server socket primitives or wiring WebSocket support.
-user-invocable: false
+description: Bind OwlMeans socket protocol declarations to Fastify WebSocket handlers.
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
 
-# @owlmeans/server-socket
+# Socket protocol handlers
 
-**Layer:** Server
-**Install:** `"@owlmeans/server-socket": "^0.1.18-rc.20"` in `dependencies`
+Declare a socket route and its contract in the shared protocol package. Bind it on the server with
+`connection()` and `bind()`.
 
-The server carrier for `@owlmeans/socket`, mounted on the same Fastify instance
-`@owlmeans/server-api` runs. It supplies the abstract members of the connection model and hands a
-handler a plain `Connection`.
+```ts
+import { bind } from '@owlmeans/server-entrypoint'
+import { connection } from '@owlmeans/server-socket'
 
-## Key Exports
-
-| Export | Description |
-|--------|-------------|
-| `createSocketService(alias?)` | Factory for the WebSocket server service |
-| `appendSocketService(ctx, alias?)` | Register it on the context |
-| `createSocketMiddleware(web?, socket?)` | Loading-stage context middleware that attaches the service to the API server. Marks the config so a re-run does not register twice |
-| `handleConnection(fn)` | Wrap `(conn, ctx, req, res) => Promise<void>` as an entrypoint handler |
-| `SocketService` | Service interface — `update(api: ApiServer)` |
-| `Config` / `Context` | The server config and context types this package expects |
-| Constants | `DEFAULT_ALIAS` (`socket-server`) |
-
-## How a socket call is carried
-
-An entrypoint declared with `socket(...)` carries `RouteProtocols.SOCKET`, and the protocol is what
-decides the carrier. The HTTP server skips those entrypoints; this service claims them, registering
-each at `entrypoint.mount()` on the same Fastify instance with `websocket: true`. So a declaration
-moves between HTTP and a socket by changing its protocol, and neither the handler nor the caller is
-rewritten.
-
-The same enforcement runs first: a `preHandler` hook matches each candidate with
-`entrypoint.route.match(req, entrypoint.mount())`, authorizes it against `getGuards()`, and asserts
-every pair from `getGates()` — inherited guards and gates included — before the connection is handed
-to the handler. A refusal is rendered by the entrypoint's `fixer` when it declares one, so an
-unauthorized upgrade fails the HTTP request rather than opening a socket that answers nothing.
-
-The route's `filter` becomes the Fastify schema for the upgrade request — `query`, `params`,
-`headers` — so a malformed connection query is refused before the handler exists.
-
-## Usage
-
-Wire the carrier once, where the application composes its context:
-
-```typescript
-import { appendSocketService, createSocketMiddleware } from '@owlmeans/server-socket'
-
-appendSocketService(context)
-context.registerMiddleware(createSocketMiddleware())
-```
-
-Declare the entrypoint with `socket()` — the `@owlmeans/route` builder that stamps
-`RouteProtocols.SOCKET` on a backend route — in the package both halves import, so the browser
-dials the very declaration the server binds:
-
-```typescript
-import { entrypoint } from '@owlmeans/entrypoint'
-import { backend, route, socket } from '@owlmeans/route'
-
-export const entrypoints = [
-  entrypoint(route(PROJECT, '/project', backend())),
-  entrypoint(route(PROJECT_STREAM, '/watch', socket(PROJECT))),
-]
-```
-
-Then attach the handler with `elevate`, exactly as for an HTTP entrypoint — the protocol is what
-sends it to this carrier instead of to the HTTP server. Nothing is served until this step runs:
-
-```typescript
-import { elevate } from '@owlmeans/server-entrypoint'
-import { handleConnection } from '@owlmeans/server-socket'
-import { MessageType } from '@owlmeans/socket'
-import type { EventMessage } from '@owlmeans/socket'
-
-elevate(entrypoints, PROJECT_STREAM, handleConnection(async (conn, ctx, req) => {
-  const stop = await subscribeSomewhere(async value => await conn.notify('update', value))
-
-  conn.listen(async message => {
-    const msg = message as EventMessage<{ code: number }>
-    if (typeof message === 'object' && msg.type === MessageType.System && msg.event === 'close') {
-      await stop()
+export const appEntrypoints = [
+  bind(streamEntrypoints.watch, connection(streamEntrypoints.watch,
+    async (connection, context, request) => {
+      await connection.send({ type: 'ready' })
     }
-  })
-}))
+  )),
+]
 ```
 
-**A socket handler never resolves its response.** Resolving sends the value down the socket and,
-with `EntrypointOutcome.Ok`, closes it immediately; rejecting closes it with code 1011 and the
-marshalled error. `handleConnection` returns the response's value only for signature compatibility.
-A long-lived subscription therefore returns without resolving, and lives on the listeners it
-registered.
-
-## Who the connection belongs to
-
-A WebSocket handshake carries no Authorization header a browser can set, so the token travels as
-the `AUTH_QUERY` query parameter. The carrier reads it lazily, on the first frame in either
-direction, and unseals it as an envelope: an `Auth` or `AuthCredentials` payload becomes the
-connection's subject, anything else leaves it anonymous.
-
-That subject is what stamps frames, as `profileId ?? userId`: an arriving frame is given it as
-`recipient` and the service's own name as `sender`, a departing one is given it as `sender`. It is
-the same pair every ownership rule in the framework keys on, so one profile of a multi-profile
-account never reads another's stream.
-
-`conn.authenticate(stage, payload)` runs the in-band sequence instead:
-
-| Stage and payload | Answer |
-|---|---|
-| `Authenticate` with an `AuthToken` | Checked against the context's auth service. Its answer is unsealed as an envelope to become the subject, and the reply carries `Authenticated`. A null answer throws `SocketUnauthorized` |
-| `Authenticate` with an already-minted `Auth` | Taken as the subject as it stands, and answered with the SAME stage — not `Authenticated` |
-| `Authenticated` | Answers the subject already captured, or throws `SocketUnauthorized` when there is none |
-| anything else | `SocketUnsupported('auth-service')` — including a payload at `Authenticate` that is neither of the two above |
-
-## Liveness and shutdown
-
-- A protocol-level ping (the WebSocket control frame) is answered with a pong and goes no further.
-- A JSON `{ type: 'ping' }` frame is answered with a protocol pong and a `{ type: 'pong' }` frame,
-  and is then handed to the connection model like any other frame. Its `type` matches no
-  `MessageType`, so it is routed nowhere, but it still reaches every `conn.listen` listener as an
-  object whose `type` is `'ping'` — a listener has to recognise the frames it wants rather than
-  assume every one it is given is a message.
-- A closing socket reaches the handler as a system frame — `MessageType.System`, `event: 'close'`,
-  payload `{ code }` — delivered to every `conn.listen` listener. It is the only disconnect notice,
-  so every subscription a handler opened is released there.
-- Fastify's `preClose` closes every live connection with code 1001 before the server stops, so a
-  rollout does not leave sockets hanging on a process that is going away.
-
-## Depends On
-
-- `@owlmeans/socket` — `createBasicConnection`, `MessageType`, the error classes
-- `@owlmeans/entrypoint`, `@owlmeans/server-entrypoint` — `getGuards` / `getGates`, `mount()`
-- `@owlmeans/server-api` — the Fastify instance and its request pipeline (`/utils`)
-- `@owlmeans/server-auth` — the auth service the in-band sequence calls
-- `@owlmeans/auth` — `AUTH_QUERY`, `AuthenticationStage`, and the `isAuth` / `isAuthToken` guards
-- `@owlmeans/basic-envelope` — reading the token off the connection query
-- `@owlmeans/context`, `@owlmeans/server-context` — service registration and the config type
-- `@fastify/websocket` (runtime), `fastify` (peer)
-
-## Related
-
-- `socket` — the message model, and the verbs a handler answers with
-- `route` — `socket()`, and what a route's protocol decides
-- `client-socket` — the browser carrier that dials these entrypoints
-- `server-job` — `watchJobs`, a worked handler built on `handleConnection`
+The handler receives a typed connection, context, request and response boundary. Guards and gates
+are inherited from the protocol tree and enforced before the WebSocket handler runs. Do not expose
+Fastify request objects through a shared contract.

package/build/helper.d.ts

@@ -1,7 +1,9 @@
-import type { AbstractRequest, AbstractResponse } from '@owlmeans/entrypoint';
+import type { AbstractRequest, AbstractResponse, EntrypointProtocolDeclaration, HandlerRequest, RequestOf, ResponseOf } from '@owlmeans/entrypoint';
 import type { Context } from '@owlmeans/server-api';
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint';
+import type { BoundEntrypointHandler, RefedEntrypointHandler } from '@owlmeans/server-entrypoint';
 import type { Connection } from '@owlmeans/socket';
 import type { WebSocket } from '@fastify/websocket';
+/** Bind a socket protocol to its connection lifecycle without an alias lookup. */
+export declare const connection: <Protocol extends EntrypointProtocolDeclaration, SocketContext extends Context = Context, SocketConnection extends Connection = Connection>(protocol: Protocol, handler: (connection: SocketConnection, context: SocketContext, request: HandlerRequest<RequestOf<Protocol>>, response: AbstractResponse<ResponseOf<Protocol>>) => Promise<void>) => BoundEntrypointHandler<Protocol>;
 export declare const handleConnection: <T extends Connection = Connection>(handler: (conn: T, ctx: Context, req: AbstractRequest<WebSocket>, res: AbstractResponse<any>) => Promise<void>) => RefedEntrypointHandler<AbstractResponse<any>>;
 //# sourceMappingURL=helper.d.ts.map

package/build/helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAGnD,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EAC/D,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,eAAe,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,KAC3G,sBAAsB,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAUhD,CAAA"}
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EACxG,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAGnD,kFAAkF;AAClF,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,6BAA6B,EAC9C,aAAa,SAAS,OAAO,GAAG,OAAO,EACvC,gBAAgB,SAAS,UAAU,GAAG,UAAU,YAEtC,QAAQ,WACT,CACP,UAAU,EAAE,gBAAgB,EAC5B,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAC5C,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,KAC7C,OAAO,CAAC,IAAI,CAAC,KACjB,sBAAsB,CAAC,QAAQ,CAkBhC,CAAA;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EAC/D,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,eAAe,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,KAC3G,sBAAsB,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAUhD,CAAA"}

package/build/helper.js

@@ -1,5 +1,20 @@
 import { assertContext } from '@owlmeans/context';
 import { makeConnection } from './utils/connection.js';
+/** Bind a socket protocol to its connection lifecycle without an alias lookup. */
+export const connection = (protocol, handler) => ({
+    protocol,
+    bind: ref => async (request, response) => {
+        const context = assertContext(ref.ref?.ctx, protocol.alias);
+        try {
+            await handler(makeConnection(request, context), context, request, response);
+            response.resolve(undefined);
+        }
+        catch (error) {
+            response.reject(error);
+        }
+        return response.value;
+    },
+});
 export const handleConnection = handler => ref => async (req, res) => {
     const ctx = assertContext(ref.ref?.ctx);
     try {

package/build/helper.js.map

@@ -1 +1 @@
-{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAMjD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,MAAM,CAAC,MAAM,gBAAgB,GAEwB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;IACxF,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAY,CAAA;IAClD,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,CAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,GAAG,CAAC,MAAM,CAAC,CAAU,CAAC,CAAA;IACxB,CAAC;IAED,yDAAyD;IACzD,OAAO,GAAG,CAAC,KAAK,CAAA;AAClB,CAAC,CAAA"}
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAQjD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,kFAAkF;AAClF,MAAM,CAAC,MAAM,UAAU,GAAG,CAKxB,QAAkB,EAClB,OAKkB,EACgB,EAAE,CAAC,CAAC;IACtC,QAAQ;IACR,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE;QACvC,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAkB,CAAA;QAC5E,IAAI,CAAC;YACH,MAAM,OAAO,CACX,cAAc,CAAC,OAAqC,EAAE,OAAO,CAAqB,EAClF,OAAO,EACP,OAAyD,EACzD,QAAkD,CACnD,CAAA;YACD,QAAQ,CAAC,OAAO,CAAC,SAAiC,CAAC,CAAA;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,QAAQ,CAAC,MAAM,CAAC,KAAc,CAAC,CAAA;QACjC,CAAC;QAED,OAAO,QAAQ,CAAC,KAAK,CAAA;IACvB,CAAC;CACF,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAEwB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;IACxF,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAY,CAAA;IAClD,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,CAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,GAAG,CAAC,MAAM,CAAC,CAAU,CAAC,CAAA;IACxB,CAAC;IAED,yDAAyD;IACzD,OAAO,GAAG,CAAC,KAAK,CAAA;AAClB,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/server-socket",
-  "version": "0.1.18-rc.20",
+  "version": "0.1.18-rc.21",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -31,15 +31,15 @@
   },
   "dependencies": {
     "@fastify/websocket": "^11.0.1",
-    "@owlmeans/auth": "^0.1.18-rc.11",
-    "@owlmeans/basic-envelope": "^0.1.18-rc.14",
-    "@owlmeans/context": "^0.1.18-rc.10",
-    "@owlmeans/entrypoint": "^0.1.18-rc.13",
-    "@owlmeans/server-api": "^0.1.18-rc.19",
-    "@owlmeans/server-auth": "^0.1.18-rc.20",
-    "@owlmeans/server-context": "^0.1.18-rc.14",
-    "@owlmeans/server-entrypoint": "^0.1.18-rc.13",
-    "@owlmeans/socket": "^0.1.18-rc.11"
+    "@owlmeans/auth": "^0.1.18-rc.12",
+    "@owlmeans/basic-envelope": "^0.1.18-rc.15",
+    "@owlmeans/context": "^0.1.18-rc.11",
+    "@owlmeans/entrypoint": "^0.1.18-rc.14",
+    "@owlmeans/server-api": "^0.1.18-rc.20",
+    "@owlmeans/server-auth": "^0.1.18-rc.21",
+    "@owlmeans/server-context": "^0.1.18-rc.15",
+    "@owlmeans/server-entrypoint": "^0.1.18-rc.14",
+    "@owlmeans/socket": "^0.1.18-rc.12"
   },
   "publishConfig": {
     "access": "public"

package/src/helper.ts

@@ -1,11 +1,46 @@
 import { assertContext } from '@owlmeans/context'
-import type { AbstractRequest, AbstractResponse } from '@owlmeans/entrypoint'
+import type {
+  AbstractRequest, AbstractResponse, EntrypointProtocolDeclaration, HandlerRequest, RequestOf, ResponseOf,
+} from '@owlmeans/entrypoint'
 import type { Context } from '@owlmeans/server-api'
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
+import type { BoundEntrypointHandler, RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
 import type { Connection } from '@owlmeans/socket'
 import type { WebSocket } from '@fastify/websocket'
 import { makeConnection } from './utils/connection.js'
 
+/** Bind a socket protocol to its connection lifecycle without an alias lookup. */
+export const connection = <
+  Protocol extends EntrypointProtocolDeclaration,
+  SocketContext extends Context = Context,
+  SocketConnection extends Connection = Connection,
+>(
+  protocol: Protocol,
+  handler: (
+    connection: SocketConnection,
+    context: SocketContext,
+    request: HandlerRequest<RequestOf<Protocol>>,
+    response: AbstractResponse<ResponseOf<Protocol>>,
+  ) => Promise<void>,
+): BoundEntrypointHandler<Protocol> => ({
+  protocol,
+  bind: ref => async (request, response) => {
+    const context = assertContext(ref.ref?.ctx, protocol.alias) as SocketContext
+    try {
+      await handler(
+        makeConnection(request as AbstractRequest<WebSocket>, context) as SocketConnection,
+        context,
+        request as unknown as HandlerRequest<RequestOf<Protocol>>,
+        response as AbstractResponse<ResponseOf<Protocol>>,
+      )
+      response.resolve(undefined as ResponseOf<Protocol>)
+    } catch (error) {
+      response.reject(error as Error)
+    }
+
+    return response.value
+  },
+})
+
 export const handleConnection: <T extends Connection = Connection>(
   handler: (conn: T, ctx: Context, req: AbstractRequest<WebSocket>, res: AbstractResponse<any>) => Promise<void>
 ) => RefedEntrypointHandler<AbstractResponse<any>> = handler => ref => async (req, res) => {