@valbuild/cli 0.105.1 → 0.106.0

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

@@ -71,8 +71,13 @@ async function* runValidation({
   const service = await server.createService(projectRoot, fs);
 
   // Modules registered in the project's val.modules. Files found on disk that
-  // are not registered here are not validated (a warning is emitted instead).
+  // are not registered here are not validated; what (if anything) is reported
+  // for them is decided by `reportUnregistered` below.
   const registered = new Set(service.getModuleFilePaths());
+
+  // Only used for files that are NOT registered, so it never duplicates the
+  // evaluation `createService` already did.
+  const inspectValModuleFile = server.createValModuleFileInspector(projectRoot, fs);
   let errors = 0;
 
   // Build a single schema/source snapshot up front so the shared resolver
@@ -94,15 +99,51 @@ async function* runValidation({
       snapshot.sources[moduleFilePath] = valModule.source;
     }
   }
-  async function* validateFile(file) {
-    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
-    if (!registered.has(moduleFilePath)) {
+
+  /**
+   * What to report for a `*.val.ts` file that val.modules does not register.
+   *
+   * The `*.val.ts` suffix is used for more than Val modules — shared schemas and
+   * other content-adjacent helpers wear it too — and those are not meant to be
+   * registered, so warning about every unregistered file buries the one warning
+   * that matters under a wall of noise. The default export is what separates
+   * them: a file that default exports a module is one someone meant to register
+   * and forgot (a warning), a file that default exports something else can never
+   * be loaded by Val under that name (an error), and a file with no default
+   * export is simply not a module (silence).
+   */
+  async function* reportUnregistered(file) {
+    const start = Date.now();
+    const inspection = inspectValModuleFile(path__default["default"].join(projectRoot, file));
+    if (inspection.status === "no-default-export") {
+      return;
+    }
+    if (inspection.status === "val-module") {
       yield {
         type: "unregistered-module",
         file
       };
       return;
     }
+    errors += 1;
+    yield {
+      type: "fatal-error",
+      file: `/${file}`,
+      message: inspection.message
+    };
+    yield {
+      type: "file-error-count",
+      file: `/${file}`,
+      errorCount: 1,
+      durationMs: Date.now() - start
+    };
+  }
+  async function* validateFile(file) {
+    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
+    if (!registered.has(moduleFilePath)) {
+      yield* reportUnregistered(file);
+      return;
+    }
     const start = Date.now();
     const valModule = await service.get(moduleFilePath, "", {
       validate: true

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

@@ -71,8 +71,13 @@ async function* runValidation({
   const service = await server.createService(projectRoot, fs);
 
   // Modules registered in the project's val.modules. Files found on disk that
-  // are not registered here are not validated (a warning is emitted instead).
+  // are not registered here are not validated; what (if anything) is reported
+  // for them is decided by `reportUnregistered` below.
   const registered = new Set(service.getModuleFilePaths());
+
+  // Only used for files that are NOT registered, so it never duplicates the
+  // evaluation `createService` already did.
+  const inspectValModuleFile = server.createValModuleFileInspector(projectRoot, fs);
   let errors = 0;
 
   // Build a single schema/source snapshot up front so the shared resolver
@@ -94,15 +99,51 @@ async function* runValidation({
       snapshot.sources[moduleFilePath] = valModule.source;
     }
   }
-  async function* validateFile(file) {
-    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
-    if (!registered.has(moduleFilePath)) {
+
+  /**
+   * What to report for a `*.val.ts` file that val.modules does not register.
+   *
+   * The `*.val.ts` suffix is used for more than Val modules — shared schemas and
+   * other content-adjacent helpers wear it too — and those are not meant to be
+   * registered, so warning about every unregistered file buries the one warning
+   * that matters under a wall of noise. The default export is what separates
+   * them: a file that default exports a module is one someone meant to register
+   * and forgot (a warning), a file that default exports something else can never
+   * be loaded by Val under that name (an error), and a file with no default
+   * export is simply not a module (silence).
+   */
+  async function* reportUnregistered(file) {
+    const start = Date.now();
+    const inspection = inspectValModuleFile(path__default["default"].join(projectRoot, file));
+    if (inspection.status === "no-default-export") {
+      return;
+    }
+    if (inspection.status === "val-module") {
       yield {
         type: "unregistered-module",
         file
       };
       return;
     }
+    errors += 1;
+    yield {
+      type: "fatal-error",
+      file: `/${file}`,
+      message: inspection.message
+    };
+    yield {
+      type: "file-error-count",
+      file: `/${file}`,
+      errorCount: 1,
+      durationMs: Date.now() - start
+    };
+  }
+  async function* validateFile(file) {
+    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
+    if (!registered.has(moduleFilePath)) {
+      yield* reportUnregistered(file);
+      return;
+    }
     const start = Date.now();
     const valModule = await service.get(moduleFilePath, "", {
       validate: true

package/cli/dist/valbuild-cli-cli.esm.js

@@ -5,7 +5,7 @@ import pc from 'picocolors';
 import fs$1 from 'fs/promises';
 import { glob } from 'fast-glob';
 import { Internal, DEFAULT_VAL_REMOTE_HOST, DEFAULT_CONTENT_HOST } from '@valbuild/core';
-import { createService, fixHandlers, createFixPatch, getModulePathRange, findJsonEntryFilePath, createJsonEntryPathMap, createModulePathMap, findAndEvalValConfigFile, getSettings, uploadRemoteFile, createDefaultValFSHost, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, loadValModules, safeReadGit, ValOpsHttp, ValOpsFS, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, formatPatchSourceError } from '@valbuild/server';
+import { createService, createValModuleFileInspector, fixHandlers, createFixPatch, getModulePathRange, findJsonEntryFilePath, createJsonEntryPathMap, createModulePathMap, findAndEvalValConfigFile, getSettings, uploadRemoteFile, createDefaultValFSHost, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, loadValModules, safeReadGit, ValOpsHttp, ValOpsFS, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, formatPatchSourceError } from '@valbuild/server';
 import { resolveSchemaSourceFixes } from '@valbuild/shared/internal';
 import fs from 'fs';
 import ts from 'typescript';
@@ -39,8 +39,13 @@ async function* runValidation({
   const service = await createService(projectRoot, fs);
 
   // Modules registered in the project's val.modules. Files found on disk that
-  // are not registered here are not validated (a warning is emitted instead).
+  // are not registered here are not validated; what (if anything) is reported
+  // for them is decided by `reportUnregistered` below.
   const registered = new Set(service.getModuleFilePaths());
+
+  // Only used for files that are NOT registered, so it never duplicates the
+  // evaluation `createService` already did.
+  const inspectValModuleFile = createValModuleFileInspector(projectRoot, fs);
   let errors = 0;
 
   // Build a single schema/source snapshot up front so the shared resolver
@@ -62,15 +67,51 @@ async function* runValidation({
       snapshot.sources[moduleFilePath] = valModule.source;
     }
   }
-  async function* validateFile(file) {
-    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
-    if (!registered.has(moduleFilePath)) {
+
+  /**
+   * What to report for a `*.val.ts` file that val.modules does not register.
+   *
+   * The `*.val.ts` suffix is used for more than Val modules — shared schemas and
+   * other content-adjacent helpers wear it too — and those are not meant to be
+   * registered, so warning about every unregistered file buries the one warning
+   * that matters under a wall of noise. The default export is what separates
+   * them: a file that default exports a module is one someone meant to register
+   * and forgot (a warning), a file that default exports something else can never
+   * be loaded by Val under that name (an error), and a file with no default
+   * export is simply not a module (silence).
+   */
+  async function* reportUnregistered(file) {
+    const start = Date.now();
+    const inspection = inspectValModuleFile(path.join(projectRoot, file));
+    if (inspection.status === "no-default-export") {
+      return;
+    }
+    if (inspection.status === "val-module") {
       yield {
         type: "unregistered-module",
         file
       };
       return;
     }
+    errors += 1;
+    yield {
+      type: "fatal-error",
+      file: `/${file}`,
+      message: inspection.message
+    };
+    yield {
+      type: "file-error-count",
+      file: `/${file}`,
+      errorCount: 1,
+      durationMs: Date.now() - start
+    };
+  }
+  async function* validateFile(file) {
+    const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
+    if (!registered.has(moduleFilePath)) {
+      yield* reportUnregistered(file);
+      return;
+    }
     const start = Date.now();
     const valModule = await service.get(moduleFilePath, "", {
       validate: true

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.105.1",
+  "version": "0.106.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -27,11 +27,11 @@
     "open": "^9.1.0",
     "picocolors": "^1.1.1",
     "zod": "^4.3.5",
-    "@valbuild/core": "0.105.1",
+    "@valbuild/core": "0.106.0",
     "@valbuild/eslint-plugin": "0.93.0",
-    "@valbuild/language-server": "0.105.1",
-    "@valbuild/server": "0.105.1",
-    "@valbuild/shared": "0.105.1"
+    "@valbuild/language-server": "0.106.0",
+    "@valbuild/server": "0.106.0",
+    "@valbuild/shared": "0.106.0"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/__fixtures__/basic/content/unregistered-helper.val.ts

@@ -0,0 +1,5 @@
+import { s } from "../val.config";
+
+// A shared schema that happens to wear the `.val.ts` suffix. It has no default
+// export, so it is not a Val module and `validate` says nothing about it.
+export const helperSchema = s.object({ text: s.string() });

package/src/__fixtures__/basic/content/unregistered-module.val.ts

@@ -0,0 +1,9 @@
+import { s, c } from "../val.config";
+
+// Deliberately NOT in val.modules: a real Val module someone forgot to
+// register, which `validate` warns about.
+export default c.define(
+  "/content/unregistered-module.val.ts",
+  s.object({ text: s.string() }),
+  { text: "hi" },
+);

package/src/__fixtures__/basic/content/unregistered-not-a-module.val.ts

@@ -0,0 +1,5 @@
+import { s } from "../val.config";
+
+// A default export that is not a Val module: nothing can ever load this file
+// under this name, so `validate` reports it as an error.
+export default s.object({ text: s.string() });

package/src/__fixtures__/basic/content/unregistered-throwing-helper.val.ts

@@ -0,0 +1,3 @@
+// Throws while being imported, so anything that inspects it - or a file that
+// imports it - has to survive a half-built module cache entry.
+throw Error("helper boom");

package/src/__fixtures__/basic/content/unregistered-throws-a.val.ts

@@ -0,0 +1,3 @@
+import "./unregistered-throwing-helper.val";
+
+export default "a";

package/src/__fixtures__/basic/content/unregistered-throws-b.val.ts

@@ -0,0 +1,3 @@
+import "./unregistered-throwing-helper.val";
+
+export default "b";

package/src/__fixtures__/basic/content/unregistered-type-default.val.ts

@@ -0,0 +1,7 @@
+import { s } from "../val.config";
+
+// A type-only default export: it does not survive transpilation, so this file
+// has no runtime default export and is just a helper.
+export const typeDefaultSchema = s.object({ text: s.string() });
+type TypeDefault = { text: string };
+export type { TypeDefault as default };

package/src/runValidation.test.ts

@@ -485,6 +485,104 @@ describe("runValidation", () => {
     expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0);
   });
 
+  describe("unregistered files", () => {
+    const runOn = async (valFiles: string[]) => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix: false,
+        valFiles,
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      return events;
+    };
+
+    test("warns about an unregistered file that IS a Val module", async () => {
+      const events = await runOn(["content/unregistered-module.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          {
+            type: "unregistered-module",
+            file: "content/unregistered-module.val.ts",
+          },
+        ]),
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-success" });
+    });
+
+    test("says nothing about an unregistered file with no default export", async () => {
+      // The `.val.ts` suffix is used for shared schemas and other helpers too.
+      // Those are not meant to be registered, so warning about them buried the
+      // one warning that matters under a wall of noise.
+      const events = await runOn(["content/unregistered-helper.val.ts"]);
+
+      expect(events.filter((e) => e.type !== "summary-success")).toHaveLength(
+        0,
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-success" });
+    });
+
+    test("says nothing about a type-only default export", async () => {
+      // `export type { T as default }` does not survive transpilation, so the
+      // file has no runtime default export - evaluating it would report a pure
+      // helper as an error.
+      const events = await runOn(["content/unregistered-type-default.val.ts"]);
+
+      expect(events.filter((e) => e.type !== "summary-success")).toHaveLength(
+        0,
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-success" });
+    });
+
+    test("errors when an unregistered file default exports a non-module", async () => {
+      // Nothing can ever load this file under this name, so it is not something
+      // to skip quietly - it is a mistake.
+      const events = await runOn(["content/unregistered-not-a-module.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "fatal-error",
+            file: "/content/unregistered-not-a-module.val.ts",
+            message: expect.stringContaining("not a Val module"),
+          }),
+        ]),
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+    });
+
+    test("reports every file broken by the same throwing import", async () => {
+      // Regression: the inspector shares one module cache across files, and the
+      // loader caches a module BEFORE evaluating it so cycles resolve. A module
+      // that threw therefore left a half-built entry behind, and the next file
+      // to import it hit that entry, saw empty exports, and got reported as
+      // "default export is undefined" - downgrading a real error to a warning,
+      // in an order-dependent way.
+      const events = await runOn([
+        "content/unregistered-throws-a.val.ts",
+        "content/unregistered-throws-b.val.ts",
+      ]);
+
+      const fatal = events.filter((e) => e.type === "fatal-error");
+      expect(fatal).toEqual([
+        expect.objectContaining({
+          file: "/content/unregistered-throws-a.val.ts",
+          message: expect.stringContaining("helper boom"),
+        }),
+        expect.objectContaining({
+          file: "/content/unregistered-throws-b.val.ts",
+          message: expect.stringContaining("helper boom"),
+        }),
+      ]);
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 2 });
+    });
+  });
+
   describe("jsonValues", () => {
     const runOn = async (valFiles: string[]) => {
       const events: ValidationEvent[] = [];

package/src/runValidation.ts

@@ -3,6 +3,7 @@ import {
   createDefaultValFSHost,
   createFixPatch,
   createService,
+  createValModuleFileInspector,
   fixHandlers,
   type FixHandlerContext,
   type IValFSHost,
@@ -61,9 +62,14 @@ export async function* runValidation({
   const service = await createService(projectRoot, fs);
 
   // Modules registered in the project's val.modules. Files found on disk that
-  // are not registered here are not validated (a warning is emitted instead).
+  // are not registered here are not validated; what (if anything) is reported
+  // for them is decided by `reportUnregistered` below.
   const registered = new Set<ModuleFilePath>(service.getModuleFilePaths());
 
+  // Only used for files that are NOT registered, so it never duplicates the
+  // evaluation `createService` already did.
+  const inspectValModuleFile = createValModuleFileInspector(projectRoot, fs);
+
   let errors = 0;
 
   // Build a single schema/source snapshot up front so the shared resolver
@@ -83,10 +89,48 @@ export async function* runValidation({
     }
   }
 
+  /**
+   * What to report for a `*.val.ts` file that val.modules does not register.
+   *
+   * The `*.val.ts` suffix is used for more than Val modules — shared schemas and
+   * other content-adjacent helpers wear it too — and those are not meant to be
+   * registered, so warning about every unregistered file buries the one warning
+   * that matters under a wall of noise. The default export is what separates
+   * them: a file that default exports a module is one someone meant to register
+   * and forgot (a warning), a file that default exports something else can never
+   * be loaded by Val under that name (an error), and a file with no default
+   * export is simply not a module (silence).
+   */
+  async function* reportUnregistered(
+    file: string,
+  ): AsyncGenerator<ValidationEvent> {
+    const start = Date.now();
+    const inspection = inspectValModuleFile(path.join(projectRoot, file));
+    if (inspection.status === "no-default-export") {
+      return;
+    }
+    if (inspection.status === "val-module") {
+      yield { type: "unregistered-module", file };
+      return;
+    }
+    errors += 1;
+    yield {
+      type: "fatal-error",
+      file: `/${file}`,
+      message: inspection.message,
+    };
+    yield {
+      type: "file-error-count",
+      file: `/${file}`,
+      errorCount: 1,
+      durationMs: Date.now() - start,
+    };
+  }
+
   async function* validateFile(file: string): AsyncGenerator<ValidationEvent> {
     const moduleFilePath = `/${file}` as ModuleFilePath; // TODO: check if this always works? (Windows?)
     if (!registered.has(moduleFilePath)) {
-      yield { type: "unregistered-module", file };
+      yield* reportUnregistered(file);
       return;
     }
     const start = Date.now();