veryfront 0.1.49 → 0.1.51

package/src/src/platform/adapters/runtime/node/http-server.ts

@@ -2,6 +2,7 @@ import * as dntShim from "../../../../../_dnt.shims.js";
 import type { ServeOptions, Server } from "../../base.js";
 import type { NodeHttpServer, WSWebSocket, WSWebSocketServer } from "./types.js";
 import { DEFAULT_PORT } from "../../../compat/constants.js";
+import { TIMEOUT_ERROR } from "../../../../errors/index.js";
 
 const pendingWebSocketUpgrades = new Map<
   string,
@@ -39,15 +40,24 @@ function createRequestId(req: { headers: Record<string, string | string[] | unde
 
 export function registerWebSocketUpgrade(requestId: string): Promise<WSWebSocket> {
   return new Promise((resolve, reject) => {
-    pendingWebSocketUpgrades.set(requestId, { resolve, reject });
-
-    dntShim.setTimeout(() => {
+    const timeoutId = dntShim.setTimeout(() => {
       const pending = pendingWebSocketUpgrades.get(requestId);
       if (!pending) return;
 
       pendingWebSocketUpgrades.delete(requestId);
-      pending.reject(new Error("WebSocket upgrade timed out"));
+      pending.reject(TIMEOUT_ERROR.create({ detail: "WebSocket upgrade timed out" }));
     }, 30000);
+
+    pendingWebSocketUpgrades.set(requestId, {
+      resolve: (ws) => {
+        clearTimeout(timeoutId);
+        resolve(ws);
+      },
+      reject: (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      },
+    });
   });
 }
 
@@ -175,7 +185,7 @@ export async function createNodeServer(
     wsServer?.close();
     wsServer = null;
     server.close();
-  });
+  }, { once: true });
 
   return new Promise((resolve) => {
     server.listen(port, hostname, () => {

package/src/src/platform/adapters/runtime/node/websocket-adapter.ts

@@ -21,12 +21,15 @@ export class NodeServerAdapter implements ServerAdapter {
     const protocol = request.headers.get("sec-websocket-protocol");
     const socket = new NodeWebSocket();
 
-    registerWebSocketUpgrade(key)
-      .then((ws) => socket._attachRealSocket(ws))
-      .catch((error) => {
+    void (async () => {
+      try {
+        const ws = await registerWebSocketUpgrade(key);
+        socket._attachRealSocket(ws);
+      } catch (error) {
         serverLogger.error("WebSocket upgrade failed:", error);
-        socket._emitError(error);
-      });
+        socket._emitError(error instanceof Error ? error : new Error(String(error)));
+      }
+    })();
 
     const headers: Record<string, string> = {
       Upgrade: "websocket",

package/src/src/platform/adapters/runtime/shared/server-lifecycle.ts

@@ -14,7 +14,7 @@ export function createServeHandler(createServer: ServerFactory, setActive: Serve
   };
 }
 
-export async function startManagedServer(
+async function startManagedServer(
   createServer: ServerFactory,
   handler: RequestHandler,
   options: ServeOptions,

package/src/src/platform/adapters/runtime/shared/shared-watcher.ts

@@ -21,10 +21,13 @@ export async function setupNodeFsWatcher(
     const fs = await import("node:fs");
     const fsPromises = await import("node:fs/promises");
 
-    const exists = await fsPromises
-      .access(path)
-      .then(() => true)
-      .catch(() => false);
+    let exists: boolean;
+    try {
+      await fsPromises.access(path);
+      exists = true;
+    } catch {
+      exists = false;
+    }
 
     if (!exists) return;
 

package/src/src/platform/adapters/veryfront-api-client/client.ts

@@ -10,6 +10,11 @@ import { API_CLIENT_ERROR, type VeryfrontAPIConfig } from "./types.js";
 
 const logger = baseLogger.component("veryfront-api-client");
 
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_INITIAL_RETRY_DELAY_MS = 1_000;
+const DEFAULT_MAX_RETRY_DELAY_MS = 10_000;
+const DEFAULT_SEARCH_LIMIT = 100;
+
 /**
  * File context for API operations.
  * - branch: Draft/working copy from a specific branch
@@ -37,9 +42,9 @@ export class VeryfrontApiClient {
 
   constructor(config: VeryfrontAPIConfig) {
     const retryConfig = {
-      maxRetries: config.retry?.maxRetries ?? 3,
-      initialDelay: config.retry?.initialDelay ?? 1000,
-      maxDelay: config.retry?.maxDelay ?? 10000,
+      maxRetries: config.retry?.maxRetries ?? DEFAULT_MAX_RETRIES,
+      initialDelay: config.retry?.initialDelay ?? DEFAULT_INITIAL_RETRY_DELAY_MS,
+      maxDelay: config.retry?.maxDelay ?? DEFAULT_MAX_RETRY_DELAY_MS,
     };
 
     this.config = { ...config, retry: retryConfig };
@@ -350,7 +355,7 @@ export class VeryfrontApiClient {
   }
 
   async searchFiles(pattern: string): Promise<{ id?: string; path: string }[]> {
-    const result = await this.listFiles({ pattern, limit: 100 });
+    const result = await this.listFiles({ pattern, limit: DEFAULT_SEARCH_LIMIT });
     return result.files.map((f) => ({ id: f.id, path: f.path }));
   }
 
@@ -367,7 +372,7 @@ export class VeryfrontApiClient {
   async searchFilesWithContent(
     pattern: string,
   ): Promise<Array<{ path: string; content: string }>> {
-    const result = await this.listFiles({ pattern, limit: 100 });
+    const result = await this.listFiles({ pattern, limit: DEFAULT_SEARCH_LIMIT });
 
     const filesWithContent: Array<{ path: string; content: string }> = [];
     const filesNeedingContent: string[] = [];
@@ -387,7 +392,8 @@ export class VeryfrontApiClient {
         try {
           const content = await this.getFileContent(path);
           return { path, content };
-        } catch {
+        } catch (error) {
+          logger.debug("Failed to fetch file content during search", { path, error });
           return null;
         }
       }),

package/src/src/platform/adapters/veryfront-api-client/operations.ts

@@ -21,6 +21,8 @@ import { SpanNames } from "../../../observability/tracing/span-names.js";
 
 const logger = baseLogger.component("api");
 
+const DEFAULT_PAGE_LIMIT = 100;
+
 export type TokenProvider = () => string;
 
 export interface ListFilesOptions {
@@ -52,7 +54,8 @@ export interface FileDetail {
 }
 
 function buildListParams(options: ListFilesOptions): URLSearchParams {
-  const { cursor, limit = 100, pattern, sortBy = "updated_at", sortOrder = "desc" } = options;
+  const { cursor, limit = DEFAULT_PAGE_LIMIT, pattern, sortBy = "updated_at", sortOrder = "desc" } =
+    options;
 
   const params = new URLSearchParams({
     limit: String(limit),
@@ -175,7 +178,11 @@ export class VeryfrontAPIOperations {
     options: Omit<ListFilesOptions, "cursor"> = {},
   ): Promise<ProjectFile[]> {
     const allFiles = await listAllFiles((cursor) =>
-      this.listBranchFiles(projectRef, branchName, { ...options, cursor, limit: 100 })
+      this.listBranchFiles(projectRef, branchName, {
+        ...options,
+        cursor,
+        limit: DEFAULT_PAGE_LIMIT,
+      })
     );
 
     logger.debug("listAllBranchFiles DONE", {
@@ -250,7 +257,11 @@ export class VeryfrontAPIOperations {
     options: Omit<ListFilesOptions, "cursor"> = {},
   ): Promise<ProjectFile[]> {
     const allFiles = await listAllFiles((cursor) =>
-      this.listEnvironmentFiles(projectRef, environmentName, { ...options, cursor, limit: 100 })
+      this.listEnvironmentFiles(projectRef, environmentName, {
+        ...options,
+        cursor,
+        limit: DEFAULT_PAGE_LIMIT,
+      })
     );
 
     logger.debug("listAllEnvironmentFiles", {
@@ -324,7 +335,7 @@ export class VeryfrontAPIOperations {
     options: Omit<ListFilesOptions, "cursor"> = {},
   ): Promise<ProjectFile[]> {
     return listAllFiles((cursor) =>
-      this.listReleaseFiles(projectRef, version, { ...options, cursor, limit: 100 })
+      this.listReleaseFiles(projectRef, version, { ...options, cursor, limit: DEFAULT_PAGE_LIMIT })
     );
   }
 

package/src/src/platform/adapters/veryfront-api-client/retry-handler.ts

@@ -131,6 +131,7 @@ export async function requestWithRetry(
         timeout: isTimeout,
       });
 
+      // no cleanup needed: one-shot
       await new Promise<void>((resolve) => dntShim.setTimeout(resolve, delay));
     } finally {
       clearTimeout(timeoutId);

package/src/src/platform/cloud/resolver.ts

@@ -0,0 +1,104 @@
+import { getRuntimeConfig, isRuntimeConfigInitialized } from "../../config/index.js";
+import { getApiBaseUrlEnv } from "../../config/env.js";
+import { getCurrentRequestContext } from "../adapters/fs/veryfront/multi-project-adapter.js";
+import { getEnv } from "../compat/process.js";
+
+export const DEFAULT_VERYFRONT_CLOUD_MODEL = "veryfront-cloud/anthropic/claude-sonnet-4-6";
+export const DEFAULT_VERYFRONT_CLOUD_EMBEDDING_MODEL =
+  "veryfront-cloud/openai/text-embedding-3-small";
+
+export interface VeryfrontCloudBootstrap {
+  apiBaseUrl: string;
+  apiToken?: string;
+  projectSlug?: string;
+  serviceLayer?: string;
+  hasRequestContext: boolean;
+  usesVeryfrontFs: boolean;
+}
+
+function getRuntimeBootstrap(): {
+  apiToken?: string;
+  projectSlug?: string;
+  usesVeryfrontFs: boolean;
+} {
+  if (!isRuntimeConfigInitialized()) {
+    return { usesVeryfrontFs: false };
+  }
+
+  const runtimeConfig = getRuntimeConfig();
+
+  return {
+    apiToken: runtimeConfig.fs?.veryfront?.apiToken,
+    projectSlug: runtimeConfig.projectSlug ?? runtimeConfig.fs?.veryfront?.projectSlug,
+    usesVeryfrontFs: runtimeConfig.fs?.type === "veryfront-api",
+  };
+}
+
+function normalizeCloudModelString(value: string | undefined, fallback: string): string {
+  const resolved = value?.trim() || fallback;
+  return resolved.startsWith("veryfront-cloud/") ? resolved : `veryfront-cloud/${resolved}`;
+}
+
+function getResolvedVeryfrontCloudContext(): Omit<VeryfrontCloudBootstrap, "apiBaseUrl"> {
+  const requestContext = getCurrentRequestContext();
+  const runtimeBootstrap = getRuntimeBootstrap();
+
+  return {
+    apiToken: requestContext?.token ??
+      getEnv("VERYFRONT_API_TOKEN") ??
+      runtimeBootstrap.apiToken,
+    projectSlug: requestContext?.projectSlug ??
+      getEnv("VERYFRONT_PROJECT_SLUG") ??
+      runtimeBootstrap.projectSlug,
+    serviceLayer: getEnv("VERYFRONT_SERVICE_LAYER")?.trim().toLowerCase(),
+    hasRequestContext: requestContext !== null,
+    usesVeryfrontFs: runtimeBootstrap.usesVeryfrontFs,
+  };
+}
+
+export function getVeryfrontCloudAuthToken(): string | undefined {
+  return getResolvedVeryfrontCloudContext().apiToken;
+}
+
+export function getVeryfrontCloudProjectSlug(): string | undefined {
+  return getResolvedVeryfrontCloudContext().projectSlug;
+}
+
+export function getVeryfrontCloudBootstrap(): VeryfrontCloudBootstrap {
+  return {
+    apiBaseUrl: getApiBaseUrlEnv(),
+    ...getResolvedVeryfrontCloudContext(),
+  };
+}
+
+export function isVeryfrontCloudEnabled(): boolean {
+  const bootstrap = getVeryfrontCloudBootstrap();
+
+  if (bootstrap.serviceLayer === "local") {
+    return false;
+  }
+
+  if (bootstrap.serviceLayer === "cloud") {
+    return Boolean(bootstrap.apiToken);
+  }
+
+  const hasProjectContext = bootstrap.hasRequestContext ||
+    bootstrap.usesVeryfrontFs ||
+    Boolean(bootstrap.projectSlug);
+
+  return Boolean(bootstrap.apiToken && hasProjectContext);
+}
+
+export function getDefaultVeryfrontCloudModel(): string {
+  return normalizeCloudModelString(
+    getEnv("VERYFRONT_DEFAULT_MODEL"),
+    DEFAULT_VERYFRONT_CLOUD_MODEL,
+  );
+}
+
+export function getDefaultVeryfrontCloudEmbeddingModel(): string {
+  return normalizeCloudModelString(
+    getEnv("VERYFRONT_DEFAULT_EMBEDDING_MODEL"),
+    DEFAULT_VERYFRONT_CLOUD_EMBEDDING_MODEL,
+  );
+}

package/src/src/platform/compat/console/index.ts

@@ -37,7 +37,8 @@ async function loadColors(): Promise<ConsoleStyler> {
   try {
     const mod = await (isDeno ? import("./deno.js") : import("./node.js"));
     _colors = mod.colors;
-  } catch {
+  } catch (_) {
+    /* expected: color module may not be available in all runtimes */
     _colors = fallbackColors;
   }
 

package/src/src/platform/compat/dynamic-import.ts

@@ -8,7 +8,8 @@
  * @module platform/compat
  */
 
-// deno-lint-ignore no-explicit-any
-export const dynamicImport = new Function("specifier", "return import(specifier)") as <T = any>(
+export const dynamicImport = new Function("specifier", "return import(specifier)") as <
+  T = unknown,
+>(
   specifier: string,
 ) => Promise<T>;

package/src/src/platform/compat/esbuild-init.ts

@@ -6,6 +6,7 @@ import * as dntShim from "../../../_dnt.shims.js";
 
 
 import process from "node:process";
+import { serverLogger } from "../../utils/logger/logger.js";
 import { isDenoCompiled } from "./runtime.js";
 import { ESBUILD_VERSION, getEsbuildBinaryName, getVFSBasePath } from "./esbuild-shared.js";
 
@@ -32,8 +33,8 @@ async function findEsbuildInVFS(): Promise<string | null> {
     try {
       const stat = await dntShim.Deno.stat(vfsPath);
       if (stat.isFile) return vfsPath;
-    } catch {
-      // ignore
+    } catch (_) {
+      /* expected: VFS path may not exist in deno compile */
     }
   }
 
@@ -47,8 +48,8 @@ async function extractEsbuildBinary(): Promise<string | null> {
   try {
     const stat = await dntShim.Deno.stat(targetPath);
     if (stat.isFile && stat.mode && (stat.mode & 0o111)) return targetPath;
-  } catch {
-    // doesn't exist
+  } catch (_) {
+    /* expected: cached binary does not exist yet */
   }
 
   const vfsPath = await findEsbuildInVFS();
@@ -57,7 +58,7 @@ async function extractEsbuildBinary(): Promise<string | null> {
   await dntShim.Deno.mkdir(cacheDir, { recursive: true });
   await dntShim.Deno.writeFile(targetPath, await dntShim.Deno.readFile(vfsPath), { mode: 0o755 });
 
-  console.log(`[esbuild] Extracted binary from VFS to ${targetPath}`);
+  serverLogger.info("[esbuild] Extracted binary from VFS", { targetPath });
   return targetPath;
 }
 
@@ -71,6 +72,6 @@ if (!dntShim.Deno.env.get("ESBUILD_BINARY_PATH") && isDenoCompiled) {
       process.env.ESBUILD_BINARY_PATH = binaryPath;
     }
   } catch (error) {
-    console.warn(`[esbuild] Binary extraction failed:`, error);
+    serverLogger.error("[esbuild] Binary extraction failed", error);
   }
 }

package/src/src/platform/compat/esbuild.ts

@@ -9,9 +9,11 @@ import * as dntShim from "../../../_dnt.shims.js";
 export type { BuildOptions, BuildResult, TransformOptions, TransformResult } from "esbuild";
 
 import nodeProcess from "node:process";
+import { serverLogger } from "../../utils/logger/logger.js";
 import { getEnv, setEnv } from "./process.js";
 import { isDenoCompiled } from "./runtime.js";
 import { ESBUILD_VERSION, getEsbuildBinaryName, getVFSBasePath } from "./esbuild-shared.js";
+import { FILE_NOT_FOUND } from "../../errors/index.js";
 
 function getTempDir(): string {
   return getEnv("TMPDIR") ?? getEnv("TEMP") ?? getEnv("TMP") ?? "/tmp";
@@ -29,7 +31,8 @@ async function isFile(path: string): Promise<boolean> {
   try {
     const stat = await dntShim.Deno.stat(path);
     return stat.isFile;
-  } catch {
+  } catch (_) {
+    /* expected: file may not exist */
     return false;
   }
 }
@@ -59,8 +62,8 @@ async function findEsbuildInVFS(): Promise<string | null> {
       const binPath = `${nodeModulesPath}/${entry.name}/bin/esbuild`;
       if (await isFile(binPath)) return binPath;
     }
-  } catch {
-    // Can't read node_modules
+  } catch (_) {
+    /* expected: node_modules directory may not be readable in VFS */
   }
 
   return null;
@@ -73,19 +76,19 @@ async function extractEsbuildBinary(): Promise<string> {
   try {
     const stat = await dntShim.Deno.stat(targetPath);
     if (stat.isFile && stat.mode && (stat.mode & 0o111)) return targetPath;
-  } catch {
-    // Doesn't exist, need to extract
+  } catch (_) {
+    /* expected: cached binary does not exist yet, need to extract */
   }
 
   const vfsPath = await findEsbuildInVFS();
   if (!vfsPath) {
     const vfsBase = getVFSBasePath(new URL(import.meta.url).pathname, getTempDir());
-    throw new Error(
-      `Could not find esbuild binary in deno compile VFS.\n` +
+    throw FILE_NOT_FOUND.create({
+      detail: `Could not find esbuild binary in deno compile VFS.\n` +
         `  Platform: ${getEsbuildBinaryName()}\n` +
         `  VFS base: ${vfsBase}\n` +
         `  Tip: Ensure esbuild is in dependencies and deno compile includes node_modules.`,
-    );
+    });
   }
 
   await dntShim.Deno.mkdir(cacheDir, { recursive: true });
@@ -115,7 +118,7 @@ async function ensureEsbuildBinary(): Promise<void> {
       setEnv("ESBUILD_BINARY_PATH", binaryPath);
       nodeProcess.env.ESBUILD_BINARY_PATH = binaryPath;
     } catch (error) {
-      console.warn(`[esbuild] Binary extraction failed:`, error);
+      serverLogger.error("[esbuild] Binary extraction failed", error);
     } finally {
       setupComplete = true;
     }
@@ -156,10 +159,6 @@ export async function stop(): Promise<void> {
   esbuild.stop();
 }
 
-export function isEsbuildReady(): boolean {
-  return setupComplete;
-}
-
 /** Eager initialization for server startup. */
 export async function initializeEsbuild(): Promise<void> {
   await ensureEsbuildBinary();

package/src/src/platform/compat/fs.ts

@@ -79,30 +79,45 @@ class NodeFileSystem implements FileSystem {
     this.initialized = true;
   }
 
+  private getFs(): NodeFsPromises {
+    if (!this.fs) throw new Error("NodeFileSystem not initialized");
+    return this.fs;
+  }
+
+  private getOs(): typeof import("node:os") {
+    if (!this.os) throw new Error("NodeFileSystem not initialized");
+    return this.os;
+  }
+
+  private getPath(): typeof import("node:path") {
+    if (!this.path) throw new Error("NodeFileSystem not initialized");
+    return this.path;
+  }
+
   async readTextFile(path: string): Promise<string> {
     await this.ensureInitialized();
-    return this.fs!.readFile(path, { encoding: "utf8" }) as Promise<string>;
+    return this.getFs().readFile(path, { encoding: "utf8" }) as Promise<string>;
   }
 
   async readFile(path: string): Promise<Uint8Array> {
     await this.ensureInitialized();
-    return this.fs!.readFile(path) as Promise<Uint8Array>;
+    return this.getFs().readFile(path) as Promise<Uint8Array>;
   }
 
   async writeTextFile(path: string, data: string): Promise<void> {
     await this.ensureInitialized();
-    await this.fs!.writeFile(path, data, { encoding: "utf8" });
+    await this.getFs().writeFile(path, data, { encoding: "utf8" });
   }
 
   async writeFile(path: string, data: Uint8Array): Promise<void> {
     await this.ensureInitialized();
-    await this.fs!.writeFile(path, data);
+    await this.getFs().writeFile(path, data);
   }
 
   async exists(path: string): Promise<boolean> {
     await this.ensureInitialized();
     try {
-      await this.fs!.access(path);
+      await this.getFs().access(path);
       return true;
     } catch (error: unknown) {
       if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return false;
@@ -112,7 +127,7 @@ class NodeFileSystem implements FileSystem {
 
   async stat(path: string): Promise<FileInfo> {
     await this.ensureInitialized();
-    const stat = await this.fs!.stat(path);
+    const stat = await this.getFs().stat(path);
     return {
       isFile: stat.isFile(),
       isDirectory: stat.isDirectory(),
@@ -124,14 +139,14 @@ class NodeFileSystem implements FileSystem {
 
   async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
     await this.ensureInitialized();
-    await this.fs!.mkdir(path, { recursive: options?.recursive ?? false });
+    await this.getFs().mkdir(path, { recursive: options?.recursive ?? false });
   }
 
   async *readDir(
     path: string,
   ): AsyncIterable<{ name: string; isFile: boolean; isDirectory: boolean }> {
     await this.ensureInitialized();
-    const entries = await this.fs!.readdir(path, { withFileTypes: true });
+    const entries = await this.getFs().readdir(path, { withFileTypes: true });
     for (const entry of entries) {
       yield { name: entry.name, isFile: entry.isFile(), isDirectory: entry.isDirectory() };
     }
@@ -140,23 +155,23 @@ class NodeFileSystem implements FileSystem {
   async remove(path: string, options?: { recursive?: boolean }): Promise<void> {
     await this.ensureInitialized();
     const recursive = options?.recursive ?? false;
-    await this.fs!.rm(path, { recursive, force: recursive });
+    await this.getFs().rm(path, { recursive, force: recursive });
   }
 
   async makeTempDir(options?: { prefix?: string }): Promise<string> {
     await this.ensureInitialized();
-    const tempDir = this.path!.join(
-      this.os!.tmpdir(),
+    const tempDir = this.getPath().join(
+      this.getOs().tmpdir(),
       `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`,
     );
-    await this.fs!.mkdir(tempDir, { recursive: true });
+    await this.getFs().mkdir(tempDir, { recursive: true });
     return tempDir;
   }
 
   async chmod(path: string, mode: number): Promise<void> {
     await this.ensureInitialized();
     try {
-      await this.fs!.chmod(path, mode);
+      await this.getFs().chmod(path, mode);
     } catch {
       // Ignore errors on Windows where chmod is not fully supported
     }
@@ -236,8 +251,8 @@ class DenoFileSystem implements FileSystem {
     try {
       // @ts-ignore - Deno global
       await dntShim.Deno.chmod(path, mode);
-    } catch {
-      // Ignore errors on Windows where chmod is not fully supported
+    } catch (_) {
+      /* expected: chmod is not fully supported on Windows */
     }
   }
 }

package/src/src/platform/compat/http/node-server.ts

@@ -19,7 +19,8 @@ export class NodeHttpServer implements HttpServer {
     try {
       this.http = (await import("node:http")) as NodeHttpModule;
       this.url = (await import("node:url")) as NodeUrlModule;
-    } catch {
+    } catch (_) {
+      /* expected: node:http/node:url not available in non-Node runtimes */
       throw toError(
         createError({
           type: "not_supported",
@@ -67,7 +68,8 @@ export class NodeHttpServer implements HttpServer {
           }
 
           res.end();
-        } catch {
+        } catch (_error) {
+          /* Request handler error - respond with 500 */
           res.statusCode = 500;
           res.end("Internal Server Error");
         }
@@ -86,7 +88,7 @@ export class NodeHttpServer implements HttpServer {
 
       options.signal?.addEventListener("abort", () => {
         server.close();
-      });
+      }, { once: true });
     });
   }
 

package/src/src/platform/compat/http/responses.ts

@@ -78,7 +78,8 @@ export function jsonResponse<T>(
       status,
       headers,
     });
-  } catch {
+  } catch (_) {
+    /* expected: JSON.stringify may fail on circular or non-serializable data */
     return errorResponse(
       HttpStatus.INTERNAL_SERVER_ERROR,
       "Failed to serialize response data",
@@ -220,7 +221,8 @@ function isValidRedirectUrl(url: string): boolean {
     }
 
     return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
+  } catch (_) {
+    /* expected: URL parsing fails for malformed URLs */
     return false;
   }
 }

package/src/src/platform/compat/http/websocket.ts

@@ -1,16 +1,17 @@
 import * as dntShim from "../../../../_dnt.shims.js";
 import { isDeno } from "../runtime.js";
 import type { WebSocketUpgradeOptions, WebSocketUpgradeResult } from "./types.js";
+import { NOT_SUPPORTED } from "../../../errors/index.js";
 
 export function upgradeWebSocket(
   request: dntShim.Request,
   options?: WebSocketUpgradeOptions,
 ): WebSocketUpgradeResult {
   if (!isDeno) {
-    throw new Error(
-      "WebSocket upgrade on Node.js requires server-level handling. " +
+    throw NOT_SUPPORTED.create({
+      detail: "WebSocket upgrade on Node.js requires server-level handling. " +
         "Use a WebSocket library like 'ws' with server.on('upgrade').",
-    );
+    });
   }
 
   return upgradeWebSocketDeno(request, options);