@valbuild/server 0.60.3 → 0.60.4

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

@@ -37,7 +37,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var z__default = /*#__PURE__*/_interopDefault(z);
@@ -73,12 +73,12 @@ function formatSyntaxErrorTree(tree, sourceFile) {
   return flatMapErrors(tree, error => formatSyntaxError(error, sourceFile));
 }
 function isLiteralPropertyName(name) {
-  return ts__namespace["default"].isIdentifier(name) || ts__namespace["default"].isStringLiteral(name) || ts__namespace["default"].isNumericLiteral(name);
+  return ts__default["default"].isIdentifier(name) || ts__default["default"].isStringLiteral(name) || ts__default["default"].isNumericLiteral(name);
 }
 function validateObjectProperties(nodes) {
   const errors = [];
   for (const node of nodes) {
-    if (!ts__namespace["default"].isPropertyAssignment(node)) {
+    if (!ts__default["default"].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));
@@ -95,7 +95,7 @@ function validateObjectProperties(nodes) {
  * validating its children.
  */
 function shallowValidateExpression(value) {
-  return ts__namespace["default"].isStringLiteralLike(value) || ts__namespace["default"].isNumericLiteral(value) || value.kind === ts__namespace["default"].SyntaxKind.TrueKeyword || value.kind === ts__namespace["default"].SyntaxKind.FalseKeyword || value.kind === ts__namespace["default"].SyntaxKind.NullKeyword || ts__namespace["default"].isArrayLiteralExpression(value) || ts__namespace["default"].isObjectLiteralExpression(value) || isValFileMethodCall(value) ? undefined : new ValSyntaxError("Expression must be a literal or call c.file", value);
+  return ts__default["default"].isStringLiteralLike(value) || ts__default["default"].isNumericLiteral(value) || value.kind === ts__default["default"].SyntaxKind.TrueKeyword || value.kind === ts__default["default"].SyntaxKind.FalseKeyword || value.kind === ts__default["default"].SyntaxKind.NullKeyword || ts__default["default"].isArrayLiteralExpression(value) || ts__default["default"].isObjectLiteralExpression(value) || isValFileMethodCall(value) ? undefined : new ValSyntaxError("Expression must be a literal or call c.file", value);
 }
 
 /**
@@ -107,19 +107,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__namespace["default"].isStringLiteralLike(value)) {
+  if (ts__default["default"].isStringLiteralLike(value)) {
     return fp.result.ok(value.text);
-  } else if (ts__namespace["default"].isNumericLiteral(value)) {
+  } else if (ts__default["default"].isNumericLiteral(value)) {
     return fp.result.ok(Number(value.text));
-  } else if (value.kind === ts__namespace["default"].SyntaxKind.TrueKeyword) {
+  } else if (value.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
     return fp.result.ok(true);
-  } else if (value.kind === ts__namespace["default"].SyntaxKind.FalseKeyword) {
+  } else if (value.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
     return fp.result.ok(false);
-  } else if (value.kind === ts__namespace["default"].SyntaxKind.NullKeyword) {
+  } else if (value.kind === ts__default["default"].SyntaxKind.NullKeyword) {
     return fp.result.ok(null);
-  } else if (ts__namespace["default"].isArrayLiteralExpression(value)) {
+  } else if (ts__default["default"].isArrayLiteralExpression(value)) {
     return fp.result.all(value.elements.map(evaluateExpression));
-  } else if (ts__namespace["default"].isObjectLiteralExpression(value)) {
+  } else if (ts__default["default"].isObjectLiteralExpression(value)) {
     return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => fp.pipe(assignments.map(assignment => fp.pipe(evaluateExpression(assignment.initializer), fp.result.map(value => [assignment.name.text, value]))), fp.result.all)), fp.result.map(Object.fromEntries));
   } else if (isValFileMethodCall(value)) {
     return fp.pipe(findValFileNodeArg(value), fp.result.flatMap(ref => {
@@ -152,14 +152,14 @@ function findObjectPropertyAssignment(value, key) {
   }));
 }
 function isValFileMethodCall(node) {
-  return ts__namespace["default"].isCallExpression(node) && ts__namespace["default"].isPropertyAccessExpression(node.expression) && ts__namespace["default"].isIdentifier(node.expression.expression) && node.expression.expression.text === "c" && node.expression.name.text === "file";
+  return ts__default["default"].isCallExpression(node) && ts__default["default"].isPropertyAccessExpression(node.expression) && ts__default["default"].isIdentifier(node.expression.expression) && node.expression.expression.text === "c" && node.expression.name.text === "file";
 }
 function findValFileNodeArg(node) {
   if (node.arguments.length === 0) {
     return fp.result.err(new ValSyntaxError(`Invalid c.file() call: missing ref argument`, node));
   } else if (node.arguments.length > 2) {
     return fp.result.err(new ValSyntaxError(`Invalid c.file() call: too many arguments ${node.arguments.length}}`, node));
-  } else if (!ts__namespace["default"].isStringLiteral(node.arguments[0])) {
+  } else if (!ts__default["default"].isStringLiteral(node.arguments[0])) {
     return fp.result.err(new ValSyntaxError(`Invalid c.file() call: ref must be a string literal`, node));
   }
   const refNode = node.arguments[0];
@@ -171,7 +171,7 @@ function findValFileMetadataArg(node) {
   } else if (node.arguments.length > 2) {
     return fp.result.err(new ValSyntaxError(`Invalid c.file() call: too many arguments ${node.arguments.length}}`, node));
   } else if (node.arguments.length === 2) {
-    if (!ts__namespace["default"].isObjectLiteralExpression(node.arguments[1])) {
+    if (!ts__default["default"].isObjectLiteralExpression(node.arguments[1])) {
       return fp.result.err(new ValSyntaxError(`Invalid c.file() call: metadata must be a object literal`, node));
     }
     return fp.result.ok(node.arguments[1]);
@@ -186,7 +186,7 @@ function findValFileMetadataArg(node) {
  */
 function validateInitializers(nodes) {
   for (const node of nodes) {
-    if (ts__namespace["default"].isSpreadElement(node)) {
+    if (ts__default["default"].isSpreadElement(node)) {
       return new ValSyntaxError("Unexpected spread element", node);
     }
   }
@@ -197,22 +197,22 @@ function isPath(node, path) {
   let currentNode = node;
   for (let i = path.length - 1; i > 0; --i) {
     const name = path[i];
-    if (!ts__namespace["default"].isPropertyAccessExpression(currentNode)) {
+    if (!ts__default["default"].isPropertyAccessExpression(currentNode)) {
       return false;
     }
-    if (!ts__namespace["default"].isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+    if (!ts__default["default"].isIdentifier(currentNode.name) || currentNode.name.text !== name) {
       return false;
     }
     currentNode = currentNode.expression;
   }
-  return ts__namespace["default"].isIdentifier(currentNode) && currentNode.text === path[0];
+  return ts__default["default"].isIdentifier(currentNode) && currentNode.text === path[0];
 }
 function validateArguments(node, validators) {
   return fp.result.allV([node.arguments.length === validators.length ? fp.result.voidOk : fp.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__namespace["default"].isCallExpression(cDefine)) {
+  if (!ts__default["default"].isCallExpression(cDefine)) {
     return fp.result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
   }
   if (!isPath(cDefine.expression, ["c", "define"])) {
@@ -220,7 +220,7 @@ function analyzeDefaultExport(node) {
   }
   return fp.pipe(validateArguments(cDefine, [id => {
     // TODO: validate ID value here?
-    if (!ts__namespace["default"].isStringLiteralLike(id)) {
+    if (!ts__default["default"].isStringLiteralLike(id)) {
       return fp.result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
     }
     return fp.result.voidOk;
@@ -238,7 +238,7 @@ function analyzeDefaultExport(node) {
 }
 function analyzeValModule(sourceFile) {
   const analysis = sourceFile.forEachChild(node => {
-    if (ts__namespace["default"].isExportAssignment(node)) {
+    if (ts__default["default"].isExportAssignment(node)) {
       return analyzeDefaultExport(node);
     }
   });
@@ -252,62 +252,62 @@ function isValidIdentifier(text) {
   if (text.length === 0) {
     return false;
   }
-  if (!ts__namespace["default"].isIdentifierStart(text.charCodeAt(0), ts__namespace["default"].ScriptTarget.ES2020)) {
+  if (!ts__default["default"].isIdentifierStart(text.charCodeAt(0), ts__default["default"].ScriptTarget.ES2020)) {
     return false;
   }
   for (let i = 1; i < text.length; ++i) {
-    if (!ts__namespace["default"].isIdentifierPart(text.charCodeAt(i), ts__namespace["default"].ScriptTarget.ES2020)) {
+    if (!ts__default["default"].isIdentifierPart(text.charCodeAt(i), ts__default["default"].ScriptTarget.ES2020)) {
       return false;
     }
   }
   return true;
 }
 function createPropertyAssignment(key, value) {
-  return ts__namespace["default"].factory.createPropertyAssignment(isValidIdentifier(key) ? ts__namespace["default"].factory.createIdentifier(key) : ts__namespace["default"].factory.createStringLiteral(key), toExpression(value));
+  return ts__default["default"].factory.createPropertyAssignment(isValidIdentifier(key) ? ts__default["default"].factory.createIdentifier(key) : ts__default["default"].factory.createStringLiteral(key), toExpression(value));
 }
 function createValFileReference(value) {
-  const args = [ts__namespace["default"].factory.createStringLiteral(value[core.FILE_REF_PROP])];
+  const args = [ts__default["default"].factory.createStringLiteral(value[core.FILE_REF_PROP])];
   if (value.metadata) {
     args.push(toExpression(value.metadata));
   }
-  return ts__namespace["default"].factory.createCallExpression(ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createIdentifier("c"), ts__namespace["default"].factory.createIdentifier("file")), undefined, args);
+  return ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createIdentifier("c"), ts__default["default"].factory.createIdentifier("file")), undefined, args);
 }
 function createValRichTextImage(value) {
-  const args = [ts__namespace["default"].factory.createStringLiteral(value[core.FILE_REF_PROP])];
+  const args = [ts__default["default"].factory.createStringLiteral(value[core.FILE_REF_PROP])];
   if (value.metadata) {
     args.push(toExpression(value.metadata));
   }
-  return ts__namespace["default"].factory.createCallExpression(ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createIdentifier("c"), "rt"), ts__namespace["default"].factory.createIdentifier("image")), undefined, args);
+  return ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createIdentifier("c"), "rt"), ts__default["default"].factory.createIdentifier("image")), undefined, args);
 }
 function createValLink(value) {
-  const args = [ts__namespace["default"].factory.createStringLiteral(value.children[0]), toExpression({
+  const args = [ts__default["default"].factory.createStringLiteral(value.children[0]), toExpression({
     href: value.href
   })];
-  return ts__namespace["default"].factory.createCallExpression(ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createIdentifier("c"), "rt"), ts__namespace["default"].factory.createIdentifier("link")), undefined, args);
+  return ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createIdentifier("c"), "rt"), ts__default["default"].factory.createIdentifier("link")), undefined, args);
 }
 function createValRichTextTaggedStringTemplate(value) {
   const {
     templateStrings: [head, ...others],
     exprs
   } = value;
-  const tag = ts__namespace["default"].factory.createPropertyAccessExpression(ts__namespace["default"].factory.createIdentifier("c"), ts__namespace["default"].factory.createIdentifier("richtext"));
+  const tag = ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createIdentifier("c"), ts__default["default"].factory.createIdentifier("richtext"));
   if (exprs.length > 0) {
-    return ts__namespace["default"].factory.createTaggedTemplateExpression(tag, undefined, ts__namespace["default"].factory.createTemplateExpression(ts__namespace["default"].factory.createTemplateHead(head, head), others.map((s, i) => ts__namespace["default"].factory.createTemplateSpan(toExpression(exprs[i]), i < others.length - 1 ? ts__namespace["default"].factory.createTemplateMiddle(s, s) : ts__namespace["default"].factory.createTemplateTail(s, s)))));
+    return ts__default["default"].factory.createTaggedTemplateExpression(tag, undefined, ts__default["default"].factory.createTemplateExpression(ts__default["default"].factory.createTemplateHead(head, head), others.map((s, i) => ts__default["default"].factory.createTemplateSpan(toExpression(exprs[i]), i < others.length - 1 ? ts__default["default"].factory.createTemplateMiddle(s, s) : ts__default["default"].factory.createTemplateTail(s, s)))));
   }
-  return ts__namespace["default"].factory.createTaggedTemplateExpression(tag, undefined, ts__namespace["default"].factory.createNoSubstitutionTemplateLiteral(head, head));
+  return ts__default["default"].factory.createTaggedTemplateExpression(tag, undefined, ts__default["default"].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__namespace["default"].factory.createStringLiteral(value);
+    return ts__default["default"].factory.createStringLiteral(value);
   } else if (typeof value === "number") {
-    return ts__namespace["default"].factory.createNumericLiteral(value);
+    return ts__default["default"].factory.createNumericLiteral(value);
   } else if (typeof value === "boolean") {
-    return value ? ts__namespace["default"].factory.createTrue() : ts__namespace["default"].factory.createFalse();
+    return value ? ts__default["default"].factory.createTrue() : ts__default["default"].factory.createFalse();
   } else if (value === null) {
-    return ts__namespace["default"].factory.createNull();
+    return ts__default["default"].factory.createNull();
   } else if (Array.isArray(value)) {
-    return ts__namespace["default"].factory.createArrayLiteralExpression(value.map(toExpression));
+    return ts__default["default"].factory.createArrayLiteralExpression(value.map(toExpression));
   } else if (typeof value === "object") {
     if (isValFileValue(value)) {
       if (isValRichTextImageValue(value)) {
@@ -319,24 +319,24 @@ function toExpression(value) {
     } else if (isValRichTextValue(value)) {
       return createValRichTextTaggedStringTemplate(value);
     }
-    return ts__namespace["default"].factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => createPropertyAssignment(key, value)));
+    return ts__default["default"].factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => createPropertyAssignment(key, value)));
   } else {
-    return ts__namespace["default"].factory.createStringLiteral(value);
+    return ts__default["default"].factory.createStringLiteral(value);
   }
 }
 
 // TODO: Choose newline based on project settings/heuristics/system default?
-const newLine = ts__namespace["default"].NewLineKind.LineFeed;
+const newLine = ts__default["default"].NewLineKind.LineFeed;
 // TODO: Handle indentation of printed code
-const printer = ts__namespace["default"].createPrinter({
+const printer = ts__default["default"].createPrinter({
   newLine: newLine
   // neverAsciiEscape: true,
 });
 function replaceNodeValue(document, node, value) {
-  const replacementText = printer.printNode(ts__namespace["default"].EmitHint.Unspecified, toExpression(value), document);
-  const span = ts__namespace["default"].createTextSpanFromBounds(node.getStart(document, false), node.end);
-  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__namespace["default"].textSpanEnd(span))}`;
-  return [document.update(newText, ts__namespace["default"].createTextChangeRange(span, replacementText.length)), node];
+  const replacementText = printer.printNode(ts__default["default"].EmitHint.Unspecified, toExpression(value), document);
+  const span = ts__default["default"].createTextSpanFromBounds(node.getStart(document, false), node.end);
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return [document.update(newText, ts__default["default"].createTextChangeRange(span, replacementText.length)), node];
 }
 function isIndentation(s) {
   for (let i = 0; i < s.length; ++i) {
@@ -348,7 +348,7 @@ function isIndentation(s) {
   return true;
 }
 function newLineStr(kind) {
-  if (kind === ts__namespace["default"].NewLineKind.CarriageReturnLineFeed) {
+  if (kind === ts__default["default"].NewLineKind.CarriageReturnLineFeed) {
     return "\r\n";
   } else {
     return "\n";
@@ -370,38 +370,38 @@ function insertAt(document, nodes, index, node) {
   let replacementText;
   if (nodes.length === 0) {
     // Replace entire range of nodes
-    replacementText = printer.printNode(ts__namespace["default"].EmitHint.Unspecified, node, document);
-    span = ts__namespace["default"].createTextSpanFromBounds(nodes.pos, nodes.end);
+    replacementText = printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document);
+    span = ts__default["default"].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__namespace["default"].EmitHint.Unspecified, node, document)}`;
-    span = ts__namespace["default"].createTextSpan(neighbor.end, 0);
+    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document)}`;
+    span = ts__default["default"].createTextSpan(neighbor.end, 0);
   } else {
     // Insert before node
     const neighbor = nodes[index];
-    replacementText = `${printer.printNode(ts__namespace["default"].EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
-    span = ts__namespace["default"].createTextSpan(neighbor.getStart(document, true), 0);
+    replacementText = `${printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
+    span = ts__default["default"].createTextSpan(neighbor.getStart(document, true), 0);
   }
-  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__namespace["default"].textSpanEnd(span))}`;
-  return document.update(newText, ts__namespace["default"].createTextChangeRange(span, replacementText.length));
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return document.update(newText, ts__default["default"].createTextChangeRange(span, replacementText.length));
 }
 function removeAt(document, nodes, index) {
   const node = nodes[index];
   let span;
   if (nodes.length === 1) {
-    span = ts__namespace["default"].createTextSpanFromBounds(nodes.pos, nodes.end);
+    span = ts__default["default"].createTextSpanFromBounds(nodes.pos, nodes.end);
   } else if (index === nodes.length - 1) {
     // Remove until previous node
     const neighbor = nodes[index - 1];
-    span = ts__namespace["default"].createTextSpanFromBounds(neighbor.end, node.end);
+    span = ts__default["default"].createTextSpanFromBounds(neighbor.end, node.end);
   } else {
     // Remove before next node
     const neighbor = nodes[index + 1];
-    span = ts__namespace["default"].createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
+    span = ts__default["default"].createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
   }
-  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts__namespace["default"].textSpanEnd(span))}`;
-  return [document.update(newText, ts__namespace["default"].createTextChangeRange(span, 0)), node];
+  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return [document.update(newText, ts__default["default"].createTextChangeRange(span, 0)), node];
 }
 function parseAndValidateArrayInsertIndex(key, nodes) {
   if (key === "-") {
@@ -443,9 +443,9 @@ function parseAndValidateArrayInboundsIndex(key, nodes) {
   }));
 }
 function replaceInNode(document, node, key, value) {
-  if (ts__namespace["default"].isArrayLiteralExpression(node)) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
     return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => replaceNodeValue(document, node.elements[index], value)));
-  } else if (ts__namespace["default"].isObjectLiteralExpression(node)) {
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
     return fp.pipe(findObjectPropertyAssignment(node, key), fp.result.flatMap(assignment => {
       if (!assignment) {
         return fp.result.err(new patch.PatchError("Cannot replace object element which does not exist"));
@@ -468,7 +468,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__namespace["default"].factory.createObjectLiteralExpression([ts__namespace["default"].factory.createPropertyAssignment(key, metadataArgNode)]), key, value);
+        ts__default["default"].factory.createObjectLiteralExpression([ts__default["default"].factory.createPropertyAssignment(key, metadataArgNode)]), key, value);
       }));
     }
   } else {
@@ -483,9 +483,9 @@ function replaceAtPath(document, rootNode, path, value) {
   }
 }
 function getFromNode(node, key) {
-  if (ts__namespace["default"].isArrayLiteralExpression(node)) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
     return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => node.elements[index]));
-  } else if (ts__namespace["default"].isObjectLiteralExpression(node)) {
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
     return fp.pipe(findObjectPropertyAssignment(node, key), fp.result.map(assignment => assignment === null || assignment === void 0 ? void 0 : assignment.initializer));
   } else if (isValFileMethodCall(node)) {
     if (key === core.FILE_REF_PROP) {
@@ -515,9 +515,9 @@ function getAtPath(rootNode, path) {
   return fp.pipe(path, fp.result.flatMapReduce((node, key) => fp.pipe(getFromNode(node, key), fp.result.filterOrElse(childNode => childNode !== undefined, () => new patch.PatchError("Path refers to non-existing object/array"))), rootNode));
 }
 function removeFromNode(document, node, key) {
-  if (ts__namespace["default"].isArrayLiteralExpression(node)) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
     return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => removeAt(document, node.elements, index)));
-  } else if (ts__namespace["default"].isObjectLiteralExpression(node)) {
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
     return fp.pipe(findObjectPropertyAssignment(node, key), fp.result.flatMap(assignment => {
       if (!assignment) {
         return fp.result.err(new patch.PatchError("Cannot replace object element which does not exist"));
@@ -563,9 +563,9 @@ function isValRichTextValue(value) {
   return !!(typeof value === "object" && value && core.VAL_EXTENSION in value && value[core.VAL_EXTENSION] === "richtext" && "templateStrings" in value && typeof value.templateStrings === "object" && Array.isArray(value.templateStrings));
 }
 function addToNode(document, node, key, value) {
-  if (ts__namespace["default"].isArrayLiteralExpression(node)) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
     return fp.pipe(parseAndValidateArrayInsertIndex(key, node.elements), fp.result.map(index => [insertAt(document, node.elements, index, toExpression(value))]));
-  } else if (ts__namespace["default"].isObjectLiteralExpression(node)) {
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
     if (key === core.FILE_REF_PROP) {
       return fp.result.err(new patch.PatchError("Cannot add a key ref to object"));
     }
@@ -687,7 +687,7 @@ function convertDataUrlToBase64(dataUrl) {
 }
 const patchSourceFile = (sourceFile, patch$1) => {
   if (typeof sourceFile === "string") {
-    return patch.applyPatch(ts__namespace["default"].createSourceFile("<val>", sourceFile, ts__namespace["default"].ScriptTarget.ES2015), ops$1, patch$1);
+    return patch.applyPatch(ts__default["default"].createSourceFile("<val>", sourceFile, ts__default["default"].ScriptTarget.ES2015), ops$1, patch$1);
   }
   return patch.applyPatch(sourceFile, ops$1, patch$1);
 };
@@ -803,7 +803,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
   const {
     config,
     error
-  } = ts__namespace["default"].readConfigFile(configFilePath, parseConfigHost.readFile.bind(parseConfigHost));
+  } = ts__default["default"].readConfigFile(configFilePath, parseConfigHost.readFile.bind(parseConfigHost));
   if (error) {
     if (typeof error.messageText === "string") {
       throw Error(`Could not parse config file: ${configFilePath}. Error: ${error.messageText}`);
@@ -811,7 +811,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
     throw Error(`Could not parse config file: ${configFilePath}. Error: ${error.messageText.messageText}`);
   }
   const optionsOverrides = undefined;
-  const parsedConfigFile = ts__namespace["default"].parseJsonConfigFileContent(config, parseConfigHost, rootDir, optionsOverrides, configFilePath);
+  const parsedConfigFile = ts__default["default"].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")}`);
   }
@@ -820,7 +820,7 @@ const getCompilerOptions = (rootDir, parseConfigHost) => {
 
 class ValSourceFileHandler {
   constructor(projectRoot, compilerOptions, host = {
-    ...ts__namespace["default"].sys,
+    ...ts__default["default"].sys,
     writeFile: (fileName, data, encoding) => {
       fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
         recursive: true
@@ -835,9 +835,9 @@ class ValSourceFileHandler {
   }
   getSourceFile(filePath) {
     const fileContent = this.host.readFile(filePath);
-    const scriptTarget = this.compilerOptions.target ?? ts__namespace["default"].ScriptTarget.ES2020;
+    const scriptTarget = this.compilerOptions.target ?? ts__default["default"].ScriptTarget.ES2020;
     if (fileContent) {
-      return ts__namespace["default"].createSourceFile(filePath, fileContent, scriptTarget);
+      return ts__default["default"].createSourceFile(filePath, fileContent, scriptTarget);
     }
   }
   writeSourceFile(sourceFile) {
@@ -849,7 +849,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts__namespace["default"].resolveModuleName(requestedModuleName, path__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : path__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__namespace["default"].ModuleKind.ESNext);
+    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : path__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -870,7 +870,7 @@ class ValModuleLoader {
   compilerOptions,
   // TODO: remove this?
   sourceFileHandler, host = {
-    ...ts__namespace["default"].sys,
+    ...ts__default["default"].sys,
     writeFile: (fileName, data, encoding) => {
       fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
         recursive: true
@@ -1130,7 +1130,7 @@ export const IS_DEV = false;2
 }
 
 async function createService(projectRoot, opts, host = {
-  ...ts__namespace["default"].sys,
+  ...ts__default["default"].sys,
   writeFile: (fileName, data, encoding) => {
     fs__default["default"].mkdirSync(path__namespace["default"].dirname(fileName), {
       recursive: true
@@ -1782,7 +1782,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);
     }
@@ -1980,6 +1984,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 {
@@ -2248,7 +2255,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: */
@@ -2263,9 +2273,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(".");
@@ -2343,8 +2350,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,
@@ -2384,7 +2395,7 @@ class RemoteFS {
         }
       }
     }
-    return ts__namespace.sys.readDirectory(rootDir, extensions, excludes, includes, depth).concat(files);
+    return ts__default["default"].sys.readDirectory(rootDir, extensions, excludes, includes, depth).concat(files);
   };
   writeFile = (filePath, data, encoding) => {
     // never write real fs
@@ -2421,7 +2432,7 @@ class RemoteFS {
   }
   fileExists = filePath => {
     var _this$data$directory;
-    if (ts__namespace.sys.fileExists(filePath)) {
+    if (ts__default["default"].sys.fileExists(filePath)) {
       return true;
     }
     const {
@@ -2432,7 +2443,7 @@ class RemoteFS {
     return !!((_this$data$directory = this.data[directory]) !== null && _this$data$directory !== void 0 && _this$data$directory.utf8Files[filename]);
   };
   readFile = filePath => {
-    const realFile = ts__namespace.sys.readFile(filePath);
+    const realFile = ts__default["default"].sys.readFile(filePath);
     if (realFile !== undefined) {
       return realFile;
     }
@@ -2448,8 +2459,8 @@ class RemoteFS {
     return content;
   };
   realpath(fullPath) {
-    if (ts__namespace.sys.fileExists(fullPath) && ts__namespace.sys.realpath) {
-      return ts__namespace.sys.realpath(fullPath);
+    if (ts__default["default"].sys.fileExists(fullPath) && ts__default["default"].sys.realpath) {
+      return ts__default["default"].sys.realpath(fullPath);
     }
     // TODO: this only works in a very limited way.
     // It does not support symlinks to symlinks nor symlinked directories for instance.
@@ -2540,28 +2551,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 (core.Internal.isFileOp(op)) {
+              throw new Error(`Val: Unexpected file operation (file: ${op.filePath}). This is likely a Val bug.`);
+            }
+            patchableOps.push(op);
+          }
+        }
+        await service.patch(moduleId, patchableOps);
+        patchIds.push(patchId);
       }
-      const 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) {
@@ -2570,13 +2600,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);
       }
     });
   }
@@ -2596,32 +2620,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 {
@@ -2830,11 +2864,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 {
@@ -2842,13 +2878,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);
       }
     });
   }
@@ -2879,13 +2909,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);
       }
     });
   }
@@ -2930,9 +2954,7 @@ class ProxyValServer extends ValServer {
           json: await fetchRes.json()
         };
       } else {
-        return {
-          status: fetchRes.status
-        };
+        return createJsonError(fetchRes);
       }
     });
   }
@@ -3093,6 +3115,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");
 }