veryfront 0.1.73 → 0.1.74

package/src/cli/commands/knowledge/command.ts

@@ -62,7 +62,7 @@ type DownloadResult = { uploadPath: string; localPath: string; bytes?: number };
 const KnowledgeIngestArgsSchema = z.object({
   projectSlug: z.string().optional(),
   projectDir: z.string().optional(),
-  source: z.string().optional(),
+  sources: z.array(z.string()).default([]),
   path: z.string().optional(),
   all: z.boolean().default(false),
   recursive: z.boolean().default(false),
@@ -72,6 +72,44 @@ const KnowledgeIngestArgsSchema = z.object({
   slug: z.string().optional(),
   json: z.boolean().default(false),
   quiet: z.boolean().default(false),
+}).superRefine((value, ctx) => {
+  const hasExplicitSources = value.sources.length > 0;
+  const hasPath = typeof value.path === "string" && value.path.length > 0;
+
+  if (hasExplicitSources && (hasPath || value.all)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Use either explicit source paths or --path with --all, not both.",
+    });
+  }
+
+  if (!hasExplicitSources && !hasPath && !value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provide one or more source paths or use --path with --all.",
+    });
+  }
+
+  if (hasPath && !value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--path requires --all.",
+    });
+  }
+
+  if (!hasPath && value.all) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--all requires --path.",
+    });
+  }
+
+  if (value.slug && value.sources.length !== 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--slug can only be used with a single explicit source.",
+    });
+  }
 });
 
 export type KnowledgeIngestOptions = z.infer<typeof KnowledgeIngestArgsSchema>;
@@ -97,7 +135,7 @@ function showKnowledgeUsage(): void {
 Veryfront Knowledge
 
 Usage:
-  veryfront knowledge ingest <source> [options]
+  veryfront knowledge ingest <source...> [options]
   veryfront knowledge ingest --path <prefix-or-dir> --all [options]
 
 Subcommands:
@@ -111,7 +149,7 @@ export function parseKnowledgeIngestArgs(
   return KnowledgeIngestArgsSchema.safeParse({
     projectSlug: getStringArg(args, "project", "p", "project-slug"),
     projectDir: getStringArg(args, "project-dir", "dir", "d"),
-    source: typeof args._[2] === "string" ? args._[2] : undefined,
+    sources: args._.slice(2).filter((value): value is string => typeof value === "string"),
     path: getStringArg(args, "path"),
     all: getBooleanArg(args, "all"),
     recursive: getBooleanArg(args, "recursive"),
@@ -273,6 +311,7 @@ export async function runKnowledgeParser(input: {
   description?: string;
   slug?: string;
   sourceReference?: string;
+  env?: Record<string, string>;
 }): Promise<KnowledgeParserResult> {
   const tempDir = await dntShim.Deno.makeTempDir({ prefix: "veryfront-knowledge-parser-" });
   const inputJsonPath = `${tempDir}/input.json`;
@@ -296,6 +335,7 @@ export async function runKnowledgeParser(input: {
     try {
       result = await new dntShim.Deno.Command("python3", {
         args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
+        ...(input.env ? { env: input.env } : {}),
         stdout: "piped",
         stderr: "piped",
       }).output();
@@ -321,7 +361,7 @@ export async function runKnowledgeParser(input: {
 }
 
 export async function collectKnowledgeSources(
-  options: Pick<KnowledgeIngestOptions, "source" | "path" | "all" | "recursive">,
+  options: Pick<KnowledgeIngestOptions, "sources" | "path" | "all" | "recursive">,
   deps: {
     client: ApiClient;
     projectSlug: string;
@@ -330,29 +370,68 @@ export async function collectKnowledgeSources(
 ): Promise<KnowledgeSource[]> {
   const fs = createFileSystem();
 
-  if (options.source) {
-    if (!isProjectUploadReference(options.source) && await fs.exists(options.source)) {
-      const localFiles = await collectLocalFiles(options.source, options.recursive);
-      if (!localFiles.length) throw new Error(`No supported files found at ${options.source}`);
-      return localFiles.map((localPath) => ({ kind: "local", input: options.source!, localPath }));
+  if (options.sources.length > 0) {
+    const explicitSources: Array<
+      | { kind: "local"; sources: KnowledgeSource[] }
+      | { kind: "upload"; input: string; uploadPath: string }
+    > = [];
+    const uploadTargets: string[] = [];
+
+    for (const input of options.sources) {
+      if (!isProjectUploadReference(input) && await fs.exists(input)) {
+        const localFiles = await collectLocalFiles(input, options.recursive);
+        if (!localFiles.length) throw new Error(`No supported files found at ${input}`);
+        explicitSources.push({
+          kind: "local",
+          sources: localFiles.map((localPath) => ({ kind: "local", input, localPath })),
+        });
+        continue;
+      }
+
+      if (isLikelyLocalPath(input)) {
+        throw new Error(`Local file not found: ${input}`);
+      }
+
+      const uploadPath = normalizeProjectUploadPath(input);
+      explicitSources.push({ kind: "upload", input, uploadPath });
+      uploadTargets.push(uploadPath);
+    }
+
+    const downloads = uploadTargets.length > 0 ? await deps.downloadUploads(uploadTargets) : [];
+    const downloadsByPath = new Map<string, DownloadResult[]>();
+
+    for (const download of downloads) {
+      const existing = downloadsByPath.get(download.uploadPath) ?? [];
+      existing.push(download);
+      downloadsByPath.set(download.uploadPath, existing);
     }
 
-    if (isLikelyLocalPath(options.source)) {
-      throw new Error(`Local file not found: ${options.source}`);
+    const resolvedSources: KnowledgeSource[] = [];
+    for (const source of explicitSources) {
+      if (source.kind === "local") {
+        resolvedSources.push(...source.sources);
+        continue;
+      }
+
+      const matchingDownloads = downloadsByPath.get(source.uploadPath);
+      const download = matchingDownloads?.shift();
+      if (!download) {
+        throw new Error(`Upload not found: ${formatKnowledgeUploadSource(source.uploadPath)}`);
+      }
+
+      resolvedSources.push({
+        kind: "upload",
+        input: source.input,
+        uploadPath: download.uploadPath,
+        localPath: download.localPath,
+      });
     }
 
-    const uploadPath = normalizeProjectUploadPath(options.source);
-    const downloads = await deps.downloadUploads([uploadPath]);
-    return downloads.map((download) => ({
-      kind: "upload",
-      input: options.source!,
-      uploadPath: download.uploadPath,
-      localPath: download.localPath,
-    }));
+    return resolvedSources;
   }
 
   if (!options.path || !options.all) {
-    throw new Error("Provide a source path or use --path with --all.");
+    throw new Error("Provide one or more source paths or use --path with --all.");
   }
 
   if (!isProjectUploadReference(options.path) && await fs.exists(options.path)) {
@@ -407,7 +486,11 @@ export async function ingestResolvedSources(
     uploadKnowledgeFile: (remotePath: string, localPath: string) => Promise<{ path: string }>;
   },
 ): Promise<KnowledgeIngestFileResult[]> {
-  const slugs = options.slug && sources.length === 1 ? [options.slug] : ensureUniqueSlugs(sources);
+  if (options.slug && sources.length !== 1) {
+    throw new Error("--slug can only be used with a single explicit source.");
+  }
+
+  const slugs = options.slug ? [options.slug] : ensureUniqueSlugs(sources);
   const results: KnowledgeIngestFileResult[] = [];
 
   for (const [index, source] of sources.entries()) {

package/src/cli/commands/knowledge/parser-source.ts

@@ -3,6 +3,7 @@ import argparse
 import csv
 import json
 import re
+import subprocess
 from datetime import date
 from pathlib import Path
 from typing import Any, Optional
@@ -71,6 +72,107 @@ def build_frontmatter(source: str, source_type: str, description: str) -> str:
     ])
 
 
+def metadata_int(metadata: dict[str, Any], *keys: str) -> Optional[int]:
+    for key in keys:
+        value = metadata.get(key)
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value
+    return None
+
+
+def metadata_string_list(metadata: dict[str, Any], *keys: str) -> Optional[list[str]]:
+    for key in keys:
+        value = metadata.get(key)
+        if isinstance(value, list) and all(isinstance(item, str) for item in value):
+            return value
+    return None
+
+
+def build_kreuzberg_stats(source_type: str, content: str, metadata: dict[str, Any]):
+    stats: dict[str, Any] = {
+        "characters": len(content),
+        "lines": len(content.splitlines()) if content else 0,
+        "engine": "kreuzberg",
+    }
+
+    if isinstance(metadata.get("mime_type"), str):
+        stats["mime_type"] = metadata["mime_type"]
+
+    if source_type == "pdf":
+        stats["pages"] = metadata_int(metadata, "page_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type in {"xlsx", "xls"}:
+        stats["sheets"] = metadata_int(metadata, "sheet_count") or 0
+        stats["rows"] = metadata_int(metadata, "row_count") or 0
+        stats["sheet_names"] = metadata_string_list(metadata, "sheet_names") or []
+    elif source_type == "docx":
+        stats["paragraphs"] = metadata_int(metadata, "paragraph_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type == "pptx":
+        stats["slides"] = metadata_int(metadata, "slide_count", "page_count") or 0
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+    elif source_type == "html":
+        stats["tables"] = metadata_int(metadata, "table_count") or 0
+
+    return stats
+
+
+def parse_with_kreuzberg(path: str, source_type: str):
+    warnings: list[str] = []
+    completed = subprocess.run(
+        [
+            "kreuzberg",
+            "extract",
+            path,
+            "--format",
+            "json",
+            "--output-format",
+            "markdown",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip() or f"exit code {completed.returncode}"
+        raise RuntimeError(f"kreuzberg extract failed: {detail}")
+
+    try:
+        payload = json.loads(completed.stdout)
+    except json.JSONDecodeError as error:
+        raise RuntimeError(f"kreuzberg extract returned invalid JSON: {error}") from error
+
+    content = payload.get("content", "")
+    if not isinstance(content, str):
+        raise RuntimeError("kreuzberg extract did not return string content")
+
+    metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
+    normalized_content = clean_text(content)
+    stats = build_kreuzberg_stats(source_type, normalized_content, metadata)
+
+    return normalized_content or "_No extractable text found in document._", stats, warnings
+
+
+def prefer_kreuzberg(source_type: str, fallback_parser):
+    def parser(path: str):
+        try:
+            return parse_with_kreuzberg(path, source_type)
+        except FileNotFoundError as error:
+            if getattr(error, "filename", "") == "kreuzberg":
+                return fallback_parser(path)
+            raise
+        except RuntimeError as error:
+            content, stats, warnings = fallback_parser(path)
+            warnings.append(
+                "kreuzberg extraction failed; fell back to the built-in parser: "
+                + str(error)
+            )
+            return content, stats, warnings
+
+    return parser
+
+
 def parse_csv_like(path: str, delimiter: str = ","):
     warnings: list[str] = []
     with open(path, newline="", encoding="utf-8-sig") as file:
@@ -305,18 +407,19 @@ def parse_json(path: str):
 def select_parser(path: Path):
     ext = path.suffix.lower()
     if ext == ".pdf":
-        return "pdf", parse_pdf
+        return "pdf", prefer_kreuzberg("pdf", parse_pdf)
     if ext in {".csv", ".tsv"}:
         delimiter = "\t" if ext == ".tsv" else ","
         return ext.lstrip("."), lambda file_path: parse_csv_like(file_path, delimiter)
     if ext in {".xlsx", ".xls"}:
-        return ext.lstrip("."), parse_excel
+        source_type = ext.lstrip(".")
+        return source_type, prefer_kreuzberg(source_type, parse_excel)
     if ext == ".docx":
-        return "docx", parse_docx
+        return "docx", prefer_kreuzberg("docx", parse_docx)
     if ext == ".pptx":
-        return "pptx", parse_pptx
+        return "pptx", prefer_kreuzberg("pptx", parse_pptx)
     if ext in {".html", ".htm"}:
-        return "html", parse_html
+        return "html", prefer_kreuzberg("html", parse_html)
     if ext in {".txt", ".md", ".mdx"}:
         return ext.lstrip("."), parse_text
     if ext == ".json":
@@ -325,6 +428,8 @@ def select_parser(path: Path):
 
 
 def build_summary(source_type: str, stats: dict[str, Any]) -> str:
+    if stats.get("engine") == "kreuzberg":
+        return f"Converted {source_type.upper()} to markdown ({stats.get('characters', 0)} chars)."
     if source_type in {"csv", "tsv"}:
         return f"Parsed {stats.get('rows', 0)} rows across {stats.get('columns', 0)} columns."
     if source_type in {"xlsx", "xls"}:

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.73",
+  "version": "0.1.74",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/server/handlers/request/ssr/ssr.handler.ts

@@ -26,7 +26,11 @@ import { serverLogger } from "../../../../utils/index.js";
 import { endRequest, startRequest } from "../../../../utils/index.js";
 import { tryNotFoundFallback } from "./not-found-fallback.js";
 import { tryErrorPageFallback } from "./error-page-fallback.js";
-import { type SSRRenderResult, SSRService } from "../../../services/rendering/ssr.service.js";
+import {
+  type SSRRenderResult,
+  SSRService,
+  type SSRServiceLike,
+} from "../../../services/rendering/ssr.service.js";
 import { ErrorPages } from "../../../utils/error-html.js";
 import { buildSSRResponse } from "./ssr-response-builder.js";
 
@@ -62,7 +66,12 @@ export class SSRHandler extends BaseHandler {
     patterns: [{ pattern: /^(?!\/_).*/, method: ["GET", "HEAD"] }],
   };
 
-  private ssrService = new SSRService();
+  private ssrService: SSRServiceLike;
+
+  constructor(ssrService?: SSRServiceLike) {
+    super();
+    this.ssrService = ssrService ?? new SSRService();
+  }
 
   handle(req: dntShim.Request, ctx: HandlerContext): Promise<HandlerResult> {
     const url = new URL(req.url);

package/src/src/server/runtime-handler/adapter-factory.ts

@@ -15,7 +15,11 @@ import { isExtendedFSAdapter } from "../../platform/adapters/fs/wrapper.js";
 import { getConfig } from "../../config/loader.js";
 import type { VeryfrontConfig } from "../../config/index.js";
 import { timeAsync } from "./request-lifecycle.js";
-import { findLocalProjectPath, localAdapterCache } from "./local-project-discovery.js";
+import {
+  defaultDiscoveryCache,
+  findLocalProjectPath,
+  type ProjectDiscoveryCache,
+} from "./local-project-discovery.js";
 import type { ParsedDomain } from "../utils/domain-parser.js";
 
 const baseLogger = getBaseLogger("SERVER");
@@ -60,6 +64,8 @@ interface AdapterResolutionOptions {
   headerProjectPath: string | undefined;
   /** Whether running in proxy mode */
   isProxyMode: boolean;
+  /** Optional injectable cache (defaults to module-level singleton) */
+  cache?: ProjectDiscoveryCache;
 }
 
 /**
@@ -71,6 +77,8 @@ interface AdapterResolutionOptions {
 export async function resolveAdapter(
   opts: AdapterResolutionOptions,
 ): Promise<AdapterResolutionResult> {
+  const cache = opts.cache ?? defaultDiscoveryCache;
+
   let effectiveProjectDir = opts.projectDir;
   let effectiveAdapter = opts.adapter;
   let effectiveConfig = opts.config;
@@ -81,7 +89,7 @@ export async function resolveAdapter(
   const trustedHeaderProjectPath = opts.isProxyMode ? opts.headerProjectPath : undefined;
   const shouldCheckLocalPath = opts.projectSlug && (!opts.isProxyMode || trustedHeaderProjectPath);
   const localProjectPath = shouldCheckLocalPath
-    ? await findLocalProjectPath(opts.projectSlug!, opts.adapter, trustedHeaderProjectPath)
+    ? await findLocalProjectPath(opts.projectSlug!, opts.adapter, trustedHeaderProjectPath, cache)
     : undefined;
 
   const isLocalProject = !!localProjectPath;
@@ -95,16 +103,16 @@ export async function resolveAdapter(
     });
 
     // Get or create local adapter
-    if (!localAdapterCache.has(effectiveProjectDir)) {
+    if (!cache.adapters.has(effectiveProjectDir)) {
       const baseAdapter = await runtime.get();
-      localAdapterCache.set(effectiveProjectDir, baseAdapter);
+      cache.adapters.set(effectiveProjectDir, baseAdapter);
       logger.debug("Created local adapter for project", {
         projectSlug: opts.projectSlug,
         projectDir: effectiveProjectDir,
       });
     }
 
-    effectiveAdapter = localAdapterCache.get(effectiveProjectDir)!;
+    effectiveAdapter = cache.adapters.get(effectiveProjectDir)!;
 
     // Load project-specific config
     try {

package/src/src/server/runtime-handler/index.ts

@@ -21,6 +21,7 @@ import { getErrorMessage } from "../../errors/veryfront-error.js";
 import { UNKNOWN_ERROR } from "../../errors/error-registry.js";
 import { errorToRFC9457Response } from "../../errors/middleware/http-error-boundary.js";
 import { RouteRegistry } from "../../routing/registry/index.js";
+import type { Handler } from "../../types/index.js";
 import { SecurityConfigLoader } from "../../security/http/config.js";
 
 // Re-export is at the bottom of the file
@@ -114,6 +115,136 @@ const baseLogger = getBaseLogger("SERVER");
 
 const logger = baseLogger.component("runtime-handler");
 
+/** Handler names in registration order. */
+export const HANDLER_NAMES = [
+  "AuthHandler",
+  "CsrfHandler",
+  "HMRHandler",
+  "CorsHandler",
+  "HealthHandler",
+  "MetricsHandler",
+  "MemoryDebugHandler",
+  "ClientLogHandler",
+  "DevEndpointsHandler",
+  "StylesCSSHandler",
+  "DebugContextHandler",
+  "OpenAPIHandler",
+  "OpenAPIDocsHandler",
+  "InternalAgentsListHandler",
+  "AgentStreamHandler",
+  "AgentRunResumeHandler",
+  "AgentRunCancelHandler",
+  "ChannelInvokeHandler",
+  "DevDashboardHandler",
+  "ProjectsHandler",
+  "StudioBridgeModulesHandler",
+  "CSSHandler",
+  "DevFileHandler",
+  "SnippetHandler",
+  "StaticHandler",
+  "LibModulesHandler",
+  "RSCHandler",
+  "ModuleHandler",
+  "ApiHandlerWrapper",
+  "MarkdownPreviewHandler",
+  "SSRHandler",
+  "NotFoundHandler",
+] as const;
+
+/** Union of all registered handler names. */
+export type HandlerName = (typeof HANDLER_NAMES)[number];
+
+/**
+ * Dependencies for handler registry creation.
+ * All fields are optional — when omitted, the real handler implementation is used.
+ * This allows tests to inject mock handlers for specific slots.
+ */
+export interface HandlerDependencies {
+  /** Override any handler by its typed name. */
+  overrides?: Partial<Record<HandlerName, Handler>>;
+  /** When true, log handler registration details. */
+  debug?: boolean;
+}
+
+/** Factory for each handler. Only called when no override is provided (lazy instantiation). */
+const handlerFactories: Record<
+  HandlerName,
+  (projectDir: string, adapter: RuntimeAdapter) => Handler
+> = {
+  AuthHandler: () => new AuthHandler(),
+  CsrfHandler: () => new CsrfHandler(),
+  HMRHandler: () => new HMRHandler(),
+  CorsHandler: () => new CorsHandler(),
+  HealthHandler: () => new HealthHandler(),
+  MetricsHandler: () => new MetricsHandler(),
+  MemoryDebugHandler: () => new MemoryDebugHandler(),
+  ClientLogHandler: () => new ClientLogHandler(),
+  DevEndpointsHandler: () => new DevEndpointsHandler(),
+  StylesCSSHandler: () => new StylesCSSHandler(),
+  DebugContextHandler: () => new DebugContextHandler(),
+  OpenAPIHandler: () => new OpenAPIHandler(),
+  OpenAPIDocsHandler: () => new OpenAPIDocsHandler(),
+  InternalAgentsListHandler: () => new InternalAgentsListHandler(),
+  AgentStreamHandler: () => new AgentStreamHandler(),
+  AgentRunResumeHandler: () => new AgentRunResumeHandler(),
+  AgentRunCancelHandler: () => new AgentRunCancelHandler(),
+  ChannelInvokeHandler: () => new ChannelInvokeHandler(),
+  DevDashboardHandler: () => new DevDashboardHandler(),
+  ProjectsHandler: () => new ProjectsHandler(),
+  StudioBridgeModulesHandler: () => new StudioBridgeModulesHandler(),
+  CSSHandler: () => new CSSHandler(),
+  DevFileHandler: () => new DevFileHandler(),
+  SnippetHandler: () => new SnippetHandler(),
+  StaticHandler: () => new StaticHandler(),
+  LibModulesHandler: () => new LibModulesHandler(),
+  RSCHandler: () => new RSCHandler(),
+  ModuleHandler: () => new ModuleHandler(),
+  ApiHandlerWrapper: (projectDir, adapter) => new ApiHandlerWrapper(projectDir, adapter),
+  MarkdownPreviewHandler: () => new MarkdownPreviewHandler(),
+  SSRHandler: () => new SSRHandler(),
+  NotFoundHandler: () => new NotFoundHandler(),
+};
+
+/**
+ * Creates a RouteRegistry populated with the standard handler chain.
+ *
+ * Handlers are instantiated lazily — overridden slots skip construction
+ * of the default handler entirely.
+ *
+ * @param projectDir - Root project directory
+ * @param adapter - Runtime adapter for environment access
+ * @param deps - Optional dependency overrides for testing
+ * @returns Object containing the registry and the api handler (for initialization)
+ */
+export function createHandlerRegistry(
+  projectDir: string,
+  adapter: RuntimeAdapter,
+  deps: HandlerDependencies = {},
+): { registry: RouteRegistry; apiHandler: ApiHandlerWrapper } {
+  const registry = new RouteRegistry({
+    debug: deps.debug,
+    enableMetrics: true,
+  });
+
+  const overrides = deps.overrides ?? {};
+
+  // Create the ApiHandlerWrapper first — it's special because callers need
+  // the returned instance for initialization regardless of overrides.
+  const apiHandler = overrides.ApiHandlerWrapper
+    ? (overrides.ApiHandlerWrapper as ApiHandlerWrapper)
+    : new ApiHandlerWrapper(projectDir, adapter);
+
+  const handlers = HANDLER_NAMES.map((name) => {
+    if (name === "ApiHandlerWrapper") return apiHandler;
+    if (overrides[name]) return overrides[name]!;
+    return handlerFactories[name](projectDir, adapter);
+  });
+
+  registry.registerAll(handlers);
+
+  return { registry, apiHandler };
+}
+
 export interface RuntimeHandlerOptions {
   projectDir: string;
   /** When true, expose additional debug logging. */
@@ -188,48 +319,10 @@ export function createVeryfrontHandler(
     }
   })();
 
-  const registry = new RouteRegistry({
+  const { registry, apiHandler } = createHandlerRegistry(projectDir, adapter, {
     debug: opts.debug,
-    enableMetrics: true,
   });
 
-  const apiHandler = new ApiHandlerWrapper(projectDir, adapter);
-
-  registry.registerAll([
-    new AuthHandler(),
-    new CsrfHandler(),
-    new HMRHandler(),
-    new CorsHandler(),
-    new HealthHandler(),
-    new MetricsHandler(),
-    new MemoryDebugHandler(),
-    new ClientLogHandler(),
-    new DevEndpointsHandler(),
-    new StylesCSSHandler(),
-    new DebugContextHandler(),
-    new OpenAPIHandler(),
-    new OpenAPIDocsHandler(),
-    new InternalAgentsListHandler(),
-    new AgentStreamHandler(),
-    new AgentRunResumeHandler(),
-    new AgentRunCancelHandler(),
-    new ChannelInvokeHandler(),
-    new DevDashboardHandler(),
-    new ProjectsHandler(),
-    new StudioBridgeModulesHandler(),
-    new CSSHandler(),
-    new DevFileHandler(),
-    new SnippetHandler(),
-    new StaticHandler(),
-    new LibModulesHandler(),
-    new RSCHandler(),
-    new ModuleHandler(),
-    apiHandler,
-    new MarkdownPreviewHandler(),
-    new SSRHandler(),
-    new NotFoundHandler(),
-  ]);
-
   const isProxyMode = opts.config?.fs?.veryfront?.proxyMode === true;
 
   const readyPromise = isProxyMode ? Promise.resolve() : apiHandler.initialize().catch((error) => {