veryfront 0.1.49 → 0.1.50

package/src/src/rendering/orchestrator/lifecycle.ts

@@ -25,6 +25,11 @@ import { CompilerService } from "./compiler-service.js";
 
 const logger = rendererLogger.component("lifecycle");
 
+/** Default max cache entries for debug mode */
+const DEBUG_MODE_MAX_ENTRIES = 50;
+/** Default max cache entries for production mode */
+const PRODUCTION_MAX_ENTRIES = 500;
+
 export interface LifecycleOptions {
   configManager: ConfigurationManager;
   port: number;
@@ -117,7 +122,8 @@ export class RendererLifecycle {
       case "memory":
       default:
         cacheStore = new MemoryCacheStore({
-          maxEntries: renderCacheConfig.maxEntries ?? (debugMode ? 50 : 500),
+          maxEntries: renderCacheConfig.maxEntries ??
+            (debugMode ? DEBUG_MODE_MAX_ENTRIES : PRODUCTION_MAX_ENTRIES),
           ttlMs: renderCacheConfig.ttl,
         });
         break;
@@ -137,6 +143,7 @@ export class RendererLifecycle {
 
     const layoutCollector = new LayoutCollector({
       projectDir,
+      projectId: this.projectId,
       adapter: this.adapter,
       config,
       compileMDX: compileMDXProxy,
@@ -152,7 +159,7 @@ export class RendererLifecycle {
       debugMode,
     });
 
-    const ssrRenderer = new SSRRenderer(mode, this.adapter, projectDir);
+    const ssrRenderer = new SSRRenderer(mode, this.adapter, projectDir, this.projectId);
 
     const pageRenderer = new PageRenderer({
       projectDir,
@@ -166,6 +173,7 @@ export class RendererLifecycle {
 
     const pageResolver = new PageResolver({
       projectDir,
+      projectId: this.projectId,
       config,
       adapter: this.adapter,
     });

package/src/src/rendering/orchestrator/module-collection.ts

@@ -8,7 +8,7 @@
  */
 
 /** Timeout for module loading in resolvePageData (prevents hanging on slow transforms) */
-export const MODULE_LOAD_TIMEOUT_MS = 10000;
+export const MODULE_LOAD_TIMEOUT_MS = 10_000;
 
 /** Timeout for data fetching (getStaticData, getServerData) */
 export const DATA_FETCH_TIMEOUT_MS = 15_000;
@@ -27,8 +27,7 @@ export interface ModuleToLoad {
 export interface LoadedModule {
   type: "page" | "layout";
   id: string;
-  // deno-lint-ignore no-explicit-any
-  mod: any;
+  mod: unknown;
 }
 
 /**

package/src/src/rendering/orchestrator/module-loader/esm-rewriter.ts

@@ -1,5 +1,6 @@
 import * as dntShim from "../../../../_dnt.shims.js";
 import { rendererLogger } from "../../../utils/index.js";
+import { MODULE_NOT_FOUND } from "../../../errors/error-registry.js";
 import type { RuntimeAdapter } from "../../../platform/adapters/base.js";
 import { generateHash } from "./cache.js";
 
@@ -60,7 +61,9 @@ export async function fetchEsmModule(
   logger.debug("Fetching esm.sh module:", url);
 
   const response = await dntShim.fetch(url);
-  if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  if (!response.ok) {
+    throw MODULE_NOT_FOUND.create({ detail: `Failed to fetch ${url}: ${response.status}` });
+  }
 
   let code = await response.text();
 

package/src/src/rendering/orchestrator/module-loader/index.ts

@@ -41,7 +41,7 @@ export { createEsmCache, createModuleCache, generateHash } from "./cache.js";
 export { fetchEsmModule, rewriteEsmPaths } from "./esm-rewriter.js";
 
 /** Maximum number of directories to track to prevent memory leaks */
-const MAX_CREATED_DIRS = 5000;
+const MAX_CREATED_DIRS = 5_000;
 
 /** Cache for created directories to avoid repeated mkdir calls (LRU-style) */
 const createdDirs = new Set<string>();
@@ -84,8 +84,8 @@ async function ensureDir(adapter: RuntimeAdapter, dir: string): Promise<void> {
 
   try {
     await adapter.fs.mkdir(dir, { recursive: true });
-  } catch {
-    // Directory might already exist, ignore errors
+  } catch (_) {
+    /* expected: directory might already exist */
   } finally {
     createdDirs.add(dir);
     pruneCreatedDirs();
@@ -213,8 +213,8 @@ export async function transformModuleWithDeps(
       } else {
         return cachedPath;
       }
-    } catch {
-      // File doesn't exist or can't be read - fall through to re-transform
+    } catch (_) {
+      /* expected: cached file may no longer exist on disk */
       moduleCache.delete(cacheKey);
     }
   }
@@ -246,14 +246,14 @@ export async function transformModuleWithDeps(
 
   // Match @/ alias imports
   const aliasImports: AliasImport[] = [...fileContent.matchAll(/from\s+["'](@\/[^"']+)["']/g)].map(
-    (m) => ({ full: m[0], path: m[1]! }),
+    (m) => ({ full: m[0], path: m[1] ?? "" }),
   );
 
   // Match relative imports (./ and ../) - exclude npm:, http://, https://, file://
   const relativeImports: RelativeImport[] = [
     ...fileContent.matchAll(/from\s+["'](\.\.?\/[^"']+)["']/g),
   ]
-    .map((m) => ({ full: m[0], path: m[1]!, fromDir: fileDir }))
+    .map((m) => ({ full: m[0], path: m[1] ?? "", fromDir: fileDir }))
     // Filter out already-transformed file:// imports
     .filter((imp) => !imp.path.includes("file://"));
 
@@ -524,7 +524,10 @@ async function getModuleCacheDir(config: ModuleLoaderConfig): Promise<string> {
  * @param config - Module loader configuration
  * @returns The loaded module
  */
-export async function loadModule(filePath: string, config: ModuleLoaderConfig): Promise<any> {
+export async function loadModule(
+  filePath: string,
+  config: ModuleLoaderConfig,
+): Promise<Record<string, unknown>> {
   const tmpDir = await getModuleCacheDir(config);
   const localAdapter = await getLocalAdapter();
 

package/src/src/rendering/orchestrator/pipeline.ts

@@ -37,13 +37,13 @@ import type { LayoutOrchestrator } from "./layout.js";
 import type { SSROrchestrator } from "./ssr-orchestrator.js";
 import type { PageDataResponse, RenderOptions, RenderResult } from "./types.js";
 import { DataFetcher } from "../../data/index.js";
-import type { DataContext } from "../../data/types.js";
+import type { DataContext, PageWithData } from "../../data/types.js";
 import { clearSSRModuleCacheForProject } from "../../modules/react-loader/index.js";
 import { setupSSRGlobals } from "../ssr-globals.js";
 import { LAYOUT_EXTENSIONS } from "../layouts/types.js";
 import type { LayoutItem } from "../../types/index.js";
 import { withTimeout, withTimeoutThrow } from "../utils/stream-utils.js";
-import { generateTailwind4CSS } from "../../html/styles-builder/index.js";
+import { extractCandidates, generateTailwindCSS } from "../../html/styles-builder/index.js";
 import { createEsmCache, createModuleCache, loadModule } from "./module-loader/index.js";
 import type { ModuleLoaderConfig } from "./module-loader/index.js";
 import {
@@ -133,7 +133,7 @@ export class RenderPipeline {
     this.moduleLoaderConfig.esmCache.clear();
   }
 
-  private loadModule(filePath: string): Promise<unknown> {
+  private loadModule(filePath: string): Promise<Record<string, unknown>> {
     return loadModule(filePath, this.moduleLoaderConfig);
   }
 
@@ -149,11 +149,14 @@ export class RenderPipeline {
    */
   private async loadModulesInParallel(modules: ModuleToLoad[]): Promise<LoadedModule[]> {
     const results = await Promise.all(
-      modules.map((m) =>
-        this.loadModule(m.path)
-          .then((mod) => ({ ...m, mod, error: null as Error | null }))
-          .catch((error: Error) => ({ ...m, mod: null, error }))
-      ),
+      modules.map(async (m) => {
+        try {
+          const mod = await this.loadModule(m.path);
+          return { ...m, mod, error: null as Error | null };
+        } catch (error) {
+          return { ...m, mod: null, error: error as Error };
+        }
+      }),
     );
 
     const loaded: LoadedModule[] = [];
@@ -276,12 +279,15 @@ export class RenderPipeline {
       () =>
         withTimeoutThrow(
           Promise.all(
-            dataJobs.map((job) =>
-              this.dataFetcher
-                .fetchData(job.mod, dataContext, this.config.mode)
-                .then((result) => ({ ...job, result, error: null as Error | null }))
-                .catch((error: Error) => ({ ...job, result: null, error }))
-            ),
+            dataJobs.map(async (job) => {
+              try {
+                const result = await this.dataFetcher
+                  .fetchData(job.mod as PageWithData, dataContext, this.config.mode);
+                return { ...job, result, error: null as Error | null };
+              } catch (error) {
+                return { ...job, result: null, error: error as Error };
+              }
+            }),
           ),
           DATA_FETCH_TIMEOUT_MS,
           `Data fetch for ${slug}`,
@@ -353,8 +359,8 @@ export class RenderPipeline {
 
     return withSpan(
       "render.page",
-      () =>
-        runWithCSSCollector(async () => {
+      async () => {
+        const { result } = await runWithCSSCollector(async () => {
           const pageResolveStart = performance.now();
           const pageInfo = await withSpan(
             "render.resolve_page",
@@ -533,20 +539,24 @@ export class RenderPipeline {
           };
 
           if (shouldCache && !options?.skipCachePersist) {
-            this.config.cacheCoordinator.persistResult(result, slug, cacheKey).catch((error) => {
-              renderPipelineLog.error("Cache persist failed", {
-                slug,
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-              });
-            });
+            void this.config.cacheCoordinator.persistResult(result, slug, cacheKey).catch(
+              (error) => {
+                renderPipelineLog.error("Cache persist failed", {
+                  slug,
+                  error: error instanceof Error ? error.message : String(error),
+                  stack: error instanceof Error ? error.stack : undefined,
+                });
+              },
+            );
           }
 
           timing.total = Math.round(performance.now() - pipelineStartTime);
           renderPipelineLog.debug("Complete", { slug, timing });
 
           return result;
-        }).then(({ result }) => result),
+        });
+        return result;
+      },
       {
         "render.slug": slug,
         "render.project_id": options?.projectId || this.config.projectDir,
@@ -677,7 +687,8 @@ export class RenderPipeline {
         );
 
         if (renderResult?.html) {
-          css = await generateTailwind4CSS(renderResult.html);
+          const candidates = extractCandidates(renderResult.html);
+          css = (await generateTailwindCSS(undefined, candidates)).css;
           if (css) cachePageCss(cssCacheKey, css);
 
           resolvePageDataLog.debug("Generated and cached CSS", {

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

@@ -14,7 +14,7 @@ import { ComponentRegistry } from "./ssr/component-registry.js";
 import type { RenderResult } from "./orchestrator/types.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 
-export interface PageRenderOptions {
+interface PageRenderOptions {
   params?: Record<string, string | string[]>;
   props?: ComponentProps;
   nonce?: string;
@@ -28,7 +28,7 @@ export interface PageRenderOptions {
   contentSourceId?: string;
 }
 
-export interface PageBundleResult {
+interface PageBundleResult {
   pageElement?: React.ReactElement;
   pageBundle?: PageBundle;
   clientModuleCode?: string;

package/src/src/rendering/page-rendering.ts

@@ -9,7 +9,7 @@ import { compileContent } from "../transforms/mdx/compiler/index.js";
 import { ensureError, getErrorMessage } from "../errors/veryfront-error.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 
-export interface MDXPageResult {
+interface MDXPageResult {
   pageElement: BundledReact.ReactElement;
   pageBundle: PageBundle;
   collectedMetadata: Record<string, unknown>;
@@ -107,7 +107,9 @@ export function handleMDXPage(
           try {
             const params = options?.params
               ? (Object.fromEntries(
-                Object.entries(options.params).map(([k, v]) => [k, Array.isArray(v) ? v[0] : v]),
+                Object.entries(options.params)
+                  .map(([k, v]) => [k, Array.isArray(v) ? v[0] : v])
+                  .filter((entry): entry is [string, string] => entry[1] !== undefined),
               ) as Record<string, string>)
               : {};
 

package/src/src/rendering/page-resolution/page-resolver.ts

@@ -39,17 +39,20 @@ function appDirToSlug(dirPath: string, appDirName: string): string {
 
 export interface PageResolverOptions {
   projectDir: string;
+  projectId?: string;
   config: VeryfrontConfig;
   adapter: RuntimeAdapter;
 }
 
 export class PageResolver {
   private projectDir: string;
+  private projectId?: string;
   private config: VeryfrontConfig;
   private adapter: RuntimeAdapter;
 
   constructor(options: PageResolverOptions) {
     this.projectDir = options.projectDir;
+    this.projectId = options.projectId;
     this.config = options.config;
     this.adapter = options.adapter;
   }
@@ -62,6 +65,7 @@ export class PageResolver {
           this.projectDir,
           this.config,
           this.adapter,
+          { projectId: this.projectId },
         );
 
         const appDirName = this.config.directories?.app ?? "app";
@@ -207,6 +211,7 @@ export class PageResolver {
       this.projectDir,
       this.config,
       this.adapter,
+      { projectId: this.projectId },
     );
     return useAppRouter ? "app" : "pages";
   }

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

@@ -13,6 +13,7 @@ import * as dntShim from "../../_dnt.shims.js";
 
 import { Semaphore } from "../modules/react-loader/ssr-module-loader/concurrency/semaphore.js";
 import { getEnvNumber } from "../platform/compat/process.js";
+import { RENDER_ERROR } from "../errors/error-registry.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -38,10 +39,10 @@ export const RENDER_PER_PROJECT_LIMIT = getEnvNumber("RENDER_PER_PROJECT_LIMIT")
  * Timeout for acquiring render permit (ms).
  * If semaphore cannot be acquired within this time, request fails fast with 503.
  */
-export const RENDER_ACQUIRE_TIMEOUT_MS = 5000;
+export const RENDER_ACQUIRE_TIMEOUT_MS = 5_000;
 
 /** Maximum time to wait for a project lock before giving up (10 seconds) */
-export const LOCK_TIMEOUT_MS = 10_000;
+const LOCK_TIMEOUT_MS = 10_000;
 
 // ---------------------------------------------------------------------------
 // Mutex
@@ -79,7 +80,7 @@ export class Mutex {
           settled = true;
           const idx = this.queue.indexOf(onAcquire);
           if (idx !== -1) this.queue.splice(idx, 1);
-          reject(new Error(`Lock acquisition timeout after ${timeoutMs}ms`));
+          reject(RENDER_ERROR.create({ detail: `Lock acquisition timeout after ${timeoutMs}ms` }));
         }, timeoutMs);
       }
 
@@ -109,7 +110,7 @@ export class Mutex {
  * Global render semaphore - limits concurrent renders across all projects per pod.
  * This is a last-line defense against resource exhaustion.
  */
-export const RENDER_MAX_QUEUE_SIZE = 100;
+const RENDER_MAX_QUEUE_SIZE = 100;
 
 export const renderSemaphore = new Semaphore(RENDER_MAX_CONCURRENT, {
   maxQueueSize: RENDER_MAX_QUEUE_SIZE,
@@ -144,7 +145,7 @@ function getProjectMutex(projectId: string): Mutex {
 /**
  * Acquire a lock for a specific project. Returns a release function.
  */
-export function acquireProjectLock(
+function acquireProjectLock(
   projectId: string,
 ): Promise<() => void> {
   return getProjectMutex(projectId).acquire(LOCK_TIMEOUT_MS);

package/src/src/rendering/renderer.ts

@@ -34,7 +34,7 @@ import * as dntShim from "../../_dnt.shims.js";
 
 import { rendererLogger } from "../utils/index.js";
 import { MDXCacheAdapter } from "../transforms/mdx/index.js";
-import { SERVICE_OVERLOADED } from "../errors/error-registry.js";
+import { INITIALIZATION_ERROR, SERVICE_OVERLOADED } from "../errors/error-registry.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { buildQueryAwareCacheKey, type QueryParamCacheOptions } from "../cache/keys.js";
 import { getEnvNumber } from "../platform/compat/process.js";
@@ -90,7 +90,9 @@ const logger = rendererLogger.component("renderer");
  * Configurable via RENDER_TIMEOUT_MS env var for cold-start scenarios.
  * Default increased to 60s to handle cold-start module transforms.
  */
-const RENDER_PIPELINE_TIMEOUT_MS = getEnvNumber("RENDER_TIMEOUT_MS") ?? 60000;
+const DEFAULT_RENDER_PIPELINE_TIMEOUT_MS = 60_000;
+const RENDER_PIPELINE_TIMEOUT_MS = getEnvNumber("RENDER_TIMEOUT_MS") ??
+  DEFAULT_RENDER_PIPELINE_TIMEOUT_MS;
 
 /**
  * Options for initializing the Renderer
@@ -176,7 +178,9 @@ export class Renderer {
       "renderer.renderPage",
       async () => {
         if (!this.initialized) {
-          throw new Error("Renderer not initialized. Call initialize() first.");
+          throw INITIALIZATION_ERROR.create({
+            detail: "Renderer not initialized. Call initialize() first.",
+          });
         }
 
         const startTime = performance.now();
@@ -389,7 +393,9 @@ export class Renderer {
     options?: RenderOptions,
   ): Promise<PageDataResponse> {
     if (!this.initialized) {
-      throw new Error("Renderer not initialized. Call initialize() first.");
+      throw INITIALIZATION_ERROR.create({
+        detail: "Renderer not initialized. Call initialize() first.",
+      });
     }
 
     const services = this.createServicesForContext(ctx);
@@ -405,7 +411,9 @@ export class Renderer {
 
   getAllPages(ctx: RenderContext): Promise<string[]> {
     if (!this.initialized) {
-      throw new Error("Renderer not initialized. Call initialize() first.");
+      throw INITIALIZATION_ERROR.create({
+        detail: "Renderer not initialized. Call initialize() first.",
+      });
     }
 
     return createPageResolver(ctx).getAllPages();
@@ -419,16 +427,6 @@ export class Renderer {
     await this.cache.clearForContext(ctx);
   }
 
-  /**
-   * Clear all cached render results (across all contexts).
-   * Called by poke/invalidation handlers to ensure fresh renders.
-   * @deprecated Use clearCacheForProject for multi-tenant deployments
-   */
-  async clearAllCaches(): Promise<void> {
-    logger.debug("Clearing ALL render caches (global)");
-    await this.cache.clearAll();
-  }
-
   async clearCacheForProject(projectId: string): Promise<void> {
     logger.debug("Clearing render cache for project", { projectId });
     await this.cache.clearForProject(projectId);
@@ -543,7 +541,9 @@ let renderer: Renderer | null = null;
 
 export function getRenderer(): Renderer {
   if (!renderer) {
-    throw new Error("Renderer not initialized. Call initializeRenderer() first.");
+    throw INITIALIZATION_ERROR.create({
+      detail: "Renderer not initialized. Call initializeRenderer() first.",
+    });
   }
   return renderer;
 }
@@ -567,21 +567,6 @@ export async function destroyRenderer(): Promise<void> {
   renderer = null;
 }
 
-/**
- * Clear all cached render results from the singleton renderer.
- * Safe to call even if renderer is not initialized (no-op).
- * @deprecated Use clearRendererCacheForProject for multi-tenant deployments
- */
-export async function clearRendererCaches(): Promise<void> {
-  logger.debug("clearRendererCaches called (global)", { hasRenderer: !!renderer });
-  if (!renderer) {
-    logger.debug("No renderer instance, skipping cache clear");
-    return;
-  }
-
-  await renderer.clearAllCaches();
-}
-
 export async function clearRendererCacheForProject(projectId: string): Promise<void> {
   logger.debug("clearRendererCacheForProject called", {
     projectId,

package/src/src/rendering/router-detection.ts

@@ -9,20 +9,28 @@
 
 import { join } from "../platform/compat/path/index.js";
 import { createFileSystem } from "../platform/compat/fs.js";
+import { rendererLogger } from "../utils/index.js";
 import type { RuntimeAdapter } from "../platform/adapters/base.js";
 import type { VeryfrontConfig } from "../config/index.js";
 import { LRUCache } from "../utils/lru-wrapper.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../observability/tracing/span-names.js";
 
+const logger = rendererLogger.component("router-detection");
+
 // Re-export from app-route-resolver for backward compatibility
 export { getAppRouteEntity } from "./app-route-resolver.js";
 
+const ROUTER_DETECTION_CACHE_MAX_ENTRIES = 200;
+const ROUTER_DETECTION_CACHE_TTL_MS = 60_000;
+
 const routerDetectionCache = new LRUCache<string, boolean>({
-  maxEntries: 200,
-  ttlMs: 60_000,
+  maxEntries: ROUTER_DETECTION_CACHE_MAX_ENTRIES,
+  ttlMs: ROUTER_DETECTION_CACHE_TTL_MS,
 });
 
+let warnedMissingProjectId = false;
+
 /**
  * Clear the router detection cache. Call when filesystem changes.
  * @deprecated Use clearRouterDetectionCacheForProject for multi-tenant deployments
@@ -34,34 +42,55 @@ export function clearRouterDetectionCache(): void {
 /**
  * Clear the router detection cache for a specific project.
  * Use this in multi-tenant deployments to avoid clearing other projects' caches.
+ *
+ * @param projectId - The project ID used as cache key. Falls back to projectDir for local dev.
  */
-export function clearRouterDetectionCacheForProject(projectDir: string): void {
-  routerDetectionCache.delete(projectDir);
+export function clearRouterDetectionCacheForProject(projectId: string): void {
+  routerDetectionCache.delete(projectId);
+}
+
+export interface DetectAppRouterOptions {
+  /** Project ID for cache isolation in multi-tenant deployments */
+  projectId?: string;
 }
 
 /**
- * Detect if app router should be used based on config and directory structure
+ * Detect if app router should be used based on config and directory structure.
+ *
+ * In multi-tenant proxy mode, `projectDir` is the same for all projects ("/app"),
+ * so the cache key must use `projectId` to avoid cross-project cache poisoning.
  */
 export async function detectAppRouter(
   projectDir: string,
   config: VeryfrontConfig,
   adapter: RuntimeAdapter,
+  options?: DetectAppRouterOptions,
 ): Promise<boolean> {
   if (config?.router === "app") return true;
   if (config?.router === "pages") return false;
 
-  const cached = routerDetectionCache.get(projectDir);
+  const cacheKey = options?.projectId ?? projectDir;
+  const cached = routerDetectionCache.get(cacheKey);
   if (cached !== undefined) return cached;
 
+  if (!options?.projectId && config?.fs?.type === "veryfront-api" && !warnedMissingProjectId) {
+    warnedMissingProjectId = true;
+    logger.warn(
+      "detectAppRouter called without projectId in multi-tenant mode — cache key falls back to projectDir which may cause cross-tenant poisoning",
+      { projectDir },
+    );
+  }
+
   return await withSpan(
     SpanNames.ROUTER_DETECT_APP,
     async () => {
       const result = await detectAppRouterImpl(projectDir, config, adapter);
-      routerDetectionCache.set(projectDir, result);
+      routerDetectionCache.set(cacheKey, result);
       return result;
     },
     {
       "router.project_dir": projectDir,
+      "router.cache_key": cacheKey,
       "router.config_router": config?.router ?? "auto",
     },
   );
@@ -142,10 +171,12 @@ async function withAdapterFallback<T>(
 ): Promise<T> {
   try {
     return await adapterFn();
-  } catch {
+  } catch (_) {
+    /* expected: adapter may not support this operation */
     try {
       return await fallbackFn();
-    } catch {
+    } catch (_) {
+      /* expected: fallback may also fail */
       return defaultValue;
     }
   }

package/src/src/rendering/rsc/server-renderer/component-detector.ts

@@ -1,6 +1,7 @@
 import type * as React from "react";
 import type { ClientComponentMeta } from "../types.js";
 
+// deno-lint-ignore no-explicit-any -- RSC components accept arbitrary props at runtime
 export type RSCComponent = React.ComponentType<any> & {
   __rsc_client?: boolean;
   __rsc_id?: string;

package/src/src/rendering/rsc/server-renderer/prop-serializer.ts

@@ -62,7 +62,8 @@ function isSerializable(value: unknown, seen: WeakSet<object> = new WeakSet()):
       if (!isSerializable(v, seen)) return false;
     }
     return true;
-  } catch {
+  } catch (_) {
+    /* expected: object may have non-enumerable or throwing getters */
     return false;
   }
 }

package/src/src/rendering/rsc/server-renderer/rsc-renderer.ts

@@ -18,6 +18,7 @@ export class RSCRenderer {
   }
 
   renderToPayload(
+    // deno-lint-ignore no-explicit-any -- RSC components accept arbitrary props at runtime
     Component: React.ComponentType<any> | React.ReactElement,
     props: Record<string, unknown> = {},
   ): Promise<RSCPayload> {

package/src/src/rendering/rsc/server-renderer/tree-processor.ts

@@ -15,6 +15,7 @@ const logger = serverLogger.component("rsc");
 
 /** Recursively renders a component tree to RSC nodes */
 export async function renderTree(
+  // deno-lint-ignore no-explicit-any -- RSC components accept arbitrary props at runtime
   Component: React.ComponentType<any> | React.ReactElement | string | number | null | undefined,
   props: Record<string, unknown>,
   clientManifest: Map<string, ClientComponentMeta>,

package/src/src/rendering/script-page-handling.ts

@@ -297,10 +297,11 @@ async function readFileWithFallback(
 ): Promise<string> {
   try {
     return await adapter.fs.readFile(modulePath);
-  } catch {
+  } catch (_) {
+    /* expected: original path may not exist, try normalized path */
     try {
       return await adapter.fs.readFile(normalizedPath);
-    } catch {
+    } catch (_) {
       throw toError(
         createError({
           type: "file",