feat: enhance error handling and support for WebSocket upgrades in request processing

- Added functions to normalize route errors and check for WebSocket upgrade responses.
- Updated runRequestEffect to handle execution context and dispose of resources properly.
- Improved error response generation by normalizing errors before returning them.
- Enhanced runRouteEffect to utilize the new execution context handling.

Author: acoyfellow

worker/effect/runtime.ts

@@ -1,5 +1,5 @@
-import type { Context } from 'hono';
-import { Effect, ManagedRuntime } from 'effect';
+import type { Context, ExecutionContext } from 'hono';
+import { Cause, Exit, ManagedRuntime } from 'effect';
 import type { Env } from '../types';
 import {
   getErrorMessage,
@@ -18,25 +18,67 @@ type RequestServices =
   | import('./services').WorkspaceRepo
   | import('./services').ContainerRuntime;
 
+function isWebSocketUpgradeResponse(value: unknown): boolean {
+  if (!(value instanceof Response)) {
+    return false;
+  }
+  if (value.status === 101) {
+    return true;
+  }
+  return (value as { webSocket?: unknown }).webSocket != null;
+}
+
+/** Effect.runPromise rejects with wrappers; squash to the real tagged error for HTTP mapping. */
+function normalizeRouteError(error: unknown): unknown {
+  if (isAppError(error)) {
+    return error;
+  }
+  if (Cause.isCause(error)) {
+    return Cause.squash(error);
+  }
+  if (error instanceof Error && error.cause !== undefined) {
+    const inner = error.cause;
+    if (Cause.isCause(inner)) {
+      return Cause.squash(inner);
+    }
+    if (isAppError(inner)) {
+      return inner;
+    }
+  }
+  return error;
+}
+
 export async function runRequestEffect<A>(
   env: Env,
-  effect: Effect.Effect<A, AppError, RequestServices>
+  effect: Effect.Effect<A, AppError, RequestServices>,
+  options?: { executionCtx?: ExecutionContext }
 ): Promise<A> {
   const runtime = ManagedRuntime.make(makeRequestLayer(env));
+  const exit = await runtime.runPromiseExit(effect);
 
-  try {
-    return await runtime.runPromise(effect);
-  } finally {
+  if (Exit.isFailure(exit)) {
     await runtime.dispose();
+    throw Cause.squash(exit.cause);
   }
+
+  const value = exit.value;
+
+  if (isWebSocketUpgradeResponse(value) && options?.executionCtx) {
+    options.executionCtx.waitUntil(runtime.dispose());
+    return value;
+  }
+
+  await runtime.dispose();
+  return value;
 }
 
 export function toRouteErrorResponse(c: WorkerContext, error: unknown): Response {
-  const appError = isAppError(error)
-    ? error
+  const normalized = normalizeRouteError(error);
+  const appError = isAppError(normalized)
+    ? normalized
     : new UnexpectedFailure({
         message: 'Internal server error',
-        cause: error,
+        cause: normalized,
       });
   const status = getErrorStatus(appError);
   const message = getErrorMessage(appError);
@@ -54,13 +96,23 @@ export function toRouteErrorResponse(c: WorkerContext, error: unknown): Response
   });
 }
 
+function tryGetExecutionCtx(c: WorkerContext): ExecutionContext | undefined {
+  try {
+    return c.executionCtx;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function runRouteEffect<A>(
   c: WorkerContext,
   effect: Effect.Effect<A, AppError, RequestServices>,
   onSuccess: (value: A) => Response
 ): Promise<Response> {
   try {
-    const value = await runRequestEffect(c.env, effect);
+    const value = await runRequestEffect(c.env, effect, {
+      executionCtx: tryGetExecutionCtx(c),
+    });
     return onSuccess(value);
   } catch (error) {
     return toRouteErrorResponse(c, error);