@valbuild/server 0.67.0 → 0.68.0

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

@@ -14,7 +14,7 @@ var ui = require('@valbuild/ui');
 var internal = require('@valbuild/shared/internal');
 var server = require('@valbuild/ui/server');
 var crypto$1 = require('crypto');
-var z = require('zod');
+var zod = require('zod');
 var sizeOf = require('image-size');
 var zodValidationError = require('zod-validation-error');
 
@@ -42,7 +42,6 @@ var ts__default = /*#__PURE__*/_interopDefault(ts);
 var fsPath__namespace = /*#__PURE__*/_interopNamespace(fsPath);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto$1);
-var z__default = /*#__PURE__*/_interopDefault(z);
 var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
 
 class ValSyntaxError {
@@ -1356,9 +1355,9 @@ function decodeJwt(token, secretKey) {
 function getExpire() {
   return Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 4; // 4 days
 }
-const JwtHeaderSchema = z.z.object({
-  alg: z.z.literal("HS256"),
-  typ: z.z.literal("JWT")
+const JwtHeaderSchema = zod.z.object({
+  alg: zod.z.literal("HS256"),
+  typ: zod.z.literal("JWT")
 });
 const jwtHeader = {
   alg: "HS256",
@@ -1383,11 +1382,11 @@ const tsOps = new TSOps(document => {
 class ValOps {
   /** Sources from val modules, immutable (without patches or anything)  */
 
-  /** The sha265 / hash of sources + schema + config */
+  /** The sha256 / hash of sources + schema + config */
 
   /** Schema from val modules, immutable  */
 
-  /** The sha265 / hash of schema + config - if this changes users needs to reload */
+  /** The sha256 / hash of schema + config - if this changes users needs to reload */
 
   constructor(valModules, options) {
     this.valModules = valModules;
@@ -1399,8 +1398,46 @@ class ValOps {
     this.modulesErrors = null;
   }
   hash(input) {
+    if (typeof input === "object") {
+      return this.hashObject(input);
+    }
     return core.Internal.getSHA256Hash(textEncoder$1.encode(input));
   }
+  hashObject(obj) {
+    const collector = [];
+    this.collectObjectRecursive(obj, collector);
+    return core.Internal.getSHA256Hash(textEncoder$1.encode(collector.join("")));
+  }
+  collectObjectRecursive(item, collector) {
+    if (typeof item === "string") {
+      collector.push(`"`, item, `"`);
+      return;
+    } else if (typeof item === "number") {
+      collector.push(item.toString());
+      return;
+    } else if (typeof item === "object") {
+      if (Array.isArray(item)) {
+        collector.push("[");
+        for (let i = 0; i < item.length; i++) {
+          this.collectObjectRecursive(item[i], collector);
+          i !== item.length - 1 && collector.push(",");
+        }
+        collector.push("]");
+      } else {
+        collector.push("{");
+        const keys = Object.keys(item).sort();
+        keys.forEach((key, i) => {
+          collector.push(`"${key}":`);
+          this.collectObjectRecursive(item[key], collector);
+          i !== keys.length - 1 && collector.push(",");
+        });
+        collector.push("}");
+      }
+      return;
+    } else {
+      console.warn("Unknown type encountered when hashing object", typeof item, item);
+    }
+  }
 
   // #region stat
   /**
@@ -1414,7 +1451,7 @@ class ValOps {
    */
 
   // #region initTree
-  async initTree() {
+  async initSources() {
     if (this.baseSha === null || this.schemaSha === null || this.sources === null || this.schemas === null || this.modulesErrors === null) {
       const currentModulesErrors = [];
       const addModuleError = (message, index, path) => {
@@ -1508,50 +1545,43 @@ class ValOps {
     const {
       baseSha,
       schemaSha
-    } = await this.initTree();
+    } = await this.initSources();
     await this.onInit(baseSha, schemaSha);
   }
   async getBaseSources() {
-    return this.initTree().then(result => result.sources);
+    return this.initSources().then(result => result.sources);
   }
   async getSchemas() {
-    return this.initTree().then(result => result.schemas);
+    return this.initSources().then(result => result.schemas);
   }
   async getModuleErrors() {
-    return this.initTree().then(result => result.moduleErrors);
+    return this.initSources().then(result => result.moduleErrors);
   }
   async getBaseSha() {
-    return this.initTree().then(result => result.baseSha);
+    return this.initSources().then(result => result.baseSha);
   }
   async getSchemaSha() {
-    return this.initTree().then(result => result.schemaSha);
+    return this.initSources().then(result => result.schemaSha);
   }
 
   // #region analyzePatches
-  analyzePatches(patchesById) {
+  analyzePatches(sortedPatches) {
     const patchesByModule = {};
     const fileLastUpdatedByPatchId = {};
-    for (const [patchIdS, {
-      path,
-      patch,
-      createdAt: created_at
-    }] of Object.entries(patchesById)) {
-      const patchId = patchIdS;
-      for (const op of patch) {
+    for (const patch of sortedPatches) {
+      for (const op of patch.patch) {
         if (op.op === "file") {
-          fileLastUpdatedByPatchId[op.filePath] = patchId;
+          const filePath = op.filePath;
+          fileLastUpdatedByPatchId[filePath] = patch.patchId;
         }
+        const path = patch.path;
+        if (!patchesByModule[path]) {
+          patchesByModule[path] = [];
+        }
+        patchesByModule[path].push({
+          patchId: patch.patchId
+        });
       }
-      if (!patchesByModule[path]) {
-        patchesByModule[path] = [];
-      }
-      patchesByModule[path].push({
-        patchId,
-        createdAt: created_at
-      });
-    }
-    for (const path in patchesByModule) {
-      patchesByModule[path].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
     }
     return {
       patchesByModule,
@@ -1560,11 +1590,11 @@ class ValOps {
   }
 
   // #region getTree
-  async getTree(analysis) {
+  async getSources(analysis) {
     if (!analysis) {
       const {
         sources
-      } = await this.initTree();
+      } = await this.initSources();
       return {
         sources,
         errors: {}
@@ -1572,76 +1602,72 @@ class ValOps {
     }
     const {
       sources
-    } = await this.initTree();
+    } = await this.initSources();
     const patchedSources = {};
     const errors = {};
-    for (const [pathS, patches] of Object.entries(analysis.patchesByModule)) {
-      const path = pathS;
+    for (const patchData of analysis.patches) {
+      const path = patchData.path;
       if (!sources[path]) {
         if (!errors[path]) {
           errors[path] = [];
         }
-        errors[path].push(...patches.map(({
-          patchId
-        }) => ({
-          patchId,
-          invalidPath: true,
+        console.error("Module not found", path);
+        errors[path].push({
+          patchId: patchData.patchId,
           skipped: true,
-          error: new patch.PatchError(`Module at path: '${path}' not found`)
-        })));
+          error: new patch.PatchError(`Module not found`)
+        });
+        continue;
       }
-      patchedSources[path] = sources[path];
-      for (const {
-        patchId
-      } of patches) {
-        if (errors[path]) {
+      if (!patchedSources[path]) {
+        patchedSources[path] = sources[path];
+      }
+      const patchId = patchData.patchId;
+      if (errors[path]) {
+        console.error("Cannot apply patch: previous errors exists", path, errors[path]);
+        errors[path].push({
+          patchId: patchId,
+          skipped: true,
+          error: new patch.PatchError(`Cannot apply patch: previous errors exists`)
+        });
+      } else {
+        const applicableOps = [];
+        const fileFixOps = {};
+        for (const op of patchData.patch) {
+          if (op.op === "file") {
+            // NOTE: We insert the last patch_id that modify a file
+            // when constructing the url we use the patch id (and the file path)
+            // to fetch the right file
+            // NOTE: overwrite and use last patch_id if multiple patches modify the same file
+            fileFixOps[op.path.join("/")] = [{
+              op: "add",
+              path: op.path.concat(...(op.nestedFilePath || [])).concat("patch_id"),
+              value: patchId
+            }];
+          } else {
+            applicableOps.push(op);
+          }
+        }
+        const patchRes = patch.applyPatch(patch.deepClone(patchedSources[path]),
+        // applyPatch mutates the source. On add operations it adds more than once? There is something strange going on... deepClone seems to fix, but is that the right solution?
+        jsonOps, applicableOps.concat(...Object.values(fileFixOps)));
+        if (fp.result.isErr(patchRes)) {
+          console.error("Could not apply patch", JSON.stringify({
+            path,
+            patchId,
+            error: patchRes.error,
+            applicableOps
+          }, null, 2));
+          if (!errors[path]) {
+            errors[path] = [];
+          }
           errors[path].push({
             patchId: patchId,
-            skipped: true,
-            error: new patch.PatchError(`Cannot apply patch: previous errors exists`)
+            skipped: false,
+            error: patchRes.error
           });
         } else {
-          const patchData = analysis.patches[patchId];
-          if (!patchData) {
-            errors[path] = [{
-              patchId: patchId,
-              skipped: false,
-              error: new patch.PatchError(`Patch not found`)
-            }];
-            continue;
-          }
-          const applicableOps = [];
-          const fileFixOps = {};
-          for (const op of patchData.patch) {
-            if (op.op === "file") {
-              // NOTE: We insert the last patch_id that modify a file
-              // when constructing the url we use the patch id (and the file path)
-              // to fetch the right file
-              // NOTE: overwrite and use last patch_id if multiple patches modify the same file
-              fileFixOps[op.path.join("/")] = [{
-                op: "add",
-                path: op.path.concat(...(op.nestedFilePath || [])).concat("patch_id"),
-                value: patchId
-              }];
-            } else {
-              applicableOps.push(op);
-            }
-          }
-          const patchRes = patch.applyPatch(patch.deepClone(patchedSources[path]),
-          // applyPatch mutates the source. On add operations it will add multiple items? There is something strange going on. DeepClone seems to fix, but is that the right?
-          jsonOps, applicableOps.concat(...Object.values(fileFixOps)));
-          if (fp.result.isErr(patchRes)) {
-            if (!errors[path]) {
-              errors[path] = [];
-            }
-            errors[path].push({
-              patchId: patchId,
-              skipped: false,
-              error: patchRes.error
-            });
-          } else {
-            patchedSources[path] = patchRes.value;
-          }
+          patchedSources[path] = patchRes.value;
         }
       }
     }
@@ -1836,7 +1862,7 @@ class ValOps {
               actual: currentValueMetadata[field],
               expected: fieldMetadata
             },
-            fixes: ["image:replace-metadata"]
+            fixes: ["image:check-metadata"]
           }];
         }
       }
@@ -1879,14 +1905,14 @@ class ValOps {
       for (const {
         patchId
       } of patches) {
-        var _patchAnalysis$patche;
-        const patch$1 = (_patchAnalysis$patche = patchAnalysis.patches) === null || _patchAnalysis$patche === void 0 || (_patchAnalysis$patche = _patchAnalysis$patche[patchId]) === null || _patchAnalysis$patche === void 0 ? void 0 : _patchAnalysis$patche.patch;
-        if (!patch$1) {
+        const patchData = patchAnalysis.patches.find(p => p.patchId === patchId);
+        if (!patchData) {
           errors.push({
             message: `Analysis required non-existing patch: ${patchId}`
           });
           break;
         }
+        const patch$1 = patchData.patch;
         const sourceFileOps = patch$1.filter(op => op.op !== "file"); // file is not a valid source file op
         const patchRes = patch.applyPatch(tsSourceFile, tsOps, sourceFileOps);
         if (fp.result.isErr(patchRes)) {
@@ -2000,13 +2026,21 @@ class ValOps {
   }
 
   // #region createPatch
-  async createPatch(path, patchAnalysis, patch$1, authorId) {
-    const initTree = await this.initTree();
+  async createPatch(path, patch$1, parentRef, authorId) {
+    const initTree = await this.initSources();
     const schemas = initTree.schemas;
     const moduleErrors = initTree.moduleErrors;
     let sources = initTree.sources;
-    if (patchAnalysis) {
-      const tree = await this.getTree(patchAnalysis);
+    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({
+        omitPatch: false
+      });
+      const patchAnalysis = this.analyzePatches(patchOps.patches);
+      const tree = await this.getSources({
+        ...patchAnalysis,
+        ...patchOps
+      });
       sources = {
         ...sources,
         ...tree.sources
@@ -2017,27 +2051,30 @@ class ValOps {
     const moduleError = moduleErrors.find(e => e.path === path);
     if (moduleError) {
       console.error(`Cannot patch. Module at path: '${path}' has fatal errors: "${moduleError.message}"`);
-      return {
+      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) {
       console.error(`Cannot patch. Module source at path: '${path}' does not exist`);
-      return {
+      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 {
+      return fp.result.err({
+        errorType: "other",
         error: {
           message: `Cannot patch. Module schema at path: '${path}' does not exist`
         }
-      };
+      });
     }
     const sourceFileOps = [];
     const files = {};
@@ -2076,14 +2113,20 @@ class ValOps {
         }
       }
     }
-    const saveRes = await this.saveSourceFilePatch(path, sourceFileOps, authorId);
-    if (saveRes.error) {
-      console.error(`Could not save source file patch at path: '${path}'. Error: ${saveRes.error.message}`);
-      return {
+    const saveRes = await this.saveSourceFilePatch(path, patch$1, 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") {
+        return fp.result.err({
+          errorType: "patch-head-conflict"
+        });
+      }
+      return fp.result.err({
+        errorType: "other",
         error: saveRes.error
-      };
+      });
     }
-    const patchId = saveRes.patchId;
+    const patchId = saveRes.value.patchId;
     const saveFileRes = await Promise.all(Object.entries(files).map(async ([filePath, data]) => {
       if (data.error) {
         return {
@@ -2148,7 +2191,7 @@ class ValOps {
         const MaxRetries = 3;
         let lastRes;
         for (let i = 0; i < MaxRetries; i++) {
-          lastRes = await this.saveBase64EncodedBinaryFileFromPatch(filePath, patchId, data.value, type, metadataOps.metadata);
+          lastRes = await this.saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data.value, type, metadataOps.metadata);
           if (!lastRes.error) {
             return {
               filePath
@@ -2163,24 +2206,25 @@ class ValOps {
     }));
     const errors = saveFileRes.filter(f => !!f.error);
     if (errors.length > 0) {
-      return {
+      return fp.result.err({
+        errorType: "other",
         error: {
           message: "Could not save patch: " + errors.map(e => e.error.message).join(", ")
         }
-      };
+      });
     }
-    return {
+    return fp.result.ok({
       patchId,
       files: saveFileRes,
       createdAt: new Date().toISOString()
-    };
+    });
   }
 
   // #region abstract ops
 }
 function isOnlyFileCheckValidationError(validationError) {
   var _validationError$fixe;
-  if ((_validationError$fixe = validationError.fixes) !== null && _validationError$fixe !== void 0 && _validationError$fixe.every(f => f === "file:check-metadata" || f === "image:replace-metadata")) {
+  if ((_validationError$fixe = validationError.fixes) !== null && _validationError$fixe !== void 0 && _validationError$fixe.every(f => f === "file:check-metadata" || f === "image:check-metadata")) {
     return true;
   }
   return false;
@@ -2270,81 +2314,51 @@ function bufferFromDataUrl(dataUrl) {
   }
 }
 
-const JSONValueT = z__default["default"].lazy(() => z__default["default"].union([z__default["default"].string(), z__default["default"].number(), z__default["default"].boolean(), z__default["default"].null(), z__default["default"].array(JSONValueT), z__default["default"].record(JSONValueT)]));
-
-/**
- * Raw JSON patch operation.
- */
-const OperationJSONT = z__default["default"].discriminatedUnion("op", [z__default["default"].object({
-  op: z__default["default"].literal("add"),
-  path: z__default["default"].string(),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("remove"),
-  /**
-   * Must be non-root
-   */
-  path: z__default["default"].string()
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("replace"),
-  path: z__default["default"].string(),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("move"),
-  /**
-   * Must be non-root and not a proper prefix of "path".
-   */
-  from: z__default["default"].string(),
-  path: z__default["default"].string()
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("copy"),
-  from: z__default["default"].string(),
-  path: z__default["default"].string()
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("test"),
-  path: z__default["default"].string(),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("file"),
-  path: z__default["default"].string(),
-  filePath: z__default["default"].string(),
-  value: z__default["default"].string()
-}).strict()]);
-const PatchJSON = z__default["default"].array(OperationJSONT);
 /**
- * Raw JSON patch operation.
+ * Computes the changed patch parent references based on the current patches and the patch IDs to be deleted.
+ *
+ * NOTE: patches that will be deleted are not included in the changed patches, since they will be deleted any how.
+ *
+ * @param currentPatches - The array of current patches.
+ * @param deletePatchIds - The array of patch IDs to be deleted.
+ * @returns An object containing the changed patches with their corresponding parent references.
  */
-const OperationT = z__default["default"].discriminatedUnion("op", [z__default["default"].object({
-  op: z__default["default"].literal("add"),
-  path: z__default["default"].array(z__default["default"].string()),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("remove"),
-  path: z__default["default"].array(z__default["default"].string()).nonempty()
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("replace"),
-  path: z__default["default"].array(z__default["default"].string()),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("move"),
-  from: z__default["default"].array(z__default["default"].string()).nonempty(),
-  path: z__default["default"].array(z__default["default"].string())
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("copy"),
-  from: z__default["default"].array(z__default["default"].string()),
-  path: z__default["default"].array(z__default["default"].string())
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("test"),
-  path: z__default["default"].array(z__default["default"].string()),
-  value: JSONValueT
-}).strict(), z__default["default"].object({
-  op: z__default["default"].literal("file"),
-  path: z__default["default"].array(z__default["default"].string()),
-  filePath: z__default["default"].string(),
-  nestedFilePath: z__default["default"].array(z__default["default"].string()).optional(),
-  value: z__default["default"].string()
-}).strict()]);
-const Patch = z__default["default"].array(OperationT);
+function computeChangedPatchParentRefs(currentPatches, deletePatchIds) {
+  let lastNonDeletedPatchIndex = -1;
+  const changedPatches = {};
+  for (let i = 0; i < currentPatches.length; i++) {
+    const current = currentPatches[i];
+    if (
+    // skip all patches that will be deleted:
+    deletePatchIds.includes(current.patchId)) {
+      var _currentPatches;
+      if (
+      // skip change if the patch after is deleted anyway:
+      !deletePatchIds.includes((_currentPatches = currentPatches[i + 1]) === null || _currentPatches === void 0 ? void 0 : _currentPatches.patchId)) {
+        if (
+        // set next patch to point to head if it exists:
+        lastNonDeletedPatchIndex === -1 && currentPatches[i + 1]) {
+          changedPatches[currentPatches[i + 1].patchId] = {
+            type: "head",
+            headBaseSha: current.baseSha
+          };
+        } else if (
+        // set next patch to point to the last non-deleted patch:
+        currentPatches[lastNonDeletedPatchIndex] && currentPatches[i + 1]) {
+          changedPatches[currentPatches[i + 1].patchId] = {
+            type: "patch",
+            patchId: currentPatches[lastNonDeletedPatchIndex].patchId
+          };
+        }
+      }
+    } else {
+      lastNonDeletedPatchIndex = i;
+    }
+  }
+  return {
+    changedPatches
+  };
+}
 
 class ValOpsFS extends ValOps {
   static VAL_DIR = ".val";
@@ -2518,32 +2532,31 @@ class ValOpsFS extends ValOps {
       patchJsonFiles = this.host.readDirectory(patchesCacheDir, ["patch.json"], [], []);
     }
     const patches = {};
-    const errors = {};
-    const parsedPatchIds = patchJsonFiles.map(file => parseInt(fsPath__namespace["default"].basename(fsPath__namespace["default"].dirname(file)), 10)).sort();
-    for (const patchIdNum of parsedPatchIds) {
-      if (Number.isNaN(patchIdNum)) {
-        throw new Error("Could not parse patch id from file name. Files found: " + patchJsonFiles.join(", "));
-      }
-      const patchId = patchIdNum.toString();
-      if (includes && includes.length > 0 && !includes.includes(patchId)) {
-        continue;
-      }
-      const parsedFSPatchRes = this.parseJsonFile(this.getPatchFilePath(patchId), FSPatch);
-      let parsedFSPatchBaseRes = undefined;
-      if (this.host.fileExists(this.getPatchBaseFile(patchId))) {
-        parsedFSPatchBaseRes = this.parseJsonFile(this.getPatchBaseFile(patchId), FSPatchBase);
-      }
-      if (parsedFSPatchRes.error) {
-        errors[patchId] = parsedFSPatchRes.error;
-      } else if (parsedFSPatchBaseRes && parsedFSPatchBaseRes.error) {
-        errors[patchId] = parsedFSPatchBaseRes.error;
+    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]);
+    parsedUnsortedFsPatches.forEach(([dir, parsedPatch, parsedBase]) => {
+      if (parsedPatch.error) {
+        errors.push({
+          ...parsedPatch.error,
+          parentPatchId: dir
+        });
+      } else if (parsedBase && parsedBase.error) {
+        errors.push({
+          ...parsedBase.error,
+          parentPatchId: dir
+        });
       } else {
-        patches[patchId] = {
-          ...parsedFSPatchRes.data,
-          appliedAt: parsedFSPatchBaseRes ? parsedFSPatchBaseRes.data : null
+        if (includes && includes.length > 0 && !includes.includes(parsedPatch.data.patchId)) {
+          return;
+        }
+        patches[parsedPatch.data.patchId] = {
+          ...parsedPatch.data,
+          appliedAt: parsedBase ? parsedBase.data : null
         };
       }
-    }
+    });
+
+    // If there are patches, but no head. error
     if (Object.keys(errors).length > 0) {
       return {
         patches,
@@ -2554,36 +2567,52 @@ class ValOpsFS extends ValOps {
       patches
     };
   }
+  getParentPatchIdFromParentRef(parentRef) {
+    return parentRef.type === "head" ? "head" : parentRef.patchId;
+  }
   async fetchPatches(filters) {
+    const fetchPatchesRes = await this.fetchPatchesFromFS(!!filters.omitPatch);
+    const sortedPatches = this.createPatchChain(fetchPatchesRes.patches).filter(patchData => {
+      if (filters.authors && !(patchData.authorId === null || filters.authors.includes(patchData.authorId))) {
+        return false;
+      }
+      if (filters.moduleFilePaths && !filters.moduleFilePaths.includes(patchData.path)) {
+        return false;
+      }
+      return true;
+    }).map(patchData => {
+      if (filters.omitPatch) {
+        return {
+          ...patchData,
+          patch: undefined
+        };
+      }
+      return patchData;
+    });
+    return {
+      patches: sortedPatches,
+      errors: fetchPatchesRes.errors
+    };
+  }
+  async fetchPatchesFromFS(omitPath) {
     const patches = {};
-    const errors = {};
     const {
-      errors: allErrors,
+      errors,
       patches: allPatches
-    } = await this.readPatches(filters.patchIds);
-    if (allErrors && Object.keys(allErrors).length > 0) {
-      for (const [patchId, error] of Object.entries(allErrors)) {
-        console.error("Error reading patch", patchId, error);
-        errors[patchId] = error;
-      }
-    }
+    } = await this.readPatches();
     for (const [patchIdS, patch] of Object.entries(allPatches)) {
       const patchId = patchIdS;
-      if (filters.authors && !(patch.authorId === null || filters.authors.includes(patch.authorId))) {
-        continue;
-      }
-      if (filters.moduleFilePaths && !filters.moduleFilePaths.includes(patch.path)) {
-        continue;
-      }
       patches[patchId] = {
-        patch: filters.omitPatch ? undefined : patch.patch,
+        patch: omitPath ? undefined : patch.patch,
+        parentRef: patch.parentRef,
         path: patch.path,
+        baseSha: patch.baseSha,
         createdAt: patch.createdAt,
         authorId: patch.authorId,
         appliedAt: patch.appliedAt
       };
     }
-    if (errors && Object.keys(errors).length > 0) {
+    if (errors && errors.length > 0) {
       return {
         patches,
         errors
@@ -2594,6 +2623,33 @@ class ValOpsFS extends ValOps {
     };
   }
 
+  // #region createPatchChain
+  createPatchChain(unsortedPatchRecord) {
+    var _Object$entries$find;
+    // TODO: Error handling
+    const nextPatch = {};
+    Object.keys(unsortedPatchRecord).forEach(patchId => {
+      const patch = unsortedPatchRecord[patchId];
+      if (patch.parentRef.type === "head") {
+        nextPatch["head"] = patchId;
+      } else {
+        nextPatch[patch.parentRef.patchId] = patchId;
+      }
+    });
+    const sortedPatches = [];
+    let nextPatchId = (_Object$entries$find = Object.entries(unsortedPatchRecord).find(([, patch]) => patch.parentRef.type === "head")) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0];
+    while (!!nextPatchId && nextPatchId in unsortedPatchRecord) {
+      const patch = unsortedPatchRecord[nextPatchId];
+      delete patch["parentRef"];
+      sortedPatches.push({
+        ...patch,
+        patchId: nextPatchId
+      });
+      nextPatchId = nextPatch[nextPatchId];
+    }
+    return sortedPatches;
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parseJsonFile(filePath, parser) {
     if (!this.host.fileExists(filePath)) {
@@ -2668,38 +2724,47 @@ class ValOpsFS extends ValOps {
       };
     }
   }
-  async saveSourceFilePatch(path, patch, authorId) {
-    let fileId = Date.now();
+  async saveSourceFilePatch(path, patch, parentRef, authorId) {
+    const patchDir = this.getParentPatchIdFromParentRef(parentRef);
     try {
-      while (this.host.fileExists(this.getPatchFilePath(fileId.toString()))) {
-        // ensure unique file / patch id
-        fileId++;
-      }
-      const patchId = fileId.toString();
+      const baseSha = await this.getBaseSha();
+      const patchId = crypto.randomUUID();
       const data = {
         patch,
+        patchId,
+        parentRef,
         path,
         authorId,
+        baseSha,
         coreVersion: core.Internal.VERSION.core,
         createdAt: new Date().toISOString()
       };
-      this.host.writeUf8File(this.getPatchFilePath(patchId), JSON.stringify(data));
-      return {
+      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({
+          errorType: "other",
+          error: writeRes.error,
+          message: "Failed to write patch file"
+        });
+      }
+      return fp.result.ok({
         patchId
-      };
+      });
     } catch (err) {
       if (err instanceof Error) {
-        return {
-          error: {
-            message: err.message
-          }
-        };
+        return fp.result.err({
+          errorType: "other",
+          error: err,
+          message: err.message
+        });
       }
-      return {
-        error: {
-          message: "Unknown error"
-        }
-      };
+      return fp.result.err({
+        errorType: "other",
+        error: err,
+        message: "Unknown error"
+      });
     }
   }
   async getSourceFile(path) {
@@ -2737,9 +2802,10 @@ class ValOpsFS extends ValOps {
       };
     }
   }
-  async saveBase64EncodedBinaryFileFromPatch(filePath, patchId, data, _type, metadata) {
-    const patchFilePath = this.getBinaryFilePath(filePath, patchId);
-    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchId);
+  async saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, _type, metadata) {
+    const patchDir = this.getParentPatchIdFromParentRef(parentRef);
+    const patchFilePath = this.getBinaryFilePath(filePath, patchDir);
+    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDir);
     try {
       const buffer = bufferFromDataUrl(data);
       if (!buffer) {
@@ -2771,7 +2837,15 @@ class ValOpsFS extends ValOps {
     }
   }
   async getBase64EncodedBinaryFileMetadataFromPatch(filePath, type, patchId) {
-    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchId);
+    const patchDirRes = await this.getParentPatchIdFromPatchId(patchId);
+    if (fp.result.isErr(patchDirRes)) {
+      return {
+        errors: [{
+          message: "Failed to get patch dir from patch id"
+        }]
+      };
+    }
+    const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDirRes.value);
     if (!this.host.fileExists(metadataFilePath)) {
       return {
         errors: [{
@@ -2780,7 +2854,7 @@ class ValOpsFS extends ValOps {
         }]
       };
     }
-    const metadataParseRes = this.parseJsonFile(metadataFilePath, z.z.record(z.z.union([z.z.string(), z.z.number()])));
+    const metadataParseRes = this.parseJsonFile(metadataFilePath, zod.z.record(zod.z.union([zod.z.string(), zod.z.number()])));
     if (metadataParseRes.error) {
       return {
         errors: [metadataParseRes.error]
@@ -2807,7 +2881,11 @@ class ValOpsFS extends ValOps {
     };
   }
   async getBase64EncodedBinaryFileFromPatch(filePath, patchId) {
-    const absPath = this.getBinaryFilePath(filePath, patchId);
+    const patchDirRes = await this.getParentPatchIdFromPatchId(patchId);
+    if (!fp.result.isOk(patchDirRes)) {
+      return null;
+    }
+    const absPath = this.getBinaryFilePath(filePath, patchDirRes.value);
     if (!this.host.fileExists(absPath)) {
       return null;
     }
@@ -2815,30 +2893,62 @@ class ValOpsFS extends ValOps {
   }
   async deletePatches(patchIds) {
     const deleted = [];
-    let errors = null;
-    for (const patchId of patchIds) {
-      try {
-        this.host.deleteDir(this.getPatchDir(patchId));
-        deleted.push(patchId);
-      } catch (err) {
-        if (!errors) {
-          errors = {};
-        }
-        errors[patchId] = {
-          message: err instanceof Error ? err.message : "Unknown error"
-        };
-      }
-    }
-    if (errors) {
+    const patchDirMapRes = await this.getParentPatchIdFromPatchIdMap();
+    if (fp.result.isErr(patchDirMapRes)) {
       return {
-        deleted,
-        errors
+        error: {
+          message: "Failed to get patch dir map"
+        }
       };
     }
+    const currentPatches = this.createPatchChain((await this.fetchPatchesFromFS(false)).patches);
+    this.updateOrderedPatches(computeChangedPatchParentRefs(currentPatches, patchIds), patchDirMapRes.value, patchIds);
     return {
       deleted
     };
   }
+  updateOrderedPatches(updates, patchDirMap, deletePatchIds) {
+    for (const patchId of deletePatchIds) {
+      const patchDir = patchDirMap[patchId];
+      if (!patchDir) {
+        console.error("Could not find patch dir for patch id scheduled for deletion: ", patchId);
+        continue;
+      }
+      try {
+        this.host.deleteDir(this.getFullPatchDir(patchDir));
+      } catch (err) {
+        console.error("Failed to delete patch dir", err);
+      }
+    }
+    for (const [patchIdS, parentRef] of Object.entries(updates.changedPatches)) {
+      const prevParentPatchId = patchDirMap[patchIdS];
+      if (!prevParentPatchId) {
+        console.error("Could not find previous parent patch id for deleted patch id: ", patchIdS);
+        continue;
+      }
+      const newParentPatchId = parentRef.type === "head" ? "head" : parentRef.patchId;
+      const currentPatchDataRes = this.parseJsonFile(this.getPatchFilePath(prevParentPatchId), FSPatch);
+      if (currentPatchDataRes.error) {
+        console.error("Failed to parse patch file while fixing patch chain after deleted patch", {
+          updates
+        }, currentPatchDataRes.error);
+        continue;
+      }
+      const newPatchData = currentPatchDataRes.data;
+      newPatchData.parentRef = parentRef;
+      try {
+        this.host.writeUf8File(this.getPatchFilePath(prevParentPatchId), JSON.stringify(newPatchData));
+        if (this.host.directoryExists(this.getFullPatchDir(newParentPatchId))) {
+          this.host.deleteDir(this.getFullPatchDir(newParentPatchId));
+        }
+        this.host.moveDir(this.getFullPatchDir(prevParentPatchId), this.getFullPatchDir(newParentPatchId));
+      } catch (err) {
+        console.error("Failed fix patch chain after deleted patch", {
+          updates
+        }, err);
+      }
+    }
+  }
   async saveFiles(preparedCommit) {
     const updatedFiles = [];
     const errors = {};
@@ -2854,12 +2964,28 @@ class ValOpsFS extends ValOps {
         };
       }
     }
+    const patchIdToPatchDirMapRes = await this.getParentPatchIdFromPatchIdMap();
+    if (fp.result.isErr(patchIdToPatchDirMapRes)) {
+      return {
+        updatedFiles,
+        errors
+      };
+    }
+    const patchIdToPatchDirMap = patchIdToPatchDirMapRes.value;
     for (const [filePath, {
       patchId
     }] of Object.entries(preparedCommit.patchedBinaryFilesDescriptors)) {
       const absPath = fsPath__namespace["default"].join(this.rootDir, ...filePath.split("/"));
       try {
-        this.host.copyFile(this.getBinaryFilePath(filePath, patchId), absPath);
+        const patchDir = patchIdToPatchDirMap[patchId];
+        if (!patchDir) {
+          errors[absPath] = {
+            message: "Failed to find PatchDir for PatchId " + patchId,
+            filePath
+          };
+          continue;
+        }
+        this.host.copyFile(this.getBinaryFilePath(filePath, patchDir), absPath);
         updatedFiles.push(absPath);
       } catch (err) {
         errors[absPath] = {
@@ -2873,7 +2999,14 @@ class ValOpsFS extends ValOps {
         baseSha: await this.getBaseSha(),
         timestamp: new Date().toISOString()
       };
-      const absPath = this.getPatchBaseFile(patchId);
+      const patchDir = patchIdToPatchDirMap[patchId];
+      if (!patchDir) {
+        errors[`patchId:${patchId}`] = {
+          message: "Failed to find PatchDir for PatchId " + patchId
+        };
+        continue;
+      }
+      const absPath = this.getPatchBaseFile(patchDir);
       try {
         this.host.writeUf8File(absPath, JSON.stringify(appliedAt));
       } catch (err) {
@@ -2917,25 +3050,47 @@ class ValOpsFS extends ValOps {
     }
     return createMetadataFromBuffer(type, mimeType, buffer);
   }
+  async getParentPatchIdFromPatchId(patchId) {
+    // This is not great. If needed we should find a better way
+    const patches = await this.readPatches();
+    if (patches.errors || patches.error) {
+      console.error("Failed to read patches", JSON.stringify(patches));
+      return fp.result.err("failed-to-read-patches");
+    }
+    const patch = patches.patches[patchId];
+    if (!patch) {
+      console.error("Could not find patch with patchId: ", patchId);
+      return fp.result.err("patch-not-found");
+    }
+    return fp.result.ok(this.getParentPatchIdFromParentRef(patch.parentRef));
+  }
+  async getParentPatchIdFromPatchIdMap() {
+    const patches = await this.readPatches();
+    if (patches.errors || patches.error) {
+      console.error("Failed to read patches", JSON.stringify(patches));
+      return fp.result.err("failed-to-read-patches");
+    }
+    return fp.result.ok(Object.fromEntries(Object.entries(patches.patches).map(([patchId, value]) => [patchId, this.getParentPatchIdFromParentRef(value.parentRef)])));
+  }
 
   // #region fs file path helpers
   getPatchesDir() {
     return fsPath__namespace["default"].join(this.rootDir, ValOpsFS.VAL_DIR, "patches");
   }
-  getPatchDir(patchId) {
-    return fsPath__namespace["default"].join(this.getPatchesDir(), patchId);
+  getFullPatchDir(patchDir) {
+    return fsPath__namespace["default"].join(this.getPatchesDir(), patchDir);
   }
-  getBinaryFilePath(filePath, patchId) {
-    return fsPath__namespace["default"].join(this.getPatchDir(patchId), "files", filePath, fsPath__namespace["default"].basename(filePath));
+  getBinaryFilePath(filePath, patchDir) {
+    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, fsPath__namespace["default"].basename(filePath));
   }
-  getBinaryFileMetadataPath(filePath, patchId) {
-    return fsPath__namespace["default"].join(this.getPatchDir(patchId), "files", filePath, "metadata.json");
+  getBinaryFileMetadataPath(filePath, patchDir) {
+    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "files", filePath, "metadata.json");
   }
-  getPatchFilePath(patchId) {
-    return fsPath__namespace["default"].join(this.getPatchDir(patchId), "patch.json");
+  getPatchFilePath(patchDir) {
+    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "patch.json");
   }
-  getPatchBaseFile(patchId) {
-    return fsPath__namespace["default"].join(this.getPatchDir(patchId), "base.json");
+  getPatchBaseFile(patchDir) {
+    return fsPath__namespace["default"].join(this.getFullPatchDir(patchDir), "base.json");
   }
 }
 class FSOpsHost {
@@ -2949,6 +3104,9 @@ class FSOpsHost {
       });
     }
   }
+  moveDir(from, to) {
+    fs__default["default"].renameSync(from, to);
+  }
   directoryExists(path) {
     return ts__default["default"].sys.directoryExists(path);
   }
@@ -2970,6 +3128,37 @@ class FSOpsHost {
     });
     fs__default["default"].writeFileSync(path, data, "utf-8");
   }
+  tryWriteUf8File(path, data) {
+    try {
+      const parentDir = fsPath__namespace["default"].join(fsPath__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), {
+        recursive: false
+      });
+    } catch (e) {
+      return {
+        type: "error",
+        errorType: "dir-already-exists",
+        error: e
+      };
+    }
+    try {
+      fs__default["default"].writeFileSync(path, data, "utf-8");
+    } catch (e) {
+      return {
+        type: "error",
+        errorType: "failed-to-write-file",
+        error: e
+      };
+    }
+    return {
+      type: "success"
+    };
+  }
   writeBinaryFile(path, data) {
     fs__default["default"].mkdirSync(fsPath__namespace["default"].dirname(path), {
       recursive: true
@@ -2983,98 +3172,97 @@ class FSOpsHost {
     fs__default["default"].copyFileSync(from, to);
   }
 }
-const FSPatch = z.z.object({
-  path: z.z.string().refine(p => p.startsWith("/") && p.includes(".val."), "Path is not valid. Must start with '/' and include '.val.'"),
-  patch: Patch,
-  authorId: z.z.string().refine(p => true).nullable(),
-  createdAt: z.z.string().datetime(),
-  coreVersion: z.z.string().nullable() // TODO: use this to check if patch is compatible with current core version?
+const FSPatch = zod.z.object({
+  path: zod.z.string().refine(p => p.startsWith("/") && p.includes(".val."), "Path is not valid. Must start with '/' and include '.val.'"),
+  patch: internal.Patch,
+  patchId: zod.z.string(),
+  baseSha: zod.z.string(),
+  parentRef: internal.ParentRef,
+  authorId: zod.z.string().refine(p => true).nullable(),
+  createdAt: zod.z.string().datetime(),
+  coreVersion: zod.z.string().nullable() // TODO: use this to check if patch is compatible with current core version?
 });
-const FSPatchBase = z.z.object({
-  baseSha: z.z.string().refine(p => true),
-  timestamp: z.z.string().datetime()
+const FSPatchBase = zod.z.object({
+  baseSha: zod.z.string().refine(p => true),
+  timestamp: zod.z.string().datetime()
 });
 
 const textEncoder = new TextEncoder();
-const PatchId = z.z.string().refine(s => !!s); // TODO: validate
-const CommitSha = z.z.string().refine(s => !!s); // TODO: validate
-const BaseSha = z.z.string().refine(s => !!s); // TODO: validate
-const AuthorId = z.z.string().refine(s => !!s); // TODO: validate
-const ModuleFilePath = z.z.string().refine(s => !!s); // TODO: validate
-const Metadata = z.z.union([z.z.object({
-  mimeType: z.z.string(),
-  width: z.z.number(),
-  height: z.z.number()
-}), z.z.object({
-  mimeType: z.z.string()
+const PatchId = zod.z.string().refine(s => !!s); // TODO: validate
+const CommitSha = zod.z.string().refine(s => !!s); // TODO: validate
+zod.z.string().refine(s => !!s); // TODO: validate
+const AuthorId = zod.z.string().refine(s => !!s); // TODO: validate
+const ModuleFilePath = zod.z.string().refine(s => !!s); // TODO: validate
+const Metadata = zod.z.union([zod.z.object({
+  mimeType: zod.z.string(),
+  width: zod.z.number(),
+  height: zod.z.number()
+}), zod.z.object({
+  mimeType: zod.z.string()
 })]);
-const MetadataRes = z.z.object({
+const MetadataRes = zod.z.object({
   filePath: ModuleFilePath,
   metadata: Metadata,
-  type: z.z.union([z.z.literal("file"), z.z.literal("image")]).nullable()
+  type: zod.z.union([zod.z.literal("file"), zod.z.literal("image")]).nullable()
 });
-const BasePatchResponse = z.z.object({
+const BasePatchResponse = zod.z.object({
   path: ModuleFilePath,
   patchId: PatchId,
   authorId: AuthorId.nullable(),
-  createdAt: z.z.string().datetime(),
-  applied: z.z.object({
-    baseSha: BaseSha,
-    commitSha: CommitSha,
-    appliedAt: z.z.string().datetime()
-  }).nullable()
+  createdAt: zod.z.string().datetime(),
+  baseSha: zod.z.string()
 });
-const GetPatches = z.z.object({
-  patches: z.z.array(z.z.intersection(z.z.object({
-    patch: Patch.optional()
+const GetPatches = zod.z.object({
+  patches: zod.z.array(zod.z.intersection(zod.z.object({
+    patch: internal.Patch.optional()
   }), BasePatchResponse)),
-  errors: z.z.array(z.z.object({
+  errors: zod.z.array(zod.z.object({
     patchId: PatchId.optional(),
-    message: z.z.string()
+    message: zod.z.string()
   })).optional()
 });
-const FilesResponse = z.z.object({
-  files: z.z.array(z.z.union([z.z.object({
-    filePath: z.z.string(),
-    location: z.z.literal("patch"),
+const FilesResponse = zod.z.object({
+  files: zod.z.array(zod.z.union([zod.z.object({
+    filePath: zod.z.string(),
+    location: zod.z.literal("patch"),
     patchId: PatchId,
-    value: z.z.string()
-  }), z.z.object({
-    filePath: z.z.string(),
-    location: z.z.literal("repo"),
+    value: zod.z.string()
+  }), zod.z.object({
+    filePath: zod.z.string(),
+    location: zod.z.literal("repo"),
     commitSha: CommitSha,
-    value: z.z.string()
+    value: zod.z.string()
   })])),
-  errors: z.z.array(z.z.union([z.z.object({
-    filePath: z.z.string(),
-    location: z.z.literal("patch"),
+  errors: zod.z.array(zod.z.union([zod.z.object({
+    filePath: zod.z.string(),
+    location: zod.z.literal("patch"),
     patchId: PatchId,
-    message: z.z.string()
-  }), z.z.object({
-    filePath: z.z.string(),
-    location: z.z.literal("repo"),
+    message: zod.z.string()
+  }), zod.z.object({
+    filePath: zod.z.string(),
+    location: zod.z.literal("repo"),
     commitSha: CommitSha,
-    message: z.z.string()
+    message: zod.z.string()
   })])).optional()
 });
-const SavePatchResponse = z.z.object({
+const SavePatchResponse = zod.z.object({
   patchId: PatchId
 });
-const DeletePatchesResponse = z.z.object({
-  deleted: z.z.array(PatchId),
-  errors: z.z.array(z.z.object({
-    message: z.z.string(),
+const DeletePatchesResponse = zod.z.object({
+  deleted: zod.z.array(PatchId),
+  errors: zod.z.array(zod.z.object({
+    message: zod.z.string(),
     patchId: PatchId
   })).optional()
 });
-const SavePatchFileResponse = z.z.object({
+zod.z.object({
   patchId: PatchId,
   filePath: ModuleFilePath
 });
-const CommitResponse = z.z.object({
-  updatedFiles: z.z.array(z.z.string()),
+const CommitResponse = zod.z.object({
+  updatedFiles: zod.z.array(zod.z.string()),
   commit: CommitSha,
-  branch: z.z.string()
+  branch: zod.z.string()
 });
 class ValOpsHttp extends ValOps {
   constructor(hostUrl, project, commitSha,
@@ -3104,18 +3292,35 @@ class ValOpsHttp extends ValOps {
     }
     const currentBaseSha = await this.getBaseSha();
     const currentSchemaSha = await this.getSchemaSha();
-    const patchData = await this.fetchPatches({
+    const allPatchData = await this.fetchPatches({
       omitPatch: true,
       authors: undefined,
       patchIds: undefined,
       moduleFilePaths: undefined
     });
+    // We think these errors will be picked up else where (?), so we only return an error here if there are no patches
+    if (allPatchData.patches.length === 0) {
+      let message;
+      if (allPatchData.error) {
+        message = allPatchData.error.message;
+      } else if (allPatchData.errors && allPatchData.errors.length > 0) {
+        const errors = allPatchData.errors;
+        message = errors.map(error => error.message).join("");
+      }
+      if (message) {
+        message = `Could not get patches: ${message}`;
+        console.error(message);
+        return {
+          type: "error",
+          error: {
+            message
+          }
+        };
+      }
+    }
     const patches = [];
-    // TODO: use proper patch sequences when available:
-    for (const [patchId] of Object.entries(patchData.patches).sort(([, a], [, b]) => {
-      return a.createdAt.localeCompare(b.createdAt, undefined);
-    })) {
-      patches.push(patchId);
+    for (const patchData of allPatchData.patches) {
+      patches.push(patchData.patchId);
     }
     const webSocketNonceRes = await this.getWebSocketNonce(params.profileId);
     if (webSocketNonceRes.status === "error") {
@@ -3176,6 +3381,16 @@ class ValOpsHttp extends ValOps {
           }
         };
       }
+      const contentType = res.headers.get("Content-Type") || "";
+      if (contentType.startsWith("application/json")) {
+        const json = await res.json();
+        return {
+          status: "error",
+          error: {
+            message: "Could not get nonce." + (json.message || "Unexpected error (no error message). Status: " + res.status)
+          }
+        };
+      }
       return {
         status: "error",
         error: {
@@ -3201,8 +3416,8 @@ class ValOpsHttp extends ValOps {
     for (let i = 0; i < patchIds.length; i += chunkSize) {
       patchIdChunks.push(patchIds.slice(i, i + chunkSize));
     }
-    let allPatches = {};
-    let allErrors = {};
+    let allPatches = [];
+    let allErrors = [];
     if (patchIds === undefined || patchIds.length === 0) {
       return this.fetchPatchesInternal({
         patchIds: patchIds,
@@ -3225,10 +3440,7 @@ class ValOpsHttp extends ValOps {
         ...res.patches
       };
       if (res.errors) {
-        allErrors = {
-          ...allErrors,
-          ...res.errors
-        };
+        allErrors = [...allErrors, ...res.errors];
       }
     }
     return {
@@ -3264,27 +3476,23 @@ class ValOpsHttp extends ValOps {
         "Content-Type": "application/json"
       }
     }).then(async res => {
-      const patches = {};
+      const patches = [];
       if (res.ok) {
         const json = await res.json();
         const parsed = GetPatches.safeParse(json);
         if (parsed.success) {
+          const errors = [];
           const data = parsed.data;
-          const errors = {};
           for (const patchesRes of data.patches) {
-            patches[patchesRes.patchId] = {
-              path: patchesRes.path,
+            patches.push({
               authorId: patchesRes.authorId,
               createdAt: patchesRes.createdAt,
-              appliedAt: patchesRes.applied && {
-                baseSha: patchesRes.applied.baseSha,
-                timestamp: patchesRes.applied.appliedAt,
-                git: {
-                  commitSha: patchesRes.applied.commitSha
-                }
-              },
-              patch: patchesRes.patch
-            };
+              appliedAt: null,
+              patchId: patchesRes.patchId,
+              path: patchesRes.path,
+              baseSha: patchesRes.baseSha,
+              patch: filters.omitPatch ? undefined : patchesRes.patch
+            });
           }
           return {
             patches,
@@ -3306,7 +3514,8 @@ class ValOpsHttp extends ValOps {
       };
     });
   }
-  async saveSourceFilePatch(path, patch, authorId) {
+  async saveSourceFilePatch(path, patch, parentRef, authorId) {
+    const baseSha = await this.getBaseSha();
     return fetch(`${this.hostUrl}/v1/${this.project}/patches`, {
       method: "POST",
       headers: {
@@ -3317,78 +3526,53 @@ class ValOpsHttp extends ValOps {
         path,
         patch,
         authorId,
+        parentPatchId: parentRef.type === "patch" ? parentRef.patchId : null,
+        baseSha,
         commit: this.commitSha,
         branch: this.branch,
         coreVersion: core.Internal.VERSION.core
       })
     }).then(async res => {
+      var _res$headers$get;
       if (res.ok) {
         const parsed = SavePatchResponse.safeParse(await res.json());
         if (parsed.success) {
-          return {
+          return fp.result.ok({
             patchId: parsed.data.patchId
-          };
+          });
         }
-        return {
-          error: {
-            message: `Could not parse save patch response. Error: ${zodValidationError.fromError(parsed.error)}`
-          }
-        };
+        return fp.result.err({
+          errorType: "other",
+          message: `Could not parse save patch response. Error: ${zodValidationError.fromError(parsed.error)}`
+        });
       }
-      return {
-        error: {
-          message: "Could not save patch. HTTP error: " + res.status + " " + res.statusText
-        }
-      };
-    }).catch(e => {
-      return {
-        error: {
-          message: `Could save source file patch (connection error?): ${e instanceof Error ? e.message : e.toString()}`
-        }
-      };
-    });
-  }
-  async saveBase64EncodedBinaryFileFromPatch(filePath, patchId, data, type, metadata) {
-    return fetch(`${this.hostUrl}/v1/${this.project}/patches/${patchId}/files`, {
-      method: "POST",
-      headers: {
-        ...this.authHeaders,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        filePath: filePath,
-        data,
-        type,
-        metadata
-      })
-    }).then(async res => {
-      if (res.ok) {
-        const parsed = SavePatchFileResponse.safeParse(await res.json());
-        if (parsed.success) {
-          return {
-            patchId: parsed.data.patchId,
-            filePath: parsed.data.filePath
-          };
-        }
-        return {
-          error: {
-            message: `Could not parse save patch file response. Error: ${zodValidationError.fromError(parsed.error)}`
-          }
-        };
+      if (res.status === 409) {
+        return fp.result.err({
+          errorType: "patch-head-conflict",
+          message: "Conflict: " + (await res.text())
+        });
       }
-      return {
-        error: {
-          message: "Could not save patch file. 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")) {
+        const json = await res.json();
+        return fp.result.err({
+          errorType: "other",
+          message: json.message || "Unknown error"
+        });
+      }
+      return fp.result.err({
+        errorType: "other",
+        message: "Could not save patch. HTTP error: " + res.status + " " + res.statusText
+      });
     }).catch(e => {
-      return {
-        error: {
-          message: `Could save source binary file in patch (connection error?): ${e.toString()}`
-        }
-      };
+      return fp.result.err({
+        errorType: "other",
+        message: `Could save source file patch (connection error?): ${e instanceof Error ? e.message : e.toString()}`
+      });
     });
   }
+  async saveBase64EncodedBinaryFileFromPatch(filePath, parentRef, patchId, data, type, metadata) {
+    throw Error("TODO: implement");
+  }
   async getHttpFiles(files) {
     const params = new URLSearchParams();
     const stringifiedFiles = JSON.stringify({
@@ -3491,7 +3675,7 @@ class ValOpsHttp extends ValOps {
     const params = new URLSearchParams();
     params.set("file_path", filePath);
     try {
-      const metadataRes = await fetch(`${this.hostUrl}/v1/${this.project}/patches/${patchId}/metadata?${params}`, {
+      const metadataRes = await fetch(`${this.hostUrl}/v1/${this.project}/patches/${patchId}/files?${params}`, {
         headers: {
           ...this.authHeaders,
           "Content-Type": "application/json"
@@ -3593,7 +3777,7 @@ class ValOpsHttp extends ValOps {
   }
   async commit(prepared, message, committer, newBranch) {
     try {
-      var _res$headers$get;
+      var _res$headers$get2;
       const existingBranch = this.branch;
       const res = await fetch(`${this.hostUrl}/v1/${this.project}/commit`, {
         method: "POST",
@@ -3629,7 +3813,7 @@ class ValOpsHttp extends ValOps {
           }
         };
       }
-      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.isNotFastForward) {
           return {
@@ -4168,8 +4352,74 @@ const ValServer = (valModules, options, callbacks) => {
       }
     },
     //#region patches
-    "/patches/~": {
+    "/patches": {
+      PUT: async req => {
+        const cookies = req.cookies;
+        const auth = getAuth(cookies);
+        if (auth.error) {
+          return {
+            status: 401,
+            json: {
+              message: auth.error
+            }
+          };
+        }
+        if (serverOps instanceof ValOpsHttp && !("id" in auth)) {
+          return {
+            status: 401,
+            json: {
+              message: "Unauthorized"
+            }
+          };
+        }
+        const patches = req.body.patches;
+        const parentRef = req.body.parentRef;
+        const authorId = "id" in auth ? auth.id : null;
+        const newPatchIds = [];
+        for (const patch of patches) {
+          const createPatchRes = await serverOps.createPatch(patch.path, patch.patch, parentRef, authorId);
+          if (fp.result.isErr(createPatchRes)) {
+            if (createPatchRes.error.errorType === "patch-head-conflict") {
+              return {
+                status: 409,
+                json: {
+                  type: "patch-head-conflict",
+                  message: "Patch id conflict"
+                }
+              };
+            } else {
+              return {
+                status: 400,
+                json: {
+                  type: "patch-error",
+                  message: "Could not create patch",
+                  errors: {
+                    [patch.path]: [{
+                      error: {
+                        message: createPatchRes.error.error.message
+                      }
+                    }]
+                  }
+                }
+              };
+            }
+          } else {
+            newPatchIds.push(createPatchRes.value.patchId);
+          }
+        }
+        return {
+          status: 200,
+          json: {
+            newPatchIds,
+            parentRef: {
+              type: "patch",
+              patchId: newPatchIds[newPatchIds.length - 1]
+            }
+          }
+        };
+      },
       GET: async req => {
+        // TODO: Fix type error patchId is string somewhere and PatchId somewhere else
         const query = req.query;
         const cookies = req.cookies;
         const auth = getAuth(cookies);
@@ -4189,38 +4439,52 @@ const ValServer = (valModules, options, callbacks) => {
             }
           };
         }
+        const omit_patch = query.omit_patch === true;
         const authors = query.author;
-        const patches = await serverOps.fetchPatches({
+        const fetchedPatchesRes = await serverOps.fetchPatches({
           authors,
           patchIds: query.patch_id,
-          omitPatch: query.omit_patch === true,
+          omitPatch: omit_patch,
           moduleFilePaths: query.module_file_path
         });
-        if (patches.error) {
+        if (fetchedPatchesRes.error) {
           // Error is singular
-          console.error("Val: Failed to get patches", patches.errors);
+          console.error("Val: Failed to get patches", fetchedPatchesRes.error);
           return {
             status: 500,
             json: {
-              message: patches.error.message,
-              details: patches.error
+              message: fetchedPatchesRes.error.message,
+              error: fetchedPatchesRes.error
             }
           };
         }
-        if (patches.errors && Object.keys(patches.errors).length > 0) {
+        if (fetchedPatchesRes.errors && Object.keys(fetchedPatchesRes.errors).length > 0) {
           // Errors is plural. Different property than above.
-          console.error("Val: Failed to get patches", patches.errors);
+          console.error("Val: Failed to get patches", fetchedPatchesRes.errors);
           return {
             status: 500,
             json: {
               message: "Failed to get patches",
-              details: patches.errors
+              patchErrors: fetchedPatchesRes.errors
             }
           };
         }
+        const patches = [];
+        for (const [patchIdS, patchData] of Object.entries(fetchedPatchesRes.patches)) {
+          const patchId = patchIdS;
+          patches.push({
+            patchId,
+            ...patchData
+          });
+        }
+        // TODO: we should sort by parentRef instead:
+        patches.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
         return {
           status: 200,
-          json: patches
+          json: {
+            patches,
+            baseSha: await serverOps.getBaseSha()
+          }
         };
       },
       DELETE: async req => {
@@ -4251,7 +4515,10 @@ const ValServer = (valModules, options, callbacks) => {
             status: 500,
             json: {
               message: "Failed to delete patches",
-              details: deleteRes.errors
+              errors: Object.entries(deleteRes.errors).map(([id, error]) => ({
+                patchId: id,
+                ...error
+              }))
             }
           };
         }
@@ -4323,13 +4590,12 @@ const ValServer = (valModules, options, callbacks) => {
       }
     },
     // #region sources
-    "/sources": {
+    "/sources/~": {
       PUT: async req => {
-        var _body$patchIds;
         const query = req.query;
         const cookies = req.cookies;
-        const body = req.body;
-        const treePath = req.path || "";
+        // TODO: filter results by moduleFilePath
+        // const moduleFilePath = req.path || "";
         const auth = getAuth(cookies);
         if (auth.error) {
           return {
@@ -4358,149 +4624,81 @@ const ValServer = (valModules, options, callbacks) => {
             }
           };
         }
-        let tree;
-        let patchAnalysis = null;
-        let newPatchIds = undefined;
-        if (body !== null && body !== void 0 && body.patchIds && (body === null || body === void 0 || (_body$patchIds = body.patchIds) === null || _body$patchIds === void 0 ? void 0 : _body$patchIds.length) > 0 || body !== null && body !== void 0 && body.addPatches) {
-          // TODO: validate patches_sha
-          const patchIds = body === null || body === void 0 ? void 0 : body.patchIds;
-          const patchOps = patchIds && patchIds.length > 0 ? await serverOps.fetchPatches({
-            patchIds,
-            omitPatch: false
-          }) : {
-            patches: {}
-          };
-          if (patchOps.error) {
-            return {
-              status: 400,
-              json: {
-                message: "Failed to fetch patches: " + patchOps.error.message,
-                details: []
-              }
-            };
-          }
-          let patchErrors = undefined;
-          for (const [patchIdS, error] of Object.entries(patchOps.errors || {})) {
-            const patchId = patchIdS;
-            if (!patchErrors) {
-              patchErrors = {};
-            }
-            patchErrors[patchId] = {
-              message: error.message
-            };
-          }
-          // TODO: errors
-          patchAnalysis = serverOps.analyzePatches(patchOps.patches);
-          if (body !== null && body !== void 0 && body.addPatches) {
-            for (const addPatch of body.addPatches) {
-              const newPatchModuleFilePath = addPatch.path;
-              const newPatchOps = addPatch.patch;
-              const authorId = "id" in auth ? auth.id : null;
-              const createPatchRes = await serverOps.createPatch(newPatchModuleFilePath, {
-                ...patchAnalysis,
-                ...patchOps
-              }, newPatchOps, authorId);
-              if (createPatchRes.error) {
-                return {
-                  status: 500,
-                  json: {
-                    message: "Failed to create patch: " + createPatchRes.error.message,
-                    details: createPatchRes.error
-                  }
-                };
-              }
-              if (!newPatchIds) {
-                newPatchIds = [createPatchRes.patchId];
-              } else {
-                newPatchIds.push(createPatchRes.patchId);
-              }
-              patchOps.patches[createPatchRes.patchId] = {
-                path: newPatchModuleFilePath,
-                patch: newPatchOps,
-                authorId,
-                createdAt: createPatchRes.createdAt,
-                appliedAt: null
-              };
-              patchAnalysis.patchesByModule[newPatchModuleFilePath] = [...(patchAnalysis.patchesByModule[newPatchModuleFilePath] || []), {
-                patchId: createPatchRes.patchId
-              }];
-            }
-          }
-          tree = {
-            ...(await serverOps.getTree({
-              ...patchAnalysis,
-              ...patchOps
-            }))
-          };
-          if (query.validate_all) {
-            const allTree = await serverOps.getTree();
-            tree = {
-              sources: {
-                ...allTree.sources,
-                ...tree.sources
-              },
-              errors: {
-                ...allTree.errors,
-                ...tree.errors
-              }
-            };
+        const patchOps = await serverOps.fetchPatches({
+          patchIds: undefined,
+          omitPatch: false
+        });
+        const patchAnalysis = serverOps.analyzePatches(patchOps.patches);
+        let sourcesRes = await serverOps.getSources();
+        const onlyPatchedTreeModules = await serverOps.getSources({
+          ...patchAnalysis,
+          ...patchOps
+        });
+        sourcesRes = {
+          sources: {
+            ...sourcesRes.sources,
+            ...(onlyPatchedTreeModules.sources || {})
+          },
+          errors: {
+            ...sourcesRes.errors,
+            ...(onlyPatchedTreeModules.errors || {})
           }
-        } else {
-          tree = await serverOps.getTree();
-        }
+        };
         let sourcesValidation = {
           errors: {},
           files: {}
         };
         if (query.validate_sources || query.validate_binary_files) {
           const schemas = await serverOps.getSchemas();
-          sourcesValidation = await serverOps.validateSources(schemas, tree.sources);
+          sourcesValidation = await serverOps.validateSources(schemas, sourcesRes.sources);
 
-          // TODO: send validation errors
+          // TODO: send binary files validation errors
           if (query.validate_binary_files) {
-            await serverOps.validateFiles(schemas, tree.sources, sourcesValidation.files);
+            await serverOps.validateFiles(schemas, sourcesRes.sources, sourcesValidation.files);
           }
         }
         const schemaSha = await serverOps.getSchemaSha();
         const modules = {};
-        for (const [moduleFilePathS, module] of Object.entries(tree.sources)) {
+        for (const [moduleFilePathS, module] of Object.entries(sourcesRes.sources)) {
           const moduleFilePath = moduleFilePathS;
-          if (moduleFilePath.startsWith(treePath)) {
-            var _sourcesValidation$er;
+          if (moduleFilePath.startsWith(moduleFilePath)) {
+            var _patchAnalysis$patche, _sourcesValidation$er;
+            const skippedPatches = [];
+            const patchErrors = {};
+            const appliedPatches = ((_patchAnalysis$patche = patchAnalysis.patchesByModule[moduleFilePath]) === null || _patchAnalysis$patche === void 0 ? void 0 : _patchAnalysis$patche.map(p => p.patchId)) || [];
+            for (const {
+              patchId,
+              skipped,
+              error
+            } of ((_sourcesRes$errors = sourcesRes.errors) === null || _sourcesRes$errors === void 0 ? void 0 : _sourcesRes$errors[moduleFilePath]) || []) {
+              var _sourcesRes$errors;
+              if (skipped) {
+                skippedPatches.push(patchId);
+              } else if (error) {
+                patchErrors[patchId] = {
+                  message: error.message
+                };
+              } else {
+                // unsure what makes sense here
+                appliedPatches.push(patchId);
+              }
+            }
             modules[moduleFilePath] = {
               source: module,
-              patches: patchAnalysis && patchAnalysis.patchesByModule[moduleFilePath] ? {
-                applied: patchAnalysis.patchesByModule[moduleFilePath].map(p => p.patchId)
+              patches: appliedPatches.length > 0 || skippedPatches.length > 0 || Object.keys(patchErrors).length > 0 ? {
+                applied: appliedPatches,
+                skipped: skippedPatches.length > 0 ? skippedPatches : undefined,
+                errors: Object.keys(patchErrors).length > 0 ? patchErrors : undefined
               } : undefined,
               validationErrors: (_sourcesValidation$er = sourcesValidation.errors[moduleFilePath]) === null || _sourcesValidation$er === void 0 ? void 0 : _sourcesValidation$er.validations
             };
           }
         }
-        if (tree.errors && Object.keys(tree.errors).length > 0) {
-          const res = {
-            status: 400,
-            json: {
-              type: "patch-error",
-              schemaSha,
-              modules,
-              errors: Object.fromEntries(Object.entries(tree.errors).map(([key, value]) => [key, value.map(error => ({
-                patchId: error.patchId,
-                skipped: error.skipped,
-                error: {
-                  message: error.error.message
-                }
-              }))])),
-              message: "One or more patches failed to be applied"
-            }
-          };
-          return res;
-        }
         const res = {
           status: 200,
           json: {
             schemaSha,
-            modules,
-            newPatchIds
+            modules
           }
         };
         return res;
@@ -4519,8 +4717,8 @@ const ValServer = (valModules, options, callbacks) => {
             }
           };
         }
-        const PostSaveBody = z.z.object({
-          patchIds: z.z.array(z.z.string().refine(id => true // TODO:
+        const PostSaveBody = zod.z.object({
+          patchIds: zod.z.array(zod.z.string().refine(id => true // TODO:
           ))
         });
         const bodyRes = PostSaveBody.safeParse(body);
@@ -4768,18 +4966,18 @@ function getStateFromCookie(stateCookie) {
 function createStateCookie(state) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
-const ValAppJwtPayload = z.z.object({
-  sub: z.z.string(),
-  exp: z.z.number(),
-  project: z.z.string(),
-  org: z.z.string()
+const ValAppJwtPayload = zod.z.object({
+  sub: zod.z.string(),
+  exp: zod.z.number(),
+  project: zod.z.string(),
+  org: zod.z.string()
 });
-const IntegratedServerJwtPayload = z.z.object({
-  sub: z.z.string(),
-  exp: z.z.number(),
-  token: z.z.string(),
-  org: z.z.string(),
-  project: z.z.string()
+const IntegratedServerJwtPayload = zod.z.object({
+  sub: zod.z.string(),
+  exp: zod.z.number(),
+  token: zod.z.string(),
+  org: zod.z.string(),
+  project: zod.z.string()
 });
 async function withAuth(secret, cookies, errorMessageType, handler) {
   const cookie = cookies[internal.VAL_SESSION_COOKIE];
@@ -5236,21 +5434,21 @@ function createValApiRouter(route, valServerPromise, convert) {
           let isOptional = false;
           let isArray = false;
           // extract inner types:
-          if (innerType instanceof z.z.ZodOptional) {
+          if (innerType instanceof zod.z.ZodOptional) {
             isOptional = true;
             innerType = innerType.unwrap();
           }
-          if (innerType instanceof z.z.ZodArray) {
+          if (innerType instanceof zod.z.ZodArray) {
             isArray = true;
             innerType = innerType.element;
           }
           // convert boolean to union of literals true and false so we can parse it as a string
-          if (innerType instanceof z.z.ZodBoolean) {
-            innerType = z.z.union([z.z.literal("true"), z.z.literal("false")]).transform(arg => arg === "true");
+          if (innerType instanceof zod.z.ZodBoolean) {
+            innerType = zod.z.union([zod.z.literal("true"), zod.z.literal("false")]).transform(arg => arg === "true");
           }
           // re-build rules:
           let arrayCompatibleRule = innerType;
-          arrayCompatibleRule = z.z.array(innerType); // we always want to parse an array because we group the query params by into an array
+          arrayCompatibleRule = zod.z.array(innerType); // we always want to parse an array because we group the query params by into an array
           if (isOptional) {
             arrayCompatibleRule = arrayCompatibleRule.optional();
           }
@@ -5259,7 +5457,7 @@ function createValApiRouter(route, valServerPromise, convert) {
           }
           queryRules[key] = arrayCompatibleRule;
         }
-        const queryRes = z.z.object(queryRules).safeParse(actualQueryParams);
+        const queryRes = zod.z.object(queryRules).safeParse(actualQueryParams);
         if (!queryRes.success) {
           return zodErrorResult(queryRes.error, `invalid query params: (${JSON.stringify(actualQueryParams)})`);
         }
@@ -5333,7 +5531,7 @@ function getCookies(req, cookiesDef) {
       input[name.trim()] = value;
     }
   }
-  return z.z.object(cookiesDef).safeParse(input);
+  return zod.z.object(cookiesDef).safeParse(input);
 }
 
 /**
@@ -5452,7 +5650,7 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
   const remainingErrors = [];
   const patch$1 = [];
   for (const fix of validationError.fixes || []) {
-    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
+    if (fix === "image:check-metadata" || fix === "image:add-metadata") {
       const imageMetadata = await getImageMetadata();
       if (imageMetadata.width === undefined || imageMetadata.height === undefined) {
         remainingErrors.push({
@@ -5460,7 +5658,7 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
           message: "Failed to get image metadata",
           fixes: undefined
         });
-      } else if (fix === "image:replace-metadata") {
+      } else if (fix === "image:check-metadata") {
         const currentValue = validationError.value;
         const metadataIsCorrect =
         // metadata is a prop that is an object
@@ -5471,7 +5669,6 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
         "height" in currentValue.metadata && currentValue.metadata.height === imageMetadata.height &&
         // mimeType is correct
         "mimeType" in currentValue.metadata && currentValue.metadata.mimeType === imageMetadata.mimeType;
-
         // skips if the metadata is already correct
         if (!metadataIsCorrect) {
           if (apply) {
@@ -5479,6 +5676,8 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
               op: "replace",
               path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
               value: {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ...currentValue.metadata,
                 width: imageMetadata.width,
                 height: imageMetadata.height,
                 mimeType: imageMetadata.mimeType
@@ -5547,6 +5746,8 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
               op: "replace",
               path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
               value: {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ...currentValue.metadata,
                 ...(fileMetadata.mimeType ? {
                   mimeType: fileMetadata.mimeType
                 } : {})
@@ -5580,21 +5781,6 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
           }
         });
       }
-    } else if (fix === "fix:deprecated-richtext") {
-      if (!validationError.value) {
-        throw Error("Cannot fix richtext without a value");
-      }
-      patch$1.push({
-        op: "replace",
-        path: patch.sourceToPatchPath(sourcePath),
-        value: validationError.value
-      });
-    } else {
-      remainingErrors.push({
-        ...validationError,
-        message: `Unknown fix: ${fix}`,
-        fixes: undefined
-      });
     }
   }
   if (!validationError.fixes || validationError.fixes.length === 0) {
@@ -5606,8 +5792,6 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
   };
 }
 
-exports.Patch = Patch;
-exports.PatchJSON = PatchJSON;
 exports.Service = Service;
 exports.ValFSHost = ValFSHost;
 exports.ValModuleLoader = ValModuleLoader;