@valbuild/server 0.96.3 → 0.97.1

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

@@ -1289,6 +1289,11 @@ export default new Proxy({}, {
           value: "export const ValApp = new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'ValApp' in this file`) } } } )"
         };
       }
+      if (modulePath.includes("/ValModulesClient")) {
+        return {
+          value: "export const ValModulesClient = new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'ValModulesClient' in this file`) } } } ); export const useRegisterValModules = () => { throw new Error(`Cannot use 'useRegisterValModules' in this type of file`) };"
+        };
+      }
       return {
         value: moduleLoader.getModule(modulePath)
       };
@@ -1359,6 +1364,11 @@ export default new Proxy({}, {
           value: requestedName
         };
       }
+      if (requestedName.includes("/ValModulesClient")) {
+        return {
+          value: requestedName
+        };
+      }
       const modulePath = moduleLoader.resolveModulePath(baseModuleName, requestedName);
       return {
         value: modulePath
@@ -1493,7 +1503,6 @@ function encodeJwt(payload, sessionKey) {
 }
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
-const textEncoder$2 = new TextEncoder();
 const jsonOps = new patch.JSONOps();
 const tsOps = new TSOps(document => {
   return fp.pipe(analyzeValModule(document), fp.result.map(({
@@ -1525,47 +1534,6 @@ class ValOps {
     this.configSha = null;
     this.modulesErrors = null;
   }
-  hash(input) {
-    if (typeof input === "object") {
-      return this.hashObject(input);
-    }
-    return core.Internal.getSHA256Hash(textEncoder$2.encode(input));
-  }
-  hashObject(obj) {
-    const collector = [];
-    this.collectObjectRecursive(obj, collector);
-    return core.Internal.getSHA256Hash(textEncoder$2.encode(collector.join("")));
-  }
-  collectObjectRecursive(item, collector) {
-    if (typeof item === "string") {
-      collector.push(`"`, item, `"`);
-      return;
-    } else if (typeof item === "number") {
-      collector.push(item.toString());
-      return;
-    } else if (typeof item === "object") {
-      if (Array.isArray(item)) {
-        collector.push("[");
-        for (let i = 0; i < item.length; i++) {
-          this.collectObjectRecursive(item[i], collector);
-          if (i !== item.length - 1) collector.push(",");
-        }
-        collector.push("]");
-      } else {
-        collector.push("{");
-        const keys = Object.keys(item).sort();
-        keys.forEach((key, i) => {
-          collector.push(`"${key}":`);
-          this.collectObjectRecursive(item[key], collector);
-          if (i !== keys.length - 1) collector.push(",");
-        });
-        collector.push("}");
-      }
-      return;
-    } else {
-      console.warn("Unknown type encountered when hashing object", typeof item, item);
-    }
-  }
 
   // #region stat
   /**
@@ -1581,93 +1549,23 @@ class ValOps {
   // #region initTree
   async initSources() {
     if (this.baseSha === null || this.sourcesSha === null || this.configSha === null || this.schemaSha === null || this.sources === null || this.schemas === null || this.modulesErrors === null) {
-      const currentModulesErrors = [];
-      const addModuleError = (message, index, path) => {
-        currentModulesErrors[index] = {
-          message,
-          path: path
-        };
+      const extracted = await core.extractValModules(this.valModules);
+      this.sources = extracted.sources;
+      this.schemas = extracted.schemas;
+      this.baseSha = extracted.baseSha;
+      this.schemaSha = extracted.schemaSha;
+      this.sourcesSha = extracted.sourcesSha;
+      this.configSha = extracted.configSha;
+      this.modulesErrors = extracted.moduleErrors;
+      return {
+        baseSha: this.baseSha,
+        schemaSha: this.schemaSha,
+        sourcesSha: this.sourcesSha,
+        configSha: this.configSha,
+        sources: extracted.sources,
+        schemas: extracted.schemas,
+        moduleErrors: extracted.moduleErrors
       };
-      const currentSources = {};
-      const currentSchemas = {};
-      const configSha = this.hash(JSON.stringify(this.valModules.config));
-      let sourcesSha = "";
-      let baseSha = configSha;
-      let schemaSha = configSha;
-      for (let moduleIdx = 0; moduleIdx < this.valModules.modules.length; moduleIdx++) {
-        const module = this.valModules.modules[moduleIdx];
-        if (!module.def) {
-          addModuleError("val.modules is missing 'def' property", moduleIdx);
-          continue;
-        }
-        if (typeof module.def !== "function") {
-          addModuleError("val.modules 'def' property is not a function", moduleIdx);
-          continue;
-        }
-        await module.def().then(value => {
-          if (!value) {
-            addModuleError(`val.modules 'def' did not return a value`, moduleIdx);
-            return;
-          }
-          if (!value.default) {
-            addModuleError(`val.modules 'def' did not return a default export`, moduleIdx);
-            return;
-          }
-          const path = core.Internal.getValPath(value.default);
-          if (path === undefined) {
-            addModuleError(`path is undefined`, moduleIdx);
-            return;
-          }
-          const schema = core.Internal.getSchema(value.default);
-          if (schema === undefined) {
-            addModuleError(`schema in path '${path}' is undefined`, moduleIdx, path);
-            return;
-          }
-          if (!(schema instanceof core.Schema)) {
-            addModuleError(`schema in path '${path}' is not an instance of Schema`, moduleIdx, path);
-            return;
-          }
-          if (typeof schema["executeSerialize"] !== "function") {
-            addModuleError(`schema.serialize in path '${path}' is not a function`, moduleIdx, path);
-            return;
-          }
-          const source = core.Internal.getSource(value.default);
-          if (source === undefined) {
-            addModuleError(`source in ${path} is undefined`, moduleIdx, path);
-            return;
-          }
-          let serializedSchema;
-          try {
-            serializedSchema = schema["executeSerialize"]();
-          } catch (e) {
-            const message = e instanceof Error ? e.message : JSON.stringify(e);
-            addModuleError(`Could not serialize module: '${path}'. Error: ${message}`, moduleIdx, path);
-            return;
-          }
-          const pathM = path;
-          currentSources[pathM] = source;
-          currentSchemas[pathM] = schema;
-          // make sure the checks above is enough that this does not fail - even if val modules are not set up correctly
-          sourcesSha = this.hash(sourcesSha + JSON.stringify({
-            path,
-            source
-          }));
-          baseSha = this.hash(baseSha + JSON.stringify({
-            path,
-            schema: serializedSchema,
-            source,
-            modulesErrors: currentModulesErrors
-          }));
-          schemaSha = this.hash(schemaSha + JSON.stringify(serializedSchema));
-        });
-      }
-      this.sources = currentSources;
-      this.schemas = currentSchemas;
-      this.baseSha = baseSha;
-      this.schemaSha = schemaSha;
-      this.sourcesSha = sourcesSha;
-      this.configSha = configSha;
-      this.modulesErrors = currentModulesErrors;
     }
     return {
       baseSha: this.baseSha,
@@ -1847,79 +1745,6 @@ class ValOps {
 
   // #region validateSources
   async validateSources(schemas, sources, patchesByModule) {
-    const checkKeyIsValid = async (key, sourcePath) => {
-      var _schemas$moduleFilePa;
-      const [moduleFilePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
-      const keyOfModuleSource = sources[moduleFilePath];
-      const keyOfModuleSchema = (_schemas$moduleFilePa = schemas[moduleFilePath]) === null || _schemas$moduleFilePa === void 0 ? void 0 : _schemas$moduleFilePa["executeSerialize"]();
-      if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") {
-        return {
-          error: true,
-          message: `Expected key at ${sourcePath} to be of type 'record'`
-        };
-      }
-      if (keyOfModuleSource && typeof keyOfModuleSource === "object" && key in keyOfModuleSource) {
-        return {
-          error: false
-        };
-      }
-      if (!keyOfModuleSource || typeof keyOfModuleSource !== "object") {
-        return {
-          error: true,
-          message: `Expected ${sourcePath} to be a truthy object`
-        };
-      }
-      return {
-        error: true,
-        message: `Key '${key}' does not exist in ${sourcePath}.`
-      };
-    };
-    const checkRouteIsValid = async (route, includePattern, excludePattern) => {
-      // Find all router modules (record schemas with router property)
-      const routerModules = [];
-      for (const [moduleFilePath, schema] of Object.entries(schemas)) {
-        const serializedSchema = schema["executeSerialize"]();
-        if (serializedSchema.type === "record" && serializedSchema.router) {
-          const source = sources[moduleFilePath];
-          if (source && typeof source === "object") {
-            routerModules.push({
-              path: moduleFilePath,
-              routes: Object.keys(source)
-            });
-          }
-        }
-      }
-      if (routerModules.length === 0) {
-        return {
-          error: true,
-          message: `No router modules found. Route validation requires at least one s.record().router() module.`
-        };
-      }
-
-      // Check if route exists in any router module
-      const allRoutes = routerModules.flatMap(m => m.routes);
-      const routeExists = allRoutes.includes(route);
-      if (!routeExists) {
-        // Filter routes by include/exclude patterns for suggestions
-        const validRoutes = internal.filterRoutesByPatterns(allRoutes, includePattern, excludePattern);
-        return {
-          error: true,
-          message: `Route '${route}' does not exist in any router module. Available routes: ${validRoutes.slice(0, 10).join(", ")}${validRoutes.length > 10 ? "..." : ""}`
-        };
-      }
-
-      // Validate against include/exclude patterns
-      const patternValidation = internal.validateRoutePatterns(route, includePattern, excludePattern);
-      if (!patternValidation.valid) {
-        return {
-          error: true,
-          message: patternValidation.message
-        };
-      }
-      return {
-        error: false
-      };
-    };
     const errors = {};
     const files = {};
     const remoteFiles = {};
@@ -1927,15 +1752,27 @@ class ValOps {
     // Build a map of gallery directory → [ModuleFilePath, ...] across ALL modules
     // (must include all modules, not just those being validated, since conflicts can come from any module)
     const galleryDirectoryToModules = new Map();
+    // Build a schema/source snapshot so the shared resolver can cross-reference
+    // keyof:check-keys and router:check-route against every module's data.
+    const snapshot = {
+      schemas: {},
+      sources: {}
+    };
     for (const [moduleFilePathS, schema] of entries) {
+      const moduleFilePath = moduleFilePathS;
       const serialized = schema["executeSerialize"]();
+      snapshot.schemas[moduleFilePath] = serialized;
+      const sourceForModule = sources[moduleFilePath];
+      if (sourceForModule !== undefined) {
+        snapshot.sources[moduleFilePath] = sourceForModule;
+      }
       if (serialized.type === "record" && serialized.mediaType && serialized.directory) {
         const dir = serialized.directory;
         const existing = galleryDirectoryToModules.get(dir);
         if (existing) {
-          existing.push(moduleFilePathS);
+          existing.push(moduleFilePath);
         } else {
-          galleryDirectoryToModules.set(dir, [moduleFilePathS]);
+          galleryDirectoryToModules.set(dir, [moduleFilePath]);
         }
       }
     }
@@ -1993,78 +1830,12 @@ class ValOps {
               }
             } else if ((_validationError$fixe = validationError.fixes) !== null && _validationError$fixe !== void 0 && _validationError$fixe.includes("image:check-remote") || (_validationError$fixe2 = validationError.fixes) !== null && _validationError$fixe2 !== void 0 && _validationError$fixe2.includes("file:check-remote")) {
               remoteFiles[sourcePath] = validationError.value;
-            } else if ((_validationError$fixe3 = validationError.fixes) !== null && _validationError$fixe3 !== void 0 && _validationError$fixe3.includes("keyof:check-keys")) {
-              const TYPE_ERROR_MESSAGE = `This is most likely a Val version mismatch or Val bug.`;
-              if (!validationError.value) {
-                addError({
-                  message: `Could not find a value for keyOf at ${sourcePath}. ${TYPE_ERROR_MESSAGE}`,
-                  // Not sure this is a type error, but it shouldn't happen in a normally functioning Val system
-                  typeError: true
-                });
-              } else {
-                if (typeof validationError.value !== "object") {
-                  addError({
-                    message: `Expected keyOf validation error to have a 'value' property of type 'object'. Found: ${typeof validationError.value}. ${TYPE_ERROR_MESSAGE}`,
-                    // Not sure this is a type error, but it shouldn't happen in a normally functioning Val system
-                    typeError: true
-                  });
-                } else {
-                  const key = "key" in validationError.value && validationError.value.key;
-                  const validationErrorSourcePath = "sourcePath" in validationError.value && validationError.value.sourcePath;
-                  if (typeof key !== "string") {
-                    addError({
-                      message: `Expected keyOf validation error 'value' to have property 'key' of type 'string'. Found: ${typeof key}. ${TYPE_ERROR_MESSAGE}`,
-                      // Not sure this is a type error, but it shouldn't happen in a normally functioning Val system
-                      typeError: true
-                    });
-                  } else if (typeof validationErrorSourcePath !== "string") {
-                    addError({
-                      message: `Expected keyOf validation error 'value' to have property 'sourcePath' of type 'string'. Found: ${typeof validationErrorSourcePath}. ${TYPE_ERROR_MESSAGE}`,
-                      // Not sure this is a type error, but it shouldn't happen in a normally functioning Val system
-                      typeError: true
-                    });
-                  } else {
-                    const res = await checkKeyIsValid(key, validationErrorSourcePath);
-                    if (res.error) {
-                      addError({
-                        message: res.message
-                      });
-                    }
-                  }
-                }
-              }
-            } else if ((_validationError$fixe4 = validationError.fixes) !== null && _validationError$fixe4 !== void 0 && _validationError$fixe4.includes("router:check-route")) {
-              const TYPE_ERROR_MESSAGE = `This is most likely a Val version mismatch or Val bug.`;
-              if (!validationError.value) {
-                addError({
-                  message: `Could not find a value for route at ${sourcePath}. ${TYPE_ERROR_MESSAGE}`,
-                  typeError: true
-                });
-              } else {
-                if (typeof validationError.value !== "object") {
-                  addError({
-                    message: `Expected route validation error to have a 'value' property of type 'object'. Found: ${typeof validationError.value}. ${TYPE_ERROR_MESSAGE}`,
-                    typeError: true
-                  });
-                } else {
-                  const route = "route" in validationError.value && validationError.value.route;
-                  const includePattern = "include" in validationError.value && validationError.value.include;
-                  const excludePattern = "exclude" in validationError.value && validationError.value.exclude;
-                  if (typeof route !== "string") {
-                    addError({
-                      message: `Expected route validation error 'value' to have property 'route' of type 'string'. Found: ${typeof route}. ${TYPE_ERROR_MESSAGE}`,
-                      typeError: true
-                    });
-                  } else {
-                    const res = await checkRouteIsValid(route, includePattern && typeof includePattern === "object" && "source" in includePattern && "flags" in includePattern ? includePattern : undefined, excludePattern && typeof excludePattern === "object" && "source" in excludePattern && "flags" in excludePattern ? excludePattern : undefined);
-                    if (res.error) {
-                      addError({
-                        message: res.message
-                      });
-                    }
-                  }
-                }
+            } else if ((_validationError$fixe3 = validationError.fixes) !== null && _validationError$fixe3 !== void 0 && _validationError$fixe3.includes("keyof:check-keys") || (_validationError$fixe4 = validationError.fixes) !== null && _validationError$fixe4 !== void 0 && _validationError$fixe4.includes("router:check-route")) {
+              const resolved = internal.resolveSchemaSourceFixForError(validationError, snapshot);
+              if (resolved && resolved.status === "remaining") {
+                addError(resolved.error);
               }
+              // resolved.status === "resolved" → drop silently
             } else if ((_validationError$fixe5 = validationError.fixes) !== null && _validationError$fixe5 !== void 0 && _validationError$fixe5.includes("images:check-unique-folder") || (_validationError$fixe6 = validationError.fixes) !== null && _validationError$fixe6 !== void 0 && _validationError$fixe6.includes("files:check-unique-folder")) {
               const TYPE_ERROR_MESSAGE = `This is most likely a Val version mismatch or Val bug.`;
               if (!validationError.value || typeof validationError.value !== "object") {
@@ -4741,7 +4512,7 @@ function hasRemoteFileSchema(schema) {
       }
     }
     return false;
-  } else if (schema.type === "boolean" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "keyOf" || schema.type === "route") {
+  } else if (schema.type === "boolean" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "keyOf" || schema.type === "route") {
     return false;
   } else {
     const exhaustiveCheck = schema;
@@ -5915,21 +5686,29 @@ const ValServer = (valModules, options, callbacks) => {
         const schemasRes = await serverOps.getSchemas();
         let sourcesRes = await serverOps.getSources();
         const unpatchedSources = sourcesRes.sources;
-        const onlyPatchedTreeModules = await serverOps.getSources({
-          ...patchAnalysis,
-          ...patchOps
-        });
-        sourcesRes = {
-          sources: {
-            ...sourcesRes.sources,
-            ...(onlyPatchedTreeModules.sources || {})
-          },
-          errors: {
-            ...sourcesRes.errors,
-            ...(onlyPatchedTreeModules.errors || {})
-          }
+        // Default to true to keep the legacy contract for older clients.
+        // The studio client always passes false: it owns patch application
+        // and rendering, and treats /sources/~ as a pure un-patched read.
+        const applyPatches = query.apply_patches !== false;
+        if (applyPatches) {
+          const onlyPatchedTreeModules = await serverOps.getSources({
+            ...patchAnalysis,
+            ...patchOps
+          });
+          sourcesRes = {
+            sources: {
+              ...sourcesRes.sources,
+              ...(onlyPatchedTreeModules.sources || {})
+            },
+            errors: {
+              ...sourcesRes.errors,
+              ...(onlyPatchedTreeModules.errors || {})
+            }
+          };
+        }
+        const renderRes = applyPatches ? await serverOps.getRenders(schemasRes, sourcesRes.sources) : {
+          renders: {}
         };
-        const renderRes = await serverOps.getRenders(schemasRes, sourcesRes.sources);
         let sourcesValidation = {
           errors: {},
           files: {},
@@ -5977,7 +5756,9 @@ const ValServer = (valModules, options, callbacks) => {
             const hasPatches = (((_patchAnalysis$patche2 = patchAnalysis.patchesByModule[moduleFilePath]) === null || _patchAnalysis$patche2 === void 0 ? void 0 : _patchAnalysis$patche2.length) ?? 0) > 0;
             modules[moduleFilePath] = {
               source: module,
-              baseSource: hasPatches ? unpatchedSources[moduleFilePath] : undefined,
+              // baseSource is only meaningful when the server applied patches:
+              // with apply_patches=false, `source` is already un-patched.
+              baseSource: applyPatches && hasPatches ? unpatchedSources[moduleFilePath] : undefined,
               render: renderRes.renders[moduleFilePath] || null,
               patches: appliedPatches.length > 0 || skippedPatches.length > 0 || Object.keys(patchErrors).length > 0 ? {
                 applied: appliedPatches,