@valbuild/cli 0.149.7 → 0.150.1

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

@@ -346,6 +346,16 @@ async function* runValidation({
                   sourcePath
                 };
               }
+              if (result.warning !== undefined) {
+                yield {
+                  type: "validation-warning",
+                  sourcePath,
+                  ...result.warning,
+                  ...(v.keyError ? {
+                    keyError: true
+                  } : {})
+                };
+              }
               if (result.fixableErrorMessage !== undefined) {
                 fileErrors += 1;
                 yield {
@@ -683,10 +693,13 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   return entry;
 }
 
+/** How many of a warning group's files are listed before "… N more". */
+const WARNING_FILES_SHOWN = 5;
 async function validate({
   root,
   fix,
-  watch
+  watch,
+  strict
 }) {
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
   let prettier;
@@ -698,7 +711,10 @@ async function validate({
   const runOnce = () => validateOnce({
     projectRoot,
     fix: !!fix,
-    prettier
+    prettier,
+    ...(strict ? {
+      strict: true
+    } : {})
   });
   if (!watch) {
     const totalErrors = await runOnce();
@@ -712,7 +728,7 @@ async function validate({
 
 /**
  * One validation pass over the project, printed as `val validate` prints it,
- * returning the number of errors found.
+ * returning the number of errors found -- and of warnings, under `strict`.
  *
  * Re-reads config and val files on each call so it always reflects the latest
  * state on disk: `val validate` calls it once or on every change (`--watch`),
@@ -722,7 +738,8 @@ async function validateOnce({
   projectRoot,
   fix,
   prettier,
-  blockingOnly = false
+  blockingOnly = false,
+  strict = false
 }) {
   const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
   const resolvedValConfigFile = valConfigFile ? {
@@ -739,6 +756,7 @@ async function validateOnce({
   console.log(pc__default["default"].greenBright(`Found ${valFiles.length} files...`));
   const fixedFiles = new Set();
   let totalErrors = 0;
+  let totalWarnings = 0;
   let repairedOnSave = 0;
 
   // Caches each val file's parsed source so files are read/parsed at most once
@@ -785,10 +803,15 @@ async function validateOnce({
   })) {
     switch (event.type) {
       case "file-valid":
-        valid.push({
-          file: relFile(event.file),
-          durationMs: event.durationMs
-        });
+        // No errors, but it may have warnings: then it is shown with them.
+        if (reports.has(relFile(event.file))) {
+          reportFor(event.file).durationMs = event.durationMs;
+        } else {
+          valid.push({
+            file: relFile(event.file),
+            durationMs: event.durationMs
+          });
+        }
         break;
       case "file-error-count":
         reportFor(event.file).durationMs = event.durationMs;
@@ -816,6 +839,21 @@ async function validateOnce({
           } : {})
         });
         break;
+      case "validation-warning":
+        totalWarnings += 1;
+        reportFor(moduleOf(event.sourcePath)).diagnostics.push({
+          severity: "warning",
+          sourcePath: event.sourcePath,
+          message: event.message,
+          files: event.files,
+          ...(event.hint !== undefined ? {
+            hint: event.hint
+          } : {}),
+          ...(event.keyError ? {
+            keyError: true
+          } : {})
+        });
+        break;
       case "unknown-fix":
         reportFor(moduleOf(event.sourcePath)).diagnostics.push({
           severity: "error",
@@ -858,28 +896,67 @@ async function validateOnce({
 
   // Renders a module's diagnostics under a single left "│" gutter bar, with the
   // file name on top and blank gutter lines for air. Output flows least- to
-  // most-actionable top-to-bottom, so fixable diagnostics are shown last (at the
-  // bottom, nearest the prompt).
+  // most-actionable top-to-bottom: warnings first, then errors, and fixable
+  // errors last (at the bottom, nearest the prompt).
   const renderModule = report => {
     const bar = pc__default["default"].dim("│");
-    const diagnostics = [...report.diagnostics].sort((a, b) => a.severity === b.severity ? 0 : a.severity === "fixable" ? 1 : -1);
+    const rank = {
+      warning: 0,
+      error: 1,
+      fixable: 2
+    };
+    const diagnostics = [...report.diagnostics].sort((a, b) => rank[a.severity] - rank[b.severity]);
+    const warningCount = diagnostics.filter(d => d.severity === "warning").length;
     const fixableCount = diagnostics.filter(d => d.severity === "fixable").length;
-    const total = diagnostics.length;
-    const hasError = fixableCount < total;
-    const symbol = hasError ? pc__default["default"].red("✘") : pc__default["default"].yellow("⚠");
-    let label;
-    if (fixableCount === total) {
-      label = `${fixableCount} fixable`;
-    } else if (fixableCount > 0) {
-      label = `${total} error${total > 1 ? "s" : ""} (${fixableCount} fixable)`;
-    } else {
-      label = `${total} error${total > 1 ? "s" : ""}`;
+    const errorCount = diagnostics.length - warningCount;
+    const symbol = errorCount > 0 ? pc__default["default"].red("✘") : pc__default["default"].yellow("⚠");
+    const labels = [];
+    if (errorCount > 0) {
+      labels.push(`${errorCount} error${errorCount > 1 ? "s" : ""}${fixableCount > 0 ? ` (${fixableCount} fixable)` : ""}`);
+    }
+    if (warningCount > 0) {
+      labels.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
     }
-    console.log(`${pc__default["default"].bold(report.file)}  ${symbol} ${label}  ${pc__default["default"].dim(`(${report.durationMs}ms)`)}`);
+    console.log(`${pc__default["default"].bold(report.file)}  ${symbol} ${labels.join(" · ")}  ${pc__default["default"].dim(`(${report.durationMs}ms)`)}`);
+    const locationOf = d => sourcePathToLocationParts(d.sourcePath, projectRoot, sourceFileCache, d.keyError ? "key" : "value");
+
+    // Warnings say the same thing about many values (every local image in a
+    // gallery), so each message is printed once, over the places it is about.
+    const warningGroups = new Map();
     for (const d of diagnostics) {
-      const target = d.keyError ? "key" : "value";
-      const dsym = d.severity === "fixable" ? pc__default["default"].yellow("⚠") : pc__default["default"].red("✘");
-      const parts = sourcePathToLocationParts(d.sourcePath, projectRoot, sourceFileCache, target);
+      if (d.severity !== "warning") continue;
+      const group = warningGroups.get(d.message);
+      if (group) {
+        group.push(d);
+      } else {
+        warningGroups.set(d.message, [d]);
+      }
+    }
+    for (const [message, group] of warningGroups) {
+      var _group$find;
+      console.log(bar);
+      console.log(`${bar}  ${pc__default["default"].yellow("⚠")}  ${message}`);
+      console.log(bar);
+      for (const d of group.slice(0, WARNING_FILES_SHOWN)) {
+        const parts = locationOf(d);
+        const files = d.files.join(", ");
+        // `file:line:col` first, so VS Code's terminal links it.
+        const where = parts ? `${parts.relativeFile}:${parts.line}:${parts.character}` : d.sourcePath;
+        console.log(`${bar}     ${where}  ${pc__default["default"].dim(files)}`);
+      }
+      if (group.length > WARNING_FILES_SHOWN) {
+        console.log(`${bar}     ${pc__default["default"].dim(`… ${group.length - WARNING_FILES_SHOWN} more`)}`);
+      }
+      const hint = (_group$find = group.find(d => d.hint !== undefined)) === null || _group$find === void 0 ? void 0 : _group$find.hint;
+      if (hint !== undefined) {
+        console.log(bar);
+        console.log(`${bar}     ${pc__default["default"].dim(`→ ${hint}`)}`);
+      }
+    }
+    for (const d of diagnostics) {
+      if (d.severity === "warning") continue;
+      const parts = locationOf(d);
+      const dsym = pc__default["default"].red("✘");
       console.log(bar);
       if (parts) {
         // `file:line:col` (no key/value label) so VS Code's terminal links it.
@@ -888,7 +965,7 @@ async function validateOnce({
       } else {
         console.log(`${bar}  ${dsym}  ${d.message}`);
       }
-      const frame = sourcePathToCodeFrame(d.sourcePath, projectRoot, sourceFileCache, target);
+      const frame = sourcePathToCodeFrame(d.sourcePath, projectRoot, sourceFileCache, d.keyError ? "key" : "value");
       if (frame !== undefined) {
         console.log(bar);
         for (const frameLine of frame.split("\n")) {
@@ -921,10 +998,13 @@ async function validateOnce({
 
   // Render the grouped report least- to most-actionable, top-to-bottom, so the
   // most important things end up at the bottom nearest the prompt: valid files
-  // and skipped modules first, then error-only modules, then fixable modules.
+  // and skipped modules first, then warning-only modules, then error-only
+  // modules, then fixable modules.
   const allReports = [...reports.values()];
+  const hasErrors = r => r.diagnostics.some(d => d.severity !== "warning");
+  const warningModules = allReports.filter(r => !hasErrors(r));
   const fixableModules = allReports.filter(r => r.diagnostics.some(d => d.severity === "fixable"));
-  const errorModules = allReports.filter(r => !r.diagnostics.some(d => d.severity === "fixable"));
+  const errorModules = allReports.filter(r => hasErrors(r) && !r.diagnostics.some(d => d.severity === "fixable"));
   for (const v of valid) {
     console.log(pc__default["default"].green("✔"), pc__default["default"].dim(`${v.file}  valid (${v.durationMs}ms)`));
   }
@@ -934,34 +1014,34 @@ async function validateOnce({
   if (allReports.length > 0) {
     console.log("");
   }
-  for (const report of [...errorModules, ...fixableModules]) {
+  for (const report of [...warningModules, ...errorModules, ...fixableModules]) {
     renderModule(report);
   }
   const fixableTotal = allReports.reduce((n, r) => n + r.diagnostics.filter(d => d.severity === "fixable").length, 0);
+  const errorFiles = allReports.filter(hasErrors).length;
+  const warningFiles = allReports.filter(r => r.diagnostics.some(d => d.severity === "warning")).length;
+  const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+  const warnings = `${plural(totalWarnings, "warning")} in ${plural(warningFiles, "file")}`;
+  const warningPart = totalWarnings > 0 ? `${warnings}${strict ? ", which --strict counts as errors" : ""}` : undefined;
+  const tail = [...(valid.length > 0 ? [`${valid.length} valid`] : []), ...(skipped.length > 0 ? [`${skipped.length} skipped`] : [])];
   if (totalErrors > 0) {
-    let summary = `${totalErrors} error${totalErrors > 1 ? "s" : ""}`;
+    let summary = plural(totalErrors, "error");
     if (fixableTotal > 0) {
       summary += ` (${fixableTotal} fixable)`;
     }
-    summary += ` across ${allReports.length} file${allReports.length > 1 ? "s" : ""}`;
-    if (valid.length > 0) {
-      summary += ` · ${valid.length} valid`;
-    }
-    if (skipped.length > 0) {
-      summary += ` · ${skipped.length} skipped`;
-    }
-    console.log(pc__default["default"].red("✘"), summary);
+    summary += ` across ${plural(errorFiles, "file")}`;
+    console.log(pc__default["default"].red("✘"), [summary, ...(warningPart ? [warningPart] : []), ...tail].join(" · "));
+  } else if (warningPart && strict) {
+    // Not "No validation errors" beside a ✘: under --strict this run failed,
+    // and the warnings are why.
+    console.log(pc__default["default"].red("✘"), [`${warnings}, and --strict fails on warnings`, ...tail].join(" · "));
+  } else if (warningPart) {
+    console.log(pc__default["default"].green("✔"), ["No validation errors", warningPart, ...tail].join(" · "));
   } else {
-    let summary = "No validation errors found";
-    if (valid.length > 0) {
-      summary += ` · ${valid.length} valid`;
-    }
-    if (skipped.length > 0) {
-      summary += ` · ${skipped.length} skipped`;
-    }
-    console.log(pc__default["default"].green("✔"), summary);
+    console.log(pc__default["default"].green("✔"), ["No validation errors found", ...tail].join(" · "));
   }
-  return blockingOnly ? totalErrors - repairedOnSave : totalErrors;
+  const errors = blockingOnly ? totalErrors - repairedOnSave : totalErrors;
+  return strict ? errors + totalWarnings : errors;
 }
 
 // Directory names anywhere in the path that should never be watched.
@@ -1208,9 +1288,10 @@ const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
 
 /**
  * `val connect`: opens admin's `/new` on "your own hosting", with what it can
- * tell from here filled in -- the project `val.config.ts` names and the
- * GitHub repository `origin` points at -- so the person only confirms. The
- * link is printed too, for when no browser opens (over SSH, in a container).
+ * tell from here filled in -- the project `val.config.ts` names, the GitHub
+ * repository `origin` points at, and which folder of it this app is in (a
+ * monorepo has several) -- so the person only confirms. The link is printed
+ * too, for when no browser opens (over SSH, in a container).
  */
 async function connect(options) {
   const {
@@ -1218,20 +1299,23 @@ async function connect(options) {
   } = options;
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
   const project = await tryGetProject(projectRoot);
-  const gitRemote = await tryGetGitRemote(projectRoot);
+  const git = findGitDir(projectRoot);
+  const gitRemote = git ? await tryGetGitRemote(git.config) : null;
   const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
+  const folder = git ? repoFolder(git.top, projectRoot) : null;
   console.log("");
   if (project) {
     console.log(`Found ${pc__default["default"].bold(`${project.orgName}/${project.projectName}`)} in val.config.ts`);
   }
   if (repo) {
-    console.log(`Found ${pc__default["default"].bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`);
+    console.log(`Found ${pc__default["default"].bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")${folder ? `, this app in ${pc__default["default"].bold(folder)}` : ""}`);
   } else {
     console.log(pc__default["default"].dim("No GitHub repository found: push this project to GitHub, or pick or create one in the browser."));
   }
   const url = connectUrl(host, {
     project,
-    repo
+    repo,
+    folder
   });
   const opened = openInBrowser(url);
   console.log(`\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc__default["default"].cyan(url)}\n`);
@@ -1248,6 +1332,7 @@ function connectUrl(host, found) {
   });
   if (found.repo) {
     params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+    if (found.folder) params.set("folder", found.folder);
   }
   if (found.project) {
     params.set("org", found.project.orgName);
@@ -1312,12 +1397,19 @@ function getGitHubOwnerAndRepo(gitRemote) {
     repo: match[2]
   } : null;
 }
-async function tryGetGitRemote(root) {
+
+/**
+ * Where the app is in its repository, with forward slashes: `apps/web`, or ""
+ * when it is at the top. Null when it is not inside the repository at all.
+ */
+function repoFolder(top, projectRoot) {
+  const relative = path__default["default"].relative(top, projectRoot);
+  if (relative.startsWith("..") || path__default["default"].isAbsolute(relative)) return null;
+  return relative.split(path__default["default"].sep).join("/");
+}
+async function tryGetGitRemote(gitConfigPath) {
   try {
-    const gitConfig = tryGetGitConfig(root);
-    if (!gitConfig) {
-      return null;
-    }
+    const gitConfig = fs__default$1["default"].readFileSync(gitConfigPath, "utf-8");
     const remoteMatch = gitConfig.match(/\[remote "origin"\][\s\S]*?url = (.+)/);
     if (remoteMatch && remoteMatch[1]) {
       return remoteMatch[1].trim();
@@ -1328,13 +1420,18 @@ async function tryGetGitRemote(root) {
     return null;
   }
 }
-function tryGetGitConfig(root) {
+
+/** The repository `root` is in: its top folder and its `.git/config`. */
+function findGitDir(root) {
   let currentDir = root;
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path__default["default"].join(currentDir, ".git", "config");
     if (fs__default$1["default"].existsSync(gitConfigPath)) {
-      return fs__default$1["default"].readFileSync(gitConfigPath, "utf-8");
+      return {
+        top: currentDir,
+        config: gitConfigPath
+      };
     }
     lastDir = currentDir;
     currentDir = path__default["default"].dirname(currentDir);
@@ -2504,6 +2601,14 @@ function resolveArtifactsDir(options) {
 async function loadBuilder() {
   try {
     const [build, node] = await Promise.all([Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@valbuild/tanstack-build')); }), Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@valbuild/tanstack-build/node')); })]);
+    /*
+     * Native rolldown rather than its WebAssembly build, whose glue the site's
+     * lockfile picks and can break (`rolldown.ts` in tanstack-build). Asked
+     * for, because the project's own tanstack-build may predate the choice.
+     */
+    if ("useRolldown" in build && "nativeRolldown" in node) {
+      build.useRolldown(node.nativeRolldown);
+    }
     return {
       status: "ok",
       build,
@@ -2517,6 +2622,52 @@ async function loadBuilder() {
   }
 }
 
+/**
+ * Whether `val publish` could build here: the builder loaded as a publish
+ * loads it, and its bundler made to parse and bundle a module. Nothing is
+ * read from the project and nothing is asked of content.
+ *
+ * What Val Build runs on an upgrade's install before a connected project
+ * may publish it, since the project's CI is what builds a connected publish:
+ * an upgrade that resolved a bundler which cannot load would otherwise land
+ * on the branch and fail every build after it (architecture/quirks.md,
+ * 2026-10-26).
+ */
+async function checkBuildTools$1() {
+  const loaded = await loadBuilder();
+  if (loaded.status === "error") return loaded;
+  try {
+    // A builder older than `loadRolldown` loaded its bundler on import.
+    if (!("loadRolldown" in loaded.build)) return {
+      status: "ok"
+    };
+    const {
+      build,
+      parseAstAsync
+    } = await loaded.build.loadRolldown();
+    await parseAstAsync("export const checked = true;");
+    const ENTRY = "\0val-check-build-tools";
+    await build({
+      input: ENTRY,
+      cwd: "/",
+      write: false,
+      plugins: [{
+        name: "val-check-build-tools",
+        resolveId: id => id === ENTRY ? id : null,
+        load: id => id === ENTRY ? "export default 1;" : null
+      }]
+    });
+    return {
+      status: "ok"
+    };
+  } catch (e) {
+    return {
+      status: "error",
+      message: `rolldown loaded, and could not build: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+
 /**
  * The `@valbuild/ui` this checkout runs: the one its `@valbuild/tanstack`
  * resolves, which is a transitive dependency pnpm does not hoist -- so it is
@@ -4009,13 +4160,17 @@ async function publish(options) {
   // the Studio leaves to the server to repair (a local image in a remote
   // project, metadata to fill in) is printed and published, as it would be
   // from the Studio. Every site made on /new starts with its template's
-  // images local, so counting those would refuse its first publish.
+  // images local, so counting those would refuse its first publish: they are
+  // warnings, and refuse a publish only under --strict.
   if (!options.skipValidation) {
     const projectRoot = options.root ? path__default["default"].resolve(options.root) : process.cwd();
     const errorCount = await validateOnce({
       projectRoot,
       fix: false,
-      blockingOnly: true
+      blockingOnly: true,
+      ...(options.strict ? {
+        strict: true
+      } : {})
     });
     if (errorCount > 0) {
       error(`Not published: ${errorCount} validation error${errorCount === 1 ? "" : "s"}.`);
@@ -4234,6 +4389,20 @@ async function ciReport(options) {
   console.log(pc__default["default"].dim(`Reported the build of ${read.report.commit.slice(0, 7)} as ${read.report.status}.`));
 }
 
+/**
+ * `val check-build-tools` -- a thin shell around `checkBuildTools`: says
+ * whether `val publish` could build here, and fails when it could not.
+ */
+async function checkBuildTools() {
+  const checked = await checkBuildTools$1();
+  if (checked.status === "error") {
+    console.error(pc__default["default"].red(checked.message));
+    process.exitCode = 1;
+    return;
+  }
+  console.log("val publish can build here.");
+}
+
 async function main() {
   const {
     input,
@@ -4263,6 +4432,7 @@ async function main() {
         --root [root], -r [root] Set project root directory (default process.cwd())
         --fix  [fix]             Attempt to fix validation errors
         --watch, -w              Re-validate on changes to val.config, val.modules and *.val files
+        --strict                 Fail on warnings too (local files in a project with remote files)
 
       
       Command: login
@@ -4320,6 +4490,13 @@ async function main() {
         --dry-run                Verify, and stop before the site changes
         --skip-validation        Publish without running "val validate" first. It runs by
                                  default, and an error stops the publish
+        --strict                 Let a validation warning stop the publish too
+
+      Command: check-build-tools
+      Description: load what "val publish" builds with, and build a one-line module with
+        it: whether this install could publish, without asking content anything. Val Build
+        runs it on an upgrade's install before a connected project can publish the upgrade.
+        Fails when it could not.
 
       Command: list-unused-files
       Description: EXPERIMENTAL.
@@ -4414,6 +4591,9 @@ async function main() {
       skipValidation: {
         type: "boolean"
       },
+      strict: {
+        type: "boolean"
+      },
       yes: {
         type: "boolean"
       },
@@ -4468,6 +4648,8 @@ async function main() {
         yes: flags.yes,
         verbose: flags.verbose
       });
+    case "check-build-tools":
+      return checkBuildTools();
     case "ci-report":
       return ciReport({
         root: flags.root,
@@ -4486,7 +4668,8 @@ async function main() {
         buildHash: flags.buildHash,
         linksOwnCss: flags.linksOwnCss,
         dryRun: flags.dryRun,
-        skipValidation: flags.skipValidation
+        skipValidation: flags.skipValidation,
+        strict: flags.strict
       });
     case "login":
       return login({
@@ -4510,7 +4693,8 @@ async function main() {
       return validate({
         root: flags.root,
         fix: flags.fix,
-        watch: flags.watch
+        watch: flags.watch,
+        strict: flags.strict
       });
     default:
       return error(`Unknown command "${input.join(" ")}"`);