@valbuild/server 0.60.3 → 0.60.5

package/dist/valbuild-server.esm.js

@@ -1,6 +1,5 @@
 import { newQuickJSWASMModule } from 'quickjs-emscripten';
-import * as ts from 'typescript';
-import ts__default from 'typescript';
+import ts from 'typescript';
 import { result, pipe } from '@valbuild/core/fp';
 import { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG, RT_IMAGE_TAG, VAL_EXTENSION, derefPatch, Internal, Schema, deserializeSchema } from '@valbuild/core';
 import { deepEqual, isNotRoot, PatchError, parseAndValidateArrayIndex, applyPatch, JSONOps, sourceToPatchPath } from '@valbuild/core/patch';
@@ -43,12 +42,12 @@ function formatSyntaxErrorTree(tree, sourceFile) {
   return flatMapErrors(tree, error => formatSyntaxError(error, sourceFile));
 }
 function isLiteralPropertyName(name) {
-  return ts__default.isIdentifier(name) || ts__default.isStringLiteral(name) || ts__default.isNumericLiteral(name);
+  return ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name);
 }
 function validateObjectProperties(nodes) {
   const errors = [];
   for (const node of nodes) {
-    if (!ts__default.isPropertyAssignment(node)) {
+    if (!ts.isPropertyAssignment(node)) {
       errors.push(new ValSyntaxError("Object literal element must be property assignment", node));
     } else if (!isLiteralPropertyName(node.name)) {
       errors.push(new ValSyntaxError("Object literal element key must be an identifier or a literal", node));
@@ -65,7 +64,7 @@ function validateObjectProperties(nodes) {
  * validating its children.
  */
 function shallowValidateExpression(value) {
-  return ts__default.isStringLiteralLike(value) || ts__default.isNumericLiteral(value) || value.kind === ts__default.SyntaxKind.TrueKeyword || value.kind === ts__default.SyntaxKind.FalseKeyword || value.kind === ts__default.SyntaxKind.NullKeyword || ts__default.isArrayLiteralExpression(value) || ts__default.isObjectLiteralExpression(value) || isValFileMethodCall(value) ? undefined : new ValSyntaxError("Expression must be a literal or call c.file", value);
+  return ts.isStringLiteralLike(value) || ts.isNumericLiteral(value) || value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword || value.kind === ts.SyntaxKind.NullKeyword || ts.isArrayLiteralExpression(value) || ts.isObjectLiteralExpression(value) || isValFileMethodCall(value) ? undefined : new ValSyntaxError("Expression must be a literal or call c.file", value);
 }
 
 /**
@@ -77,19 +76,19 @@ function evaluateExpression(value) {
   // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
   // https://github.com/microsoft/TypeScript/blob/4b794fe1dd0d184d3f8f17e94d8187eace57c91e/src/compiler/types.ts#L2127-L2131
 
-  if (ts__default.isStringLiteralLike(value)) {
+  if (ts.isStringLiteralLike(value)) {
     return result.ok(value.text);
-  } else if (ts__default.isNumericLiteral(value)) {
+  } else if (ts.isNumericLiteral(value)) {
     return result.ok(Number(value.text));
-  } else if (value.kind === ts__default.SyntaxKind.TrueKeyword) {
+  } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
     return result.ok(true);
-  } else if (value.kind === ts__default.SyntaxKind.FalseKeyword) {
+  } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
     return result.ok(false);
-  } else if (value.kind === ts__default.SyntaxKind.NullKeyword) {
+  } else if (value.kind === ts.SyntaxKind.NullKeyword) {
     return result.ok(null);
-  } else if (ts__default.isArrayLiteralExpression(value)) {
+  } else if (ts.isArrayLiteralExpression(value)) {
     return result.all(value.elements.map(evaluateExpression));
-  } else if (ts__default.isObjectLiteralExpression(value)) {
+  } else if (ts.isObjectLiteralExpression(value)) {
     return pipe(validateObjectProperties(value.properties), result.flatMap(assignments => pipe(assignments.map(assignment => pipe(evaluateExpression(assignment.initializer), result.map(value => [assignment.name.text, value]))), result.all)), result.map(Object.fromEntries));
   } else if (isValFileMethodCall(value)) {
     return pipe(findValFileNodeArg(value), result.flatMap(ref => {
@@ -122,14 +121,14 @@ function findObjectPropertyAssignment(value, key) {
   }));
 }
 function isValFileMethodCall(node) {
-  return ts__default.isCallExpression(node) && ts__default.isPropertyAccessExpression(node.expression) && ts__default.isIdentifier(node.expression.expression) && node.expression.expression.text === "c" && node.expression.name.text === "file";
+  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "c" && node.expression.name.text === "file";
 }
 function findValFileNodeArg(node) {
   if (node.arguments.length === 0) {
     return result.err(new ValSyntaxError(`Invalid c.file() call: missing ref argument`, node));
   } else if (node.arguments.length > 2) {
     return result.err(new ValSyntaxError(`Invalid c.file() call: too many arguments ${node.arguments.length}}`, node));
-  } else if (!ts__default.isStringLiteral(node.arguments[0])) {
+  } else if (!ts.isStringLiteral(node.arguments[0])) {
     return result.err(new ValSyntaxError(`Invalid c.file() call: ref must be a string literal`, node));
   }
   const refNode = node.arguments[0];
@@ -141,7 +140,7 @@ function findValFileMetadataArg(node) {
   } else if (node.arguments.length > 2) {
     return result.err(new ValSyntaxError(`Invalid c.file() call: too many arguments ${node.arguments.length}}`, node));
   } else if (node.arguments.length === 2) {
-    if (!ts__default.isObjectLiteralExpression(node.arguments[1])) {
+    if (!ts.isObjectLiteralExpression(node.arguments[1])) {
       return result.err(new ValSyntaxError(`Invalid c.file() call: metadata must be a object literal`, node));
     }
     return result.ok(node.arguments[1]);
@@ -156,7 +155,7 @@ function findValFileMetadataArg(node) {
  */
 function validateInitializers(nodes) {
   for (const node of nodes) {
-    if (ts__default.isSpreadElement(node)) {
+    if (ts.isSpreadElement(node)) {
       return new ValSyntaxError("Unexpected spread element", node);
     }
   }
@@ -167,22 +166,22 @@ function isPath(node, path) {
   let currentNode = node;
   for (let i = path.length - 1; i > 0; --i) {
     const name = path[i];
-    if (!ts__default.isPropertyAccessExpression(currentNode)) {
+    if (!ts.isPropertyAccessExpression(currentNode)) {
       return false;
     }
-    if (!ts__default.isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+    if (!ts.isIdentifier(currentNode.name) || currentNode.name.text !== name) {
       return false;
     }
     currentNode = currentNode.expression;
   }
-  return ts__default.isIdentifier(currentNode) && currentNode.text === path[0];
+  return ts.isIdentifier(currentNode) && currentNode.text === path[0];
 }
 function validateArguments(node, validators) {
   return result.allV([node.arguments.length === validators.length ? result.voidOk : result.err(new ValSyntaxError(`Expected ${validators.length} arguments`, node)), ...node.arguments.slice(0, validators.length).map((argument, index) => validators[index](argument))]);
 }
 function analyzeDefaultExport(node) {
   const cDefine = node.expression;
-  if (!ts__default.isCallExpression(cDefine)) {
+  if (!ts.isCallExpression(cDefine)) {
     return result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
   }
   if (!isPath(cDefine.expression, ["c", "define"])) {
@@ -190,7 +189,7 @@ function analyzeDefaultExport(node) {
   }
   return pipe(validateArguments(cDefine, [id => {
     // TODO: validate ID value here?
-    if (!ts__default.isStringLiteralLike(id)) {
+    if (!ts.isStringLiteralLike(id)) {
       return result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
     }
     return result.voidOk;
@@ -208,7 +207,7 @@ function analyzeDefaultExport(node) {
 }
 function analyzeValModule(sourceFile) {
   const analysis = sourceFile.forEachChild(node => {
-    if (ts__default.isExportAssignment(node)) {
+    if (ts.isExportAssignment(node)) {
       return analyzeDefaultExport(node);
     }
   });
@@ -222,62 +221,62 @@ function isValidIdentifier(text) {
   if (text.length === 0) {
     return false;
   }
-  if (!ts__default.isIdentifierStart(text.charCodeAt(0), ts__default.ScriptTarget.ES2020)) {
+  if (!ts.isIdentifierStart(text.charCodeAt(0), ts.ScriptTarget.ES2020)) {
     return false;
   }
   for (let i = 1; i < text.length; ++i) {
-    if (!ts__default.isIdentifierPart(text.charCodeAt(i), ts__default.ScriptTarget.ES2020)) {
+    if (!ts.isIdentifierPart(text.charCodeAt(i), ts.ScriptTarget.ES2020)) {
       return false;
     }
   }
   return true;
 }
 function createPropertyAssignment(key, value) {
-  return ts__default.factory.createPropertyAssignment(isValidIdentifier(key) ? ts__default.factory.createIdentifier(key) : ts__default.factory.createStringLiteral(key), toExpression(value));
+  return ts.factory.createPropertyAssignment(isValidIdentifier(key) ? ts.factory.createIdentifier(key) : ts.factory.createStringLiteral(key), toExpression(value));
 }
 function createValFileReference(value) {
-  const args = [ts__default.factory.createStringLiteral(value[FILE_REF_PROP])];
+  const args = [ts.factory.createStringLiteral(value[FILE_REF_PROP])];
   if (value.metadata) {
     args.push(toExpression(value.metadata));
   }
-  return ts__default.factory.createCallExpression(ts__default.factory.createPropertyAccessExpression(ts__default.factory.createIdentifier("c"), ts__default.factory.createIdentifier("file")), undefined, args);
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), ts.factory.createIdentifier("file")), undefined, args);
 }
 function createValRichTextImage(value) {
-  const args = [ts__default.factory.createStringLiteral(value[FILE_REF_PROP])];
+  const args = [ts.factory.createStringLiteral(value[FILE_REF_PROP])];
   if (value.metadata) {
     args.push(toExpression(value.metadata));
   }
-  return ts__default.factory.createCallExpression(ts__default.factory.createPropertyAccessExpression(ts__default.factory.createPropertyAccessExpression(ts__default.factory.createIdentifier("c"), "rt"), ts__default.factory.createIdentifier("image")), undefined, args);
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), "rt"), ts.factory.createIdentifier("image")), undefined, args);
 }
 function createValLink(value) {
-  const args = [ts__default.factory.createStringLiteral(value.children[0]), toExpression({
+  const args = [ts.factory.createStringLiteral(value.children[0]), toExpression({
     href: value.href
   })];
-  return ts__default.factory.createCallExpression(ts__default.factory.createPropertyAccessExpression(ts__default.factory.createPropertyAccessExpression(ts__default.factory.createIdentifier("c"), "rt"), ts__default.factory.createIdentifier("link")), undefined, args);
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), "rt"), ts.factory.createIdentifier("link")), undefined, args);
 }
 function createValRichTextTaggedStringTemplate(value) {
   const {
     templateStrings: [head, ...others],
     exprs
   } = value;
-  const tag = ts__default.factory.createPropertyAccessExpression(ts__default.factory.createIdentifier("c"), ts__default.factory.createIdentifier("richtext"));
+  const tag = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), ts.factory.createIdentifier("richtext"));
   if (exprs.length > 0) {
-    return ts__default.factory.createTaggedTemplateExpression(tag, undefined, ts__default.factory.createTemplateExpression(ts__default.factory.createTemplateHead(head, head), others.map((s, i) => ts__default.factory.createTemplateSpan(toExpression(exprs[i]), i < others.length - 1 ? ts__default.factory.createTemplateMiddle(s, s) : ts__default.factory.createTemplateTail(s, s)))));
+    return ts.factory.createTaggedTemplateExpression(tag, undefined, ts.factory.createTemplateExpression(ts.factory.createTemplateHead(head, head), others.map((s, i) => ts.factory.createTemplateSpan(toExpression(exprs[i]), i < others.length - 1 ? ts.factory.createTemplateMiddle(s, s) : ts.factory.createTemplateTail(s, s)))));
   }
-  return ts__default.factory.createTaggedTemplateExpression(tag, undefined, ts__default.factory.createNoSubstitutionTemplateLiteral(head, head));
+  return ts.factory.createTaggedTemplateExpression(tag, undefined, ts.factory.createNoSubstitutionTemplateLiteral(head, head));
 }
 function toExpression(value) {
   if (typeof value === "string") {
     // TODO: Use configuration/heuristics to determine use of single quote or double quote
-    return ts__default.factory.createStringLiteral(value);
+    return ts.factory.createStringLiteral(value);
   } else if (typeof value === "number") {
-    return ts__default.factory.createNumericLiteral(value);
+    return ts.factory.createNumericLiteral(value);
   } else if (typeof value === "boolean") {
-    return value ? ts__default.factory.createTrue() : ts__default.factory.createFalse();
+    return value ? ts.factory.createTrue() : ts.factory.createFalse();
   } else if (value === null) {
-    return ts__default.factory.createNull();
+    return ts.factory.createNull();
   } else if (Array.isArray(value)) {
-    return ts__default.factory.createArrayLiteralExpression(value.map(toExpression));
+    return ts.factory.createArrayLiteralExpression(value.map(toExpression));
   } else if (typeof value === "object") {
     if (isValFileValue(value)) {
       if (isValRichTextImageValue(value)) {
@@ -289,24 +288,24 @@ function toExpression(value) {
     } else if (isValRichTextValue(value)) {
       return createValRichTextTaggedStringTemplate(value);
     }
-    return ts__default.factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => createPropertyAssignment(key, value)));
+    return ts.factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => createPropertyAssignment(key, value)));
   } else {
-    return ts__default.factory.createStringLiteral(value);
+    return ts.factory.createStringLiteral(value);
   }
 }
 
 // TODO: Choose newline based on project settings/heuristics/system default?
-const newLine = ts__default.NewLineKind.LineFeed;
+const newLine = ts.NewLineKind.LineFeed;
 // TODO: Handle indentation of printed code
-const printer = ts__default.createPrinter({
+const printer = ts.createPrinter({
   newLine: newLine
   // neverAsciiEscape: true,
 });
 function replaceNodeValue(document, node, value) {
-  const replacementText = printer.printNode(ts__default.EmitHint.Unspecified, toExpression(value), document);
-  const span = ts__default.createTextSpanFromBounds(node.getStart(document, false), node.end);
-  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default.textSpanEnd(span))}`;
-  return [document.update(newText, ts__default.createTextChangeRange(span, replacementText.length)), node];
+  const replacementText = printer.printNode(ts.EmitHint.Unspecified, toExpression(value), document);
+  const span = ts.createTextSpanFromBounds(node.getStart(document, false), node.end);
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, replacementText.length)), node];
 }
 function isIndentation(s) {
   for (let i = 0; i < s.length; ++i) {
@@ -318,7 +317,7 @@ function isIndentation(s) {
   return true;
 }
 function newLineStr(kind) {
-  if (kind === ts__default.NewLineKind.CarriageReturnLineFeed) {
+  if (kind === ts.NewLineKind.CarriageReturnLineFeed) {
     return "\r\n";
   } else {
     return "\n";
@@ -340,38 +339,38 @@ function insertAt(document, nodes, index, node) {
   let replacementText;
   if (nodes.length === 0) {
     // Replace entire range of nodes
-    replacementText = printer.printNode(ts__default.EmitHint.Unspecified, node, document);
-    span = ts__default.createTextSpanFromBounds(nodes.pos, nodes.end);
+    replacementText = printer.printNode(ts.EmitHint.Unspecified, node, document);
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
   } else if (index === nodes.length) {
     // Insert after last node
     const neighbor = nodes[nodes.length - 1];
-    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts__default.EmitHint.Unspecified, node, document)}`;
-    span = ts__default.createTextSpan(neighbor.end, 0);
+    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts.EmitHint.Unspecified, node, document)}`;
+    span = ts.createTextSpan(neighbor.end, 0);
   } else {
     // Insert before node
     const neighbor = nodes[index];
-    replacementText = `${printer.printNode(ts__default.EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
-    span = ts__default.createTextSpan(neighbor.getStart(document, true), 0);
+    replacementText = `${printer.printNode(ts.EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
+    span = ts.createTextSpan(neighbor.getStart(document, true), 0);
   }
-  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default.textSpanEnd(span))}`;
-  return document.update(newText, ts__default.createTextChangeRange(span, replacementText.length));
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return document.update(newText, ts.createTextChangeRange(span, replacementText.length));
 }
 function removeAt(document, nodes, index) {
   const node = nodes[index];
   let span;
   if (nodes.length === 1) {
-    span = ts__default.createTextSpanFromBounds(nodes.pos, nodes.end);
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
   } else if (index === nodes.length - 1) {
     // Remove until previous node
     const neighbor = nodes[index - 1];
-    span = ts__default.createTextSpanFromBounds(neighbor.end, node.end);
+    span = ts.createTextSpanFromBounds(neighbor.end, node.end);
   } else {
     // Remove before next node
     const neighbor = nodes[index + 1];
-    span = ts__default.createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
+    span = ts.createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
   }
-  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts__default.textSpanEnd(span))}`;
-  return [document.update(newText, ts__default.createTextChangeRange(span, 0)), node];
+  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, 0)), node];
 }
 function parseAndValidateArrayInsertIndex(key, nodes) {
   if (key === "-") {
@@ -413,9 +412,9 @@ function parseAndValidateArrayInboundsIndex(key, nodes) {
   }));
 }
 function replaceInNode(document, node, key, value) {
-  if (ts__default.isArrayLiteralExpression(node)) {
+  if (ts.isArrayLiteralExpression(node)) {
     return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => replaceNodeValue(document, node.elements[index], value)));
-  } else if (ts__default.isObjectLiteralExpression(node)) {
+  } else if (ts.isObjectLiteralExpression(node)) {
     return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
       if (!assignment) {
         return result.err(new PatchError("Cannot replace object element which does not exist"));
@@ -438,7 +437,7 @@ function replaceInNode(document, node, key, value) {
         }
         return replaceInNode(document,
         // TODO: creating a fake object here might not be right - seems to work though
-        ts__default.factory.createObjectLiteralExpression([ts__default.factory.createPropertyAssignment(key, metadataArgNode)]), key, value);
+        ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment(key, metadataArgNode)]), key, value);
       }));
     }
   } else {
@@ -453,9 +452,9 @@ function replaceAtPath(document, rootNode, path, value) {
   }
 }
 function getFromNode(node, key) {
-  if (ts__default.isArrayLiteralExpression(node)) {
+  if (ts.isArrayLiteralExpression(node)) {
     return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => node.elements[index]));
-  } else if (ts__default.isObjectLiteralExpression(node)) {
+  } else if (ts.isObjectLiteralExpression(node)) {
     return pipe(findObjectPropertyAssignment(node, key), result.map(assignment => assignment === null || assignment === void 0 ? void 0 : assignment.initializer));
   } else if (isValFileMethodCall(node)) {
     if (key === FILE_REF_PROP) {
@@ -485,9 +484,9 @@ function getAtPath(rootNode, path) {
   return pipe(path, result.flatMapReduce((node, key) => pipe(getFromNode(node, key), result.filterOrElse(childNode => childNode !== undefined, () => new PatchError("Path refers to non-existing object/array"))), rootNode));
 }
 function removeFromNode(document, node, key) {
-  if (ts__default.isArrayLiteralExpression(node)) {
+  if (ts.isArrayLiteralExpression(node)) {
     return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => removeAt(document, node.elements, index)));
-  } else if (ts__default.isObjectLiteralExpression(node)) {
+  } else if (ts.isObjectLiteralExpression(node)) {
     return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
       if (!assignment) {
         return result.err(new PatchError("Cannot replace object element which does not exist"));
@@ -533,9 +532,9 @@ function isValRichTextValue(value) {
   return !!(typeof value === "object" && value && VAL_EXTENSION in value && value[VAL_EXTENSION] === "richtext" && "templateStrings" in value && typeof value.templateStrings === "object" && Array.isArray(value.templateStrings));
 }
 function addToNode(document, node, key, value) {
-  if (ts__default.isArrayLiteralExpression(node)) {
+  if (ts.isArrayLiteralExpression(node)) {
     return pipe(parseAndValidateArrayInsertIndex(key, node.elements), result.map(index => [insertAt(document, node.elements, index, toExpression(value))]));
-  } else if (ts__default.isObjectLiteralExpression(node)) {
+  } else if (ts.isObjectLiteralExpression(node)) {
     if (key === FILE_REF_PROP) {
       return result.err(new PatchError("Cannot add a key ref to object"));
     }
@@ -657,7 +656,7 @@ function convertDataUrlToBase64(dataUrl) {
 }
 const patchSourceFile = (sourceFile, patch) => {
   if (typeof sourceFile === "string") {
-    return applyPatch(ts__default.createSourceFile("<val>", sourceFile, ts__default.ScriptTarget.ES2015), ops$1, patch);
+    return applyPatch(ts.createSourceFile("<val>", sourceFile, ts.ScriptTarget.ES2015), ops$1, patch);
   }
   return applyPatch(sourceFile, ops$1, patch);
 };
@@ -773,7 +772,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
   const {
     config,
     error
-  } = ts__default.readConfigFile(configFilePath, parseConfigHost.readFile.bind(parseConfigHost));
+  } = ts.readConfigFile(configFilePath, parseConfigHost.readFile.bind(parseConfigHost));
   if (error) {
     if (typeof error.messageText === "string") {
       throw Error(`Could not parse config file: ${configFilePath}. Error: ${error.messageText}`);
@@ -781,7 +780,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
     throw Error(`Could not parse config file: ${configFilePath}. Error: ${error.messageText.messageText}`);
   }
   const optionsOverrides = undefined;
-  const parsedConfigFile = ts__default.parseJsonConfigFileContent(config, parseConfigHost, rootDir, optionsOverrides, configFilePath);
+  const parsedConfigFile = ts.parseJsonConfigFileContent(config, parseConfigHost, rootDir, optionsOverrides, configFilePath);
   if (parsedConfigFile.errors.length > 0) {
     throw Error(`Could not parse config file: ${configFilePath}. Errors: ${parsedConfigFile.errors.map(e => e.messageText).join("\n")}`);
   }
@@ -790,7 +789,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
 
 class ValSourceFileHandler {
   constructor(projectRoot, compilerOptions, host = {
-    ...ts__default.sys,
+    ...ts.sys,
     writeFile: (fileName, data, encoding) => {
       fs.mkdirSync(path__default.dirname(fileName), {
         recursive: true
@@ -805,9 +804,9 @@ class ValSourceFileHandler {
   }
   getSourceFile(filePath) {
     const fileContent = this.host.readFile(filePath);
-    const scriptTarget = this.compilerOptions.target ?? ts__default.ScriptTarget.ES2020;
+    const scriptTarget = this.compilerOptions.target ?? ts.ScriptTarget.ES2020;
     if (fileContent) {
-      return ts__default.createSourceFile(filePath, fileContent, scriptTarget);
+      return ts.createSourceFile(filePath, fileContent, scriptTarget);
     }
   }
   writeSourceFile(sourceFile) {
@@ -819,7 +818,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts__default.resolveModuleName(requestedModuleName, path__default.isAbsolute(containingFilePath) ? containingFilePath : path__default.resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default.ModuleKind.ESNext);
+    const resolutionRes = ts.resolveModuleName(requestedModuleName, path__default.isAbsolute(containingFilePath) ? containingFilePath : path__default.resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts.ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -840,7 +839,7 @@ class ValModuleLoader {
   compilerOptions,
   // TODO: remove this?
   sourceFileHandler, host = {
-    ...ts__default.sys,
+    ...ts.sys,
     writeFile: (fileName, data, encoding) => {
       fs.mkdirSync(path__default.dirname(fileName), {
         recursive: true
@@ -1100,7 +1099,7 @@ export const IS_DEV = false;2
 }
 
 async function createService(projectRoot, opts, host = {
-  ...ts__default.sys,
+  ...ts.sys,
   writeFile: (fileName, data, encoding) => {
     fs.mkdirSync(path__default.dirname(fileName), {
       recursive: true
@@ -1752,7 +1751,11 @@ class ValServer {
     }
     let modules;
     if (commit) {
-      modules = await this.execCommit(patches, cookies);
+      const commitRes = await this.execCommit(patches, cookies);
+      if (commitRes.status !== 200) {
+        return commitRes;
+      }
+      modules = commitRes.json;
     } else {
       modules = await this.getPatchedModules(patches);
     }
@@ -1950,6 +1953,9 @@ function guessMimeTypeFromPath(filePath) {
   }
   return null;
 }
+function isCachedPatchFileOp(op) {
+  return !!(op.op === "file" && typeof op.filePath === "string" && op.value && typeof op.value === "object" && !Array.isArray(op.value) && "sha256" in op.value && typeof op.value.sha256 === "string");
+}
 
 const textEncoder = new TextEncoder();
 class LocalValServer extends ValServer {
@@ -2218,7 +2224,10 @@ class LocalValServer extends ValServer {
       this.host.rmFile(this.getPatchFilePath(patchId));
       await this.options.service.patch(moduleId, patch);
     }
-    return this.getPatchedModules(patches);
+    return {
+      status: 200,
+      json: await this.getPatchedModules(patches)
+    };
   }
 
   /* Bad requests on Local Server: */
@@ -2233,9 +2242,6 @@ class LocalValServer extends ValServer {
     return this.badRequest();
   }
 }
-function isCachedPatchFileOp(op) {
-  return !!(op.op === "file" && typeof op.filePath === "string" && op.value && typeof op.value === "object" && !Array.isArray(op.value) && "sha256" in op.value && typeof op.value.sha256 === "string");
-}
 
 function decodeJwt(token, secretKey) {
   const [headerBase64, payloadBase64, signatureBase64, ...rest] = token.split(".");
@@ -2313,8 +2319,12 @@ class RemoteFS {
   }
   async getPendingOperations() {
     const modified = {};
-    for (const modifiedFile in this.modifiedFiles) {
-      modified[modifiedFile] = this.data[modifiedFile].utf8Files[modifiedFile];
+    for (const modifiedFile of this.modifiedFiles) {
+      const {
+        directory,
+        filename
+      } = RemoteFS.parsePath(modifiedFile);
+      modified[modifiedFile] = this.data[directory].utf8Files[filename];
     }
     return {
       modified: modified,
@@ -2510,28 +2520,47 @@ class ProxyValServer extends ValServer {
           }
         };
       }
-      const params = `commit=${encodeURIComponent(commit)}`;
+      const params = `commit=${encodeURIComponent(commit)}&root=${encodeURIComponent(this.apiOptions.root || "/")}&cwd=${encodeURIComponent(this.cwd)}`;
       const url = new URL(`/v1/commit/${this.options.valName}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
 
-      // Creates a fresh copy of the fs. We cannot touch the existing fs, since we might still want to do
-      // other operations on it.
+      // Creates a fresh copy of the fs. We cannot touch the existing fs, since there might be parallel operations?
       // We could perhaps free up the other fs while doing this operation, but uncertain if we can actually do that and if that would actually help on memory.
-      // It is a concern we have, since we might be using quite a lot of memory when having the whole FS in memory. In particular because of images / files.
+      // It is a concern we have, since we might be using quite a lot of memory when having the whole FS in memory.
+      // NOTE that base64 values from patches are not part of the patches, nor are they part of the fs so at least we do not have to worry about them.
+      // This NOTE was written after we wrote the comments above. We are a bit uncertain whether memory usage should be a concern at this point.
       const remoteFS = new RemoteFS();
       const initRes = await this.initRemoteFS(commit, remoteFS, token);
       if (initRes.status !== 200) {
         return initRes;
       }
       const service = await createService(this.cwd, this.apiOptions, remoteFS);
-      for (const [, moduleId, patch] of patches) {
-        await service.patch(moduleId, patch);
+      // TODO: optimize patches, e.g. only take the last replace for a given thing, etc...
+      const patchIds = [];
+      const binaryFileUpdates = {};
+      for (const [patchId, moduleId, patch] of patches) {
+        const patchableOps = [];
+        for (const op of patch) {
+          if (isCachedPatchFileOp(op)) {
+            binaryFileUpdates[op.filePath] = op.value;
+          } else {
+            if (Internal.isFileOp(op)) {
+              throw new Error(`Val: Unexpected file operation (file: ${op.filePath}). This is likely a Val bug.`);
+            }
+            patchableOps.push(op);
+          }
+        }
+        await service.patch(moduleId, patchableOps);
+        patchIds.push(patchId);
       }
-      const fileOps = await remoteFS.getPendingOperations();
+      const sourceFileUpdates = await remoteFS.getPendingOperations();
       const fetchRes = await fetch(url, {
         method: "POST",
         headers: getAuthHeaders(token, "application/json"),
         body: JSON.stringify({
-          fileOps
+          sourceFileUpdates: sourceFileUpdates.modified,
+          binaryFileUpdates,
+          deletedFiles: sourceFileUpdates.deleted,
+          patchIds
         })
       });
       if (fetchRes.status === 200) {
@@ -2540,13 +2569,7 @@ class ProxyValServer extends ValServer {
           json: await fetchRes.json()
         };
       } else {
-        console.error("Failed to get patches", fetchRes.status, await fetchRes.text());
-        return {
-          status: fetchRes.status,
-          json: {
-            message: "Failed to get patches"
-          }
-        };
+        return createJsonError(fetchRes);
       }
     });
   }
@@ -2566,32 +2589,42 @@ class ProxyValServer extends ValServer {
       });
       if (fetchRes.status === 200) {
         const json = await fetchRes.json();
-        remoteFS.initializeWith(json);
+        let error = false;
+        if (typeof json !== "object") {
+          error = {
+            details: "Invalid response: not an object"
+          };
+        }
+        if (typeof json.git !== "object") {
+          error = {
+            details: "Invalid response: missing git"
+          };
+        }
+        if (typeof json.git.commit !== "string") {
+          error = {
+            details: "Invalid response: missing git.commit"
+          };
+        }
+        if (typeof json.directories !== "object" || json.directories === null) {
+          error = {
+            details: "Invalid response: missing directories"
+          };
+        }
+        if (error) {
+          return {
+            status: 500,
+            json: {
+              message: "Failed to fetch remote files",
+              ...error
+            }
+          };
+        }
+        remoteFS.initializeWith(json.directories);
         return {
           status: 200
         };
       } else {
-        try {
-          var _fetchRes$headers$get;
-          if ((_fetchRes$headers$get = fetchRes.headers.get("Content-Type")) !== null && _fetchRes$headers$get !== void 0 && _fetchRes$headers$get.includes("application/json")) {
-            const json = await fetchRes.json();
-            return {
-              status: fetchRes.status,
-              json: {
-                message: "Failed to fetch remote files",
-                details: json
-              }
-            };
-          }
-        } catch (err) {
-          console.error(err);
-        }
-        return {
-          status: fetchRes.status,
-          json: {
-            message: "Unknown failure while fetching remote files"
-          }
-        };
+        return createJsonError(fetchRes);
       }
     } catch (err) {
       return {
@@ -2800,11 +2833,13 @@ class ProxyValServer extends ValServer {
       token
     }) => {
       const patchIds = query.id || [];
-      const params = `${patchIds.map(id => `id=${encodeURIComponent(id)}`).join("&")}`;
-      const url = new URL(`/v1/patches/${this.options.valName}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
+      const url = new URL(`/v1/patches/${this.options.valName}/heads/${this.options.git.branch}/~`, this.options.valContentUrl);
       const fetchRes = await fetch(url, {
-        method: "GET",
-        headers: getAuthHeaders(token, "application/json")
+        method: "DELETE",
+        headers: getAuthHeaders(token, "application/json"),
+        body: JSON.stringify({
+          patches: patchIds
+        })
       });
       if (fetchRes.status === 200) {
         return {
@@ -2812,13 +2847,7 @@ class ProxyValServer extends ValServer {
           json: await fetchRes.json()
         };
       } else {
-        console.error("Failed to delete patches", fetchRes.status, await fetchRes.text());
-        return {
-          status: fetchRes.status,
-          json: {
-            message: "Failed to delete patches"
-          }
-        };
+        return createJsonError(fetchRes);
       }
     });
   }
@@ -2849,13 +2878,7 @@ class ProxyValServer extends ValServer {
           json: await fetchRes.json()
         };
       } else {
-        console.error("Failed to get patches", fetchRes.status, await fetchRes.text());
-        return {
-          status: fetchRes.status,
-          json: {
-            message: "Failed to get patches"
-          }
-        };
+        return createJsonError(fetchRes);
       }
     });
   }
@@ -2900,9 +2923,7 @@ class ProxyValServer extends ValServer {
           json: await fetchRes.json()
         };
       } else {
-        return {
-          status: fetchRes.status
-        };
+        return createJsonError(fetchRes);
       }
     });
   }
@@ -3063,6 +3084,22 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
+async function createJsonError(fetchRes) {
+  var _fetchRes$headers$get;
+  if ((_fetchRes$headers$get = fetchRes.headers.get("Content-Type")) !== null && _fetchRes$headers$get !== void 0 && _fetchRes$headers$get.includes("application/json")) {
+    return {
+      status: fetchRes.status,
+      json: await fetchRes.json()
+    };
+  }
+  console.error("Unexpected failure (did not get a json) - Val down?", fetchRes.status, await fetchRes.text());
+  return {
+    status: fetchRes.status,
+    json: {
+      message: "Unexpected failure (did not get a json) - Val down?"
+    }
+  };
+}
 function createStateCookie(state) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }