@valbuild/server 0.75.4 → 0.76.0

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

@@ -7,7 +7,7 @@ var ts = require('typescript');
 var fp = require('@valbuild/core/fp');
 var core = require('@valbuild/core');
 var patch = require('@valbuild/core/patch');
-var fsPath = require('path');
+var path = require('path');
 var fs = require('fs');
 var sucrase = require('sucrase');
 var ui = require('@valbuild/ui');
@@ -41,7 +41,7 @@ function _interopNamespace(e) {
 }
 
 var ts__default = /*#__PURE__*/_interopDefault(ts);
-var fsPath__namespace = /*#__PURE__*/_interopNamespace(fsPath);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto$1);
 var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
@@ -819,7 +819,7 @@ class TSOps {
 }
 
 function getSyntheticContainingPath(rootDir) {
-  return fsPath__namespace["default"].join(rootDir, "<val>"); // TODO: this is the synthetic path used when evaluating / patching modules. I am not sure <val> is the best choice: val.ts / js better? But that is weird too. At least now it is clear(er) that it is indeed a synthetic file (i.e. not an actual file)
+  return path__namespace["default"].join(rootDir, "<val>"); // TODO: this is the synthetic path used when evaluating / patching modules. I am not sure <val> is the best choice: val.ts / js better? But that is weird too. At least now it is clear(er) that it is indeed a synthetic file (i.e. not an actual file)
 }
 
 const ops = new TSOps(document => {
@@ -990,8 +990,8 @@ globalThis.valModule = {
 };
 
 const getCompilerOptions = (rootDir, parseConfigHost) => {
-  const tsConfigPath = fsPath__namespace["default"].resolve(rootDir, "tsconfig.json");
-  const jsConfigPath = fsPath__namespace["default"].resolve(rootDir, "jsconfig.json");
+  const tsConfigPath = path__namespace["default"].resolve(rootDir, "tsconfig.json");
+  const jsConfigPath = path__namespace["default"].resolve(rootDir, "jsconfig.json");
   let configFilePath;
   if (parseConfigHost.fileExists(jsConfigPath)) {
     configFilePath = jsConfigPath;
@@ -1022,7 +1022,7 @@ class ValSourceFileHandler {
   constructor(projectRoot, compilerOptions, host = {
     ...ts__default["default"].sys,
     writeFile: (fileName, data, encoding) => {
-      fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(fileName), {
+      fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
         recursive: true
       });
       fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
@@ -1049,7 +1049,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, fsPath__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : fsPath__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
+    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : path__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -1072,7 +1072,7 @@ class ValModuleLoader {
   sourceFileHandler, host = {
     ...ts__default["default"].sys,
     writeFile: (fileName, data, encoding) => {
-      fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(fileName), {
+      fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
         recursive: true
       });
       fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
@@ -1365,7 +1365,7 @@ export default new Proxy({}, {
 async function createService(projectRoot, opts, host = {
   ...ts__default["default"].sys,
   writeFile: (fileName, data, encoding) => {
-    fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(fileName), {
+    fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
       recursive: true
     });
     fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
@@ -2245,96 +2245,8 @@ class ValOps {
   }
 
   // #region createPatch
-  async createPatch(path, patch$1, patchId, parentRef, authorId) {
-    const initTree = await this.initSources();
-    const schemas = initTree.schemas;
-    const moduleErrors = initTree.moduleErrors;
-    let sources = initTree.sources;
-    if (parentRef.type !== "head") {
-      // There's room for some optimizations here: we could do this once, then re-use every time we create a patch, then again we only create one patch at a time
-      const patchOps = await this.fetchPatches({
-        excludePatchOps: false
-      });
-      const patchAnalysis = this.analyzePatches(patchOps.patches);
-      const tree = await this.getSources({
-        ...patchAnalysis,
-        ...patchOps
-      });
-      sources = {
-        ...sources,
-        ...tree.sources
-      };
-    }
-    const source = sources[path];
-    const schema = schemas[path];
-    const moduleError = moduleErrors.find(e => e.path === path);
-    if (moduleError) {
-      console.error(`Cannot patch. Module at path: '${path}' has fatal errors: "${moduleError.message}"`);
-      return fp.result.err({
-        errorType: "other",
-        error: {
-          message: `Cannot patch. Module at path: '${path}' has fatal errors: ` + moduleErrors.map(m => `"${m.message}"`).join(" and ")
-        }
-      });
-    }
-    if (source === undefined) {
-      console.error(`Cannot patch. Module source at path: '${path}' does not exist`);
-      return fp.result.err({
-        errorType: "other",
-        error: {
-          message: `Cannot patch. Module source at path: '${path}' does not exist`
-        }
-      });
-    }
-    if (!schema) {
-      console.error(`Cannot patch. Module schema at path: '${path}' does not exist`);
-      return fp.result.err({
-        errorType: "other",
-        error: {
-          message: `Cannot patch. Module schema at path: '${path}' does not exist`
-        }
-      });
-    }
-    const sourceFileOps = [];
-    const files = {};
-    for (const op of patch$1) {
-      if (op.op !== "file") {
-        sourceFileOps.push(op);
-      } else {
-        const {
-          value,
-          filePath
-        } = op;
-        if (files[filePath]) {
-          console.error(`Cannot have multiple files with same path in same patch. Path: ${filePath}`);
-          files[filePath] = {
-            error: new patch.PatchError("Cannot have multiple files with same path in same patch")
-          };
-        } else if (typeof value !== "string") {
-          console.error(`Value is not a string. Path: ${filePath}. Value: ${value}`);
-          files[filePath] = {
-            error: new patch.PatchError("Value is not a string")
-          };
-        } else {
-          const sha256 = core.Internal.getSHA256Hash(textEncoder$2.encode(value));
-          files[filePath] = {
-            value,
-            sha256,
-            path: op.path,
-            remote: op.remote
-          };
-          sourceFileOps.push({
-            op: "file",
-            path: op.path,
-            filePath,
-            nestedFilePath: op.nestedFilePath,
-            value: sha256,
-            remote: op.remote
-          });
-        }
-      }
-    }
-    const saveRes = await this.saveSourceFilePatch(path, patch$1, patchId, parentRef, authorId);
+  async createPatch(path, patch, patchId, parentRef, authorId) {
+    const saveRes = await this.saveSourceFilePatch(path, patch, patchId, parentRef, authorId);
     if (fp.result.isErr(saveRes)) {
       console.error(`Could not save source patch at path: '${path}'. Error: ${saveRes.error.errorType === "other" ? saveRes.error.message : saveRes.error.errorType}`);
       if (saveRes.error.errorType === "patch-head-conflict") {
@@ -2347,95 +2259,8 @@ class ValOps {
         error: saveRes.error
       });
     }
-    const saveFileRes = await Promise.all(Object.entries(files).map(async ([filePath, data]) => {
-      if (data.error) {
-        return {
-          filePath,
-          error: data.error
-        };
-      } else {
-        var _lastRes;
-        let type;
-        const modulePath = core.Internal.patchPathToModulePath(data.path);
-        try {
-          const {
-            schema: schemaAtPath
-          } = core.Internal.resolvePath(modulePath, source, schema);
-          type = schemaAtPath instanceof core.ImageSchema || schemaAtPath instanceof core.RichTextSchema // if it's a rich text schema, we assume it's an image - hope this assumption holds!
-          ? "image" : schemaAtPath instanceof core.FileSchema ? "file" : schemaAtPath.serialize().type;
-        } catch (e) {
-          if (e instanceof Error) {
-            console.error(`Could not resolve file type at: ${modulePath}. Error: ${e.message}`);
-            return {
-              filePath,
-              error: new patch.PatchError(`Could not resolve file type at: ${modulePath}. Error: ${e.message}`)
-            };
-          }
-          console.error(`Could not resolve file type at: ${modulePath}. Unknown error.`);
-          return {
-            filePath,
-            error: new patch.PatchError(`Could not resolve file type at: ${modulePath}. Unknown error.`)
-          };
-        }
-        if (type !== "image" && type !== "file") {
-          console.error("Unknown file type (resolved from schema): " + type);
-          return {
-            filePath,
-            error: new patch.PatchError("Unknown file type (resolved from schema): " + type)
-          };
-        }
-        const mimeType = getMimeTypeFromBase64(data.value);
-        if (!mimeType) {
-          console.error("Could not get mimeType from base 64 encoded value");
-          return {
-            filePath,
-            error: new patch.PatchError("Could not get mimeType from base 64 encoded value. First chars were: " + data.value.slice(0, 20))
-          };
-        }
-        const buffer = bufferFromDataUrl(data.value);
-        if (!buffer) {
-          console.error("Could not create buffer from base 64 encoded value");
-          return {
-            filePath,
-            error: new patch.PatchError("Could not create buffer from base 64 encoded value")
-          };
-        }
-        const metadataOps = createMetadataFromBuffer(type, mimeType, buffer);
-        if (metadataOps.errors) {
-          console.error(`Could not get metadata. Errors: ${metadataOps.errors.map(error => error.message).join(", ")}`);
-          return {
-            filePath,
-            error: new patch.PatchError(`Could not get metadata. Errors: ${metadataOps.errors.map(error => error.message).join(", ")}`)
-          };
-        }
-        const MaxRetries = 3;
-        let lastRes;
-        for (let i = 0; i < MaxRetries; i++) {
-          lastRes = await this.saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data.value, type, metadataOps.metadata, data.remote);
-          if (!lastRes.error) {
-            return {
-              filePath
-            };
-          }
-        }
-        return {
-          filePath,
-          error: new patch.PatchError(((_lastRes = lastRes) === null || _lastRes === void 0 || (_lastRes = _lastRes.error) === null || _lastRes === void 0 ? void 0 : _lastRes.message) || "Unexpectedly could not save patch file")
-        };
-      }
-    }));
-    const errors = saveFileRes.filter(f => !!f.error);
-    if (errors.length > 0) {
-      return fp.result.err({
-        errorType: "other",
-        error: {
-          message: "Could not save patch: " + errors.map(e => e.error.message).join(", ")
-        }
-      });
-    }
     return fp.result.ok({
       patchId,
-      files: saveFileRes,
       createdAt: new Date().toISOString()
     });
   }
@@ -2511,17 +2336,6 @@ function createMetadataFromBuffer(type, mimeType, buffer) {
     metadata
   };
 }
-const base64DataAttr = "data:";
-function getMimeTypeFromBase64(content) {
-  const dataIndex = content.indexOf(base64DataAttr);
-  const base64Index = content.indexOf(";base64,");
-  if (dataIndex > -1 || base64Index > -1) {
-    const mimeType = content.slice(dataIndex + base64DataAttr.length, base64Index);
-    const normalizedMimeType = mimeType === "image/jpg" ? "image/jpeg" : mimeType;
-    return normalizedMimeType;
-  }
-  return null;
-}
 function bufferFromDataUrl(dataUrl) {
   let base64Data;
   const base64Index = dataUrl.indexOf(";base64,");
@@ -2685,7 +2499,7 @@ class ValOpsFS extends ValOps {
         const mtimeInDir = {};
         if (fs__default["default"].existsSync(dir)) {
           for (const file of fs__default["default"].readdirSync(dir)) {
-            mtimeInDir[file] = fs__default["default"].statSync(fsPath__namespace["default"].join(dir, file)).mtime.getTime();
+            mtimeInDir[file] = fs__default["default"].statSync(path__namespace["default"].join(dir, file)).mtime.getTime();
           }
         }
         return new Promise(resolve => {
@@ -2698,7 +2512,7 @@ class ValOpsFS extends ValOps {
                 resolve("request-again");
               }
               for (const file of fs__default["default"].readdirSync(dir)) {
-                const mtime = fs__default["default"].statSync(fsPath__namespace["default"].join(dir, file)).mtime.getTime();
+                const mtime = fs__default["default"].statSync(path__namespace["default"].join(dir, file)).mtime.getTime();
                 if (mtime !== mtimeInDir[file]) {
                   resolve("request-again");
                 }
@@ -2759,7 +2573,7 @@ class ValOpsFS extends ValOps {
         patchesDirHandle = handle;
       }),
       // we poll the files that Val depends on for changes
-      disableFilePolling ? new Promise(() => {}) : didFilesChangeUsingPolling([fsPath__namespace["default"].join(this.rootDir, "val.config.ts"), fsPath__namespace["default"].join(this.rootDir, "val.modules.ts"), fsPath__namespace["default"].join(this.rootDir, "val.config.js"), fsPath__namespace["default"].join(this.rootDir, "val.modules.js"), ...moduleFilePaths.map(p => fsPath__namespace["default"].join(this.rootDir, p))], statFilePollingInterval, handle => {
+      disableFilePolling ? new Promise(() => {}) : didFilesChangeUsingPolling([path__namespace["default"].join(this.rootDir, "val.config.ts"), path__namespace["default"].join(this.rootDir, "val.modules.ts"), path__namespace["default"].join(this.rootDir, "val.config.js"), path__namespace["default"].join(this.rootDir, "val.modules.js"), ...moduleFilePaths.map(p => path__namespace["default"].join(this.rootDir, p))], statFilePollingInterval, handle => {
         valFilesIntervalHandle = handle;
       }), new Promise(resolve => {
         fsWatcher = fs__default["default"].watch(this.rootDir, {
@@ -2817,7 +2631,7 @@ class ValOpsFS extends ValOps {
     }
     const patches = {};
     const errors = [];
-    const parsedUnsortedFsPatches = patchJsonFiles.map(file => fsPath__namespace["default"].basename(fsPath__namespace["default"].dirname(file))).map(patchDir => [patchDir, this.parseJsonFile(this.getPatchFilePath(patchDir), FSPatch), this.host.fileExists(this.getPatchBaseFile(patchDir)) ? this.parseJsonFile(this.getPatchBaseFile(patchDir), FSPatchBase) : undefined]);
+    const parsedUnsortedFsPatches = patchJsonFiles.map(file => path__namespace["default"].basename(path__namespace["default"].dirname(file))).map(patchDir => [patchDir, this.parseJsonFile(this.getPatchFilePath(patchDir), FSPatch), this.host.fileExists(this.getPatchBaseFile(patchDir)) ? this.parseJsonFile(this.getPatchBaseFile(patchDir), FSPatchBase) : undefined]);
     parsedUnsortedFsPatches.forEach(([dir, parsedPatch, parsedBase]) => {
       if (parsedPatch.error) {
         errors.push({
@@ -3028,9 +2842,7 @@ class ValOpsFS extends ValOps {
       }
       const writeRes = this.host.tryWriteUf8File(this.getPatchFilePath(patchDir), JSON.stringify(data));
       if (writeRes.type === "error") {
-        return writeRes.errorType === "dir-already-exists" ? fp.result.err({
-          errorType: "patch-head-conflict"
-        }) : fp.result.err({
+        return fp.result.err({
           errorType: "other",
           error: writeRes.error,
           message: "Failed to write patch file"
@@ -3055,7 +2867,7 @@ class ValOpsFS extends ValOps {
     }
   }
   async getSourceFile(path) {
-    const filePath = fsPath__namespace["default"].join(this.rootDir, path);
+    const filePath = path__namespace["default"].join(this.rootDir, path);
     if (!this.host.fileExists(filePath)) {
       return {
         error: {
@@ -3068,7 +2880,7 @@ class ValOpsFS extends ValOps {
     };
   }
   async saveSourceFile(path, data) {
-    const filePath = fsPath__namespace["default"].join(this.rootDir, ...path.split("/"));
+    const filePath = path__namespace["default"].join(this.rootDir, ...path.split("/"));
     try {
       this.host.writeUf8File(filePath, data);
       return {
@@ -3089,10 +2901,10 @@ class ValOpsFS extends ValOps {
       };
     }
   }
-  async saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, _type, metadata, remote) {
+  async saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, _type, metadata) {
     const patchDir = this.getParentPatchIdFromParentRef(parentRef);
-    const patchFilePath = this.getBinaryFilePath(filePath, patchDir, remote);
-    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDir, remote);
+    const patchFilePath = this.getBinaryFilePath(filePath, patchDir);
+    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDir);
     try {
       const buffer = bufferFromDataUrl(data);
       if (!buffer) {
@@ -3123,7 +2935,7 @@ class ValOpsFS extends ValOps {
       };
     }
   }
-  async getBase64EncodedBinaryFileMetadataFromPatch(filePath, type, patchId, remote) {
+  async getBase64EncodedBinaryFileMetadataFromPatch(filePath, type, patchId) {
     const patchDirRes = await this.getParentPatchIdFromPatchId(patchId);
     if (fp.result.isErr(patchDirRes)) {
       return {
@@ -3132,7 +2944,7 @@ class ValOpsFS extends ValOps {
         }]
       };
     }
-    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDirRes.value, remote);
+    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDirRes.value);
     if (!this.host.fileExists(metadataFilePath)) {
       return {
         errors: [{
@@ -3172,10 +2984,7 @@ class ValOpsFS extends ValOps {
     if (!fp.result.isOk(patchDirRes)) {
       return null;
     }
-    const absPath = this.getBinaryFilePath(filePath, patchDirRes.value,
-    // We save remote remote files using the filepath (so not the remote reference) and we also retrieve them using the filepath. Therefore remote is always false
-    false // remote = false
-    );
+    const absPath = this.getBinaryFilePath(filePath, patchDirRes.value);
     if (!this.host.fileExists(absPath)) {
       return null;
     }
@@ -3199,7 +3008,7 @@ class ValOpsFS extends ValOps {
   }
   async deleteAllPatches() {
     const patchesCacheDir = this.getPatchesDir();
-    const tmpDir = fsPath__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches-deleted-" + crypto.randomUUID());
+    const tmpDir = path__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches-deleted-" + crypto.randomUUID());
     try {
       this.host.moveDir(patchesCacheDir, tmpDir);
       this.host.deleteDir(tmpDir);
@@ -3314,13 +3123,11 @@ class ValOpsFS extends ValOps {
           };
           continue;
         }
-        console.log("Uploading remote file", ref);
         const res = await uploadRemoteFile(this.contentUrl, this.options.config.project, splitRemoteRefRes.bucket, splitRemoteRefRes.fileHash, getFileExt(splitRemoteRefRes.filePath), fileBuffer, auth);
         if (!res.success) {
           console.error("Failed to upload remote file", ref, res.error);
           throw new Error(`Failed to upload remote file: ${ref}. ${res.error}`);
         }
-        console.log("Completed remote file", ref);
         uploadedRemoteRefs.push(ref);
       }
     }
@@ -3337,7 +3144,7 @@ class ValOpsFS extends ValOps {
       patchId
     }] of localFileDescriptors) {
       const filePath = ref;
-      const absPath = fsPath__namespace["default"].join(this.rootDir, ...filePath.split("/"));
+      const absPath = path__namespace["default"].join(this.rootDir, ...filePath.split("/"));
       try {
         const patchDir = patchIdToPatchDirMap[patchId];
         if (!patchDir) {
@@ -3347,7 +3154,7 @@ class ValOpsFS extends ValOps {
           };
           continue;
         }
-        this.host.copyFile(this.getBinaryFilePath(filePath, patchDir, false), absPath);
+        this.host.copyFile(this.getBinaryFilePath(filePath, patchDir), absPath);
         updatedFiles.push(absPath);
       } catch (err) {
         errors[absPath] = {
@@ -3357,7 +3164,7 @@ class ValOpsFS extends ValOps {
       }
     }
     for (const [filePath, data] of Object.entries(preparedCommit.patchedSourceFiles)) {
-      const absPath = fsPath__namespace["default"].join(this.rootDir, ...filePath.split("/"));
+      const absPath = path__namespace["default"].join(this.rootDir, ...filePath.split("/"));
       try {
         this.host.writeUf8File(absPath, data);
         updatedFiles.push(absPath);
@@ -3397,7 +3204,7 @@ class ValOpsFS extends ValOps {
     };
   }
   async getBinaryFile(filePath) {
-    const absPath = fsPath__namespace["default"].join(this.rootDir, ...filePath.split("/"));
+    const absPath = path__namespace["default"].join(this.rootDir, ...filePath.split("/"));
     if (!this.host.fileExists(absPath)) {
       return null;
     }
@@ -3418,7 +3225,7 @@ class ValOpsFS extends ValOps {
     if (!mimeType) {
       return {
         errors: [{
-          message: `Could not guess mime type of file ext: ${fsPath__namespace["default"].extname(filePath)}`,
+          message: `Could not guess mime type of file ext: ${path__namespace["default"].extname(filePath)}`,
           filePath
         }]
       };
@@ -3456,38 +3263,22 @@ class ValOpsFS extends ValOps {
 
   // #region fs file path helpers
   getPatchesDir() {
-    return fsPath__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches");
+    return path__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches");
   }
   getFullPatchDir(patchDir) {
-    return fsPath__namespace["default"].join(this.getPatchesDir(), patchDir);
+    return path__namespace["default"].join(this.getPatchesDir(), patchDir);
   }
-  getBinaryFilePath(filePath, patchDir, remote) {
-    if (remote) {
-      const res = core.Internal.remote.splitRemoteRef(filePath);
-      if (res.status === "error") {
-        throw new Error("Failed to split remote ref: " + filePath);
-      }
-      const actualFilePath = res.filePath;
-      return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", actualFilePath, fsPath__namespace["default"].basename(actualFilePath));
-    }
-    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, fsPath__namespace["default"].basename(filePath));
+  getBinaryFilePath(filePath, patchDir) {
+    return path__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, path__namespace["default"].basename(filePath));
   }
-  getBinaryFileMetadataPath(filePath, patchDir, remote) {
-    if (remote) {
-      const res = core.Internal.remote.splitRemoteRef(filePath);
-      if (res.status === "error") {
-        throw new Error("Failed to split remote ref (in metadata path): " + filePath);
-      }
-      const actualFilePath = res.filePath;
-      return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", actualFilePath, fsPath__namespace["default"].basename(actualFilePath));
-    }
-    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, "metadata.json");
+  getBinaryFileMetadataPath(filePath, patchDir) {
+    return path__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, "metadata.json");
   }
   getPatchFilePath(patchDir) {
-    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "patch.json");
+    return path__namespace["default"].join(this.getFullPatchDir(patchDir), "patch.json");
   }
   getPatchBaseFile(patchDir) {
-    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "base.json");
+    return path__namespace["default"].join(this.getFullPatchDir(patchDir), "base.json");
   }
 }
 class FSOpsHost {
@@ -3520,28 +3311,24 @@ class FSOpsHost {
     return fs__default["default"].readFileSync(path, "utf-8");
   }
   writeUf8File(path, data) {
-    fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(path), {
+    fs__default["default"].mkdirSync(path__namespace["default"].dirname(path), {
       recursive: true
     });
     fs__default["default"].writeFileSync(path, data, "utf-8");
   }
   tryWriteUf8File(path, data) {
     try {
-      const parentDir = fsPath__namespace["default"].join(fsPath__namespace["default"].dirname(path), "../");
+      const parentDir = path__namespace["default"].join(path__namespace["default"].dirname(path), "../");
       fs__default["default"].mkdirSync(parentDir, {
         recursive: true
       });
       // Make the parent dir separately. This is because we need mkdir to throw
       // if the directory already exists. If we use recursive: true, it doesn't
-      fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(path), {
+      fs__default["default"].mkdirSync(path__namespace["default"].dirname(path), {
         recursive: false
       });
     } catch (e) {
-      return {
-        type: "error",
-        errorType: "dir-already-exists",
-        error: e
-      };
+      // ignore
     }
     try {
       fs__default["default"].writeFileSync(path, data, "utf-8");
@@ -3557,13 +3344,13 @@ class FSOpsHost {
     };
   }
   writeBinaryFile(path, data) {
-    fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(path), {
+    fs__default["default"].mkdirSync(path__namespace["default"].dirname(path), {
       recursive: true
     });
     fs__default["default"].writeFileSync(path, new Uint8Array(data), "base64url");
   }
   copyFile(from, to) {
-    fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(to), {
+    fs__default["default"].mkdirSync(path__namespace["default"].dirname(to), {
       recursive: true
     });
     fs__default["default"].copyFileSync(from, to);
@@ -3707,9 +3494,93 @@ class ValOpsHttp extends ValOps {
   async onInit() {
     // TODO: unused for now. Implement or remove
   }
-  async getCommitSummary(preparedCommit) {
+  async getPresignedAuthNonce(profileId, corsOrigin) {
     try {
       var _res$headers$get;
+      const res = await fetch(`${this.contentUrl}/v1/${this.project}/presigned-auth-nonce`, {
+        method: "POST",
+        headers: {
+          ...this.authHeaders,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          profileId,
+          corsOrigin
+        })
+      });
+      if (res.ok) {
+        const json = await res.json();
+        const parsed = zod.z.object({
+          nonce: zod.z.string(),
+          expiresAt: zod.z.string()
+        }).safeParse(json);
+        if (parsed.success) {
+          const {
+            nonce
+          } = parsed.data;
+          return {
+            status: "success",
+            data: {
+              nonce,
+              baseUrl: `${this.contentUrl}/v1/${this.project}`
+            }
+          };
+        } else {
+          console.error("Could not parse presigned auth nonce response. Error: " + zodValidationError.fromError(parsed.error));
+          return {
+            status: "error",
+            statusCode: 500,
+            error: {
+              message: "Could not get presigned auth nonce. The response that Val got from the server was not in the expected format. You might be running on an old version, or it might be a transient error or a configuration issue. Please try again later."
+            }
+          };
+        }
+      }
+      if (res.status === 401) {
+        return {
+          statusCode: 401,
+          status: "error",
+          error: {
+            message: "Could not get presigned auth nonce. Although your user is authorized, the application has authorization issues. Contact the developers on your team and ask them to verify the api keys."
+          }
+        };
+      }
+      if ((_res$headers$get = res.headers.get("Content-Type")) !== null && _res$headers$get !== void 0 && _res$headers$get.includes("application/json")) {
+        const json = await res.json();
+        if (json.message) {
+          console.error("Presigned auth nonce error:", json.message);
+          return {
+            status: "error",
+            statusCode: 500,
+            error: {
+              message: json.message
+            }
+          };
+        }
+      }
+      const unknownErrorMessage = `Could not get presigned auth nonce. HTTP error: ${res.status} ${res.statusText}`;
+      console.error(unknownErrorMessage);
+      return {
+        status: "error",
+        statusCode: 500,
+        error: {
+          message: unknownErrorMessage
+        }
+      };
+    } catch (e) {
+      console.error("Could not get presigned auth nonce (connection error?):", e);
+      return {
+        status: "error",
+        statusCode: 500,
+        error: {
+          message: `Could not get presigned auth nonce. Error: ${e instanceof Error ? e.message : JSON.stringify(e)}`
+        }
+      };
+    }
+  }
+  async getCommitSummary(preparedCommit) {
+    try {
+      var _res$headers$get2;
       const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit-summary`, {
         method: "POST",
         headers: {
@@ -3745,7 +3616,7 @@ class ValOpsHttp extends ValOps {
         };
       }
       const unknownErrorMessage = `Could not get summary. HTTP error: ${res.status} ${res.statusText}`;
-      if ((_res$headers$get = res.headers.get("Content-Type")) !== null && _res$headers$get !== void 0 && _res$headers$get.includes("application/json")) {
+      if ((_res$headers$get2 = res.headers.get("Content-Type")) !== null && _res$headers$get2 !== void 0 && _res$headers$get2.includes("application/json")) {
         const json = await res.json();
         if (json.message) {
           console.error("Summary error:", json.message);
@@ -4073,7 +3944,7 @@ class ValOpsHttp extends ValOps {
         coreVersion: core.Internal.VERSION.core
       })
     }).then(async res => {
-      var _res$headers$get2;
+      var _res$headers$get3;
       if (res.ok) {
         const parsed = SavePatchResponse.safeParse(await res.json());
         if (parsed.success) {
@@ -4092,7 +3963,7 @@ class ValOpsHttp extends ValOps {
           message: "Conflict: " + (await res.text())
         });
       }
-      if ((_res$headers$get2 = res.headers.get("Content-Type")) !== null && _res$headers$get2 !== void 0 && _res$headers$get2.includes("application/json")) {
+      if ((_res$headers$get3 = res.headers.get("Content-Type")) !== null && _res$headers$get3 !== void 0 && _res$headers$get3.includes("application/json")) {
         const json = await res.json();
         return fp.result.err({
           errorType: "other",
@@ -4110,23 +3981,12 @@ class ValOpsHttp extends ValOps {
       });
     });
   }
-  async saveBase64EncodedBinaryFileFromPatch(filePathOrRef, _parentRef,
-  // this is required for the FS implementation, but not for the HTTP implementation (patchId is enough)
-  patchId, data, type, metadata, remote) {
-    let filePath;
-    if (remote) {
-      const splitRemoteRefDataRes = core.Internal.remote.splitRemoteRef(filePathOrRef);
-      if (splitRemoteRefDataRes.status === "error") {
-        return {
-          error: {
-            message: `Could not split remote ref: ${splitRemoteRefDataRes.error}`
-          }
-        };
-      }
-      filePath = "/" + splitRemoteRefDataRes.filePath;
-    } else {
-      filePath = filePathOrRef;
-    }
+
+  /**
+   * @deprecated For HTTP ops use direct upload instead (i.e. client should upload the files directly) since hosting platforms (Vercel) might have low limits on the size of the request body.
+   */
+  async saveBase64EncodedBinaryFileFromPatch(filePathOrRef, parentRef, patchId, data, type, metadata) {
+    const filePath = filePathOrRef;
     return fetch(`${this.contentUrl}/v1/${this.project}/patches/${patchId}/files`, {
       method: "POST",
       headers: {
@@ -4135,10 +3995,11 @@ class ValOpsHttp extends ValOps {
       },
       body: JSON.stringify({
         filePath,
+        parentRef,
+        // Not currently used
         data,
         type,
-        metadata,
-        remote
+        metadata
       })
     }).then(async res => {
       if (res.ok) {
@@ -4385,7 +4246,7 @@ class ValOpsHttp extends ValOps {
     });
   }
   async getCommitMessage(preparedCommit) {
-    var _res$headers$get3;
+    var _res$headers$get4;
     const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit-summary`, {
       method: "POST",
       headers: {
@@ -4403,7 +4264,7 @@ class ValOpsHttp extends ValOps {
         commitSummary: json.commitSummary
       };
     }
-    if ((_res$headers$get3 = res.headers.get("Content-Type")) !== null && _res$headers$get3 !== void 0 && _res$headers$get3.includes("application/json")) {
+    if ((_res$headers$get4 = res.headers.get("Content-Type")) !== null && _res$headers$get4 !== void 0 && _res$headers$get4.includes("application/json")) {
       const json = await res.json();
       return {
         error: {
@@ -4419,7 +4280,7 @@ class ValOpsHttp extends ValOps {
   }
   async commit(prepared, message, committer, filesDirectory, newBranch) {
     try {
-      var _res$headers$get4;
+      var _res$headers$get5;
       const existingBranch = this.branch;
       const res = await fetch(`${this.contentUrl}/v1/${this.project}/commit`, {
         method: "POST",
@@ -4456,7 +4317,7 @@ class ValOpsHttp extends ValOps {
           }
         };
       }
-      if ((_res$headers$get4 = res.headers.get("Content-Type")) !== null && _res$headers$get4 !== void 0 && _res$headers$get4.includes("application/json")) {
+      if ((_res$headers$get5 = res.headers.get("Content-Type")) !== null && _res$headers$get5 !== void 0 && _res$headers$get5.includes("application/json")) {
         const json = await res.json();
         if (json.isNotFastForward) {
           return {
@@ -4488,7 +4349,7 @@ class ValOpsHttp extends ValOps {
 
   // #region profiles
   async getProfiles() {
-    var _res$headers$get5;
+    var _res$headers$get6;
     const res = await fetch(`${this.contentUrl}/v1/${this.project}/profiles`, {
       headers: {
         ...this.authHeaders,
@@ -4503,7 +4364,7 @@ class ValOpsHttp extends ValOps {
       }
       return parsed.data.profiles;
     }
-    if ((_res$headers$get5 = res.headers.get("Content-Type")) !== null && _res$headers$get5 !== void 0 && _res$headers$get5.includes("application/json")) {
+    if ((_res$headers$get6 = res.headers.get("Content-Type")) !== null && _res$headers$get6 !== void 0 && _res$headers$get6.includes("application/json")) {
       const json = await res.json();
       throw Error(`Could not get profiles (status: ${res.status}): ${"message" in json ? json.message : "Unknown error"}`);
     }
@@ -4532,7 +4393,7 @@ async function getSettings(projectName, auth) {
     if (response.status === 404) {
       return {
         success: false,
-        message: `Project '${projectName}' not found: that the name of the project is correct and that you have access to it.`
+        message: `Project '${projectName}' not found: verify that the name of the project is correct and that you have access to it.`
       };
     }
     if (response.status !== 200) {
@@ -4562,7 +4423,7 @@ async function getSettings(projectName, auth) {
 }
 
 function getPersonalAccessTokenPath(root) {
-  return fsPath__namespace["default"].join(fsPath__namespace["default"].resolve(root), ".val", "pat.json");
+  return path__namespace["default"].join(path__namespace["default"].resolve(root), ".val", "pat.json");
 }
 function parsePersonalAccessTokenFile(content) {
   if (!content) {
@@ -4840,7 +4701,7 @@ const ValServer = (valModules, options, callbacks) => {
         };
       }
       const fs = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('fs')); });
-      const patPath = getPersonalAccessTokenPath(fsPath__namespace["default"].join(process.cwd()));
+      const patPath = getPersonalAccessTokenPath(path__namespace["default"].join(process.cwd()));
       let patFile;
       try {
         patFile = await fs.promises.readFile(patPath, "utf-8");
@@ -5279,12 +5140,12 @@ const ValServer = (valModules, options, callbacks) => {
         const remoteFileAuth = remoteFileAuthRes.json.remoteFileAuth;
         const settingsRes = await getSettings(options.project, remoteFileAuth);
         if (!settingsRes.success) {
-          console.warn("Could not get public project id: " + settingsRes.message);
+          console.warn("Could not get remote files settings: " + settingsRes.message);
           return {
             status: 400,
             json: {
               errorCode: "error-could-not-get-settings",
-              message: `Could not get settings id: ${settingsRes.message}`
+              message: `Could not get remote files settings: ${settingsRes.message}`
             }
           };
         }
@@ -5366,6 +5227,105 @@ const ValServer = (valModules, options, callbacks) => {
         };
       }
     },
+    "/upload/patches": {
+      POST: async req => {
+        if (serverOps instanceof ValOpsHttp) {
+          return {
+            status: 400,
+            json: {
+              message: "Do not use this endpoint in HTTP mode"
+            }
+          };
+        }
+        const pathParts = req.path.split("/");
+        const patchId = pathParts[1];
+        const isValidPatchId = patchId.length === 36;
+        const isValidEndpoint = pathParts[0] === "" && isValidPatchId && pathParts[2] === "files";
+        if (!isValidEndpoint) {
+          return {
+            status: 400,
+            json: {
+              message: "Invalid endpoint"
+            }
+          };
+        }
+        const {
+          filePath,
+          parentRef,
+          type,
+          data,
+          metadata
+        } = req.body;
+        const saveRes = await serverOps.saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, type, metadata);
+        if (saveRes.error) {
+          return {
+            status: 400,
+            json: {
+              message: saveRes.error.message
+            }
+          };
+        }
+        return {
+          status: 200,
+          json: {
+            filePath,
+            patchId
+          }
+        };
+      }
+    },
+    "/direct-file-upload-settings": {
+      POST: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (serverOps instanceof ValOpsFS) {
+          // In FS mode we do not use the remote server at all and just return an url that points to this server
+          // which has an endpoint that handles this
+          // A bit hacky perhaps, but we want to have as similar semantics as possible in client code when it comes to FS / HTTP
+          const host = `/api/val`;
+          return {
+            status: 200,
+            json: {
+              nonce: null,
+              baseUrl: `${host}/upload` // NOTE: this is the /upload/patches endpoint - the client will add /patches/:patchId/files to this and post to it
+            }
+          };
+        }
+        const httpOps = serverOps;
+        const profileId = "id" in auth && auth.id ? auth.id : undefined;
+        if (!profileId) {
+          return {
+            status: 401,
+            json: {
+              message: "Unauthorized"
+            }
+          };
+        }
+        const corsOrigin = "*"; // TODO: add cors origin
+        const presignedAuthNonce = await httpOps.getPresignedAuthNonce(profileId, corsOrigin);
+        if (presignedAuthNonce.status === "error") {
+          return {
+            status: presignedAuthNonce.statusCode,
+            json: presignedAuthNonce.error
+          };
+        }
+        return {
+          status: 200,
+          json: {
+            nonce: presignedAuthNonce.data.nonce,
+            baseUrl: presignedAuthNonce.data.baseUrl
+          }
+        };
+      }
+    },
     //#region patches
     "/patches": {
       PUT: async req => {
@@ -5407,7 +5367,7 @@ const ValServer = (valModules, options, callbacks) => {
                 status: 400,
                 json: {
                   type: "patch-error",
-                  message: "Could not create patch",
+                  message: createPatchRes.error.error.message,
                   errors: {
                     [patch.path]: [{
                       error: {
@@ -5869,8 +5829,22 @@ const ValServer = (valModules, options, callbacks) => {
             return remoteFileAuthRes;
           }
           const remoteFileAuth = (_remoteFileAuthRes = remoteFileAuthRes) === null || _remoteFileAuthRes === void 0 || (_remoteFileAuthRes = _remoteFileAuthRes.json) === null || _remoteFileAuthRes === void 0 ? void 0 : _remoteFileAuthRes.remoteFileAuth;
+          const saveRes = await serverOps.saveOrUploadFiles(preparedCommit, mode, remoteFileAuth);
+          if (Object.keys(saveRes.errors).length > 0) {
+            console.error("Val: Failed to save files", saveRes.errors);
+            return {
+              status: 400,
+              json: {
+                message: "Failed to save files",
+                details: Object.entries(saveRes.errors).map(([key, error]) => {
+                  return {
+                    message: `Got error: ${error} in ${key}`
+                  };
+                })
+              }
+            };
+          }
           const deleteRes = await serverOps.deleteAllPatches();
-          await serverOps.saveOrUploadFiles(preparedCommit, mode, remoteFileAuth);
           if (deleteRes.error) {
             console.error(`Val got an error while cleaning up patches after publish: ${deleteRes.error.message}`);
           }
@@ -6363,7 +6337,7 @@ async function initHandlerOptions(route, opts, config) {
 // TODO: remove
 async function safeReadGit(cwd) {
   async function findGitHead(currentDir, depth) {
-    const gitHeadPath = fsPath__namespace.join(currentDir, ".git", "HEAD");
+    const gitHeadPath = path__namespace.join(currentDir, ".git", "HEAD");
     if (depth > 1000) {
       console.error(`Reached max depth while scanning for .git folder. Current working dir: ${cwd}.`);
       return {
@@ -6387,7 +6361,7 @@ async function safeReadGit(cwd) {
         };
       }
     } catch (error) {
-      const parentDir = fsPath__namespace.dirname(currentDir);
+      const parentDir = path__namespace.dirname(currentDir);
 
       // We've reached the root directory
       if (parentDir === currentDir) {
@@ -6411,7 +6385,7 @@ async function safeReadGit(cwd) {
 }
 async function readCommit(gitDir, branchName) {
   try {
-    return (await fs.promises.readFile(fsPath__namespace.join(gitDir, ".git", "refs", "heads", branchName), "utf-8")).trim();
+    return (await fs.promises.readFile(path__namespace.join(gitDir, ".git", "refs", "heads", branchName), "utf-8")).trim();
   } catch (err) {
     return undefined;
   }
@@ -6687,10 +6661,10 @@ class ValFSHost {
     return this.currentDirectory;
   }
   getCanonicalFileName(fileName) {
-    if (fsPath__namespace["default"].isAbsolute(fileName)) {
-      return fsPath__namespace["default"].normalize(fileName);
+    if (path__namespace["default"].isAbsolute(fileName)) {
+      return path__namespace["default"].normalize(fileName);
     }
-    return fsPath__namespace["default"].resolve(this.getCurrentDirectory(), fileName);
+    return path__namespace["default"].resolve(this.getCurrentDirectory(), fileName);
   }
   fileExists(fileName) {
     return this.valFS.fileExists(fileName);
@@ -6857,11 +6831,11 @@ async function checkRemoteRef(remoteHost, ref, projectRoot, schema, metadata) {
 }
 function getCachedRemoteFileDir(projectRoot) {
   // store in projectRoot/.val/remote-file-cache
-  const remoteFileCacheDir = fsPath__namespace["default"].join(projectRoot, ".val", "remote-file-cache");
+  const remoteFileCacheDir = path__namespace["default"].join(projectRoot, ".val", "remote-file-cache");
   return remoteFileCacheDir;
 }
 function getCachedRemoteFilePath(fileExt, currentFileHash, remoteFileCacheDir) {
-  const remoteFilePath = fsPath__namespace["default"].join(remoteFileCacheDir, currentFileHash + "." + fileExt);
+  const remoteFilePath = path__namespace["default"].join(remoteFileCacheDir, currentFileHash + "." + fileExt);
   return remoteFilePath;
 }
 async function getFileBufferFromRemote(ref, fileExt, currentFileHash, projectRoot) {
@@ -7144,8 +7118,8 @@ async function createFixPatch(config, apply, sourcePath, validationError, remote
         });
         continue;
       }
-      const absoluteFilePath = fsPath__namespace["default"].join(config.projectRoot, splitRemoteRefDataRes.filePath);
-      await fs__default["default"].promises.mkdir(fsPath__namespace["default"].dirname(absoluteFilePath), {
+      const absoluteFilePath = path__namespace["default"].join(config.projectRoot, splitRemoteRefDataRes.filePath);
+      await fs__default["default"].promises.mkdir(path__namespace["default"].dirname(absoluteFilePath), {
         recursive: true
       });
       const res = await downloadFileFromRemote(url, absoluteFilePath);
@@ -7306,7 +7280,7 @@ async function getImageMetadata(projectRoot, validationError) {
     // TODO:
     throw Error("Cannot fix image without a file reference");
   }
-  const filename = fsPath__namespace["default"].join(projectRoot, fileRef);
+  const filename = path__namespace["default"].join(projectRoot, fileRef);
   const buffer = fs__default["default"].readFileSync(filename);
   return extractImageMetadata(filename, buffer);
 }
@@ -7316,7 +7290,7 @@ async function getFileMetadata(projectRoot, validationError) {
     // TODO:
     throw Error("Cannot fix file without a file reference");
   }
-  const filename = fsPath__namespace["default"].join(projectRoot, fileRef);
+  const filename = path__namespace["default"].join(projectRoot, fileRef);
   fs__default["default"].readFileSync(filename);
   return extractFileMetadata(fileRef);
 }