veryfront 0.1.49 → 0.1.51

package/src/src/middleware/builtin/security/redis-rate-limit.ts

@@ -43,7 +43,8 @@ export class RedisRateLimitStore implements RateLimitStore {
       const redisClientModule = ["npm:@redis/client", "@1.5.8"].join("");
       const mod = await import(redisClientModule);
       createClient = mod.createClient as (options: { url?: string }) => RedisClient;
-    } catch {
+    } catch (_) {
+      // expected: redis client module may not be installed
       this.clientPromise = null;
       throw toError(
         createError({

package/src/src/middleware/builtin/timeout.ts

@@ -10,7 +10,7 @@ import { HTTP_GATEWAY_TIMEOUT } from "../../utils/constants/http.js";
 
 const logger = serverLogger.component("timeout");
 
-const DEFAULT_TIMEOUT_MS = 60000;
+const DEFAULT_TIMEOUT_MS = 60_000;
 const TIMEOUT_SENTINEL = Symbol("timeout");
 
 export interface TimeoutOptions {

package/src/src/modules/component-registry/registry.ts

@@ -52,9 +52,10 @@ export class ComponentRegistry {
       "modules.componentRegistry.discover",
       async () => {
         this.initialized = false;
-        this.initializedPromise = this._discoverInternal().then(() => {
+        this.initializedPromise = (async () => {
+          await this._discoverInternal();
           this.initialized = true;
-        });
+        })();
         await this.initializedPromise;
       },
       { "registry.projectDir": this.options.projectDir },
@@ -234,7 +235,8 @@ export class ComponentRegistry {
           lastModified: stat.mtime?.toISOString(),
           type: "component",
         });
-      } catch {
+      } catch (_) {
+        /* expected: stat may fail for components without filesystem entries */
         components.push({ name, path: info.path, type: "component" });
       }
     }

package/src/src/modules/import-map/default-import-map.ts

@@ -32,7 +32,7 @@ function getVeryfrontSsrImportMap(): Record<string, string> {
   const react = `${base}/react/public.js${ssr}`;
 
   // Map veryfront/embedding to the React hooks submodule for SSR.
-  // The full embedding/index.ts imports heavy server-side code (vectorStore, uploadStore,
+  // The full embedding/index.ts imports heavy server-side code (vectorStore, ragStore,
   // AI SDK) that fails to transform. SSR only needs the React hook (useUploads).
   const embedding = `${base}/embedding/react/index.js${ssr}`;
 

package/src/src/modules/import-map/loader.ts

@@ -90,8 +90,8 @@ async function loadDenoJsonImportMap(
           : {};
         return { imports, scopes };
       }
-    } catch {
-      // deno.json not found in virtual filesystem
+    } catch (_) {
+      /* expected: deno.json not found in virtual filesystem */
     }
     return null;
   }
@@ -118,8 +118,8 @@ async function loadDenoJsonImportMap(
           : {};
         return { imports, scopes };
       }
-    } catch {
-      // deno.json not found in this directory, continue searching
+    } catch (_) {
+      /* expected: deno.json not found in this directory, continue searching */
     }
 
     const parent = dirname(currentPath);
@@ -153,8 +153,8 @@ export function loadImportMap(
             scopes: importMap.scopes ?? {},
           };
         }
-      } catch {
-        // Config not found or invalid, continue without it
+      } catch (_) {
+        /* expected: config not found or invalid, continue without it */
       }
 
       // Merge: defaults < deno.json < config

package/src/src/modules/import-map/preloader.ts

@@ -7,36 +7,39 @@ const importMapCache = new Map<string, Promise<ImportMapConfig>>();
 export function preloadImportMap(
   projectDir: string,
   adapter: RuntimeAdapter,
+  projectId?: string,
 ): Promise<ImportMapConfig> {
-  const cached = importMapCache.get(projectDir);
+  const cacheKey = projectId ?? projectDir;
+  const cached = importMapCache.get(cacheKey);
   if (cached) return cached;
 
   const promise = loadImportMap(projectDir, adapter);
-  importMapCache.set(projectDir, promise);
+  importMapCache.set(cacheKey, promise);
 
   promise.catch(() => {
-    importMapCache.delete(projectDir);
+    importMapCache.delete(cacheKey);
   });
 
   return promise;
 }
 
 export async function getCachedImportMap(
-  projectDir: string,
+  cacheKey: string,
 ): Promise<ImportMapConfig | undefined> {
-  const cached = importMapCache.get(projectDir);
+  const cached = importMapCache.get(cacheKey);
   if (!cached) return undefined;
 
   try {
     return await cached;
-  } catch {
+  } catch (_) {
+    /* expected: cached import map promise may have been rejected */
     return undefined;
   }
 }
 
-export function clearImportMapCache(projectDir?: string): void {
-  if (projectDir) {
-    importMapCache.delete(projectDir);
+export function clearImportMapCache(cacheKey?: string): void {
+  if (cacheKey) {
+    importMapCache.delete(cacheKey);
     return;
   }
 

package/src/src/modules/import-map/resolver.ts

@@ -23,7 +23,8 @@ function extractEsmShPackage(url: string): string | null {
 
     const packageName = pathname.split("@")[0]?.split("/")[0] ?? "";
     return packageName || null;
-  } catch {
+  } catch (_) {
+    /* expected: URL may be malformed */
     return null;
   }
 }

package/src/src/modules/react-loader/ssr-module-loader/cache/memory.ts

@@ -115,7 +115,7 @@ export async function tryAcquireTransformSlot(
 
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    await new Promise<void>((resolve) => dntShim.setTimeout(resolve, PROJECT_SLOT_RETRY_INTERVAL_MS));
+    await new Promise<void>((resolve) => dntShim.setTimeout(resolve, PROJECT_SLOT_RETRY_INTERVAL_MS)); // no cleanup needed: one-shot
     if (acquireTransformSlot(projectId)) return true;
   }
 

package/src/src/modules/react-loader/ssr-module-loader/concurrency/semaphore.ts

@@ -1,4 +1,8 @@
+/** Default timeout for acquiring a semaphore permit (ms) */
 import * as dntShim from "../../../../../_dnt.shims.js";
+
+const DEFAULT_ACQUIRE_TIMEOUT_MS = 100;
+
 export class Semaphore {
   private permits: number;
   private readonly maxQueueSize: number;
@@ -9,7 +13,7 @@ export class Semaphore {
     this.maxQueueSize = options?.maxQueueSize ?? Infinity;
   }
 
-  tryAcquire(timeoutMs = 100): Promise<boolean> {
+  tryAcquire(timeoutMs = DEFAULT_ACQUIRE_TIMEOUT_MS): Promise<boolean> {
     if (this.permits > 0) {
       this.permits--;
       return Promise.resolve(true);

package/src/src/modules/react-loader/ssr-module-loader/cross-project-import-loader.ts

@@ -1,5 +1,6 @@
 import * as dntShim from "../../../../_dnt.shims.js";
 import { getApiBaseUrlEnv } from "../../../config/env.js";
+import { CACHE_ERROR, NETWORK_ERROR } from "../../../errors/index.js";
 import type { FileSystem } from "../../../platform/compat/fs.js";
 import { injectContext } from "../../../observability/tracing/otlp-setup.js";
 import { transformToESM } from "../../../transforms/esm/index.js";
@@ -11,13 +12,13 @@ import { rendererLogger as logger } from "../../../utils/index.js";
 import { globalCrossProjectCache } from "./cache/index.js";
 import type { SSRModuleLoaderOptions } from "./types.js";
 
-export interface CrossProjectImportCache {
+interface CrossProjectImportCache {
   hashContentAsync(content: string): Promise<string>;
   getTempPath(filePath: string, contentHash?: string): Promise<string>;
   getFs(): FileSystem;
 }
 
-export interface TransformCrossProjectImportFlowOptions {
+interface TransformCrossProjectImportFlowOptions {
   crossProjectImport: CrossProjectImport;
   options: Pick<
     SSRModuleLoaderOptions,
@@ -84,9 +85,9 @@ export async function transformCrossProjectImportFlow(
     clearTimeout(timeout);
 
     if (!response.ok) {
-      throw new Error(
-        `Failed to fetch ${registryUrl}: ${response.status} ${response.statusText}`,
-      );
+      throw NETWORK_ERROR.create({
+        detail: `Failed to fetch ${registryUrl}: ${response.status} ${response.statusText}`,
+      });
     }
 
     const sourceCode = await response.text();
@@ -125,7 +126,9 @@ export async function transformCrossProjectImportFlow(
         "SSR-MODULE-LOADER",
       );
       if (!written) {
-        throw new Error(`Failed to write cross-project import cache file: ${tempPath}`);
+        throw CACHE_ERROR.create({
+          detail: `Failed to write cross-project import cache file: ${tempPath}`,
+        });
       }
 
       globalCrossProjectCache.set(cacheKey, { tempPath, contentHash });

package/src/src/modules/react-loader/ssr-module-loader/http-bundle-helpers.ts

@@ -10,11 +10,14 @@
 import { createFileSystem, exists } from "../../../platform/compat/fs.js";
 import { LRUCache } from "../../../utils/lru-wrapper.js";
 
+/** Max entries in the verified HTTP bundle paths LRU cache */
+const VERIFIED_BUNDLE_CACHE_MAX_ENTRIES = 2_000;
+
 /**
  * Extract VF module paths (veryfront-mdx-esm/*.mjs) from code.
  * These are user project modules that may import HTTP bundles.
  */
-export function extractVfModulePaths(code: string): string[] {
+function extractVfModulePaths(code: string): string[] {
   // Create regex per call to avoid shared lastIndex state across concurrent calls.
   const vfModulePattern = /file:\/\/([^"'\s]+veryfront-mdx-esm\/[^"'\s]+\.mjs)/gi;
   const paths: string[] = [];
@@ -83,8 +86,8 @@ export async function extractAllHttpBundlePathsRecursive(
           pendingVfModules.push(nestedPath);
         }
       }
-    } catch {
-      // Ignore read errors for VF modules
+    } catch (_) {
+      /* expected: VF module file may fail to read */
     }
   }
 
@@ -154,4 +157,6 @@ export function extractAllFilePaths(code: string): string[] {
  * Bounded LRU to prevent unbounded memory growth in long-running pods.
  * Keying by contentHash ensures verification is re-done when content changes at the same path.
  */
-export const verifiedHttpBundlePaths = new LRUCache<string, true>({ maxEntries: 2000 });
+export const verifiedHttpBundlePaths = new LRUCache<string, true>({
+  maxEntries: VERIFIED_BUNDLE_CACHE_MAX_ENTRIES,
+});

package/src/src/modules/react-loader/ssr-module-loader/loader.ts

@@ -642,7 +642,7 @@ export class SSRModuleLoader {
         }
 
         if (isSSRDistributedCacheEnabled()) {
-          setInRedis(contentCacheKey, transformed, {
+          void setInRedis(contentCacheKey, transformed, {
             isProduction: this.cache.isProductionContentSource(),
           }).catch((error) => {
             logger.debug("Distributed cache set failed", {

package/src/src/modules/react-loader/ssr-module-loader/preflight-imports.ts

@@ -1,7 +1,7 @@
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import type { LocalImport, MissingImport } from "../../../transforms/esm/import-parser.js";
 
-export interface PreflightImportsResult {
+interface PreflightImportsResult {
   validImports: LocalImport[];
   missingImports: MissingImport[];
 }
@@ -31,7 +31,8 @@ export async function preflightLocalImports(
           reason: `Pre-flight: not a file on disk: ${imp.absolutePath}`,
         });
       }
-    } catch {
+    } catch (_) {
+      /* expected: file may not be accessible on disk */
       missingImports.push({
         specifier: imp.specifier,
         fromFile: filePath,

package/src/src/modules/react-loader/ssr-module-loader/ssr-cache-manager.ts

@@ -10,6 +10,7 @@ import * as dntShim from "../../../../_dnt.shims.js";
 
 
 import { VERSION } from "../../../utils/version.js";
+import { INVALID_ARGUMENT } from "../../../errors/index.js";
 import { buildSSRModuleCacheKey } from "../../../cache/keys.js";
 import { computeConfigHashSync } from "../../../cache/config-hash.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
@@ -28,6 +29,9 @@ import type { ModuleCacheEntry, SSRModuleLoaderOptions } from "./types.js";
 
 const logger = rendererLogger.component("ssr-module-loader");
 
+/** Content length threshold: below this, use fast sync hash; above, use async SHA-256 */
+const SYNC_HASH_THRESHOLD = 10_000;
+
 const UNRESOLVED_VF_MODULE_IMPORT_PATTERN =
   /from\s*["']((?:file:\/\/)?\/?\/?_vf_modules\/[^"']+)["']/;
 
@@ -58,9 +62,10 @@ export class SSRCacheManager {
 
   getCacheKey(filePath: string): string {
     if (!this.options.contentSourceId) {
-      throw new Error(
-        `Missing contentSourceId for SSR module cache (project: ${this.options.projectId}, file: ${filePath})`,
-      );
+      throw INVALID_ARGUMENT.create({
+        detail:
+          `Missing contentSourceId for SSR module cache (project: ${this.options.projectId}, file: ${filePath})`,
+      });
     }
 
     const reactVersion = this.options.reactVersion ?? "default";
@@ -74,7 +79,7 @@ export class SSRCacheManager {
   }
 
   async hashContentAsync(content: string): Promise<string> {
-    if (content.length < 10000) return hashCodeHex(content);
+    if (content.length < SYNC_HASH_THRESHOLD) return hashCodeHex(content);
 
     try {
       const data = new TextEncoder().encode(content);
@@ -84,7 +89,8 @@ export class SSRCacheManager {
         .slice(0, 8)
         .map((b) => b.toString(16).padStart(2, "0"))
         .join("");
-    } catch {
+    } catch (_) {
+      /* expected: WebCrypto may not be available, fall back to sync hash */
       return hashCodeHex(content);
     }
   }
@@ -172,7 +178,8 @@ export class SSRCacheManager {
       }
       verifiedHttpBundlePaths.set(verifyKey, true);
       return globalModuleCache.has(contentCacheKey);
-    } catch {
+    } catch (error) {
+      logger.debug("Failed to validate memory cache entry, invalidating", { error });
       this.invalidateContentAndFileCacheEntries(contentCacheKey, filePathCacheKey, cachedEntry);
       return false;
     }
@@ -236,10 +243,11 @@ export class SSRCacheManager {
         if (!stat.isFile) {
           return true;
         }
-      } catch {
+      } catch (error) {
         logger.debug("Redis cache has invalid local path, re-transforming", {
           file: filePath.slice(-40),
           missingPath: path.slice(-60),
+          error,
         });
         return true;
       }
@@ -252,12 +260,14 @@ export class SSRCacheManager {
     const { projectId, contentSourceId } = this.options;
 
     if (!projectId) {
-      throw new Error(
-        `Missing projectId for SSR temp directory (projectDir: ${this.options.projectDir})`,
-      );
+      throw INVALID_ARGUMENT.create({
+        detail: `Missing projectId for SSR temp directory (projectDir: ${this.options.projectDir})`,
+      });
     }
     if (!contentSourceId) {
-      throw new Error(`Missing contentSourceId for SSR temp directory (project: ${projectId})`);
+      throw INVALID_ARGUMENT.create({
+        detail: `Missing contentSourceId for SSR temp directory (project: ${projectId})`,
+      });
     }
 
     const baseCacheDir = getMdxEsmCacheDir();

package/src/src/modules/react-loader/ssr-module-loader/vf-module-resolver.ts

@@ -86,8 +86,17 @@ export async function resolveVfModuleImports(
 
   const results = await Promise.all(
     imports.map(async ({ original, path }) => {
-      const cachedFilePath = await fetchAndCacheModule(path, fetcherContext);
-      return { original, path, cachedFilePath };
+      try {
+        const cachedFilePath = await fetchAndCacheModule(path, fetcherContext);
+        return { original, path, cachedFilePath };
+      } catch (error) {
+        logger.warn("Failed to fetch _vf_modules import", {
+          file: options.filePath.slice(-40),
+          path,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return { original, path, cachedFilePath: null };
+      }
     }),
   );
 

package/src/src/modules/react-loader/unified-loader.ts

@@ -58,13 +58,13 @@ export function loadComponentsUnified(
   );
 }
 
-function transformAllComponents(
+async function transformAllComponents(
   components: ComponentSource[],
   projectDir: string,
   adapter: RuntimeAdapter,
   transformOpts: TransformOptions,
 ): Promise<TransformedComponent[]> {
-  return Promise.all(
+  return await Promise.all(
     components.map(async (comp) => ({
       name: comp.name,
       code: await transformToESM(comp.source, comp.filePath, projectDir, adapter, transformOpts),

package/src/src/modules/server/module-batch-handler.ts

@@ -45,9 +45,15 @@ const SLOW_REQUEST_THRESHOLD_MS = 500;
 /** Slow module transform threshold in milliseconds */
 const SLOW_TRANSFORM_THRESHOLD_MS = 100;
 
+/** Max entries in the per-project transform LRU cache */
+const TRANSFORM_CACHE_MAX_ENTRIES = 1_000;
+
+/** Immutable cache max-age in seconds (1 year) */
+const IMMUTABLE_CACHE_MAX_AGE_SECONDS = 31_536_000;
+
 /** Cache for transformed modules (path -> code) */
 const transformCache = new LRUCache<string, string>({
-  maxEntries: 1000,
+  maxEntries: TRANSFORM_CACHE_MAX_ENTRIES,
 });
 
 // Register cache for monitoring
@@ -250,7 +256,7 @@ export function handleModuleBatch(req: dntShim.Request, options: BatchHandlerOpt
         status: HTTP_OK,
         headers: {
           "Content-Type": "application/javascript; charset=utf-8",
-          "Cache-Control": "public, max-age=31536000, immutable",
+          "Cache-Control": `public, max-age=${IMMUTABLE_CACHE_MAX_AGE_SECONDS}, immutable`,
           "X-Batch-Modules": String(successes.length),
           "X-Batch-Duration": String(Math.round(duration)),
           "X-Batch-Slow": isSlow ? "true" : "false",
@@ -291,8 +297,8 @@ async function loadAndTransformModule(
 
       const source = await secureFs.readFile(fullPath);
       return transformModule(source, fullPath, projectDir, adapter, options);
-    } catch {
-      // Continue trying
+    } catch (_) {
+      /* expected: file may not exist at this extension */
     }
   }
 
@@ -314,8 +320,8 @@ async function loadAndTransformModule(
 
         const source = await platformFs.readTextFile(frameworkPath);
         return transformModule(source, frameworkPath, projectDir, adapter, options);
-      } catch {
-        // Continue trying
+      } catch (_) {
+        /* expected: framework file may not exist at this extension */
       }
     }
   }

package/src/src/modules/server/module-server.ts

@@ -18,7 +18,6 @@ import { parseProjectDomain } from "../../server/utils/domain-parser.js";
 import { applySSRImportRewrites } from "./ssr-import-rewriter.js";
 import { addHMRTimestamps } from "../../transforms/esm/import-rewriter.js";
 import { getFrameworkRootFromMeta } from "../../platform/compat/vfs-paths.js";
-import { isDenoCompiled } from "../../platform/compat/runtime.js";
 
 const logger = serverLogger.component("module-server");
 
@@ -84,37 +83,6 @@ export default {};
   "_dnt.polyfills": `export default {};\n`,
 };
 
-/**
- * Validate that all required polyfills are embedded.
- * Call this at startup in compiled mode to fail fast if polyfills are missing.
- *
- * @throws Error if any required polyfill is missing from EMBEDDED_POLYFILLS
- */
-export async function validateEmbeddedPolyfills(): Promise<void> {
-  if (!isDenoCompiled) return; // Only validate in compiled mode
-
-  // Dynamic import to avoid circular dependency at module load time
-  const { getRequiredPolyfillPaths } = await import(
-    "../../transforms/import-rewriter/strategies/node-builtin-strategy.js"
-  );
-
-  const requiredPaths = getRequiredPolyfillPaths();
-  const embeddedPaths = new Set(Object.keys(EMBEDDED_POLYFILLS));
-
-  const missing = requiredPaths.filter((path: string) => !embeddedPaths.has(path));
-
-  if (missing.length > 0) {
-    const errorMsg = `FATAL: Missing embedded polyfills (will cause 404 errors in browser):\n` +
-      missing.map((p: string) => `  - ${p}`).join("\n") +
-      `\n\nAdd these to EMBEDDED_POLYFILLS in src/modules/server/module-server.ts`;
-
-    logger.error(errorMsg);
-    throw new Error(errorMsg);
-  }
-
-  logger.info(`Validated ${embeddedPaths.size} embedded polyfills`);
-}
-
 const DEV_MODULE_PREFIX = /^\/(?:_vf_modules|_veryfront\/modules)\//;
 const SNIPPET_MODULE_PREFIX = /^\/_vf_modules\/_snippets\/([a-f0-9]+)\.js/;
 // Cross-project import patterns: /_vf_modules/_cross/<slug>[@<version>]/@/<path>
@@ -557,8 +525,8 @@ async function findSourceFile(
             });
             return { path: frameworkPath, isFrameworkFile: true };
           }
-        } catch {
-          // continue
+        } catch (_) {
+          /* expected: file may not exist at this extension */
         }
       }
     }
@@ -590,8 +558,8 @@ async function findSourceFile(
         });
         return { path: fullPath, isFrameworkFile: false };
       }
-    } catch {
-      // continue
+    } catch (_) {
+      /* expected: file may not exist at this path */
     }
   }
 
@@ -604,8 +572,8 @@ async function findSourceFile(
         logger.debug("Found file", { basePath, resolvedPath: fullPath });
         return { path: fullPath, isFrameworkFile: false };
       }
-    } catch {
-      // continue
+    } catch (_) {
+      /* expected: file may not exist at this extension */
     }
   }
 
@@ -626,8 +594,8 @@ async function findSourceFile(
           });
           return { path: fullPath, isFrameworkFile: false };
         }
-      } catch {
-        // continue
+      } catch (_) {
+        /* expected: file may not exist after stripping prefix */
       }
     }
   }
@@ -643,8 +611,8 @@ async function findSourceFile(
         });
         return { path: fullPath, isFrameworkFile: false };
       }
-    } catch {
-      // continue
+    } catch (_) {
+      /* expected: index file may not exist at this extension */
     }
   }
 
@@ -662,8 +630,8 @@ async function findSourceFile(
           });
           return { path: fullPath, isFrameworkFile: false };
         }
-      } catch {
-        // continue
+      } catch (_) {
+        /* expected: file may not exist in common directory */
       }
     }
   }

package/src/src/modules/server/ssr-import-rewriter.ts

@@ -5,7 +5,7 @@ import {
 import { isDeno, isNode } from "../../platform/compat/runtime.js";
 import { getLocalReactPaths } from "../../platform/compat/react-paths.js";
 
-export interface SSRRewriteOptions {
+interface SSRRewriteOptions {
   /** Project slug for multi-project routing */
   projectSlug?: string | null;
   /** Branch name for branch-aware routing */

package/src/src/modules/server/websocket-handler.ts

@@ -123,7 +123,7 @@ export async function closeAllConnections(
   // Alternate between microtasks and macrotasks to ensure all I/O completes.
   for (let i = 0; i < 10; i++) {
     await Promise.resolve();
-    await new Promise((resolve) => dntShim.setTimeout(resolve, 50));
+    await new Promise((resolve) => dntShim.setTimeout(resolve, 50)); // no cleanup needed: one-shot
   }
 
   for (const client of clients) {