veryfront 0.1.92 → 0.1.94

package/src/src/platform/adapters/veryfront-api-client/operations.ts

@@ -64,19 +64,28 @@ export interface ResolveStyleArtifactInput extends StyleArtifactSelector {
   styleProfileHash: string;
 }
 
+export interface EnsureStyleArtifactBuildInput extends ResolveStyleArtifactInput {
+  force?: boolean;
+}
+
 export interface UpsertStyleArtifactInput extends ResolveStyleArtifactInput {
-  artifactHash: string;
+  status?: "building" | "ready" | "failed";
+  artifactHash?: string;
   assetPath?: string;
   contentType?: string;
   etag?: string;
+  buildJobId?: string;
+  failureReason?: string;
 }
 
 export interface ProjectStyleArtifactResolution {
-  status: "ready" | "missing";
+  status: "ready" | "missing" | "building" | "failed";
   artifactHash?: string;
   assetPath?: string;
   etag?: string;
   contentType?: string;
+  buildJobId?: string;
+  failureReason?: string;
   updatedAt?: string;
 }
 
@@ -128,6 +137,8 @@ function mapStyleArtifactResolution(raw: unknown): ProjectStyleArtifactResolutio
     assetPath: response.asset_path,
     etag: response.etag,
     contentType: response.content_type,
+    buildJobId: response.build_job_id,
+    failureReason: response.failure_reason,
     updatedAt: response.updated_at,
   };
 }
@@ -491,6 +502,37 @@ export class VeryfrontAPIOperations {
     return mapStyleArtifactResolution(await this.request(url));
   }
 
+  async ensureStyleArtifactBuild(
+    projectRef: string,
+    input: EnsureStyleArtifactBuildInput,
+  ): Promise<ProjectStyleArtifactResolution> {
+    const url = `/projects/${encodeURIComponent(projectRef)}/style-artifacts/current/builds`;
+    logger.debug("ensureStyleArtifactBuild", {
+      projectRef,
+      branch: input.branch,
+      environmentName: input.environmentName,
+      releaseId: input.releaseId,
+      styleProfileHash: input.styleProfileHash,
+      force: input.force ?? false,
+    });
+
+    return mapStyleArtifactResolution(
+      await this.request(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          style_profile_hash: input.styleProfileHash,
+          branch: input.branch,
+          environment_name: input.environmentName,
+          release_id: input.releaseId,
+          force: input.force ?? false,
+        }),
+      }),
+    );
+  }
+
   async upsertStyleArtifact(
     projectRef: string,
     input: UpsertStyleArtifactInput,
@@ -502,6 +544,7 @@ export class VeryfrontAPIOperations {
       environmentName: input.environmentName,
       releaseId: input.releaseId,
       styleProfileHash: input.styleProfileHash,
+      status: input.status ?? "ready",
       artifactHash: input.artifactHash,
     });
 
@@ -516,10 +559,13 @@ export class VeryfrontAPIOperations {
           branch: input.branch,
           environment_name: input.environmentName,
           release_id: input.releaseId,
+          status: input.status ?? "ready",
           artifact_hash: input.artifactHash,
           asset_path: input.assetPath,
           content_type: input.contentType,
           etag: input.etag,
+          build_job_id: input.buildJobId,
+          failure_reason: input.failureReason,
         }),
       }),
     );

package/src/src/platform/adapters/veryfront-api-client/schemas/api.schema.ts

@@ -148,11 +148,13 @@ export const LookupDomainResponseSchema = z.object({
 });
 
 export const StyleArtifactResolveResponseSchema = z.object({
-  status: z.enum(["ready", "missing"]),
+  status: z.enum(["ready", "missing", "building", "failed"]),
   artifact_hash: z.string().optional(),
   asset_path: z.string().optional(),
   etag: z.string().optional(),
   content_type: z.string().optional(),
+  build_job_id: z.string().uuid().optional(),
+  failure_reason: z.string().optional(),
   updated_at: z.string().optional(),
 });
 
@@ -228,4 +230,10 @@ export const API_ENDPOINTS = {
     description:
       "Resolve metadata for the latest ready style artifact for a branch, environment, or release selector",
   },
+  ensureStyleArtifactBuild: {
+    method: "POST" as const,
+    path: "/projects/{projectRef}/style-artifacts/current/builds",
+    description:
+      "Ensure a background style artifact build exists for a branch, environment, or release selector",
+  },
 } as const;

package/src/src/rendering/styles.ts

@@ -0,0 +1,15 @@
+/**
+ * Public style artifact helpers used by CLI and worker entrypoints.
+ *
+ * @module rendering/styles
+ */
+
+export {
+  buildPreparedCSSArtifactFromFiles,
+  type PreparedCSSArtifactBuildResult,
+} from "../html/styles-builder/css-pregeneration.js";
+export {
+  createStyleScopeProfile,
+  type StyleScopeProfile,
+} from "../html/styles-builder/style-scope-profile.js";
+export { resolveStyleContentVersion } from "../html/styles-builder/content-version.js";

package/src/src/sandbox/index.ts

@@ -24,6 +24,7 @@ export {
   type CommandJobHeartbeatStatus,
   type CommandJobOutput,
   type CommandJobStatus,
+  type ExecOptions,
   type ExecResult,
   type ExecStreamEvent,
   Sandbox,

package/src/src/sandbox/sandbox.ts

@@ -19,6 +19,16 @@ import {
 import { getVeryfrontCloudAuthToken } from "../platform/cloud/resolver.js";
 import { getHostEnv } from "../platform/compat/process.js";
 
+/** Options for command execution: working directory, timeout, and environment variables. */
+export interface ExecOptions {
+  /** Working directory for the command. */
+  cwd?: string;
+  /** Timeout in seconds for the command. */
+  timeout_seconds?: number;
+  /** Additional environment variables for the command. */
+  env?: Record<string, string>;
+}
+
 /** Options for creating a sandbox session. */
 export interface SandboxOptions {
   /** Base URL of the Veryfront API. Defaults to VERYFRONT_API_URL env. */
@@ -242,12 +252,12 @@ export class Sandbox {
   }
 
   /** Execute a bash command in the sandbox and return buffered result. */
-  async executeCommand(command: string): Promise<ExecResult> {
+  async executeCommand(command: string, options?: ExecOptions): Promise<ExecResult> {
     let stdout = "";
     let stderr = "";
     let exitCode = 1;
 
-    for await (const event of this.executeStream(command)) {
+    for await (const event of this.executeStream(command, options)) {
       switch (event.type) {
         case "stdout":
           stdout += event.data ?? "";
@@ -265,14 +275,14 @@ export class Sandbox {
   }
 
   /** Execute a bash command with streaming output (NDJSON). */
-  async *executeStream(command: string): AsyncGenerator<ExecStreamEvent> {
+  async *executeStream(command: string, options?: ExecOptions): AsyncGenerator<ExecStreamEvent> {
     const res = await dntShim.fetch(`${this.endpoint}/exec`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ command }),
+      body: JSON.stringify({ command, ...options }),
     });
 
     if (!res.ok) {
@@ -343,14 +353,14 @@ export class Sandbox {
   }
 
   /** Start an async command job in the sandbox. */
-  async startCommandJob(command: string): Promise<CommandJob> {
+  async startCommandJob(command: string, options?: ExecOptions): Promise<CommandJob> {
     const res = await dntShim.fetch(`${this.endpoint}/exec/jobs`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ command }),
+      body: JSON.stringify({ command, ...options }),
     });
 
     if (!res.ok) {
@@ -399,6 +409,23 @@ export class Sandbox {
     };
   }
 
+  /** List all command jobs in the sandbox. */
+  async listCommandJobs(): Promise<CommandJob[]> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs`, {
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `List command jobs failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    const json = await res.json();
+    const jobs = Array.isArray(json) ? json : (json.jobs ?? []);
+    return jobs.map((j: Record<string, unknown>) => Sandbox.mapCommandJob(j));
+  }
+
   /** Cancel an async command job. */
   async cancelCommandJob(jobId: string): Promise<CommandJob> {
     const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}/cancel`, {

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

@@ -7,6 +7,7 @@ import type {
   RoutePattern,
 } from "../../types/index.js";
 import { runWithCacheBatching } from "../../cache/request-cache-batcher.js";
+import { getHostEnv } from "../../platform/compat/process.js";
 import { serverLogger } from "../../utils/index.js";
 import { ResponseBuilder } from "./response/index.js";
 
@@ -78,7 +79,7 @@ export abstract class BaseHandler implements Handler {
   }
 
   protected logDebug(message: string, extra?: Record<string, unknown>, ctx?: HandlerContext): void {
-    if (!ctx?.debug && !ctx?.adapter.env.get("VERYFRONT_DEBUG")) return;
+    if (!ctx?.debug && !getHostEnv("VERYFRONT_DEBUG")) return;
     serverLogger.debug(`[${this.metadata.name}] ${message}`, extra ?? undefined);
   }
 
@@ -108,7 +109,9 @@ export abstract class BaseHandler implements Handler {
     fn: () => Promise<T>,
     options: { requireToken?: boolean } = {},
   ): Promise<T> {
-    const effectiveToken = ctx.proxyToken || ctx.adapter.env.get("VERYFRONT_API_TOKEN") || "";
+    // Framework-owned token: bypass project env overlay so proxy mode works
+    // when a remote project overlay is active.
+    const effectiveToken = ctx.proxyToken || getHostEnv("VERYFRONT_API_TOKEN") || "";
     const fsWrapper = ctx.adapter.fs as {
       setRequestToken?: (t: string) => void;
       setRequestBranch?: (b: string | null) => void;

package/src/src/server/context/request-context.ts

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { getEnv } from "../../platform/compat/process.js";
+import { getHostEnv } from "../../platform/compat/process.js";
 import { parseProjectDomain } from "../utils/domain-parser.js";
 
 export interface RequestContext {
@@ -28,7 +28,9 @@ export function createRequestContext(req: dntShim.Request): RequestContext {
     : "production";
 
   return {
-    token: req.headers.get("x-token") ?? getEnv("VERYFRONT_API_TOKEN") ?? "",
+    // Framework-owned token: bypass project env overlay so proxy mode works
+    // when a remote project overlay is active.
+    token: req.headers.get("x-token") ?? getHostEnv("VERYFRONT_API_TOKEN") ?? "",
     slug: req.headers.get("x-project-slug") ?? parsed.slug ?? "",
     branch: parsed.branch,
     mode,

package/src/src/server/handlers/dev/scripts/hmr-scripts.ts

@@ -57,11 +57,94 @@ function getUpdateJSFunction(logPrefix: string): string {
     return false;
   }
 
+  async function swapTailwindStylesheet(nextHref) {
+    const current = document.getElementById('vf-tailwind-css');
+    if (!(current instanceof HTMLLinkElement) || !nextHref || !current.parentNode) {
+      return false;
+    }
+
+    const nextUrl = new URL(nextHref, window.location.origin).toString();
+    const currentHref = current.getAttribute('href');
+    const currentUrl = currentHref ? new URL(currentHref, window.location.href).toString() : '';
+    if (currentUrl === nextUrl) {
+      return true;
+    }
+
+    const pending = current.cloneNode(false);
+    if (!(pending instanceof HTMLLinkElement)) {
+      return false;
+    }
+
+    pending.removeAttribute('id');
+    pending.setAttribute('data-vf-tailwind-pending', 'true');
+    pending.href = nextHref;
+
+    await new Promise((resolve, reject) => {
+      const timeoutId = window.setTimeout(() => {
+        cleanup(new Error('stylesheet-timeout'));
+      }, 5000);
+
+      let settled = false;
+
+      function cleanup(error) {
+        if (settled) return;
+        settled = true;
+        window.clearTimeout(timeoutId);
+        pending.removeEventListener('load', onLoad);
+        pending.removeEventListener('error', onError);
+
+        if (error) {
+          pending.remove();
+          reject(error);
+          return;
+        }
+
+        pending.id = 'vf-tailwind-css';
+        current.remove();
+        resolve(true);
+      }
+
+      function onLoad() {
+        cleanup(null);
+      }
+
+      function onError() {
+        cleanup(new Error('stylesheet-load-failed'));
+      }
+
+      pending.addEventListener('load', onLoad, { once: true });
+      pending.addEventListener('error', onError, { once: true });
+      current.parentNode.insertBefore(pending, current.nextSibling);
+    });
+
+    return true;
+  }
+
+  async function applyStyleUpdate(changedPath, styleHref) {
+    if (styleHref) {
+      try {
+        const swapped = await swapTailwindStylesheet(styleHref);
+        if (swapped) {
+          ${
+    logPrefix === "[HMR]"
+      ? `console.log('${logPrefix} Swapped stylesheet:', styleHref);`
+      : `dlog('${logPrefix} Swapped stylesheet:', styleHref);`
+  }
+          return true;
+        }
+      } catch (error) {
+        console.warn('${logPrefix} Failed to swap stylesheet:', error);
+      }
+    }
+
+    return refreshStylesheets(changedPath) || refreshStylesheets();
+  }
+
   function getRenderPath() {
     return window.location.pathname + window.location.search + window.location.hash;
   }
 
-  async function updateJS(path) {
+  async function updateJS(path, styleHref) {
     ${
     logPrefix === "[HMR]"
       ? `console.log('${logPrefix} Updating JS module:', path);`
@@ -83,7 +166,7 @@ function getUpdateJSFunction(logPrefix: string): string {
       }
 
       // Refresh Tailwind CSS (new classes may be needed from JS changes)
-      refreshStylesheets();
+      await applyStyleUpdate(path, styleHref);
 
       // Re-render the page with fresh modules
       if (window.__veryfrontRenderPage) {
@@ -271,6 +354,7 @@ function generateHMRClient(opts: HMRScriptOptions): string {
 
   // Debounce updates to prevent flashing from rapid-fire changes
   let pendingPaths = [];
+  let pendingStyleHref = null;
   let updateDebounceTimer = null;
   const UPDATE_DEBOUNCE_MS = 150;
 
@@ -282,7 +366,7 @@ function generateHMRClient(opts: HMRScriptOptions): string {
 
     // CSS changes: hot-swap stylesheet without full page reload
     if (update.path.endsWith('.css')) {
-      const didRefresh = refreshStylesheets(update.path) || refreshStylesheets();
+      const didRefresh = await applyStyleUpdate(update.path, update.styleHref);
       if (!didRefresh) {
         notifyStudioAndReload('css-update-no-stylesheet');
         return;
@@ -293,12 +377,17 @@ function generateHMRClient(opts: HMRScriptOptions): string {
 
     // Debounce JS updates — batch rapid updates into single re-render
     pendingPaths.push(update.path);
+    if (typeof update.styleHref === 'string') {
+      pendingStyleHref = update.styleHref;
+    }
 
     if (updateDebounceTimer) clearTimeout(updateDebounceTimer);
 
     updateDebounceTimer = setTimeout(async () => {
       const paths = pendingPaths;
+      const styleHref = pendingStyleHref;
       pendingPaths = [];
+      pendingStyleHref = null;
       updateDebounceTimer = null;
 
       if (paths.length > 1) {
@@ -306,7 +395,7 @@ function generateHMRClient(opts: HMRScriptOptions): string {
       }
 
       // Single re-render handles all paths (server propagates timestamps to all imports)
-      if (paths.length > 0) await updateJS(paths[0]);
+      if (paths.length > 0) await updateJS(paths[0], styleHref);
     }, UPDATE_DEBOUNCE_MS);
   }
 ${getUpdateJSFunction(logPrefix)}

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

@@ -29,6 +29,7 @@ import { createStyleScopeProfile } from "../../../html/styles-builder/style-scop
 import { serverLogger } from "../../../utils/index.js";
 import type { ResolvedContentContext } from "../../../platform/adapters/fs/veryfront/types.js";
 import type {
+  EnsureStyleArtifactBuildInput,
   ResolveStyleArtifactInput,
   VeryfrontApiClient,
 } from "../../../platform/adapters/veryfront-api-client/index.js";
@@ -353,6 +354,9 @@ body::before {
       });
 
       if (resolved.status !== "ready" || !resolved.artifactHash) {
+        if (resolved.status !== "building") {
+          await this.ensureRemotePreparedCSSBuild(client, selector, styleProfileHash);
+        }
         return undefined;
       }
 
@@ -415,4 +419,31 @@ body::before {
       });
     }
   }
+
+  private shouldEnsureRemoteStyleArtifactBuild(selector: StyleArtifactSelectorContext): boolean {
+    return Boolean(selector.environmentName || selector.releaseId);
+  }
+
+  private async ensureRemotePreparedCSSBuild(
+    client: VeryfrontApiClient,
+    selector: StyleArtifactSelectorContext,
+    styleProfileHash: string,
+  ): Promise<void> {
+    if (!this.shouldEnsureRemoteStyleArtifactBuild(selector)) return;
+
+    try {
+      await client.ensureStyleArtifactBuild(
+        {
+          ...selector,
+          styleProfileHash,
+        } satisfies EnsureStyleArtifactBuildInput,
+      );
+    } catch (error) {
+      logger.debug("Failed to ensure remote prepared CSS build", {
+        selector,
+        styleProfileHash,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
 }

package/src/src/server/handlers/preview/hmr-message-router.ts

@@ -1,4 +1,5 @@
 import { serverLogger } from "../../../utils/index.js";
+import type { ReloadProjectInfo } from "../../reload-notifier.js";
 import { getClientCount, getOpenSockets } from "./hmr-client-manager.js";
 
 const logger = serverLogger.component("hmr-handler");
@@ -19,6 +20,13 @@ export function getMetrics(): { clients: number } & HMRMetrics {
   return { clients: getClientCount(), ...metrics };
 }
 
+function buildStyleUpdatePayload(project?: ReloadProjectInfo): Record<string, string> {
+  const payload: Record<string, string> = {};
+  if (project?.styleAssetPath) payload.styleHref = project.styleAssetPath;
+  if (project?.styleArtifactHash) payload.styleHash = project.styleArtifactHash;
+  return payload;
+}
+
 function requiresFullReload(path: string): boolean {
   const ext = path.split(".").pop()?.toLowerCase();
   return ext === "mdx" || ext === "md" || path.includes("veryfront.config");
@@ -28,11 +36,12 @@ function requiresFullReload(path: string): boolean {
  * Broadcast update to all connected HMR clients, optionally filtered by projectSlug.
  * No server-side debounce here — ReloadNotifier already debounces (300ms).
  */
-export function broadcastUpdate(changedPaths?: string[], projectSlug?: string): void {
+export function broadcastUpdate(changedPaths?: string[], project?: ReloadProjectInfo): void {
   logger.debug("broadcastUpdate called", {
     changedPaths,
     totalClients: getClientCount(),
-    projectSlug,
+    projectSlug: project?.projectSlug,
+    styleAssetPath: project?.styleAssetPath,
   });
 
   const timestamp = Date.now();
@@ -44,12 +53,13 @@ export function broadcastUpdate(changedPaths?: string[], projectSlug?: string):
 
   if (needsFullReload) {
     const message = JSON.stringify({ type: "reload", timestamp });
-    broadcastMessage(message, projectSlug);
+    broadcastMessage(message, project?.projectSlug);
     metrics.messagesForwarded++;
   } else {
+    const stylePayload = buildStyleUpdatePayload(project);
     for (const path of changedPaths) {
-      const message = JSON.stringify({ type: "update", path, timestamp });
-      broadcastMessage(message, projectSlug);
+      const message = JSON.stringify({ type: "update", path, timestamp, ...stylePayload });
+      broadcastMessage(message, project?.projectSlug);
       metrics.messagesForwarded++;
     }
   }

package/src/src/server/handlers/preview/hmr.handler.ts

@@ -78,7 +78,7 @@ export class HMRHandler extends BaseHandler {
         return;
       }
 
-      broadcastUpdate(changedPaths, project?.projectSlug);
+      broadcastUpdate(changedPaths, project);
     });
 
     startPingInterval();

package/src/src/server/handlers/preview/markdown-preview.handler.ts

@@ -16,7 +16,7 @@ import { HTTP_OK } from "../../../utils/constants/index.js";
 import { compileMarkdownRuntime } from "../../../transforms/md/compiler/md-compiler.js";
 import { extract } from "../../../platform/compat/std/front-matter-yaml.js";
 import { isExtendedFSAdapter } from "../../../platform/adapters/fs/wrapper.js";
-import { getEnv } from "../../../platform/compat/process.js";
+import { getHostEnv } from "../../../platform/compat/process.js";
 import { tryNotFoundFallback } from "../request/ssr/not-found-fallback.js";
 import { generateMarkdownHtml } from "./markdown-html-generator.js";
 import { validatePathSync } from "../../../security/index.js";
@@ -70,7 +70,9 @@ export class MarkdownPreviewHandler extends BaseHandler {
     const hasMultiProjectSupport = isExtendedFSAdapter(fsAdapter) && fsAdapter.isMultiProjectMode();
 
     if (ctx.projectSlug && hasMultiProjectSupport) {
-      const effectiveToken = ctx.proxyToken || getEnv("VERYFRONT_API_TOKEN") || "";
+      // Framework-owned token: bypass project env overlay so proxy mode works
+      // when a remote project overlay is active.
+      const effectiveToken = ctx.proxyToken || getHostEnv("VERYFRONT_API_TOKEN") || "";
       const branch = ctx.parsedDomain?.branch ?? null;
 
       return await fsAdapter.runWithContext(

package/src/src/server/handlers/request/css.handler.ts

@@ -10,7 +10,7 @@ import {
   extractCacheKeyContext,
   runWithCacheKeyContext,
 } from "../../../cache/cache-key-builder.js";
-import { getEnv } from "../../../platform/compat/process.js";
+import { getHostEnv } from "../../../platform/compat/process.js";
 import { runWithRequestContext } from "../../../platform/adapters/fs/veryfront/multi-project-adapter.js";
 
 /** Pattern to match hashed CSS URLs: /_vf/css/[8-char-hash].css */
@@ -50,7 +50,9 @@ export class CSSHandler extends BaseHandler {
     // the distributed API cache backend can't authenticate and silently returns
     // null — causing cross-pod cache misses. Wrap the lookup in request context
     // so the API backend can resolve the token and project.
-    const effectiveToken = ctx.proxyToken || getEnv("VERYFRONT_API_TOKEN") || "";
+    // Framework-owned token: bypass project env overlay so proxy mode works
+    // when a remote project overlay is active.
+    const effectiveToken = ctx.proxyToken || getHostEnv("VERYFRONT_API_TOKEN") || "";
     const lookup = () =>
       runWithCacheKeyContext(cacheCtx, () =>
         getCSSWithJITFallback(

package/src/src/server/handlers/request/ssr/ssr.handler.ts

@@ -19,7 +19,7 @@ import type {
 import { PRIORITY_LOW } from "../../../../utils/constants/index.js";
 import { generateNonce } from "../../../../security/http/response/security-handler.js";
 import { isExtendedFSAdapter } from "../../../../platform/adapters/fs/wrapper.js";
-import { getEnv } from "../../../../platform/compat/process.js";
+import { getHostEnv } from "../../../../platform/compat/process.js";
 import { shouldUseNoCacheHeadersFromHandler } from "../../../context/enriched-context.js";
 import { withSpan } from "../../../../observability/tracing/otlp-setup.js";
 import { serverLogger } from "../../../../utils/index.js";
@@ -117,7 +117,9 @@ export class SSRHandler extends BaseHandler {
       if (ctx.projectSlug && isExtended && fsAdapter.isMultiProjectMode()) {
         const prodMode = isProductionMode(ctx, url);
         const branch = ctx.parsedDomain?.branch ?? null;
-        const effectiveToken = ctx.proxyToken || getEnv("VERYFRONT_API_TOKEN") || "";
+        // Framework-owned token: bypass project env overlay so proxy mode works
+        // when a remote project overlay is active.
+        const effectiveToken = ctx.proxyToken || getHostEnv("VERYFRONT_API_TOKEN") || "";
 
         logger.debug("Using multi-project context", {
           projectSlug: ctx.projectSlug,

package/src/src/server/reload-notifier.ts

@@ -3,13 +3,15 @@ import { serverLogger } from "../utils/index.js";
 
 const logger = serverLogger.component("reload-notifier");
 
-interface ReloadProjectInfo {
+export interface ReloadProjectInfo {
   projectSlug?: string;
   projectId?: string;
   projectDir?: string;
   environment?: "preview" | "production";
   branch?: string | null;
   releaseId?: string | null;
+  styleArtifactHash?: string;
+  styleAssetPath?: string;
 }
 
 type ReloadListener = (changedPaths?: string[], project?: ReloadProjectInfo) => void;

package/src/src/utils/version.ts

@@ -3,7 +3,7 @@ import { getEnv } from "../platform/compat/process.js";
 
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.92";
+export const VERSION = "0.1.94";
 
 export function normalizeVeryfrontVersion(version: string | undefined): string | undefined {
   if (!version) return undefined;