veryfront 0.1.83 → 0.1.85

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/orchestrator/css-candidate-manifest.ts

@@ -23,6 +23,14 @@ interface RouteCandidateOptions {
   developmentMode: boolean;
 }
 
+interface ProjectCandidateOptions {
+  projectScope: string;
+  projectVersion: string;
+  projectDir: string;
+  files: SourceFileLike[];
+  developmentMode: boolean;
+}
+
 const logger = rendererLogger.component("css-candidate-manifest");
 const SOURCE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".ts", ".js"];
 const DEV_MANIFEST_TTL_MS = 2_000;
@@ -90,6 +98,29 @@ function buildCandidateManifest(files: SourceFileLike[], projectDir: string): Ca
   return { fileCandidates, allCandidates, builtAt: Date.now() };
 }
 
+function getOrBuildManifest(
+  options: Pick<
+    ProjectCandidateOptions,
+    "projectScope" | "projectVersion" | "projectDir" | "files" | "developmentMode"
+  >,
+): CandidateManifest {
+  const manifestKey = buildManifestCacheKey(options.projectScope, options.projectVersion);
+  const existingManifest = manifestCache.get(manifestKey);
+  const manifest = shouldRebuildManifest(existingManifest, options.developmentMode)
+    ? buildCandidateManifest(options.files, options.projectDir)
+    : existingManifest!;
+
+  if (manifest !== existingManifest) {
+    manifestCache.set(manifestKey, manifest);
+
+    for (const key of routeCandidateCache.keys()) {
+      if (key.startsWith(`${manifestKey}:`)) routeCandidateCache.delete(key);
+    }
+  }
+
+  return manifest;
+}
+
 function addCandidatesForPath(
   target: Set<string>,
   manifest: CandidateManifest,
@@ -109,20 +140,7 @@ function addCandidatesForPath(
  */
 export function getRouteCandidates(options: RouteCandidateOptions): Set<string> {
   const manifestKey = buildManifestCacheKey(options.projectScope, options.projectVersion);
-  const existingManifest = manifestCache.get(manifestKey);
-  const manifest = shouldRebuildManifest(existingManifest, options.developmentMode)
-    ? buildCandidateManifest(options.files, options.projectDir)
-    : existingManifest!;
-
-  if (manifest !== existingManifest) {
-    manifestCache.set(manifestKey, manifest);
-
-    // Clear route subsets when project-level file manifest is rebuilt.
-    for (const key of routeCandidateCache.keys()) {
-      if (key.startsWith(`${manifestKey}:`)) routeCandidateCache.delete(key);
-    }
-  }
-
+  const manifest = getOrBuildManifest(options);
   const routeCacheKey = `${manifestKey}:${options.routeKey}`;
   const cachedRoute = routeCandidateCache.get(routeCacheKey);
   if (cachedRoute) return new Set(cachedRoute);
@@ -156,6 +174,14 @@ export function getRouteCandidates(options: RouteCandidateOptions): Set<string>
   return new Set(routeCandidates);
 }
 
+/**
+ * Resolve full-project Tailwind candidates from a precomputed per-project manifest.
+ */
+export function getProjectCandidates(options: ProjectCandidateOptions): Set<string> {
+  const manifest = getOrBuildManifest(options);
+  return new Set(manifest.allCandidates);
+}
+
 /**
  * Invalidate cached candidate manifests for one project scope (or all scopes).
  */

package/src/src/server/handlers/dev/styles-candidate-scanner.ts

@@ -12,6 +12,8 @@ import { extractCandidates } from "../../../html/styles-builder/tailwind-compile
 import { serverLogger } from "../../../utils/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import { join } from "../../../platform/compat/path/index.js";
+import { getProjectCandidates } from "../../../rendering/orchestrator/css-candidate-manifest.js";
+import type { ResolvedContentContext } from "../../../platform/adapters/fs/veryfront/types.js";
 import type { HandlerContext } from "../types.js";
 import { FRAMEWORK_CANDIDATES } from "./framework-candidates.generated.js";
 
@@ -23,6 +25,25 @@ const SKIP_DIRS = new Set(["node_modules", ".cache", ".git", "dist", "build", ".
 /** De-duplicated set of framework candidates, computed once at import time. */
 const frameworkCandidates = new Set<string>(FRAMEWORK_CANDIDATES);
 
+interface SourceFileProvider {
+  getAllSourceFiles?: () =>
+    | Array<{ path: string; content?: string }>
+    | Promise<Array<{ path: string; content?: string }>>;
+  getContentContext?: () => ResolvedContentContext | null;
+}
+
+function resolveProjectVersion(
+  ctx: HandlerContext,
+  contentContext: ResolvedContentContext | null,
+): string {
+  if (contentContext?.releaseId) return `release:${contentContext.releaseId}`;
+  if (contentContext?.branch) return `branch:${contentContext.branch}`;
+  if (contentContext?.environmentName) return `environment:${contentContext.environmentName}`;
+  if (ctx.releaseId) return `release:${ctx.releaseId}`;
+  if (ctx.parsedDomain?.branch) return `branch:${ctx.parsedDomain.branch}`;
+  return "live";
+}
+
 /**
  * Extract Tailwind CSS candidate class names from all project source files.
  *
@@ -42,9 +63,8 @@ export async function extractProjectCandidates(ctx: HandlerContext): Promise<Set
 
   // Call method directly on wrappedFs to preserve 'this' context
   const fsAdapter = wrappedFs.getUnderlyingAdapter() as {
-    getAllSourceFiles?: () =>
-      | Array<{ path: string; content?: string }>
-      | Promise<Array<{ path: string; content?: string }>>;
+    getAllSourceFiles?: SourceFileProvider["getAllSourceFiles"];
+    getContentContext?: SourceFileProvider["getContentContext"];
   };
 
   if (typeof fsAdapter.getAllSourceFiles !== "function") {
@@ -56,14 +76,20 @@ export async function extractProjectCandidates(ctx: HandlerContext): Promise<Set
 
   const candidates = new Set<string>(frameworkCandidates);
   const files = await fsAdapter.getAllSourceFiles();
-
-  for (const file of files) {
-    if (!file.content) continue;
-    if (!SOURCE_EXTENSIONS.some((ext) => file.path.endsWith(ext))) continue;
-
-    for (const cls of extractCandidates(file.content)) {
-      candidates.add(cls);
-    }
+  const contentContext = typeof fsAdapter.getContentContext === "function"
+    ? fsAdapter.getContentContext()
+    : null;
+
+  for (
+    const cls of getProjectCandidates({
+      projectScope: ctx.projectSlug ?? contentContext?.projectSlug ?? ctx.projectDir,
+      projectVersion: resolveProjectVersion(ctx, contentContext),
+      projectDir: ctx.projectDir,
+      files,
+      developmentMode: contentContext?.sourceType === "branch",
+    })
+  ) {
+    candidates.add(cls);
   }
 
   return candidates;

package/src/src/server/handlers/dev/styles-css.handler.ts

@@ -14,6 +14,7 @@ import { joinPath } from "../../../utils/path-utils.js";
 import {
   formatCSSError,
   generateTailwindCSS,
+  getProjectCSS,
 } from "../../../html/styles-builder/tailwind-compiler.js";
 import { DEFAULT_STYLESHEET } from "../../../html/styles-builder/css-hash-cache.js";
 import { serverLogger } from "../../../utils/index.js";
@@ -21,6 +22,10 @@ import { extractProjectCandidates } from "./styles-candidate-scanner.js";
 
 const logger = serverLogger.component("styles-css-handler");
 
+type GeneratedStylesResult =
+  | Awaited<ReturnType<typeof generateTailwindCSS>>
+  | Awaited<ReturnType<typeof getProjectCSS>>;
+
 export class StylesCSSHandler extends BaseHandler {
   metadata: HandlerMetadata = {
     name: "StylesCSSHandler",
@@ -54,11 +59,9 @@ export class StylesCSSHandler extends BaseHandler {
           });
           candidates = new Set<string>();
         }
-        const result = await generateTailwindCSS(rawCss, candidates, {
-          projectSlug: ctx.projectSlug,
-        });
+        const result = await this.generateStylesheet(ctx, rawCss, candidates);
 
-        if (result.error) {
+        if ("error" in result && result.error) {
           const formatted = formatCSSError(result.error);
           logger.error("Tailwind error", {
             error: formatted.message,
@@ -104,6 +107,8 @@ body::before {
         logger.debug("CSS generated", {
           candidates: candidates.size,
           cssLength: result.css.length,
+          fromCache: "fromCache" in result ? result.fromCache : false,
+          cssHash: "hash" in result ? result.hash : undefined,
         });
 
         return this.respond(
@@ -144,4 +149,20 @@ body::before {
       return DEFAULT_STYLESHEET;
     }
   }
+
+  private generateStylesheet(
+    ctx: HandlerContext,
+    rawCss: string,
+    candidates: Set<string>,
+  ): Promise<GeneratedStylesResult> {
+    if (!ctx.projectSlug) {
+      return generateTailwindCSS(rawCss, candidates);
+    }
+
+    return getProjectCSS(ctx.projectSlug, rawCss, candidates, {
+      minify: true,
+      environment: "preview",
+      buildMode: "production",
+    });
+  }
 }

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,
+  );
 }
 
 /**

package/src/src/transforms/import-rewriter/strategies/bare-strategy.ts

@@ -13,6 +13,7 @@ import type {
   RewriteResult,
 } from "../types.js";
 import { buildEsmShUrl, TAILWIND_VERSION } from "../url-builder.js";
+import { parseBarePackageSpecifier } from "../../shared/package-specifier.js";
 
 const logger = rendererLogger.component("esm");
 
@@ -22,10 +23,6 @@ function hasVersionSpecifier(specifier: string): boolean {
   return /@[\d^~x][\d.x^~-]*(?=\/|$)/.test(specifier);
 }
 
-function normalizeVersionedSpecifier(specifier: string): string {
-  return specifier.replace(/@[\d^~x][\d.x^~-]*(?=\/|$)/, "");
-}
-
 function warnUnversionedImport(specifier: string, projectId: string): void {
   const key = `${projectId}:${specifier}`;
   if (unversionedImportsWarned.has(key)) return;
@@ -73,20 +70,22 @@ export class BareStrategy implements ImportRewriteStrategy {
   rewrite(info: ImportSpecifierInfo, ctx: RewriteContext): RewriteResult {
     if (ctx.target === "ssr") return { specifier: null };
 
-    const normalized = normalizeVersionedSpecifier(info.specifier);
+    const parsed = parseBarePackageSpecifier(info.specifier);
+    if (parsed == null) {
+      return { specifier: null };
+    }
 
-    let finalSpecifier = normalized;
+    const packageName = parsed.packageName;
+    let version = parsed.version ?? undefined;
+    const subpath = parsed.subpath ?? undefined;
 
-    if (normalized === "tailwindcss" || normalized.startsWith("tailwindcss/")) {
-      finalSpecifier = normalized.replace(
-        /^tailwindcss/,
-        `tailwindcss@${TAILWIND_VERSION}`,
-      );
+    if (packageName === "tailwindcss") {
+      version = TAILWIND_VERSION;
     } else if (!hasVersionSpecifier(info.specifier)) {
       warnUnversionedImport(info.specifier, ctx.projectId);
     }
 
-    const url = buildEsmShUrl(finalSpecifier, undefined, undefined, {
+    const url = buildEsmShUrl(packageName, version, subpath, {
       external: ["react"],
     });
 

package/src/src/transforms/shared/package-specifier.ts

@@ -0,0 +1,29 @@
+export interface ParsedBarePackageSpecifier {
+  packageName: string;
+  version: string | null;
+  subpath: string | null;
+}
+
+export function parseBarePackageSpecifier(
+  specifier: string,
+): ParsedBarePackageSpecifier | null {
+  const scopedMatch = specifier.match(/^(@[^/]+\/[^/@]+)(?:@([^/]+))?(\/.*)?$/);
+  if (scopedMatch?.[1]) {
+    return {
+      packageName: scopedMatch[1],
+      version: scopedMatch[2] ?? null,
+      subpath: scopedMatch[3] ?? null,
+    };
+  }
+
+  const unscopedMatch = specifier.match(/^([^/@][^/@]*?)(?:@([^/]+))?(\/.*)?$/);
+  if (unscopedMatch?.[1]) {
+    return {
+      packageName: unscopedMatch[1],
+      version: unscopedMatch[2] ?? null,
+      subpath: unscopedMatch[3] ?? null,
+    };
+  }
+
+  return null;
+}