@valbuild/server 0.60.24 → 0.61.0

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

@@ -2,7 +2,7 @@
 import { Service } from "./Service.js";
 import { result } from "@valbuild/core/fp";
 import { Patch } from "./patch/validation.js";
-import { ApiGetPatchResponse, ApiPostPatchResponse, ModuleId, PatchId, ApiDeletePatchResponse, FileMetadata, ImageMetadata } from "@valbuild/core";
+import { ApiGetPatchResponse, ApiPostPatchResponse, ModuleId, PatchId, ApiDeletePatchResponse, FileMetadata, ImageMetadata, ValModules } from "@valbuild/core";
 import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValServerError, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValSession } from "@valbuild/shared/internal";
 import { ValServer, ValServerCallbacks } from "./ValServer.js";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
@@ -20,13 +20,14 @@ export interface ValServerBufferHost {
     readBuffer: (fileName: string) => Promise<Buffer | undefined>;
 }
 export declare class LocalValServer extends ValServer {
+    readonly valModules: ValModules;
     readonly options: LocalValServerOptions;
     readonly callbacks: ValServerCallbacks;
     private readonly host;
     private static readonly PATCHES_DIR;
     private static readonly FILES_DIR;
     private readonly patchesRootPath;
-    constructor(options: LocalValServerOptions, callbacks: ValServerCallbacks);
+    constructor(valModules: ValModules, options: LocalValServerOptions, callbacks: ValServerCallbacks);
     session(): Promise<ValServerJsonResult<ValSession>>;
     deletePatches(query: {
         id?: string[];
@@ -44,10 +45,8 @@ export declare class LocalValServer extends ValServer {
     private getPatchFilePath;
     private badRequest;
     protected ensureInitialized(): Promise<result.Result<undefined, ValServerError>>;
-    protected getModule(moduleId: ModuleId, options: {
-        source: boolean;
-        schema: boolean;
-    }): Promise<SerializedModuleContent>;
+    private getSerializedModules;
+    protected getModule(moduleId: ModuleId): Promise<SerializedModuleContent>;
     protected getAllModules(treePath: string): Promise<ModuleId[]>;
     protected execCommit(patches: [PatchId, ModuleId, Patch][]): Promise<{
         status: 200;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ApiCommitResponse, ApiGetPatchResponse, ApiPostPatchResponse, ApiPostValidationErrorResponse, ApiTreeResponse, ApiDeletePatchResponse, ApiPostValidationResponse } from "@valbuild/core";
+import { ApiCommitResponse, ApiGetPatchResponse, ApiPostPatchResponse, ApiPostValidationErrorResponse, ApiTreeResponse, ApiDeletePatchResponse, ApiPostValidationResponse, ValModules } from "@valbuild/core";
 import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCookies, ValServerError, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValSession } from "@valbuild/shared/internal";
 import { result } from "@valbuild/core/fp";
 import { Operation } from "@valbuild/core/patch";
@@ -16,9 +16,10 @@ export type ValServerOptions = {
 };
 export declare abstract class ValServer implements IValServer {
     readonly cwd: string;
+    readonly valModules: ValModules;
     readonly options: ValServerOptions;
     readonly callbacks: ValServerCallbacks;
-    constructor(cwd: string, options: ValServerOptions, callbacks: ValServerCallbacks);
+    constructor(cwd: string, valModules: ValModules, options: ValServerOptions, callbacks: ValServerCallbacks);
     enable(query: {
         redirect_to?: string;
     }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;

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

@@ -1,6 +1,6 @@
 import { ServiceOptions } from "./Service.js";
 import { IValServer, ValServerCallbacks } from "./ValServer.js";
-import { ValConfig } from "@valbuild/core";
+import { ValConfig, ValModules } from "@valbuild/core";
 import { ValServerGenericResult } from "@valbuild/shared/internal";
 type Versions = {
     versions?: {
@@ -114,7 +114,7 @@ type ValServerOverrides = Partial<{
      */
     disableCache?: boolean;
 }>;
-export declare function createValServer(route: string, opts: ValApiOptions, callbacks: ValServerCallbacks): Promise<IValServer>;
+export declare function createValServer(valModules: ValModules, route: string, opts: ValApiOptions, callbacks: ValServerCallbacks): Promise<IValServer>;
 export declare function safeReadGit(cwd: string): Promise<{
     commit?: string;
     branch?: string;

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

@@ -4,5 +4,5 @@ import { type ValSyntaxErrorTree } from "./patch/ts/syntax.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { QuickJSRuntime } from "quickjs-emscripten";
 import ts from "typescript";
-export declare const patchValFile: (id: string, valConfigPath: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<void>;
+export declare const patchValFile: (id: string, rootDir: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<void>;
 export declare const patchSourceFile: (sourceFile: ts.SourceFile | string, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;

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

@@ -633,6 +633,10 @@ class TSOps {
   }
 }
 
+function getSyntheticContainingPath(rootDir) {
+  return path__namespace["default"].join(rootDir, "<val>"); // TODO: this is the synthetic path used when evaluating / patching modules. I am not sure <val> is the best choice: val.ts / js better? But that is weird too. At least now it is clear(er) that it is indeed a synthetic file (i.e. not an actual file)
+}
+
 const ops$1 = new TSOps(document => {
   return fp.pipe(analyzeValModule(document), fp.result.map(({
     source
@@ -640,10 +644,10 @@ const ops$1 = new TSOps(document => {
 });
 
 // TODO: rename to patchValFiles since we may write multiple files
-const patchValFile = async (id, valConfigPath, patch$1, sourceFileHandler, runtime) => {
+const patchValFile = async (id, rootDir, patch$1, sourceFileHandler, runtime) => {
   // const timeId = randomUUID();
   // console.time("patchValFile" + timeId);
-  const filePath = sourceFileHandler.resolveSourceModulePath(valConfigPath, `.${id}.val`);
+  const filePath = sourceFileHandler.resolveSourceModulePath(getSyntheticContainingPath(rootDir), `.${id}.val`);
   const sourceFile = sourceFileHandler.getSourceFile(filePath);
   if (!sourceFile) {
     throw Error(`Source file ${filePath} not found`);
@@ -741,9 +745,7 @@ globalThis.valModule = {
   defaultExport: !!valModule?.default,
 };
 `;
-    const result = context.evalCode(code,
-    // Synthetic module name
-    path__namespace["default"].join(rootDirPath, "<val>"));
+    const result = context.evalCode(code, getSyntheticContainingPath(rootDirPath));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -1412,8 +1414,9 @@ function getValidationErrorMetadata(validationError) {
 
 const ops = new patch.JSONOps();
 class ValServer {
-  constructor(cwd, options, callbacks) {
+  constructor(cwd, valModules, options, callbacks) {
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
   }
@@ -2050,8 +2053,9 @@ const textEncoder = new TextEncoder();
 class LocalValServer extends ValServer {
   static PATCHES_DIR = "patches";
   static FILES_DIR = "files";
-  constructor(options, callbacks) {
-    super(options.service.sourceFileHandler.projectRoot, options, callbacks);
+  constructor(valModules, options, callbacks) {
+    super(options.service.sourceFileHandler.projectRoot, valModules, options, callbacks);
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
     this.patchesRootPath = options.cacheDir || path__namespace["default"].join(options.service.sourceFileHandler.projectRoot, ".val");
@@ -2320,19 +2324,59 @@ class LocalValServer extends ValServer {
     // No RemoteFS so nothing to ensure
     return fp.result.ok(undefined);
   }
-  getModule(moduleId, options) {
-    return this.options.service.get(moduleId, "", {
-      ...options,
-      validate: false
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = core.Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = core.Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = core.Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
     });
   }
   async getAllModules(treePath) {
-    const moduleIds = this.host.readDirectory(this.cwd, ["ts", "js"], ["node_modules", ".*"], ["**/*.val.ts", "**/*.val.js"]).filter(file => {
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
       if (treePath) {
-        return file.replace(this.cwd, "").startsWith(treePath);
+        return path.startsWith(treePath);
       }
       return true;
-    }).map(file => file.replace(this.cwd, "").replace(".val.js", "").replace(".val.ts", "").split(path__namespace["default"].sep).join("/"));
+    }).map(({
+      path
+    }) => path);
     return moduleIds;
   }
   async execCommit(patches) {
@@ -2423,30 +2467,72 @@ function encodeJwt(payload, sessionKey) {
 
 class ProxyValServer extends ValServer {
   moduleCache = null;
-  constructor(cwd, options, apiOptions, callbacks) {
-    super(cwd, options, callbacks);
+  constructor(cwd, valModules, options, apiOptions, callbacks) {
+    super(cwd, valModules, options, callbacks);
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.apiOptions = apiOptions;
     this.callbacks = callbacks;
     this.moduleCache = null;
   }
 
-  /** Remote FS dependent methods: */
+  // TODO: restructure this
 
-  async getModule(moduleId,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _options) {
-    if (this.moduleCache) {
-      return this.moduleCache[moduleId];
-    }
-    throw new Error("Module cache not initialized");
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = core.Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = core.Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = core.Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
+    });
   }
   async getAllModules(treePath) {
-    if (!this.moduleCache) {
-      throw new Error("Module cache not initialized");
-    }
-    return Object.keys(this.moduleCache).filter(moduleId => moduleId.startsWith(treePath));
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
+      if (treePath) {
+        return path.startsWith(treePath);
+      }
+      return true;
+    }).map(({
+      path
+    }) => path);
+    return moduleIds;
   }
   execCommit(patches, cookies) {
     return withAuth(this.options.valSecret, cookies, "execCommit", async ({
@@ -2487,67 +2573,14 @@ class ProxyValServer extends ValServer {
       }
     });
   }
-  async init(commit, token) {
-    const params = createParams({
-      root: this.apiOptions.root,
-      commit,
-      ext: ["ts", "js", "json"],
-      package: ["@valbuild/core@" + this.options.versions.core, "@valbuild/next@" + this.options.versions.next],
-      include: ["**/*.val.{js,ts},package.json,tsconfig.json,jsconfig.json"]
-    });
-    const url = new URL(`/v1/eval/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
-    try {
-      const fetchRes = await fetch(url, {
-        headers: getAuthHeaders(token, "application/json")
-      });
-      if (fetchRes.status === 200) {
-        const json = await fetchRes.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.modules !== "object" || json.modules === null) {
-          error = {
-            details: "Invalid response: missing modules"
-          };
-        }
-        if (error) {
-          console.error("Could not initialize remote modules", error);
-          return {
-            status: 500,
-            json: {
-              message: "Failed to fetch remote modules",
-              ...error
-            }
-          };
-        }
-        this.moduleCache = json.modules;
-        return {
-          status: 200
-        };
-      } else {
-        return createJsonError(fetchRes);
-      }
-    } catch (err) {
-      return {
-        status: 500,
-        json: {
-          message: "Failed to fetch: check network connection"
-        }
-      };
-    }
+  async init(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _commit,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _token) {
+    return {
+      status: 200
+    };
   }
   async ensureInitialized(errorMessageType, cookies) {
     const commit = this.options.git.commit;
@@ -3116,13 +3149,13 @@ function createParams(params) {
   return paramsString;
 }
 
-async function createValServer(route, opts, callbacks) {
+async function createValServer(valModules, route, opts, callbacks) {
   const serverOpts = await initHandlerOptions(route, opts);
   if (serverOpts.mode === "proxy") {
     const projectRoot = process.cwd(); //[process.cwd(), opts.root || ""]      .filter((seg) => seg)      .join("/");
-    return new ProxyValServer(projectRoot, serverOpts, opts, callbacks);
+    return new ProxyValServer(projectRoot, valModules, serverOpts, opts, callbacks);
   } else {
-    return new LocalValServer(serverOpts, callbacks);
+    return new LocalValServer(valModules, serverOpts, callbacks);
   }
 }
 async function initHandlerOptions(route, opts) {

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

@@ -633,6 +633,10 @@ class TSOps {
   }
 }
 
+function getSyntheticContainingPath(rootDir) {
+  return path__namespace["default"].join(rootDir, "<val>"); // TODO: this is the synthetic path used when evaluating / patching modules. I am not sure <val> is the best choice: val.ts / js better? But that is weird too. At least now it is clear(er) that it is indeed a synthetic file (i.e. not an actual file)
+}
+
 const ops$1 = new TSOps(document => {
   return fp.pipe(analyzeValModule(document), fp.result.map(({
     source
@@ -640,10 +644,10 @@ const ops$1 = new TSOps(document => {
 });
 
 // TODO: rename to patchValFiles since we may write multiple files
-const patchValFile = async (id, valConfigPath, patch$1, sourceFileHandler, runtime) => {
+const patchValFile = async (id, rootDir, patch$1, sourceFileHandler, runtime) => {
   // const timeId = randomUUID();
   // console.time("patchValFile" + timeId);
-  const filePath = sourceFileHandler.resolveSourceModulePath(valConfigPath, `.${id}.val`);
+  const filePath = sourceFileHandler.resolveSourceModulePath(getSyntheticContainingPath(rootDir), `.${id}.val`);
   const sourceFile = sourceFileHandler.getSourceFile(filePath);
   if (!sourceFile) {
     throw Error(`Source file ${filePath} not found`);
@@ -741,9 +745,7 @@ globalThis.valModule = {
   defaultExport: !!valModule?.default,
 };
 `;
-    const result = context.evalCode(code,
-    // Synthetic module name
-    path__namespace["default"].join(rootDirPath, "<val>"));
+    const result = context.evalCode(code, getSyntheticContainingPath(rootDirPath));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -1412,8 +1414,9 @@ function getValidationErrorMetadata(validationError) {
 
 const ops = new patch.JSONOps();
 class ValServer {
-  constructor(cwd, options, callbacks) {
+  constructor(cwd, valModules, options, callbacks) {
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
   }
@@ -2050,8 +2053,9 @@ const textEncoder = new TextEncoder();
 class LocalValServer extends ValServer {
   static PATCHES_DIR = "patches";
   static FILES_DIR = "files";
-  constructor(options, callbacks) {
-    super(options.service.sourceFileHandler.projectRoot, options, callbacks);
+  constructor(valModules, options, callbacks) {
+    super(options.service.sourceFileHandler.projectRoot, valModules, options, callbacks);
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
     this.patchesRootPath = options.cacheDir || path__namespace["default"].join(options.service.sourceFileHandler.projectRoot, ".val");
@@ -2320,19 +2324,59 @@ class LocalValServer extends ValServer {
     // No RemoteFS so nothing to ensure
     return fp.result.ok(undefined);
   }
-  getModule(moduleId, options) {
-    return this.options.service.get(moduleId, "", {
-      ...options,
-      validate: false
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = core.Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = core.Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = core.Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
     });
   }
   async getAllModules(treePath) {
-    const moduleIds = this.host.readDirectory(this.cwd, ["ts", "js"], ["node_modules", ".*"], ["**/*.val.ts", "**/*.val.js"]).filter(file => {
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
       if (treePath) {
-        return file.replace(this.cwd, "").startsWith(treePath);
+        return path.startsWith(treePath);
       }
       return true;
-    }).map(file => file.replace(this.cwd, "").replace(".val.js", "").replace(".val.ts", "").split(path__namespace["default"].sep).join("/"));
+    }).map(({
+      path
+    }) => path);
     return moduleIds;
   }
   async execCommit(patches) {
@@ -2423,30 +2467,72 @@ function encodeJwt(payload, sessionKey) {
 
 class ProxyValServer extends ValServer {
   moduleCache = null;
-  constructor(cwd, options, apiOptions, callbacks) {
-    super(cwd, options, callbacks);
+  constructor(cwd, valModules, options, apiOptions, callbacks) {
+    super(cwd, valModules, options, callbacks);
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.apiOptions = apiOptions;
     this.callbacks = callbacks;
     this.moduleCache = null;
   }
 
-  /** Remote FS dependent methods: */
+  // TODO: restructure this
 
-  async getModule(moduleId,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _options) {
-    if (this.moduleCache) {
-      return this.moduleCache[moduleId];
-    }
-    throw new Error("Module cache not initialized");
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = core.Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = core.Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = core.Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
+    });
   }
   async getAllModules(treePath) {
-    if (!this.moduleCache) {
-      throw new Error("Module cache not initialized");
-    }
-    return Object.keys(this.moduleCache).filter(moduleId => moduleId.startsWith(treePath));
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
+      if (treePath) {
+        return path.startsWith(treePath);
+      }
+      return true;
+    }).map(({
+      path
+    }) => path);
+    return moduleIds;
   }
   execCommit(patches, cookies) {
     return withAuth(this.options.valSecret, cookies, "execCommit", async ({
@@ -2487,67 +2573,14 @@ class ProxyValServer extends ValServer {
       }
     });
   }
-  async init(commit, token) {
-    const params = createParams({
-      root: this.apiOptions.root,
-      commit,
-      ext: ["ts", "js", "json"],
-      package: ["@valbuild/core@" + this.options.versions.core, "@valbuild/next@" + this.options.versions.next],
-      include: ["**/*.val.{js,ts},package.json,tsconfig.json,jsconfig.json"]
-    });
-    const url = new URL(`/v1/eval/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
-    try {
-      const fetchRes = await fetch(url, {
-        headers: getAuthHeaders(token, "application/json")
-      });
-      if (fetchRes.status === 200) {
-        const json = await fetchRes.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.modules !== "object" || json.modules === null) {
-          error = {
-            details: "Invalid response: missing modules"
-          };
-        }
-        if (error) {
-          console.error("Could not initialize remote modules", error);
-          return {
-            status: 500,
-            json: {
-              message: "Failed to fetch remote modules",
-              ...error
-            }
-          };
-        }
-        this.moduleCache = json.modules;
-        return {
-          status: 200
-        };
-      } else {
-        return createJsonError(fetchRes);
-      }
-    } catch (err) {
-      return {
-        status: 500,
-        json: {
-          message: "Failed to fetch: check network connection"
-        }
-      };
-    }
+  async init(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _commit,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _token) {
+    return {
+      status: 200
+    };
   }
   async ensureInitialized(errorMessageType, cookies) {
     const commit = this.options.git.commit;
@@ -3116,13 +3149,13 @@ function createParams(params) {
   return paramsString;
 }
 
-async function createValServer(route, opts, callbacks) {
+async function createValServer(valModules, route, opts, callbacks) {
   const serverOpts = await initHandlerOptions(route, opts);
   if (serverOpts.mode === "proxy") {
     const projectRoot = process.cwd(); //[process.cwd(), opts.root || ""]      .filter((seg) => seg)      .join("/");
-    return new ProxyValServer(projectRoot, serverOpts, opts, callbacks);
+    return new ProxyValServer(projectRoot, valModules, serverOpts, opts, callbacks);
   } else {
-    return new LocalValServer(serverOpts, callbacks);
+    return new LocalValServer(valModules, serverOpts, callbacks);
   }
 }
 async function initHandlerOptions(route, opts) {

package/dist/valbuild-server.esm.js

@@ -603,6 +603,10 @@ class TSOps {
   }
 }
 
+function getSyntheticContainingPath(rootDir) {
+  return path__default.join(rootDir, "<val>"); // TODO: this is the synthetic path used when evaluating / patching modules. I am not sure <val> is the best choice: val.ts / js better? But that is weird too. At least now it is clear(er) that it is indeed a synthetic file (i.e. not an actual file)
+}
+
 const ops$1 = new TSOps(document => {
   return pipe(analyzeValModule(document), result.map(({
     source
@@ -610,10 +614,10 @@ const ops$1 = new TSOps(document => {
 });
 
 // TODO: rename to patchValFiles since we may write multiple files
-const patchValFile = async (id, valConfigPath, patch, sourceFileHandler, runtime) => {
+const patchValFile = async (id, rootDir, patch, sourceFileHandler, runtime) => {
   // const timeId = randomUUID();
   // console.time("patchValFile" + timeId);
-  const filePath = sourceFileHandler.resolveSourceModulePath(valConfigPath, `.${id}.val`);
+  const filePath = sourceFileHandler.resolveSourceModulePath(getSyntheticContainingPath(rootDir), `.${id}.val`);
   const sourceFile = sourceFileHandler.getSourceFile(filePath);
   if (!sourceFile) {
     throw Error(`Source file ${filePath} not found`);
@@ -711,9 +715,7 @@ globalThis.valModule = {
   defaultExport: !!valModule?.default,
 };
 `;
-    const result = context.evalCode(code,
-    // Synthetic module name
-    path__default.join(rootDirPath, "<val>"));
+    const result = context.evalCode(code, getSyntheticContainingPath(rootDirPath));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -1382,8 +1384,9 @@ function getValidationErrorMetadata(validationError) {
 
 const ops = new JSONOps();
 class ValServer {
-  constructor(cwd, options, callbacks) {
+  constructor(cwd, valModules, options, callbacks) {
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
   }
@@ -2020,8 +2023,9 @@ const textEncoder = new TextEncoder();
 class LocalValServer extends ValServer {
   static PATCHES_DIR = "patches";
   static FILES_DIR = "files";
-  constructor(options, callbacks) {
-    super(options.service.sourceFileHandler.projectRoot, options, callbacks);
+  constructor(valModules, options, callbacks) {
+    super(options.service.sourceFileHandler.projectRoot, valModules, options, callbacks);
+    this.valModules = valModules;
     this.options = options;
     this.callbacks = callbacks;
     this.patchesRootPath = options.cacheDir || path__default.join(options.service.sourceFileHandler.projectRoot, ".val");
@@ -2290,19 +2294,59 @@ class LocalValServer extends ValServer {
     // No RemoteFS so nothing to ensure
     return result.ok(undefined);
   }
-  getModule(moduleId, options) {
-    return this.options.service.get(moduleId, "", {
-      ...options,
-      validate: false
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
     });
   }
   async getAllModules(treePath) {
-    const moduleIds = this.host.readDirectory(this.cwd, ["ts", "js"], ["node_modules", ".*"], ["**/*.val.ts", "**/*.val.js"]).filter(file => {
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
       if (treePath) {
-        return file.replace(this.cwd, "").startsWith(treePath);
+        return path.startsWith(treePath);
       }
       return true;
-    }).map(file => file.replace(this.cwd, "").replace(".val.js", "").replace(".val.ts", "").split(path__default.sep).join("/"));
+    }).map(({
+      path
+    }) => path);
     return moduleIds;
   }
   async execCommit(patches) {
@@ -2393,30 +2437,72 @@ function encodeJwt(payload, sessionKey) {
 
 class ProxyValServer extends ValServer {
   moduleCache = null;
-  constructor(cwd, options, apiOptions, callbacks) {
-    super(cwd, options, callbacks);
+  constructor(cwd, valModules, options, apiOptions, callbacks) {
+    super(cwd, valModules, options, callbacks);
     this.cwd = cwd;
+    this.valModules = valModules;
     this.options = options;
     this.apiOptions = apiOptions;
     this.callbacks = callbacks;
     this.moduleCache = null;
   }
 
-  /** Remote FS dependent methods: */
+  // TODO: restructure this
 
-  async getModule(moduleId,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _options) {
-    if (this.moduleCache) {
-      return this.moduleCache[moduleId];
-    }
-    throw new Error("Module cache not initialized");
+  getSerializedModules() {
+    return Promise.all(this.valModules.modules.map(({
+      def
+    }, i) => {
+      return def().then(({
+        default: valModule
+      }) => {
+        var _Internal$getSchema;
+        const path = Internal.getValPath(valModule);
+        if (!path) {
+          throw Error(`Module defined at pos: ${i} is missing path`);
+        }
+        const source = Internal.getSource(valModule);
+        if (!source) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing source`);
+        }
+        const schema = (_Internal$getSchema = Internal.getSchema(valModule)) === null || _Internal$getSchema === void 0 ? void 0 : _Internal$getSchema.serialize();
+        if (!schema) {
+          // TODO
+          throw Error(`Module defined at pos: ${i} is missing schema`);
+        }
+        return {
+          path,
+          source: source,
+          errors: false,
+          //valModule[GetSchema]?.validate(path, source),
+          schema: schema
+        };
+      });
+    }));
+  }
+  getModule(moduleId) {
+    // TODO: do not get all modules - we only should only get the ones we need
+    return this.getSerializedModules().then(all => {
+      const found = all.find(valModule => valModule.path === moduleId);
+      if (!found) {
+        throw Error(`Module ${moduleId} not found`);
+      }
+      return found;
+    });
   }
   async getAllModules(treePath) {
-    if (!this.moduleCache) {
-      throw new Error("Module cache not initialized");
-    }
-    return Object.keys(this.moduleCache).filter(moduleId => moduleId.startsWith(treePath));
+    const moduleIds = (await this.getSerializedModules()).filter(({
+      path
+    }) => {
+      if (treePath) {
+        return path.startsWith(treePath);
+      }
+      return true;
+    }).map(({
+      path
+    }) => path);
+    return moduleIds;
   }
   execCommit(patches, cookies) {
     return withAuth(this.options.valSecret, cookies, "execCommit", async ({
@@ -2457,67 +2543,14 @@ class ProxyValServer extends ValServer {
       }
     });
   }
-  async init(commit, token) {
-    const params = createParams({
-      root: this.apiOptions.root,
-      commit,
-      ext: ["ts", "js", "json"],
-      package: ["@valbuild/core@" + this.options.versions.core, "@valbuild/next@" + this.options.versions.next],
-      include: ["**/*.val.{js,ts},package.json,tsconfig.json,jsconfig.json"]
-    });
-    const url = new URL(`/v1/eval/${this.options.remote}/heads/${this.options.git.branch}/~?${params}`, this.options.valContentUrl);
-    try {
-      const fetchRes = await fetch(url, {
-        headers: getAuthHeaders(token, "application/json")
-      });
-      if (fetchRes.status === 200) {
-        const json = await fetchRes.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.modules !== "object" || json.modules === null) {
-          error = {
-            details: "Invalid response: missing modules"
-          };
-        }
-        if (error) {
-          console.error("Could not initialize remote modules", error);
-          return {
-            status: 500,
-            json: {
-              message: "Failed to fetch remote modules",
-              ...error
-            }
-          };
-        }
-        this.moduleCache = json.modules;
-        return {
-          status: 200
-        };
-      } else {
-        return createJsonError(fetchRes);
-      }
-    } catch (err) {
-      return {
-        status: 500,
-        json: {
-          message: "Failed to fetch: check network connection"
-        }
-      };
-    }
+  async init(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _commit,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _token) {
+    return {
+      status: 200
+    };
   }
   async ensureInitialized(errorMessageType, cookies) {
     const commit = this.options.git.commit;
@@ -3086,13 +3119,13 @@ function createParams(params) {
   return paramsString;
 }
 
-async function createValServer(route, opts, callbacks) {
+async function createValServer(valModules, route, opts, callbacks) {
   const serverOpts = await initHandlerOptions(route, opts);
   if (serverOpts.mode === "proxy") {
     const projectRoot = process.cwd(); //[process.cwd(), opts.root || ""]      .filter((seg) => seg)      .join("/");
-    return new ProxyValServer(projectRoot, serverOpts, opts, callbacks);
+    return new ProxyValServer(projectRoot, valModules, serverOpts, opts, callbacks);
   } else {
-    return new LocalValServer(serverOpts, callbacks);
+    return new LocalValServer(valModules, serverOpts, callbacks);
   }
 }
 async function initHandlerOptions(route, opts) {

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.60.24",
+  "version": "0.61.0",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",
@@ -24,9 +24,9 @@
     "concurrently": "^7.6.0"
   },
   "dependencies": {
-    "@valbuild/core": "~0.60.24",
-    "@valbuild/shared": "~0.60.24",
-    "@valbuild/ui": "~0.60.24",
+    "@valbuild/core": "~0.61.0",
+    "@valbuild/shared": "~0.61.0",
+    "@valbuild/ui": "~0.61.0",
     "express": "^4.18.2",
     "image-size": "^1.0.2",
     "minimatch": "^3.0.4",