veryfront 0.1.89 → 0.1.91

package/esm/src/server/handlers/dev/styles-candidate-scanner.js

@@ -8,6 +8,8 @@
  * @module server/handlers/dev/styles-candidate-scanner
  */
 import { extractCandidates } from "../../../html/styles-builder/tailwind-compiler.js";
+import { resolveStyleContentVersion } from "../../../html/styles-builder/content-version.js";
+import { createStyleScopeProfile, shouldIncludeStylePath, shouldTraverseStyleDirectory, } from "../../../html/styles-builder/style-scope-profile.js";
 import { serverLogger } from "../../../utils/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import { join } from "../../../platform/compat/path/index.js";
@@ -15,22 +17,8 @@ import { getProjectCandidates } from "../../../rendering/orchestrator/css-candid
 import { FRAMEWORK_CANDIDATES } from "./framework-candidates.generated.js";
 const logger = serverLogger.component("styles-candidate-scanner");
 const SOURCE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".ts", ".js"];
-const SKIP_DIRS = new Set(["node_modules", ".cache", ".git", "dist", "build", ".vscode"]);
 /** De-duplicated set of framework candidates, computed once at import time. */
 const frameworkCandidates = new Set(FRAMEWORK_CANDIDATES);
-function resolveProjectVersion(ctx, contentContext) {
-    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.
  *
@@ -39,6 +27,7 @@ function resolveProjectVersion(ctx, contentContext) {
  * method is available (local dev mode).
  */
 export async function extractProjectCandidates(ctx) {
+    const styleProfile = createStyleScopeProfile(ctx.config);
     const wrappedFs = ctx.adapter.fs;
     if (typeof wrappedFs.getUnderlyingAdapter !== "function") {
         logger.debug("[StylesCandidateScanner] No FS adapter wrapper, falling back to local file scanning");
@@ -57,8 +46,13 @@ export async function extractProjectCandidates(ctx) {
         : null;
     for (const cls of getProjectCandidates({
         projectScope: ctx.projectSlug ?? contentContext?.projectSlug ?? ctx.projectDir,
-        projectVersion: resolveProjectVersion(ctx, contentContext),
+        projectVersion: resolveStyleContentVersion(contentContext, {
+            releaseId: ctx.releaseId,
+            branch: ctx.parsedDomain?.branch,
+            environmentName: ctx.environmentName,
+        }),
         projectDir: ctx.projectDir,
+        styleProfile,
         files,
         developmentMode: contentContext?.sourceType === "branch",
     })) {
@@ -71,6 +65,7 @@ export async function extractProjectCandidates(ctx) {
  * Used in local development mode where projects are read directly from disk.
  */
 async function scanLocalFiles(projectDir, ctx) {
+    const styleProfile = createStyleScopeProfile(ctx.config);
     const candidates = new Set(frameworkCandidates);
     const fs = createFileSystem();
     const scanDir = async (dir) => {
@@ -85,12 +80,15 @@ async function scanLocalFiles(projectDir, ctx) {
         for await (const entry of entries) {
             const fullPath = join(dir, entry.name);
             if (entry.isDirectory) {
-                if (!SKIP_DIRS.has(entry.name))
+                if (shouldTraverseStyleDirectory(styleProfile, fullPath, projectDir)) {
                     await scanDir(fullPath);
+                }
                 continue;
             }
             if (!entry.isFile)
                 continue;
+            if (!shouldIncludeStylePath(styleProfile, fullPath, projectDir))
+                continue;
             if (!SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext)))
                 continue;
             try {

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

@@ -12,5 +12,12 @@ export declare class StylesCSSHandler extends BaseHandler {
     handle(req: dntShim.Request, ctx: HandlerContext): Promise<HandlerResult>;
     private loadStylesheet;
     private generateStylesheet;
+    private getContentContext;
+    private getVeryfrontApiClient;
+    private createPreparedCSSContext;
+    private resolveStyleArtifactSelector;
+    private tryResolveRemotePreparedCSS;
+    private getPreparedCSSByHash;
+    private registerPreparedCSSArtifact;
 }
 //# sourceMappingURL=styles-css.handler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"styles-css.handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/server/handlers/dev/styles-css.handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAkBnG,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,QAAQ,EAAE,eAAe,CAKvB;IAEI,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;YAkGjE,cAAc;IAkB5B,OAAO,CAAC,kBAAkB;CAe3B"}
+{"version":3,"file":"styles-css.handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/server/handlers/dev/styles-css.handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AA+BnG,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,QAAQ,EAAE,eAAe,CAKvB;IAEI,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;YAiKjE,cAAc;IAkB5B,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,wBAAwB;IA0BhC,OAAO,CAAC,4BAA4B;YA2CtB,2BAA2B;YAiD3B,oBAAoB;YASpB,2BAA2B;CA0B1C"}

package/esm/src/server/handlers/dev/styles-css.handler.js

@@ -1,8 +1,11 @@
 import { BaseHandler } from "../response/base.js";
 import { HTTP_OK, PRIORITY_HIGH_DEV } from "../../../utils/constants/index.js";
 import { joinPath } from "../../../utils/path-utils.js";
-import { formatCSSError, generateTailwindCSS, getProjectCSS, } from "../../../html/styles-builder/tailwind-compiler.js";
+import { formatCSSError, getCSSByHashAsync, getProjectCSS, regenerateCSSByHash, } from "../../../html/styles-builder/tailwind-compiler.js";
 import { DEFAULT_STYLESHEET } from "../../../html/styles-builder/css-hash-cache.js";
+import { resolveStyleContentVersion } from "../../../html/styles-builder/content-version.js";
+import { createPreparedProjectCSSContext, storePreparedProjectCSS, tryGetPreparedProjectCSS, } from "../../../html/styles-builder/prepared-project-css-cache.js";
+import { createStyleScopeProfile } from "../../../html/styles-builder/style-scope-profile.js";
 import { serverLogger } from "../../../utils/index.js";
 import { extractProjectCandidates } from "./styles-candidate-scanner.js";
 const logger = serverLogger.component("styles-css-handler");
@@ -19,6 +22,9 @@ export class StylesCSSHandler extends BaseHandler {
         try {
             return await this.withProxyContext(ctx, async () => {
                 const responseBuilder = this.createResponseBuilder(ctx).withCache("no-cache");
+                const projectScope = ctx.projectSlug ?? ctx.projectDir;
+                const styleProfile = createStyleScopeProfile(ctx.config);
+                const contentContext = this.getContentContext(ctx);
                 let rawCss;
                 try {
                     rawCss = await this.loadStylesheet(ctx);
@@ -29,6 +35,28 @@ export class StylesCSSHandler extends BaseHandler {
                     });
                     rawCss = DEFAULT_STYLESHEET;
                 }
+                const preparedContext = this.createPreparedCSSContext(projectScope, rawCss, styleProfile.hash, contentContext, ctx);
+                if (preparedContext) {
+                    const prepared = await tryGetPreparedProjectCSS(preparedContext);
+                    if (prepared) {
+                        logger.debug("Prepared CSS cache hit", {
+                            projectScope,
+                            projectVersion: preparedContext.projectVersion,
+                            styleProfileHash: styleProfile.hash,
+                            cssHash: prepared.hash,
+                        });
+                        return this.respond(responseBuilder.withContentType("text/css; charset=utf-8", prepared.css, HTTP_OK));
+                    }
+                }
+                const remotePrepared = await this.tryResolveRemotePreparedCSS(ctx, projectScope, styleProfile.hash, contentContext, preparedContext);
+                if (remotePrepared) {
+                    logger.debug("Prepared CSS resolved via style artifact metadata", {
+                        projectScope,
+                        styleProfileHash: styleProfile.hash,
+                        cssHash: remotePrepared.hash,
+                    });
+                    return this.respond(responseBuilder.withContentType("text/css; charset=utf-8", remotePrepared.css, HTTP_OK));
+                }
                 let candidates;
                 try {
                     candidates = await extractProjectCandidates(ctx);
@@ -39,9 +67,12 @@ export class StylesCSSHandler extends BaseHandler {
                     });
                     candidates = new Set();
                 }
-                const result = await this.generateStylesheet(ctx, rawCss, candidates);
-                if ("error" in result && result.error) {
-                    const formatted = formatCSSError(result.error);
+                let result;
+                try {
+                    result = await this.generateStylesheet(ctx, rawCss, candidates);
+                }
+                catch (error) {
+                    const formatted = formatCSSError(error instanceof Error ? error : String(error));
                     logger.error("Tailwind error", {
                         error: formatted.message,
                         suggestion: formatted.suggestion,
@@ -78,11 +109,21 @@ body::before {
                     });
                 }
                 logger.debug("CSS generated", {
+                    projectScope,
                     candidates: candidates.size,
                     cssLength: result.css.length,
                     fromCache: "fromCache" in result ? result.fromCache : false,
                     cssHash: "hash" in result ? result.hash : undefined,
                 });
+                if (preparedContext && "hash" in result) {
+                    await storePreparedProjectCSS(preparedContext, {
+                        css: result.css,
+                        hash: result.hash,
+                    });
+                }
+                if ("hash" in result) {
+                    await this.registerPreparedCSSArtifact(ctx, styleProfile.hash, contentContext, result.hash);
+                }
                 return this.respond(responseBuilder.withContentType("text/css; charset=utf-8", result.css, HTTP_OK));
             });
         }
@@ -115,13 +156,139 @@ body::before {
         }
     }
     generateStylesheet(ctx, rawCss, candidates) {
-        if (!ctx.projectSlug) {
-            return generateTailwindCSS(rawCss, candidates);
-        }
-        return getProjectCSS(ctx.projectSlug, rawCss, candidates, {
+        const projectScope = ctx.projectSlug ?? ctx.projectDir;
+        return getProjectCSS(projectScope, rawCss, candidates, {
             minify: true,
             environment: "preview",
             buildMode: "production",
         });
     }
+    getContentContext(ctx) {
+        const wrappedFs = ctx.adapter.fs;
+        if (typeof wrappedFs.getUnderlyingAdapter !== "function")
+            return null;
+        const fsAdapter = wrappedFs.getUnderlyingAdapter();
+        return typeof fsAdapter.getContentContext === "function" ? fsAdapter.getContentContext() : null;
+    }
+    getVeryfrontApiClient(ctx) {
+        const wrappedFs = ctx.adapter.fs;
+        if (typeof wrappedFs.getUnderlyingAdapter !== "function")
+            return null;
+        const fsAdapter = wrappedFs.getUnderlyingAdapter();
+        return typeof fsAdapter.getClient === "function" ? fsAdapter.getClient() : null;
+    }
+    createPreparedCSSContext(projectScope, rawCss, styleProfileHash, contentContext, ctx) {
+        if (!projectScope)
+            return undefined;
+        return createPreparedProjectCSSContext(projectScope, resolveStyleContentVersion(contentContext, {
+            releaseId: ctx.releaseId,
+            branch: ctx.parsedDomain?.branch,
+            environmentName: ctx.environmentName,
+        }), rawCss, styleProfileHash, {
+            minify: true,
+            environment: "preview",
+            buildMode: "production",
+        });
+    }
+    resolveStyleArtifactSelector(contentContext, ctx) {
+        if (contentContext?.sourceType === "branch" && contentContext.branch) {
+            return {
+                branch: contentContext.branch,
+            };
+        }
+        if (contentContext?.sourceType === "environment" && contentContext.environmentName) {
+            return {
+                environmentName: contentContext.environmentName,
+            };
+        }
+        if (contentContext?.sourceType === "release" && contentContext.releaseId) {
+            return {
+                releaseId: contentContext.releaseId,
+            };
+        }
+        if (ctx.parsedDomain?.branch) {
+            return {
+                branch: ctx.parsedDomain.branch,
+            };
+        }
+        if (ctx.environmentName) {
+            return {
+                environmentName: ctx.environmentName,
+            };
+        }
+        if (ctx.releaseId) {
+            return {
+                releaseId: ctx.releaseId,
+            };
+        }
+        return null;
+    }
+    async tryResolveRemotePreparedCSS(ctx, projectScope, styleProfileHash, contentContext, preparedContext) {
+        if (!projectScope)
+            return undefined;
+        const selector = this.resolveStyleArtifactSelector(contentContext, ctx);
+        if (!selector)
+            return undefined;
+        const client = this.getVeryfrontApiClient(ctx);
+        if (!client)
+            return undefined;
+        try {
+            const resolved = await client.resolveStyleArtifact({
+                ...selector,
+                styleProfileHash,
+            });
+            if (resolved.status !== "ready" || !resolved.artifactHash) {
+                return undefined;
+            }
+            const css = await this.getPreparedCSSByHash(resolved.artifactHash, projectScope);
+            if (!css)
+                return undefined;
+            if (preparedContext) {
+                await storePreparedProjectCSS(preparedContext, {
+                    css,
+                    hash: resolved.artifactHash,
+                });
+            }
+            return {
+                css,
+                hash: resolved.artifactHash,
+            };
+        }
+        catch (error) {
+            logger.debug("Failed to resolve prepared CSS via style artifact metadata", {
+                projectScope,
+                styleProfileHash,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
+        }
+    }
+    async getPreparedCSSByHash(cssHash, projectScope) {
+        const cached = await getCSSByHashAsync(cssHash);
+        if (cached)
+            return cached;
+        return regenerateCSSByHash(cssHash, projectScope);
+    }
+    async registerPreparedCSSArtifact(ctx, styleProfileHash, contentContext, cssHash) {
+        const selector = this.resolveStyleArtifactSelector(contentContext, ctx);
+        if (!selector)
+            return;
+        const client = this.getVeryfrontApiClient(ctx);
+        if (!client)
+            return;
+        try {
+            await client.upsertStyleArtifact({
+                ...selector,
+                styleProfileHash,
+                artifactHash: cssHash,
+            });
+        }
+        catch (error) {
+            logger.debug("Failed to register prepared CSS artifact", {
+                cssHash,
+                styleProfileHash,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",

package/src/cli/commands/knowledge/command.ts

@@ -219,6 +219,23 @@ function slugify(value: string): string {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "document";
 }
 
+/**
+ * Strip the chat-upload prefix that Studio prepends to uploaded files.
+ *
+ * Studio stores uploads with a generated prefix like:
+ *   chat-<uuid>-<timestamp>-<shortid>-<original-filename>
+ *
+ * This function removes the prefix so knowledge files use the clean
+ * original filename (e.g. "agents" instead of
+ * "chat-909d3dbc-5a9a-4156-97e4-bcceb5c2ec0d-1773942180291-fv1qg5-agents").
+ */
+const CHAT_UPLOAD_PREFIX_RE =
+  /^chat-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-\d+-[a-z0-9]+-/i;
+
+export function stripChatUploadPrefix(name: string): string {
+  return name.replace(CHAT_UPLOAD_PREFIX_RE, "");
+}
+
 function defaultOutputRoot(): Promise<string> {
   return dntShim.Deno.makeTempDir({ prefix: "veryfront-knowledge-" });
 }
@@ -361,7 +378,7 @@ function buildSourceReference(source: KnowledgeSource): string {
     : source.localPath;
 }
 
-function buildSuggestedSlug(source: KnowledgeSource, index: number): string {
+export function buildSuggestedSlug(source: KnowledgeSource, index: number): string {
   const normalized = normalize(
     source.kind === "upload" ? source.uploadPath : source.localPath,
   ).replace(/\\/g, "/");
@@ -383,9 +400,20 @@ function buildSuggestedSlug(source: KnowledgeSource, index: number): string {
     stripped = normalized.replace(/\.[^.]+$/, "");
   }
 
+  // Strip Studio's chat-upload prefix from the filename portion so that
+  // knowledge files use the original clean filename.
+  const lastSlash = stripped.lastIndexOf("/");
+  if (lastSlash >= 0) {
+    const dir = stripped.slice(0, lastSlash + 1);
+    const file = stripChatUploadPrefix(stripped.slice(lastSlash + 1));
+    stripped = file ? `${dir}${file}` : stripped;
+  } else {
+    stripped = stripChatUploadPrefix(stripped) || stripped;
+  }
+
   return slugify(stripped || basename(normalized, extname(normalized)) || `document-${index + 1}`);
 }
-function ensureUniqueSlugs(sources: KnowledgeSource[]): string[] {
+export function ensureUniqueSlugs(sources: KnowledgeSource[]): string[] {
   const counts = new Map<string, number>();
   return sources.map((source, index) => {
     const baseSlug = buildSuggestedSlug(source, index);

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/html/styles-builder/candidate-extractor.ts

@@ -6,6 +6,9 @@
  * @module html/styles-builder/candidate-extractor
  */
 
+import type { StyleScopeProfile } from "./style-scope-profile.js";
+import { shouldIncludeStylePath } from "./style-scope-profile.js";
+
 /**
  * Extract potential Tailwind class name candidates from source code content.
  * Uses a comprehensive regex pattern matching Tailwind v4 utility patterns.
@@ -17,12 +20,22 @@ export function extractCandidates(content: string): string[] {
 
 export function extractCandidatesFromFiles(
   files: Array<{ path: string; content?: string }>,
+  options: {
+    projectDir?: string;
+    styleProfile?: StyleScopeProfile;
+  } = {},
 ): Set<string> {
   const candidates = new Set<string>();
   const sourceExtensions = [".tsx", ".jsx", ".ts", ".js", ".mdx"];
 
   for (const file of files) {
     if (!file.content) continue;
+    if (
+      options.styleProfile &&
+      !shouldIncludeStylePath(options.styleProfile, file.path, options.projectDir)
+    ) {
+      continue;
+    }
     if (!sourceExtensions.some((ext) => file.path.endsWith(ext))) continue;
 
     for (const candidate of extractCandidates(file.content)) {

package/src/src/html/styles-builder/content-version.ts

@@ -0,0 +1,20 @@
+import type { ResolvedContentContext } from "../../platform/adapters/fs/veryfront/types.js";
+
+interface ContentVersionFallback {
+  releaseId?: string | null;
+  branch?: string | null;
+  environmentName?: string | null;
+}
+
+export function resolveStyleContentVersion(
+  contentContext: ResolvedContentContext | null,
+  fallback: ContentVersionFallback = {},
+): string {
+  if (contentContext?.releaseId) return `release:${contentContext.releaseId}`;
+  if (contentContext?.branch) return `branch:${contentContext.branch}`;
+  if (contentContext?.environmentName) return `environment:${contentContext.environmentName}`;
+  if (fallback.releaseId) return `release:${fallback.releaseId}`;
+  if (fallback.branch) return `branch:${fallback.branch}`;
+  if (fallback.environmentName) return `environment:${fallback.environmentName}`;
+  return "live";
+}

package/src/src/html/styles-builder/css-pregeneration.ts

@@ -8,20 +8,35 @@
 
 import { serverLogger } from "../../utils/index.js";
 import { extractCandidatesFromFiles, getProjectCSS } from "./tailwind-compiler.js";
+import {
+  createPreparedProjectCSSContext,
+  storePreparedProjectCSS,
+} from "./prepared-project-css-cache.js";
+import type { StyleScopeProfile } from "./style-scope-profile.js";
 
 const logger = serverLogger.component("css-pregeneration");
 
 interface CSSPregenerationOptions {
   /** Project slug for cache keying */
   projectSlug: string;
+  /** Current content version for the prepared stylesheet artifact */
+  projectVersion: string;
+  /** Project root used for style scope filtering */
+  projectDir?: string;
   /** List of files with content to extract candidates from */
   files: Array<{ path: string; content?: string }>;
+  /** Style scope profile for convention-based filtering */
+  styleProfile: StyleScopeProfile;
   /** Optional custom stylesheet (globals.css content) */
   stylesheet?: string;
   /** Optional stylesheet path (from config) to locate content in files */
   stylesheetPath?: string;
   /** Enable minification (default: true) */
   minify?: boolean;
+  /** Environment segment used for prepared artifact cache partitioning */
+  environment?: string;
+  /** Build mode recorded in the prepared artifact profile */
+  buildMode?: "development" | "production";
 }
 
 /**
@@ -39,34 +54,56 @@ interface CSSPregenerationOptions {
 export async function pregenerateCSSFromFiles(
   options: CSSPregenerationOptions,
 ): Promise<void> {
-  const { projectSlug, files, stylesheet, stylesheetPath, minify = true } = options;
+  const {
+    projectSlug,
+    projectVersion,
+    projectDir,
+    files,
+    styleProfile,
+    stylesheet,
+    stylesheetPath,
+    minify = true,
+    environment = "preview",
+    buildMode = "production",
+  } = options;
   const startTime = performance.now();
 
   try {
-    const candidates = extractCandidatesFromFiles(files);
-
-    if (candidates.size === 0) {
-      logger.debug("No candidates found, skipping", {
-        projectSlug,
-        fileCount: files.length,
-      });
-      return;
-    }
-
     const resolvedStylesheet = stylesheet ?? findStylesheetFromFiles(files, stylesheetPath);
+    const candidates = extractCandidatesFromFiles(files, {
+      projectDir,
+      styleProfile,
+    });
 
     logger.debug("Starting", {
       projectSlug,
+      projectVersion,
       fileCount: files.length,
       candidateCount: candidates.size,
       hasStylesheet: Boolean(resolvedStylesheet),
+      styleProfileHash: styleProfile.hash,
     });
 
-    const result = await getProjectCSS(projectSlug, resolvedStylesheet, candidates, { minify });
+    const result = await getProjectCSS(projectSlug, resolvedStylesheet, candidates, {
+      minify,
+      environment,
+      buildMode,
+    });
+    await storePreparedProjectCSS(
+      createPreparedProjectCSSContext(
+        projectSlug,
+        projectVersion,
+        resolvedStylesheet,
+        styleProfile.hash,
+        { minify, environment, buildMode },
+      ),
+      { css: result.css, hash: result.hash },
+    );
     const duration = performance.now() - startTime;
 
     logger.debug("Complete", {
       projectSlug,
+      projectVersion,
       candidateCount: candidates.size,
       cssLength: result.css.length,
       cssHash: result.hash,