veryfront 0.1.49 → 0.1.51

package/src/src/proxy/cache/memory-cache.ts

@@ -5,9 +5,10 @@ import * as dntShim from "../../../_dnt.shims.js";
 
 
 import type { CacheStats, MemoryCacheOptions, TokenCache, TokenCacheEntry } from "./types.js";
+import { proxyLogger } from "../logger.js";
 import { withSpan } from "../tracing.js";
 
-const DEFAULT_MAX_SIZE = 1000;
+const DEFAULT_MAX_SIZE = 1_000;
 const DEFAULT_CLEANUP_INTERVAL = 60_000;
 
 export class MemoryCache implements TokenCache {
@@ -129,7 +130,7 @@ export class MemoryCache implements TokenCache {
     }
 
     if (cleaned > 0) {
-      console.log(`[MemoryCache] Cleaned ${cleaned} expired entries`);
+      proxyLogger.debug("[MemoryCache] Cleaned expired entries", { cleaned });
     }
   }
 }

package/src/src/proxy/cache/redis-cache.ts

@@ -5,8 +5,11 @@ import { proxyLogger } from "../logger.js";
 
 const logger = proxyLogger.child({ module: "redis-cache" });
 const DEFAULT_PREFIX = "vf:token:";
-const DEFAULT_CONNECT_TIMEOUT = 5000;
+const DEFAULT_CONNECT_TIMEOUT_MS = 5_000;
 const DEFAULT_SCAN_COUNT = 100;
+const MAX_RECONNECT_RETRIES = 3;
+const RECONNECT_BACKOFF_BASE_MS = 100;
+const RECONNECT_BACKOFF_MAX_MS = 3_000;
 
 export class RedisCache implements TokenCache {
   private client: RedisClientType | null = null;
@@ -20,7 +23,7 @@ export class RedisCache implements TokenCache {
   constructor(options: RedisCacheOptions) {
     this.url = options.url;
     this.prefix = options.prefix ?? DEFAULT_PREFIX;
-    this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+    this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT_MS;
   }
 
   private key(k: string): string {
@@ -32,8 +35,7 @@ export class RedisCache implements TokenCache {
       "cache.redis.get",
       async () => {
         try {
-          await this.ensureConnected();
-          const client = this.client!;
+          const client = await this.getConnectedClient();
           const data = await client.get(this.key(key));
 
           if (!data) {
@@ -69,8 +71,7 @@ export class RedisCache implements TokenCache {
       "cache.redis.set",
       async () => {
         try {
-          await this.ensureConnected();
-          const client = this.client!;
+          const client = await this.getConnectedClient();
           const ttlMs = entry.expiresAt - Date.now();
           const ttlSeconds = Math.max(1, Math.floor(ttlMs / 1000));
           await client.setEx(this.key(key), ttlSeconds, JSON.stringify(entry));
@@ -91,8 +92,8 @@ export class RedisCache implements TokenCache {
       "cache.redis.delete",
       async () => {
         try {
-          await this.ensureConnected();
-          await this.client!.del(this.key(key));
+          const client = await this.getConnectedClient();
+          await client.del(this.key(key));
         } catch (error) {
           logger.error("[RedisCache] Delete error", {
             error: error instanceof Error ? error.message : String(error),
@@ -108,8 +109,7 @@ export class RedisCache implements TokenCache {
   async clear(): Promise<void> {
     return withSpan("cache.redis.clear", async () => {
       try {
-        await this.ensureConnected();
-        const client = this.client!;
+        const client = await this.getConnectedClient();
 
         const pattern = `${this.prefix}*`;
         let cursor = 0;
@@ -149,8 +149,8 @@ export class RedisCache implements TokenCache {
       "cache.redis.has",
       async () => {
         try {
-          await this.ensureConnected();
-          return (await this.client!.exists(this.key(key))) === 1;
+          const client = await this.getConnectedClient();
+          return (await client.exists(this.key(key))) === 1;
         } catch (error) {
           logger.error("[RedisCache] Has error", {
             error: error instanceof Error ? error.message : String(error),
@@ -168,8 +168,8 @@ export class RedisCache implements TokenCache {
       let size = 0;
 
       try {
-        await this.ensureConnected();
-        size = await this.client!.dbSize();
+        const client = await this.getConnectedClient();
+        size = await client.dbSize();
       } catch (error) {
         this.connected = false;
         logger.error("[RedisCache] Stats error", {
@@ -191,8 +191,8 @@ export class RedisCache implements TokenCache {
 
       try {
         await client.quit();
-      } catch {
-        // Ignore close errors
+      } catch (_) {
+        // expected: close errors are non-critical
       } finally {
         this.client = null;
         this.connected = false;
@@ -200,6 +200,14 @@ export class RedisCache implements TokenCache {
     });
   }
 
+  private async getConnectedClient(): Promise<RedisClientType> {
+    await this.ensureConnected();
+    if (!this.client) {
+      throw new Error("Redis client not available after connect");
+    }
+    return this.client;
+  }
+
   private async ensureConnected(): Promise<void> {
     return withSpan("cache.redis.connect", async () => {
       if (this.connected && this.client) return;
@@ -209,9 +217,10 @@ export class RedisCache implements TokenCache {
         socket: {
           connectTimeout: this.connectTimeout,
           reconnectStrategy: (retries) => {
-            // Exponential backoff with max 3 retries
-            if (retries > 3) return new Error("Max reconnection attempts reached");
-            return Math.min(retries * 100, 3000);
+            if (retries > MAX_RECONNECT_RETRIES) {
+              return new Error("Max reconnection attempts reached");
+            }
+            return Math.min(retries * RECONNECT_BACKOFF_BASE_MS, RECONNECT_BACKOFF_MAX_MS);
           },
         },
       });

package/src/src/proxy/cache/resilient-cache.ts

@@ -176,7 +176,17 @@ export class ResilientCache implements TokenCache {
 
   async close(): Promise<void> {
     return withSpan("cache.resilient.close", async () => {
-      await Promise.all([this.primary.close(), this.fallback.close()]);
+      const results = await Promise.allSettled([
+        this.primary.close(),
+        this.fallback.close(),
+      ]);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          logger.warn("[ResilientCache] Error closing cache:", {
+            error: result.reason instanceof Error ? result.reason.message : result.reason,
+          });
+        }
+      }
     });
   }
 

package/src/src/proxy/handler.ts

@@ -162,7 +162,8 @@ function extractUserIdFromToken(token: string): string | undefined {
     else if (remainder === 3) base64 += "=";
     const decoded = JSON.parse(atob(base64));
     return decoded?.userId;
-  } catch {
+  } catch (_) {
+    /* expected: malformed JWT token */
     return undefined;
   }
 }
@@ -193,7 +194,8 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
       candidatePaths.map(async (projectPath) => {
         try {
           return (await fs.exists(projectPath)) ? projectPath : null;
-        } catch {
+        } catch (_) {
+          /* expected: filesystem check may fail */
           return null;
         }
       }),
@@ -214,8 +216,8 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
         localProjects[slug] = projectPath;
         logger?.debug("Dynamically discovered local project", { slug, projectPath });
         return projectPath;
-      } catch {
-        // continue
+      } catch (_) {
+        // expected: filesystem check may fail
       }
     }
 

package/src/src/proxy/logger.ts

@@ -14,7 +14,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
  * Request context for proxy logging.
  * Stored in AsyncLocalStorage to propagate through the call stack.
  */
-export interface ProxyRequestContext {
+interface ProxyRequestContext {
   requestId: string;
   projectSlug?: string;
   projectId?: string;
@@ -41,7 +41,7 @@ export function runWithProxyRequestContext<T>(
 /**
  * Get the current proxy request context (if any).
  */
-export function getProxyRequestContext(): ProxyRequestContext | undefined {
+function getProxyRequestContext(): ProxyRequestContext | undefined {
   return requestContextStore.getStore();
 }
 
@@ -136,7 +136,8 @@ function formatValue(value: unknown): string {
   let text: string | undefined;
   try {
     text = JSON.stringify(value);
-  } catch {
+  } catch (_) {
+    /* expected: non-serializable value */
     text = String(value);
   }
 
@@ -203,8 +204,8 @@ function isTty(): boolean {
     if (typeof dntShim.Deno !== "undefined" && typeof dntShim.Deno.stdout?.isTerminal === "function") {
       return dntShim.Deno.stdout.isTerminal();
     }
-  } catch {
-    // ignore
+  } catch (_) {
+    // expected: TTY detection may be unavailable
   }
 
   const stdout = (dntShim.dntGlobalThis as { process?: { stdout?: { isTTY?: boolean } } }).process?.stdout;

package/src/src/proxy/main.ts

@@ -84,7 +84,7 @@ const rendererRouter = (discoveryHost || staticTargets)
   ? new RendererRouter(
     discoveryHost || "static-targets",
     PRODUCTION_SERVER_URL,
-    parseInt(getEnv("VERYFRONT_SERVER_DISCOVERY_INTERVAL_MS") || "15000") || 15000,
+    parseInt(getEnv("VERYFRONT_SERVER_DISCOVERY_INTERVAL_MS") || "15000") || 15_000,
   )
   : null;
 
@@ -95,15 +95,20 @@ const apiInternalPass = getEnv("VERYFRONT_API_INTERNAL_PASS") || "";
 const serverResolver = new ServerResolver(apiInternalUrl, apiInternalUser, apiInternalPass);
 
 const { hostname: HOST, port: PORT } = resolveProxyBinding();
-const WS_CONNECT_TIMEOUT_MS = 30000;
+const WS_CONNECT_TIMEOUT_MS = 30_000;
 // Timeout for forwarding requests to production server (SSR can take time on cold start)
+const DEFAULT_SERVER_REQUEST_TIMEOUT_MS = 90_000;
 const VERYFRONT_SERVER_REQUEST_TIMEOUT_MS = parseInt(
-  getEnv("VERYFRONT_SERVER_REQUEST_TIMEOUT_MS") || "90000",
+  getEnv("VERYFRONT_SERVER_REQUEST_TIMEOUT_MS") || String(DEFAULT_SERVER_REQUEST_TIMEOUT_MS),
 );
 // Retry configuration for transient connection errors
-const VERYFRONT_SERVER_RETRY_COUNT = parseInt(getEnv("VERYFRONT_SERVER_RETRY_COUNT") || "1");
+const DEFAULT_SERVER_RETRY_COUNT = 1;
+const DEFAULT_SERVER_RETRY_DELAY_MS = 100;
+const VERYFRONT_SERVER_RETRY_COUNT = parseInt(
+  getEnv("VERYFRONT_SERVER_RETRY_COUNT") || String(DEFAULT_SERVER_RETRY_COUNT),
+);
 const VERYFRONT_SERVER_RETRY_DELAY_MS = parseInt(
-  getEnv("VERYFRONT_SERVER_RETRY_DELAY_MS") || "100",
+  getEnv("VERYFRONT_SERVER_RETRY_DELAY_MS") || String(DEFAULT_SERVER_RETRY_DELAY_MS),
 );
 
 // Initialize cache and proxy handler
@@ -374,7 +379,7 @@ function forwardToServer(req: dntShim.Request): Promise<dntShim.Response> {
                   method: req.method,
                 },
               );
-              await new Promise((resolve) => dntShim.setTimeout(resolve, VERYFRONT_SERVER_RETRY_DELAY_MS));
+              await new Promise((resolve) => dntShim.setTimeout(resolve, VERYFRONT_SERVER_RETRY_DELAY_MS)); // no cleanup needed: one-shot
             }
 
             const abortController = new AbortController();

package/src/src/proxy/oauth-client.ts

@@ -5,8 +5,9 @@ import * as dntShim from "../../_dnt.shims.js";
 
 
 import { injectContext, ProxySpanNames, withSpan } from "./tracing.js";
+import { REQUEST_ERROR, TIMEOUT_ERROR } from "../errors/index.js";
 
-const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_TIMEOUT_MS = 10_000;
 
 export interface TokenResponse {
   access_token: string;
@@ -14,7 +15,7 @@ export interface TokenResponse {
   expires_in?: number;
 }
 
-export interface OAuthTokenConfig {
+interface OAuthTokenConfig {
   apiBaseUrl: string;
   apiClientId: string;
   apiClientSecret: string;
@@ -70,12 +71,14 @@ export async function fetchOAuthToken(
         }
 
         const errorText = await response.text().catch((): string => "Unknown error");
-        throw new Error(
-          `OAuth token request failed: ${response.status} - ${errorText}`,
-        );
+        throw REQUEST_ERROR.create({
+          detail: `OAuth token request failed: ${response.status} - ${errorText}`,
+        });
       } catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
-          throw new Error(`OAuth token request timed out after ${timeoutMs}ms`);
+          throw TIMEOUT_ERROR.create({
+            detail: `OAuth token request timed out after ${timeoutMs}ms`,
+          });
         }
         throw error;
       } finally {

package/src/src/proxy/renderer-router.ts

@@ -29,7 +29,7 @@ export function jumpHash(keyStr: string, numBuckets: number): number {
   return Number(b);
 }
 
-const MAX_STALENESS_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_STALENESS_MS = 5 * 60 * 1_000; // 5 minutes
 
 export class RendererRouter {
   private targets: string[] = [];

package/src/src/proxy/token-manager.ts

@@ -2,6 +2,7 @@ import { fetchOAuthToken, type TokenResponse } from "./oauth-client.js";
 import type { TokenCache, TokenCacheEntry } from "./cache/types.js";
 import { MemoryCache } from "./cache/memory-cache.js";
 import { ProxySpanNames, withSpan } from "./tracing.js";
+import { CACHE_ERROR } from "../errors/index.js";
 
 export type TokenScope = "preview" | "production";
 
@@ -11,8 +12,10 @@ interface NegativeCacheEntry {
   cachedAt: number;
 }
 
-const NEGATIVE_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-const NEGATIVE_CACHE_MAX_SIZE = 1000;
+const NEGATIVE_CACHE_TTL_MS = 5 * 60 * 1_000; // 5 minutes
+const NEGATIVE_CACHE_MAX_SIZE = 1_000;
+const DEFAULT_REFRESH_BUFFER_MS = 2 * 60 * 1_000; // 2 minutes before expiry
+const DEFAULT_TOKEN_TTL_MS = 3_600 * 1_000; // 1 hour
 
 export interface OAuthConfig {
   apiBaseUrl: string;
@@ -22,7 +25,7 @@ export interface OAuthConfig {
   previewApiClientSecret: string;
 }
 
-export interface TokenManagerOptions {
+interface TokenManagerOptions {
   cache?: TokenCache;
   refreshBuffer?: number; // ms before expiry to trigger refresh
 }
@@ -38,7 +41,7 @@ export class TokenManager {
     options: TokenManagerOptions = {},
   ) {
     this.cache = options.cache ?? new MemoryCache();
-    this.refreshBuffer = options.refreshBuffer ?? 2 * 60 * 1000; // 2 minutes before expiry
+    this.refreshBuffer = options.refreshBuffer ?? DEFAULT_REFRESH_BUFFER_MS;
   }
 
   async getToken(
@@ -54,8 +57,8 @@ export class TokenManager {
       async () => {
         const negEntry = this.negativeCache.get(cacheKey);
         if (negEntry) {
-          if (Date.now() - negEntry.cachedAt < NEGATIVE_CACHE_TTL) {
-            throw new Error(negEntry.message);
+          if (Date.now() - negEntry.cachedAt < NEGATIVE_CACHE_TTL_MS) {
+            throw CACHE_ERROR.create({ detail: negEntry.message });
           }
           this.negativeCache.delete(cacheKey);
         }
@@ -172,14 +175,14 @@ export class TokenManager {
 
     try {
       const payload = response.access_token.split(".")[1];
-      if (!payload) return Date.now() + 3600 * 1000;
+      if (!payload) return Date.now() + DEFAULT_TOKEN_TTL_MS;
 
       const decoded = JSON.parse(atob(payload));
       if (decoded?.exp) return decoded.exp * 1000;
-    } catch {
-      // Fall through to default
+    } catch (_) {
+      // expected: malformed JWT payload, fall through to default
     }
 
-    return Date.now() + 3600 * 1000;
+    return Date.now() + DEFAULT_TOKEN_TTL_MS;
   }
 }

package/src/src/proxy/tracing.ts

@@ -8,6 +8,7 @@ import * as dntShim from "../../_dnt.shims.js";
 import type { Context, Span, Tracer } from "@opentelemetry/api";
 import denoConfig from "../../deno.js";
 import { getEnv } from "./env.js";
+import { proxyLogger } from "./logger.js";
 
 // Get version from environment variable or root deno.json
 const VERYFRONT_VERSION: string = getEnv("VERYFRONT_VERSION") ??
@@ -80,7 +81,7 @@ export async function initializeOTLPWithApis(): Promise<void> {
   }
 
   if (!config.endpoint) {
-    console.warn("[otel] No endpoint configured");
+    proxyLogger.warn("[otel] No endpoint configured");
     initialized = true;
     return;
   }
@@ -118,12 +119,12 @@ export async function initializeOTLPWithApis(): Promise<void> {
 
     await loadApis();
 
-    console.log("[otel] Initialized", {
+    proxyLogger.info("[otel] Initialized", {
       serviceName: config.serviceName,
       endpoint: config.endpoint,
     });
   } catch (error) {
-    console.error("[otel] Init failed", { error });
+    proxyLogger.error("[otel] Init failed", error);
     initialized = true;
   }
 }
@@ -133,9 +134,9 @@ export async function shutdownOTLP(): Promise<void> {
 
   try {
     await tracerProvider.shutdown();
-    console.log("[otel] Shutdown complete");
+    proxyLogger.info("[otel] Shutdown complete");
   } catch (error) {
-    console.warn("[otel] Shutdown error", { error });
+    proxyLogger.error("[otel] Shutdown error", error);
   }
 }
 

package/src/src/react/compat/config-generator.ts

@@ -17,7 +17,7 @@ export interface ReactVersionConfig {
   imports: Record<string, string>;
 }
 
-export interface ReactVersionSwitcher {
+interface ReactVersionSwitcher {
   switchTo(version: ReactVersion): Promise<void>;
   getCurrentVersion(): Promise<ReactVersion | null>;
   getAvailableVersions(): ReactVersion[];

package/src/src/react/compat/hooks-adapter.ts

@@ -16,6 +16,33 @@ function hasReactHook(hookName: string): boolean {
   return typeof (React as Record<string, unknown>)[hookName] === "function";
 }
 
+export function createTransitionFallbackScheduler(
+  onPendingChange: (pending: boolean) => void,
+): {
+  destroy(): void;
+  startTransition(callback: () => void): void;
+} {
+  const timers = new Set<ReturnType<typeof dntShim.setTimeout>>();
+
+  return {
+    destroy() {
+      for (const timerId of timers) clearTimeout(timerId);
+      timers.clear();
+    },
+    startTransition(callback: () => void) {
+      onPendingChange(true);
+
+      const timerId = dntShim.setTimeout(() => {
+        timers.delete(timerId);
+        callback();
+        onPendingChange(false);
+      }, 0);
+
+      timers.add(timerId);
+    },
+  };
+}
+
 export function useFormStatusCompat(): FormStatus {
   if (!hasFeature("useFormStatus") || !hasReactHook("useFormStatus")) {
     return { pending: false, data: null, method: null, action: null };
@@ -23,7 +50,7 @@ export function useFormStatusCompat(): FormStatus {
 
   try {
     return (React as typeof React & { useFormStatus: () => FormStatus }).useFormStatus();
-  } catch {
+  } catch (_) {
     logger.warn("useFormStatus not available in current React version");
     return { pending: false, data: null, method: null, action: null };
   }
@@ -43,7 +70,7 @@ export function useOptimisticCompat<State, OptimisticState = State>(
           ) => [S, (action: OptimisticStateAction<O>) => void];
         }
       ).useOptimistic(state, updateFn);
-    } catch {
+    } catch (_) {
       logger.warn("useOptimistic not available in current React version");
     }
   }
@@ -85,20 +112,26 @@ export function useTransitionCompat(): ReturnType<typeof React.useTransition> {
   if (versionInfo.isReact18 || versionInfo.isReact19) {
     try {
       return React.useTransition();
-    } catch {
+    } catch (_) {
       logger.warn("useTransition not available, falling back to mock");
     }
   }
 
   const [isPending, setIsPending] = React.useState(false);
 
-  const startTransition = React.useCallback((callback: () => void) => {
-    setIsPending(true);
+  const schedulerRef = React.useRef<ReturnType<typeof createTransitionFallbackScheduler>>(
+    undefined,
+  );
+  if (!schedulerRef.current) {
+    schedulerRef.current = createTransitionFallbackScheduler(setIsPending);
+  }
+  React.useEffect(
+    () => () => schedulerRef.current?.destroy(),
+    [],
+  );
 
-    dntShim.setTimeout(() => {
-      callback();
-      setIsPending(false);
-    }, 0);
+  const startTransition = React.useCallback((callback: () => void) => {
+    schedulerRef.current?.startTransition(callback);
   }, []);
 
   return [isPending, startTransition];
@@ -110,7 +143,7 @@ export function useDeferredValueCompat<T>(value: T): T {
   if (versionInfo.isReact18 || versionInfo.isReact19) {
     try {
       return React.useDeferredValue(value);
-    } catch {
+    } catch (_) {
       logger.warn("useDeferredValue not available, returning value directly");
     }
   }
@@ -126,7 +159,7 @@ export function useIdCompat(): string {
   if (versionInfo.isReact18 || versionInfo.isReact19) {
     try {
       return React.useId();
-    } catch {
+    } catch (_) {
       logger.warn("useId not available, using fallback");
     }
   }
@@ -180,18 +213,6 @@ export function resetCompatHooksContext(): void {
   compatHooksContext = null;
 }
 
-export const CompatHooksContext = {
-  get Provider(): React.Provider<CompatHooks> {
-    return getCompatHooksContext().Provider;
-  },
-  get Consumer(): React.Consumer<CompatHooks> {
-    return getCompatHooksContext().Consumer;
-  },
-  get displayName(): string | undefined {
-    return getCompatHooksContext().displayName;
-  },
-};
-
 export function useCompatHooks(): CompatHooks {
   return React.useContext(getCompatHooksContext());
 }

package/src/src/react/compat/ssr-adapter/server-loader.ts

@@ -1,4 +1,5 @@
 import { getReactVersionInfo } from "../version-detector/index.js";
+import { INITIALIZATION_ERROR } from "../../../errors/index.js";
 import { Singleflight } from "../../../utils/singleflight.js";
 import { cacheModuleToLocal } from "../../../transforms/esm/http-cache.js";
 import { getReactUrls } from "../../../transforms/esm/package-registry.js";
@@ -43,7 +44,9 @@ export function getProjectReact(): Promise<typeof import("react")> {
     // This prevents "multiple React instances" errors in SSR.
     const reactUrl = getReactUrls().react;
     if (!reactUrl) {
-      throw new Error("[server-loader] React URL not found in getReactUrls()");
+      throw INITIALIZATION_ERROR.create({
+        detail: "[server-loader] React URL not found in getReactUrls()",
+      });
     }
 
     const reactModule = await loadFromCachedHttpModule<{ default?: typeof import("react") }>(
@@ -70,7 +73,9 @@ export function getReactDOMServer(): Promise<ReactDOMServer> {
     // where components use React from one source and react-dom/server from another.
     const serverUrl = getReactUrls()["react-dom/server"];
     if (!serverUrl) {
-      throw new Error("[server-loader] react-dom/server URL not found in getReactUrls()");
+      throw INITIALIZATION_ERROR.create({
+        detail: "[server-loader] react-dom/server URL not found in getReactUrls()",
+      });
     }
     const serverModule = await loadFromCachedHttpModule<typeof import("react-dom/server")>(
       serverUrl,

package/src/src/react/compat/version-detector/feature-detector.ts

@@ -79,7 +79,7 @@ export async function detectReactVersionFromProject(
         version,
       });
     }
-  } catch {
+  } catch (_) {
     logger.debug("Could not read package.json, using bundled React version", {
       projectDir,
       version,

package/src/src/react/compat/version-detector/version-cache.ts

@@ -9,17 +9,21 @@ export function getReactVersionInfo(): ReactVersionInfo {
   return defaultVersionInfo;
 }
 
-export async function getReactVersionInfoForProject(projectDir: string): Promise<ReactVersionInfo> {
-  const cached = projectVersionCache.get(projectDir);
+export async function getReactVersionInfoForProject(
+  projectDir: string,
+  projectId?: string,
+): Promise<ReactVersionInfo> {
+  const cacheKey = projectId ?? projectDir;
+  const cached = projectVersionCache.get(cacheKey);
   if (cached) return cached;
 
   const info = await detectReactVersionFromProject(projectDir);
-  projectVersionCache.set(projectDir, info);
+  projectVersionCache.set(cacheKey, info);
   return info;
 }
 
-export function clearProjectVersionCache(projectDir: string): void {
-  projectVersionCache.delete(projectDir);
+export function clearProjectVersionCache(projectId: string): void {
+  projectVersionCache.delete(projectId);
 }
 
 export function hasFeature(feature: keyof ReactFeatures): boolean {

package/src/src/react/components/LayoutComponent.tsx

@@ -6,7 +6,7 @@ import { rendererLogger as logger } from "../../utils/index.js";
 
 export type { MdxBundle } from "../../types/index.js";
 
-export interface LayoutComponentProps {
+interface LayoutComponentProps {
   mdxBundle: MdxBundle;
   children: React.ReactNode;
   components?: MDXComponents;

package/src/src/react/components/ProviderComponent.tsx

@@ -5,7 +5,7 @@ import type { MDXComponents } from "../../types/index.js";
 import type { MdxBundle } from "./LayoutComponent.js";
 import { rendererLogger as logger } from "../../utils/index.js";
 
-export interface ProviderComponentProps {
+interface ProviderComponentProps {
   mdxBundle: MdxBundle;
   children: React.ReactNode;
   components?: MDXComponents;