veryfront 0.1.128 → 0.1.129

package/esm/src/utils/version.js

@@ -25,7 +25,6 @@ export const RUNTIME_VERSION = resolveRuntimeVersion({
     veryfrontVersion: getVersionEnv("VERYFRONT_VERSION"),
     releaseVersion: getVersionEnv("RELEASE_VERSION"),
     denoVersion: typeof denoConfig.version === "string" ? denoConfig.version : undefined,
-    fallbackVersion: VERSION,
 });
 export const SERVER_START_TIME = Date.now();
 export function createBuildVersion(projectUpdated) {

package/esm/src/workflow/worker/dynamic-job-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-job-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/dynamic-job-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAWH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAM5D;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAsBD;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,MAAM,CAAC,CAiLjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iCAAiC;IAChD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CAchC"}
+{"version":3,"file":"dynamic-job-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/dynamic-job-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAY5D;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,MAAM,CAAC,CAgIjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iCAAiC;IAChD,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CAchC"}

package/esm/src/workflow/worker/dynamic-job-entrypoint.js

@@ -26,13 +26,11 @@
  */
 import { logger as baseLogger } from "../../utils/index.js";
 import { getEnv } from "../../platform/compat/process.js";
-import { env as getProcessEnv } from "../../platform/compat/process.js";
-import { runWithRequestContext } from "../../platform/adapters/fs/veryfront/multi-project-adapter.js";
 import { enhanceAdapterWithFS } from "../../platform/adapters/fs/integration.js";
 import { denoAdapter } from "../../platform/adapters/runtime/deno/index.js";
-import { mergeInjectedWorkflowEnv } from "../../jobs/runtime-env.js";
 import { discoverWorkflows } from "../discovery/index.js";
 import { WorkflowExecutor } from "../executor/workflow-executor.js";
+import { failRunExecution, getFinalRunExitCode, getTenantFromEnv, hydrateRunContextEnv, runWithTenantContext, } from "./shared.js";
 const logger = baseLogger.component("dynamic-job");
 /**
  * Exit codes for the job
@@ -44,23 +42,6 @@ export const DYNAMIC_EXIT_CODES = {
     NOT_FOUND: 3,
     DISCOVERY_FAILED: 4,
 };
-/**
- * Get tenant context from environment variables
- */
-function getTenantFromEnv() {
-    const projectSlug = getEnv("TENANT_PROJECT_SLUG");
-    const token = getEnv("TENANT_TOKEN");
-    if (!projectSlug || !token) {
-        return undefined;
-    }
-    return {
-        projectSlug,
-        token,
-        projectId: getEnv("TENANT_PROJECT_ID"),
-        productionMode: getEnv("TENANT_PRODUCTION_MODE") === "1",
-        releaseId: getEnv("TENANT_RELEASE_ID") || undefined,
-    };
-}
 /**
  * Run a workflow job with dynamic discovery
  *
@@ -90,21 +71,7 @@ export async function runDynamicWorkflowJob(config) {
             logger.error(`Workflow run not found: ${runId}`);
             return DYNAMIC_EXIT_CODES.NOT_FOUND;
         }
-        const injectedEnv = mergeInjectedWorkflowEnv(run.context.env, getProcessEnv());
-        if (injectedEnv) {
-            const currentEnv = run.context.env;
-            const currentSerialized = currentEnv ? JSON.stringify(currentEnv) : "";
-            const nextSerialized = JSON.stringify(injectedEnv);
-            if (currentSerialized !== nextSerialized) {
-                await backend.updateRun(runId, {
-                    context: {
-                        ...run.context,
-                        env: injectedEnv,
-                    },
-                });
-                run = (await backend.getRun(runId)) ?? run;
-            }
-        }
+        run = await hydrateRunContextEnv(backend, runId, run);
         // Get tenant context (from env or from stored run)
         const tenant = getTenantFromEnv() ?? run._tenant;
         if (!tenant) {
@@ -116,13 +83,7 @@ export async function runDynamicWorkflowJob(config) {
             logger.info(`Tenant: ${tenant.projectSlug}`);
         }
         // Execute with tenant context
-        return await runWithRequestContext({
-            projectSlug: tenant.projectSlug,
-            token: tenant.token,
-            projectId: tenant.projectId,
-            productionMode: tenant.productionMode,
-            releaseId: tenant.releaseId,
-        }, async () => {
+        return await runWithTenantContext(tenant, async () => {
             // Set up FS adapter with Veryfront API backend
             const apiUrl = getEnv("VERYFRONT_API_URL") || "https://api.veryfront.com";
             const fsConfig = {
@@ -175,38 +136,10 @@ export async function runDynamicWorkflowJob(config) {
             // Execute the workflow
             try {
                 await executor.resume(runId);
-                const finalRun = await backend.getRun(runId);
-                const status = finalRun?.status;
-                switch (status) {
-                    case "completed":
-                        if (debug) {
-                            logger.info(`Workflow completed successfully: ${runId}`);
-                        }
-                        return DYNAMIC_EXIT_CODES.SUCCESS;
-                    case "failed":
-                        logger.error(`Workflow failed: ${runId}`, finalRun?.error);
-                        return DYNAMIC_EXIT_CODES.WORKFLOW_FAILED;
-                    case "waiting":
-                        if (debug) {
-                            logger.info(`Workflow paused (waiting): ${runId}`);
-                        }
-                        return DYNAMIC_EXIT_CODES.SUCCESS;
-                    default:
-                        logger.warn(`Unexpected final status: ${status}`);
-                        return DYNAMIC_EXIT_CODES.SUCCESS;
-                }
+                return getFinalRunExitCode(logger, DYNAMIC_EXIT_CODES, runId, await backend.getRun(runId), debug);
             }
             catch (error) {
-                logger.error("Execution error:", error);
-                await backend.updateRun(runId, {
-                    status: "failed",
-                    error: {
-                        message: `EXECUTION_ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                        stack: error instanceof Error ? error.stack : undefined,
-                    },
-                    completedAt: new Date(),
-                });
-                return DYNAMIC_EXIT_CODES.WORKFLOW_FAILED;
+                return await failRunExecution(backend, logger, DYNAMIC_EXIT_CODES, runId, error);
             }
         });
     }

package/esm/src/workflow/worker/job-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/job-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAyB,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAI7E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAsBX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmHjF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,0BAA0B;IACzC,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA0BhC"}
+{"version":3,"file":"job-entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/job-entrypoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,wBAAwB;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgEjF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,0BAA0B;IACzC,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,SAAS,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAErD,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CA0BhC"}

package/esm/src/workflow/worker/job-entrypoint.js

@@ -21,9 +21,7 @@
  */
 import { logger as baseLogger } from "../../utils/index.js";
 import { getEnv } from "../../platform/compat/process.js";
-import { env as getProcessEnv } from "../../platform/compat/process.js";
-import { runWithRequestContext } from "../../platform/adapters/fs/veryfront/multi-project-adapter.js";
-import { mergeInjectedWorkflowEnv } from "../../jobs/runtime-env.js";
+import { failRunExecution, getFinalRunExitCode, getTenantFromEnv, hydrateRunContextEnv, runWithTenantContext, } from "./shared.js";
 const logger = baseLogger.component("workflow-job");
 /**
  * Exit codes for the job
@@ -34,23 +32,6 @@ export const EXIT_CODES = {
     CONFIG_ERROR: 2,
     NOT_FOUND: 3,
 };
-/**
- * Get tenant context from environment variables
- */
-function getTenantFromEnv() {
-    const projectSlug = getEnv("TENANT_PROJECT_SLUG");
-    const token = getEnv("TENANT_TOKEN");
-    if (!projectSlug || !token) {
-        return undefined;
-    }
-    return {
-        projectSlug,
-        token,
-        projectId: getEnv("TENANT_PROJECT_ID") || undefined,
-        productionMode: getEnv("TENANT_PRODUCTION_MODE") === "1",
-        releaseId: getEnv("TENANT_RELEASE_ID") || undefined,
-    };
-}
 /**
  * Run the workflow job
  *
@@ -96,21 +77,7 @@ export async function runWorkflowJob(config) {
             logger.error(`Workflow run not found: ${runId}`);
             return EXIT_CODES.NOT_FOUND;
         }
-        const injectedEnv = mergeInjectedWorkflowEnv(run.context.env, getProcessEnv());
-        if (injectedEnv) {
-            const currentEnv = run.context.env;
-            const currentSerialized = currentEnv ? JSON.stringify(currentEnv) : "";
-            const nextSerialized = JSON.stringify(injectedEnv);
-            if (currentSerialized !== nextSerialized) {
-                await backend.updateRun(runId, {
-                    context: {
-                        ...run.context,
-                        env: injectedEnv,
-                    },
-                });
-                run = (await backend.getRun(runId)) ?? run;
-            }
-        }
+        run = await hydrateRunContextEnv(backend, runId, run);
         // Get tenant context (from env or from stored run)
         const tenant = getTenantFromEnv() ?? run._tenant;
         if (debug) {
@@ -120,26 +87,7 @@ export async function runWorkflowJob(config) {
         // Execute workflow and determine exit code based on final status
         const executeWorkflow = async () => {
             await executor.resume(runId);
-            const finalRun = await backend.getRun(runId);
-            const status = finalRun?.status;
-            switch (status) {
-                case "completed":
-                    if (debug) {
-                        logger.info(`Workflow completed successfully: ${runId}`);
-                    }
-                    return EXIT_CODES.SUCCESS;
-                case "failed":
-                    logger.error(`Workflow failed: ${runId}`, finalRun?.error);
-                    return EXIT_CODES.WORKFLOW_FAILED;
-                case "waiting":
-                    if (debug) {
-                        logger.info(`Workflow paused (waiting): ${runId}`);
-                    }
-                    return EXIT_CODES.SUCCESS;
-                default:
-                    logger.warn(`Unexpected final status: ${status}`);
-                    return EXIT_CODES.SUCCESS;
-            }
+            return getFinalRunExitCode(logger, EXIT_CODES, runId, await backend.getRun(runId), debug);
         };
         // Wrapper that handles execution errors
         const safeExecute = async () => {
@@ -147,27 +95,12 @@ export async function runWorkflowJob(config) {
                 return await executeWorkflow();
             }
             catch (error) {
-                logger.error(`Execution error:`, error);
-                await backend.updateRun(runId, {
-                    status: "failed",
-                    error: {
-                        message: `EXECUTION_ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                        stack: error instanceof Error ? error.stack : undefined,
-                    },
-                    completedAt: new Date(),
-                });
-                return EXIT_CODES.WORKFLOW_FAILED;
+                return await failRunExecution(backend, logger, EXIT_CODES, runId, error);
             }
         };
         // Run with tenant context if available
         if (tenant) {
-            return await runWithRequestContext({
-                projectSlug: tenant.projectSlug,
-                token: tenant.token,
-                projectId: tenant.projectId,
-                productionMode: tenant.productionMode,
-                releaseId: tenant.releaseId,
-            }, safeExecute);
+            return await runWithTenantContext(tenant, safeExecute);
         }
         return await safeExecute();
     }

package/esm/src/workflow/worker/shared.d.ts

@@ -0,0 +1,18 @@
+import type { WorkflowBackend } from "../backends/types.js";
+import type { CapturedTenantContext, WorkflowRun } from "../types.js";
+interface EntrypointLogger {
+    error: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+}
+interface EntrypointExitCodes {
+    SUCCESS: number;
+    WORKFLOW_FAILED: number;
+}
+export declare function getTenantFromEnv(): CapturedTenantContext | undefined;
+export declare function hydrateRunContextEnv(backend: WorkflowBackend, runId: string, run: WorkflowRun): Promise<WorkflowRun>;
+export declare function getFinalRunExitCode(logger: EntrypointLogger, exitCodes: EntrypointExitCodes, runId: string, finalRun: WorkflowRun | null, debug?: boolean): number;
+export declare function failRunExecution(backend: WorkflowBackend, logger: EntrypointLogger, exitCodes: EntrypointExitCodes, runId: string, error: unknown): Promise<number>;
+export declare function runWithTenantContext<T>(tenant: CapturedTenantContext, fn: () => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/esm/src/workflow/worker/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/shared.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEtE,UAAU,gBAAgB;IACxB,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACrD,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpD,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrD;AAED,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,gBAAgB,IAAI,qBAAqB,GAAG,SAAS,CAepE;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,WAAW,CAAC,CAoBtB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,mBAAmB,EAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,WAAW,GAAG,IAAI,EAC5B,KAAK,UAAQ,GACZ,MAAM,CAsBR;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,mBAAmB,EAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,qBAAqB,EAC7B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAWZ"}

package/esm/src/workflow/worker/shared.js

@@ -0,0 +1,77 @@
+import { env as getProcessEnv } from "../../platform/compat/process.js";
+import { runWithRequestContext } from "../../platform/adapters/fs/veryfront/multi-project-adapter.js";
+import { getEnv } from "../../platform/compat/process.js";
+import { mergeInjectedWorkflowEnv } from "../../jobs/runtime-env.js";
+export function getTenantFromEnv() {
+    const projectSlug = getEnv("TENANT_PROJECT_SLUG");
+    const token = getEnv("TENANT_TOKEN");
+    if (!projectSlug || !token) {
+        return undefined;
+    }
+    return {
+        projectSlug,
+        token,
+        projectId: getEnv("TENANT_PROJECT_ID"),
+        productionMode: getEnv("TENANT_PRODUCTION_MODE") === "1",
+        releaseId: getEnv("TENANT_RELEASE_ID"),
+    };
+}
+export async function hydrateRunContextEnv(backend, runId, run) {
+    const injectedEnv = mergeInjectedWorkflowEnv(run.context.env, getProcessEnv());
+    if (!injectedEnv) {
+        return run;
+    }
+    const currentSerialized = run.context.env ? JSON.stringify(run.context.env) : "";
+    const nextSerialized = JSON.stringify(injectedEnv);
+    if (currentSerialized === nextSerialized) {
+        return run;
+    }
+    await backend.updateRun(runId, {
+        context: {
+            ...run.context,
+            env: injectedEnv,
+        },
+    });
+    return (await backend.getRun(runId)) ?? run;
+}
+export function getFinalRunExitCode(logger, exitCodes, runId, finalRun, debug = false) {
+    switch (finalRun?.status) {
+        case "completed":
+            if (debug) {
+                logger.info(`Workflow completed successfully: ${runId}`);
+            }
+            return exitCodes.SUCCESS;
+        case "failed":
+            logger.error(`Workflow failed: ${runId}`, finalRun.error);
+            return exitCodes.WORKFLOW_FAILED;
+        case "waiting":
+            if (debug) {
+                logger.info(`Workflow paused (waiting): ${runId}`);
+            }
+            return exitCodes.SUCCESS;
+        default:
+            logger.warn(`Unexpected final status: ${finalRun?.status}`);
+            return exitCodes.SUCCESS;
+    }
+}
+export async function failRunExecution(backend, logger, exitCodes, runId, error) {
+    logger.error("Execution error:", error);
+    await backend.updateRun(runId, {
+        status: "failed",
+        error: {
+            message: `EXECUTION_ERROR: ${error instanceof Error ? error.message : String(error)}`,
+            stack: error instanceof Error ? error.stack : undefined,
+        },
+        completedAt: new Date(),
+    });
+    return exitCodes.WORKFLOW_FAILED;
+}
+export function runWithTenantContext(tenant, fn) {
+    return runWithRequestContext({
+        projectSlug: tenant.projectSlug,
+        token: tenant.token,
+        projectId: tenant.projectId,
+        productionMode: tenant.productionMode,
+        releaseId: tenant.releaseId,
+    }, fn);
+}

package/package.json

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

package/src/cli/router.ts

@@ -3,6 +3,8 @@
  *
  * @module cli/router
  */
+import * as dntShim from "../_dnt.shims.js";
+
 
 import { cliErrorBoundary } from "../src/errors/index.js";
 import { cliLogger, VERSION } from "./utils/index.js";
@@ -44,7 +46,13 @@ import { parseLoginMethod } from "./auth/utils.js";
 import { showCommandHelp, showMainHelp } from "./help/index.js";
 import { setColorOverride } from "./ui/colors.js";
 import { exitProcess, setQuietMode, setVerboseMode } from "./utils/index.js";
-import { setJsonMode, setOutputPath } from "./shared/json-output.js";
+import {
+  createSuccessEnvelope,
+  isJsonMode,
+  outputJson,
+  setJsonMode,
+  setOutputPath,
+} from "./shared/json-output.js";
 import { detectCI, setNonInteractive } from "./shared/interactive.js";
 import type { ParsedArgs } from "./shared/types.js";
 
@@ -130,8 +138,33 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
 
   if (args.yes || args.y || detectCI()) setNonInteractive(true);
 
+  // Start update check early so the network request runs during command execution
+  const updateCheck = import("./shared/update-check.js")
+    .then(({ checkForUpdates }) => checkForUpdates(VERSION))
+    .catch(() => {});
+
   if (args.version || args.v) {
+    if (isJsonMode()) {
+      await outputJson(createSuccessEnvelope("version", {
+        version: VERSION,
+        deno: dntShim.Deno.version.deno,
+        v8: dntShim.Deno.version.v8,
+        typescript: dntShim.Deno.version.typescript,
+        os: dntShim.Deno.build.os,
+        arch: dntShim.Deno.build.arch,
+        standalone: dntShim.Deno.build.standalone ?? false,
+      }));
+      exitProcess(0);
+      return;
+    }
     cliLogger.info(`Veryfront CLI v${VERSION}`);
+    if (args.verbose) {
+      cliLogger.info(
+        `Deno ${dntShim.Deno.version.deno} (V8 ${dntShim.Deno.version.v8}, TypeScript ${dntShim.Deno.version.typescript})`,
+      );
+      cliLogger.info(`OS: ${dntShim.Deno.build.os} ${dntShim.Deno.build.arch}`);
+    }
+    await updateCheck;
     exitProcess(0);
     return;
   }
@@ -140,6 +173,7 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
 
   if (args.help || args.h) {
     showHelp(command);
+    await updateCheck;
     exitProcess(0);
     return;
   }
@@ -147,7 +181,6 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
   await cliErrorBoundary(async () => {
     if (command === "help") {
       showHelp();
-      exitProcess(0);
       return;
     }
 
@@ -175,4 +208,10 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
 
     await (handler ?? handleStartCommand)(args);
   });
+
+  // Wait for update check to finish (with timeout to avoid hanging)
+  await Promise.race([
+    updateCheck,
+    new Promise((r) => dntShim.setTimeout(r, 5000)),
+  ]);
 }

package/src/cli/shared/update-check.ts

@@ -0,0 +1,110 @@
+/**
+ * Non-blocking update check
+ *
+ * Checks for newer CLI versions after command execution.
+ * Cached for 24 hours. Never blocks command output.
+ *
+ * @module cli/shared/update-check
+ */
+import * as dntShim from "../../_dnt.shims.js";
+
+
+import { getEnv } from "../../src/platform/index.js";
+import { createFileSystem } from "../../src/platform/index.js";
+import { join } from "../../src/platform/compat/path/index.js";
+import { getEnvironmentConfig } from "../../src/config/index.js";
+import { isJsonMode } from "./json-output.js";
+import { isQuiet } from "../utils/index.js";
+import { detectCI } from "./interactive.js";
+
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const REGISTRY_URL = "https://jsr.io/@veryfront/veryfront/meta.json";
+const INSTALL_CMD = "deno install -gArf jsr:@veryfront/veryfront";
+
+interface UpdateCache {
+  lastCheck: number;
+  latestVersion: string | null;
+}
+
+function getCacheFile(): string | null {
+  const env = getEnvironmentConfig();
+  if (!env.homeDir) return null;
+  const cacheDir = join(env.homeDir, ".cache", "veryfront");
+  return join(cacheDir, "update-check.json");
+}
+
+export function compareVersions(current: string, latest: string): boolean {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+export function shouldSkip(): boolean {
+  if (getEnv("VERYFRONT_NO_UPDATE_CHECK") === "1") return true;
+  if (detectCI()) return true;
+  if (isJsonMode()) return true;
+  if (isQuiet()) return true;
+  return false;
+}
+
+function printUpdateNotice(current: string, latest: string): void {
+  console.error(`\n  Update available: ${current} → ${latest}`);
+  console.error(`  Run: ${INSTALL_CMD}\n`);
+}
+
+export async function checkForUpdates(
+  currentVersion: string,
+): Promise<void> {
+  if (shouldSkip()) return;
+
+  const cacheFile = getCacheFile();
+  if (!cacheFile) return;
+
+  const fs = createFileSystem();
+
+  try {
+    const raw = await fs.readTextFile(cacheFile);
+    const cache: UpdateCache = JSON.parse(raw);
+    if (Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+      if (
+        cache.latestVersion &&
+        compareVersions(currentVersion, cache.latestVersion)
+      ) {
+        printUpdateNotice(currentVersion, cache.latestVersion);
+      }
+      return;
+    }
+  } catch {
+    // No cache — proceed
+  }
+
+  try {
+    const resp = await dntShim.fetch(REGISTRY_URL);
+    if (!resp.ok) {
+      await resp.body?.cancel();
+      return;
+    }
+    const data = await resp.json();
+    const latestVersion = data.latest as string | undefined;
+    if (!latestVersion) return;
+
+    const env = getEnvironmentConfig();
+    if (!env.homeDir) return;
+    const cacheDir = join(env.homeDir, ".cache", "veryfront");
+    await fs.mkdir(cacheDir, { recursive: true });
+    await fs.writeTextFile(
+      cacheFile,
+      JSON.stringify({ lastCheck: Date.now(), latestVersion }),
+    );
+
+    if (compareVersions(currentVersion, latestVersion)) {
+      printUpdateNotice(currentVersion, latestVersion);
+    }
+  } catch {
+    // Network error — silently ignore
+  }
+}

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.128",
+  "version": "0.1.129",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [
@@ -45,18 +45,18 @@ export default {
     "./cli": "./cli/main.ts"
   },
   "imports": {
-    "veryfront/head": "./src/react/components/Head.tsx",
-    "veryfront/router": "./src/react/router/index.tsx",
-    "veryfront/context": "./src/react/context/index.tsx",
+    "veryfront/head": "./src/react/runtime/core.ts",
+    "veryfront/router": "./src/react/runtime/core.ts",
+    "veryfront/context": "./src/react/runtime/core.ts",
     "veryfront/fonts": "./src/react/fonts/index.ts",
     "veryfront/chat": "./src/chat/index.ts",
     "veryfront/markdown": "./src/markdown/index.ts",
     "veryfront/mdx": "./src/mdx/index.ts",
     "veryfront/fs": "./src/fs/index.ts",
     "veryfront/platform": "./src/platform/index.ts",
-    "veryfront/react/head": "./src/react/components/Head.tsx",
-    "veryfront/react/router": "./src/react/router/index.tsx",
-    "veryfront/react/context": "./src/react/context/index.tsx",
+    "veryfront/react/head": "./src/react/runtime/core.ts",
+    "veryfront/react/router": "./src/react/runtime/core.ts",
+    "veryfront/react/context": "./src/react/runtime/core.ts",
     "veryfront/react/fonts": "./src/react/fonts/index.ts",
     "veryfront/react/components/ai": "./src/react/components/ai/index.ts",
     "veryfront/components/ai": "./src/react/components/ai/index.ts",
@@ -351,10 +351,15 @@ export default {
     "test:bun": "node ./tests/bun/run-tests.mjs src/",
     "test:all-runtimes": "deno task test:unit && deno task test:node && deno task test:bun",
     "test:e2e": "deno task test:e2e:playwright",
-    "test:e2e:playwright": "npx playwright test --config=tests/e2e/playwright.config.ts",
+    "test:e2e:playwright": "PW_DISABLE_TS_ESM=1 npx playwright test --config=tests/e2e/playwright.config.cjs",
     "test:e2e:rsc-browser": "deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --no-check --allow-all tests/e2e/regressions/rsc-proxy-hydration.test.ts --unstable-worker-options --unstable-net",
     "test:e2e:binary": "deno task generate && deno test --allow-all tests/integration/compiled-binary-e2e.test.ts",
     "test:e2e:binary:fresh": "deno task generate && VERYFRONT_BINARY_FRESH=1 deno test --allow-all tests/integration/compiled-binary-e2e.test.ts",
+    "bench:browser": "deno run -A benchmarks/browser/run.ts",
+    "bench:server": "deno run -A benchmarks/server/run.ts",
+    "bench:compare:local": "deno run -A benchmarks/compare/local.ts",
+    "perf:bench": "deno run -A benchmarks/perf-bench.ts",
+    "perf:loop": "deno run -A benchmarks/perf-loop.ts",
     "check:circular": "deno run -A jsr:@cunarist/deno-circular-deps src/index.ts",
     "cli": "deno run --allow-all cli/main.ts",
     "mcp": "deno run --allow-all cli/main.ts mcp",

package/src/src/channels/control-plane.ts

@@ -101,6 +101,10 @@ function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
   return buffer;
 }
 
+function parseCompactJwsPart<T>(encodedPart: string): T {
+  return JSON.parse(new TextDecoder().decode(base64urlDecodeToBytes(encodedPart))) as T;
+}
+
 function pemToDer(pem: string, label: string): ArrayBuffer {
   const body = pem
     .replace(`-----BEGIN ${label}-----`, "")
@@ -155,16 +159,8 @@ async function verifySignedRequestJws<TClaims extends SignedRequestClaims>(
     throw new Error("Control-plane signature must include header, payload, and signature");
   }
 
-  const header = compactJwsHeaderSchema.parse(
-    JSON.parse(new TextDecoder().decode(base64urlDecodeToBytes(encodedHeader))),
-  );
-  const claims = options.claimsSchema.parse(
-    JSON.parse(new TextDecoder().decode(base64urlDecodeToBytes(encodedPayload))),
-  );
-
-  if (header.alg !== "EdDSA") {
-    throw new Error("Unsupported control-plane JWS algorithm");
-  }
+  compactJwsHeaderSchema.parse(parseCompactJwsPart(encodedHeader));
+  const claims = options.claimsSchema.parse(parseCompactJwsPart(encodedPayload));
 
   const signingInput = new TextEncoder().encode(`${encodedHeader}.${encodedPayload}`);
   const signature = base64urlDecodeToBytes(encodedSignature);