@valbuild/server 0.143.1 → 0.144.1

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

@@ -3593,6 +3593,12 @@ function findNestedJsonValuesModuleErrors(schemas) {
   }
   return errors;
 }
+
+/**
+ * What a save told this instance a `.jsonValues()` entry holds: its content --
+ * JSON `null` included -- or that it was deleted. See `adoptedJsonEntries`.
+ */
+
 // #region ValOps
 class ValOps {
   /** Sources from val modules, immutable (without patches or anything)  */
@@ -3641,7 +3647,9 @@ class ValOps {
    * unlike a module source there is nothing to re-extract, because the memo was
    * never holding the content in the first place.
    *
-   * `null` for an entry the commit deleted.
+   * `deleted` for an entry the commit deleted: tagged, not `null`, because an
+   * entry's content may itself be JSON `null` (a nullable item), and a saved
+   * `null` read back as "deleted" would report the entry missing.
    *
    * Never cleared: it describes what is on disk. A host rebuild makes a new
    * instance, which is the right reset. Bounded by the project's entry count,
@@ -3660,6 +3668,16 @@ class ValOps {
     this.modulesErrors = null;
     this.shaEntries = null;
     this.shaModuleErrors = null;
+    for (const [moduleFilePath, entries] of (options === null || options === void 0 ? void 0 : options.snapshotJsonEntries) ?? []) {
+      const adopted = new Map();
+      for (const [entryKey, content] of entries) {
+        adopted.set(entryKey, {
+          kind: "content",
+          content
+        });
+      }
+      this.adoptedJsonEntries.set(moduleFilePath, adopted);
+    }
   }
 
   // #region stat
@@ -3801,7 +3819,13 @@ class ValOps {
       }
       const adopted = this.adoptedJsonEntries.get(moduleFilePath) ?? new Map();
       for (const [entryKey, content] of Object.entries(entries)) {
-        adopted.set(entryKey, content);
+        // A commit's `null` is a deleted entry: see `patchedJsonEntries`.
+        adopted.set(entryKey, content === null ? {
+          kind: "deleted"
+        } : {
+          kind: "content",
+          content
+        });
       }
       this.adoptedJsonEntries.set(moduleFilePath, adopted);
     }
@@ -4035,6 +4059,7 @@ class ValOps {
       }
     }
     const loaded = await Promise.all([...requestedKeys, ...sourceKeys].map(async entryKey => {
+      var _this$adoptedJsonEntr, _this$siteSourcesBefo;
       const marker = record[entryKey];
       if (marker !== undefined && !core.Internal.isJson(marker)) {
         // Not a jsonValues entry — return the inlined value as-is (defensive).
@@ -4069,15 +4094,20 @@ class ValOps {
        * The BASELINE only. Pending patches replay over it below exactly as
        * they do over the thunk's answer.
        */
-      const adopted = this.adoptedJsonEntries.get(moduleFilePath);
-      if (adopted !== undefined && adopted.has(entryKey)) {
-        const content = adopted.get(entryKey);
+      const adopted = (_this$adoptedJsonEntr = this.adoptedJsonEntries.get(moduleFilePath)) === null || _this$adoptedJsonEntr === void 0 ? void 0 : _this$adoptedJsonEntr.get(entryKey);
+      if (adopted !== undefined) {
         return {
           entryKey,
-          baseContent: content === null ? undefined : content
+          baseContent: adopted.kind === "deleted" ? undefined : adopted.content
         };
       }
-      const thunk = core.Internal.getJsonImport(marker);
+      /*
+       * A snapshot's marker came as JSON, with no import behind it: the
+       * entry the proposal did not save is the build's, behind the marker
+       * the module evaluated to.
+       */
+      const siteMarker = (_this$siteSourcesBefo = this.siteSourcesBeforeSnapshot) === null || _this$siteSourcesBefo === void 0 || (_this$siteSourcesBefo = _this$siteSourcesBefo[moduleFilePath]) === null || _this$siteSourcesBefo === void 0 ? void 0 : _this$siteSourcesBefo[entryKey];
+      const thunk = core.Internal.getJsonImport(marker) ?? (core.Internal.isJson(siteMarker) ? core.Internal.getJsonImport(siteMarker) : undefined);
       if (!thunk) {
         return {
           entryKey,
@@ -8988,6 +9018,116 @@ function proposalSnapshot(proposal) {
   }
   return snapshot;
 }
+
+/**
+ * The `.jsonValues()` entries the proposal saved, by module and key.
+ *
+ * An entry's content is not in its module's Source -- that holds a marker per
+ * entry -- but in the entry's own `*.val.json`, and a save writes that file:
+ * it reaches the proposal's address as saved TEXT ({@link ValProposal.files}),
+ * not as Source. So the snapshot alone shows the build's entries. This is the
+ * other half: each saved `*.val.json`, read as the entry its module names.
+ *
+ * Which entry a file is comes from the module's `.val.ts`, whose
+ * `c.json(() => import("..."))` thunks name the files -- the saved text if
+ * the save rewrote it, else the build's own (`projectSource`). An entry whose
+ * module cannot be read that way is left to the build, as before: this adds
+ * what it can find and never fails the address.
+ */
+function proposalJsonEntries(proposal, projectSource) {
+  const found = new Map();
+  const savedJson = Object.keys(proposal.files).filter(path => path.endsWith(".val.json"));
+  if (savedJson.length === 0) return found;
+  const savedJsonPaths = new Set(savedJson);
+  for (const [moduleFilePath, source] of Object.entries(proposal.modules)) {
+    if (!holdsJsonMarkers(source)) continue;
+    const relative = moduleFilePath.replace(/^\//, "");
+    const text = proposal.files[relative] ?? (projectSource === null || projectSource === void 0 ? void 0 : projectSource[relative]);
+    if (text === undefined) continue;
+    const entries = jsonEntryPaths(relative, text);
+    if (entries === null) continue;
+    const byKey = new Map();
+    for (const [key, importPath] of entries) {
+      const jsonPath = resolveExistingJsonPath(moduleFilePath, importPath).replace(/^\//, "");
+      if (!savedJsonPaths.has(jsonPath)) continue;
+      const content = parseJson(proposal.files[jsonPath]);
+      if (content !== undefined) byKey.set(key, content);
+    }
+    if (byKey.size > 0) found.set(moduleFilePath, byKey);
+  }
+  return found;
+}
+
+/**
+ * The snapshot as a page reads it: {@link proposalSnapshot}, with each saved
+ * `.jsonValues()` entry's content in place of its marker -- the shape a draft
+ * already has, where the entries it edits hold content and the rest are
+ * markers the readers resolve from the build. See {@link proposalJsonEntries}.
+ *
+ * For the readers only. Val's own server keeps the markers
+ * ({@link proposalSnapshot}): its patching works on them, and it takes the
+ * saved entries separately.
+ */
+function proposalSnapshotForReaders(proposal, projectSource) {
+  const snapshot = proposalSnapshot(proposal);
+  for (const [moduleFilePath, entries] of proposalJsonEntries(proposal, projectSource)) {
+    const source = snapshot[moduleFilePath];
+    if (!isObject$1(source)) continue;
+    const filled = {};
+    for (const [key, value] of Object.entries(source)) {
+      if (isJsonValue(value)) filled[key] = value;
+    }
+    for (const [key, content] of entries) {
+      // Own keys only: an entry may be named `toString`.
+      if (Object.prototype.hasOwnProperty.call(filled, key)) {
+        filled[key] = content;
+      }
+    }
+    snapshot[moduleFilePath] = filled;
+  }
+  return snapshot;
+}
+
+/** A record of `.jsonValues()` markers (`{ _type: "json" }`), at least one. */
+function holdsJsonMarkers(source) {
+  return isObject$1(source) && Object.values(source).some(value => isObject$1(value) && value["_type"] === "json");
+}
+
+/** Each entry key's import path, from a `.jsonValues()` module's text. */
+function jsonEntryPaths(fileName, text) {
+  try {
+    const analysis = analyzeValModule(ts__default["default"].createSourceFile(fileName, text, ts__default["default"].ScriptTarget.ES2015, true));
+    if (fp.result.isErr(analysis)) return null;
+    const paths = new Map();
+    for (const [key, entry] of analyzeJsonValuesEntries(analysis.value.source)) {
+      paths.set(key, entry.importPath);
+    }
+    return paths;
+  } catch {
+    // Not a module this can read: its entries stay the build's.
+    return null;
+  }
+}
+function parseJson(text) {
+  if (text === undefined) return undefined;
+  try {
+    const value = JSON.parse(text);
+    return isMutableJsonValue(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** {@link isJsonValue}, for the mutable JSON a server patches. */
+function isMutableJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isMutableJsonValue);
+  }
+  return isObject$1(value) && Object.values(value).every(isMutableJsonValue);
+}
 function isObject$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -9432,7 +9572,8 @@ class ValOpsHttp extends ValOps {
   auth, valModules, options) {
     super(valModules, options !== null && options !== void 0 && options.proposal ? {
       ...options,
-      snapshotSources: proposalSnapshot(options.proposal)
+      snapshotSources: proposalSnapshot(options.proposal),
+      snapshotJsonEntries: proposalJsonEntries(options.proposal, options.projectSource)
     } : options);
     this.contentUrl = contentUrl;
     this.project = project;
@@ -20273,7 +20414,7 @@ function readFileOrUndefined$1(absolutePath) {
  * be uploaded first). On the way DOWN the same playlists are rewritten back to
  * relative names, which is what lets a published stream be plain static files.
  */
-function isRecord$2(value) {
+function isRecord$3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPlaylist$1(ref) {
@@ -20282,14 +20423,14 @@ function isPlaylist$1(ref) {
 
 /** The paths a video value holds, each with where in the value it sits. */
 function videoPathsOf(video) {
-  if (!isRecord$2(video) || typeof video.path !== "string") {
+  if (!isRecord$3(video) || typeof video.path !== "string") {
     return [];
   }
   const found = [{
     at: ["path"],
     path: video.path
   }];
-  if (isRecord$2(video.poster) && typeof video.poster.path === "string") {
+  if (isRecord$3(video.poster) && typeof video.poster.path === "string") {
     found.push({
       at: ["poster", "path"],
       path: video.poster.path
@@ -20297,7 +20438,7 @@ function videoPathsOf(video) {
   }
   if (Array.isArray(video.captions)) {
     video.captions.forEach((track, index) => {
-      if (isRecord$2(track) && typeof track.path === "string") {
+      if (isRecord$3(track) && typeof track.path === "string") {
         found.push({
           at: ["captions", String(index), "path"],
           path: track.path
@@ -20368,7 +20509,7 @@ function metadataOf(localRef, role, video) {
       height: video.height
     };
   }
-  if (role === "poster" && isRecord$2(video.poster)) {
+  if (role === "poster" && isRecord$3(video.poster)) {
     return {
       mimeType: video.poster.mimeType ?? mimeType,
       width: video.poster.width,
@@ -20384,7 +20525,7 @@ function metadataOf(localRef, role, video) {
  * Places a video's local files on Val Remote, each once, and remembers where.
  *
  * The one implementation of "upload a video" for every fix that does it: a
- * video field (`video:upload-remote`), and an entry of an `s.videoset()`
+ * video field (`video:upload-remote`), and an entry of an `s.videodir()`
  * (`videos:upload-remote`). What differs between the two is which files go up
  * and what their refs are hashed against, so those are the arguments.
  *
@@ -20477,7 +20618,7 @@ function resolveVideo(ctx) {
   }
   const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
   const video = resolved.source;
-  if (((_resolved$schema = resolved.schema) === null || _resolved$schema === void 0 ? void 0 : _resolved$schema.type) !== "video" || !isRecord$2(video) || typeof video.path !== "string") {
+  if (((_resolved$schema = resolved.schema) === null || _resolved$schema === void 0 ? void 0 : _resolved$schema.type) !== "video" || !isRecord$3(video) || typeof video.path !== "string") {
     return {
       success: false,
       result: {
@@ -20497,7 +20638,7 @@ function resolveVideo(ctx) {
  * The paths of a video FIELD that its fix moves.
  *
  * All of them for a video of its own. For a field picked from an
- * `s.videoset()` (`referencedModule`), only the poster and the captions: the
+ * `s.videodir()` (`referencedModule`), only the poster and the captions: the
  * video file is the set's — its key there — and moving it from here would
  * leave the field naming a file the set does not have. The set's own fix
  * (`videos:upload-remote`) moves it, and rewrites the fields that name it.
@@ -20670,6 +20811,192 @@ async function handleVideoDownloadRemote(ctx) {
   };
 }
 
+/**
+ * The fields that name an entry of a media collection by its key, and the
+ * patches that point them at a new key.
+ *
+ * A collection — `s.imagedir()`, `s.filedir()`, `s.videodir()` — is a record
+ * keyed by each entry's file path, and a field picked from it
+ * (`s.image(imagesVal)`, `s.file(filesVal)`, `s.video(videosVal)`) stores that
+ * key as its `path`. So when `--fix` renames a key — moving an entry of a
+ * `.remote()` collection to Val Remote renames it from the local path to the
+ * ref — every field holding the old key would name an entry the collection no
+ * longer has, and nothing could repair it afterwards.
+ *
+ * Two kinds of value name a key:
+ *
+ * - **A field whose schema is backed by the collection** (`referencedModule`).
+ * - **An inline image in rich text** whose `img` schema is backed by it
+ *   (`s.richtext({ img: s.image(imagesVal) })`). The field's own schema is
+ *   `richtext`, so a walk looking only for image leaves goes straight past
+ *   them — the Studio's reference scan learned that once already
+ *   (`getReferencedFiles`), and uses the same `forEachRichTextImage`.
+ *
+ * **A field is renamed when the key it names is the old key**, and "names" is
+ * `galleryKeyOf` in core: the field's `path` when that is a key, and otherwise
+ * the local path inside it when it is a ref. That is how a field is read
+ * (`fillFromGallery`) and how it is validated, so it is exactly the set of
+ * fields the rename would break. The second shape is real: an image uploaded
+ * THROUGH an `s.image(remoteGallery)` field in the Studio stores the ref in
+ * the field and keys the entry by the local path inside it, so uploading that
+ * entry here has to move the field to the entry's new key as well. A ref that
+ * is itself a key names its own entry, and is left alone.
+ *
+ * Nothing here imports `fixHandlers.ts` at runtime: that module calls this one.
+ */
+
+/** What of a `Service` the project-wide walk needs. */
+
+/** A value that names an entry of a collection by its key. */
+
+function isRecord$2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Whether a serialized schema is backed by `collection` anywhere in it. */
+function isBackedBy(schema, collection) {
+  if (Array.isArray(schema)) {
+    return schema.some(item => isBackedBy(item, collection));
+  }
+  if (!isRecord$2(schema)) {
+    return false;
+  }
+  if (schema.referencedModule === collection) {
+    return true;
+  }
+  return Object.values(schema).some(value => isBackedBy(value, collection));
+}
+
+/**
+ * The references already found, per service and collection.
+ *
+ * `val validate --fix` renames a key once per local entry, so a gallery of N
+ * local entries would otherwise walk the project N times — validating every
+ * module that uses the gallery each time. Caching per `Service` is exact, not
+ * an approximation: a `Service` answers `get` from the snapshot it was created
+ * with (`patch` writes to disk and changes nothing it returns), so the walk
+ * would find the same references every time. A new `Service` — the language
+ * server makes one after every edit — starts with nothing cached.
+ */
+const referencesByService = new WeakMap();
+
+/**
+ * Every value in the project that names an entry of `collection`, as the
+ * service's snapshot has it. Found once per service; see
+ * {@link referencesByService}.
+ */
+function collectionReferencesOf(service, collection) {
+  let byCollection = referencesByService.get(service);
+  if (!byCollection) {
+    byCollection = new Map();
+    referencesByService.set(service, byCollection);
+  }
+  let references = byCollection.get(collection);
+  if (!references) {
+    references = findCollectionReferences(service, collection);
+    // A walk that failed is not an answer; the next caller tries again.
+    references.catch(() => byCollection.delete(collection));
+    byCollection.set(collection, references);
+  }
+  return references;
+}
+
+/**
+ * The walk itself.
+ *
+ * Validated reads for the modules backed by the collection, because only
+ * those come back with their `.jsonValues()` entries loaded — an unvalidated
+ * read hands back each entry as a marker, and a field inside one would be
+ * invisible. Every other module is read once, unvalidated, to find out it is
+ * not one of them.
+ */
+async function findCollectionReferences(service, collection) {
+  const found = [];
+  for (const moduleFilePath of service.getModuleFilePaths()) {
+    const shallow = await service.get(moduleFilePath, "", {
+      validate: false
+    });
+    if (!isBackedBy(shallow.schema, collection)) {
+      continue;
+    }
+    const loaded = await service.get(moduleFilePath, "", {
+      validate: true
+    });
+    if (loaded.source === undefined || !loaded.schema) {
+      continue;
+    }
+    const add = (sourcePath, value) => {
+      if (isRecord$2(value) && typeof value.path === "string") {
+        found.push({
+          moduleFilePath,
+          sourcePath,
+          path: value.path
+        });
+      }
+    };
+    internal.traverseSchemaSource(loaded.source, loaded.schema, moduleFilePath, ({
+      source,
+      schema,
+      path: sourcePath
+    }) => {
+      if (schema.type === "image" || schema.type === "file" || schema.type === "video") {
+        if (schema.referencedModule === collection) {
+          add(sourcePath, source);
+        }
+      } else if (schema.type === "richtext") {
+        var _richTextImageSchema;
+        if (((_richTextImageSchema = internal.richTextImageSchema(schema)) === null || _richTextImageSchema === void 0 ? void 0 : _richTextImageSchema.referencedModule) === collection) {
+          internal.forEachRichTextImage(sourcePath, source, add);
+        }
+      }
+    });
+  }
+  return found;
+}
+
+/**
+ * The patch path of `sourcePath`. Not `sourceToPatchPath`: a collection's keys
+ * are file paths, and their dots do not survive its `split(".")`.
+ */
+function patchPathOf$1(sourcePath) {
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+  return core.Internal.splitModulePath(modulePath);
+}
+
+/**
+ * The patches that point every value naming a key in `renamed` at its new key.
+ *
+ * `renamed` is keyed by the collection's keys BEFORE the rename, and the
+ * collection is read as it is now — so call this before its own patch lands.
+ *
+ * One `add` on each value's `path`, so the alt text, hotspot, poster and
+ * captions beside it are never rewritten.
+ */
+async function collectionReferencePatches(service, collection, renamed) {
+  const collectionSource = (await service.get(collection, "", {
+    validate: false
+  })).source;
+  const keys = new Set(isRecord$2(collectionSource) ? Object.keys(collectionSource) : []);
+  const byModule = new Map();
+  for (const reference of await collectionReferencesOf(service, collection)) {
+    const key = core.Internal.media.galleryKeyOf(reference.path, candidate => keys.has(candidate));
+    if (key === null || !Object.prototype.hasOwnProperty.call(renamed, key)) {
+      continue;
+    }
+    const patch = byModule.get(reference.moduleFilePath) ?? [];
+    patch.push({
+      op: "add",
+      path: patchPathOf$1(reference.sourcePath).concat("path"),
+      value: renamed[key]
+    });
+    byModule.set(reference.moduleFilePath, patch);
+  }
+  return [...byModule].map(([moduleFilePath, patch]) => ({
+    moduleFilePath,
+    patch
+  }));
+}
+
 /**
  * What is out of step between a gallery's entries and its directory.
  *
@@ -20778,7 +21105,7 @@ function filesInDirectory({
 }
 
 /**
- * The fixes of an `s.videoset()` — the video twin of an image gallery.
+ * The fixes of an `s.videodir()` — the video twin of an image gallery.
  *
  * A set is a record keyed by each video's file path (an HLS stream by its
  * master playlist), so most of this is the gallery fixes again with the key as
@@ -21041,34 +21368,14 @@ async function filesNamedByVideoFields(service, options) {
 /**
  * The patches that point every `s.video(set)` field at a set entry's new key.
  *
- * One `add` on each field's `path`, so the description, poster, times and
- * captions beside it are never rewritten. A field of another set, or of no
- * set, is left alone even when its path is the same string: it names its own
- * file.
+ * The same walk an image or file collection's rename uses
+ * (`collectionReferencePatches`): one `add` on each field's `path`, so the
+ * description, poster, times and captions beside it are never rewritten, and
+ * a field of another set, or of no set, is left alone even when its path is
+ * the same string — it names its own file.
  */
 async function videosetReferencePatches(service, setModuleFilePath, renamed) {
-  const byModule = new Map();
-  for (const field of await videoFieldsOf(service)) {
-    if (field.schema.referencedModule !== setModuleFilePath) {
-      continue;
-    }
-    const value = field.source;
-    const current = isRecord$1(value) ? value.path : undefined;
-    if (typeof current !== "string" || !(current in renamed)) {
-      continue;
-    }
-    const patch = byModule.get(field.moduleFilePath) ?? [];
-    patch.push({
-      op: "add",
-      path: patchPathOf(field.sourcePath).concat("path"),
-      value: renamed[current]
-    });
-    byModule.set(field.moduleFilePath, patch);
-  }
-  return [...byModule].map(([moduleFilePath, patch]) => ({
-    moduleFilePath,
-    patch
-  }));
+  return collectionReferencePatches(service, setModuleFilePath, renamed);
 }
 
 /** The record at `sourcePath` and its entries, or why it could not be read. */
@@ -22652,13 +22959,13 @@ async function handleRemoteFileUpload(ctx) {
   return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
 }
 
-// Gallery (s.imageset({ ... }).remote() / s.fileset({ ... }).remote()) upload.
+// Gallery (s.imagedir(dir, { ... }).remote() / s.filedir(dir, { ... }).remote()) upload.
 // Unlike a single image/file field, a gallery entry is keyed by its local file
 // path and the value is bare metadata (no FileSource), so we derive the file
 // ref from the key and synthesize the image/file schema from the record's
 // media options.
 async function handleRemoteGalleryFileUpload(ctx) {
-  var _ctx$validationError$;
+  var _ctx$validationError$, _ctx$remoteFiles$ctx$;
   if (!ctx.fix) {
     return {
       success: false,
@@ -22696,7 +23003,7 @@ async function handleRemoteGalleryFileUpload(ctx) {
   // `accept`/`dir` come from the RECORD that holds the entry, resolved
   // from the entry's PARENT path - not from the module root, which is only the
   // record when the gallery is the whole module. A nested gallery
-  // (s.object({ gallery: s.imageset(...) })) would otherwise synthesize a schema
+  // (s.object({ gallery: s.imagedir(...) })) would otherwise synthesize a schema
   // with no options and bake a validation hash into the remote ref that can
   // never validate, so a mismatch fails fast instead of uploading.
   const [, parentModulePath] = core.Internal.splitModuleFilePathAndModulePath(core.Internal.parentOfSourcePath(ctx.sourcePath));
@@ -22731,7 +23038,24 @@ async function handleRemoteGalleryFileUpload(ctx) {
       } : {})
     }
   };
-  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+  const uploaded = await uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+  const ref = (_ctx$remoteFiles$ctx$ = ctx.remoteFiles[ctx.sourcePath]) === null || _ctx$remoteFiles$ctx$ === void 0 ? void 0 : _ctx$remoteFiles$ctx$.ref;
+  if (!uploaded.success || !uploaded.shouldApplyPatch || ref === undefined) {
+    return uploaded;
+  }
+  // `createFixPatch` renames the entry's key to the ref. Every field picked
+  // from the gallery that holds the old key — and every rich text image from
+  // it — would then name an image the gallery no longer has, so they are
+  // pointed at the ref in the same run, as `videos:upload-remote` does.
+  const otherModulePatches = await collectionReferencePatches(ctx.service, ctx.moduleFilePath, {
+    [fileRef]: ref
+  });
+  return {
+    ...uploaded,
+    ...(otherModulePatches.length > 0 ? {
+      otherModulePatches
+    } : {})
+  };
 }
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
@@ -22750,13 +23074,47 @@ async function handleRemoteFileDownload(ctx) {
     };
   }
 }
+
+/**
+ * `image:check-remote` / `file:check-remote`: core's "Remote image was not
+ * checked." — emitted for EVERY remote value of an `s.image().remote()` /
+ * `s.file().remote()`, wrong or not, because core cannot read the bytes or the
+ * ref's validation hash. It is a request to look, not a finding, so there is
+ * nothing to report here: `createFixPatch` does the looking (`checkRemoteRef`)
+ * and returns an error only for a ref that is actually wrong, with a fix where
+ * the ref only needs rewriting.
+ *
+ * So these stay a hand-off. Reporting core's message here instead would put an
+ * error on every remote image in a project, which is what the language server
+ * learned to stop doing (`mediaChecks.ts`).
+ */
 async function handleRemoteFileCheck() {
-  // Skip - no action needed
   return {
     success: true,
     shouldApplyPatch: true
   };
 }
+
+/**
+ * `images:check-remote` / `files:check-remote`: a gallery key that is wrong as
+ * a key — a remote URL in a gallery that is not `.remote()`, a ref that does
+ * not parse, one outside the gallery's directory (`validateMediaKey` in core).
+ *
+ * Unlike the singular codes, core emits these only when something IS wrong,
+ * and its message says what. There is nothing to look up and nothing to move,
+ * so it is reported as it is, for a person: only they know whether the key or
+ * the gallery's options are the mistake. It used to share the singular codes'
+ * handler, which hands off to `createFixPatch` — and that has no branch for a
+ * gallery key, so the error vanished and the module was reported valid.
+ *
+ * The same answer as `videos:check-remote`.
+ */
+async function handleGalleryCheckRemote(ctx) {
+  return {
+    success: false,
+    errorMessage: ctx.validationError.message
+  };
+}
 async function handleUniqueFolderCheck(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.dir !== "string") {
@@ -22951,9 +23309,9 @@ const currentFixHandlers = {
   "videos:check-unique-folder": handleUniqueFolderCheck,
   "videos:check-all-files": handleVideosetCheckAllFiles,
   "image:check-remote": handleRemoteFileCheck,
-  "images:check-remote": handleRemoteFileCheck,
+  "images:check-remote": handleGalleryCheckRemote,
   "file:check-remote": handleRemoteFileCheck,
-  "files:check-remote": handleRemoteFileCheck,
+  "files:check-remote": handleGalleryCheckRemote,
   "images:check-unique-folder": handleUniqueFolderCheck,
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,
@@ -23807,6 +24165,7 @@ exports.persistPersonalAccessToken = persistPersonalAccessToken;
 exports.planJsonValuesEntryExtraction = planJsonValuesEntryExtraction;
 exports.proposalFromEnv = proposalFromEnv;
 exports.proposalSnapshot = proposalSnapshot;
+exports.proposalSnapshotForReaders = proposalSnapshotForReaders;
 exports.readCapturedReport = readCapturedReport;
 exports.readPatchStore = readPatchStore;
 exports.rebaseContentOp = rebaseContentOp;