@valbuild/server 0.15.0 → 0.16.0

package/dist/declarations/src/LocalValServer.d.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import { Service } from "./Service.js";
+import { ValServer } from "./ValServer.js";
+export type LocalValServerOptions = {
+    service: Service;
+};
+export declare class LocalValServer implements ValServer {
+    readonly options: LocalValServerOptions;
+    constructor(options: LocalValServerOptions);
+    session(_req: express.Request, res: express.Response): Promise<void>;
+    getIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    patchIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    private badRequest;
+    commit(req: express.Request, res: express.Response): Promise<void>;
+    authorize(req: express.Request, res: express.Response): Promise<void>;
+    callback(req: express.Request, res: express.Response): Promise<void>;
+    logout(req: express.Request, res: express.Response): Promise<void>;
+}

package/dist/declarations/src/SerializedModuleContent.d.ts

@@ -1,7 +1,22 @@
-import { type Source, type SerializedSchema } from "@valbuild/core";
-import { type SourcePath } from "@valbuild/core/src/val";
+import { type Source, type SerializedSchema, ValidationErrors } from "@valbuild/core";
+import { ModuleId, type SourcePath } from "@valbuild/core/src/val";
+export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module"];
 export type SerializedModuleContent = {
     source: Source;
     schema: SerializedSchema;
     path: SourcePath;
+    errors: false;
+} | {
+    source?: Source;
+    schema?: SerializedSchema;
+    path?: SourcePath;
+    errors: {
+        invalidModuleId?: ModuleId;
+        validation?: ValidationErrors;
+        fatal?: {
+            message: string;
+            stack?: string[];
+            type?: (typeof FATAL_ERROR_TYPES)[number];
+        }[];
+    };
 };

package/dist/declarations/src/Service.d.ts

@@ -1,5 +1,6 @@
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { Patch } from "@valbuild/core/patch";
+import { ValModuleLoader } from "./ValModuleLoader.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { IValFSHost } from "./ValFSHost.js";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
@@ -12,7 +13,7 @@ export type ServiceOptions = {
      */
     valConfigPath: string;
 };
-export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost): Promise<Service>;
+export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost, loader?: ValModuleLoader): Promise<Service>;
 export declare class Service {
     private readonly sourceFileHandler;
     private readonly runtime;

package/dist/declarations/src/createFixPatch.d.ts

@@ -0,0 +1,8 @@
+import { SourcePath, ValidationError } from "@valbuild/core";
+import { Patch } from "@valbuild/core/patch";
+export declare function createFixPatch(config: {
+    projectRoot: string;
+}, apply: boolean, sourcePath: SourcePath, validationError: ValidationError): Promise<{
+    patch: Patch;
+    remainingErrors: ValidationError[];
+} | undefined>;

package/dist/declarations/src/index.d.ts

@@ -10,3 +10,5 @@ export type { IValFSHost } from "./ValFSHost.js";
 export type { ValFS } from "./ValFS.js";
 export { patchSourceFile } from "./patchValFile.js";
 export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";
+export { LocalValServer } from "./LocalValServer.js";
+export { createFixPatch } from "./createFixPatch.js";

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

@@ -13,6 +13,7 @@ var express = require('express');
 var server = require('@valbuild/ui/server');
 var z = require('zod');
 var crypto = require('crypto');
+var sizeOf = require('image-size');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -22,6 +23,7 @@ var fs__default = /*#__PURE__*/_interopDefault(fs);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var z__default = /*#__PURE__*/_interopDefault(z);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
 
 class ValSyntaxError {
   constructor(message, node) {
@@ -571,41 +573,64 @@ globalThis.valModule = {
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
   source: valModule?.default && Internal.getRawSource(valModule?.default),
+  validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
+    valModule?.default && Internal.getValPath(valModule?.default) || "/",
+    valModule?.default && Internal.getRawSource(valModule?.default)
+  )
 };
 `;
     const result = context.evalCode(code,
     // Synthetic module name
     path__default["default"].join(path__default["default"].dirname(valConfigPath), "<val>"));
+    const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
-      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
-
-      throw new Error(`Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${error.stack ? error.stack : ""}`);
+      return {
+        errors: {
+          invalidModuleId: id,
+          fatal: [{
+            message: `${error.name || "Unknown error"}: ${error.message || "<no message>"}`,
+            stack: error.stack
+          }]
+        }
+      };
     } else {
       result.value.dispose();
       const valModule = context.getProp(context.global, "valModule").consume(context.dump);
-      const errors = [];
       if (!valModule) {
-        errors.push(`Could not find any modules at: ${id}`);
+        fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.schema)) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.source)) {
-          errors.push(`Expected val id: '${id}' to have a source`);
+          fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
-      if (errors.length > 0) {
-        throw Error(`While processing module of id: ${id}, we got the following errors:\n${errors.join("\n")}`);
+      let errors = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? id : undefined,
+          fatal: fatalErrors.map(message => ({
+            message
+          }))
+        };
+      }
+      if (valModule !== null && valModule !== void 0 && valModule.validation) {
+        errors = {
+          ...(errors ? errors : {}),
+          validation: valModule.validation
+        };
       }
       return {
         path: valModule.id,
-        // This might not be the asked id/path, however, that should be handled further up in the call chain
+        // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
         source: valModule.source,
-        schema: valModule.schema
+        schema: valModule.schema,
+        errors
       };
     }
   } finally {
@@ -752,7 +777,7 @@ class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts__default["default"].ModuleKind.ESNext,
-      target: ts__default["default"].ScriptTarget.ES2020 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
+      target: ts__default["default"].ScriptTarget.ES2015 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
       // moduleResolution: ts.ModuleResolutionKind.NodeNext,
       // target: ts.ScriptTarget.ES2020, // QuickJs runs in ES2020 so we must use that
     });
@@ -873,12 +898,11 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
 async function createService(projectRoot, opts, host = {
   ...ts__default["default"].sys,
   writeFile: fs__default["default"].writeFileSync
-}) {
+}, loader) {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
-  const loader = new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host);
   const module = await quickjsEmscripten.newQuickJSWASMModule();
-  const runtime = await newValQuickJSRuntime(module, loader);
+  const runtime = await newValQuickJSRuntime(module, loader || new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host));
   return new Service(opts, sourceFileHandler, runtime);
 }
 class Service {
@@ -891,12 +915,23 @@ class Service {
   }
   async get(moduleId, modulePath) {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
-    const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-    return {
-      path: [moduleId, resolved.path].join("."),
-      schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
-      source: resolved.source
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+      const sourcePath = [moduleId, resolved.path].join(".");
+      return {
+        path: sourcePath,
+        schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
+        source: resolved.source,
+        errors: valModule.errors && valModule.errors.validation && valModule.errors.validation[sourcePath] ? {
+          validation: valModule.errors.validation[sourcePath] ? {
+            [sourcePath]: valModule.errors.validation[sourcePath]
+          } : undefined,
+          fatal: valModule.errors && valModule.errors.fatal ? valModule.errors.fatal : undefined
+        } : false
+      };
+    } else {
+      return valModule;
+    }
   }
   async patch(moduleId, patch) {
     return patchValFile(moduleId, this.valConfigPath, patch, this.sourceFileHandler, this.runtime);
@@ -1514,10 +1549,120 @@ class ValFSHost {
   }
 }
 
+async function createFixPatch(config, apply, sourcePath, validationError) {
+  async function getImageMetadata() {
+    const maybeRef = validationError.value && typeof validationError.value === "object" && core.FILE_REF_PROP in validationError.value && typeof validationError.value[core.FILE_REF_PROP] === "string" ? validationError.value[core.FILE_REF_PROP] : undefined;
+    if (!maybeRef) {
+      // TODO:
+      throw Error("Cannot fix image without a file reference");
+    }
+    const localFile = path__default["default"].join(config.projectRoot, maybeRef);
+    const buffer = fs__default["default"].readFileSync(localFile);
+    const sha256 = await getSHA256Hash(buffer);
+    const imageSize = sizeOf__default["default"](buffer);
+    return {
+      ...imageSize,
+      sha256
+    };
+  }
+  const remainingErrors = [];
+  const patch$1 = [];
+  for (const fix of validationError.fixes || []) {
+    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
+      const imageMetadata = await getImageMetadata();
+      if (imageMetadata.width === undefined || imageMetadata.height === undefined || imageMetadata.sha256 === undefined) {
+        remainingErrors.push({
+          ...validationError,
+          message: "Failed to get image metadata",
+          fixes: undefined
+        });
+      } else if (fix === "image:replace-metadata") {
+        const currentValue = validationError.value;
+        const metadataIsCorrect =
+        // metadata is a prop that is an object
+        typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object" &&
+        // sha256 is correct
+        "sha256" in currentValue.metadata && currentValue.metadata.sha256 === imageMetadata.sha256 &&
+        // width is correct
+        "width" in currentValue.metadata && currentValue.metadata.width === imageMetadata.width &&
+        // height is correct
+        "height" in currentValue.metadata && currentValue.metadata.height === imageMetadata.height;
+
+        // skips if the metadata is already correct
+        if (!metadataIsCorrect) {
+          if (apply) {
+            patch$1.push({
+              op: "replace",
+              path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
+              value: {
+                width: imageMetadata.width,
+                height: imageMetadata.height,
+                sha256: imageMetadata.sha256
+              }
+            });
+          } else {
+            if (typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object") {
+              if (!("sha256" in currentValue.metadata) || currentValue.metadata.sha256 !== imageMetadata.sha256) {
+                remainingErrors.push({
+                  message: "Image metadata sha256 is incorrect! Found: " + ("sha256" in currentValue.metadata ? currentValue.metadata.sha256 : "<empty>") + ". Expected: " + imageMetadata.sha256 + ".",
+                  fixes: undefined
+                });
+              }
+              if (!("width" in currentValue.metadata) || currentValue.metadata.width !== imageMetadata.width) {
+                remainingErrors.push({
+                  message: "Image metadata width is incorrect! Found: " + ("width" in currentValue.metadata ? currentValue.metadata.width : "<empty>") + ". Expected: " + imageMetadata.width,
+                  fixes: undefined
+                });
+              }
+              if (!("height" in currentValue.metadata) || currentValue.metadata.height !== imageMetadata.height) {
+                remainingErrors.push({
+                  message: "Image metadata height is incorrect! Found: " + ("height" in currentValue.metadata ? currentValue.metadata.height : "<empty>") + ". Expected: " + imageMetadata.height,
+                  fixes: undefined
+                });
+              }
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: "Image metadata is not an object!",
+                fixes: undefined
+              });
+            }
+          }
+        }
+      } else if (fix === "image:add-metadata") {
+        patch$1.push({
+          op: "add",
+          path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
+          value: {
+            width: imageMetadata.width,
+            height: imageMetadata.height,
+            sha256: imageMetadata.sha256
+          }
+        });
+      }
+    }
+  }
+  if (!validationError.fixes || validationError.fixes.length === 0) {
+    remainingErrors.push(validationError);
+  }
+  return {
+    patch: patch$1,
+    remainingErrors
+  };
+}
+const getSHA256Hash = async bits => {
+  const hashBuffer = await crypto__default["default"].subtle.digest("SHA-256", bits);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hash = hashArray.map(item => item.toString(16).padStart(2, "0")).join("");
+  return hash;
+};
+
+exports.LocalValServer = LocalValServer;
 exports.Service = Service;
 exports.ValFSHost = ValFSHost;
 exports.ValModuleLoader = ValModuleLoader;
 exports.ValSourceFileHandler = ValSourceFileHandler;
+exports.createFixPatch = createFixPatch;
 exports.createRequestHandler = createRequestHandler;
 exports.createRequestListener = createRequestListener;
 exports.createService = createService;

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

@@ -13,6 +13,7 @@ var express = require('express');
 var server = require('@valbuild/ui/server');
 var z = require('zod');
 var crypto = require('crypto');
+var sizeOf = require('image-size');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -22,6 +23,7 @@ var fs__default = /*#__PURE__*/_interopDefault(fs);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var z__default = /*#__PURE__*/_interopDefault(z);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
 
 class ValSyntaxError {
   constructor(message, node) {
@@ -571,41 +573,64 @@ globalThis.valModule = {
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
   source: valModule?.default && Internal.getRawSource(valModule?.default),
+  validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
+    valModule?.default && Internal.getValPath(valModule?.default) || "/",
+    valModule?.default && Internal.getRawSource(valModule?.default)
+  )
 };
 `;
     const result = context.evalCode(code,
     // Synthetic module name
     path__default["default"].join(path__default["default"].dirname(valConfigPath), "<val>"));
+    const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
-      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
-
-      throw new Error(`Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${error.stack ? error.stack : ""}`);
+      return {
+        errors: {
+          invalidModuleId: id,
+          fatal: [{
+            message: `${error.name || "Unknown error"}: ${error.message || "<no message>"}`,
+            stack: error.stack
+          }]
+        }
+      };
     } else {
       result.value.dispose();
       const valModule = context.getProp(context.global, "valModule").consume(context.dump);
-      const errors = [];
       if (!valModule) {
-        errors.push(`Could not find any modules at: ${id}`);
+        fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.schema)) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.source)) {
-          errors.push(`Expected val id: '${id}' to have a source`);
+          fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
-      if (errors.length > 0) {
-        throw Error(`While processing module of id: ${id}, we got the following errors:\n${errors.join("\n")}`);
+      let errors = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? id : undefined,
+          fatal: fatalErrors.map(message => ({
+            message
+          }))
+        };
+      }
+      if (valModule !== null && valModule !== void 0 && valModule.validation) {
+        errors = {
+          ...(errors ? errors : {}),
+          validation: valModule.validation
+        };
       }
       return {
         path: valModule.id,
-        // This might not be the asked id/path, however, that should be handled further up in the call chain
+        // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
         source: valModule.source,
-        schema: valModule.schema
+        schema: valModule.schema,
+        errors
       };
     }
   } finally {
@@ -752,7 +777,7 @@ class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts__default["default"].ModuleKind.ESNext,
-      target: ts__default["default"].ScriptTarget.ES2020 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
+      target: ts__default["default"].ScriptTarget.ES2015 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
       // moduleResolution: ts.ModuleResolutionKind.NodeNext,
       // target: ts.ScriptTarget.ES2020, // QuickJs runs in ES2020 so we must use that
     });
@@ -873,12 +898,11 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
 async function createService(projectRoot, opts, host = {
   ...ts__default["default"].sys,
   writeFile: fs__default["default"].writeFileSync
-}) {
+}, loader) {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
-  const loader = new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host);
   const module = await quickjsEmscripten.newQuickJSWASMModule();
-  const runtime = await newValQuickJSRuntime(module, loader);
+  const runtime = await newValQuickJSRuntime(module, loader || new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host));
   return new Service(opts, sourceFileHandler, runtime);
 }
 class Service {
@@ -891,12 +915,23 @@ class Service {
   }
   async get(moduleId, modulePath) {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
-    const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-    return {
-      path: [moduleId, resolved.path].join("."),
-      schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
-      source: resolved.source
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+      const sourcePath = [moduleId, resolved.path].join(".");
+      return {
+        path: sourcePath,
+        schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
+        source: resolved.source,
+        errors: valModule.errors && valModule.errors.validation && valModule.errors.validation[sourcePath] ? {
+          validation: valModule.errors.validation[sourcePath] ? {
+            [sourcePath]: valModule.errors.validation[sourcePath]
+          } : undefined,
+          fatal: valModule.errors && valModule.errors.fatal ? valModule.errors.fatal : undefined
+        } : false
+      };
+    } else {
+      return valModule;
+    }
   }
   async patch(moduleId, patch) {
     return patchValFile(moduleId, this.valConfigPath, patch, this.sourceFileHandler, this.runtime);
@@ -1514,10 +1549,120 @@ class ValFSHost {
   }
 }
 
+async function createFixPatch(config, apply, sourcePath, validationError) {
+  async function getImageMetadata() {
+    const maybeRef = validationError.value && typeof validationError.value === "object" && core.FILE_REF_PROP in validationError.value && typeof validationError.value[core.FILE_REF_PROP] === "string" ? validationError.value[core.FILE_REF_PROP] : undefined;
+    if (!maybeRef) {
+      // TODO:
+      throw Error("Cannot fix image without a file reference");
+    }
+    const localFile = path__default["default"].join(config.projectRoot, maybeRef);
+    const buffer = fs__default["default"].readFileSync(localFile);
+    const sha256 = await getSHA256Hash(buffer);
+    const imageSize = sizeOf__default["default"](buffer);
+    return {
+      ...imageSize,
+      sha256
+    };
+  }
+  const remainingErrors = [];
+  const patch$1 = [];
+  for (const fix of validationError.fixes || []) {
+    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
+      const imageMetadata = await getImageMetadata();
+      if (imageMetadata.width === undefined || imageMetadata.height === undefined || imageMetadata.sha256 === undefined) {
+        remainingErrors.push({
+          ...validationError,
+          message: "Failed to get image metadata",
+          fixes: undefined
+        });
+      } else if (fix === "image:replace-metadata") {
+        const currentValue = validationError.value;
+        const metadataIsCorrect =
+        // metadata is a prop that is an object
+        typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object" &&
+        // sha256 is correct
+        "sha256" in currentValue.metadata && currentValue.metadata.sha256 === imageMetadata.sha256 &&
+        // width is correct
+        "width" in currentValue.metadata && currentValue.metadata.width === imageMetadata.width &&
+        // height is correct
+        "height" in currentValue.metadata && currentValue.metadata.height === imageMetadata.height;
+
+        // skips if the metadata is already correct
+        if (!metadataIsCorrect) {
+          if (apply) {
+            patch$1.push({
+              op: "replace",
+              path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
+              value: {
+                width: imageMetadata.width,
+                height: imageMetadata.height,
+                sha256: imageMetadata.sha256
+              }
+            });
+          } else {
+            if (typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object") {
+              if (!("sha256" in currentValue.metadata) || currentValue.metadata.sha256 !== imageMetadata.sha256) {
+                remainingErrors.push({
+                  message: "Image metadata sha256 is incorrect! Found: " + ("sha256" in currentValue.metadata ? currentValue.metadata.sha256 : "<empty>") + ". Expected: " + imageMetadata.sha256 + ".",
+                  fixes: undefined
+                });
+              }
+              if (!("width" in currentValue.metadata) || currentValue.metadata.width !== imageMetadata.width) {
+                remainingErrors.push({
+                  message: "Image metadata width is incorrect! Found: " + ("width" in currentValue.metadata ? currentValue.metadata.width : "<empty>") + ". Expected: " + imageMetadata.width,
+                  fixes: undefined
+                });
+              }
+              if (!("height" in currentValue.metadata) || currentValue.metadata.height !== imageMetadata.height) {
+                remainingErrors.push({
+                  message: "Image metadata height is incorrect! Found: " + ("height" in currentValue.metadata ? currentValue.metadata.height : "<empty>") + ". Expected: " + imageMetadata.height,
+                  fixes: undefined
+                });
+              }
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: "Image metadata is not an object!",
+                fixes: undefined
+              });
+            }
+          }
+        }
+      } else if (fix === "image:add-metadata") {
+        patch$1.push({
+          op: "add",
+          path: patch.sourceToPatchPath(sourcePath).concat("metadata"),
+          value: {
+            width: imageMetadata.width,
+            height: imageMetadata.height,
+            sha256: imageMetadata.sha256
+          }
+        });
+      }
+    }
+  }
+  if (!validationError.fixes || validationError.fixes.length === 0) {
+    remainingErrors.push(validationError);
+  }
+  return {
+    patch: patch$1,
+    remainingErrors
+  };
+}
+const getSHA256Hash = async bits => {
+  const hashBuffer = await crypto__default["default"].subtle.digest("SHA-256", bits);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hash = hashArray.map(item => item.toString(16).padStart(2, "0")).join("");
+  return hash;
+};
+
+exports.LocalValServer = LocalValServer;
 exports.Service = Service;
 exports.ValFSHost = ValFSHost;
 exports.ValModuleLoader = ValModuleLoader;
 exports.ValSourceFileHandler = ValSourceFileHandler;
+exports.createFixPatch = createFixPatch;
 exports.createRequestHandler = createRequestHandler;
 exports.createRequestListener = createRequestListener;
 exports.createService = createService;

package/dist/valbuild-server.esm.js

@@ -2,13 +2,14 @@ import { newQuickJSWASMModule } from 'quickjs-emscripten';
 import ts from 'typescript';
 import { result, pipe } from '@valbuild/core/fp';
 import { FILE_REF_PROP, derefPatch, Internal, Schema } from '@valbuild/core';
-import { deepEqual, isNotRoot, PatchError, parseAndValidateArrayIndex, applyPatch, parsePatch } from '@valbuild/core/patch';
+import { deepEqual, isNotRoot, PatchError, parseAndValidateArrayIndex, applyPatch, parsePatch, sourceToPatchPath } from '@valbuild/core/patch';
 import path from 'path';
 import fs from 'fs';
 import express, { Router } from 'express';
 import { createRequestHandler as createRequestHandler$1 } from '@valbuild/ui/server';
 import z, { z as z$1 } from 'zod';
 import crypto from 'crypto';
+import sizeOf from 'image-size';
 
 class ValSyntaxError {
   constructor(message, node) {
@@ -558,41 +559,64 @@ globalThis.valModule = {
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
   source: valModule?.default && Internal.getRawSource(valModule?.default),
+  validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
+    valModule?.default && Internal.getValPath(valModule?.default) || "/",
+    valModule?.default && Internal.getRawSource(valModule?.default)
+  )
 };
 `;
     const result = context.evalCode(code,
     // Synthetic module name
     path.join(path.dirname(valConfigPath), "<val>"));
+    const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
-      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
-
-      throw new Error(`Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${error.stack ? error.stack : ""}`);
+      return {
+        errors: {
+          invalidModuleId: id,
+          fatal: [{
+            message: `${error.name || "Unknown error"}: ${error.message || "<no message>"}`,
+            stack: error.stack
+          }]
+        }
+      };
     } else {
       result.value.dispose();
       const valModule = context.getProp(context.global, "valModule").consume(context.dump);
-      const errors = [];
       if (!valModule) {
-        errors.push(`Could not find any modules at: ${id}`);
+        fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.schema)) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.source)) {
-          errors.push(`Expected val id: '${id}' to have a source`);
+          fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
-      if (errors.length > 0) {
-        throw Error(`While processing module of id: ${id}, we got the following errors:\n${errors.join("\n")}`);
+      let errors = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? id : undefined,
+          fatal: fatalErrors.map(message => ({
+            message
+          }))
+        };
+      }
+      if (valModule !== null && valModule !== void 0 && valModule.validation) {
+        errors = {
+          ...(errors ? errors : {}),
+          validation: valModule.validation
+        };
       }
       return {
         path: valModule.id,
-        // This might not be the asked id/path, however, that should be handled further up in the call chain
+        // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
         source: valModule.source,
-        schema: valModule.schema
+        schema: valModule.schema,
+        errors
       };
     }
   } finally {
@@ -739,7 +763,7 @@ class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2020 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
+      target: ts.ScriptTarget.ES2015 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
       // moduleResolution: ts.ModuleResolutionKind.NodeNext,
       // target: ts.ScriptTarget.ES2020, // QuickJs runs in ES2020 so we must use that
     });
@@ -860,12 +884,11 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
 async function createService(projectRoot, opts, host = {
   ...ts.sys,
   writeFile: fs.writeFileSync
-}) {
+}, loader) {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
-  const loader = new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host);
   const module = await newQuickJSWASMModule();
-  const runtime = await newValQuickJSRuntime(module, loader);
+  const runtime = await newValQuickJSRuntime(module, loader || new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host));
   return new Service(opts, sourceFileHandler, runtime);
 }
 class Service {
@@ -878,12 +901,23 @@ class Service {
   }
   async get(moduleId, modulePath) {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
-    const resolved = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-    return {
-      path: [moduleId, resolved.path].join("."),
-      schema: resolved.schema instanceof Schema ? resolved.schema.serialize() : resolved.schema,
-      source: resolved.source
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+      const sourcePath = [moduleId, resolved.path].join(".");
+      return {
+        path: sourcePath,
+        schema: resolved.schema instanceof Schema ? resolved.schema.serialize() : resolved.schema,
+        source: resolved.source,
+        errors: valModule.errors && valModule.errors.validation && valModule.errors.validation[sourcePath] ? {
+          validation: valModule.errors.validation[sourcePath] ? {
+            [sourcePath]: valModule.errors.validation[sourcePath]
+          } : undefined,
+          fatal: valModule.errors && valModule.errors.fatal ? valModule.errors.fatal : undefined
+        } : false
+      };
+    } else {
+      return valModule;
+    }
   }
   async patch(moduleId, patch) {
     return patchValFile(moduleId, this.valConfigPath, patch, this.sourceFileHandler, this.runtime);
@@ -1501,4 +1535,112 @@ class ValFSHost {
   }
 }
 
-export { Service, ValFSHost, ValModuleLoader, ValSourceFileHandler, createRequestHandler, createRequestListener, createService, formatSyntaxErrorTree, getCompilerOptions, patchSourceFile };
+async function createFixPatch(config, apply, sourcePath, validationError) {
+  async function getImageMetadata() {
+    const maybeRef = validationError.value && typeof validationError.value === "object" && FILE_REF_PROP in validationError.value && typeof validationError.value[FILE_REF_PROP] === "string" ? validationError.value[FILE_REF_PROP] : undefined;
+    if (!maybeRef) {
+      // TODO:
+      throw Error("Cannot fix image without a file reference");
+    }
+    const localFile = path.join(config.projectRoot, maybeRef);
+    const buffer = fs.readFileSync(localFile);
+    const sha256 = await getSHA256Hash(buffer);
+    const imageSize = sizeOf(buffer);
+    return {
+      ...imageSize,
+      sha256
+    };
+  }
+  const remainingErrors = [];
+  const patch = [];
+  for (const fix of validationError.fixes || []) {
+    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
+      const imageMetadata = await getImageMetadata();
+      if (imageMetadata.width === undefined || imageMetadata.height === undefined || imageMetadata.sha256 === undefined) {
+        remainingErrors.push({
+          ...validationError,
+          message: "Failed to get image metadata",
+          fixes: undefined
+        });
+      } else if (fix === "image:replace-metadata") {
+        const currentValue = validationError.value;
+        const metadataIsCorrect =
+        // metadata is a prop that is an object
+        typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object" &&
+        // sha256 is correct
+        "sha256" in currentValue.metadata && currentValue.metadata.sha256 === imageMetadata.sha256 &&
+        // width is correct
+        "width" in currentValue.metadata && currentValue.metadata.width === imageMetadata.width &&
+        // height is correct
+        "height" in currentValue.metadata && currentValue.metadata.height === imageMetadata.height;
+
+        // skips if the metadata is already correct
+        if (!metadataIsCorrect) {
+          if (apply) {
+            patch.push({
+              op: "replace",
+              path: sourceToPatchPath(sourcePath).concat("metadata"),
+              value: {
+                width: imageMetadata.width,
+                height: imageMetadata.height,
+                sha256: imageMetadata.sha256
+              }
+            });
+          } else {
+            if (typeof currentValue === "object" && currentValue && "metadata" in currentValue && currentValue.metadata && typeof currentValue.metadata === "object") {
+              if (!("sha256" in currentValue.metadata) || currentValue.metadata.sha256 !== imageMetadata.sha256) {
+                remainingErrors.push({
+                  message: "Image metadata sha256 is incorrect! Found: " + ("sha256" in currentValue.metadata ? currentValue.metadata.sha256 : "<empty>") + ". Expected: " + imageMetadata.sha256 + ".",
+                  fixes: undefined
+                });
+              }
+              if (!("width" in currentValue.metadata) || currentValue.metadata.width !== imageMetadata.width) {
+                remainingErrors.push({
+                  message: "Image metadata width is incorrect! Found: " + ("width" in currentValue.metadata ? currentValue.metadata.width : "<empty>") + ". Expected: " + imageMetadata.width,
+                  fixes: undefined
+                });
+              }
+              if (!("height" in currentValue.metadata) || currentValue.metadata.height !== imageMetadata.height) {
+                remainingErrors.push({
+                  message: "Image metadata height is incorrect! Found: " + ("height" in currentValue.metadata ? currentValue.metadata.height : "<empty>") + ". Expected: " + imageMetadata.height,
+                  fixes: undefined
+                });
+              }
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: "Image metadata is not an object!",
+                fixes: undefined
+              });
+            }
+          }
+        }
+      } else if (fix === "image:add-metadata") {
+        patch.push({
+          op: "add",
+          path: sourceToPatchPath(sourcePath).concat("metadata"),
+          value: {
+            width: imageMetadata.width,
+            height: imageMetadata.height,
+            sha256: imageMetadata.sha256
+          }
+        });
+      }
+    }
+  }
+  if (!validationError.fixes || validationError.fixes.length === 0) {
+    remainingErrors.push(validationError);
+  }
+  return {
+    patch,
+    remainingErrors
+  };
+}
+const getSHA256Hash = async bits => {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", bits);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hash = hashArray.map(item => item.toString(16).padStart(2, "0")).join("");
+  return hash;
+};
+
+export { LocalValServer, Service, ValFSHost, ValModuleLoader, ValSourceFileHandler, createFixPatch, createRequestHandler, createRequestListener, createService, formatSyntaxErrorTree, getCompilerOptions, patchSourceFile };

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",
@@ -25,9 +25,10 @@
     "concurrently": "^7.6.0"
   },
   "dependencies": {
-    "@valbuild/core": "~0.15.0",
+    "@valbuild/core": "~0.16.0",
     "@valbuild/ui": "~0.15.0",
     "express": "^4.18.2",
+    "image-size": "^1.0.2",
     "quickjs-emscripten": "^0.21.1",
     "ts-morph": "^17.0.1",
     "typescript": "^4.9.4",

package/src/SerializedModuleContent.ts

@@ -1,8 +1,35 @@
-import { type Source, type SerializedSchema } from "@valbuild/core";
-import { type SourcePath } from "@valbuild/core/src/val";
+import {
+  type Source,
+  type SerializedSchema,
+  ValidationErrors,
+} from "@valbuild/core";
+import { ModuleId, type SourcePath } from "@valbuild/core/src/val";
 
-export type SerializedModuleContent = {
-  source: Source;
-  schema: SerializedSchema;
-  path: SourcePath;
-};
+export const FATAL_ERROR_TYPES = [
+  "no-schema",
+  "no-source",
+  "invalid-id",
+  "no-module",
+] as const;
+
+export type SerializedModuleContent =
+  | {
+      source: Source;
+      schema: SerializedSchema;
+      path: SourcePath;
+      errors: false;
+    }
+  | {
+      source?: Source;
+      schema?: SerializedSchema;
+      path?: SourcePath;
+      errors: {
+        invalidModuleId?: ModuleId;
+        validation?: ValidationErrors;
+        fatal?: {
+          message: string;
+          stack?: string[];
+          type?: (typeof FATAL_ERROR_TYPES)[number];
+        }[];
+      };
+    };

package/src/Service.ts

@@ -34,7 +34,8 @@ export async function createService(
   host: IValFSHost = {
     ...ts.sys,
     writeFile: fs.writeFileSync,
-  }
+  },
+  loader?: ValModuleLoader
 ): Promise<Service> {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(
@@ -42,14 +43,12 @@ export async function createService(
     compilerOptions,
     host
   );
-  const loader = new ValModuleLoader(
-    projectRoot,
-    compilerOptions,
-    sourceFileHandler,
-    host
-  );
   const module = await newQuickJSWASMModule();
-  const runtime = await newValQuickJSRuntime(module, loader);
+  const runtime = await newValQuickJSRuntime(
+    module,
+    loader ||
+      new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host)
+  );
   return new Service(opts, sourceFileHandler, runtime);
 }
 
@@ -74,19 +73,40 @@ export class Service {
       this.runtime
     );
 
-    const resolved = Internal.resolvePath(
-      modulePath,
-      valModule.source,
-      valModule.schema
-    );
-    return {
-      path: [moduleId, resolved.path].join(".") as SourcePath,
-      schema:
-        resolved.schema instanceof Schema<SelectorSource>
-          ? resolved.schema.serialize()
-          : resolved.schema,
-      source: resolved.source,
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = Internal.resolvePath(
+        modulePath,
+        valModule.source,
+        valModule.schema
+      );
+      const sourcePath = [moduleId, resolved.path].join(".") as SourcePath;
+      return {
+        path: sourcePath,
+        schema:
+          resolved.schema instanceof Schema<SelectorSource>
+            ? resolved.schema.serialize()
+            : resolved.schema,
+        source: resolved.source,
+        errors:
+          valModule.errors &&
+          valModule.errors.validation &&
+          valModule.errors.validation[sourcePath]
+            ? {
+                validation: valModule.errors.validation[sourcePath]
+                  ? {
+                      [sourcePath]: valModule.errors.validation[sourcePath],
+                    }
+                  : undefined,
+                fatal:
+                  valModule.errors && valModule.errors.fatal
+                    ? valModule.errors.fatal
+                    : undefined,
+              }
+            : false,
+      };
+    } else {
+      return valModule;
+    }
   }
 
   async patch(

package/src/ValModuleLoader.ts

@@ -60,7 +60,7 @@ export class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2020, // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
+      target: ts.ScriptTarget.ES2015, // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
       // moduleResolution: ts.ModuleResolutionKind.NodeNext,
       // target: ts.ScriptTarget.ES2020, // QuickJs runs in ES2020 so we must use that
     });

package/src/createFixPatch.ts

@@ -0,0 +1,174 @@
+import { FILE_REF_PROP, SourcePath, ValidationError } from "@valbuild/core";
+import { Patch, sourceToPatchPath } from "@valbuild/core/patch";
+import sizeOf from "image-size";
+import path from "path";
+import fs from "fs";
+import crypto from "crypto";
+
+export async function createFixPatch(
+  config: { projectRoot: string },
+  apply: boolean,
+  sourcePath: SourcePath,
+  validationError: ValidationError
+): Promise<{ patch: Patch; remainingErrors: ValidationError[] } | undefined> {
+  async function getImageMetadata() {
+    const maybeRef =
+      validationError.value &&
+      typeof validationError.value === "object" &&
+      FILE_REF_PROP in validationError.value &&
+      typeof validationError.value[FILE_REF_PROP] === "string"
+        ? validationError.value[FILE_REF_PROP]
+        : undefined;
+
+    if (!maybeRef) {
+      // TODO:
+      throw Error("Cannot fix image without a file reference");
+    }
+    const localFile = path.join(config.projectRoot, maybeRef);
+    const buffer = fs.readFileSync(localFile);
+    const sha256 = await getSHA256Hash(buffer);
+    const imageSize = sizeOf(buffer);
+    return {
+      ...imageSize,
+      sha256,
+    };
+  }
+  const remainingErrors: ValidationError[] = [];
+  const patch: Patch = [];
+  for (const fix of validationError.fixes || []) {
+    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
+      const imageMetadata = await getImageMetadata();
+      if (
+        imageMetadata.width === undefined ||
+        imageMetadata.height === undefined ||
+        imageMetadata.sha256 === undefined
+      ) {
+        remainingErrors.push({
+          ...validationError,
+          message: "Failed to get image metadata",
+          fixes: undefined,
+        });
+      } else if (fix === "image:replace-metadata") {
+        const currentValue = validationError.value;
+        const metadataIsCorrect =
+          // metadata is a prop that is an object
+          typeof currentValue === "object" &&
+          currentValue &&
+          "metadata" in currentValue &&
+          currentValue.metadata &&
+          typeof currentValue.metadata === "object" &&
+          // sha256 is correct
+          "sha256" in currentValue.metadata &&
+          currentValue.metadata.sha256 === imageMetadata.sha256 &&
+          // width is correct
+          "width" in currentValue.metadata &&
+          currentValue.metadata.width === imageMetadata.width &&
+          // height is correct
+          "height" in currentValue.metadata &&
+          currentValue.metadata.height === imageMetadata.height;
+
+        // skips if the metadata is already correct
+        if (!metadataIsCorrect) {
+          if (apply) {
+            patch.push({
+              op: "replace",
+              path: sourceToPatchPath(sourcePath).concat("metadata"),
+              value: {
+                width: imageMetadata.width,
+                height: imageMetadata.height,
+                sha256: imageMetadata.sha256,
+              },
+            });
+          } else {
+            if (
+              typeof currentValue === "object" &&
+              currentValue &&
+              "metadata" in currentValue &&
+              currentValue.metadata &&
+              typeof currentValue.metadata === "object"
+            ) {
+              if (
+                !("sha256" in currentValue.metadata) ||
+                currentValue.metadata.sha256 !== imageMetadata.sha256
+              ) {
+                remainingErrors.push({
+                  message:
+                    "Image metadata sha256 is incorrect! Found: " +
+                    ("sha256" in currentValue.metadata
+                      ? currentValue.metadata.sha256
+                      : "<empty>") +
+                    ". Expected: " +
+                    imageMetadata.sha256 +
+                    ".",
+                  fixes: undefined,
+                });
+              }
+              if (
+                !("width" in currentValue.metadata) ||
+                currentValue.metadata.width !== imageMetadata.width
+              ) {
+                remainingErrors.push({
+                  message:
+                    "Image metadata width is incorrect! Found: " +
+                    ("width" in currentValue.metadata
+                      ? currentValue.metadata.width
+                      : "<empty>") +
+                    ". Expected: " +
+                    imageMetadata.width,
+                  fixes: undefined,
+                });
+              }
+              if (
+                !("height" in currentValue.metadata) ||
+                currentValue.metadata.height !== imageMetadata.height
+              ) {
+                remainingErrors.push({
+                  message:
+                    "Image metadata height is incorrect! Found: " +
+                    ("height" in currentValue.metadata
+                      ? currentValue.metadata.height
+                      : "<empty>") +
+                    ". Expected: " +
+                    imageMetadata.height,
+                  fixes: undefined,
+                });
+              }
+            } else {
+              remainingErrors.push({
+                ...validationError,
+                message: "Image metadata is not an object!",
+                fixes: undefined,
+              });
+            }
+          }
+        }
+      } else if (fix === "image:add-metadata") {
+        patch.push({
+          op: "add",
+          path: sourceToPatchPath(sourcePath).concat("metadata"),
+          value: {
+            width: imageMetadata.width,
+            height: imageMetadata.height,
+            sha256: imageMetadata.sha256,
+          },
+        });
+      }
+    }
+  }
+  if (!validationError.fixes || validationError.fixes.length === 0) {
+    remainingErrors.push(validationError);
+  }
+  return {
+    patch,
+    remainingErrors,
+  };
+}
+
+const getSHA256Hash = async (bits: Uint8Array) => {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", bits);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hash = hashArray
+    .map((item) => item.toString(16).padStart(2, "0"))
+    .join("");
+  return hash;
+};

package/src/index.ts

@@ -10,3 +10,5 @@ export type { IValFSHost } from "./ValFSHost";
 export type { ValFS } from "./ValFS";
 export { patchSourceFile } from "./patchValFile";
 export { formatSyntaxErrorTree } from "./patch/ts/syntax";
+export { LocalValServer } from "./LocalValServer";
+export { createFixPatch } from "./createFixPatch";

package/src/readValFile.ts

@@ -1,3 +1,4 @@
+import { ModuleId } from "@valbuild/core";
 import path from "path";
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { SerializedModuleContent } from "./SerializedModuleContent";
@@ -16,6 +17,10 @@ globalThis.valModule = {
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
   source: valModule?.default && Internal.getRawSource(valModule?.default),
+  validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
+    valModule?.default && Internal.getValPath(valModule?.default) || "/",
+    valModule?.default && Internal.getRawSource(valModule?.default)
+  )
 };
 `;
     const result = context.evalCode(
@@ -23,48 +28,61 @@ globalThis.valModule = {
       // Synthetic module name
       path.join(path.dirname(valConfigPath), "<val>")
     );
+    const fatalErrors: string[] = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
-      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
-
-      throw new Error(
-        `Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${
-          error.stack ? error.stack : ""
-        }`
-      );
+      return {
+        errors: {
+          invalidModuleId: id as ModuleId,
+          fatal: [
+            {
+              message: `${error.name || "Unknown error"}: ${
+                error.message || "<no message>"
+              }`,
+              stack: error.stack,
+            },
+          ],
+        },
+      };
     } else {
       result.value.dispose();
       const valModule = context
         .getProp(context.global, "valModule")
         .consume(context.dump);
 
-      const errors: string[] = [];
-
       if (!valModule) {
-        errors.push(`Could not find any modules at: ${id}`);
+        fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(
+            `Expected val id: '${id}' but got: '${valModule.id}'`
+          );
         }
         if (!valModule?.schema) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!valModule?.source) {
-          errors.push(`Expected val id: '${id}' to have a source`);
+          fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
-
-      if (errors.length > 0) {
-        throw Error(
-          `While processing module of id: ${id}, we got the following errors:\n${errors.join(
-            "\n"
-          )}`
-        );
+      let errors: SerializedModuleContent["errors"] = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? (id as ModuleId) : undefined,
+          fatal: fatalErrors.map((message) => ({ message })),
+        };
+      }
+      if (valModule?.validation) {
+        errors = {
+          ...(errors ? errors : {}),
+          validation: valModule.validation,
+        };
       }
       return {
-        path: valModule.id, // This might not be the asked id/path, however, that should be handled further up in the call chain
+        path: valModule.id, // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
         source: valModule.source,
         schema: valModule.schema,
+        errors,
       };
     }
   } finally {