veryfront 0.1.82 → 0.1.84

package/src/src/platform/adapters/fs/veryfront/multi-project-adapter.ts

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { logger as baseLogger } from "../../../../utils/index.js";
 import { INITIALIZATION_ERROR } from "../../../../errors/index.js";
 import type { DirectoryEntry, FSAdapter, FSAdapterConfig } from "./types.js";
-import type { FileInfo } from "../../base.js";
+import type { FileInfo, ResolveFileOptions } from "../../base.js";
 import { ProxyFSAdapterManager } from "./proxy-manager.js";
 import type { VeryfrontFSAdapter } from "./index.js";
 import { runWithCacheBatching } from "../../../../cache/request-cache-batcher.js";
@@ -213,9 +213,12 @@ export class MultiProjectFSAdapter implements FSAdapter {
     }
   }
 
-  async resolveFile(basePath: string): Promise<string | null> {
+  async resolveFile(
+    basePath: string,
+    options?: ResolveFileOptions,
+  ): Promise<string | null> {
     const adapter = await this.getAdapter();
-    return adapter.resolveFile(basePath);
+    return adapter.resolveFile(basePath, options);
   }
 
   dispose(): void {

package/src/src/platform/adapters/fs/veryfront/read-operations.ts

@@ -41,6 +41,7 @@ export interface ContentContextProvider {
       updated_at?: string;
     }> | undefined
   >;
+  hasCachedFileList?: () => Promise<boolean>;
   /** True if cache prefix is being deleted - skip persistent cache reads */
   isPersistentCacheInvalidated?: (prefix: string) => boolean;
   /** Back-compat: release-scoped invalidation */

package/src/src/platform/adapters/fs/veryfront/stat-operations.ts

@@ -1,6 +1,6 @@
 import { logger as baseLogger } from "../../../../utils/index.js";
 import { isFrameworkSourcePath } from "../../../../utils/path-utils.js";
-import type { FileInfo } from "../../base.js";
+import type { FileInfo, ResolveFileOptions } from "../../base.js";
 import type { ProjectFile } from "../../veryfront-api-client/index.js";
 import { VeryfrontOperationsBase } from "./base-operations.js";
 import { createError, toError } from "../../../../errors/index.js";
@@ -326,6 +326,125 @@ export class StatOperations extends VeryfrontOperationsBase {
     return files;
   }
 
+  private buildResolveSearchPatterns(
+    normalizedPath: string,
+    options?: ResolveFileOptions,
+  ): string[] {
+    const patterns = new Set<string>();
+    const pathWithoutExt = stripKnownExtension(normalizedPath, EXTENSION_PRIORITY);
+    const allowPagesPrefix = options?.allowPagesPrefix !== false;
+    const addPattern = (pattern: string): void => {
+      if (pattern.length > 0) patterns.add(pattern);
+    };
+
+    if (EXTENSION_PRIORITY.some((ext) => normalizedPath.endsWith(ext))) {
+      addPattern(normalizedPath);
+      return [...patterns];
+    }
+
+    addPattern(`${pathWithoutExt}.*`);
+    if (allowPagesPrefix && !pathWithoutExt.startsWith("pages/")) {
+      addPattern(`pages/${pathWithoutExt}.*`);
+    }
+
+    addPattern(`${pathWithoutExt}/index.*`);
+    if (allowPagesPrefix && !pathWithoutExt.startsWith("pages/")) {
+      addPattern(`pages/${pathWithoutExt}/index.*`);
+    }
+
+    return [...patterns];
+  }
+
+  private normalizeMatchedPaths(
+    matches: Array<{ path: string }>,
+  ): Array<{ path: string }> {
+    return matches.map((match) => ({
+      path: normalizeIndexedFilePath(match as ProjectFile).normalizedPath,
+    }));
+  }
+
+  private async tryResolveViaApiSearch(
+    normalizedPath: string,
+    options?: ResolveFileOptions,
+  ): Promise<string | null | undefined> {
+    if (isFrameworkSourcePath(normalizedPath)) {
+      logger.debug("Skipping API search for framework path", { normalizedPath });
+      return null;
+    }
+
+    if (!this.apiSearchCircuitBreaker.canSearch()) {
+      logger.warn("API search circuit breaker open, skipping", { normalizedPath });
+      return undefined;
+    }
+
+    const patterns = this.buildResolveSearchPatterns(normalizedPath, options);
+    let sawSuccessfulSearch = false;
+
+    for (const pattern of patterns) {
+      try {
+        const matches = await this.client.searchFiles(pattern);
+        sawSuccessfulSearch = true;
+        this.apiSearchCircuitBreaker.recordSuccess();
+
+        const normalizedMatches = this.normalizeMatchedPaths(matches);
+        if (pattern === normalizedPath) {
+          const exactMatch = normalizedMatches.find((match) => match.path === normalizedPath);
+          if (exactMatch) {
+            logger.debug("resolveFile found exact file via API search", {
+              normalizedPath,
+              pattern,
+            });
+            return exactMatch.path;
+          }
+          continue;
+        }
+
+        const sortedMatches = sortPathsByExtensionPriority(normalizedMatches, EXTENSION_PRIORITY);
+        const first = sortedMatches[0];
+        if (first) {
+          logger.debug("resolveFile found via API search", {
+            normalizedPath,
+            pattern,
+            resolvedPath: first.path,
+          });
+          return first.path;
+        }
+      } catch (error) {
+        const result = this.apiSearchCircuitBreaker.recordFailure();
+        if (result.tripped) {
+          logger.warn("API search circuit breaker tripped", {
+            failures: result.failures,
+          });
+          return undefined;
+        }
+        logger.error("API pattern search failed", { pattern, error });
+      }
+
+      if (!this.apiSearchCircuitBreaker.canSearch()) {
+        logger.warn("API search circuit breaker open, aborting remaining patterns", {
+          normalizedPath,
+        });
+        return undefined;
+      }
+    }
+
+    if (sawSuccessfulSearch) {
+      logger.debug("resolveFile not found via API search", { normalizedPath, patterns });
+      return null;
+    }
+
+    return undefined;
+  }
+
+  private async hasCachedFileList(): Promise<boolean> {
+    if (this.contextProvider?.hasCachedFileList) {
+      return await this.contextProvider.hasCachedFileList();
+    }
+
+    const files = await this.contextProvider?.getFileList?.();
+    return Array.isArray(files) && files.length > 0;
+  }
+
   async exists(path: string): Promise<boolean> {
     const normalizedPath = this.normalizer.normalize(path);
     try {
@@ -337,7 +456,7 @@ export class StatOperations extends VeryfrontOperationsBase {
     }
   }
 
-  async resolveFile(basePath: string): Promise<string | null> {
+  async resolveFile(basePath: string, options?: ResolveFileOptions): Promise<string | null> {
     const resolveStart = performance.now();
     const normalizedPath = this.normalizer.normalize(basePath);
     const ctx = this.contextProvider?.getContentContext();
@@ -349,6 +468,36 @@ export class StatOperations extends VeryfrontOperationsBase {
       cacheKey,
     });
 
+    const cached = await this.cache.getAsync<string>(cacheKey);
+    if (cached === NOT_FOUND_SENTINEL) {
+      logger.debug("resolveFile cached negative result", { normalizedPath });
+      return null;
+    }
+
+    if (cached !== undefined) {
+      logger.debug("resolveFile cache hit", {
+        normalizedPath,
+        cached,
+      });
+      return cached;
+    }
+
+    const hasCachedFileList = await this.hasCachedFileList();
+    const attemptedApiResolve = !hasCachedFileList;
+
+    if (!hasCachedFileList) {
+      const apiResolved = await this.tryResolveViaApiSearch(normalizedPath, options);
+      if (typeof apiResolved === "string") {
+        this.cache.set(cacheKey, apiResolved);
+        return apiResolved;
+      }
+
+      if (apiResolved === null) {
+        this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
+        return null;
+      }
+    }
+
     const indexStart = performance.now();
     await this.ensureIndexBuilt();
     const indexMs = Math.round(performance.now() - indexStart);
@@ -382,7 +531,7 @@ export class StatOperations extends VeryfrontOperationsBase {
       return resolvedDirect;
     }
 
-    if (!pathWithoutExt.startsWith("pages/")) {
+    if (options?.allowPagesPrefix !== false && !pathWithoutExt.startsWith("pages/")) {
       const resolvedPages = resolveByExtensionPriority(
         fileIdx,
         `pages/${pathWithoutExt}`,
@@ -410,6 +559,15 @@ export class StatOperations extends VeryfrontOperationsBase {
       return indexPath;
     }
 
+    if (attemptedApiResolve) {
+      logger.debug("resolveFile not found after pre-index API search", {
+        normalizedPath,
+        indexMs,
+      });
+      this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
+      return null;
+    }
+
     if (isFrameworkSourcePath(normalizedPath)) {
       logger.debug("Skipping API search for framework path", { normalizedPath });
       return null;
@@ -425,32 +583,10 @@ export class StatOperations extends VeryfrontOperationsBase {
       return null;
     }
 
-    const cacheCheckStart = performance.now();
-    const cached = await this.cache.getAsync<string>(cacheKey);
-    const cacheCheckMs = Math.round(performance.now() - cacheCheckStart);
-
-    if (cached === NOT_FOUND_SENTINEL) {
-      logger.debug("resolveFile cached negative result", {
-        normalizedPath,
-        cacheCheckMs,
-      });
-      return null;
-    }
-
-    if (cached !== undefined) {
-      logger.debug("resolveFile cache hit (unexpected)", {
-        normalizedPath,
-        cached,
-        cacheCheckMs,
-      });
-      return cached;
-    }
-
     const searchPattern = `${pathWithoutExt}.*`;
     logger.debug("Searching for file via API", {
       pattern: searchPattern,
       normalizedPath,
-      cacheCheckMs,
     });
 
     try {

package/src/src/platform/adapters/fs/veryfront/types.ts

@@ -1,3 +1,4 @@
+import type { ResolveFileOptions } from "../../base.js";
 import type { Project } from "../../veryfront-api-client/index.js";
 import type { GitHubConfig } from "../github/types.js";
 import type { DirectoryEntry } from "../shared-types.js";
@@ -26,7 +27,7 @@ export interface FSAdapter {
   initialize?(): Promise<void>;
   shutdown?(): Promise<void>;
 
-  resolveFile?(basePath: string): Promise<string | null>;
+  resolveFile?(basePath: string, options?: ResolveFileOptions): Promise<string | null>;
 }
 
 export interface ContextualFSAdapter extends FSAdapter {

package/src/src/platform/adapters/fs/wrapper.ts

@@ -1,4 +1,11 @@
-import type { DirEntry, FileInfo, FileSystemAdapter, FileWatcher, WatchOptions } from "../base.js";
+import type {
+  DirEntry,
+  FileInfo,
+  FileSystemAdapter,
+  FileWatcher,
+  ResolveFileOptions,
+  WatchOptions,
+} from "../base.js";
 import type { ContextualFSAdapter, DirectoryEntry, FSAdapter } from "./veryfront/types.js";
 
 export interface ExtendedFileSystemAdapter extends FileSystemAdapter {
@@ -224,9 +231,9 @@ export class FSAdapterWrapper implements ExtendedFileSystemAdapter {
     };
   }
 
-  resolveFile(basePath: string): Promise<string | null> {
+  resolveFile(basePath: string, options?: ResolveFileOptions): Promise<string | null> {
     if (!this._fsAdapter.resolveFile) throw new NotSupportedError("resolveFile", this.adapterType);
-    return this._fsAdapter.resolveFile(basePath);
+    return this._fsAdapter.resolveFile(basePath, options);
   }
 
   async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {

package/src/src/proxy/error-response.ts

@@ -0,0 +1,33 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { ErrorPages } from "../server/utils/error-html.js";
+import type { ProxyContext } from "./handler.js";
+
+type ProxyError = NonNullable<ProxyContext["error"]>;
+
+export function jsonErrorResponse(status: number, body: Record<string, unknown>): dntShim.Response {
+  return new dntShim.Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export function createProxyErrorResponse(error: ProxyError): dntShim.Response {
+  if (error.redirectUrl) {
+    return new dntShim.Response(null, {
+      status: 302,
+      headers: { Location: error.redirectUrl },
+    });
+  }
+
+  if (error.slug === "release-not-found" || error.slug === "project-not-found") {
+    return new dntShim.Response(ErrorPages.notFound(), {
+      status: 404,
+      headers: { "Content-Type": "text/html; charset=utf-8" },
+    });
+  }
+
+  return jsonErrorResponse(error.status, {
+    error: error.message,
+    status: error.status,
+  });
+}

package/src/src/proxy/handler.ts

@@ -175,6 +175,12 @@ function extractUserToken(cookieHeader: string): string | undefined {
   return match?.[1] ? decodeURIComponent(match[1]) : undefined;
 }
 
+function getStatusFromError(error: unknown): number | null {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = message.match(/failed: (\d+)/);
+  return match ? Number(match[1]) : null;
+}
+
 async function extractUserIdFromToken(
   token: string,
   apiBaseUrl: string,
@@ -461,6 +467,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     const userToken = extractUserToken(cookieHeader);
 
     let token: string | undefined;
+    let tokenFetchError: unknown;
 
     if (isLocalProject) {
       logger?.debug("Local project, skipping token fetch", { localPath });
@@ -476,6 +483,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
           try {
             token = await tokenManager.getToken(scope, projectSlug, customDomain);
           } catch (error) {
+            tokenFetchError = error;
             logger?.error("Token fetch failed", error as Error, { projectSlug, customDomain });
           }
         }
@@ -488,6 +496,29 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
 
       const base = { scope, host, parsedDomain };
 
+      if (projectSlug && scope === "preview" && !token) {
+        const status = getStatusFromError(tokenFetchError);
+        if (status === 404) {
+          logger?.info("Preview project not found", { projectSlug, host });
+          return makeErrorContext(
+            base,
+            404,
+            "Preview project not found",
+            undefined,
+            undefined,
+            "project-not-found",
+          );
+        }
+
+        logger?.warn("Preview request has no usable token", {
+          projectSlug,
+          host,
+          hadUserToken: !!userToken,
+          hadTokenFetchError: !!tokenFetchError,
+        });
+        return makeErrorContext(base, 502, "Failed to authenticate preview request");
+      }
+
       if (isCustomDomain && !projectSlug) {
         if (!token) {
           logger?.error("Cannot process custom domain without token", undefined, { domain: host });
@@ -590,6 +621,18 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
           );
         }
 
+        if (!resolved.projectId) {
+          logger?.info("Preview project not found after lookup", { projectSlug, host });
+          return makeErrorContext(
+            base,
+            404,
+            "Preview project not found",
+            token,
+            undefined,
+            "project-not-found",
+          );
+        }
+
         projectId = resolved.projectId;
         environmentId = resolved.environmentId;
 

package/src/src/proxy/main.ts

@@ -37,12 +37,12 @@ import {
   withSpan,
 } from "./tracing.js";
 import { proxyLogger, runWithProxyRequestContext } from "./logger.js";
-import { ErrorPages } from "../server/utils/error-html.js";
 import { RendererRouter } from "./renderer-router.js";
 import { ServerResolver } from "./server-resolver.js";
 import { parseProjectDomain } from "../server/utils/domain-parser.js";
 import { exit, getEnv, onSignal } from "../platform/compat/process.js";
 import { createHttpServer, upgradeWebSocket } from "../platform/compat/http/index.js";
+import { createProxyErrorResponse, jsonErrorResponse } from "./error-response.js";
 
 function getLocalProjects(): Record<string, string> {
   const raw = getEnv("LOCAL_PROJECTS");
@@ -274,13 +274,6 @@ function handleWebSocketUpgrade(req: dntShim.Request): dntShim.Response {
   return response;
 }
 
-function jsonErrorResponse(status: number, body: Record<string, unknown>): dntShim.Response {
-  return new dntShim.Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
 function forwardToServer(req: dntShim.Request): Promise<dntShim.Response> {
   const startTime = performance.now();
   const url = new URL(req.url);
@@ -311,25 +304,7 @@ function forwardToServer(req: dntShim.Request): Promise<dntShim.Response> {
             const logLevel = ctx.error.status < 500 ? "warn" : "error";
             proxyLogger[logLevel](`${ctx.error.status} ${req.method} ${url.pathname}`, { ms });
             endSpan(spanInfo?.span, ctx.error.status);
-
-            if (ctx.error.redirectUrl) {
-              return new dntShim.Response(null, {
-                status: 302,
-                headers: { Location: ctx.error.redirectUrl },
-              });
-            }
-
-            if (ctx.error.slug === "release-not-found") {
-              return new dntShim.Response(ErrorPages.notFound(), {
-                status: 404,
-                headers: { "Content-Type": "text/html; charset=utf-8" },
-              });
-            }
-
-            return jsonErrorResponse(ctx.error.status, {
-              error: ctx.error.message,
-              status: ctx.error.status,
-            });
+            return createProxyErrorResponse(ctx.error);
           }
 
           const reqLogger = proxyLogger.child({

package/src/src/rendering/app-route-resolver.ts

@@ -127,14 +127,6 @@ async function tryLoadPageFile(
   slug: string,
   adapter: RuntimeAdapter,
 ): Promise<EntityInfo | null> {
-  try {
-    const info = await adapter.fs.stat(file);
-    if (!info.isFile) return null;
-  } catch (_) {
-    /* expected: file may not exist */
-    return null;
-  }
-
   let raw: string;
   try {
     raw = await adapter.fs.readFile(file);

package/src/src/rendering/orchestrator/file-resolver/index.ts

@@ -6,6 +6,7 @@
  * @module rendering/orchestrator/file-resolver
  */
 
+import { join } from "../../../platform/compat/path/index.js";
 import { rendererLogger as logger } from "../../../utils/index.js";
 import type { RuntimeAdapter } from "../../../platform/adapters/base.js";
 import { buildCandidatePaths, findFirstExisting } from "./candidates.js";
@@ -48,6 +49,24 @@ export async function findSourceFile(
   projectDir: string,
   adapter: RuntimeAdapter,
 ): Promise<string | null> {
+  if (adapter.fs.resolveFile) {
+    const directBases = [join(projectDir, basePath)];
+    const withoutComponents = basePath.replace(/^components\//, "");
+    if (withoutComponents !== basePath) {
+      directBases.push(join(projectDir, withoutComponents));
+    }
+
+    for (const candidateBase of directBases) {
+      const resolved = await adapter.fs.resolveFile(candidateBase, {
+        allowPagesPrefix: false,
+      });
+      if (resolved) {
+        logger.debug("[FileResolver] Found file via resolveFile:", resolved);
+        return resolved;
+      }
+    }
+  }
+
   const candidates = buildCandidatePaths(projectDir, basePath, SOURCE_EXTENSIONS);
 
   const withoutComponents = basePath.replace(/^components\//, "");

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

@@ -7,7 +7,11 @@ import type { RuntimeAdapter } from "../../platform/adapters/base.js";
 import type { VeryfrontConfig } from "../../config/index.js";
 import type { EntityInfo } from "../../types/index.js";
 import { getEntityBySlug } from "../../types/entities/getEntityInfo.js";
-import { detectAppRouter, getAppRouteEntity } from "../router-detection.js";
+import {
+  detectAppRouter,
+  getAppRouteEntity,
+  primeRouterDetectionCache,
+} from "../router-detection.js";
 
 const PAGE_EXTENSIONS = /\.(mdx|md|tsx|jsx|ts|js)$/;
 const APP_ROUTER_PAGE_PATTERN = /^page\.(mdx|md|tsx|jsx|ts|js)$/;
@@ -61,39 +65,44 @@ export class PageResolver {
     return withSpan(
       "routing.resolve_page",
       async () => {
-        const useAppRouter = await detectAppRouter(
-          this.projectDir,
-          this.config,
-          this.adapter,
-          { projectId: this.projectId },
-        );
-
         const appDirName = this.config.directories?.app ?? "app";
+        const cacheKey = this.projectId ?? this.projectDir;
 
         let pageInfo: EntityInfo | null | undefined;
 
-        if (useAppRouter) {
+        if (this.config.router === "app") {
+          pageInfo = await getAppRouteEntity(
+            this.projectDir,
+            slug,
+            this.adapter,
+            appDirName,
+          );
+          if (pageInfo) {
+            primeRouterDetectionCache(cacheKey, "app");
+          }
+        } else if (this.config.router === "pages") {
+          pageInfo = await getEntityBySlug(this.projectDir, slug, this.adapter);
+          if (pageInfo) {
+            primeRouterDetectionCache(cacheKey, "pages");
+          }
+        } else {
+          // Auto mode stays structural: a single resolved route must not pin router mode
+          // for projects that are still transitioning between app/ and pages/.
           pageInfo = await getAppRouteEntity(
             this.projectDir,
             slug,
             this.adapter,
             appDirName,
           );
-
           if (!pageInfo) {
-            logger.debug(
-              "App Router resolution failed, falling back to Pages Router",
-              { slug },
-            );
+            pageInfo = await getEntityBySlug(this.projectDir, slug, this.adapter);
           }
         }
 
-        pageInfo ??= await getEntityBySlug(this.projectDir, slug, this.adapter);
-
         if (!pageInfo) {
           throw FILE_NOT_FOUND.create({
             detail: `Page not found: ${slug}`,
-            context: { slug, useAppRouter },
+            context: { slug, router: this.config.router ?? "auto" },
           });
         }
 

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

@@ -49,6 +49,13 @@ export function clearRouterDetectionCacheForProject(projectId: string): void {
   routerDetectionCache.delete(projectId);
 }
 
+export function primeRouterDetectionCache(
+  projectKey: string,
+  mode: "app" | "pages",
+): void {
+  routerDetectionCache.set(projectKey, mode === "app");
+}
+
 export interface DetectAppRouterOptions {
   /** Project ID for cache isolation in multi-tenant deployments */
   projectId?: string;

package/src/src/transforms/esm/http-cache-helpers.ts

@@ -9,6 +9,8 @@ import { cwd } from "../../platform/compat/process.js";
 import { rendererLogger } from "../../utils/index.js";
 import { resolveImport } from "../../modules/import-map/resolver.js";
 import type { ImportMapConfig } from "../../modules/import-map/types.js";
+import { buildEsmShUrl } from "../import-rewriter/url-builder.js";
+import { parseBarePackageSpecifier } from "../shared/package-specifier.js";
 import { DEFAULT_REACT_VERSION, getReactImportMap } from "./package-registry.js";
 
 const logger = rendererLogger.component("http-cache");
@@ -149,7 +151,16 @@ export function resolveBareSpecifier(
   const mapped = resolveImport(specifier, importMap);
   if (mapped !== specifier) return mapped;
 
-  return `https://esm.sh/${specifier}?target=es2022`;
+  const parsed = parseBarePackageSpecifier(specifier);
+  if (parsed == null) {
+    return `https://esm.sh/${specifier}?target=es2022`;
+  }
+
+  return buildEsmShUrl(
+    parsed.packageName,
+    parsed.version ?? undefined,
+    parsed.subpath ?? undefined,
+  );
 }
 
 /**