@valbuild/cli 0.98.0 → 0.99.0

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

@@ -100,32 +100,13 @@ async function handleFileMetadata(ctx) {
     shouldApplyPatch: true
   };
 }
-async function handleRemoteFileUpload(ctx) {
-  var _resolvedRemoteFileAt;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const filePath = path__default["default"].join(ctx.projectRoot, fileRefProp);
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(ctx, fileRef, metadata, schema) {
+  const filePath = path__default["default"].join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -165,21 +146,6 @@ async function handleRemoteFileUpload(ctx) {
       }]
     };
   }
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
-    };
-  }
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`
-    };
-  }
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -215,12 +181,6 @@ async function handleRemoteFileUpload(ctx) {
       errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
     };
   }
-  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
-    };
-  }
   remoteFilesCounter += 1;
   const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
   if (!bucket) {
@@ -246,8 +206,6 @@ async function handleRemoteFileUpload(ctx) {
   const fileHash = core.Internal.remote.getFileHash(fileBuffer);
   const coreVersion = core.Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = core.Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -267,7 +225,7 @@ async function handleRemoteFileUpload(ctx) {
   }
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata
+    metadata
   };
   return {
     success: true,
@@ -284,6 +242,131 @@ async function handleRemoteFileUpload(ctx) {
     }]
   };
 }
+async function handleRemoteFileUpload(ctx) {
+  var _resolvedRemoteFileAt;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+    };
+  }
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
+    };
+  }
+  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
+    };
+  }
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+  return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) 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$;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const fix = (_ctx$validationError$ = ctx.validationError.fixes) === null || _ctx$validationError$ === void 0 ? void 0 : _ctx$validationError$[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  const entrySource = resolved.source;
+  const metadata = entrySource && typeof entrySource === "object" && !Array.isArray(entrySource) ? entrySource : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` 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.images(...) })) 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));
+  const recordSchema = core.Internal.resolvePath(parentModulePath, ctx.valModule.source, ctx.valModule.schema).schema;
+  if ((recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${(recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) ?? "nothing"}`
+    };
+  }
+  const {
+    accept,
+    directory
+  } = recordSchema;
+  const schema = mediaType === "image" ? {
+    type: "image",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {}),
+      ...(directory ? {
+        directory
+      } : {})
+    }
+  } : {
+    type: "file",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {})
+    }
+  };
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
     return {
@@ -341,6 +424,17 @@ async function handleUniqueFolderCheck(ctx) {
     success: true
   };
 }
+
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key) {
+  const remoteRefRes = core.Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
 async function handleCheckAllFiles(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.directory !== "string") {
@@ -359,7 +453,10 @@ async function handleCheckAllFiles(ctx) {
       errorMessage: `Could not get source for ${ctx.sourcePath}`
     };
   }
-  const trackedFiles = new Set(Object.keys(source));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(Object.keys(source).map(remoteKeyToLocalPath));
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter(f => {
@@ -414,6 +511,8 @@ const currentFixHandlers = {
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,

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

@@ -100,32 +100,13 @@ async function handleFileMetadata(ctx) {
     shouldApplyPatch: true
   };
 }
-async function handleRemoteFileUpload(ctx) {
-  var _resolvedRemoteFileAt;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const filePath = path__default["default"].join(ctx.projectRoot, fileRefProp);
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(ctx, fileRef, metadata, schema) {
+  const filePath = path__default["default"].join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -165,21 +146,6 @@ async function handleRemoteFileUpload(ctx) {
       }]
     };
   }
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
-    };
-  }
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`
-    };
-  }
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -215,12 +181,6 @@ async function handleRemoteFileUpload(ctx) {
       errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
     };
   }
-  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
-    };
-  }
   remoteFilesCounter += 1;
   const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
   if (!bucket) {
@@ -246,8 +206,6 @@ async function handleRemoteFileUpload(ctx) {
   const fileHash = core.Internal.remote.getFileHash(fileBuffer);
   const coreVersion = core.Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = core.Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -267,7 +225,7 @@ async function handleRemoteFileUpload(ctx) {
   }
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata
+    metadata
   };
   return {
     success: true,
@@ -284,6 +242,131 @@ async function handleRemoteFileUpload(ctx) {
     }]
   };
 }
+async function handleRemoteFileUpload(ctx) {
+  var _resolvedRemoteFileAt;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+    };
+  }
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
+    };
+  }
+  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
+    };
+  }
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+  return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) 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$;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const fix = (_ctx$validationError$ = ctx.validationError.fixes) === null || _ctx$validationError$ === void 0 ? void 0 : _ctx$validationError$[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  const entrySource = resolved.source;
+  const metadata = entrySource && typeof entrySource === "object" && !Array.isArray(entrySource) ? entrySource : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` 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.images(...) })) 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));
+  const recordSchema = core.Internal.resolvePath(parentModulePath, ctx.valModule.source, ctx.valModule.schema).schema;
+  if ((recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${(recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) ?? "nothing"}`
+    };
+  }
+  const {
+    accept,
+    directory
+  } = recordSchema;
+  const schema = mediaType === "image" ? {
+    type: "image",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {}),
+      ...(directory ? {
+        directory
+      } : {})
+    }
+  } : {
+    type: "file",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {})
+    }
+  };
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
     return {
@@ -341,6 +424,17 @@ async function handleUniqueFolderCheck(ctx) {
     success: true
   };
 }
+
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key) {
+  const remoteRefRes = core.Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
 async function handleCheckAllFiles(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.directory !== "string") {
@@ -359,7 +453,10 @@ async function handleCheckAllFiles(ctx) {
       errorMessage: `Could not get source for ${ctx.sourcePath}`
     };
   }
-  const trackedFiles = new Set(Object.keys(source));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(Object.keys(source).map(remoteKeyToLocalPath));
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter(f => {
@@ -414,6 +511,8 @@ const currentFixHandlers = {
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,

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

@@ -68,32 +68,13 @@ async function handleFileMetadata(ctx) {
     shouldApplyPatch: true
   };
 }
-async function handleRemoteFileUpload(ctx) {
-  var _resolvedRemoteFileAt;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const filePath = path.join(ctx.projectRoot, fileRefProp);
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(ctx, fileRef, metadata, schema) {
+  const filePath = path.join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -133,21 +114,6 @@ async function handleRemoteFileUpload(ctx) {
       }]
     };
   }
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
-    };
-  }
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`
-    };
-  }
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -183,12 +149,6 @@ async function handleRemoteFileUpload(ctx) {
       errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
     };
   }
-  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
-    };
-  }
   remoteFilesCounter += 1;
   const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
   if (!bucket) {
@@ -214,8 +174,6 @@ async function handleRemoteFileUpload(ctx) {
   const fileHash = Internal.remote.getFileHash(fileBuffer);
   const coreVersion = Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -235,7 +193,7 @@ async function handleRemoteFileUpload(ctx) {
   }
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata
+    metadata
   };
   return {
     success: true,
@@ -252,6 +210,131 @@ async function handleRemoteFileUpload(ctx) {
     }]
   };
 }
+async function handleRemoteFileUpload(ctx) {
+  var _resolvedRemoteFileAt;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[FILE_REF_PROP];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+    };
+  }
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
+    };
+  }
+  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
+    };
+  }
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+  return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) 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$;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const fix = (_ctx$validationError$ = ctx.validationError.fixes) === null || _ctx$validationError$ === void 0 ? void 0 : _ctx$validationError$[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`
+    };
+  }
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolved = Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  const entrySource = resolved.source;
+  const metadata = entrySource && typeof entrySource === "object" && !Array.isArray(entrySource) ? entrySource : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` 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.images(...) })) 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] = Internal.splitModuleFilePathAndModulePath(Internal.parentOfSourcePath(ctx.sourcePath));
+  const recordSchema = Internal.resolvePath(parentModulePath, ctx.valModule.source, ctx.valModule.schema).schema;
+  if ((recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${(recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) ?? "nothing"}`
+    };
+  }
+  const {
+    accept,
+    directory
+  } = recordSchema;
+  const schema = mediaType === "image" ? {
+    type: "image",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {}),
+      ...(directory ? {
+        directory
+      } : {})
+    }
+  } : {
+    type: "file",
+    opt: false,
+    options: {
+      ...(accept ? {
+        accept
+      } : {})
+    }
+  };
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
     return {
@@ -309,6 +392,17 @@ async function handleUniqueFolderCheck(ctx) {
     success: true
   };
 }
+
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key) {
+  const remoteRefRes = Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
 async function handleCheckAllFiles(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.directory !== "string") {
@@ -327,7 +421,10 @@ async function handleCheckAllFiles(ctx) {
       errorMessage: `Could not get source for ${ctx.sourcePath}`
     };
   }
-  const trackedFiles = new Set(Object.keys(source));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(Object.keys(source).map(remoteKeyToLocalPath));
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter(f => {
@@ -382,6 +479,8 @@ const currentFixHandlers = {
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.98.0",
+  "version": "0.99.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -27,11 +27,11 @@
     "open": "^9.1.0",
     "picocolors": "^1.1.1",
     "zod": "^4.3.5",
-    "@valbuild/core": "0.97.7",
+    "@valbuild/core": "0.99.0",
     "@valbuild/eslint-plugin": "0.93.0",
-    "@valbuild/language-server": "0.98.0",
-    "@valbuild/server": "0.98.0",
-    "@valbuild/shared": "0.97.7"
+    "@valbuild/language-server": "0.99.0",
+    "@valbuild/server": "0.99.0",
+    "@valbuild/shared": "0.99.0"
   },
   "peerDependencies": {
     "prettier": "*",

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

@@ -0,0 +1,20 @@
+import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/basic-gallery-remote-existing.val.ts",
+  s.images({
+    directory: "/public/val/images-remote2",
+    accept: "image/*",
+    remote: true,
+  }),
+
+  {
+    "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc1/f/def4/p/public/val/images-remote2/image.png":
+      {
+        width: 1,
+        height: 1,
+        mimeType: "image/png",
+        alt: null,
+      },
+  },
+);

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

@@ -0,0 +1,19 @@
+import { c, s } from "../val.config";
+
+export default c.define(
+  "/content/basic-gallery-remote.val.ts",
+  s.images({
+    directory: "/public/val/images-remote",
+    accept: "image/*",
+    remote: true,
+  }),
+
+  {
+    "/public/val/images-remote/image.png": {
+      width: 1,
+      height: 1,
+      mimeType: "image/png",
+      alt: null,
+    },
+  },
+);

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

@@ -1,5 +1,7 @@
 import { initVal } from "@valbuild/core";
 
-const { s, c, config } = initVal();
+// NOTE: initVal() must be called with an options object for `config` to be
+// defined - the CLI requires val.config to export a config object.
+const { s, c, config } = initVal({});
 
 export { s, c, config };

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

@@ -13,4 +13,6 @@ export default modules(config, [
   { def: () => import("./content/basic-gallery-fail-on-non-unique-dir.val") },
   { def: () => import("./content/basic-gallery-missing-tracked.val") },
   { def: () => import("./content/basic-gallery-wrong-metadata.val") },
+  { def: () => import("./content/basic-gallery-remote.val") },
+  { def: () => import("./content/basic-gallery-remote-existing.val") },
 ]);

package/src/runValidation.test.ts

@@ -383,4 +383,105 @@ describe("runValidation", () => {
       service.dispose();
     }
   });
+
+  test("reports upload-remote error for local entry in a remote gallery", async () => {
+    const events: ValidationEvent[] = [];
+
+    for await (const event of runValidation({
+      root: tmpDir,
+      fix: false,
+      valFiles: ["content/basic-gallery-remote.val.ts"],
+      project: undefined,
+      remote: mockRemote,
+      fs: createDefaultValFSHost(),
+    })) {
+      events.push(event);
+    }
+
+    expect(events.at(-1)).toEqual({
+      type: "summary-errors",
+      count: expect.any(Number),
+    });
+    const errors = events.filter((e) => e.type === "validation-error");
+    expect(
+      errors.some(
+        (e) =>
+          "message" in e &&
+          (e.message as string).includes("needs to be uploaded"),
+      ),
+    ).toBe(true);
+  });
+
+  test("uploads local entry in a remote gallery and rewrites the key when fix is true", async () => {
+    const uploadRemote: IValRemote = {
+      remoteHost: DEFAULT_VAL_REMOTE_HOST,
+      getSettings: async () => ({
+        success: true,
+        data: {
+          publicProjectId: "pubproj",
+          remoteFileBuckets: [{ bucket: "01" }],
+        },
+      }),
+      uploadFile: async () => ({ success: true }),
+    };
+    // Upload requires a personal access token on disk.
+    fs.mkdirSync(path.join(tmpDir, ".val"), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, ".val", "pat.json"),
+      JSON.stringify({ pat: "test-pat" }),
+    );
+
+    const events: ValidationEvent[] = [];
+    for await (const event of runValidation({
+      root: tmpDir,
+      fix: true,
+      valFiles: ["content/basic-gallery-remote.val.ts"],
+      project: "test/project",
+      remote: uploadRemote,
+      fs: createDefaultValFSHost(),
+    })) {
+      events.push(event);
+    }
+
+    expect(events.some((e) => e.type === "remote-uploaded")).toBe(true);
+    expect(events.some((e) => e.type === "fix-applied")).toBe(true);
+
+    const service = await createService(tmpDir, createDefaultValFSHost());
+    try {
+      const result = await service.get(
+        "/content/basic-gallery-remote.val.ts" as ModuleFilePath,
+        "" as ModulePath,
+        { validate: false },
+      );
+      const source = result.source as Record<string, unknown>;
+      // The local-path key is replaced by a remote URL key (file kept on disk).
+      expect(source).not.toHaveProperty("/public/val/images-remote/image.png");
+      const keys = Object.keys(source);
+      expect(keys).toHaveLength(1);
+      expect(keys[0]).toContain("pubproj");
+      expect(keys[0]).toContain("public/val/images-remote/image.png");
+    } finally {
+      service.dispose();
+    }
+  });
+
+  test("does not flag a kept-on-disk file behind a remote gallery key", async () => {
+    const events: ValidationEvent[] = [];
+
+    for await (const event of runValidation({
+      root: tmpDir,
+      fix: false,
+      valFiles: ["content/basic-gallery-remote-existing.val.ts"],
+      project: undefined,
+      remote: mockRemote,
+      fs: createDefaultValFSHost(),
+    })) {
+      events.push(event);
+    }
+
+    // The file kept on disk under the remote URL key must not be reported as
+    // untracked, and the remote URL key must not be reported as missing.
+    expect(events.at(-1)).toEqual({ type: "summary-success" });
+    expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0);
+  });
 });

package/src/runValidation.ts

@@ -181,45 +181,17 @@ export async function handleFileMetadata(
   return { success: true, shouldApplyPatch: true };
 }
 
-export async function handleRemoteFileUpload(
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(
   ctx: FixHandlerContext,
+  fileRef: string,
+  metadata: Record<string, unknown> | undefined,
+  schema: SerializedImageSchema | SerializedFileSchema,
 ): Promise<FixHandlerResult> {
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`,
-    };
-  }
-
-  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
-    ctx.sourcePath,
-  );
-
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
-    };
-  }
-
-  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(
-    modulePath,
-    ctx.valModule.source,
-    ctx.valModule.schema,
-  );
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (resolvedRemoteFileAtSourcePath.source as any)?.[
-    FILE_REF_PROP
-  ];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`,
-    };
-  }
-
-  const filePath = path.join(ctx.projectRoot, fileRefProp);
+  const filePath = path.join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -259,26 +231,6 @@ export async function handleRemoteFileUpload(
     };
   }
 
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`,
-    };
-  }
-
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource)
-    ? actualRemoteFileSource.metadata
-    : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`,
-    };
-  }
-
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -317,16 +269,6 @@ export async function handleRemoteFileUpload(
     };
   }
 
-  if (
-    resolveRemoteFileSchema.type !== "image" &&
-    resolveRemoteFileSchema.type !== "file"
-  ) {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`,
-    };
-  }
-
   remoteFilesCounter += 1;
   const bucket =
     remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
@@ -361,10 +303,6 @@ export async function handleRemoteFileUpload(
   const fileHash = Internal.remote.getFileHash(fileBuffer);
   const coreVersion = Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema as
-    | SerializedImageSchema
-    | SerializedFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -399,7 +337,7 @@ export async function handleRemoteFileUpload(
 
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata,
+    metadata,
   };
 
   return {
@@ -415,6 +353,177 @@ export async function handleRemoteFileUpload(
   };
 }
 
+export async function handleRemoteFileUpload(
+  ctx: FixHandlerContext,
+): Promise<FixHandlerResult> {
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`,
+    };
+  }
+
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
+    ctx.sourcePath,
+  );
+
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
+    };
+  }
+
+  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(
+    modulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  );
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (resolvedRemoteFileAtSourcePath.source as any)?.[
+    FILE_REF_PROP
+  ];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`,
+    };
+  }
+
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`,
+    };
+  }
+
+  if (
+    resolveRemoteFileSchema.type !== "image" &&
+    resolveRemoteFileSchema.type !== "file"
+  ) {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`,
+    };
+  }
+
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource)
+    ? actualRemoteFileSource.metadata
+    : undefined;
+
+  return uploadRemoteFileCore(
+    ctx,
+    fileRefProp,
+    fileSourceMetadata,
+    resolveRemoteFileSchema,
+  );
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) 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.
+export async function handleRemoteGalleryFileUpload(
+  ctx: FixHandlerContext,
+): Promise<FixHandlerResult> {
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`,
+    };
+  }
+
+  const fix = ctx.validationError.fixes?.[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`,
+    };
+  }
+
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
+    ctx.sourcePath,
+  );
+
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
+    };
+  }
+
+  const resolved = Internal.resolvePath(
+    modulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  );
+  const entrySource = resolved.source;
+  const metadata =
+    entrySource &&
+    typeof entrySource === "object" &&
+    !Array.isArray(entrySource)
+      ? (entrySource as Record<string, unknown>)
+      : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` 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.images(...) })) 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] = Internal.splitModuleFilePathAndModulePath(
+    Internal.parentOfSourcePath(ctx.sourcePath),
+  );
+  const recordSchema = Internal.resolvePath(
+    parentModulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  ).schema;
+  if (recordSchema?.type !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${
+        recordSchema?.type ?? "nothing"
+      }`,
+    };
+  }
+  const { accept, directory } = recordSchema;
+  const schema: SerializedImageSchema | SerializedFileSchema =
+    mediaType === "image"
+      ? {
+          type: "image",
+          opt: false,
+          options: {
+            ...(accept ? { accept } : {}),
+            ...(directory ? { directory } : {}),
+          },
+        }
+      : {
+          type: "file",
+          opt: false,
+          options: {
+            ...(accept ? { accept } : {}),
+          },
+        };
+
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
+
 export async function handleRemoteFileDownload(
   ctx: FixHandlerContext,
 ): Promise<FixHandlerResult> {
@@ -479,6 +588,17 @@ export async function handleUniqueFolderCheck(
   return { success: true };
 }
 
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key: string): string {
+  const remoteRefRes = Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
+
 export async function handleCheckAllFiles(
   ctx: FixHandlerContext,
 ): Promise<FixHandlerResult> {
@@ -500,7 +620,12 @@ export async function handleCheckAllFiles(
       errorMessage: `Could not get source for ${ctx.sourcePath}`,
     };
   }
-  const trackedFiles = new Set(Object.keys(source as Record<string, unknown>));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(
+    Object.keys(source as Record<string, unknown>).map(remoteKeyToLocalPath),
+  );
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter((f) => {
@@ -558,6 +683,8 @@ export const currentFixHandlers: Record<
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,