@valbuild/server 0.60.20 → 0.60.22

package/dist/valbuild-server.cjs.prod.js

@@ -15,7 +15,6 @@ var z = require('zod');
 var internal = require('@valbuild/shared/internal');
 var sizeOf = require('image-size');
 var crypto = require('crypto');
-var minimatch = require('minimatch');
 var server = require('@valbuild/ui/server');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
@@ -44,7 +43,6 @@ var fs__default = /*#__PURE__*/_interopDefault(fs);
 var z__default = /*#__PURE__*/_interopDefault(z);
 var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var minimatch__default = /*#__PURE__*/_interopDefault(minimatch);
 
 class ValSyntaxError {
   constructor(message, node) {
@@ -693,7 +691,7 @@ const patchSourceFile = (sourceFile, patch$1) => {
   return patch.applyPatch(sourceFile, ops$1, patch$1);
 };
 
-const readValFile = async (id, valConfigPath, runtime, options) => {
+const readValFile = async (id, rootDirPath, runtime, options) => {
   const context = runtime.newContext();
 
   // avoid failures when console.log is called
@@ -745,7 +743,7 @@ globalThis.valModule = {
 `;
     const result = context.evalCode(code,
     // Synthetic module name
-    path__namespace["default"].join(path__namespace["default"].dirname(valConfigPath), "<val>"));
+    path__namespace["default"].join(rootDirPath, "<val>"));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -1190,18 +1188,16 @@ async function createService(projectRoot, opts, host = {
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
   const module = await quickjsEmscripten.newQuickJSWASMModule();
   const runtime = await newValQuickJSRuntime(module, loader || new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host, opts.disableCache === undefined ? true : opts.disableCache));
-  return new Service(opts, sourceFileHandler, runtime);
+  return new Service(projectRoot, sourceFileHandler, runtime);
 }
 class Service {
-  constructor({
-    valConfigPath
-  }, sourceFileHandler, runtime) {
+  constructor(projectRoot, sourceFileHandler, runtime) {
     this.sourceFileHandler = sourceFileHandler;
     this.runtime = runtime;
-    this.valConfigPath = valConfigPath || "./val.config";
+    this.projectRoot = projectRoot;
   }
   async get(moduleId, modulePath, options) {
-    const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime, options ?? {
+    const valModule = await readValFile(moduleId, this.projectRoot, this.runtime, options ?? {
       validate: true,
       source: true,
       schema: true
@@ -1225,7 +1221,7 @@ class Service {
     }
   }
   async patch(moduleId, patch) {
-    await patchValFile(moduleId, this.valConfigPath, patch, this.sourceFileHandler, this.runtime);
+    await patchValFile(moduleId, this.projectRoot, patch, this.sourceFileHandler, this.runtime);
   }
   dispose() {
     this.runtime.dispose();
@@ -1416,9 +1412,8 @@ function getValidationErrorMetadata(validationError) {
 
 const ops = new patch.JSONOps();
 class ValServer {
-  constructor(cwd, host, options, callbacks) {
+  constructor(cwd, options, callbacks) {
     this.cwd = cwd;
-    this.host = host;
     this.options = options;
     this.callbacks = callbacks;
   }
@@ -1454,19 +1449,10 @@ class ValServer {
       redirectTo: redirectToRes
     };
   }
-  getAllModules(treePath) {
-    const moduleIds = this.host.readDirectory(this.cwd, ["ts", "js"], ["node_modules", ".*"], ["**/*.val.ts", "**/*.val.js"]).filter(file => {
-      if (treePath) {
-        return file.replace(this.cwd, "").startsWith(treePath);
-      }
-      return true;
-    }).map(file => file.replace(this.cwd, "").replace(".val.js", "").replace(".val.ts", "").split(path__namespace["default"].sep).join("/"));
-    return moduleIds;
-  }
   async getTree(treePath,
   // TODO: use the params: patch, schema, source now we return everything, every time
   query, cookies, requestHeaders) {
-    const ensureRes = await this.ensureRemoteFSInitialized("getTree", cookies);
+    const ensureRes = await this.ensureInitialized("getTree", cookies);
     if (fp.result.isErr(ensureRes)) {
       return ensureRes.error;
     }
@@ -1474,7 +1460,7 @@ class ValServer {
     const execValidations = query.validate === "true";
     const includeSource = query.source === "true";
     const includeSchema = query.schema === "true";
-    const moduleIds = this.getAllModules(treePath);
+    const moduleIds = await this.getAllModules(treePath);
     let {
       patchIdsByModuleId,
       patchesById,
@@ -1514,14 +1500,14 @@ class ValServer {
     };
   }
   async postValidate(rawBody, cookies, requestHeaders) {
-    const ensureRes = await this.ensureRemoteFSInitialized("postValidate", cookies);
+    const ensureRes = await this.ensureInitialized("postValidate", cookies);
     if (fp.result.isErr(ensureRes)) {
       return ensureRes.error;
     }
     return this.validateThenMaybeCommit(rawBody, false, cookies, requestHeaders);
   }
   async postCommit(rawBody, cookies, requestHeaders) {
-    const ensureRes = await this.ensureRemoteFSInitialized("postCommit", cookies);
+    const ensureRes = await this.ensureInitialized("postCommit", cookies);
     if (fp.result.isErr(ensureRes)) {
       return ensureRes.error;
     }
@@ -1547,7 +1533,6 @@ class ValServer {
   }
 
   /* */
-
   async applyAllPatchesThenValidate(moduleId, patchIdsByModuleId, patchesById, fileUpdates, cookies, requestHeaders, applyPatches, validate, includeSource, includeSchema) {
     const serializedModuleContent = await this.getModule(moduleId, {
       validate: validate,
@@ -1812,7 +1797,7 @@ class ValServer {
       fileUpdates
     } = res.value;
     const validationErrorsByModuleId = {};
-    for (const moduleIdStr of this.getAllModules("/")) {
+    for (const moduleIdStr of await this.getAllModules("/")) {
       const moduleId = moduleIdStr;
       const serializedModuleContent = await this.applyAllPatchesThenValidate(moduleId, filterPatchesByModuleIdRes.data.patches ||
       // TODO: refine to ModuleId and PatchId when parsing
@@ -2055,10 +2040,11 @@ class LocalValServer extends ValServer {
   static PATCHES_DIR = "patches";
   static FILES_DIR = "files";
   constructor(options, callbacks) {
-    super(options.service.sourceFileHandler.projectRoot, options.service.sourceFileHandler.host, options, callbacks);
+    super(options.service.sourceFileHandler.projectRoot, options, callbacks);
     this.options = options;
     this.callbacks = callbacks;
     this.patchesRootPath = options.cacheDir || path__namespace["default"].join(options.service.sourceFileHandler.projectRoot, ".val");
+    this.host = this.options.service.sourceFileHandler.host;
   }
   async session() {
     return {
@@ -2316,13 +2302,22 @@ class LocalValServer extends ValServer {
       }
     };
   }
-  async ensureRemoteFSInitialized() {
+  async ensureInitialized() {
     // No RemoteFS so nothing to ensure
     return fp.result.ok(undefined);
   }
   getModule(moduleId, options) {
     return this.options.service.get(moduleId, "", options);
   }
+  async getAllModules(treePath) {
+    const moduleIds = this.host.readDirectory(this.cwd, ["ts", "js"], ["node_modules", ".*"], ["**/*.val.ts", "**/*.val.js"]).filter(file => {
+      if (treePath) {
+        return file.replace(this.cwd, "").startsWith(treePath);
+      }
+      return true;
+    }).map(file => file.replace(this.cwd, "").replace(".val.js", "").replace(".val.ts", "").split(path__namespace["default"].sep).join("/"));
+    return moduleIds;
+  }
   async execCommit(patches) {
     for (const [patchId, moduleId, patch] of patches) {
       // TODO: patch the entire module content directly by using a { path: "", op: "replace", value: patchedData }?
@@ -2409,219 +2404,32 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto__default["default"].createHmac("sha256", sessionKey).update(`${jwtHeaderBase64}.${payloadBase64}`).digest("base64")}`;
 }
 
-const SEPARATOR = "/";
-class RemoteFS {
-  initialized = false;
-  constructor() {
-    this.data = {};
-    this.modifiedFiles = [];
-    this.deletedFiles = [];
-  }
-  useCaseSensitiveFileNames = true;
-  isInitialized() {
-    return this.initialized;
-  }
-  async initializeWith(data) {
-    this.data = data;
-    this.initialized = true;
-  }
-  async getPendingOperations() {
-    const modified = {};
-    for (const modifiedFile of this.modifiedFiles) {
-      const {
-        directory,
-        filename
-      } = RemoteFS.parsePath(modifiedFile);
-      modified[modifiedFile] = this.data[directory].utf8Files[filename];
-    }
-    return {
-      modified: modified,
-      deleted: this.deletedFiles
-    };
-  }
-  changedDirectories = {};
-  readDirectory = (rootDir, extensions, excludes, includes, depth) => {
-    // TODO: rewrite this! And make some tests! This is a mess!
-    // Considered using glob which typescript seems to use, but that works on an entire typeof fs
-    // glob uses minimatch internally, so using that instead
-    const files = [];
-    for (const dir in this.data) {
-      const depthExceeded = depth ? dir.replace(rootDir, "").split(SEPARATOR).length > depth : false;
-      if (dir.startsWith(rootDir) && !depthExceeded) {
-        for (const file in this.data[dir].utf8Files) {
-          for (const extension of extensions) {
-            if (file.endsWith(extension)) {
-              const path = `${dir}/${file}`;
-              for (const include of includes ?? []) {
-                // TODO: should default includes be ['**/*']?
-                if (minimatch__default["default"](path, include)) {
-                  let isExcluded = false;
-                  for (const exlude of excludes ?? []) {
-                    if (minimatch__default["default"](path, exlude)) {
-                      isExcluded = true;
-                      break;
-                    }
-                  }
-                  if (!isExcluded) {
-                    files.push(path);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return ts__default["default"].sys.readDirectory(rootDir, extensions, excludes, includes, depth).concat(files);
-  };
-  writeFile = (filePath, data, encoding) => {
-    // never write real fs
-    const {
-      directory,
-      filename
-    } = RemoteFS.parsePath(filePath);
-    if (this.data[directory] === undefined) {
-      throw new Error(`Directory not found: ${directory}`);
-    }
-    this.changedDirectories[directory] = this.changedDirectories[directory] ?? new Set();
-
-    // if it fails below this should not be added, so maybe a try/catch?
-    this.changedDirectories[directory].add(filename);
-    this.data[directory].utf8Files[filename] = data;
-    this.modifiedFiles.push(filePath);
-  };
-  rmFile(filePath) {
-    // never remove from real fs
-    const {
-      directory,
-      filename
-    } = RemoteFS.parsePath(filePath);
-    if (this.data[directory] === undefined) {
-      throw new Error(`Directory not found: ${directory}`);
-    }
-    this.changedDirectories[directory] = this.changedDirectories[directory] ?? new Set();
-
-    // if it fails below this should not be added, so maybe a try/catch?
-    this.changedDirectories[directory].add(filename);
-    delete this.data[directory].utf8Files[filename];
-    delete this.data[directory].symlinks[filename];
-    this.deletedFiles.push(filePath);
-  }
-  fileExists = filePath => {
-    var _this$data$directory;
-    if (ts__default["default"].sys.fileExists(filePath)) {
-      return true;
-    }
-    const {
-      directory,
-      filename
-    } = RemoteFS.parsePath(this.realpath(filePath) // ts.sys seems to resolve symlinks while calling fileExists, i.e. a broken symlink (pointing to a non-existing file) is not considered to exist
-    );
-    return !!((_this$data$directory = this.data[directory]) !== null && _this$data$directory !== void 0 && _this$data$directory.utf8Files[filename]);
-  };
-  readFile = filePath => {
-    const realFile = ts__default["default"].sys.readFile(filePath);
-    if (realFile !== undefined) {
-      return realFile;
-    }
-    const {
-      directory,
-      filename
-    } = RemoteFS.parsePath(filePath);
-    const dirNode = this.data[directory];
-    if (!dirNode) {
-      return undefined;
-    }
-    const content = dirNode.utf8Files[filename];
-    return content;
-  };
-  realpath(fullPath) {
-    if (ts__default["default"].sys.fileExists(fullPath) && ts__default["default"].sys.realpath) {
-      return ts__default["default"].sys.realpath(fullPath);
-    }
-    // TODO: this only works in a very limited way.
-    // It does not support symlinks to symlinks nor symlinked directories for instance.
-    const {
-      directory,
-      filename
-    } = RemoteFS.parsePath(fullPath);
-    if (this.data[directory] === undefined) {
-      return fullPath;
-    }
-    if (this.data[directory].utf8Files[filename] === undefined) {
-      const link = this.data[directory].symlinks[filename];
-      if (link === undefined) {
-        return fullPath;
-      } else {
-        return link;
-      }
-    } else {
-      return path__namespace["default"].join(directory, filename);
-    }
-  }
-
-  /**
-   *
-   * @param path
-   * @returns directory and filename. NOTE: directory might be empty string
-   */
-  static parsePath(path) {
-    const pathParts = path.split(SEPARATOR);
-    const filename = pathParts.pop();
-    if (!filename) {
-      throw new Error(`Invalid path: '${path}'. Node filename: '${filename}'`);
-    }
-    const directory = pathParts.join(SEPARATOR);
-    return {
-      directory,
-      filename
-    };
-  }
-}
-
-/**
- * Represents directories
- * NOTE: the keys of directory nodes are the "full" path, i.e. "foo/bar"
- * NOTE: the keys of file nodes are the "filename" only, i.e. "baz.txt"
- *
- * @example
- * {
- *  "foo/bar": { // <- directory. NOTE: this is the "full" path
- *     gitHubSha: "123",
- *     files: {
- *       "baz.txt": "hello world" // <- file. NOTE: this is the "filename" only
- *     },
- *   },
- * };
- */
-// TODO: a Map would be better here
-
 class ProxyValServer extends ValServer {
-  moduleCache = {};
+  moduleCache = null;
   constructor(cwd, options, apiOptions, callbacks) {
-    const remoteFS = new RemoteFS();
-    super(cwd, remoteFS, options, callbacks);
+    super(cwd, options, callbacks);
     this.cwd = cwd;
     this.options = options;
     this.apiOptions = apiOptions;
     this.callbacks = callbacks;
-    this.remoteFS = remoteFS;
+    this.moduleCache = null;
   }
 
   /** Remote FS dependent methods: */
 
-  async getModule(moduleId, options) {
-    const cacheKey = moduleId + ";" + JSON.stringify(options) + this.options.git.commit + this.cwd;
-    const cachedModule = this.moduleCache[cacheKey];
-    if (cachedModule) {
-      return Promise.resolve(cachedModule);
+  async getModule(moduleId,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _options) {
+    if (this.moduleCache) {
+      return this.moduleCache[moduleId];
     }
-    if (!this.lazyService) {
-      this.lazyService = await createService(this.cwd, this.apiOptions, this.remoteFS);
+    throw new Error("Module cache not initialized");
+  }
+  async getAllModules(treePath) {
+    if (!this.moduleCache) {
+      throw new Error("Module cache not initialized");
     }
-    const currentModule = await this.lazyService.get(moduleId, "", options);
-    this.moduleCache[cacheKey] = currentModule;
-    return currentModule;
+    return Object.keys(this.moduleCache).filter(moduleId => moduleId.startsWith(treePath));
   }
   execCommit(patches, cookies) {
     return withAuth(this.options.valSecret, cookies, "execCommit", async ({
@@ -2636,46 +2444,19 @@ class ProxyValServer extends ValServer {
           }
         };
       }
-      const params = `commit=${encodeURIComponent(commit)}&root=${encodeURIComponent(this.apiOptions.root || "/")}&cwd=${encodeURIComponent(this.cwd)}`;
+      const params = createParams({
+        root: this.apiOptions.root,
+        commit,
+        ext: ["ts", "js", "json"],
+        package: ["@valbuild/core@" + this.options.versions.core, "@valbuild/next@" + this.options.versions.next],
+        include: ["**/*.val.{js,ts},package.json,tsconfig.json,jsconfig.json"]
+      });
       const url = new URL(`/v1/commit/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
-
-      // Creates a fresh copy of the fs. We cannot touch the existing fs, since there might be parallel operations?
-      // We could perhaps free up the other fs while doing this operation, but uncertain if we can actually do that and if that would actually help on memory.
-      // It is a concern we have, since we might be using quite a lot of memory when having the whole FS in memory.
-      // NOTE that base64 values from patches are not part of the patches, nor are they part of the fs so at least we do not have to worry about them.
-      // This NOTE was written after we wrote the comments above. We are a bit uncertain whether memory usage should be a concern at this point.
-      const remoteFS = new RemoteFS();
-      const initRes = await this.initRemoteFS(commit, remoteFS, token);
-      if (initRes.status !== 200) {
-        return initRes;
-      }
-      const service = await createService(this.cwd, this.apiOptions, remoteFS);
-      // TODO: optimize patches, e.g. only take the last replace for a given thing, etc...
-      const patchIds = [];
-      const binaryFileUpdates = {};
-      for (const [patchId, moduleId, patch] of patches) {
-        const patchableOps = [];
-        for (const op of patch) {
-          if (isCachedPatchFileOp(op)) {
-            binaryFileUpdates[op.filePath] = op.value;
-          } else {
-            if (core.Internal.isFileOp(op)) {
-              throw new Error(`Val: Unexpected file operation (file: ${op.filePath}). This is likely a Val bug.`);
-            }
-            patchableOps.push(op);
-          }
-        }
-        await service.patch(moduleId, patchableOps);
-        patchIds.push(patchId);
-      }
-      const sourceFileUpdates = await remoteFS.getPendingOperations();
+      const patchIds = patches.map(([patchId]) => patchId);
       const fetchRes = await fetch(url, {
         method: "POST",
         headers: getAuthHeaders(token, "application/json"),
         body: JSON.stringify({
-          sourceFileUpdates: sourceFileUpdates.modified,
-          binaryFileUpdates,
-          deletedFiles: sourceFileUpdates.deleted,
           patchIds
         })
       });
@@ -2689,14 +2470,15 @@ class ProxyValServer extends ValServer {
       }
     });
   }
-  async initRemoteFS(commit, remoteFS, token) {
-    const params = new URLSearchParams(this.apiOptions.root ? {
+  async init(commit, token) {
+    const params = createParams({
       root: this.apiOptions.root,
-      commit
-    } : {
-      commit
+      commit,
+      ext: ["ts", "js", "json"],
+      package: ["@valbuild/core@" + this.options.versions.core, "@valbuild/next@" + this.options.versions.next],
+      include: ["**/*.val.{js,ts},package.json,tsconfig.json,jsconfig.json"]
     });
-    const url = new URL(`/v1/fs/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
+    const url = new URL(`/v1/eval/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
     try {
       const fetchRes = await fetch(url, {
         headers: getAuthHeaders(token, "application/json")
@@ -2719,22 +2501,22 @@ class ProxyValServer extends ValServer {
             details: "Invalid response: missing git.commit"
           };
         }
-        if (typeof json.directories !== "object" || json.directories === null) {
+        if (typeof json.modules !== "object" || json.modules === null) {
           error = {
-            details: "Invalid response: missing directories"
+            details: "Invalid response: missing modules"
           };
         }
         if (error) {
+          console.error("Could not initialize remote modules", error);
           return {
             status: 500,
             json: {
-              message: "Failed to fetch remote files",
+              message: "Failed to fetch remote modules",
               ...error
             }
           };
         }
-        remoteFS.initializeWith(Object.fromEntries(Object.entries(json.directories).map(([dir, content]) => [path__namespace["default"].join(this.cwd, ...dir.split("/") // content is always posix - not sure that matters...
-        ), content])));
+        this.moduleCache = json.modules;
         return {
           status: 200
         };
@@ -2750,7 +2532,7 @@ class ProxyValServer extends ValServer {
       };
     }
   }
-  async ensureRemoteFSInitialized(errorMessageType, cookies) {
+  async ensureInitialized(errorMessageType, cookies) {
     const commit = this.options.git.commit;
     if (!commit) {
       return fp.result.err({
@@ -2761,8 +2543,8 @@ class ProxyValServer extends ValServer {
       });
     }
     const res = await withAuth(this.options.valSecret, cookies, errorMessageType, async data => {
-      if (!this.remoteFS.isInitialized()) {
-        return this.initRemoteFS(commit, this.remoteFS, data.token);
+      if (!this.moduleCache) {
+        return this.init(commit, data.token);
       } else {
         return {
           status: 200
@@ -3083,11 +2865,33 @@ class ProxyValServer extends ValServer {
           };
         }
         const host = `${reqHeaders["x-forwarded-proto"]}://${reqHeaders["host"]}`;
-        const fileUrl = filePath.slice("/public".length);
-        return {
-          status: 302,
-          redirectTo: new URL(fileUrl, host).toString()
-        };
+        const staticPublicUrl = new URL(filePath.slice("/public".length), host).toString();
+        const fetchRes = await fetch(staticPublicUrl, {
+          headers: getAuthHeaders(data.token)
+        });
+        if (fetchRes.status === 200) {
+          // TODO: does this stream data?
+          if (fetchRes.body) {
+            return {
+              status: fetchRes.status,
+              headers: {
+                "Content-Type": fetchRes.headers.get("Content-Type") || "",
+                "Content-Length": fetchRes.headers.get("Content-Length") || "0",
+                "Cache-Control": "public, max-age=31536000, immutable"
+              },
+              body: fetchRes.body
+            };
+          } else {
+            return {
+              status: 500,
+              json: {
+                message: "No body in response"
+              }
+            };
+          }
+        } else {
+          throw new Error("Failed to fetch file: " + filePath);
+        }
       }
     });
   }
@@ -3279,6 +3083,25 @@ function getAuthHeaders(token, type) {
     Authorization: `Bearer ${token}`
   };
 }
+function createParams(params) {
+  let paramIdx = 0;
+  let paramsString = "";
+  for (const key in params) {
+    const param = params[key];
+    if (Array.isArray(param)) {
+      for (const value of param) {
+        paramsString += `${key}=${encodeURIComponent(value)}&`;
+      }
+    } else if (param) {
+      paramsString += `${key}=${encodeURIComponent(param)}`;
+    }
+    if (paramIdx < Object.keys(params).length - 1) {
+      paramsString += "&";
+    }
+    paramIdx++;
+  }
+  return paramsString;
+}
 
 async function createValServer(route, opts, callbacks) {
   const serverOpts = await initHandlerOptions(route, opts);
@@ -3294,6 +3117,7 @@ async function initHandlerOptions(route, opts) {
   const maybeValSecret = opts.valSecret || process.env.VAL_SECRET;
   const isProxyMode = opts.mode === "proxy" || opts.mode === undefined && (maybeApiKey || maybeValSecret);
   if (isProxyMode) {
+    var _opts$versions, _opts$versions2;
     const valBuildUrl = opts.valBuildUrl || process.env.VAL_BUILD_URL || "https://app.val.build";
     if (!maybeApiKey || !maybeValSecret) {
       throw new Error("VAL_API_KEY and VAL_SECRET env vars must both be set in proxy mode");
@@ -3311,6 +3135,14 @@ async function initHandlerOptions(route, opts) {
     if (!maybeValRemote) {
       throw new Error("Proxy mode does not work unless the 'remote' option in val.config is defined or the VAL_REMOTE env var is set.");
     }
+    const coreVersion = (_opts$versions = opts.versions) === null || _opts$versions === void 0 ? void 0 : _opts$versions.core;
+    if (!coreVersion) {
+      throw new Error("Could not determine version of @valbuild/core");
+    }
+    const nextVersion = (_opts$versions2 = opts.versions) === null || _opts$versions2 === void 0 ? void 0 : _opts$versions2.next;
+    if (!nextVersion) {
+      throw new Error("Could not determine version of @valbuild/next");
+    }
     return {
       mode: "proxy",
       route,
@@ -3318,6 +3150,10 @@ async function initHandlerOptions(route, opts) {
       valSecret: maybeValSecret,
       valBuildUrl,
       valContentUrl,
+      versions: {
+        core: coreVersion,
+        next: nextVersion
+      },
       git: {
         commit: maybeGitCommit,
         branch: maybeGitBranch