@valbuild/cli 0.143.1 → 0.144.1

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @valbuild/cli
 
+## 0.144.1
+
+### Patch Changes
+
+- Updated dependencies [[`a641bb0`](https://github.com/valbuild/val/commit/a641bb0286756339252c53e9230d766c23fcccc6)]:
+  - @valbuild/server@0.144.1
+  - @valbuild/language-server@0.144.1
+
+## 0.144.0
+
+### Patch Changes
+
+- [#788](https://github.com/valbuild/val/pull/788) [`a84271c`](https://github.com/valbuild/val/commit/a84271c534822071c1e428cf9990602459682d25) Thanks [@freekh](https://github.com/freekh)! - Fixes to `npx val validate` for `s.imagedir()` and `s.filedir()`, and the `s.image(galleryVal)` / `s.file(filesVal)` fields that use them:
+
+  - **`--fix` now updates every field that uses an uploaded image or file.** When `--fix` moves an entry of an `s.imagedir(dir).remote()` or `s.filedir(dir, options).remote()` to Val Remote, the entry's key changes from the local path to the remote URL. Fields that held the old path were left pointing at it, and reported "The gallery does not have an image at …" with nothing to fix it. Now `s.image(galleryVal)` and `s.file(filesVal)` fields, and images in rich text (`s.richtext({ img: s.image(galleryVal) })`), are updated in the same run. The VS Code extension's "upload to Val Remote" updates them in the same edit, including fields inside `.jsonValues()` entries, which live in their own `*.val.json` files.
+  - **A field that uses an image or file from a `.remote()` gallery is no longer reported as "Expected local image, but found remote".** The gallery decides whether its files are on Val Remote; the field only has to name a file the gallery has. Before, `--fix` would download the file and point the field at a path the gallery did not have.
+  - **Images uploaded through a field into a `.remote()` gallery.** When you upload an image through an `s.image(galleryVal)` field in Val Studio, the field stores the remote URL and the gallery stores the image under its local path. Validation now accepts this, and `useVal` / `fetchVal` now fill in the image's `width`, `height` and `mimeType` from the gallery for it, as they do for every other gallery image.
+  - **Errors in a gallery's keys are reported.** A remote URL in a gallery that is not `.remote()`, a remote URL that is not valid, or one outside the gallery's `dir` was silently ignored by `npx val validate`. It is now reported as an error. `--fix` does not change it: you decide whether the key or the gallery's options are wrong.
+  - **A file is no longer reported as valid when it still has an error.** When `--fix` fixed one error in a file and another error was left, the file could be printed as "✔ valid".
+
+- [#827](https://github.com/valbuild/val/pull/827) [`1272b14`](https://github.com/valbuild/val/commit/1272b1408cf55fefccdce442352c208a7f69f44b) Thanks [@freekh](https://github.com/freekh)! - Publishing to Val's platform, through `val publish` or the Studio, now handles a stylesheet that imports other stylesheets, and fonts installed as packages:
+
+  ```css
+  /* src/styles.css */
+  @import "tailwindcss";
+  @import "./theme/theme.css";
+
+  /* src/theme/theme.css */
+  @import "@fontsource-variable/inter";
+  ```
+
+  Before this, the platform's build passed `@import "./theme/theme.css"` on to Tailwind without resolving it, and publishing stopped with `Tailwind asked for './theme/theme.css', which this build does not carry`. A font package such as `@fontsource-variable/inter` was built as code, failed, and was skipped.
+
+  - A stylesheet's own `@import`s are inlined where they were written, the same way `vite build` handles them. That covers relative files and stylesheets that dependencies ship. `layer()`, `supports()` and media conditions are kept, and a stylesheet imported twice is only included once.
+  - The files a dependency's stylesheet points at with `url(...)`, such as a font package's `.woff2` files, are published with the site and served from it.
+
+- Updated dependencies [[`a84271c`](https://github.com/valbuild/val/commit/a84271c534822071c1e428cf9990602459682d25), [`860ab2b`](https://github.com/valbuild/val/commit/860ab2b87333daf95a48215b0e4a1b44f441c878), [`1272b14`](https://github.com/valbuild/val/commit/1272b1408cf55fefccdce442352c208a7f69f44b)]:
+  - @valbuild/core@0.144.0
+  - @valbuild/shared@0.144.0
+  - @valbuild/server@0.144.0
+  - @valbuild/language-server@0.144.0
+  - @valbuild/tanstack-build@0.144.0
+
 ## 0.143.1
 
 ### Patch Changes

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

@@ -243,8 +243,9 @@ async function* runValidation({
       };
       return;
     } else {
+      // What is still wrong with this module once every handler has run: an
+      // error that was fixed is not counted, one that was not is.
       let fileErrors = 0;
-      let fixedErrors = 0;
       if (valModule.errors) {
         if (valModule.errors.validation) {
           // Resolve schema/source fixes (keyof:check-keys, router:check-route)
@@ -331,7 +332,6 @@ async function* runValidation({
                 continue;
               }
               if (result.appliedFix) {
-                fixedErrors += 1;
                 yield {
                   type: "fix-applied",
                   file,
@@ -371,7 +371,6 @@ async function* runValidation({
                       sourcePath: other.moduleFilePath
                     };
                   }
-                  fixedErrors += 1;
                   yield {
                     type: "fix-applied",
                     file,
@@ -407,7 +406,10 @@ async function* runValidation({
             }
           }
         }
-        if (fixedErrors === fileErrors && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
+        // Valid means nothing is left, not that as many errors were fixed as
+        // are left: one fix and one error that no fix touches add up to the
+        // same count, and printed a module with an error in it as valid.
+        if (fileErrors === 0 && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
           yield {
             type: "file-valid",
             file: moduleFilePath,
@@ -1029,7 +1031,7 @@ async function listUnusedFiles({
         }
       });
     }
-    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) is
+    // A media collection (`s.imagedir()`, `s.filedir()`, `s.videodir()`) is
     // keyed by its files, and an entry that is fine reports no error either —
     // so, as for a video, they are found by walking the source. A video set's
     // stream holds every playlist and segment its master names, and an entry
@@ -2616,7 +2618,10 @@ async function buildArtifacts(options) {
       }
     })();
     const deps = node.layerDepsOf(manifest, sources);
-    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources));
+    // The files those stylesheets point at -- a font package's `.woff2`s --
+    // published with the site under the names their `url()`s now use.
+    const dependencyAssets = {};
+    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources), dependencyAssets);
     const layer = await node.buildVendorLayer(root, deps, css, {
       base: target.base,
       // A project on the platform layers its own copies; only the platform's
@@ -2644,6 +2649,7 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
+      dependencyAssets,
       // The project's own files, without the generated tree or the
       // stylesheets: what the next publish -- the Studio's included -- starts
       // from. See `withoutStylesheets`.

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

@@ -243,8 +243,9 @@ async function* runValidation({
       };
       return;
     } else {
+      // What is still wrong with this module once every handler has run: an
+      // error that was fixed is not counted, one that was not is.
       let fileErrors = 0;
-      let fixedErrors = 0;
       if (valModule.errors) {
         if (valModule.errors.validation) {
           // Resolve schema/source fixes (keyof:check-keys, router:check-route)
@@ -331,7 +332,6 @@ async function* runValidation({
                 continue;
               }
               if (result.appliedFix) {
-                fixedErrors += 1;
                 yield {
                   type: "fix-applied",
                   file,
@@ -371,7 +371,6 @@ async function* runValidation({
                       sourcePath: other.moduleFilePath
                     };
                   }
-                  fixedErrors += 1;
                   yield {
                     type: "fix-applied",
                     file,
@@ -407,7 +406,10 @@ async function* runValidation({
             }
           }
         }
-        if (fixedErrors === fileErrors && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
+        // Valid means nothing is left, not that as many errors were fixed as
+        // are left: one fix and one error that no fix touches add up to the
+        // same count, and printed a module with an error in it as valid.
+        if (fileErrors === 0 && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
           yield {
             type: "file-valid",
             file: moduleFilePath,
@@ -1029,7 +1031,7 @@ async function listUnusedFiles({
         }
       });
     }
-    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) is
+    // A media collection (`s.imagedir()`, `s.filedir()`, `s.videodir()`) is
     // keyed by its files, and an entry that is fine reports no error either —
     // so, as for a video, they are found by walking the source. A video set's
     // stream holds every playlist and segment its master names, and an entry
@@ -2616,7 +2618,10 @@ async function buildArtifacts(options) {
       }
     })();
     const deps = node.layerDepsOf(manifest, sources);
-    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources));
+    // The files those stylesheets point at -- a font package's `.woff2`s --
+    // published with the site under the names their `url()`s now use.
+    const dependencyAssets = {};
+    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources), dependencyAssets);
     const layer = await node.buildVendorLayer(root, deps, css, {
       base: target.base,
       // A project on the platform layers its own copies; only the platform's
@@ -2644,6 +2649,7 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
+      dependencyAssets,
       // The project's own files, without the generated tree or the
       // stylesheets: what the next publish -- the Studio's included -- starts
       // from. See `withoutStylesheets`.

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

@@ -208,8 +208,9 @@ async function* runValidation({
       };
       return;
     } else {
+      // What is still wrong with this module once every handler has run: an
+      // error that was fixed is not counted, one that was not is.
       let fileErrors = 0;
-      let fixedErrors = 0;
       if (valModule.errors) {
         if (valModule.errors.validation) {
           // Resolve schema/source fixes (keyof:check-keys, router:check-route)
@@ -296,7 +297,6 @@ async function* runValidation({
                 continue;
               }
               if (result.appliedFix) {
-                fixedErrors += 1;
                 yield {
                   type: "fix-applied",
                   file,
@@ -336,7 +336,6 @@ async function* runValidation({
                       sourcePath: other.moduleFilePath
                     };
                   }
-                  fixedErrors += 1;
                   yield {
                     type: "fix-applied",
                     file,
@@ -372,7 +371,10 @@ async function* runValidation({
             }
           }
         }
-        if (fixedErrors === fileErrors && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
+        // Valid means nothing is left, not that as many errors were fixed as
+        // are left: one fix and one error that no fix touches add up to the
+        // same count, and printed a module with an error in it as valid.
+        if (fileErrors === 0 && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
           yield {
             type: "file-valid",
             file: moduleFilePath,
@@ -994,7 +996,7 @@ async function listUnusedFiles({
         }
       });
     }
-    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) is
+    // A media collection (`s.imagedir()`, `s.filedir()`, `s.videodir()`) is
     // keyed by its files, and an entry that is fine reports no error either —
     // so, as for a video, they are found by walking the source. A video set's
     // stream holds every playlist and segment its master names, and an entry
@@ -2581,7 +2583,10 @@ async function buildArtifacts(options) {
       }
     })();
     const deps = node.layerDepsOf(manifest, sources);
-    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources));
+    // The files those stylesheets point at -- a font package's `.woff2`s --
+    // published with the site under the names their `url()`s now use.
+    const dependencyAssets = {};
+    const css = await node.collectDependencyCss(root, node.cssSpecifiersOf(sources), dependencyAssets);
     const layer = await node.buildVendorLayer(root, deps, css, {
       base: target.base,
       // A project on the platform layers its own copies; only the platform's
@@ -2609,6 +2614,7 @@ async function buildArtifacts(options) {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
+      dependencyAssets,
       // The project's own files, without the generated tree or the
       // stylesheets: what the next publish -- the Studio's included -- starts
       // from. See `withoutStylesheets`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.143.1",
+  "version": "0.144.1",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -26,11 +26,11 @@
     "picocolors": "^1.1.1",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.143.0",
-    "@valbuild/language-server": "0.143.1",
-    "@valbuild/shared": "0.143.0",
+    "@valbuild/core": "0.144.0",
+    "@valbuild/language-server": "0.144.1",
+    "@valbuild/server": "0.144.1",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/server": "0.143.1"
+    "@valbuild/shared": "0.144.0"
   },
   "peerDependencies": {
     "prettier": "*",
@@ -38,7 +38,7 @@
     "rolldown": ">=1.2.5",
     "@tanstack/router-generator": ">=1.167.0",
     "@tanstack/router-plugin": ">=1.168.0",
-    "@valbuild/tanstack-build": "^0.142.0"
+    "@valbuild/tanstack-build": "^0.144.0"
   },
   "peerDependenciesMeta": {
     "@valbuild/tanstack-build": {
@@ -70,7 +70,7 @@
     "prettier": "~3.8.5",
     "rolldown": "^1.2.5",
     "tsx": "^4.23.12",
-    "@valbuild/tanstack-build": "0.142.0"
+    "@valbuild/tanstack-build": "0.144.0"
   },
   "scripts": {
     "start": "tsx src/cli.ts --",

package/src/__fixtures__/basic/content/basic-files.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-files.val.ts",
-  s.fileset({
-    dir: "/public/val/files",
-    accept: "*/*",
-  }),
+  s.filedir("/public/val/files", { accept: "*/*" }),
   {
     "/public/val/files/tracked.txt": {
       mimeType: "text/plain",

package/src/__fixtures__/basic/content/basic-fixable-and-unfixable.val.ts

@@ -0,0 +1,12 @@
+import { c, s } from "../val.config";
+
+// One error `--fix` repairs (the image's metadata) and one it cannot (the
+// title is too short), in the same module.
+export default c.define(
+  "/content/basic-fixable-and-unfixable.val.ts",
+  s.object({ image: s.image(), title: s.string().minLength(30) }),
+  {
+    image: { path: "/public/val/image.png" },
+    title: "Too short",
+  },
+);

package/src/__fixtures__/basic/content/basic-gallery-2.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-2.val.ts",
-  s.imageset({
-    dir: "/public/val/images2",
-    accept: "image/*",
-  }),
+  s.imagedir("/public/val/images2", { accept: "image/*" }),
   {
     "/public/val/images2/image.png": {
       width: 1,

package/src/__fixtures__/basic/content/basic-gallery-fail-on-non-unique-dir.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-fail-on-non-unique-dir.val.ts",
-  s.imageset({
-    dir: "/public/val/images",
-    accept: "image/*",
-  }),
+  s.imagedir("/public/val/images", { accept: "image/*" }),
   {
     "/public/val/images/image.png": {
       width: 1,

package/src/__fixtures__/basic/content/basic-gallery-missing-tracked.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-missing-tracked.val.ts",
-  s.imageset({
-    dir: "/public/val/images4",
-    accept: "image/*",
-  }),
+  s.imagedir("/public/val/images4", { accept: "image/*" }),
   {
     "/public/val/images4/missing.png": {
       width: 1,

package/src/__fixtures__/basic/content/basic-gallery-remote-existing.val.ts

@@ -2,12 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-remote-existing.val.ts",
-  s
-    .imageset({
-      dir: "/public/val/images-remote2",
-      accept: "image/*",
-    })
-    .remote(),
+  s.imagedir("/public/val/images-remote2", { accept: "image/*" }).remote(),
 
   {
     "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc1/f/def4/p/public/val/images-remote2/image.png":

package/src/__fixtures__/basic/content/basic-gallery-remote.val.ts

@@ -2,12 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-remote.val.ts",
-  s
-    .imageset({
-      dir: "/public/val/images-remote",
-      accept: "image/*",
-    })
-    .remote(),
+  s.imagedir("/public/val/images-remote", { accept: "image/*" }).remote(),
 
   {
     "/public/val/images-remote/image.png": {

package/src/__fixtures__/basic/content/basic-gallery-wrong-metadata.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery-wrong-metadata.val.ts",
-  s.imageset({
-    dir: "/public/val/images3",
-    accept: "image/*",
-  }),
+  s.imagedir("/public/val/images3", { accept: "image/*" }),
   {
     "/public/val/images3/image.png": {
       width: 999,

package/src/__fixtures__/basic/content/basic-gallery.val.ts

@@ -2,10 +2,7 @@ import { c, s } from "../val.config";
 
 export default c.define(
   "/content/basic-gallery.val.ts",
-  s.imageset({
-    dir: "/public/val/images",
-    accept: "image/*",
-  }),
+  s.imagedir("/public/val/images", { accept: "image/*" }),
 
   {
     "/public/val/images/image.png": {

package/src/__fixtures__/basic/val.modules.ts

@@ -6,6 +6,7 @@ export default modules(config, [
   { def: () => import("./content/basic-errors.val") },
   { def: () => import("./content/basic-files.val") },
   { def: () => import("./content/basic-image.val") },
+  { def: () => import("./content/basic-fixable-and-unfixable.val") },
   { def: () => import("./content/basic-image-from-gallery.val") },
   { def: () => import("./content/basic-image-from-galleries.val") },
   { def: () => import("./content/basic-gallery.val") },

package/src/listUnusedFiles.ts

@@ -56,7 +56,7 @@ export async function listUnusedFiles({ root }: { root?: string }) {
         },
       );
     }
-    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) is
+    // A media collection (`s.imagedir()`, `s.filedir()`, `s.videodir()`) is
     // keyed by its files, and an entry that is fine reports no error either —
     // so, as for a video, they are found by walking the source. A video set's
     // stream holds every playlist and segment its master names, and an entry

package/src/publish/buildArtifacts.ts

@@ -279,9 +279,13 @@ export async function buildArtifacts(options: {
       }
     })();
     const deps = node.layerDepsOf(manifest, sources);
+    // The files those stylesheets point at -- a font package's `.woff2`s --
+    // published with the site under the names their `url()`s now use.
+    const dependencyAssets: Record<string, string> = {};
     const css = await node.collectDependencyCss(
       root,
       node.cssSpecifiersOf(sources),
+      dependencyAssets,
     );
     const layer = await node.buildVendorLayer(root, deps, css, {
       base: target.base,
@@ -319,6 +323,7 @@ export async function buildArtifacts(options: {
       env: publicEnv(options.env ?? process.env),
       publicFiles: readPublicFiles(root),
       assets,
+      dependencyAssets,
       // The project's own files, without the generated tree or the
       // stylesheets: what the next publish -- the Studio's included -- starts
       // from. See `withoutStylesheets`.

package/src/runValidation.imageset.test.ts

@@ -0,0 +1,340 @@
+import { describe, test, expect, beforeEach, afterEach } from "@jest/globals";
+import path from "path";
+import fs from "fs";
+import {
+  DEFAULT_VAL_REMOTE_HOST,
+  type ModuleFilePath,
+  type ModulePath,
+} from "@valbuild/core";
+import { createService } from "@valbuild/server";
+import {
+  createDefaultValFSHost,
+  runValidation,
+  ValidationEvent,
+  IValRemote,
+} from "./runValidation";
+
+/**
+ * `val validate` over a project with `s.imagedir().remote()` and
+ * `s.filedir().remote()` collections, and a page that picks from them — as a
+ * field, and as an image inside rich text. End to end: module loading, the fix
+ * handlers, the patches and the `.val.ts` rewrite.
+ */
+
+const BASIC_FIXTURE = path.resolve(__dirname, "__fixtures__/basic");
+
+// An 8x8 solid-colour PNG, so the metadata extractor has real bytes to read.
+const PNG = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX/AAD//" +
+    "/+l2Z/dAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9oIBRELLnJqTAAAAAxJREFUCNdjYGBgAAAABAABJzQnCgAAAABJRU5ErkJggg==",
+  "base64",
+);
+
+const LOGO = "/public/val/images/logo_abcde.png";
+/**
+ * What the Studio stores in a field when an image is uploaded through it into
+ * a remote gallery: a ref, while the gallery keys the entry by the local path
+ * inside it (here, LOGO).
+ */
+const LOGO_UPLOADED_THROUGH_FIELD = `https://remote.val.build/file/p/pubproj/b/01/v/0.0.0/h/${"c".repeat(
+  64,
+)}/f/${"d".repeat(12)}/p${LOGO}`;
+const DOC = "/public/val/files/doc_12345.pdf";
+
+const PROJECT: Record<string, string> = {
+  "val.modules.ts": `import { modules } from "@valbuild/core";
+import { config } from "./val.config";
+
+export default modules(config, [
+  { def: () => import("./content/images.val") },
+  { def: () => import("./content/files.val") },
+  { def: () => import("./content/page.val") },
+  { def: () => import("./content/cards.val") },
+  { def: () => import("./content/local-images.val") },
+  { def: () => import("./content/remote-image.val") },
+]);
+`,
+  "content/images.val.ts": `import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/images.val.ts",
+  s.imagedir("/public/val/images").remote(),
+  {
+    "${LOGO}": { width: 8, height: 8, mimeType: "image/png", alt: "Logo" },
+  },
+);
+`,
+  "content/files.val.ts": `import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/files.val.ts",
+  s.filedir("/public/val/files", { accept: "application/pdf" }).remote(),
+  {
+    "${DOC}": { mimeType: "application/pdf" },
+  },
+);
+`,
+  // A field inside a `.jsonValues()` entry: its value is in the entry's
+  // `*.val.json`, which is where the rename has to land.
+  "content/cards.val.ts": `import { c, s } from "../val.config";
+import imagesVal from "./images.val";
+
+export default c.define(
+  "/content/cards.val.ts",
+  s.record(s.object({ image: s.image(imagesVal) })).jsonValues(),
+  {
+    "/a": c.json(() => import("./cards/a.val.json")),
+  },
+);
+`,
+  "content/cards/a.val.json": JSON.stringify({ image: { path: LOGO } }),
+  "content/page.val.ts": `import { c, s } from "../val.config";
+import imagesVal from "./images.val";
+import filesVal from "./files.val";
+
+export default c.define(
+  "/content/page.val.ts",
+  s.object({
+    hero: s.image(imagesVal),
+    card: s.image(imagesVal),
+    body: s.richtext({ img: s.image(imagesVal) }),
+    attachment: s.file(filesVal),
+  }),
+  {
+    hero: { path: "${LOGO}", alt: "Kept" },
+    card: { path: "${LOGO_UPLOADED_THROUGH_FIELD}" },
+    body: [
+      {
+        tag: "p",
+        children: ["Look: ", { tag: "img", src: { path: "${LOGO}" } }],
+      },
+    ],
+    attachment: { path: "${DOC}" },
+  },
+);
+`,
+  // Not \`.remote()\`, and keyed by a ref anyway: an error for a person.
+  "content/local-images.val.ts": `import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/local-images.val.ts",
+  s.imagedir("/public/val/local"),
+  {
+    "https://remote.val.build/file/p/pubproj/b/01/v/0.0.0/h/${"a".repeat(64)}/f/${"b".repeat(12)}/p/public/val/local/x_00000.png":
+      { width: 8, height: 8, mimeType: "image/png", alt: null },
+  },
+);
+`,
+  // A field of its own, not from a gallery, with a ref that does not parse.
+  "content/remote-image.val.ts": `import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/remote-image.val.ts",
+  s.image().remote(),
+  { path: "https://remote.val.build/file/not-a-ref.png", width: 8, height: 8, mimeType: "image/png" },
+);
+`,
+};
+
+const notExpected: 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");
+  },
+};
+
+async function run(
+  root: string,
+  valFiles: string[],
+  fix: boolean,
+  remote: IValRemote = notExpected,
+): Promise<ValidationEvent[]> {
+  const events: ValidationEvent[] = [];
+  for await (const event of runValidation({
+    root,
+    fix,
+    valFiles,
+    project: fix ? "test/project" : undefined,
+    remote,
+    fs: createDefaultValFSHost(),
+  })) {
+    events.push(event);
+  }
+  return events;
+}
+
+async function sourceOf(root: string, moduleFilePath: string) {
+  const service = await createService(root, createDefaultValFSHost());
+  try {
+    const result = await service.get(
+      moduleFilePath as ModuleFilePath,
+      "" as ModulePath,
+      { validate: false },
+    );
+    return result.source;
+  } finally {
+    service.dispose();
+  }
+}
+
+function errorsOf(events: ValidationEvent[]) {
+  return events.filter(
+    (e) =>
+      e.type === "validation-error" || e.type === "validation-fixable-error",
+  );
+}
+
+describe("val validate with remote image and file collections", () => {
+  let root: string;
+
+  beforeEach(() => {
+    const tmpBase = path.join(__dirname, ".tmp");
+    fs.mkdirSync(tmpBase, { recursive: true });
+    root = fs.mkdtempSync(path.join(tmpBase, "imageset-"));
+    for (const file of ["val.config.ts", "tsconfig.json"]) {
+      fs.copyFileSync(path.join(BASIC_FIXTURE, file), path.join(root, file));
+    }
+    const files: Record<string, string | Buffer> = {
+      ...PROJECT,
+      [LOGO.slice(1)]: PNG,
+      [DOC.slice(1)]: "%PDF-1.4\n",
+      "public/val/local/x_00000.png": PNG,
+    };
+    for (const [file, content] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
+      fs.writeFileSync(path.join(root, file), content);
+    }
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  test("--fix uploads the entries, renames their keys, and points the page's field and rich text image at them", async () => {
+    fs.mkdirSync(path.join(root, ".val"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, ".val", "pat.json"),
+      JSON.stringify({ pat: "test-pat" }),
+    );
+    const uploaded: string[] = [];
+    const remote: IValRemote = {
+      remoteHost: DEFAULT_VAL_REMOTE_HOST,
+      getSettings: async () => ({
+        success: true,
+        data: {
+          publicProjectId: "pubproj",
+          remoteFileBuckets: [{ bucket: "01" }],
+        },
+      }),
+      uploadFile: async (_project, _bucket, fileHash) => {
+        uploaded.push(fileHash);
+        return { success: true };
+      },
+    };
+    const modules = [
+      "content/cards.val.ts",
+      "content/files.val.ts",
+      "content/images.val.ts",
+      "content/page.val.ts",
+    ];
+    // Before: the page is valid against both collections, and the two
+    // entries are fixable.
+    expect(
+      errorsOf(await run(root, modules, false)).map((e) => e.sourcePath),
+    ).toEqual([
+      `/content/files.val.ts?p="${DOC}"`,
+      `/content/images.val.ts?p="${LOGO}"`,
+    ]);
+
+    await run(root, modules, true, remote);
+    expect(uploaded).toHaveLength(2);
+
+    const images = await sourceOf(root, "/content/images.val.ts");
+    const [logoRef] = Object.keys(images ?? {});
+    expect(logoRef).toMatch(
+      /^https:\/\/.*pubproj.*public\/val\/images\/logo_abcde\.png$/,
+    );
+    const files = await sourceOf(root, "/content/files.val.ts");
+    const [docRef] = Object.keys(files ?? {});
+    expect(docRef).toMatch(
+      /^https:\/\/.*pubproj.*public\/val\/files\/doc_12345\.pdf$/,
+    );
+    expect(await sourceOf(root, "/content/page.val.ts")).toEqual({
+      hero: { path: logoRef, alt: "Kept" },
+      card: { path: logoRef },
+      body: [
+        {
+          tag: "p",
+          children: ["Look: ", { tag: "img", src: { path: logoRef } }],
+        },
+      ],
+      attachment: { path: docRef },
+    });
+    expect(
+      JSON.parse(
+        fs.readFileSync(path.join(root, "content/cards/a.val.json"), "utf-8"),
+      ),
+    ).toEqual({ image: { path: logoRef } });
+
+    // And all of them are valid against each other afterwards.
+    const again = await run(root, modules, false);
+    expect(errorsOf(again)).toEqual([]);
+    expect(again.at(-1)).toEqual({ type: "summary-success" });
+  });
+
+  describe("a key that is wrong as a key", () => {
+    test("is reported with what core says, and the module is not valid", async () => {
+      const events = await run(root, ["content/local-images.val.ts"], false);
+      expect(errorsOf(events)).toEqual([
+        expect.objectContaining({
+          type: "validation-error",
+          message: expect.stringContaining("Remote URLs are not allowed"),
+          keyError: true,
+        }),
+      ]);
+      expect(events.filter((e) => e.type === "file-valid")).toEqual([]);
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+    });
+
+    test("--fix leaves it to a person, and still reports it", async () => {
+      const before = fs.readFileSync(
+        path.join(root, "content/local-images.val.ts"),
+        "utf-8",
+      );
+      const events = await run(root, ["content/local-images.val.ts"], true);
+      expect(errorsOf(events)).toEqual([
+        expect.objectContaining({
+          type: "validation-error",
+          message: expect.stringContaining("Remote URLs are not allowed"),
+        }),
+      ]);
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+      expect(
+        fs.readFileSync(
+          path.join(root, "content/local-images.val.ts"),
+          "utf-8",
+        ),
+      ).toBe(before);
+    });
+  });
+
+  /**
+   * The singular `image:check-remote` is core's "was not checked" marker, put
+   * on every remote image whether or not it is wrong. It stays a hand-off to
+   * `createFixPatch`, which checks the ref and reports only what is wrong —
+   * this pins that the hand-off does report it.
+   */
+  test("a field's malformed remote ref is still reported, through the check createFixPatch makes", async () => {
+    const events = await run(root, ["content/remote-image.val.ts"], false);
+    expect(errorsOf(events)).toEqual([
+      expect.objectContaining({
+        sourcePath: "/content/remote-image.val.ts",
+        message: expect.stringContaining("not-a-ref.png"),
+      }),
+    ]);
+    expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+  });
+});

package/src/runValidation.test.ts

@@ -125,6 +125,52 @@ describe("runValidation", () => {
     });
   });
 
+  describe("a module where --fix repairs one error and not the other", () => {
+    const FILE = "content/basic-fixable-and-unfixable.val.ts";
+    const runOn = async (fix: boolean) => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix,
+        valFiles: [FILE],
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      return events;
+    };
+
+    test("is not reported valid after --fix, and counts only what is left", async () => {
+      const events = await runOn(true);
+
+      expect(events.filter((e) => e.type === "fix-applied")).toHaveLength(1);
+      expect(events.filter((e) => e.type === "validation-error")).toEqual([
+        expect.objectContaining({
+          sourcePath: `/${FILE}?p="title"`,
+        }),
+      ]);
+      // One fixed and one left must not add up to "valid".
+      expect(events.filter((e) => e.type === "file-valid")).toEqual([]);
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          type: "file-error-count",
+          file: `/${FILE}`,
+          errorCount: 1,
+        }),
+      );
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 });
+    });
+
+    test("without --fix, reports both", async () => {
+      const events = await runOn(false);
+
+      expect(events.filter((e) => e.type === "file-valid")).toEqual([]);
+      expect(events.at(-1)).toEqual({ type: "summary-errors", count: 2 });
+    });
+  });
+
   test("handles module with both s.image and s.images", async () => {
     const events: ValidationEvent[] = [];
 

package/src/runValidation.ts

@@ -175,8 +175,9 @@ export async function* runValidation({
       };
       return;
     } else {
+      // What is still wrong with this module once every handler has run: an
+      // error that was fixed is not counted, one that was not is.
       let fileErrors = 0;
-      let fixedErrors = 0;
       if (valModule.errors) {
         if (valModule.errors.validation) {
           // Resolve schema/source fixes (keyof:check-keys, router:check-route)
@@ -265,7 +266,6 @@ export async function* runValidation({
               }
 
               if (result.appliedFix) {
-                fixedErrors += 1;
                 yield { type: "fix-applied", file, sourcePath };
               }
 
@@ -306,7 +306,6 @@ export async function* runValidation({
                       sourcePath: other.moduleFilePath,
                     };
                   }
-                  fixedErrors += 1;
                   yield { type: "fix-applied", file, sourcePath };
                 } else if (
                   !fix &&
@@ -339,8 +338,11 @@ export async function* runValidation({
             }
           }
         }
+        // Valid means nothing is left, not that as many errors were fixed as
+        // are left: one fix and one error that no fix touches add up to the
+        // same count, and printed a module with an error in it as valid.
         if (
-          fixedErrors === fileErrors &&
+          fileErrors === 0 &&
           (!valModule.errors.fatal || valModule.errors.fatal.length == 0)
         ) {
           yield {

package/src/runValidation.videoset.test.ts

@@ -15,7 +15,7 @@ import {
 } from "./runValidation";
 
 /**
- * `val validate` over a project with an `s.videoset()`, end to end: module
+ * `val validate` over a project with an `s.videodir()`, end to end: module
  * loading, the fix handlers, the patches and the `.val.ts` rewrite.
  *
  * The project is written here rather than kept as a fixture because its whole
@@ -55,7 +55,7 @@ export default modules(config, [
 
 export default c.define(
   "/content/videos.val.ts",
-  s.videoset({ dir: "/public/val/videos" }),
+  s.videodir("/public/val/videos"),
   {
     "/public/val/videos/clip_abcde.mp4": { alt: "A clip" },
     "/public/val/videos/intro_05198/master.m3u8": {
@@ -72,7 +72,7 @@ export default c.define(
 
 export default c.define(
   "/content/videos-remote.val.ts",
-  s.videoset({ dir: "/public/val/remote-videos" }).remote(),
+  s.videodir("/public/val/remote-videos").remote(),
   {
     "/public/val/remote-videos/clip_fghij.mp4": {
       mimeType: "video/mp4",
@@ -155,7 +155,7 @@ async function sourceOf(root: string, moduleFilePath: string) {
   }
 }
 
-describe("val validate with an s.videoset()", () => {
+describe("val validate with an s.videodir()", () => {
   let root: string;
 
   beforeEach(() => {