veryfront 0.1.49 → 0.1.51

package/src/src/rendering/snippet-renderer.ts

@@ -1,4 +1,5 @@
 import { computeHash, rendererLogger } from "../utils/index.js";
+import { RENDER_ERROR } from "../errors/error-registry.js";
 import type { RenderMetadata } from "../types/index.js";
 import type { VeryfrontConfig } from "../config/index.js";
 import { wrapInHTMLShell } from "../html/html-shell-generator.js";
@@ -15,8 +16,9 @@ import { withSpan } from "../observability/tracing/otlp-setup.js";
 const logger = rendererLogger.component("snippet-renderer");
 
 const SNIPPET_CACHE_MAX_ENTRIES = 500;
-const SNIPPET_CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+const SNIPPET_CACHE_TTL_MS = 10 * 60 * 1_000; // 10 minutes
 const SNIPPET_DISTRIBUTED_CACHE_TTL_SECONDS = 600; // 10 minutes for distributed cache
+const SNIPPET_CACHE_CLEANUP_INTERVAL_MS = 60_000;
 
 export interface SnippetRenderOptions {
   mode: "development" | "production";
@@ -47,7 +49,7 @@ interface SnippetCacheEntry {
 const snippetCache = new LRUCache<string, SnippetCacheEntry>({
   maxEntries: SNIPPET_CACHE_MAX_ENTRIES,
   ttlMs: SNIPPET_CACHE_TTL_MS,
-  cleanupIntervalMs: 60000,
+  cleanupIntervalMs: SNIPPET_CACHE_CLEANUP_INTERVAL_MS,
 });
 
 registerCache("snippet-cache", () => ({
@@ -59,26 +61,27 @@ registerCache("snippet-cache", () => ({
 let distributedSnippetCache: CacheBackend | null = null;
 let distributedCacheInitPromise: Promise<CacheBackend> | null = null;
 
-function getDistributedSnippetCache(): Promise<CacheBackend> {
-  if (distributedSnippetCache) return Promise.resolve(distributedSnippetCache);
+async function getDistributedSnippetCache(): Promise<CacheBackend> {
+  if (distributedSnippetCache) return distributedSnippetCache;
   if (distributedCacheInitPromise) return distributedCacheInitPromise;
 
-  distributedCacheInitPromise = createCacheBackend({ keyPrefix: "snippet" })
-    .then((backend) => {
+  distributedCacheInitPromise = (async () => {
+    try {
+      const backend = await createCacheBackend({ keyPrefix: "snippet" });
       distributedSnippetCache = backend;
       logger.debug("Distributed cache initialized", {
         type: backend.type,
       });
       return backend;
-    })
-    .catch((error) => {
+    } catch (error) {
       logger.warn(
         "[SnippetRenderer] Failed to initialize distributed cache, using memory",
         { error },
       );
       distributedSnippetCache = new MemoryCacheBackend(SNIPPET_CACHE_MAX_ENTRIES);
       return distributedSnippetCache;
-    });
+    }
+  })();
 
   return distributedCacheInitPromise;
 }
@@ -125,11 +128,14 @@ export function clearSnippetCache(): void {
 
   if (keysToDelete.length === 0) return;
 
-  getDistributedSnippetCache()
-    .then((cache) => Promise.allSettled(keysToDelete.map((key) => cache.del(key))))
-    .catch(() => {
+  void (async () => {
+    try {
+      const cache = await getDistributedSnippetCache();
+      await Promise.allSettled(keysToDelete.map((key) => cache.del(key)));
+    } catch {
       // Ignore distributed cache clear failures
-    });
+    }
+  })();
 }
 
 export function clearSnippetCacheForProject(projectSlug: string): void {
@@ -152,11 +158,14 @@ export function clearSnippetCacheForProject(projectSlug: string): void {
 
   if (keysToDelete.length === 0) return;
 
-  getDistributedSnippetCache()
-    .then((cache) => Promise.allSettled(keysToDelete.map((key) => cache.del(key))))
-    .catch(() => {
+  void (async () => {
+    try {
+      const cache = await getDistributedSnippetCache();
+      await Promise.allSettled(keysToDelete.map((key) => cache.del(key)));
+    } catch {
       // Ignore distributed cache clear failures
-    });
+    }
+  })();
 }
 
 function getModuleServerBase(moduleServerUrl?: string): string {
@@ -174,7 +183,8 @@ function getServerPort(moduleServerUrl?: string): number | undefined {
   try {
     const url = new URL(moduleServerUrl);
     return url.port ? parseInt(url.port, 10) : undefined;
-  } catch {
+  } catch (_) {
+    /* expected: invalid URL string */
     return undefined;
   }
 }
@@ -219,24 +229,21 @@ export function renderSnippet(
 
         snippetCache.set(hash, cacheEntry);
 
-        getDistributedSnippetCache()
-          .then((cache) =>
-            cache
-              .set(
-                hash,
-                JSON.stringify(cacheEntry),
-                SNIPPET_DISTRIBUTED_CACHE_TTL_SECONDS,
-              )
-              .catch((error) => {
-                logger.debug(
-                  "[SnippetRenderer] Failed to store in distributed cache",
-                  { hash, error },
-                );
-              })
-          )
-          .catch(() => {
-            // Ignore - local cache is sufficient
-          });
+        void (async () => {
+          try {
+            const cache = await getDistributedSnippetCache();
+            await cache.set(
+              hash,
+              JSON.stringify(cacheEntry),
+              SNIPPET_DISTRIBUTED_CACHE_TTL_SECONDS,
+            );
+          } catch (error) {
+            logger.debug(
+              "[SnippetRenderer] Failed to store in distributed cache",
+              { hash, error },
+            );
+          }
+        })();
 
         logger.debug("Snippet cached", {
           hash,
@@ -257,7 +264,9 @@ export function renderSnippet(
 
         const module = await import(snippetUrl);
         const MDXContent = module.default || module.MDXContent;
-        if (!MDXContent) throw new Error("No MDXContent export found in compiled snippet");
+        if (!MDXContent) {
+          throw RENDER_ERROR.create({ detail: "No MDXContent export found in compiled snippet" });
+        }
 
         const [{ renderToString }, React] = await Promise.all([
           import("react-dom/server"),

package/src/src/rendering/ssr-globals/dom-stubs.ts

@@ -6,6 +6,11 @@ const noopNull = (): null => null;
 const noopEmptyArray = (): [] => [];
 const emptyString = "";
 
+/** Default SSR viewport width for window stub */
+const SSR_VIEWPORT_WIDTH = 1_024;
+/** Default SSR viewport height for window stub */
+const SSR_VIEWPORT_HEIGHT = 768;
+
 function createClassListStub(): {
   add: () => void;
   remove: () => void;
@@ -343,10 +348,10 @@ export function createWindowStub(): {
       forward: noop,
     },
 
-    innerWidth: 1024,
-    innerHeight: 768,
-    outerWidth: 1024,
-    outerHeight: 768,
+    innerWidth: SSR_VIEWPORT_WIDTH,
+    innerHeight: SSR_VIEWPORT_HEIGHT,
+    outerWidth: SSR_VIEWPORT_WIDTH,
+    outerHeight: SSR_VIEWPORT_HEIGHT,
     screenX: 0,
     screenY: 0,
     pageXOffset: 0,
@@ -359,6 +364,7 @@ export function createWindowStub(): {
     clearTimeout: globalThis.clearTimeout,
     setInterval: dntShim.dntGlobalThis.setInterval,
     clearInterval: globalThis.clearInterval,
+    // SSR stub: fire-and-forget timer simulating rAF; cleanup via cancelAnimationFrame
     requestAnimationFrame: (cb: () => void) => dntShim.dntGlobalThis.setTimeout(cb, 16),
     cancelAnimationFrame: globalThis.clearTimeout,
 

package/src/src/rendering/ssr-globals/fetch-interceptor.ts

@@ -34,7 +34,8 @@ function rewriteFetchUrlForSSR(url: string): string {
     const parsed = new URL(url);
     if (!isProjectDomain(parsed.hostname)) return url;
     return `http://localhost:${serverPort}${parsed.pathname}${parsed.search}`;
-  } catch {
+  } catch (_) {
+    /* expected: URL may be invalid or relative */
     return url;
   }
 }
@@ -51,7 +52,8 @@ function isClientOnlyApiUrl(url: string): boolean {
   try {
     const parsed = new URL(url);
     return parsed.hostname === "localhost" && parsed.pathname.startsWith("/api/");
-  } catch {
+  } catch (_) {
+    /* expected: URL may be invalid */
     return false;
   }
 }
@@ -77,8 +79,8 @@ function createSSRFetch(): typeof dntShim.fetch {
       spanAttributes["http.target"] = `${parsed.pathname}${parsed.search}`;
       spanAttributes["http.host"] = parsed.host;
       spanAttributes["http.scheme"] = parsed.protocol.replace(":", "");
-    } catch {
-      // Ignore - non-absolute URLs won't provide host/scheme
+    } catch (_) {
+      /* expected: non-absolute URLs won't provide host/scheme */
     }
 
     return withSpan(

package/src/src/rendering/ssr-globals/index.ts

@@ -31,7 +31,8 @@ import { createElementClass, createWindowStub } from "./dom-stubs.js";
 function setGlobal(name: string, value: unknown): void {
   try {
     (dntShim.dntGlobalThis as Record<string, unknown>)[name] = value;
-  } catch {
+  } catch (_) {
+    /* expected: direct assignment may fail on frozen/non-configurable properties */
     Object.defineProperty(dntShim.dntGlobalThis, name, {
       value,
       writable: true,

package/src/src/rendering/ssr-renderer.ts

@@ -76,12 +76,19 @@ export class SSRRenderer {
   private readonly mode: string;
   private readonly adapter?: RuntimeAdapter;
   private readonly projectDir?: string;
+  private readonly projectId?: string;
   private versionInfo: ReturnType<typeof getReactVersionInfo> | null = null;
 
-  constructor(mode: string, adapter?: RuntimeAdapter, projectDir?: string) {
+  constructor(
+    mode: string,
+    adapter?: RuntimeAdapter,
+    projectDir?: string,
+    projectId?: string,
+  ) {
     this.mode = mode;
     this.adapter = adapter;
     this.projectDir = projectDir;
+    this.projectId = projectId;
   }
 
   private async getVersionInfo(): Promise<ReturnType<typeof getReactVersionInfo>> {
@@ -93,7 +100,7 @@ export class SSRRenderer {
     }
 
     const { getReactVersionInfoForProject } = await import("../react/index.js");
-    this.versionInfo = await getReactVersionInfoForProject(this.projectDir);
+    this.versionInfo = await getReactVersionInfoForProject(this.projectDir, this.projectId);
     return this.versionInfo;
   }
 

package/src/src/rendering/utils/stream-utils.ts

@@ -122,8 +122,8 @@ export async function streamToString(
     clearTimeout(timeoutId);
     try {
       reader.releaseLock();
-    } catch {
-      // Ignore if already released
+    } catch (_) {
+      /* expected: reader lock may already be released */
     }
   }
 }

package/src/src/routing/api/api-route-matcher.ts

@@ -3,6 +3,12 @@ import type { Route, RouteMatch } from "../matchers/types.js";
 import { getDisableLruIntervalEnv } from "../../config/env.js";
 import { LRUCache } from "../../utils/lru-wrapper.js";
 
+/** Max entries in the route-match LRU cache */
+const ROUTE_CACHE_MAX_ENTRIES = 500;
+
+/** Time-to-live for cached route matches (5 minutes) */
+const ROUTE_CACHE_TTL_MS = 5 * 60 * 1_000;
+
 export type { Route, RouteMatch };
 
 /** Route entry with compiled regex and metadata */
@@ -26,8 +32,8 @@ export class ApiRouteMatcher {
   constructor() {
     const disableIntervals = shouldDisableLruInterval();
     this.routeCache = new LRUCache<string, RouteMatch | null>({
-      maxEntries: 500,
-      ttlMs: disableIntervals ? undefined : 5 * 60 * 1000,
+      maxEntries: ROUTE_CACHE_MAX_ENTRIES,
+      ttlMs: disableIntervals ? undefined : ROUTE_CACHE_TTL_MS,
     });
   }
 
@@ -178,15 +184,13 @@ export class ApiRouteMatcher {
   }
 }
 
-/** @deprecated Use ApiRouteMatcher instead - kept for backwards compatibility */
-export { ApiRouteMatcher as DynamicRouter };
-
 function shouldDisableLruInterval(): boolean {
   if ((dntShim.dntGlobalThis as Record<string, unknown>).__vfDisableLruInterval === true) return true;
 
   try {
     return getDisableLruIntervalEnv();
-  } catch {
+  } catch (_) {
+    /* expected: env variable may not be available */
     return false;
   }
 }

package/src/src/routing/api/handler.ts

@@ -9,19 +9,22 @@ import { badGateway, internalServerError, notFound } from "../../platform/compat
 import type { CORSConfig } from "../../security/index.js";
 import { applyCORSHeaders, handleCORSPreflight } from "../../security/index.js";
 import { type APIContext } from "./context-builder.js";
-import { DynamicRouter, type RouteMatch } from "./api-route-matcher.js";
+import { ApiRouteMatcher, type RouteMatch } from "./api-route-matcher.js";
 import type { APIRoute } from "./module-loader/types.js";
 import { loadHandlerModule } from "./module-loader/loader.js";
 import { discoverAppRoutes, discoverPagesRoutes } from "./route-discovery.js";
 import { executeAppRoute, executePagesRoute } from "./route-executor.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 
+/** Max entries in the loaded-handler LRU cache */
+const HANDLER_CACHE_MAX_ENTRIES = 256;
+
 export type { APIContext, APIRoute };
 
 /**
  * Injection interface for testing APIRouteHandler dependencies
  */
-export interface APIRouteHandlerDeps {
+interface APIRouteHandlerDeps {
   loadHandlerModule?: typeof loadHandlerModule;
   discoverPagesRoutes?: typeof discoverPagesRoutes;
   discoverAppRoutes?: typeof discoverAppRoutes;
@@ -55,8 +58,8 @@ export interface APIResponse {
 export type APIHandler = (ctx: APIContext) => Promise<dntShim.Response> | dntShim.Response;
 
 export class APIRouteHandler {
-  private router = new DynamicRouter();
-  private routeCache = new LRUCache<string, APIRoute>({ maxEntries: 256 });
+  private router = new ApiRouteMatcher();
+  private routeCache = new LRUCache<string, APIRoute>({ maxEntries: HANDLER_CACHE_MAX_ENTRIES });
   private lastErrorMessage: string | null = null;
 
   private adapter: RuntimeAdapter | null;

package/src/src/routing/api/index.ts

@@ -7,7 +7,7 @@
 export { APIRouteHandler } from "./handler.js";
 export type { APIContext, APIHandler, APIResponse, APIRoute } from "./handler.js";
 
-export { ApiRouteMatcher, DynamicRouter } from "./api-route-matcher.js";
+export { ApiRouteMatcher } from "./api-route-matcher.js";
 export type { Route, RouteMatch } from "./api-route-matcher.js";
 
 export {

package/src/src/routing/api/module-loader/esbuild-plugin.ts

@@ -11,7 +11,7 @@ import type { Message, Plugin } from "esbuild";
 
 const logger = serverLogger.component("api");
 
-export interface HTTPPluginOptions {
+interface HTTPPluginOptions {
   allowedHosts: string[];
   lockfile?: LockfileManager;
   projectDir?: string;
@@ -78,7 +78,8 @@ export function createHTTPPlugin(options: HTTPPluginOptions | string[]): Plugin
           const resolved = new URL(args.path, args.importer).toString();
           resolvedUrls.push(resolved);
           return { path: resolved, namespace: "http-url" };
-        } catch {
+        } catch (_) {
+          /* expected: relative URL resolution may fail */
           return undefined;
         }
       });
@@ -145,7 +146,7 @@ export function createHTTPPlugin(options: HTTPPluginOptions | string[]): Plugin
 
                 logger.warn(`[http] integrity mismatch, refetching: ${args.path}`);
               }
-            } catch {
+            } catch (_error) {
               logger.warn(`[http] cached URL failed, refetching: ${args.path}`);
             }
           }

package/src/src/routing/api/module-loader/http-validator.ts

@@ -16,7 +16,8 @@ export function validateHTTPImports(source: string, allowedHosts: string[]): voi
     try {
       const u = new URL(url);
       hostUrl = `${u.protocol}//${u.host}`;
-    } catch {
+    } catch (_) {
+      /* expected: URL may be malformed */
       continue;
     }
 

package/src/src/routing/api/module-loader/loader.ts

@@ -83,7 +83,8 @@ async function readProjectDependencies(
     const content = await fs.readTextFile(pathHelper.join(projectDir, "package.json"));
     const pkg = JSON.parse(content) as { dependencies?: Record<string, string> };
     return new Map(Object.entries(pkg.dependencies ?? {}));
-  } catch {
+  } catch (_) {
+    /* expected: package.json may not exist */
     return new Map();
   }
 }
@@ -128,7 +129,7 @@ function __vf_loadCjs(id, parentDir) {
     if (!resolved.match(/\\.[a-zA-Z0-9]+$/)) {
       var exts = [".js", ".cjs", ".json", "/index.js", "/index.cjs", "/index.json"];
       for (var i = 0; i < exts.length; i++) {
-        try { Deno.statSync(resolved + exts[i]); resolved += exts[i]; break; } catch {}
+        try { Deno.statSync(resolved + exts[i]); resolved += exts[i]; break; } catch (_) { /* expected: probing file extensions */ }
       }
     }
     __vf_assertContained(resolved);
@@ -238,7 +239,7 @@ export function loadHandlerModule(options: LoadModuleOptions): Promise<APIRoute
   );
 }
 
-function loadModule(args: {
+async function loadModule(args: {
   modulePath: string;
   projectDir: string;
   adapter: RuntimeAdapter;
@@ -254,12 +255,11 @@ function loadModule(args: {
     return loadAndTranspileModule(modulePath, projectDir, adapter, fs, config);
   }
 
-  return fs.exists(modulePath).then((fileExistsLocally) => {
-    if (fileExistsLocally) return loadTSModuleDirect(modulePath);
+  const fileExistsLocally = await fs.exists(modulePath);
+  if (fileExistsLocally) return loadTSModuleDirect(modulePath);
 
-    logger.debug(`File not local, using adapter-based loading: ${modulePath}`);
-    return loadAndTranspileModule(modulePath, projectDir, adapter, fs, config);
-  });
+  logger.debug(`File not local, using adapter-based loading: ${modulePath}`);
+  return loadAndTranspileModule(modulePath, projectDir, adapter, fs, config);
 }
 
 /**
@@ -600,8 +600,8 @@ async function readFileWithExtensions(
     try {
       const contents = await adapter.fs.readFile(filePath);
       return { filePath, contents };
-    } catch {
-      // try next
+    } catch (_) {
+      /* expected: trying next file extension candidate */
     }
   }
 
@@ -698,7 +698,8 @@ async function rewriteExternalImports(
           if (!entryPoint) return null;
 
           return pathToFileURL(pathHelper.join(packagePath, entryPoint)).href;
-        } catch {
+        } catch (_) {
+          /* expected: package.json may not exist or be invalid */
           return null;
         }
       };
@@ -771,7 +772,7 @@ async function rewriteExternalImports(
       try {
         const pkgJson = JSON.parse(await fs.readTextFile(vfPackageJsonPath));
         exportsMap = pkgJson.exports || {};
-      } catch {
+      } catch (_error) {
         logger.debug(`Could not read veryfront package.json: `);
       }
 
@@ -950,8 +951,8 @@ async function rewriteExternalImports(
           const pkgContent = await fs.readTextFile(pkgPath);
           const pkg = JSON.parse(pkgContent) as { version?: string };
           if (pkg.version) resolvedVersion = pkg.version;
-        } catch {
-          // Fall back to declared range
+        } catch (_) {
+          /* expected: installed package.json may not exist, fall back to declared range */
         }
         // Static: from "pkg" and from "pkg/sub"
         transformed = transformed.replace(

package/src/src/routing/api/openapi/path-utils.ts

@@ -9,7 +9,7 @@
 /**
  * Path parameter extracted from route pattern.
  */
-export interface PathParam {
+interface PathParam {
   /** Parameter name (e.g., "id", "slug") */
   name: string;
   /** Whether the parameter is required */

package/src/src/routing/api/openapi/spec-generator.ts

@@ -8,7 +8,7 @@
 
 import type { RuntimeAdapter } from "../../../platform/adapters/base.js";
 import type { VeryfrontConfig } from "../../../config/index.js";
-import type { DynamicRouter, RouteEntry } from "../api-route-matcher.js";
+import type { ApiRouteMatcher, RouteEntry } from "../api-route-matcher.js";
 import { loadHandlerModule } from "../module-loader/loader.js";
 import {
   getDefaultStatusDescription,
@@ -29,7 +29,7 @@ const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"
 type HttpMethod = (typeof HTTP_METHODS)[number];
 type HttpMethodLower = Lowercase<HttpMethod>;
 
-export interface GenerateSpecOptions {
+interface GenerateSpecOptions {
   /** API title for OpenAPI info */
   title?: string;
   /** API version */
@@ -41,7 +41,7 @@ export interface GenerateSpecOptions {
 }
 
 export async function generateOpenAPISpec(
-  router: DynamicRouter,
+  router: ApiRouteMatcher,
   projectDir: string,
   adapter: RuntimeAdapter,
   config?: VeryfrontConfig,
@@ -146,13 +146,14 @@ function buildOperation(
   const openApiPath = toOpenAPIPath(pattern);
   const supportsBody = method === "POST" || method === "PUT" || method === "PATCH";
 
+  const parameters: OpenAPIParameter[] = [];
+
   const operation: OpenAPIOperation = {
     operationId: generateOperationId(method, openApiPath),
     summary: metadata?.summary ?? `${method} ${openApiPath}`,
     description: metadata?.description,
     tags: metadata?.tags,
     deprecated: metadata?.deprecated,
-    parameters: [],
     responses: {},
   };
 
@@ -168,14 +169,14 @@ function buildOperation(
       parameter.description = "Catch-all parameter (matches multiple path segments)";
     }
 
-    operation.parameters!.push(parameter);
+    parameters.push(parameter);
   }
 
   const queryProps = metadata?.query?.properties;
   if (queryProps) {
     const required = metadata?.query?.required ?? [];
     for (const [name, schema] of Object.entries(queryProps)) {
-      operation.parameters!.push({
+      parameters.push({
         name,
         in: "query",
         required: required.includes(name),
@@ -206,13 +207,13 @@ function buildOperation(
     if (supportsBody) operation.responses["400"] = { description: "Bad request" };
   }
 
-  if (operation.parameters!.length === 0) delete operation.parameters;
+  if (parameters.length > 0) operation.parameters = parameters;
 
   return operation;
 }
 
 export async function generateOpenAPIJson(
-  router: DynamicRouter,
+  router: ApiRouteMatcher,
   projectDir: string,
   adapter: RuntimeAdapter,
   config?: VeryfrontConfig,

package/src/src/routing/api/openapi/types.ts

@@ -54,18 +54,18 @@ export interface OpenAPISpec {
   servers?: OpenAPIServer[];
 }
 
-export interface OpenAPIInfo {
+interface OpenAPIInfo {
   title: string;
   version: string;
   description?: string;
 }
 
-export interface OpenAPITag {
+interface OpenAPITag {
   name: string;
   description?: string;
 }
 
-export interface OpenAPIServer {
+interface OpenAPIServer {
   url: string;
   description?: string;
 }
@@ -99,7 +99,7 @@ export interface OpenAPIParameter {
   schema: JsonSchema;
 }
 
-export interface OpenAPIRequestBody {
+interface OpenAPIRequestBody {
   required?: boolean;
   description?: string;
   content: {
@@ -107,7 +107,7 @@ export interface OpenAPIRequestBody {
   };
 }
 
-export interface OpenAPIResponse {
+interface OpenAPIResponse {
   description: string;
   content?: {
     "application/json"?: { schema: JsonSchema };

package/src/src/routing/api/route-discovery.ts

@@ -1,6 +1,6 @@
 import { relative } from "../../platform/compat/path/index.js";
 import type { RuntimeAdapter } from "../../platform/adapters/base.js";
-import type { DynamicRouter } from "./api-route-matcher.js";
+import type { ApiRouteMatcher } from "./api-route-matcher.js";
 import { discoverFiles } from "../../utils/file-discovery.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 
@@ -9,7 +9,7 @@ const ROUTE_FILE_RE = /^route\.(ts|js|tsx|jsx)$/;
 const PAGE_EXT_RE = /\.(ts|js|tsx|jsx)$/;
 
 export function discoverPagesRoutes(
-  router: DynamicRouter,
+  router: ApiRouteMatcher,
   dir: string,
   prefix: string,
   adapter: RuntimeAdapter,
@@ -30,7 +30,7 @@ export function discoverPagesRoutes(
 }
 
 export function discoverAppRoutes(
-  router: DynamicRouter,
+  router: ApiRouteMatcher,
   dir: string,
   prefix: string,
   adapter: RuntimeAdapter,

package/src/src/routing/index.ts

@@ -7,10 +7,10 @@
 
 export type { Route, RouteMatch } from "./matchers/index.js";
 export {
-  DynamicRouter,
   getSpecificityScore,
   matchRoute,
   normalizePath,
+  PageRouteMatcher,
   parseRoute,
 } from "./matchers/index.js";
 

package/src/src/routing/matchers/index.ts

@@ -5,7 +5,7 @@
  */
 
 export type { Route, RouteMatch } from "./types.js";
-export { DynamicRouter, PageRouteMatcher } from "./pattern-route-matcher.js";
+export { PageRouteMatcher } from "./pattern-route-matcher.js";
 export { getSpecificityScore, parseRoute } from "./route-parser.js";
 export { matchRoute } from "./route-matcher.js";
 export { normalizePath } from "../../utils/index.js";

package/src/src/routing/matchers/pattern-route-matcher.ts

@@ -44,6 +44,3 @@ export class PageRouteMatcher {
     return [...this.routes];
   }
 }
-
-/** @deprecated Use PageRouteMatcher instead - kept for backwards compatibility */
-export { PageRouteMatcher as DynamicRouter };