@valbuild/cli 0.140.2 → 0.141.0

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

@@ -4,9 +4,9 @@ import path from 'path';
 import pc from 'picocolors';
 import { glob } from 'fast-glob';
 import { Internal, DEFAULT_VAL_REMOTE_HOST, DEFAULT_CONTENT_HOST } from '@valbuild/core';
-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 { createPrettierFormatter, createService, createValModuleFileInspector, fixHandlers, createFixPatch, getModulePathRange, findJsonEntryFilePath, createJsonEntryPathMap, createModulePathMap, findAndEvalValConfigFile, getSettings, uploadRemoteFile, createDefaultValFSHost, filesOfVideo, startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, loadValModules, safeReadGit, ValOpsHttp, ValOpsFS, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, formatPatchSourceError, APP_MODE_REQUIRES_REMOTE_FILES } from '@valbuild/server';
 import fs from 'fs/promises';
-import { resolveSchemaSourceFixes, parseBuildTarget, parseDeclare, parseArtifacts, parseVerify, parsePromote, parseStatus, parsePublishToken, PublishProtocolError, parseProblems } from '@valbuild/shared/internal';
+import { resolveSchemaSourceFixes, traverseSchemaSource, parseBuildTarget, parseDeclare, parseArtifacts, parseVerify, parsePromote, parseStatus, parsePublishToken, PublishProtocolError, parseProblems } from '@valbuild/shared/internal';
 import fs$1 from 'fs';
 import ts from 'typescript';
 import JSZip from 'jszip';
@@ -324,6 +324,18 @@ async function* runValidation({
                 }, !!fix, sourcePath, v, remoteFiles, valModule.source, valModule.schema);
                 if (fix && fixPatch !== null && fixPatch !== void 0 && fixPatch.patch && (fixPatch === null || fixPatch === void 0 ? void 0 : fixPatch.patch.length) > 0) {
                   await service.patch(moduleFilePath, fixPatch.patch);
+                  // A fix that renames something other modules name (a video
+                  // set's key) rewrites them too, and only once its own patch
+                  // is in: a reference to a key that was never renamed is the
+                  // one thing worse than a stale one.
+                  for (const other of result.otherModulePatches ?? []) {
+                    await service.patch(other.moduleFilePath, other.patch);
+                    yield {
+                      type: "fix-applied",
+                      file: other.moduleFilePath.slice(1),
+                      sourcePath: other.moduleFilePath
+                    };
+                  }
                   fixedErrors += 1;
                   yield {
                     type: "fix-applied",
@@ -940,11 +952,10 @@ async function watchAndValidate(projectRoot, runOnce) {
 async function listUnusedFiles({
   root
 }) {
-  var _valConfigFile$files;
   const projectRoot = root ? path.resolve(root) : process.cwd();
-  const valConfigFile = await findAndEvalValConfigFile(projectRoot);
-  // Strip the leading "/" so it is relative to the project root (e.g. "public/val").
-  const managedDir = ((valConfigFile === null || valConfigFile === void 0 || (_valConfigFile$files = valConfigFile.files) === null || _valConfigFile$files === void 0 ? void 0 : _valConfigFile$files.directory) ?? "/public/val").replace(/^\//, "");
+
+  // Relative to the project root.
+  const managedDir = "public/val";
   const service = await createService(projectRoot);
   const registered = new Set(service.getModuleFilePaths());
   const valFiles = await glob("**/*.val.{js,ts}", {
@@ -961,6 +972,54 @@ async function listUnusedFiles({
     const valModule = await service.get(moduleId, "", {
       validate: true
     });
+    // A video is found by walking the source, not by its validation errors:
+    // unlike an image, a video with all its metadata reports none, so the
+    // errors below would call every finished video unused. And a video names
+    // more than its `path` — a poster, caption tracks, and a stream's
+    // playlists and segments — which `filesOfVideo` is the one answer to.
+    if (valModule.source !== undefined && valModule.schema) {
+      traverseSchemaSource(valModule.source, valModule.schema, moduleId, ({
+        source,
+        schema
+      }) => {
+        if (schema.type !== "video") {
+          return;
+        }
+        for (const ref of filesOfVideo(source, {
+          projectRoot
+        })) {
+          if (!Internal.isRemoteMediaPath(ref)) {
+            filesUsedByVal.push(path.join(projectRoot, ...ref.split("/")));
+          }
+        }
+      });
+    }
+    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) 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
+    // its default poster and captions.
+    if (valModule.source !== undefined && valModule.schema) {
+      forEachMediaCollection(valModule.source, valModule.schema, (entries, mediaType) => {
+        for (const [key, entry] of Object.entries(entries)) {
+          const refs = mediaType === "videos" ?
+          // The entry's poster and captions are its own files too.
+          filesOfVideo(isObject(entry) ? {
+            ...entry,
+            path: key
+          } : {
+            path: key
+          }, {
+            projectRoot
+          }) : [key];
+          for (const ref of refs) {
+            if (!Internal.isRemoteMediaPath(ref)) {
+              filesUsedByVal.push(path.join(projectRoot, ...ref.split("/")));
+            }
+          }
+        }
+      });
+    }
     // TODO: not sure using validation is the best way to do this, but it works currently.
     if (valModule.errors) {
       if (valModule.errors.validation) {
@@ -1005,6 +1064,44 @@ async function listUnusedFiles({
 function isFileRef(value) {
   return !!value && typeof value === "object" && "path" in value && typeof value.path === "string";
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Every media collection in a module's source, with its entries.
+ *
+ * `traverseSchemaSource` visits leaves, and a collection is a record whose
+ * KEYS are what matters, so it never shows up there.
+ */
+function forEachMediaCollection(source, schema, visit) {
+  if (schema.type === "record") {
+    if (!isObject(source)) {
+      return;
+    }
+    if (schema.mediaType) {
+      visit(source, schema.mediaType);
+      return;
+    }
+    for (const value of Object.values(source)) {
+      forEachMediaCollection(value, schema.item, visit);
+    }
+  } else if (schema.type === "object") {
+    if (!isObject(source)) {
+      return;
+    }
+    for (const [key, item] of Object.entries(schema.items)) {
+      forEachMediaCollection(source[key], item, visit);
+    }
+  } else if (schema.type === "array") {
+    if (!Array.isArray(source)) {
+      return;
+    }
+    for (const value of source) {
+      forEachMediaCollection(value, schema.item, visit);
+    }
+  }
+}
 
 /**
  * The versions of the Val packages this project has installed.
@@ -1185,7 +1282,6 @@ async function lsp() {
 
 class DebugContextError extends Error {}
 async function createDebugContext(options) {
-  var _config$files;
   const projectRoot = options.root ? path.resolve(options.root) : process.cwd();
   if (!fs$1.existsSync(projectRoot)) {
     throw new DebugContextError(`Project root does not exist: ${projectRoot}`);
@@ -1196,7 +1292,7 @@ async function createDebugContext(options) {
   }
   const valModules = loadValModules(projectRoot);
   const contentUrl = process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST;
-  const filesDirectory = ((_config$files = config.files) === null || _config$files === void 0 ? void 0 : _config$files.directory) ?? "/public/val";
+  const filesDirectory = "/public/val";
   const project = config.project || process.env.VAL_PROJECT || null;
   const git = await safeReadGit(projectRoot);
   const branch = options.branch || config.gitBranch || process.env.VAL_GIT_BRANCH || git.branch || null;
@@ -1286,7 +1382,8 @@ function readAuth(projectRoot) {
  * Starts from the modules the pending patches touch and closes over the
  * cross-module references a schema can hold:
  *  - `keyOf` points at another module through its `path` (a SourcePath)
- *  - `image`/`file` point at a gallery module through `referencedModule`
+ *  - `image`/`file`/`video` point at a gallery (or video set) module through
+ *    `referencedModule`
  *  - route validation cross-references *every* router module, so if any
  *    included module has a route or router we need all of them
  */
@@ -1375,6 +1472,7 @@ function collectSchemaReferences(schema) {
         break;
       case "file":
       case "image":
+      case "video":
         if (node.referencedModule) {
           refs.referencedModules.push(node.referencedModule);
         }
@@ -3078,7 +3176,39 @@ async function runPublish(options) {
   if (git.status === "error") {
     return git;
   }
-  const config = await findAndEvalValConfigFile(root).catch(() => null);
+  const read = await findAndEvalValConfigFile(root).then(config => ({
+    config,
+    error: null
+  }), error => ({
+    config: null,
+    error
+  }));
+  const config = read.config;
+  /*
+   * The Val app stores all media remotely, and the deployed server refuses to
+   * start for a project that does not say so. Refused here too, so that a
+   * developer who removes `files: { remote: true }` finds out from this
+   * command -- not from the site, after the build has gone out.
+   *
+   * A config that cannot be read is refused as well when this builds the
+   * checkout, because the commonest way to lose the setting is to shorten
+   * `initVal({ files: { remote: true } })` to `initVal()`, which exports no
+   * config at all. Skipping the check then would be skipping it exactly when
+   * it was needed.
+   *
+   * A directory of artifacts built elsewhere is the exception: it may have no
+   * config beside it, or none this machine can evaluate, and the server's own
+   * check still stands there.
+   */
+  const refusal = remoteFilesRefusal(read, {
+    building: !prebuilt
+  });
+  if (refusal !== null) {
+    return {
+      status: "error",
+      message: refusal
+    };
+  }
   const project = (config === null || config === void 0 ? void 0 : config.project) ?? env.VAL_PROJECT ?? null;
   const credential = await resolvePublishCredential({
     root,
@@ -3636,6 +3766,24 @@ function formatBytes(bytes) {
   }
   return `${value.toFixed(1)} ${units[unit]}`;
 }
+/**
+ * Why this project cannot be published to the Val app as its media is
+ * configured, or null when it can. See the call site.
+ */
+function remoteFilesRefusal(read, {
+  building
+}) {
+  if (read.config !== null) {
+    var _read$config$files;
+    return ((_read$config$files = read.config.files) === null || _read$config$files === void 0 ? void 0 : _read$config$files.remote) === true ? null : APP_MODE_REQUIRES_REMOTE_FILES;
+  }
+  if (!building) return null;
+  if (read.error !== null) {
+    const reason = read.error instanceof Error ? read.error.message : String(read.error);
+    return `${APP_MODE_REQUIRES_REMOTE_FILES}\n\nval.config.ts could not be read, so this could not be checked: ${reason}`;
+  }
+  return `${APP_MODE_REQUIRES_REMOTE_FILES}\n\nThere is no val.config.ts (or val.config.js) in this project to say it.`;
+}
 
 /**
  * `val publish` - a built project in, a live site out.
@@ -3941,7 +4089,7 @@ async function main() {
 
       Command: list-unused-files
       Description: EXPERIMENTAL.
-        List files that are in the configured files directory (files.directory, default public/val) but not in use by any Val module.
+        List files that are in the configured files directory (public/val) but not in use by any Val module.
         This is useful for cleaning up unused files.
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.140.2",
+  "version": "0.141.0",
   "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.139.1",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/language-server": "0.140.2",
-    "@valbuild/shared": "0.140.2",
-    "@valbuild/server": "0.140.2"
+    "@valbuild/language-server": "0.141.0",
+    "@valbuild/core": "0.141.0",
+    "@valbuild/shared": "0.141.0",
+    "@valbuild/server": "0.141.0"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/cli.ts

@@ -95,7 +95,7 @@ async function main(): Promise<void> {
 
       Command: list-unused-files
       Description: EXPERIMENTAL.
-        List files that are in the configured files directory (files.directory, default public/val) but not in use by any Val module.
+        List files that are in the configured files directory (public/val) but not in use by any Val module.
         This is useful for cleaning up unused files.
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())

package/src/debug/context.ts

@@ -64,7 +64,7 @@ export async function createDebugContext(options: {
   }
   const valModules = loadValModules(projectRoot);
   const contentUrl = process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST;
-  const filesDirectory = config.files?.directory ?? "/public/val";
+  const filesDirectory = "/public/val";
   const project = config.project || process.env.VAL_PROJECT || null;
   const git = await safeReadGit(projectRoot);
   const branch =

package/src/debug/moduleClosure.ts

@@ -18,7 +18,8 @@ export type InclusionReason =
  * Starts from the modules the pending patches touch and closes over the
  * cross-module references a schema can hold:
  *  - `keyOf` points at another module through its `path` (a SourcePath)
- *  - `image`/`file` point at a gallery module through `referencedModule`
+ *  - `image`/`file`/`video` point at a gallery (or video set) module through
+ *    `referencedModule`
  *  - route validation cross-references *every* router module, so if any
  *    included module has a route or router we need all of them
  */
@@ -123,6 +124,7 @@ function collectSchemaReferences(schema: SerializedSchema): SchemaReferences {
         break;
       case "file":
       case "image":
+      case "video":
         if (node.referencedModule) {
           refs.referencedModules.push(node.referencedModule);
         }

package/src/listUnusedFiles.ts

@@ -1,18 +1,20 @@
-import { ModuleFilePath, ModulePath, SourcePath } from "@valbuild/core";
-import { createService } from "@valbuild/server";
+import {
+  Internal,
+  ModuleFilePath,
+  ModulePath,
+  SerializedSchema,
+  SourcePath,
+} from "@valbuild/core";
+import { createService, filesOfVideo } from "@valbuild/server";
+import { traverseSchemaSource } from "@valbuild/shared/internal";
 import { glob } from "fast-glob";
 import path from "path";
-import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 
 export async function listUnusedFiles({ root }: { root?: string }) {
   const projectRoot = root ? path.resolve(root) : process.cwd();
 
-  const valConfigFile = await findAndEvalValConfigFile(projectRoot);
-  // Strip the leading "/" so it is relative to the project root (e.g. "public/val").
-  const managedDir = (valConfigFile?.files?.directory ?? "/public/val").replace(
-    /^\//,
-    "",
-  );
+  // Relative to the project root.
+  const managedDir = "public/val";
 
   const service = await createService(projectRoot);
   const registered = new Set<ModuleFilePath>(service.getModuleFilePaths());
@@ -32,6 +34,56 @@ export async function listUnusedFiles({ root }: { root?: string }) {
     const valModule = await service.get(moduleId, "" as ModulePath, {
       validate: true,
     });
+    // A video is found by walking the source, not by its validation errors:
+    // unlike an image, a video with all its metadata reports none, so the
+    // errors below would call every finished video unused. And a video names
+    // more than its `path` — a poster, caption tracks, and a stream's
+    // playlists and segments — which `filesOfVideo` is the one answer to.
+    if (valModule.source !== undefined && valModule.schema) {
+      traverseSchemaSource(
+        valModule.source,
+        valModule.schema,
+        moduleId as string as SourcePath,
+        ({ source, schema }) => {
+          if (schema.type !== "video") {
+            return;
+          }
+          for (const ref of filesOfVideo(source, { projectRoot })) {
+            if (!Internal.isRemoteMediaPath(ref)) {
+              filesUsedByVal.push(path.join(projectRoot, ...ref.split("/")));
+            }
+          }
+        },
+      );
+    }
+    // A media collection (`s.imageset()`, `s.fileset()`, `s.videoset()`) 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
+    // its default poster and captions.
+    if (valModule.source !== undefined && valModule.schema) {
+      forEachMediaCollection(
+        valModule.source,
+        valModule.schema,
+        (entries, mediaType) => {
+          for (const [key, entry] of Object.entries(entries)) {
+            const refs =
+              mediaType === "videos"
+                ? // The entry's poster and captions are its own files too.
+                  filesOfVideo(
+                    isObject(entry) ? { ...entry, path: key } : { path: key },
+                    { projectRoot },
+                  )
+                : [key];
+            for (const ref of refs) {
+              if (!Internal.isRemoteMediaPath(ref)) {
+                filesUsedByVal.push(path.join(projectRoot, ...ref.split("/")));
+              }
+            }
+          }
+        },
+      );
+    }
     // TODO: not sure using validation is the best way to do this, but it works currently.
     if (valModule.errors) {
       if (valModule.errors.validation) {
@@ -86,3 +138,49 @@ function isFileRef(value: unknown): value is { path: string } {
     typeof value.path === "string"
   );
 }
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Every media collection in a module's source, with its entries.
+ *
+ * `traverseSchemaSource` visits leaves, and a collection is a record whose
+ * KEYS are what matters, so it never shows up there.
+ */
+function forEachMediaCollection(
+  source: unknown,
+  schema: SerializedSchema,
+  visit: (
+    entries: Record<string, unknown>,
+    mediaType: "files" | "images" | "videos",
+  ) => void,
+): void {
+  if (schema.type === "record") {
+    if (!isObject(source)) {
+      return;
+    }
+    if (schema.mediaType) {
+      visit(source, schema.mediaType);
+      return;
+    }
+    for (const value of Object.values(source)) {
+      forEachMediaCollection(value, schema.item, visit);
+    }
+  } else if (schema.type === "object") {
+    if (!isObject(source)) {
+      return;
+    }
+    for (const [key, item] of Object.entries(schema.items)) {
+      forEachMediaCollection(source[key], item, visit);
+    }
+  } else if (schema.type === "array") {
+    if (!Array.isArray(source)) {
+      return;
+    }
+    for (const value of source) {
+      forEachMediaCollection(value, schema.item, visit);
+    }
+  }
+}

package/src/publish/__fixtures__/buildPublishProbe.ts

@@ -69,7 +69,7 @@ export const Route = createFileRoute("/build/")({
 `,
   "src/styles.css": `h1 { color: rebeccapurple; }\n`,
   // A Val project, so the publish wires it -- and wires it at a branch.
-  "val.config.ts": `export const config = { project: "acme/site" };\n`,
+  "val.config.ts": `export const config = { project: "acme/site", files: { remote: true } };\n`,
   "val.modules.ts": `export default { modules: [] };\n`,
   "public/robots.txt": "User-agent: *\n",
 };

package/src/publish/runPublish.test.ts

@@ -4,6 +4,7 @@ import os from "os";
 import path from "path";
 import zlib from "zlib";
 import { startFakeContentService } from "./fakeContent";
+import { APP_MODE_REQUIRES_REMOTE_FILES } from "@valbuild/server";
 import { runPublish } from "./runPublish";
 
 /**
@@ -59,6 +60,78 @@ const apiCalls = (calls: Array<{ method: string; path: string }>) =>
     .map(({ method, path: p }) => `${method} ${p}`);
 
 describe("val publish", () => {
+  test("refuses a project whose media is not remote, before building", async () => {
+    // The Val app has no repository for an upload to go into, so its deployed
+    // server refuses such a project -- and finding that out after the build
+    // has gone out is the worst place to find it.
+    const fake = await startFakeContentService({ token: TOKEN });
+    const root = makeArtifacts();
+    fs.writeFileSync(
+      path.join(root, "val.config.ts"),
+      `export const config = { project: "acme/site" };\n`,
+    );
+    try {
+      const result = await run(root, fake.url);
+      expect(result).toEqual({
+        status: "error",
+        message: APP_MODE_REQUIRES_REMOTE_FILES,
+      });
+      expect(apiCalls(fake.calls)).toEqual([]);
+    } finally {
+      await fake.close();
+    }
+  });
+
+  test.each([
+    [
+      // `initVal()` exports no config at all: the commonest way to lose the
+      // setting, and the one a lenient read would wave through.
+      "a config that cannot be read",
+      { "val.config.ts": "export const config = undefined;\n" },
+      "could not be read",
+    ],
+    ["no config at all", {}, "There is no val.config.ts"],
+  ])(
+    "refuses to build a checkout with %s",
+    async (_, files: Record<string, string>, reason) => {
+      const fake = await startFakeContentService({ token: TOKEN });
+      const root = fs.mkdtempSync(path.join(os.tmpdir(), "val-publish-cfg-"));
+      fs.writeFileSync(path.join(root, "package.json"), "{}\n");
+      for (const [name, contents] of Object.entries(files)) {
+        fs.writeFileSync(path.join(root, name), contents);
+      }
+      try {
+        const result = await run(root, fake.url);
+        expect(result.status).toBe("error");
+        expect(result).toMatchObject({
+          message: expect.stringContaining(APP_MODE_REQUIRES_REMOTE_FILES),
+        });
+        expect(result).toMatchObject({
+          message: expect.stringContaining(reason),
+        });
+        // Refused before anything was asked of content, let alone built.
+        expect(fake.calls).toEqual([]);
+      } finally {
+        await fake.close();
+      }
+    },
+  );
+
+  test("...and publishes it once it says files: { remote: true }", async () => {
+    const fake = await startFakeContentService({ token: TOKEN });
+    const root = makeArtifacts();
+    fs.writeFileSync(
+      path.join(root, "val.config.ts"),
+      `export const config = { project: "acme/site", files: { remote: true } };\n`,
+    );
+    try {
+      const result = await run(root, fake.url);
+      expect(result).toMatchObject({ status: "live" });
+    } finally {
+      await fake.close();
+    }
+  });
+
   test("declares, uploads, confirms, verifies and promotes", async () => {
     const fake = await startFakeContentService({ token: TOKEN });
     const root = makeArtifacts();

package/src/publish/runPublish.ts

@@ -1,4 +1,5 @@
-import { safeReadGit } from "@valbuild/server";
+import { APP_MODE_REQUIRES_REMOTE_FILES, safeReadGit } from "@valbuild/server";
+import type { ValConfig } from "@valbuild/core";
 import fs from "fs";
 import path from "path";
 import { findAndEvalValConfigFile } from "../utils/evalValConfigFile";
@@ -155,7 +156,31 @@ export async function runPublish(
     return git;
   }
 
-  const config = await findAndEvalValConfigFile(root).catch(() => null);
+  const read: ConfigRead = await findAndEvalValConfigFile(root).then(
+    (config) => ({ config, error: null }),
+    (error: unknown) => ({ config: null, error }),
+  );
+  const config = read.config;
+  /*
+   * The Val app stores all media remotely, and the deployed server refuses to
+   * start for a project that does not say so. Refused here too, so that a
+   * developer who removes `files: { remote: true }` finds out from this
+   * command -- not from the site, after the build has gone out.
+   *
+   * A config that cannot be read is refused as well when this builds the
+   * checkout, because the commonest way to lose the setting is to shorten
+   * `initVal({ files: { remote: true } })` to `initVal()`, which exports no
+   * config at all. Skipping the check then would be skipping it exactly when
+   * it was needed.
+   *
+   * A directory of artifacts built elsewhere is the exception: it may have no
+   * config beside it, or none this machine can evaluate, and the server's own
+   * check still stands there.
+   */
+  const refusal = remoteFilesRefusal(read, { building: !prebuilt });
+  if (refusal !== null) {
+    return { status: "error", message: refusal };
+  }
   const project = config?.project ?? env.VAL_PROJECT ?? null;
   const credential = await resolvePublishCredential({
     root,
@@ -741,3 +766,29 @@ export function formatBytes(bytes: number): string {
   }
   return `${value.toFixed(1)} ${units[unit]}`;
 }
+
+type ConfigRead =
+  | { config: ValConfig | null; error: null }
+  | { config: null; error: unknown };
+
+/**
+ * Why this project cannot be published to the Val app as its media is
+ * configured, or null when it can. See the call site.
+ */
+function remoteFilesRefusal(
+  read: ConfigRead,
+  { building }: { building: boolean },
+): string | null {
+  if (read.config !== null) {
+    return read.config.files?.remote === true
+      ? null
+      : APP_MODE_REQUIRES_REMOTE_FILES;
+  }
+  if (!building) return null;
+  if (read.error !== null) {
+    const reason =
+      read.error instanceof Error ? read.error.message : String(read.error);
+    return `${APP_MODE_REQUIRES_REMOTE_FILES}\n\nval.config.ts could not be read, so this could not be checked: ${reason}`;
+  }
+  return `${APP_MODE_REQUIRES_REMOTE_FILES}\n\nThere is no val.config.ts (or val.config.js) in this project to say it.`;
+}

package/src/runValidation.ts

@@ -294,6 +294,18 @@ export async function* runValidation({
 
                 if (fix && fixPatch?.patch && fixPatch?.patch.length > 0) {
                   await service.patch(moduleFilePath, fixPatch.patch);
+                  // A fix that renames something other modules name (a video
+                  // set's key) rewrites them too, and only once its own patch
+                  // is in: a reference to a key that was never renamed is the
+                  // one thing worse than a stale one.
+                  for (const other of result.otherModulePatches ?? []) {
+                    await service.patch(other.moduleFilePath, other.patch);
+                    yield {
+                      type: "fix-applied",
+                      file: other.moduleFilePath.slice(1),
+                      sourcePath: other.moduleFilePath,
+                    };
+                  }
                   fixedErrors += 1;
                   yield { type: "fix-applied", file, sourcePath };
                 } else if (