veryfront 0.1.128 → 0.1.129

package/src/src/rendering/orchestrator/html.ts

@@ -26,16 +26,20 @@ import { computeSourceHash } from "../../studio/hash-utils.js";
 import { extractRelativePath } from "../../utils/route-path-utils.js";
 import { resolveAppComponentPath } from "../layouts/utils/app-resolver.js";
 import { StreamTimeoutError, streamToString } from "../utils/stream-utils.js";
+import { profilePhase, profileSyncPhase } from "../../observability/request-profiler.js";
 import {
   normalizeCssModuleKey,
   rewriteCssModuleContent,
 } from "../../transforms/css-modules/naming.js";
+import { getProjectCSS } from "../../html/styles-builder/index.js";
+import { warmPreparedCSSArtifactFromFiles } from "../../html/styles-builder/css-pregeneration.js";
 import { getRouteCandidates } from "./css-candidate-manifest.js";
 import { resolveStyleContentVersion } from "../../html/styles-builder/content-version.js";
 import { createStyleScopeProfile } from "../../html/styles-builder/style-scope-profile.js";
 import type { ResolvedContentContext } from "../../platform/adapters/fs/veryfront/types.js";
 
 const logger = rendererLogger.component("html-generator");
+type ProjectCSSResult = Awaited<ReturnType<typeof getProjectCSS>> | null;
 
 function findTagEnd(html: string, start: number): number {
   let activeQuote: '"' | "'" | null = null;
@@ -187,7 +191,12 @@ export class HTMLGenerator {
   ): Promise<ReadableStream> {
     const fullContext = context as HTMLGenerationContext;
     const mergedFrontmatter = this.mergeFrontmatter(fullContext);
-    const htmlOptions = await this.buildHTMLOptions(fullContext, mergedFrontmatter);
+    const htmlOptions = await profilePhase(
+      "html.build_options",
+      () => this.buildHTMLOptions(fullContext, mergedFrontmatter),
+    );
+    const projectCSSPromise = this.startProjectCSSPreparation(fullContext, htmlOptions);
+    this.startPreparedCSSWarmup(fullContext, htmlOptions);
 
     let reactContent: string;
     try {
@@ -201,11 +210,16 @@ export class HTMLGenerator {
       reactContent = error.partialContent.trim();
     }
 
-    const { start, end } = await this.generateShellParts(
-      fullContext,
-      mergedFrontmatter,
-      htmlOptions,
-      reactContent,
+    const { start, end } = await profilePhase(
+      "html.generate_shell_parts",
+      () =>
+        this.generateShellParts(
+          fullContext,
+          mergedFrontmatter,
+          htmlOptions,
+          reactContent,
+          projectCSSPromise,
+        ),
     );
 
     const encoder = new TextEncoder();
@@ -276,14 +290,24 @@ export class HTMLGenerator {
 
   private async wrapHTMLFragment(context: HTMLGenerationContext): Promise<string> {
     const mergedFrontmatter = this.mergeFrontmatter(context);
-    const htmlOptions = await this.buildHTMLOptions(context, mergedFrontmatter);
+    const htmlOptions = await profilePhase(
+      "html.build_options",
+      () => this.buildHTMLOptions(context, mergedFrontmatter),
+    );
+    const projectCSSPromise = this.startProjectCSSPreparation(context, htmlOptions);
+    this.startPreparedCSSWarmup(context, htmlOptions);
     const reactContent = context.html.trim();
 
-    const { start, end } = await this.generateShellParts(
-      context,
-      mergedFrontmatter,
-      htmlOptions,
-      reactContent,
+    const { start, end } = await profilePhase(
+      "html.generate_shell_parts",
+      () =>
+        this.generateShellParts(
+          context,
+          mergedFrontmatter,
+          htmlOptions,
+          reactContent,
+          projectCSSPromise,
+        ),
     );
 
     return `${start}${reactContent}${end}`;
@@ -294,6 +318,7 @@ export class HTMLGenerator {
     mergedFrontmatter: MDXFrontmatter,
     htmlOptions: HTMLGenerationOptions,
     reactContent: string,
+    projectCSSPromise?: Promise<ProjectCSSResult>,
   ): Promise<{ start: string; end: string }> {
     const head = context.collectedHead;
     const effectiveTitle = head?.title || mergedFrontmatter.title || "Veryfront App";
@@ -317,6 +342,7 @@ export class HTMLGenerator {
       context.options?.params,
       context.options?.props,
       reactContent,
+      projectCSSPromise,
     );
 
     const { scripts, other } = this.buildHeadElements(head);
@@ -343,6 +369,76 @@ export class HTMLGenerator {
     return { start: modifiedStart, end };
   }
 
+  private startProjectCSSPreparation(
+    context: HTMLGenerationContext,
+    htmlOptions: HTMLGenerationOptions,
+  ): Promise<ProjectCSSResult> | undefined {
+    const isLocalProject = htmlOptions.isLocalProject ?? false;
+    if (isLocalProject || htmlOptions.environment !== "production") return undefined;
+
+    const projectScope = htmlOptions.projectSlug || htmlOptions.projectId || context.slug;
+    if (!projectScope || projectScope === "default") return undefined;
+
+    return getProjectCSS(
+      projectScope,
+      htmlOptions.globalCSS,
+      new Set([...(htmlOptions.projectClasses ?? [])]),
+      {
+        minify: true,
+        environment: htmlOptions.environment,
+        buildMode: htmlOptions.mode,
+      },
+    );
+  }
+
+  private startPreparedCSSWarmup(
+    context: HTMLGenerationContext,
+    htmlOptions: HTMLGenerationOptions,
+  ): void {
+    const isLocalProject = htmlOptions.isLocalProject ?? false;
+    const usesPreviewStylesheet = isLocalProject || htmlOptions.environment !== "production";
+    if (!usesPreviewStylesheet) return;
+
+    const wrappedFs = this.config.adapter.fs as unknown as {
+      getUnderlyingAdapter?: () => unknown;
+    };
+    if (typeof wrappedFs.getUnderlyingAdapter !== "function") return;
+
+    const fsAdapter = wrappedFs.getUnderlyingAdapter() as {
+      getAllSourceFiles?: () =>
+        | Array<{ path: string; content?: string }>
+        | Promise<Array<{ path: string; content?: string }>>;
+    };
+    if (typeof fsAdapter.getAllSourceFiles !== "function") return;
+
+    const projectScope = htmlOptions.projectSlug || htmlOptions.projectId || context.slug;
+    if (!projectScope || projectScope === "default") return;
+
+    const projectVersion = this.getProjectContentVersion() ??
+      (this.config.mode === "development" ? "dev" : "unknown");
+    const styleProfile = createStyleScopeProfile(this.config.config);
+    const stylesheetPath = this.config.config?.tailwind?.stylesheet;
+
+    Promise.resolve(fsAdapter.getAllSourceFiles()).then((files) =>
+      warmPreparedCSSArtifactFromFiles({
+        projectSlug: projectScope,
+        projectVersion,
+        projectDir: this.config.projectDir,
+        files,
+        styleProfile,
+        stylesheetPath,
+        minify: true,
+        environment: "preview",
+        buildMode: "production",
+      })
+    ).catch((error) => {
+      logger.debug("Prepared CSS warmup skipped after source scan failure", {
+        projectScope,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    });
+  }
+
   private buildHeadElements(head?: CollectedHead): { scripts: string; other: string } {
     if (!head) return { scripts: "", other: "" };
 
@@ -438,15 +534,21 @@ export class HTMLGenerator {
   ): Promise<HTMLGenerationOptions> {
     const stylesheetPath = this.config.config?.tailwind?.stylesheet || "globals.css";
     const [appComponentPathOrNull, globalCSS] = await Promise.all([
-      this.resolveAppPath(),
-      this.loadProjectFile(stylesheetPath),
+      profilePhase("html.resolve_app_path", () => this.resolveAppPath()),
+      profilePhase("html.load_global_css", () => this.loadProjectFile(stylesheetPath)),
     ]);
     const appComponentPath = appComponentPathOrNull ?? undefined;
-    const projectClasses = await this.extractProjectClassesForRoute(context, appComponentPath);
+    const projectClasses = await profilePhase(
+      "html.route_candidates",
+      () => this.extractProjectClassesForRoute(context, appComponentPath),
+    );
 
     // Load CSS imported by components and merge with globalCSS.
     // Deduplicate against the configured stylesheet to avoid double-loading.
-    const combinedCSS = await this.mergeImportedCSS(globalCSS, context.cssImports, stylesheetPath);
+    const combinedCSS = await profilePhase(
+      "html.merge_imported_css",
+      () => this.mergeImportedCSS(globalCSS, context.cssImports, stylesheetPath),
+    );
 
     logger.debug("App component resolution", {
       appComponentPath,
@@ -474,7 +576,7 @@ export class HTMLGenerator {
       ? computeSourceHash(context.pageInfo.entity.content)
       : undefined;
 
-    return {
+    return profileSyncPhase("html.build_options.finalize", () => ({
       mode: this.config.mode,
       config: this.config.config,
       projectDir: this.config.projectDir,
@@ -491,6 +593,7 @@ export class HTMLGenerator {
       frontmatter: mergedFrontmatter,
       studioEmbed: context.options?.studioEmbed,
       projectId: context.options?.projectId,
+      projectSlug: context.options?.projectSlug,
       pageId: context.options?.pageId,
       sourceHash,
       colorScheme: context.options?.colorScheme,
@@ -501,7 +604,8 @@ export class HTMLGenerator {
       projectClasses,
       isLocalProject: this.config.mode === "development",
       noHmr: context.options?.noHmr,
-    };
+      forceProductionScripts: context.options?.forceProductionScripts,
+    }));
   }
 
   /**

package/src/src/rendering/orchestrator/ssr-orchestrator.ts

@@ -12,6 +12,10 @@ import type { RenderOptions } from "./types.js";
 import { runWithHeadCollector } from "../../react/head-collector.js";
 import { getWorkerPool, isSSRIsolationEnabled } from "../../security/sandbox/worker-pool.js";
 import type { WorkerResponse } from "../../security/sandbox/worker-types.js";
+import {
+  endRenderSession,
+  hasRenderSession,
+} from "../../transforms/mdx/esm-module-loader/module-fetcher/index.js";
 
 const logger = rendererLogger.component("ssr-orchestrator");
 
@@ -113,6 +117,10 @@ export class SSROrchestrator {
 
     const { html, stream } = renderResult;
 
+    if (options?.renderSessionId && hasRenderSession(options.renderSessionId)) {
+      endRenderSession(options.renderSessionId);
+    }
+
     const mergedOptions = {
       ...generationContext.options,
       ...options,

package/src/src/rendering/orchestrator/types.ts

@@ -55,6 +55,10 @@ export interface RenderOptions {
   skipCachePersist?: boolean;
   /** Disable HMR scripts (for embedded iframes where WebSocket is unwanted) */
   noHmr?: boolean;
+  /** Force production client scripts even when rendering a local project */
+  forceProductionScripts?: boolean;
+  /** Internal SSR module-tracking session id for first-response manifest preloads */
+  renderSessionId?: string;
 }
 
 export interface RenderContext {

package/src/src/repositories/types.ts

@@ -1,9 +1,5 @@
 import type { DirEntry, FileInfo } from "../platform/adapters/base.js";
-
-// Re-export schema-based types
 export type { CacheRepositoryOptions, CacheStats, RepositoryContext } from "./schemas/index.js";
-
-// Import for use in interface definitions
 import type { CacheStats, RepositoryContext } from "./schemas/index.js";
 
 export interface FileSystemRepository {

package/src/src/resource/factory.ts

@@ -12,8 +12,8 @@ import { createError, toError } from "../errors/veryfront-error.js";
 export function resource<TParams = unknown, TData = unknown>(
   config: ResourceConfig<TParams, TData>,
 ): Resource<TParams, TData> {
-  const pattern = config.pattern ?? generateResourcePattern();
-  const id = patternToId(pattern);
+  const pattern = config.pattern ?? generateFallbackPattern();
+  const id = resourcePatternToId(pattern);
 
   return {
     id,
@@ -24,13 +24,7 @@ export function resource<TParams = unknown, TData = unknown>(
       try {
         config.paramsSchema.parse(params);
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw toError(
-          createError({
-            type: "agent",
-            message: `Resource "${id}" params validation failed: ${message}`,
-          }),
-        );
+        throw createParamsValidationError(id, error);
       }
 
       return config.load(params);
@@ -46,7 +40,7 @@ export function resource<TParams = unknown, TData = unknown>(
  * Auto-discovery is handled by the discovery module which scans
  * the filesystem and extracts patterns from resource definitions.
  */
-function generateResourcePattern(): string {
+function generateFallbackPattern(): string {
   return `/resource_${Date.now()}`;
 }
 
@@ -54,6 +48,16 @@ function generateResourcePattern(): string {
  * Convert path pattern to ID
  * Example: "/users/:userId/profile" -> "users_userId_profile"
  */
-function patternToId(pattern: string): string {
+function resourcePatternToId(pattern: string): string {
   return pattern.replace(/^\//, "").replace(/\//g, "_").replace(/:/g, "");
 }
+
+function createParamsValidationError(resourceId: string, cause: unknown): Error {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return toError(
+    createError({
+      type: "agent",
+      message: `Resource "${resourceId}" params validation failed: ${message}`,
+    }),
+  );
+}

package/src/src/resource/registry.ts

@@ -11,12 +11,12 @@ import type { Resource } from "./types.js";
 import { ProjectScopedRegistryManager } from "../ai/registry-manager.js";
 import { ScopedRegistryFacade } from "../ai/registry-facade.js";
 
-const resourceManager = new ProjectScopedRegistryManager<Resource>("resource");
+const resourceRegistryManager = new ProjectScopedRegistryManager<Resource>("resource");
 
-class ResourceRegistryClass extends ScopedRegistryFacade<Resource> {
+class ResourceRegistry extends ScopedRegistryFacade<Resource> {
   findByPattern(uri: string): Resource | undefined {
     for (const resource of this.getAll().values()) {
-      if (this.matchesPattern(uri, resource.pattern)) return resource;
+      if (this.matchPattern(uri, resource.pattern)) return resource;
     }
     return undefined;
   }
@@ -25,12 +25,12 @@ class ResourceRegistryClass extends ScopedRegistryFacade<Resource> {
     return new RegExp(`^${pattern.replace(/:(\w+)/g, "(?<$1>[^/]+)")}$`);
   }
 
-  private matchesPattern(uri: string, pattern: string): boolean {
-    return this.patternToRegex(pattern).test(uri);
+  private matchPattern(uri: string, pattern: string): RegExpMatchArray | null {
+    return uri.match(this.patternToRegex(pattern));
   }
 
   extractParams(uri: string, pattern: string): Record<string, string> {
-    return uri.match(this.patternToRegex(pattern))?.groups ?? {};
+    return this.matchPattern(uri, pattern)?.groups ?? {};
   }
 
   list(): string[] {
@@ -38,4 +38,4 @@ class ResourceRegistryClass extends ScopedRegistryFacade<Resource> {
   }
 }
 
-export const resourceRegistry = new ResourceRegistryClass(resourceManager);
+export const resourceRegistry = new ResourceRegistry(resourceRegistryManager);

package/src/src/schemas/common.ts

@@ -1,12 +1,16 @@
 import { z } from "zod";
 import { MAX_URL_LENGTH_FOR_VALIDATION } from "../utils/constants/index.js";
+import { timestamp } from "./primitives.js";
+
+const SLUG_PATTERN = /^[a-z0-9-]+$/;
+const E164_PHONE_NUMBER_PATTERN = /^\+?[1-9]\d{1,14}$/;
 
 export const CommonSchemas = {
   email: z.string().email().max(255),
   uuid: z.string().uuid(),
-  slug: z.string().regex(/^[a-z0-9-]+$/).min(1).max(100),
+  slug: z.string().regex(SLUG_PATTERN).min(1).max(100),
   url: z.string().url().max(MAX_URL_LENGTH_FOR_VALIDATION),
-  phoneNumber: z.string().regex(/^\+?[1-9]\d{1,14}$/),
+  phoneNumber: z.string().regex(E164_PHONE_NUMBER_PATTERN),
 
   pagination: z.object({
     page: z.coerce.number().int().positive().default(1),
@@ -17,8 +21,8 @@ export const CommonSchemas = {
 
   dateRange: z
     .object({
-      from: z.string().datetime(),
-      to: z.string().datetime(),
+      from: timestamp,
+      to: timestamp,
     })
     .refine(({ from, to }) => new Date(from) <= new Date(to), {
       message: "From date must be before or equal to To date",
@@ -33,7 +37,6 @@ export const CommonSchemas = {
     .regex(/[^A-Za-z0-9]/, "Password must contain at least one special character"),
 };
 
-// Export inferred types for convenience
 export type Email = z.infer<typeof CommonSchemas.email>;
 export type Uuid = z.infer<typeof CommonSchemas.uuid>;
 export type Slug = z.infer<typeof CommonSchemas.slug>;

package/src/src/security/http/config.ts

@@ -3,7 +3,7 @@ import type { SecurityConfig } from "../../types/index.js";
 import type { VeryfrontConfig } from "../../config/index.js";
 import { getConfig } from "../../config/index.js";
 import { serverLogger } from "../../utils/index.js";
-import { buildCSP, generateNonce } from "./response/security-handler.js";
+import { buildCSP, generateNonce, serializeCSPDirectives } from "./response/security-handler.js";
 
 const logger = serverLogger.component("security-config-loader");
 
@@ -33,7 +33,7 @@ export class SecurityConfigLoader {
       this.applyConfig(cfg);
     } catch (error) {
       // Config is optional, so we don't throw
-      logger.debug("Failed to load config:", error);
+      logger.debug("Failed to load config", { error });
       this.isLoaded = true; // Mark as loaded even on error to prevent retry
     }
   }
@@ -54,26 +54,10 @@ export class SecurityConfigLoader {
     }
 
     this.securityConfig = security;
-    this.cspUserHeader = this.parseCspUserHeader(security.csp);
+    this.cspUserHeader = serializeCSPDirectives(security.csp);
     this.isLoaded = true;
   }
 
-  private parseCspUserHeader(csp: SecurityConfig["csp"]): string | null {
-    if (!csp || typeof csp !== "object") return null;
-
-    const pieces: string[] = [];
-
-    for (const [k, v] of Object.entries(csp)) {
-      if (v === undefined) continue;
-
-      const key = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-      const val = Array.isArray(v) ? v.join(" ") : String(v);
-      pieces.push(`${key} ${val}`);
-    }
-
-    return pieces.length ? pieces.join("; ") : null;
-  }
-
   getSecurityConfig(): SecurityConfig | null {
     return this.securityConfig;
   }

package/src/src/security/http/response/security-handler.ts

@@ -56,6 +56,26 @@ function buildDefaultCSP(nonce: string): string {
   ].join("; ");
 }
 
+export function serializeCSPDirectives(
+  csp: SecurityConfig["csp"],
+  nonce?: string,
+): string | null {
+  if (!csp || typeof csp !== "object") return null;
+
+  const pieces: string[] = [];
+
+  for (const [key, value] of Object.entries(csp)) {
+    if (value === undefined) continue;
+
+    const directive = key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+    const sources = Array.isArray(value) ? value.join(" ") : String(value);
+    const serialized = `${directive} ${sources}`;
+    pieces.push(nonce ? serialized.replace(/{NONCE}/g, nonce) : serialized);
+  }
+
+  return pieces.length ? pieces.join("; ") : null;
+}
+
 export function buildCSP(
   isDev: boolean,
   nonce: string,
@@ -69,19 +89,8 @@ export function buildCSP(
   if (cspUserHeader?.trim()) return cspUserHeader.replace(/{NONCE}/g, nonce);
 
   const cfgCsp = config?.csp;
-  if (cfgCsp && typeof cfgCsp === "object") {
-    const pieces: string[] = [];
-
-    for (const [k, v] of Object.entries(cfgCsp)) {
-      if (v === undefined) continue;
-
-      const key = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-      const val = Array.isArray(v) ? v.join(" ") : String(v);
-      pieces.push(`${key} ${val}`.replace(/{NONCE}/g, nonce));
-    }
-
-    if (pieces.length) return pieces.join("; ");
-  }
+  const serializedConfigCsp = serializeCSPDirectives(cfgCsp, nonce);
+  if (serializedConfigCsp) return serializedConfigCsp;
 
   // No explicit CSP configured — apply a secure default in production.
   // Dev mode skips the default to avoid blocking HMR and dev tooling.

package/src/src/security/index.ts

@@ -30,13 +30,10 @@ export type {
   ValidatedHandlerFunction,
 } from "./input-validation/index.js";
 
-export {
-  AuthHandler,
-  loadSecurityConfig,
-  SecurityConfigLoader,
-  setCors,
-} from "./http/handlers-index.js";
-export type { CORSConfig, CSPDirectives, SecurityConfig } from "./http/handlers-index.js";
+export { AuthHandler } from "./http/auth.js";
+export { SecurityConfigLoader } from "./http/config.js";
+export { loadSecurityConfig, setCors } from "./http/middleware/index.js";
+export type { CORSConfig, CSPDirectives, SecurityConfig } from "./http/middleware/index.js";
 
 export { CsrfHandler } from "./http/csrf/index.js";
 export { applyCsrfCookie, generateCsrfToken, validateCsrf } from "./csrf/index.js";

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

@@ -34,6 +34,7 @@ import type {
   VeryfrontApiClient,
 } from "../../../platform/adapters/veryfront-api-client/index.js";
 import { extractProjectCandidates } from "./styles-candidate-scanner.js";
+import { profilePhase } from "../../../observability/request-profiler.js";
 
 const logger = serverLogger.component("styles-css-handler");
 
@@ -59,7 +60,7 @@ export class StylesCSSHandler extends BaseHandler {
         const contentContext = this.getContentContext(ctx);
         let rawCss: string;
         try {
-          rawCss = await this.loadStylesheet(ctx);
+          rawCss = await profilePhase("css.load_stylesheet", () => this.loadStylesheet(ctx));
         } catch (error) {
           logger.error("Failed to load stylesheet", {
             error: error instanceof Error ? error.message : String(error),
@@ -75,7 +76,10 @@ export class StylesCSSHandler extends BaseHandler {
         );
 
         if (preparedContext) {
-          const prepared = await tryGetPreparedProjectCSS(preparedContext);
+          const prepared = await profilePhase(
+            "css.prepared_cache_lookup",
+            () => tryGetPreparedProjectCSS(preparedContext),
+          );
           if (prepared) {
             logger.debug("Prepared CSS cache hit", {
               projectScope,
@@ -90,12 +94,16 @@ export class StylesCSSHandler extends BaseHandler {
           }
         }
 
-        const remotePrepared = await this.tryResolveRemotePreparedCSS(
-          ctx,
-          projectScope,
-          styleProfile.hash,
-          contentContext,
-          preparedContext,
+        const remotePrepared = await profilePhase(
+          "css.remote_artifact_lookup",
+          () =>
+            this.tryResolveRemotePreparedCSS(
+              ctx,
+              projectScope,
+              styleProfile.hash,
+              contentContext,
+              preparedContext,
+            ),
         );
         if (remotePrepared) {
           logger.debug("Prepared CSS resolved via style artifact metadata", {
@@ -111,7 +119,10 @@ export class StylesCSSHandler extends BaseHandler {
 
         let candidates: Set<string>;
         try {
-          candidates = await extractProjectCandidates(ctx);
+          candidates = await profilePhase(
+            "css.extract_candidates",
+            () => extractProjectCandidates(ctx),
+          );
         } catch (error) {
           logger.error("Failed to extract candidates", {
             error: error instanceof Error ? error.message : String(error),
@@ -120,7 +131,10 @@ export class StylesCSSHandler extends BaseHandler {
         }
         let result: GeneratedStylesResult;
         try {
-          result = await this.generateStylesheet(ctx, rawCss, candidates);
+          result = await profilePhase(
+            "css.generate_stylesheet",
+            () => this.generateStylesheet(ctx, rawCss, candidates),
+          );
         } catch (error) {
           const formatted = formatCSSError(error instanceof Error ? error : String(error));
           logger.error("Tailwind error", {
@@ -173,10 +187,14 @@ body::before {
         });
 
         if (preparedContext && "hash" in result) {
-          await storePreparedProjectCSS(preparedContext, {
-            css: result.css,
-            hash: result.hash,
-          });
+          await profilePhase(
+            "css.store_prepared",
+            () =>
+              storePreparedProjectCSS(preparedContext, {
+                css: result.css,
+                hash: result.hash,
+              }),
+          );
         }
 
         if ("hash" in result) {

package/src/src/server/handlers/monitoring/metrics.handler.ts

@@ -2,6 +2,7 @@ import * as dntShim from "../../../../_dnt.shims.js";
 import { BaseHandler } from "../response/base.js";
 import type { HandlerContext, HandlerMetadata, HandlerPriority, HandlerResult } from "../types.js";
 import { metrics } from "../../../observability/simple-metrics/index.js";
+import { snapshotRequestProfiles } from "../../../observability/request-profiler.js";
 import { ResponseBuilder } from "../../../security/index.js";
 import {
   HTTP_INTERNAL_SERVER_ERROR,
@@ -29,11 +30,12 @@ export class MetricsHandler extends BaseHandler {
 
     try {
       const snap = metrics.snapshot();
+      const profiling = snapshotRequestProfiles();
       const memory = this.safeCall(memoryUsage);
       const uptimeValue = this.safeCall(uptime);
 
       const response = ResponseBuilder.json(
-        { counters: snap, memory, uptime: uptimeValue },
+        { counters: snap, profiling, memory, uptime: uptimeValue },
         req,
         { securityConfig, corsConfig, status: HTTP_OK },
       );