veryfront 0.1.49 → 0.1.51

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/distributed-cache.ts

@@ -39,7 +39,7 @@ type DistributedCache = NonNullable<Awaited<ReturnType<typeof getDistributedTran
  * Always returns the `distributedCache` handle (if available) so it can be
  * reused for writing after transform, even when the read was a miss.
  */
-export interface DistributedCacheReadResult {
+interface DistributedCacheReadResult {
   /** The validated module code, or null if cache miss / validation failure */
   code: string | null;
   /** The distributed cache backend (for subsequent writes) */
@@ -210,19 +210,22 @@ export function writeDistributedCache(
   const bundlePaths = extractHttpBundlePaths(moduleCode);
   if (bundlePaths.length > 0) {
     const entries = bundlePaths.map((b) => ({ hash: b.hash, url: "", sizeBytes: 0 }));
-    createBundleManifest(entries).then(async (manifest) => {
-      await storeBundleManifest(manifest);
-      const bundleManifestKey = `${transformCacheKey}:bm`;
-      await distributedCache.set(
-        bundleManifestKey,
-        manifest.manifestId,
-        TRANSFORM_CACHE_TTL_SECONDS,
-      );
-    }).catch((error) => {
-      log.debug(`${LOG_PREFIX_MDX_LOADER} Bundle manifest creation failed`, {
-        normalizedPath,
-        error,
-      });
-    });
+    void (async () => {
+      try {
+        const manifest = await createBundleManifest(entries);
+        await storeBundleManifest(manifest);
+        const bundleManifestKey = `${transformCacheKey}:bm`;
+        await distributedCache.set(
+          bundleManifestKey,
+          manifest.manifestId,
+          TRANSFORM_CACHE_TTL_SECONDS,
+        );
+      } catch (error) {
+        log.debug(`${LOG_PREFIX_MDX_LOADER} Bundle manifest creation failed`, {
+          normalizedPath,
+          error,
+        });
+      }
+    })();
   }
 }

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/framework-validator.ts

@@ -88,7 +88,8 @@ export async function hasIncompatibleFrameworkPaths(code: string, log: Logger):
         log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path does not exist`, { path });
         return true;
       }
-    } catch {
+    } catch (_) {
+      /* expected: framework file may not exist in this environment */
       log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path not accessible`, { path });
       return true;
     }
@@ -128,7 +129,8 @@ export async function findMissingFileDependenciesInCode(
         log.debug(`${LOG_PREFIX_MDX_LOADER} File dependency does not exist`, { path: cleanPath });
         missing.push(cleanPath);
       }
-    } catch {
+    } catch (_) {
+      /* expected: file dependency may not exist on this pod */
       log.debug(`${LOG_PREFIX_MDX_LOADER} File dependency not accessible`, { path: cleanPath });
       missing.push(cleanPath);
     }
@@ -141,7 +143,7 @@ export async function findMissingFileDependenciesInCode(
  * Check if code contains raw HTTP URLs that would fail in compiled binary mode.
  * Compiled binaries cannot do dynamic HTTP imports.
  */
-export function hasRawHttpImports(code: string): boolean {
+function hasRawHttpImports(code: string): boolean {
   // Match HTTP URLs in import statements: from "https://..." or from 'https://...'
   const httpImportPattern = /from\s+["'](https?:\/\/[^"']+)["']/gi;
   return httpImportPattern.test(code);
@@ -168,8 +170,8 @@ export async function validateCachedModule(
     pathCache.delete(versionedKey);
     try {
       await getLocalFs().remove(cachedPath);
-    } catch {
-      /* ignore removal errors */
+    } catch (_) {
+      /* expected: cached file may already be removed */
     }
     return false;
   }
@@ -200,8 +202,8 @@ export async function validateCachedModule(
   pathCache.delete(versionedKey);
   try {
     await getLocalFs().remove(cachedPath);
-  } catch {
-    /* ignore removal errors */
+  } catch (_) {
+    /* expected: cached file may already be removed */
   }
   return false;
 }

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/index.ts

@@ -215,7 +215,8 @@ async function doFetchAndCacheModule(
           return cachedPath;
         }
       }
-    } catch {
+    } catch (_) {
+      /* expected: cached file may no longer exist on disk */
       pathCache.delete(versionedKey);
     }
   }

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/module-cache.ts

@@ -71,8 +71,8 @@ export async function cacheModule(
       recordModuleToSession(normalizedPath);
       return cachePath;
     }
-  } catch {
-    // Not cached, write it
+  } catch (_) {
+    /* expected: cached file may not exist yet */
   }
 
   await localFs.mkdir(esmCacheDir, { recursive: true });

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/render-sessions.ts

@@ -80,7 +80,7 @@ export function endRenderSession(sessionId: string): void {
  * Get the current active render session (if any).
  * Used to record modules during fetch and for per-session in-flight deduplication.
  */
-export function getCurrentSession(): RenderSession | null {
+function getCurrentSession(): RenderSession | null {
   const firstSession = renderSessions.values().next();
   return firstSession.done ? null : firstSession.value;
 }

package/src/src/transforms/mdx/esm-module-loader/module-writer.ts

@@ -11,6 +11,13 @@
 import { join } from "../../../platform/compat/path/index.js";
 import React from "react";
 import { rendererLogger as logger } from "../../../utils/index.js";
+import {
+  BUILD_FAILED,
+  BUNDLE_ERROR,
+  CACHE_ERROR,
+  IMPORT_RESOLUTION_ERROR,
+  INVALID_ARGUMENT,
+} from "../../../errors/index.js";
 import { getErrorCollector } from "../../../observability/error-collector.js";
 import { withSpan } from "../../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../../observability/tracing/span-names.js";
@@ -66,7 +73,7 @@ const mdxWriteFlight = new Singleflight<void>();
  * Note: We always cache HTTP imports for consistency between compiled and
  * non-compiled modes, allowing them to share the same cache.
  */
-export async function cacheHttpImports(code: string, importMap: ImportMapConfig): Promise<string> {
+async function cacheHttpImports(code: string, importMap: ImportMapConfig): Promise<string> {
   const result = await cacheHttpImportsToLocal(code, {
     cacheDir: getHttpBundleCacheDir(),
     importMap,
@@ -149,9 +156,9 @@ export async function doLoadModuleESM(
     logger.debug(`${LOG_PREFIX_MDX_LOADER} Step: transformReactToLocalPaths DONE`, { projectSlug });
 
     if (!context.projectId) {
-      throw new Error(
-        `Missing projectId for MDX module cache (projectSlug: ${context.projectSlug})`,
-      );
+      throw INVALID_ARGUMENT.create({
+        detail: `Missing projectId for MDX module cache (projectSlug: ${context.projectSlug})`,
+      });
     }
 
     let codeHash = hashString(rewritten);
@@ -174,7 +181,7 @@ export async function doLoadModuleESM(
         unresolvedPaths.join(", ")
       }`;
       logger.error(`${LOG_PREFIX_MDX_RENDERER} ${errorMsg}`);
-      throw new Error(errorMsg);
+      throw IMPORT_RESOLUTION_ERROR.create({ detail: errorMsg });
     }
 
     const nsDir = join(esmCacheDir, namespaceKey);
@@ -196,7 +203,7 @@ export async function doLoadModuleESM(
       logger.debug(`${LOG_PREFIX_MDX_LOADER} Writing module file`, { projectSlug, filePath });
       const written = await writeCacheFile(localFs, filePath, rewritten, "MDX-ESM-LOADER");
       if (!written) {
-        throw new Error(`Failed to write MDX module cache file: ${filePath}`);
+        throw BUILD_FAILED.create({ detail: `Failed to write MDX module cache file: ${filePath}` });
       }
     });
     logger.debug(`${LOG_PREFIX_MDX_LOADER} Step: mdxWriteFlight DONE`, { projectSlug, filePath });
@@ -258,9 +265,9 @@ export async function doLoadModuleESM(
               "MDX-ESM-LOADER",
             );
             if (!written) {
-              throw new Error(
-                `Failed to write refreshed MDX module cache file: ${refreshedPath}`,
-              );
+              throw BUILD_FAILED.create({
+                detail: `Failed to write refreshed MDX module cache file: ${refreshedPath}`,
+              });
             }
           });
 
@@ -278,11 +285,11 @@ export async function doLoadModuleESM(
           if (refreshedBundles.length > 0) {
             const stillFailed = await ensureHttpBundlesExist(refreshedBundles, cacheDir);
             if (stillFailed.length > 0) {
-              throw new Error(
-                `Failed to recover ${stillFailed.length} HTTP bundle(s) after re-fetch: ${
+              throw BUNDLE_ERROR.create({
+                detail: `Failed to recover ${stillFailed.length} HTTP bundle(s) after re-fetch: ${
                   stillFailed.join(", ")
                 }`,
-              );
+              });
             }
           }
         }
@@ -333,9 +340,9 @@ export async function doLoadModuleESM(
             "MDX-ESM-LOADER",
           );
           if (!written) {
-            throw new Error(
-              `Failed to write regenerated MDX module cache file: ${refreshedPath}`,
-            );
+            throw BUILD_FAILED.create({
+              detail: `Failed to write regenerated MDX module cache file: ${refreshedPath}`,
+            });
           }
         });
 
@@ -353,9 +360,11 @@ export async function doLoadModuleESM(
           extractFrameworkBundlePaths(rewritten),
         );
         if (stillMissing.length > 0) {
-          throw new Error(
-            `Failed to regenerate ${stillMissing.length} framework bundle(s): ${stillMissing[0]}`,
-          );
+          throw BUNDLE_ERROR.create({
+            detail: `Failed to regenerate ${stillMissing.length} framework bundle(s): ${
+              stillMissing[0]
+            }`,
+          });
         }
 
         logger.debug(`${LOG_PREFIX_MDX_LOADER} Framework bundles regenerated successfully`, {
@@ -368,9 +377,9 @@ export async function doLoadModuleESM(
     // Verify the cache file exists before attempting dynamic import
     const fileExists = await verifyCacheFileExists(localFs, filePath, "MDX-ESM-LOADER");
     if (!fileExists) {
-      throw new Error(
-        `MDX module cache file missing before import: ${filePath}`,
-      );
+      throw CACHE_ERROR.create({
+        detail: `MDX module cache file missing before import: ${filePath}`,
+      });
     }
 
     const mod = await withSpan(

package/src/src/transforms/mdx/esm-module-loader/resolution/file-finder.ts

@@ -54,7 +54,8 @@ async function tryReadFile(
   try {
     const content = await readFile(path);
     return { sourceCode: decodeContent(content), actualFilePath: path };
-  } catch {
+  } catch (_) {
+    /* expected: file may not exist at this path */
     return null;
   }
 }
@@ -171,8 +172,8 @@ export async function resolveModuleFile(
           lookupDir,
         });
         return { sourceCode: content, actualFilePath: frameworkPath };
-      } catch {
-        // Continue trying other extensions/directories
+      } catch (_) {
+        /* expected: file may not exist with this extension/directory combination */
       }
     }
   }

package/src/src/transforms/mdx/esm-module-loader/types.ts

@@ -28,12 +28,12 @@ export interface FSAdapter {
   makeTempDir(prefix: string): Promise<string>;
 }
 
-export interface ImportMatch {
+interface ImportMatch {
   original: string;
   path: string;
 }
 
-export interface ModuleFetchResult {
+interface ModuleFetchResult {
   original: string;
   filePath: string | null;
   path: string;
@@ -76,7 +76,7 @@ export interface ModuleFetcherContext {
   transformDeadline?: number;
 }
 
-export interface JSXTransform {
+interface JSXTransform {
   original: string;
   transformed: string;
 }

package/src/src/transforms/mdx/esm-module-loader/utils/stub-module.ts

@@ -92,8 +92,8 @@ export async function createStubModule(
         namedImports,
         importStatement,
       });
-    } catch {
-      // Error collector may not be initialized in all contexts
+    } catch (_) {
+      /* expected: error collector may not be initialized in all contexts */
     }
 
     logger.error(`${LOG_PREFIX_MDX_LOADER} Missing module: ${modulePath}`, {

package/src/src/transforms/pipeline/index.ts

@@ -337,8 +337,9 @@ export async function transformToESM(
 /** Extract readFile from adapter if available, for dependency hash computation. */
 function extractReadFile(adapter: unknown): ((path: string) => Promise<string>) | undefined {
   const a = adapter as { fs?: { readFile?: (path: string) => Promise<string> } } | null;
-  if (typeof a?.fs?.readFile !== "function") return undefined;
-  return (path: string) => a.fs!.readFile!(path);
+  const readFile = a?.fs?.readFile;
+  if (typeof readFile !== "function") return undefined;
+  return (path: string) => readFile.call(a!.fs, path);
 }
 
 /**

package/src/src/transforms/pipeline/stages/compile.ts

@@ -1,5 +1,6 @@
 import { getEsbuild } from "../../../platform/compat/esbuild.js";
 import { rendererLogger } from "../../../utils/index.js";
+import { COMPILATION_ERROR } from "../../../errors/index.js";
 import { getErrorCollector } from "../../../observability/error-collector.js";
 import { getLoaderFromPath } from "../../esm/transform-utils.js";
 import { type TransformContext, type TransformPlugin, TransformStage } from "../types.js";
@@ -60,7 +61,10 @@ export const compilePlugin: TransformPlugin = {
 
       getErrorCollector().addCompileError(errorMsg, ctx.filePath);
 
-      throw new Error(`ESM transform failed for ${ctx.filePath} (loader: ${loader}): ${errorMsg}`);
+      throw COMPILATION_ERROR.create({
+        detail: `ESM transform failed for ${ctx.filePath} (loader: ${loader}): ${errorMsg}`,
+        cause: err,
+      });
     }
   },
 };

package/src/src/transforms/pipeline/stages/ssr-vf-modules/path-resolver.ts

@@ -33,8 +33,8 @@ export async function tryReadWithExtensions(
         const content = await fs.readTextFile(sourcePath);
         return { sourcePath, content };
       }
-    } catch {
-      // Continue trying other extensions
+    } catch (_) {
+      /* expected: file may not exist at this extension */
     }
   }
   return null;
@@ -140,14 +140,14 @@ export async function resolveVeryfrontSourcePath(specifier: string): Promise<str
       try {
         const srcPath = basePath + ".src";
         if (await exists(srcPath)) return srcPath;
-      } catch {
-        // Continue
+      } catch (_) {
+        /* expected: file may not exist at this path */
       }
       // Try exact path
       try {
         if (await exists(basePath)) return basePath;
-      } catch {
-        // Continue
+      } catch (_) {
+        /* expected: file may not exist at this path */
       }
       continue;
     }
@@ -163,8 +163,8 @@ export async function resolveVeryfrontSourcePath(specifier: string): Promise<str
       const pathWithExt = basePath + ext;
       try {
         if (await exists(pathWithExt)) return pathWithExt;
-      } catch {
-        // Continue
+      } catch (_) {
+        /* expected: file may not exist at this path */
       }
     }
 
@@ -173,8 +173,8 @@ export async function resolveVeryfrontSourcePath(specifier: string): Promise<str
       const indexPath = join(basePath, "index" + ext);
       try {
         if (await exists(indexPath)) return indexPath;
-      } catch {
-        // Continue
+      } catch (_) {
+        /* expected: file may not exist at this path */
       }
     }
   }
@@ -216,16 +216,16 @@ export async function resolveRelativeFrameworkImport(
     // Try exact path first
     try {
       if (await exists(basePath)) return basePath;
-    } catch {
-      // Continue
+    } catch (_) {
+      /* expected: file may not exist at this path */
     }
 
     // Try with .src suffix for embedded sources
     try {
       const srcPath = basePath + ".src";
       if (await exists(srcPath)) return srcPath;
-    } catch {
-      // Continue
+    } catch (_) {
+      /* expected: file may not exist at this path */
     }
 
     // Not found with explicit extension
@@ -242,8 +242,8 @@ export async function resolveRelativeFrameworkImport(
     const pathWithExt = basePath + ext;
     try {
       if (await exists(pathWithExt)) return pathWithExt;
-    } catch {
-      // Continue
+    } catch (_) {
+      /* expected: file may not exist at this path */
     }
   }
 
@@ -252,8 +252,8 @@ export async function resolveRelativeFrameworkImport(
     const indexPath = join(basePath, "index" + ext);
     try {
       if (await exists(indexPath)) return indexPath;
-    } catch {
-      // Continue
+    } catch (_) {
+      /* expected: file may not exist at this path */
     }
   }
 

package/src/src/transforms/pipeline/stages/ssr-vf-modules/transform.ts

@@ -8,6 +8,7 @@
 import { createFileSystem } from "../../../../platform/compat/fs.js";
 import { join } from "../../../../platform/compat/path/index.js";
 import { rendererLogger as logger } from "../../../../utils/index.js";
+import { IMPORT_RESOLUTION_ERROR } from "../../../../errors/index.js";
 import { replaceSpecifiers } from "../../../esm/lexer.js";
 import { hashCodeHex } from "../../../../utils/hash-utils.js";
 import { getHttpBundleCacheDir, getMdxEsmCacheDir } from "../../../../utils/cache-dir.js";
@@ -175,13 +176,14 @@ export async function transformFrameworkCode(
       if (resolved) {
         veryfrontReplacements.set(specifier, resolved);
       } else if (throwOnMissingImport) {
-        throw new Error(
-          `${LOG_PREFIX} Could not resolve framework import "${specifier}" in ${sourcePath}. ` +
+        throw IMPORT_RESOLUTION_ERROR.create({
+          detail:
+            `${LOG_PREFIX} Could not resolve framework import "${specifier}" in ${sourcePath}. ` +
             `Expected to find ${
               join(FRAMEWORK_ROOT, "src", specifier.slice("#veryfront/".length))
             }.{ts,tsx,js,jsx} ` +
             `or an index file at that path.`,
-        );
+        });
       }
     }
 
@@ -211,9 +213,10 @@ export async function transformFrameworkCode(
         const resolvedPath = await resolveRelativeFrameworkImport(specifier, sourcePath, ctx.fs);
         if (!resolvedPath) {
           if (throwOnMissingImport) {
-            throw new Error(
-              `${LOG_PREFIX} Could not resolve relative import "${specifier}" in ${sourcePath}`,
-            );
+            throw IMPORT_RESOLUTION_ERROR.create({
+              detail:
+                `${LOG_PREFIX} Could not resolve relative import "${specifier}" in ${sourcePath}`,
+            });
           }
           logger.warn(
             `${LOG_PREFIX} Could not resolve relative import "${specifier}" in ${sourcePath}`,

package/src/src/transforms/plugins/babel-node-positions.ts

@@ -26,7 +26,6 @@ interface BabelGeneratorResult {
   map?: unknown;
 }
 
-// deno-lint-ignore no-explicit-any
 type TraverseFunction = (ast: t.Node, opts: Record<string, unknown>) => void;
 type GenerateFunction = (ast: t.Node, opts?: Record<string, unknown>) => BabelGeneratorResult;
 
@@ -178,7 +177,8 @@ export function injectNodePositions(source: string, options: TransformOptions):
       retainLines: true,
       compact: false,
     }).code;
-  } catch {
+  } catch (_) {
+    /* expected: source may not be parseable TSX/JSX */
     return source;
   }
 }

package/src/src/transforms/plugins/plugin-loader.ts

@@ -8,7 +8,7 @@ import remarkGfm from "remark-gfm";
 import { remarkMdxHeadings } from "./remark-headings.js";
 import { remarkCodeBlocks, remarkMdxRemoveParagraphs } from "./remark-mdx-utils.js";
 
-export type PluginFunction = (
+type PluginFunction = (
   tree: MdastRoot | HastRoot,
   file?: unknown,
 ) =>

package/src/src/transforms/plugins/rehype-node-positions.ts

@@ -15,7 +15,7 @@
 import type { Element, Root } from "@types/hast";
 import { visit } from "unist-util-visit";
 
-export interface RehypeNodePositionsOptions {
+interface RehypeNodePositionsOptions {
   filePath?: string;
 }
 

package/src/src/transforms/shared/cross-project-import.ts

@@ -1,4 +1,4 @@
-export interface ParsedCrossProjectImport {
+interface ParsedCrossProjectImport {
   projectSlug: string;
   version: string;
   path: string;

package/src/src/transforms/veryfront-module-urls.ts

@@ -52,7 +52,3 @@ for (const [key, target] of Object.entries(config.exports ?? {})) {
 export function resolveVeryfrontModuleUrl(specifier: string): string | null {
   return veryfrontModuleUrlMap.get(specifier) ?? null;
 }
-
-export function getVeryfrontModuleUrlMap(): Record<string, string> {
-  return Object.fromEntries(veryfrontModuleUrlMap);
-}

package/src/src/types/entities/getEntityInfo.ts

@@ -97,8 +97,8 @@ export async function getEntityInfo(
             const extracted = extract(content);
             frontmatter = extracted.attrs as Frontmatter;
             body = extracted.body;
-          } catch {
-            // Malformed YAML frontmatter - continue with empty frontmatter
+          } catch (_) {
+            /* expected: malformed YAML frontmatter */
           }
         }
 
@@ -113,20 +113,24 @@ export async function getEntityInfo(
           try {
             const adapterFs = adapter.fs;
             if (isExtendedFSAdapter(adapterFs) && adapterFs.isVeryfrontAdapter()) {
-              const underlyingAdapter = adapterFs.getUnderlyingAdapter() as {
-                getEntityIdForPath?: (path: string) => string | undefined;
-              };
-
-              const getEntityIdForPath = underlyingAdapter?.getEntityIdForPath;
-              if (getEntityIdForPath) {
+              const underlyingAdapter = adapterFs.getUnderlyingAdapter();
+
+              if (
+                underlyingAdapter &&
+                "getEntityIdForPath" in underlyingAdapter &&
+                typeof underlyingAdapter.getEntityIdForPath === "function"
+              ) {
+                const getEntityIdForPath = underlyingAdapter.getEntityIdForPath as (
+                  path: string,
+                ) => string | undefined;
                 const relativePath = filePath
                   .replace(/^.*?\/pages\//, "pages/")
                   .replace(/^.*?\/components\//, "components/");
                 entityId = getEntityIdForPath(relativePath) ?? entityId;
               }
             }
-          } catch {
-            // Ignore errors, fall back to file path
+          } catch (_) {
+            /* expected: entity ID extraction may fail, fall back to file path */
           }
         }
 
@@ -226,7 +230,8 @@ export async function getEntityBySlug(
                 { operationName: "stat:getEntityBySlug", logError: false },
               );
               dirExists = stat.isDirectory;
-            } catch {
+            } catch (_) {
+              /* expected: stat may fail for non-existent directories */
               dirExists = false;
             }
 
@@ -249,8 +254,8 @@ export async function getEntityBySlug(
             for (const info of dynamicResults) {
               if (info?.entity.isPage) return info;
             }
-          } catch {
-            // Directory doesn't exist or error reading it, continue to next depth
+          } catch (_) {
+            /* expected: directory may not exist or readDir may fail */
           }
         }
 
@@ -314,7 +319,8 @@ export async function getEntityBySlug(
                 { operationName: "stat:getEntityBySlug", logError: false },
               );
               dirExists = stat.isDirectory;
-            } catch {
+            } catch (_) {
+              /* expected: stat may fail for non-existent directories */
               dirExists = false;
             }
           } else {
@@ -343,8 +349,8 @@ export async function getEntityBySlug(
           for (const info of dynamicResults) {
             if (info?.entity.isPage) return info;
           }
-        } catch {
-          // Directory doesn't exist or error reading it, continue to next depth
+        } catch (_) {
+          /* expected: directory may not exist or readDir may fail */
         }
       }