@valbuild/server 0.60.21 → 0.60.23

package/dist/valbuild-server.esm.js

@@ -12,7 +12,6 @@ import z, { z as z$1 } from 'zod';
 import { MIME_TYPES_TO_EXT, filenameToMimeType, VAL_ENABLE_COOKIE_NAME, VAL_STATE_COOKIE as VAL_STATE_COOKIE$1, VAL_SESSION_COOKIE as VAL_SESSION_COOKIE$1 } from '@valbuild/shared/internal';
 import sizeOf from 'image-size';
 import crypto from 'crypto';
-import minimatch from 'minimatch';
 import { createUIRequestHandler } from '@valbuild/ui/server';
 
 class ValSyntaxError {
@@ -662,7 +661,7 @@ const patchSourceFile = (sourceFile, patch) => {
   return applyPatch(sourceFile, ops$1, patch);
 };
 
-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
@@ -714,7 +713,7 @@ globalThis.valModule = {
 `;
     const result = context.evalCode(code,
     // Synthetic module name
-    path__default.join(path__default.dirname(valConfigPath), "<val>"));
+    path__default.join(rootDirPath, "<val>"));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -1159,18 +1158,16 @@ async function createService(projectRoot, opts, host = {
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
   const module = await newQuickJSWASMModule();
   const runtime = await newValQuickJSRuntime(module, loader || new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host, opts.disableCache === undefined ? process.env.NODE_ENV === "development" ? false : 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
@@ -1194,7 +1191,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();
@@ -1385,9 +1382,8 @@ function getValidationErrorMetadata(validationError) {
 
 const ops = new JSONOps();
 class ValServer {
-  constructor(cwd, host, options, callbacks) {
+  constructor(cwd, options, callbacks) {
     this.cwd = cwd;
-    this.host = host;
     this.options = options;
     this.callbacks = callbacks;
   }
@@ -1423,19 +1419,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__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 debugTiming("ensureInitialized", () => this.ensureInitialized("getTree", cookies));
     if (result.isErr(ensureRes)) {
       return ensureRes.error;
     }
@@ -1443,7 +1430,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 debugTiming("getAllModules", () => this.getAllModules(treePath));
     let {
       patchIdsByModuleId,
       patchesById,
@@ -1454,7 +1441,7 @@ class ValServer {
       fileUpdates: {}
     };
     if (applyPatches) {
-      const res = await this.readPatches(cookies);
+      const res = await debugTiming("readPatches", () => this.readPatches(cookies));
       if (result.isErr(res)) {
         return res.error;
       }
@@ -1462,9 +1449,9 @@ class ValServer {
       patchesById = res.value.patchesById;
       fileUpdates = res.value.fileUpdates;
     }
-    const possiblyPatchedContent = await Promise.all(moduleIds.map(async moduleId => {
+    const possiblyPatchedContent = await debugTiming("applyAllPatchesThenValidate", () => Promise.all(moduleIds.map(async moduleId => {
       return this.applyAllPatchesThenValidate(moduleId, patchIdsByModuleId, patchesById, fileUpdates, cookies, requestHeaders, applyPatches, execValidations, includeSource, includeSchema);
-    }));
+    })));
     const modules = Object.fromEntries(possiblyPatchedContent.map(serializedModuleContent => {
       const module = {
         schema: serializedModuleContent.schema,
@@ -1483,14 +1470,14 @@ class ValServer {
     };
   }
   async postValidate(rawBody, cookies, requestHeaders) {
-    const ensureRes = await this.ensureRemoteFSInitialized("postValidate", cookies);
+    const ensureRes = await this.ensureInitialized("postValidate", cookies);
     if (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 (result.isErr(ensureRes)) {
       return ensureRes.error;
     }
@@ -1516,7 +1503,6 @@ class ValServer {
   }
 
   /* */
-
   async applyAllPatchesThenValidate(moduleId, patchIdsByModuleId, patchesById, fileUpdates, cookies, requestHeaders, applyPatches, validate, includeSource, includeSchema) {
     const serializedModuleContent = await this.getModule(moduleId, {
       validate: validate,
@@ -1535,38 +1521,40 @@ class ValServer {
       return serializedModuleContent;
     }
     let source = maybeSource;
-    for (const patchId of patchIdsByModuleId[moduleId] ?? []) {
-      const patch = patchesById[patchId];
-      if (!patch) {
-        continue;
-      }
-      const patchRes = applyPatch(source, ops, patch.filter(Internal.notFileOp));
-      if (result.isOk(patchRes)) {
-        source = patchRes.value;
-      } else {
-        console.error("Val: got an unexpected error while applying patch. Is there a mismatch in Val versions? Perhaps Val is misconfigured?", {
-          patchId,
-          moduleId,
-          patch: JSON.stringify(patch, null, 2),
-          error: patchRes.error
-        });
-        return {
-          path: moduleId,
-          schema,
-          source,
-          errors: {
-            fatal: [{
-              message: "Unexpected error applying patch",
-              type: "invalid-patch"
-            }]
-          }
-        };
+    await debugTiming("applyPatches:" + moduleId, async () => {
+      for (const patchId of patchIdsByModuleId[moduleId] ?? []) {
+        const patch = patchesById[patchId];
+        if (!patch) {
+          continue;
+        }
+        const patchRes = applyPatch(source, ops, patch.filter(Internal.notFileOp));
+        if (result.isOk(patchRes)) {
+          source = patchRes.value;
+        } else {
+          console.error("Val: got an unexpected error while applying patch. Is there a mismatch in Val versions? Perhaps Val is misconfigured?", {
+            patchId,
+            moduleId,
+            patch: JSON.stringify(patch, null, 2),
+            error: patchRes.error
+          });
+          return {
+            path: moduleId,
+            schema,
+            source,
+            errors: {
+              fatal: [{
+                message: "Unexpected error applying patch",
+                type: "invalid-patch"
+              }]
+            }
+          };
+        }
       }
-    }
+    });
     if (validate) {
-      const validationErrors = deserializeSchema(schema).validate(moduleId, source);
+      const validationErrors = await debugTiming("validate:" + moduleId, async () => deserializeSchema(schema).validate(moduleId, source));
       if (validationErrors) {
-        const revalidated = await this.revalidateImageAndFileValidation(validationErrors, fileUpdates, cookies, requestHeaders);
+        const revalidated = await debugTiming("revalidate image/file:" + moduleId, async () => this.revalidateImageAndFileValidation(validationErrors, fileUpdates, cookies, requestHeaders));
         return {
           path: moduleId,
           schema,
@@ -1781,7 +1769,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
@@ -2018,16 +2006,27 @@ function guessMimeTypeFromPath(filePath) {
 function isCachedPatchFileOp(op) {
   return !!(op.op === "file" && typeof op.filePath === "string" && op.value && typeof op.value === "object" && !Array.isArray(op.value) && "sha256" in op.value && typeof op.value.sha256 === "string");
 }
+async function debugTiming(id, fn) {
+  if (process.env["VAL_DEBUG_TIMING"] === "true") {
+    const start = Date.now();
+    const r = await fn();
+    console.log(`Timing: ${id} took: ${Date.now() - start}ms (${new Date().toISOString()})`);
+    return r;
+  } else {
+    return fn();
+  }
+}
 
 const textEncoder = new TextEncoder();
 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__default.join(options.service.sourceFileHandler.projectRoot, ".val");
+    this.host = this.options.service.sourceFileHandler.host;
   }
   async session() {
     return {
@@ -2285,13 +2284,22 @@ class LocalValServer extends ValServer {
       }
     };
   }
-  async ensureRemoteFSInitialized() {
+  async ensureInitialized() {
     // No RemoteFS so nothing to ensure
     return 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__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 }?
@@ -2378,219 +2386,32 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto.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(path, include)) {
-                  let isExcluded = false;
-                  for (const exlude of excludes ?? []) {
-                    if (minimatch(path, exlude)) {
-                      isExcluded = true;
-                      break;
-                    }
-                  }
-                  if (!isExcluded) {
-                    files.push(path);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return ts.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.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.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.sys.fileExists(fullPath) && ts.sys.realpath) {
-      return ts.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__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 ({
@@ -2605,46 +2426,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 (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
         })
       });
@@ -2658,14 +2452,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")
@@ -2688,22 +2483,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__default.join(this.cwd, ...dir.split("/") // content is always posix - not sure that matters...
-        ), content])));
+        this.moduleCache = json.modules;
         return {
           status: 200
         };
@@ -2719,7 +2514,7 @@ class ProxyValServer extends ValServer {
       };
     }
   }
-  async ensureRemoteFSInitialized(errorMessageType, cookies) {
+  async ensureInitialized(errorMessageType, cookies) {
     const commit = this.options.git.commit;
     if (!commit) {
       return result.err({
@@ -2730,8 +2525,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
@@ -3011,54 +2806,51 @@ class ProxyValServer extends ValServer {
       }
     });
   }
-  async getFiles(filePath, query, cookies, reqHeaders) {
-    return withAuth(this.options.valSecret, cookies, "getFiles", async data => {
-      const url = new URL(`/v1/files/${this.options.remote}${filePath}`, this.options.valContentUrl);
-      if (typeof query.sha256 === "string") {
-        url.searchParams.append("sha256", query.sha256);
+  async getFiles(filePath, query, _cookies, reqHeaders) {
+    const url = new URL(`/v1/files/${this.options.remote}${filePath}`, this.options.valContentUrl);
+    if (typeof query.sha256 === "string") {
+      url.searchParams.append("sha256", query.sha256);
+    }
+    const fetchRes = await fetch(url);
+    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": fetchRes.headers.get("Cache-Control") || ""
+          },
+          body: fetchRes.body
+        };
       } else {
-        console.warn("Missing sha256 query param");
+        return {
+          status: 500,
+          json: {
+            message: "No body in response"
+          }
+        };
       }
-      const fetchRes = await fetch(url, {
-        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 {
-        if (!(reqHeaders.host && reqHeaders["x-forwarded-proto"])) {
-          return {
-            status: 500,
-            json: {
-              message: "Missing host or x-forwarded-proto header"
-            }
-          };
-        }
-        const host = `${reqHeaders["x-forwarded-proto"]}://${reqHeaders["host"]}`;
-        const fileUrl = filePath.slice("/public".length);
+    } else {
+      if (!(reqHeaders.host && reqHeaders["x-forwarded-proto"])) {
         return {
-          status: 302,
-          redirectTo: new URL(fileUrl, host).toString()
+          status: 500,
+          json: {
+            message: "Missing host or x-forwarded-proto header"
+          }
         };
       }
-    });
+      const host = `${reqHeaders["x-forwarded-proto"]}://${reqHeaders["host"]}`;
+      const staticPublicUrl = new URL(filePath.slice("/public".length), host).toString();
+      const fetchRes = await fetch(staticPublicUrl);
+      return {
+        status: fetchRes.status,
+        // forward headers from static public url
+        headers: Object.fromEntries(fetchRes.headers.entries()),
+        body: fetchRes.body
+      };
+    }
   }
 }
 function verifyCallbackReq(stateCookie, queryParams) {
@@ -3248,6 +3040,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);
@@ -3263,6 +3074,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");
@@ -3280,6 +3092,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,
@@ -3287,6 +3107,10 @@ async function initHandlerOptions(route, opts) {
       valSecret: maybeValSecret,
       valBuildUrl,
       valContentUrl,
+      versions: {
+        core: coreVersion,
+        next: nextVersion
+      },
       git: {
         commit: maybeGitCommit,
         branch: maybeGitBranch