@valbuild/cli 0.134.0 → 0.135.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @valbuild/cli
 
+## 0.135.0
+
+### Patch Changes
+
+- [#707](https://github.com/valbuild/val/pull/707) [`c9affec`](https://github.com/valbuild/val/commit/c9affece6ae6ba62bd6c1113ed1fdab6317fa112) Thanks [@freekh](https://github.com/freekh)! - `val validate --fix` now formats with your prettier config instead of prettier's defaults
+
+  `--fix` formatted the files it repaired by calling `prettier.format(code, { filepath })`, which never reads `.prettierrc`: `filepath` picks the parser and nothing else — only `resolveConfig`, `getFileInfo` and prettier's own CLI consult the config. On a project whose style is not prettier's default, a two-line content fix therefore arrived as a whole-file rewrite, and in a repo with a format check in CI it turned a content fix into a red build.
+
+  There is now one implementation of "format a written file the way this project does", `createPrettierFormatter`, exported from `@valbuild/server` and re-exported by `@valbuild/next/server` and `@valbuild/tanstack/server`. It resolves `.prettierrc` for each file (including any `overrides` that match it), leaves anything in `.prettierignore` untouched, and falls back to prettier's defaults when the project has no config. `val validate --fix` uses it, so the CLI and the Studio can no longer disagree about formatting.
+
+  Use it for your app's `formatter` too — this is the recommended setup, and it replaces reading `.prettierrc.json` by hand:
+
+  ```ts
+  import prettier from "prettier";
+  import {
+    initValServer,
+    createPrettierFormatter,
+  } from "@valbuild/next/server";
+
+  const { valNextAppRouter } = initValServer(
+    valModules,
+    { ...config },
+    {
+      draftMode,
+      formatter: createPrettierFormatter(prettier, {
+        projectRoot: process.cwd(),
+      }),
+    },
+  );
+  ```
+
+  Existing `formatter` callbacks keep working unchanged.
+
+- Updated dependencies [[`c9affec`](https://github.com/valbuild/val/commit/c9affece6ae6ba62bd6c1113ed1fdab6317fa112), [`72a7ca7`](https://github.com/valbuild/val/commit/72a7ca78354fff00e37a51359b17fba9334dc5e6)]:
+  - @valbuild/server@0.135.0
+  - @valbuild/language-server@0.135.0
+
+## 0.134.1
+
+### Patch Changes
+
+- Updated dependencies [[`821e789`](https://github.com/valbuild/val/commit/821e789c1af47510af5d23eb96384ff78ddd7646)]:
+  - @valbuild/shared@0.134.1
+  - @valbuild/language-server@0.134.1
+  - @valbuild/server@0.134.1
+
 ## 0.134.0
 
 ### Minor Changes

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

@@ -4,12 +4,12 @@ var meow = require('meow');
 var chalk = require('chalk');
 var path = require('path');
 var pc = require('picocolors');
-var fs$1 = require('fs/promises');
 var fastGlob = require('fast-glob');
 var core = require('@valbuild/core');
 var server = require('@valbuild/server');
+var fs = require('fs/promises');
 var internal = require('@valbuild/shared/internal');
-var fs = require('fs');
+var fs$1 = require('fs');
 var ts = require('typescript');
 var JSZip = require('jszip');
 var readline = require('readline');
@@ -42,8 +42,8 @@ var meow__default = /*#__PURE__*/_interopDefault(meow);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pc__default = /*#__PURE__*/_interopDefault(pc);
-var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
@@ -65,6 +65,62 @@ function info(message, opts = {}) {
   console.log(chalk__default["default"].blue("️ℹ️ : ") + message);
 }
 
+/** A file whose fix landed but which could not be formatted afterwards. */
+
+/**
+ * Format the files `--fix` just wrote, the way the project formats everything.
+ *
+ * Through `createPrettierFormatter`, which is the same function an app hands to
+ * `initValServer` / `initValMcp`, so a fix applied here and an edit saved from
+ * the Studio come out identically formatted. Calling
+ * `prettier.format(code, { filepath })` directly — which this did — reads no
+ * config at all: `filepath` picks the parser, and `.prettierrc` is only ever
+ * consulted by `resolveConfig`, `getFileInfo` and prettier's own CLI. A project
+ * whose style is not prettier's default got its whole file rewritten by a
+ * two-line content fix, and a red `format` job with it.
+ *
+ * Separate from `validate.ts` so it can be tested against a real project on
+ * disk: `runValidation` stops before this step, and `validate()` itself ends in
+ * `process.exit`, so neither can reach it from a test.
+ *
+ * Rendering is the caller's, which is why failures are returned rather than
+ * logged. A file that cannot be formatted is not a failed run: the fix itself
+ * landed, and stopping here would leave the fix applied and the report unwritten.
+ */
+async function formatFixedFiles(prettier, projectRoot, files) {
+  const format = server.createPrettierFormatter(prettier, {
+    projectRoot
+  });
+  const written = [];
+  const failures = [];
+  for (const file of files) {
+    const filePath = path__default["default"].join(projectRoot, file);
+    const fileContent = await fs__default["default"].readFile(filePath, "utf-8");
+    let formattedContent;
+    try {
+      formattedContent = await format(fileContent, file);
+    } catch (err) {
+      failures.push({
+        file,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    // A file prettier left alone — one the project put in `.prettierignore`,
+    // or one already in its final form — is not rewritten. Writing identical
+    // bytes still bumps the mtime, and a `--fix` run alongside a dev server
+    // makes it rebuild for nothing.
+    if (formattedContent !== fileContent) {
+      await fs__default["default"].writeFile(filePath, formattedContent);
+      written.push(file);
+    }
+  }
+  return {
+    written,
+    failures
+  };
+}
+
 async function* runValidation({
   root,
   fix,
@@ -560,7 +616,7 @@ function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
   const filePath = path__default["default"].join(projectRoot, jsonFilePath);
   let fileContent;
   try {
-    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+    fileContent = fs__default$1["default"].readFileSync(filePath, "utf-8");
   } catch {
     cache.set(jsonFilePath, null);
     return null;
@@ -580,7 +636,7 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const filePath = path__default["default"].join(projectRoot, moduleFilePath);
   let fileContent;
   try {
-    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+    fileContent = fs__default$1["default"].readFileSync(filePath, "utf-8");
   } catch {
     cache.set(moduleFilePath, null);
     return null;
@@ -788,15 +844,19 @@ async function validate({
       console.log("");
     };
 
-    // Run prettier on files that had fixes applied
+    // Format the files that had fixes applied, the way the project formats
+    // everything else. See `formatFixedFiles` for why this cannot simply be
+    // `prettier.format(code, { filepath })`.
+    //
+    // A file that could not be formatted is reported and skipped rather than
+    // thrown: the fix itself landed, and aborting here would leave the fix
+    // applied and the report below unwritten.
     if (prettier) {
-      for (const file of fixedFiles) {
-        const filePath = path__default["default"].join(projectRoot, file);
-        const fileContent = await fs__default$1["default"].readFile(filePath, "utf-8");
-        const formattedContent = await prettier.format(fileContent, {
-          filepath: filePath
-        });
-        await fs__default$1["default"].writeFile(filePath, formattedContent);
+      const {
+        failures
+      } = await formatFixedFiles(prettier, projectRoot, fixedFiles);
+      for (const failure of failures) {
+        console.log(pc__default["default"].yellow("⚠"), `Could not format ${relFile(failure.file)}: ${failure.message}`);
       }
     }
 
@@ -1084,8 +1144,8 @@ function tryGetGitConfig(root) {
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path__default["default"].join(currentDir, ".git", "config");
-    if (fs__default["default"].existsSync(gitConfigPath)) {
-      return fs__default["default"].readFileSync(gitConfigPath, "utf-8");
+    if (fs__default$1["default"].existsSync(gitConfigPath)) {
+      return fs__default$1["default"].readFileSync(gitConfigPath, "utf-8");
     }
     lastDir = currentDir;
     currentDir = path__default["default"].dirname(currentDir);
@@ -1162,7 +1222,7 @@ class DebugContextError extends Error {}
 async function createDebugContext(options) {
   var _config$files;
   const projectRoot = options.root ? path__default["default"].resolve(options.root) : process.cwd();
-  if (!fs__default["default"].existsSync(projectRoot)) {
+  if (!fs__default$1["default"].existsSync(projectRoot)) {
     throw new DebugContextError(`Project root does not exist: ${projectRoot}`);
   }
   const config = await server.findAndEvalValConfigFile(projectRoot);
@@ -1235,8 +1295,8 @@ async function createDebugContext(options) {
  */
 function readAuth(projectRoot) {
   const patFile = server.getPersonalAccessTokenPath(projectRoot);
-  if (fs__default["default"].existsSync(patFile)) {
-    const contents = fs__default["default"].readFileSync(patFile, "utf-8");
+  if (fs__default$1["default"].existsSync(patFile)) {
+    const contents = fs__default$1["default"].readFileSync(patFile, "utf-8");
     const parsed = server.parsePersonalAccessTokenFile(contents);
     if (parsed.success) {
       return {
@@ -1787,7 +1847,7 @@ function readProjectValVersions(projectRoot) {
 function readLocalFile(projectRoot, projectRelativePath) {
   const absPath = path__default["default"].join(projectRoot, projectRelativePath);
   try {
-    return fs__default["default"].readFileSync(absPath, "utf-8");
+    return fs__default$1["default"].readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -1929,10 +1989,10 @@ async function writeZip(outPath, entries) {
     type: "nodebuffer",
     compression: "DEFLATE"
   });
-  fs__default["default"].mkdirSync(path__default["default"].dirname(outPath), {
+  fs__default$1["default"].mkdirSync(path__default["default"].dirname(outPath), {
     recursive: true
   });
-  fs__default["default"].writeFileSync(outPath, buffer);
+  fs__default$1["default"].writeFileSync(outPath, buffer);
 }
 function timestamp() {
   return new Date().toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
@@ -2081,7 +2141,7 @@ async function collectArtifacts(dir) {
   const skipped = [];
   let totalBytes = 0;
   const walk = async current => {
-    const entries = await fs__default["default"].promises.readdir(current, {
+    const entries = await fs__default$1["default"].promises.readdir(current, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -2095,7 +2155,7 @@ async function collectArtifacts(dir) {
         // A symlinked file is published as its bytes; a symlinked directory is
         // not walked, because one usually comes with a cycle, and a publisher
         // that hangs is worse than one that says what it left out.
-        const stat = await fs__default["default"].promises.stat(absolute).catch(() => null);
+        const stat = await fs__default$1["default"].promises.stat(absolute).catch(() => null);
         if (stat === null) {
           skipped.push(`${key} (broken symlink)`);
           continue;
@@ -2136,7 +2196,7 @@ async function hashFile(absolute) {
   let bytes = 0;
   // Streamed: an artifact may be 128 MB, and reading one into a Buffer to hash
   // it is a needless way to run a CI runner out of memory.
-  const stream = fs__default["default"].createReadStream(absolute);
+  const stream = fs__default$1["default"].createReadStream(absolute);
   await new Promise((resolve, reject) => {
     stream.on("data", chunk => {
       hash.update(chunk);
@@ -2186,7 +2246,7 @@ async function layerRevOf(artifacts) {
       layerRev: null
     };
   }
-  const bytes = await fs__default["default"].promises.readFile(layer.file);
+  const bytes = await fs__default$1["default"].promises.readFile(layer.file);
   let parsed;
   try {
     parsed = JSON.parse(zlib__default["default"].gunzipSync(bytes).toString("utf-8"));
@@ -2214,7 +2274,7 @@ const DEFAULT_ARTIFACTS_DIR = ".val/publish";
 function resolveArtifactsDir(options) {
   const named = options.dir ?? DEFAULT_ARTIFACTS_DIR;
   const dir = path__default["default"].resolve(options.root, named);
-  if (!fs__default["default"].existsSync(dir) || !fs__default["default"].statSync(dir).isDirectory()) {
+  if (!fs__default$1["default"].existsSync(dir) || !fs__default$1["default"].statSync(dir).isDirectory()) {
     return {
       status: "error",
       message: `No artifacts to publish: ${dir} is not a directory.\n\n` + "Build the project first, then point at what it produced:\n\n" + "    npx val publish --artifacts <directory>\n\n" + "The path of each file under it is its artifact key - `server`, `client`,\n" + "`public/...`, `chunk/client/...`, `layer`."
@@ -2554,7 +2614,7 @@ async function putArtifact(slot, file, fetchImpl) {
    * different size as far as the signature is concerned. An artifact is capped
    * at 128 MB by the API, which is the bound this trades against.
    */
-  const body = await fs__default["default"].promises.readFile(file);
+  const body = await fs__default$1["default"].promises.readFile(file);
   let res;
   try {
     res = await fetchImpl(slot.url, {
@@ -2787,12 +2847,12 @@ function looksLikePersonalAccessToken(token) {
 }
 function readPersonalAccessToken(root) {
   const patFile = server.getPersonalAccessTokenPath(root);
-  if (!fs__default["default"].existsSync(patFile)) {
+  if (!fs__default$1["default"].existsSync(patFile)) {
     return {
       status: "none"
     };
   }
-  const parsed = server.parsePersonalAccessTokenFile(fs__default["default"].readFileSync(patFile, "utf-8"));
+  const parsed = server.parsePersonalAccessTokenFile(fs__default$1["default"].readFileSync(patFile, "utf-8"));
   if (!parsed.success) {
     return {
       status: "error",

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

@@ -4,12 +4,12 @@ var meow = require('meow');
 var chalk = require('chalk');
 var path = require('path');
 var pc = require('picocolors');
-var fs$1 = require('fs/promises');
 var fastGlob = require('fast-glob');
 var core = require('@valbuild/core');
 var server = require('@valbuild/server');
+var fs = require('fs/promises');
 var internal = require('@valbuild/shared/internal');
-var fs = require('fs');
+var fs$1 = require('fs');
 var ts = require('typescript');
 var JSZip = require('jszip');
 var readline = require('readline');
@@ -42,8 +42,8 @@ var meow__default = /*#__PURE__*/_interopDefault(meow);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pc__default = /*#__PURE__*/_interopDefault(pc);
-var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
@@ -65,6 +65,62 @@ function info(message, opts = {}) {
   console.log(chalk__default["default"].blue("️ℹ️ : ") + message);
 }
 
+/** A file whose fix landed but which could not be formatted afterwards. */
+
+/**
+ * Format the files `--fix` just wrote, the way the project formats everything.
+ *
+ * Through `createPrettierFormatter`, which is the same function an app hands to
+ * `initValServer` / `initValMcp`, so a fix applied here and an edit saved from
+ * the Studio come out identically formatted. Calling
+ * `prettier.format(code, { filepath })` directly — which this did — reads no
+ * config at all: `filepath` picks the parser, and `.prettierrc` is only ever
+ * consulted by `resolveConfig`, `getFileInfo` and prettier's own CLI. A project
+ * whose style is not prettier's default got its whole file rewritten by a
+ * two-line content fix, and a red `format` job with it.
+ *
+ * Separate from `validate.ts` so it can be tested against a real project on
+ * disk: `runValidation` stops before this step, and `validate()` itself ends in
+ * `process.exit`, so neither can reach it from a test.
+ *
+ * Rendering is the caller's, which is why failures are returned rather than
+ * logged. A file that cannot be formatted is not a failed run: the fix itself
+ * landed, and stopping here would leave the fix applied and the report unwritten.
+ */
+async function formatFixedFiles(prettier, projectRoot, files) {
+  const format = server.createPrettierFormatter(prettier, {
+    projectRoot
+  });
+  const written = [];
+  const failures = [];
+  for (const file of files) {
+    const filePath = path__default["default"].join(projectRoot, file);
+    const fileContent = await fs__default["default"].readFile(filePath, "utf-8");
+    let formattedContent;
+    try {
+      formattedContent = await format(fileContent, file);
+    } catch (err) {
+      failures.push({
+        file,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    // A file prettier left alone — one the project put in `.prettierignore`,
+    // or one already in its final form — is not rewritten. Writing identical
+    // bytes still bumps the mtime, and a `--fix` run alongside a dev server
+    // makes it rebuild for nothing.
+    if (formattedContent !== fileContent) {
+      await fs__default["default"].writeFile(filePath, formattedContent);
+      written.push(file);
+    }
+  }
+  return {
+    written,
+    failures
+  };
+}
+
 async function* runValidation({
   root,
   fix,
@@ -560,7 +616,7 @@ function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
   const filePath = path__default["default"].join(projectRoot, jsonFilePath);
   let fileContent;
   try {
-    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+    fileContent = fs__default$1["default"].readFileSync(filePath, "utf-8");
   } catch {
     cache.set(jsonFilePath, null);
     return null;
@@ -580,7 +636,7 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const filePath = path__default["default"].join(projectRoot, moduleFilePath);
   let fileContent;
   try {
-    fileContent = fs__default["default"].readFileSync(filePath, "utf-8");
+    fileContent = fs__default$1["default"].readFileSync(filePath, "utf-8");
   } catch {
     cache.set(moduleFilePath, null);
     return null;
@@ -788,15 +844,19 @@ async function validate({
       console.log("");
     };
 
-    // Run prettier on files that had fixes applied
+    // Format the files that had fixes applied, the way the project formats
+    // everything else. See `formatFixedFiles` for why this cannot simply be
+    // `prettier.format(code, { filepath })`.
+    //
+    // A file that could not be formatted is reported and skipped rather than
+    // thrown: the fix itself landed, and aborting here would leave the fix
+    // applied and the report below unwritten.
     if (prettier) {
-      for (const file of fixedFiles) {
-        const filePath = path__default["default"].join(projectRoot, file);
-        const fileContent = await fs__default$1["default"].readFile(filePath, "utf-8");
-        const formattedContent = await prettier.format(fileContent, {
-          filepath: filePath
-        });
-        await fs__default$1["default"].writeFile(filePath, formattedContent);
+      const {
+        failures
+      } = await formatFixedFiles(prettier, projectRoot, fixedFiles);
+      for (const failure of failures) {
+        console.log(pc__default["default"].yellow("⚠"), `Could not format ${relFile(failure.file)}: ${failure.message}`);
       }
     }
 
@@ -1084,8 +1144,8 @@ function tryGetGitConfig(root) {
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path__default["default"].join(currentDir, ".git", "config");
-    if (fs__default["default"].existsSync(gitConfigPath)) {
-      return fs__default["default"].readFileSync(gitConfigPath, "utf-8");
+    if (fs__default$1["default"].existsSync(gitConfigPath)) {
+      return fs__default$1["default"].readFileSync(gitConfigPath, "utf-8");
     }
     lastDir = currentDir;
     currentDir = path__default["default"].dirname(currentDir);
@@ -1162,7 +1222,7 @@ class DebugContextError extends Error {}
 async function createDebugContext(options) {
   var _config$files;
   const projectRoot = options.root ? path__default["default"].resolve(options.root) : process.cwd();
-  if (!fs__default["default"].existsSync(projectRoot)) {
+  if (!fs__default$1["default"].existsSync(projectRoot)) {
     throw new DebugContextError(`Project root does not exist: ${projectRoot}`);
   }
   const config = await server.findAndEvalValConfigFile(projectRoot);
@@ -1235,8 +1295,8 @@ async function createDebugContext(options) {
  */
 function readAuth(projectRoot) {
   const patFile = server.getPersonalAccessTokenPath(projectRoot);
-  if (fs__default["default"].existsSync(patFile)) {
-    const contents = fs__default["default"].readFileSync(patFile, "utf-8");
+  if (fs__default$1["default"].existsSync(patFile)) {
+    const contents = fs__default$1["default"].readFileSync(patFile, "utf-8");
     const parsed = server.parsePersonalAccessTokenFile(contents);
     if (parsed.success) {
       return {
@@ -1787,7 +1847,7 @@ function readProjectValVersions(projectRoot) {
 function readLocalFile(projectRoot, projectRelativePath) {
   const absPath = path__default["default"].join(projectRoot, projectRelativePath);
   try {
-    return fs__default["default"].readFileSync(absPath, "utf-8");
+    return fs__default$1["default"].readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -1929,10 +1989,10 @@ async function writeZip(outPath, entries) {
     type: "nodebuffer",
     compression: "DEFLATE"
   });
-  fs__default["default"].mkdirSync(path__default["default"].dirname(outPath), {
+  fs__default$1["default"].mkdirSync(path__default["default"].dirname(outPath), {
     recursive: true
   });
-  fs__default["default"].writeFileSync(outPath, buffer);
+  fs__default$1["default"].writeFileSync(outPath, buffer);
 }
 function timestamp() {
   return new Date().toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
@@ -2081,7 +2141,7 @@ async function collectArtifacts(dir) {
   const skipped = [];
   let totalBytes = 0;
   const walk = async current => {
-    const entries = await fs__default["default"].promises.readdir(current, {
+    const entries = await fs__default$1["default"].promises.readdir(current, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -2095,7 +2155,7 @@ async function collectArtifacts(dir) {
         // A symlinked file is published as its bytes; a symlinked directory is
         // not walked, because one usually comes with a cycle, and a publisher
         // that hangs is worse than one that says what it left out.
-        const stat = await fs__default["default"].promises.stat(absolute).catch(() => null);
+        const stat = await fs__default$1["default"].promises.stat(absolute).catch(() => null);
         if (stat === null) {
           skipped.push(`${key} (broken symlink)`);
           continue;
@@ -2136,7 +2196,7 @@ async function hashFile(absolute) {
   let bytes = 0;
   // Streamed: an artifact may be 128 MB, and reading one into a Buffer to hash
   // it is a needless way to run a CI runner out of memory.
-  const stream = fs__default["default"].createReadStream(absolute);
+  const stream = fs__default$1["default"].createReadStream(absolute);
   await new Promise((resolve, reject) => {
     stream.on("data", chunk => {
       hash.update(chunk);
@@ -2186,7 +2246,7 @@ async function layerRevOf(artifacts) {
       layerRev: null
     };
   }
-  const bytes = await fs__default["default"].promises.readFile(layer.file);
+  const bytes = await fs__default$1["default"].promises.readFile(layer.file);
   let parsed;
   try {
     parsed = JSON.parse(zlib__default["default"].gunzipSync(bytes).toString("utf-8"));
@@ -2214,7 +2274,7 @@ const DEFAULT_ARTIFACTS_DIR = ".val/publish";
 function resolveArtifactsDir(options) {
   const named = options.dir ?? DEFAULT_ARTIFACTS_DIR;
   const dir = path__default["default"].resolve(options.root, named);
-  if (!fs__default["default"].existsSync(dir) || !fs__default["default"].statSync(dir).isDirectory()) {
+  if (!fs__default$1["default"].existsSync(dir) || !fs__default$1["default"].statSync(dir).isDirectory()) {
     return {
       status: "error",
       message: `No artifacts to publish: ${dir} is not a directory.\n\n` + "Build the project first, then point at what it produced:\n\n" + "    npx val publish --artifacts <directory>\n\n" + "The path of each file under it is its artifact key - `server`, `client`,\n" + "`public/...`, `chunk/client/...`, `layer`."
@@ -2554,7 +2614,7 @@ async function putArtifact(slot, file, fetchImpl) {
    * different size as far as the signature is concerned. An artifact is capped
    * at 128 MB by the API, which is the bound this trades against.
    */
-  const body = await fs__default["default"].promises.readFile(file);
+  const body = await fs__default$1["default"].promises.readFile(file);
   let res;
   try {
     res = await fetchImpl(slot.url, {
@@ -2787,12 +2847,12 @@ function looksLikePersonalAccessToken(token) {
 }
 function readPersonalAccessToken(root) {
   const patFile = server.getPersonalAccessTokenPath(root);
-  if (!fs__default["default"].existsSync(patFile)) {
+  if (!fs__default$1["default"].existsSync(patFile)) {
     return {
       status: "none"
     };
   }
-  const parsed = server.parsePersonalAccessTokenFile(fs__default["default"].readFileSync(patFile, "utf-8"));
+  const parsed = server.parsePersonalAccessTokenFile(fs__default$1["default"].readFileSync(patFile, "utf-8"));
   if (!parsed.success) {
     return {
       status: "error",

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

@@ -2,12 +2,12 @@ import meow from 'meow';
 import chalk from 'chalk';
 import path from 'path';
 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, 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 { createPrettierFormatter, 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 fs from 'fs/promises';
 import { resolveSchemaSourceFixes } from '@valbuild/shared/internal';
-import fs from 'fs';
+import fs$1 from 'fs';
 import ts from 'typescript';
 import JSZip from 'jszip';
 import readline from 'readline';
@@ -31,6 +31,62 @@ function info(message, opts = {}) {
   console.log(chalk.blue("️ℹ️ : ") + message);
 }
 
+/** A file whose fix landed but which could not be formatted afterwards. */
+
+/**
+ * Format the files `--fix` just wrote, the way the project formats everything.
+ *
+ * Through `createPrettierFormatter`, which is the same function an app hands to
+ * `initValServer` / `initValMcp`, so a fix applied here and an edit saved from
+ * the Studio come out identically formatted. Calling
+ * `prettier.format(code, { filepath })` directly — which this did — reads no
+ * config at all: `filepath` picks the parser, and `.prettierrc` is only ever
+ * consulted by `resolveConfig`, `getFileInfo` and prettier's own CLI. A project
+ * whose style is not prettier's default got its whole file rewritten by a
+ * two-line content fix, and a red `format` job with it.
+ *
+ * Separate from `validate.ts` so it can be tested against a real project on
+ * disk: `runValidation` stops before this step, and `validate()` itself ends in
+ * `process.exit`, so neither can reach it from a test.
+ *
+ * Rendering is the caller's, which is why failures are returned rather than
+ * logged. A file that cannot be formatted is not a failed run: the fix itself
+ * landed, and stopping here would leave the fix applied and the report unwritten.
+ */
+async function formatFixedFiles(prettier, projectRoot, files) {
+  const format = createPrettierFormatter(prettier, {
+    projectRoot
+  });
+  const written = [];
+  const failures = [];
+  for (const file of files) {
+    const filePath = path.join(projectRoot, file);
+    const fileContent = await fs.readFile(filePath, "utf-8");
+    let formattedContent;
+    try {
+      formattedContent = await format(fileContent, file);
+    } catch (err) {
+      failures.push({
+        file,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    // A file prettier left alone — one the project put in `.prettierignore`,
+    // or one already in its final form — is not rewritten. Writing identical
+    // bytes still bumps the mtime, and a `--fix` run alongside a dev server
+    // makes it rebuild for nothing.
+    if (formattedContent !== fileContent) {
+      await fs.writeFile(filePath, formattedContent);
+      written.push(file);
+    }
+  }
+  return {
+    written,
+    failures
+  };
+}
+
 async function* runValidation({
   root,
   fix,
@@ -526,7 +582,7 @@ function getCachedJsonFile(jsonFilePath, projectRoot, cache) {
   const filePath = path.join(projectRoot, jsonFilePath);
   let fileContent;
   try {
-    fileContent = fs.readFileSync(filePath, "utf-8");
+    fileContent = fs$1.readFileSync(filePath, "utf-8");
   } catch {
     cache.set(jsonFilePath, null);
     return null;
@@ -546,7 +602,7 @@ function getCachedFile(moduleFilePath, projectRoot, cache) {
   const filePath = path.join(projectRoot, moduleFilePath);
   let fileContent;
   try {
-    fileContent = fs.readFileSync(filePath, "utf-8");
+    fileContent = fs$1.readFileSync(filePath, "utf-8");
   } catch {
     cache.set(moduleFilePath, null);
     return null;
@@ -754,15 +810,19 @@ async function validate({
       console.log("");
     };
 
-    // Run prettier on files that had fixes applied
+    // Format the files that had fixes applied, the way the project formats
+    // everything else. See `formatFixedFiles` for why this cannot simply be
+    // `prettier.format(code, { filepath })`.
+    //
+    // A file that could not be formatted is reported and skipped rather than
+    // thrown: the fix itself landed, and aborting here would leave the fix
+    // applied and the report below unwritten.
     if (prettier) {
-      for (const file of fixedFiles) {
-        const filePath = path.join(projectRoot, file);
-        const fileContent = await fs$1.readFile(filePath, "utf-8");
-        const formattedContent = await prettier.format(fileContent, {
-          filepath: filePath
-        });
-        await fs$1.writeFile(filePath, formattedContent);
+      const {
+        failures
+      } = await formatFixedFiles(prettier, projectRoot, fixedFiles);
+      for (const failure of failures) {
+        console.log(pc.yellow("⚠"), `Could not format ${relFile(failure.file)}: ${failure.message}`);
       }
     }
 
@@ -1050,8 +1110,8 @@ function tryGetGitConfig(root) {
   let lastDir = null;
   while (currentDir !== lastDir) {
     const gitConfigPath = path.join(currentDir, ".git", "config");
-    if (fs.existsSync(gitConfigPath)) {
-      return fs.readFileSync(gitConfigPath, "utf-8");
+    if (fs$1.existsSync(gitConfigPath)) {
+      return fs$1.readFileSync(gitConfigPath, "utf-8");
     }
     lastDir = currentDir;
     currentDir = path.dirname(currentDir);
@@ -1128,7 +1188,7 @@ class DebugContextError extends Error {}
 async function createDebugContext(options) {
   var _config$files;
   const projectRoot = options.root ? path.resolve(options.root) : process.cwd();
-  if (!fs.existsSync(projectRoot)) {
+  if (!fs$1.existsSync(projectRoot)) {
     throw new DebugContextError(`Project root does not exist: ${projectRoot}`);
   }
   const config = await findAndEvalValConfigFile(projectRoot);
@@ -1201,8 +1261,8 @@ async function createDebugContext(options) {
  */
 function readAuth(projectRoot) {
   const patFile = getPersonalAccessTokenPath(projectRoot);
-  if (fs.existsSync(patFile)) {
-    const contents = fs.readFileSync(patFile, "utf-8");
+  if (fs$1.existsSync(patFile)) {
+    const contents = fs$1.readFileSync(patFile, "utf-8");
     const parsed = parsePersonalAccessTokenFile(contents);
     if (parsed.success) {
       return {
@@ -1753,7 +1813,7 @@ function readProjectValVersions(projectRoot) {
 function readLocalFile(projectRoot, projectRelativePath) {
   const absPath = path.join(projectRoot, projectRelativePath);
   try {
-    return fs.readFileSync(absPath, "utf-8");
+    return fs$1.readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -1895,10 +1955,10 @@ async function writeZip(outPath, entries) {
     type: "nodebuffer",
     compression: "DEFLATE"
   });
-  fs.mkdirSync(path.dirname(outPath), {
+  fs$1.mkdirSync(path.dirname(outPath), {
     recursive: true
   });
-  fs.writeFileSync(outPath, buffer);
+  fs$1.writeFileSync(outPath, buffer);
 }
 function timestamp() {
   return new Date().toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
@@ -2047,7 +2107,7 @@ async function collectArtifacts(dir) {
   const skipped = [];
   let totalBytes = 0;
   const walk = async current => {
-    const entries = await fs.promises.readdir(current, {
+    const entries = await fs$1.promises.readdir(current, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -2061,7 +2121,7 @@ async function collectArtifacts(dir) {
         // A symlinked file is published as its bytes; a symlinked directory is
         // not walked, because one usually comes with a cycle, and a publisher
         // that hangs is worse than one that says what it left out.
-        const stat = await fs.promises.stat(absolute).catch(() => null);
+        const stat = await fs$1.promises.stat(absolute).catch(() => null);
         if (stat === null) {
           skipped.push(`${key} (broken symlink)`);
           continue;
@@ -2102,7 +2162,7 @@ async function hashFile(absolute) {
   let bytes = 0;
   // Streamed: an artifact may be 128 MB, and reading one into a Buffer to hash
   // it is a needless way to run a CI runner out of memory.
-  const stream = fs.createReadStream(absolute);
+  const stream = fs$1.createReadStream(absolute);
   await new Promise((resolve, reject) => {
     stream.on("data", chunk => {
       hash.update(chunk);
@@ -2152,7 +2212,7 @@ async function layerRevOf(artifacts) {
       layerRev: null
     };
   }
-  const bytes = await fs.promises.readFile(layer.file);
+  const bytes = await fs$1.promises.readFile(layer.file);
   let parsed;
   try {
     parsed = JSON.parse(zlib.gunzipSync(bytes).toString("utf-8"));
@@ -2180,7 +2240,7 @@ const DEFAULT_ARTIFACTS_DIR = ".val/publish";
 function resolveArtifactsDir(options) {
   const named = options.dir ?? DEFAULT_ARTIFACTS_DIR;
   const dir = path.resolve(options.root, named);
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+  if (!fs$1.existsSync(dir) || !fs$1.statSync(dir).isDirectory()) {
     return {
       status: "error",
       message: `No artifacts to publish: ${dir} is not a directory.\n\n` + "Build the project first, then point at what it produced:\n\n" + "    npx val publish --artifacts <directory>\n\n" + "The path of each file under it is its artifact key - `server`, `client`,\n" + "`public/...`, `chunk/client/...`, `layer`."
@@ -2520,7 +2580,7 @@ async function putArtifact(slot, file, fetchImpl) {
    * different size as far as the signature is concerned. An artifact is capped
    * at 128 MB by the API, which is the bound this trades against.
    */
-  const body = await fs.promises.readFile(file);
+  const body = await fs$1.promises.readFile(file);
   let res;
   try {
     res = await fetchImpl(slot.url, {
@@ -2753,12 +2813,12 @@ function looksLikePersonalAccessToken(token) {
 }
 function readPersonalAccessToken(root) {
   const patFile = getPersonalAccessTokenPath(root);
-  if (!fs.existsSync(patFile)) {
+  if (!fs$1.existsSync(patFile)) {
     return {
       status: "none"
     };
   }
-  const parsed = parsePersonalAccessTokenFile(fs.readFileSync(patFile, "utf-8"));
+  const parsed = parsePersonalAccessTokenFile(fs$1.readFileSync(patFile, "utf-8"));
   if (!parsed.success) {
     return {
       status: "error",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.134.0",
+  "version": "0.135.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -28,9 +28,9 @@
     "zod-validation-error": "^5.0.0",
     "@valbuild/core": "0.134.0",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/language-server": "0.134.0",
-    "@valbuild/shared": "0.134.0",
-    "@valbuild/server": "0.134.0"
+    "@valbuild/language-server": "0.135.0",
+    "@valbuild/server": "0.135.0",
+    "@valbuild/shared": "0.134.1"
   },
   "peerDependencies": {
     "prettier": "*",
@@ -46,6 +46,8 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.5.0",
+    "@prettier/sync": "^0.6.1",
+    "prettier": "~3.8.5",
     "tsx": "^4.23.12"
   },
   "scripts": {

package/src/formatFixedFiles.test.ts

@@ -0,0 +1,229 @@
+import { describe, test, expect, beforeEach, afterEach } from "@jest/globals";
+import path from "path";
+import fs from "fs";
+import synchronizedPrettier from "@prettier/sync";
+import { DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core";
+import {
+  createDefaultValFSHost,
+  runValidation,
+  IValRemote,
+} from "./runValidation";
+import { formatFixedFiles } from "./formatFixedFiles";
+
+/**
+ * The step `val validate --fix` ends on, against a real project on disk.
+ *
+ * The fixes here are produced by `runValidation` itself rather than written by
+ * the test, because the thing being checked is what happens to the TypeScript
+ * the fix pipeline emits — which is unformatted, and which used to be handed to
+ * `prettier.format(code, { filepath })` and therefore rewritten in prettier's
+ * defaults no matter what the project had configured.
+ *
+ * It stops short of calling `validate()` because that ends in `process.exit`
+ * once the fixture's remaining errors are counted, which would take the jest
+ * worker with it. `validate()` does nothing between the two but render.
+ *
+ * `@prettier/sync` rather than `prettier`: prettier 3's CommonJS entry loads its
+ * ESM build with a dynamic `import()`, which jest refuses without
+ * `--experimental-vm-modules`.
+ */
+
+const BASIC_FIXTURE = path.resolve(__dirname, "__fixtures__/basic");
+
+// The fixture is copied INSIDE the package rather than into the OS temp dir:
+// the project's `val.config.ts` is evaluated with a `require` resolving from
+// its own path, so it has to be somewhere `@valbuild/core` can be walked up to.
+const TMP_BASE = path.join(__dirname, ".tmp");
+
+/** A module in neither style, so either pass has something to change. */
+const UNFORMATTED_MODULE = `import {c,s} from "../val.config"
+export default c.define("/content/basic-image.val.ts",s.image(),{path:"/public/val/image.png"})
+`;
+
+const mockRemote: IValRemote = {
+  remoteHost: DEFAULT_VAL_REMOTE_HOST,
+  getSettings: async () => {
+    throw new Error("Not expected to be called");
+  },
+  uploadFile: async () => {
+    throw new Error("Not expected to be called");
+  },
+};
+
+/** Apply every fix in `valFiles`, and report which files were written. */
+async function applyFixes(
+  tmpDir: string,
+  valFiles: string[],
+): Promise<string[]> {
+  const fixed = new Set<string>();
+  for await (const event of runValidation({
+    root: tmpDir,
+    fix: true,
+    valFiles,
+    project: undefined,
+    remote: mockRemote,
+    fs: createDefaultValFSHost(),
+  })) {
+    if (event.type === "fix-applied") {
+      fixed.add(event.file);
+    }
+  }
+  return [...fixed];
+}
+
+describe("formatFixedFiles", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    fs.mkdirSync(TMP_BASE, { recursive: true });
+    tmpDir = fs.mkdtempSync(path.join(TMP_BASE, "formatFixedFiles-"));
+    fs.cpSync(BASIC_FIXTURE, tmpDir, { recursive: true });
+    // Every case writes its own config into its own directory, and prettier
+    // caches per directory for the life of the process — including the fact
+    // that a directory had none.
+    synchronizedPrettier.clearConfigCache();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeConfig(config: Record<string, unknown>): void {
+    fs.writeFileSync(
+      path.join(tmpDir, ".prettierrc.json"),
+      JSON.stringify(config),
+    );
+  }
+
+  test("formats a fixed file with the project's config, not prettier's defaults", async () => {
+    writeConfig({ singleQuote: true, semi: false });
+    const fixed = await applyFixes(tmpDir, ["content/basic-image.val.ts"]);
+    expect(fixed).toEqual(["content/basic-image.val.ts"]);
+
+    const { written, failures } = await formatFixedFiles(
+      synchronizedPrettier,
+      tmpDir,
+      fixed,
+    );
+
+    expect(failures).toEqual([]);
+    expect(written).toEqual(["content/basic-image.val.ts"]);
+    const after = fs.readFileSync(
+      path.join(tmpDir, "content/basic-image.val.ts"),
+      "utf-8",
+    );
+    // The fix landed...
+    expect(after).toContain("width: 1");
+    // ...in the project's style. Prettier's default is double quotes and semis,
+    // which is what the old `prettier.format(code, { filepath })` produced.
+    expect(after).toContain("'/public/val/image.png'");
+    expect(after).not.toContain('"/public/val/image.png"');
+    expect(after.trimEnd().endsWith(")")).toBe(true);
+  });
+
+  test("leaves a fixed file the project put in .prettierignore unformatted", async () => {
+    writeConfig({ singleQuote: true });
+    fs.writeFileSync(
+      path.join(tmpDir, ".prettierignore"),
+      "content/basic-image.val.ts\n",
+    );
+    const fixed = await applyFixes(tmpDir, ["content/basic-image.val.ts"]);
+
+    const { written, failures } = await formatFixedFiles(
+      synchronizedPrettier,
+      tmpDir,
+      fixed,
+    );
+
+    expect(failures).toEqual([]);
+    // Nothing rewritten, so the mtime is not bumped either.
+    expect(written).toEqual([]);
+    const after = fs.readFileSync(
+      path.join(tmpDir, "content/basic-image.val.ts"),
+      "utf-8",
+    );
+    // The fix still landed — only the formatting was skipped.
+    expect(after).toContain("width: 1");
+    expect(after).toContain('"/public/val/image.png"');
+  });
+
+  test("does not rewrite a file that is already formatted", async () => {
+    writeConfig({});
+    const fixed = await applyFixes(tmpDir, ["content/basic-image.val.ts"]);
+    const target = path.join(tmpDir, "content/basic-image.val.ts");
+
+    // First pass formats it; a second pass has nothing left to do.
+    await formatFixedFiles(synchronizedPrettier, tmpDir, fixed);
+    const { written, failures } = await formatFixedFiles(
+      synchronizedPrettier,
+      tmpDir,
+      fixed,
+    );
+
+    expect(failures).toEqual([]);
+    expect(written).toEqual([]);
+    expect(fs.readFileSync(target, "utf-8")).toContain("width: 1");
+  });
+
+  test("reports a file it cannot format instead of throwing, and keeps going", async () => {
+    writeConfig({});
+    const fixed = await applyFixes(tmpDir, ["content/basic-image.val.ts"]);
+    // A parser prettier does not have: the same shape as a malformed config or
+    // a plugin that fails to load, and the only failure mode reachable here
+    // without breaking the file the fix just wrote.
+    const brokenPrettier = {
+      ...synchronizedPrettier,
+      format: () => {
+        throw new Error("No parser could be inferred");
+      },
+    };
+
+    const { written, failures } = await formatFixedFiles(
+      brokenPrettier,
+      tmpDir,
+      [...fixed, ...fixed],
+    );
+
+    expect(written).toEqual([]);
+    // Both entries reported: the loop continued past the first failure.
+    expect(failures).toHaveLength(2);
+    expect(failures[0]).toEqual({
+      file: "content/basic-image.val.ts",
+      message: "No parser could be inferred",
+    });
+    // The fix is still on disk, unformatted rather than lost.
+    expect(
+      fs.readFileSync(path.join(tmpDir, "content/basic-image.val.ts"), "utf-8"),
+    ).toContain("width: 1");
+  });
+
+  test("resolves a project-relative path against the project, with or without a leading slash", async () => {
+    writeConfig({ singleQuote: true });
+    const fixed = await applyFixes(tmpDir, ["content/basic-image.val.ts"]);
+    // `runValidation` reports this one without a leading slash, but a
+    // `ModuleFilePath` carries one and `validate.ts` strips it for display, so
+    // both shapes reach here. Resolving either against the filesystem root
+    // rather than the project would find a different `.prettierrc` — or none,
+    // which is the old bug wearing a different hat.
+    expect(fixed).toEqual(["content/basic-image.val.ts"]);
+    const target = path.join(tmpDir, "content/basic-image.val.ts");
+
+    for (const reported of [
+      "content/basic-image.val.ts",
+      "/content/basic-image.val.ts",
+    ]) {
+      fs.writeFileSync(target, UNFORMATTED_MODULE);
+      const { written, failures } = await formatFixedFiles(
+        synchronizedPrettier,
+        tmpDir,
+        [reported],
+      );
+
+      expect(failures).toEqual([]);
+      expect(written).toEqual([reported]);
+      expect(fs.readFileSync(target, "utf-8")).toContain(
+        "'/public/val/image.png'",
+      );
+    }
+  });
+});

package/src/formatFixedFiles.ts

@@ -0,0 +1,69 @@
+import path from "path";
+import fs from "fs/promises";
+import { createPrettierFormatter, type PrettierLike } from "@valbuild/server";
+
+/** A file whose fix landed but which could not be formatted afterwards. */
+export type FormatFailure = {
+  /** Project-relative, as `--fix` reported it. */
+  file: string;
+  message: string;
+};
+
+export type FormatFixedFilesResult = {
+  /** Files actually rewritten — a file already in its final form is not. */
+  written: string[];
+  failures: FormatFailure[];
+};
+
+/**
+ * Format the files `--fix` just wrote, the way the project formats everything.
+ *
+ * Through `createPrettierFormatter`, which is the same function an app hands to
+ * `initValServer` / `initValMcp`, so a fix applied here and an edit saved from
+ * the Studio come out identically formatted. Calling
+ * `prettier.format(code, { filepath })` directly — which this did — reads no
+ * config at all: `filepath` picks the parser, and `.prettierrc` is only ever
+ * consulted by `resolveConfig`, `getFileInfo` and prettier's own CLI. A project
+ * whose style is not prettier's default got its whole file rewritten by a
+ * two-line content fix, and a red `format` job with it.
+ *
+ * Separate from `validate.ts` so it can be tested against a real project on
+ * disk: `runValidation` stops before this step, and `validate()` itself ends in
+ * `process.exit`, so neither can reach it from a test.
+ *
+ * Rendering is the caller's, which is why failures are returned rather than
+ * logged. A file that cannot be formatted is not a failed run: the fix itself
+ * landed, and stopping here would leave the fix applied and the report unwritten.
+ */
+export async function formatFixedFiles(
+  prettier: PrettierLike,
+  projectRoot: string,
+  files: Iterable<string>,
+): Promise<FormatFixedFilesResult> {
+  const format = createPrettierFormatter(prettier, { projectRoot });
+  const written: string[] = [];
+  const failures: FormatFailure[] = [];
+  for (const file of files) {
+    const filePath = path.join(projectRoot, file);
+    const fileContent = await fs.readFile(filePath, "utf-8");
+    let formattedContent: string;
+    try {
+      formattedContent = await format(fileContent, file);
+    } catch (err) {
+      failures.push({
+        file,
+        message: err instanceof Error ? err.message : String(err),
+      });
+      continue;
+    }
+    // A file prettier left alone — one the project put in `.prettierignore`,
+    // or one already in its final form — is not rewritten. Writing identical
+    // bytes still bumps the mtime, and a `--fix` run alongside a dev server
+    // makes it rebuild for nothing.
+    if (formattedContent !== fileContent) {
+      await fs.writeFile(filePath, formattedContent);
+      written.push(file);
+    }
+  }
+  return { written, failures };
+}

package/src/validate.ts

@@ -1,9 +1,9 @@
 import path from "path";
 import picocolors from "picocolors";
-import fs from "fs/promises";
 import { glob } from "fast-glob";
 import { DEFAULT_CONTENT_HOST, DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core";
 import { getSettings, uploadRemoteFile } from "@valbuild/server";
+import { formatFixedFiles } from "./formatFixedFiles";
 import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 import { createDefaultValFSHost, runValidation } from "./runValidation";
 import {
@@ -283,15 +283,24 @@ export async function validate({
       console.log("");
     };
 
-    // Run prettier on files that had fixes applied
+    // Format the files that had fixes applied, the way the project formats
+    // everything else. See `formatFixedFiles` for why this cannot simply be
+    // `prettier.format(code, { filepath })`.
+    //
+    // A file that could not be formatted is reported and skipped rather than
+    // thrown: the fix itself landed, and aborting here would leave the fix
+    // applied and the report below unwritten.
     if (prettier) {
-      for (const file of fixedFiles) {
-        const filePath = path.join(projectRoot, file);
-        const fileContent = await fs.readFile(filePath, "utf-8");
-        const formattedContent = await prettier.format(fileContent, {
-          filepath: filePath,
-        });
-        await fs.writeFile(filePath, formattedContent);
+      const { failures } = await formatFixedFiles(
+        prettier,
+        projectRoot,
+        fixedFiles,
+      );
+      for (const failure of failures) {
+        console.log(
+          picocolors.yellow("⚠"),
+          `Could not format ${relFile(failure.file)}: ${failure.message}`,
+        );
       }
     }