@valbuild/core 0.139.1 → 0.141.0

package/dist/{index-eb9f6480.esm.js → index-a6c53286.esm.js}

@@ -2752,6 +2752,28 @@ var discriminatedUnion = function discriminatedUnion(key) {
   return new DiscriminatedUnionSchema(key, objects);
 };
 
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+
 var RegEx$1 = /^(https?:\/\/[^/]+)\/file\/p\/([^/]+)\/b\/([^/]+)\/v\/([^/]+)\/h\/([^/]+)\/f\/([^/]+)\/p\/(.+)$/;
 function splitRemoteRef(ref) {
   if (ref[0] === "/") {
@@ -2793,6 +2815,8 @@ function splitRemoteRef(ref) {
   };
 }
 
+var _excluded = ["poster", "captions"];
+
 /** What must stay in frame when a page crops an image. */
 
 /**
@@ -2801,6 +2825,76 @@ function splitRemoteRef(ref) {
  * here. One place per fact.
  */
 
+/**
+ * The still shown before a video plays — `<video poster>`.
+ *
+ * Derived, like a video's `width` and `height`: the Studio grabs the frame at
+ * {@link VideoSource.posterTime} and uploads it as an image, so a page can show
+ * it without decoding the video. It is a media object of its own (a `path`,
+ * and a `patch_id` while unpublished) because it is a file of its own.
+ */
+
+/**
+ * One text track of a video — `<track src srclang label kind default>`.
+ *
+ * `path` is a WebVTT file, uploaded like any other file.
+ */
+
+/**
+ * What a video FIELD authors, on top of the file it names: the description,
+ * the crop, the poster, the trim and the caption tracks.
+ *
+ * This is the whole value of a field picked from an `s.videoset()`
+ * (`s.video(videosetVal)`) — the mime type, size and length live in the set,
+ * keyed by `path`, and repeating them here is how two copies of one fact get
+ * to disagree. The poster, captions and times stay with the FIELD: one video
+ * used in two places can be trimmed and captioned differently in each.
+ *
+ * Times are in seconds from the start of the file.
+ */
+
+/**
+ * What one page chooses about a video — as opposed to what is true of the
+ * file. A field (`s.video()`) carries these for itself; the entry of a set
+ * (`s.videoset()`) carries them as DEFAULTS, which every field picked from the
+ * set starts from and may override key by key. See {@link fillFromGallery}.
+ */
+
+/**
+ * A video: a progressive file (`video/mp4`, `video/webm`) or an HLS stream
+ * (`application/vnd.apple.mpegurl`, whose `path` is the master playlist).
+ *
+ * `mimeType` is REQUIRED on a video of its own: a page has to know which of
+ * the two it is holding before it can play it at all — an `.m3u8` handed to a
+ * `<video src>` plays only in Safari. (What tells a video's TYPE apart from an
+ * image's is its declared keys, see {@link IsVideoSource}, because a field
+ * picked from a set has no `mimeType` of its own.)
+ *
+ * `width`, `height`, `duration` and `mimeType` are read from the bytes;
+ * everything else is authored.
+ */
+
+/**
+ * Whether a source TYPE is a video's.
+ *
+ * Every media source is "a `path` plus optional fields", so assignability
+ * cannot tell an image from a video: an image is assignable to a set-backed
+ * video and the other way round. The keys a type DECLARES can — only a video
+ * declares `posterTime` — so the readers' conditional types ask this before
+ * they ask about images.
+ */
+
+/** The mime type of an HLS master playlist. */
+var HLS_MIME_TYPE = "application/vnd.apple.mpegurl";
+
+/** Whether a video is an HLS stream rather than a single progressive file. */
+function isHlsVideo(src) {
+  if (src.mimeType !== undefined) {
+    return src.mimeType === HLS_MIME_TYPE || src.mimeType.toLowerCase() === "application/x-mpegurl";
+  }
+  return src.path.split("?")[0].toLowerCase().endsWith(".m3u8");
+}
+
 /**
  * The structural supertype of every media source.
  *
@@ -2854,66 +2948,181 @@ function resolveMedia(src) {
     url: mediaUrl(src)
   });
 }
+
+/**
+ * A video as a reader sees it: every file it names — the video itself, its
+ * poster and each caption track — carries the URL its bytes are served from.
+ *
+ * Each gets its own {@link mediaUrl} because each is its own file with its own
+ * `patch_id`: replacing only the poster drafts the poster, and the video keeps
+ * its published URL.
+ */
+
+/**
+ * The single implementation of {@link ResolvedVideo}. `url` is passed in as a
+ * function so the reader can tag the video's own URL (stega) without tagging
+ * the poster's and the captions', which are not where an edit lands.
+ */
+function resolveVideo(src) {
+  var videoUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mediaUrl;
+  var poster = src.poster,
+    captions = src.captions,
+    rest = _objectWithoutProperties(src, _excluded);
+  var resolved = _objectSpread2(_objectSpread2({}, rest), {}, {
+    url: videoUrl(src)
+  });
+  if (poster && _typeof(poster) === "object" && typeof poster.path === "string") {
+    return withCaptions(_objectSpread2(_objectSpread2({}, resolved), {}, {
+      poster: _objectSpread2(_objectSpread2({}, poster), {}, {
+        url: mediaUrl(poster)
+      })
+    }), captions);
+  }
+  return withCaptions(resolved, captions);
+}
+function withCaptions(resolved, captions) {
+  if (!Array.isArray(captions)) {
+    return resolved;
+  }
+  return _objectSpread2(_objectSpread2({}, resolved), {}, {
+    captions: captions.filter(function (track) {
+      return !!track && _typeof(track) === "object" && typeof track.path === "string";
+    }).map(function (track) {
+      return _objectSpread2(_objectSpread2({}, track), {}, {
+        url: mediaUrl(track)
+      });
+    })
+  });
+}
 function isMediaSchema(schema) {
-  return _typeof(schema) === "object" && schema !== null && "type" in schema && (schema.type === "image" || schema.type === "file");
+  return _typeof(schema) === "object" && schema !== null && "type" in schema && (schema.type === "image" || schema.type === "file" || schema.type === "video");
 }
 
 /**
- * Fill in what a gallery-backed field does not carry itself.
- *
- * `s.image(galleryModule)` stores only `{path, alt?, hotspot?}` — the
- * dimensions and mime type live in the gallery module, keyed by path. This is
- * the single implementation of that lookup; core, stega/RSC and the Studio all
- * call it rather than each rolling their own.
+ * What a gallery entry holds as a DEFAULT for the fields picked from it, in
+ * the groups a field overrides together.
  *
- * `alt` is filled in too, because a gallery holds the alt text an editor typed
- * once for a file used in several places — but only when the field does not
- * have its own, so a per-image override wins. A gallery whose `alt` schema is a
- * locale record holds an object rather than a string; that is left alone rather
- * than copied into a field typed `string`, and making the override
- * locale-shaped is a separate change.
+ * Per key, not per value: a field that has set its own `startTime` still
+ * takes the gallery's `endTime`. The poster is the one pair — `poster` is the
+ * frame at `posterTime`, so a field with either has chosen its own still, and
+ * taking the other half from the gallery would describe a frame nobody chose.
+ */
+var GALLERY_DEFAULT_GROUPS = [["alt"], ["hotspot"], ["poster", "posterTime"], ["startTime"], ["endTime"], ["captions"]];
+
+/** What is true of the file, and the gallery's alone. */
+var GALLERY_FILE_FACTS = ["width", "height", "mimeType", "duration"];
+
+/**
+ * The gallery entry a gallery-backed value names, or `null` when it is not
+ * gallery-backed or the gallery has no such entry.
  *
  * The double lookup is load-bearing: a remote gallery keys its entries by the
  * remote URL while the file itself stays on disk under its local path.
  */
-function fillFromGallery(src, schema, getModuleSource) {
+function galleryEntryOf(src, schema, getModuleSource) {
   if (!isMediaSchema(schema) || !schema.referencedModule) {
-    return src;
+    return null;
   }
   var moduleSource = getModuleSource(schema.referencedModule);
-  if (!moduleSource || _typeof(moduleSource) !== "object" || Array.isArray(moduleSource)) {
-    return src;
+  if (!isPlainObject(moduleSource)) {
+    return null;
   }
-  var entries = moduleSource;
-  var key = src.path in entries ? src.path : null;
+  var key = src.path in moduleSource ? src.path : null;
   if (key === null) {
     var splitRemoteRefRes = splitRemoteRef(src.path);
-    if (splitRemoteRefRes.status === "success" && splitRemoteRefRes.filePath in entries) {
+    if (splitRemoteRefRes.status === "success" && splitRemoteRefRes.filePath in moduleSource) {
       key = splitRemoteRefRes.filePath;
     }
   }
   if (key === null) {
-    return src;
+    return null;
   }
-  var entry = entries[key];
-  if (!entry || _typeof(entry) !== "object" || Array.isArray(entry)) {
+  var entry = moduleSource[key];
+  return isPlainObject(entry) ? entry : null;
+}
+
+/**
+ * The value a gallery-backed field means: its own keys, and the gallery's
+ * where it has none.
+ *
+ * `s.image(galleryModule)` and `s.video(videosModule)` store only what one
+ * page chose — the rest lives in the gallery, keyed by path. Two things come
+ * from there:
+ *
+ * - **What is true of the file** — dimensions, mime type, length. The field
+ *   never has these, so they are always the gallery's.
+ * - **The defaults** — description, focal point, a video's poster, start, end
+ *   and captions ({@link GALLERY_DEFAULT_GROUPS}). An editor sets them once
+ *   on the gallery entry; a field that sets its own wins, KEY BY KEY.
+ *
+ * The single implementation of that merge: core, stega/RSC and the Studio all
+ * call it rather than each rolling their own, so a page and the Studio's
+ * preview of it cannot disagree about which poster a video has.
+ *
+ * A gallery whose `alt` schema is a locale record holds an object rather than
+ * a string; that is left alone rather than copied into a field typed
+ * `string`, and making the override locale-shaped is a separate change.
+ */
+function fillFromGallery(src, schema, getModuleSource) {
+  var entry = galleryEntryOf(src, schema, getModuleSource);
+  if (entry === null) {
     return src;
   }
-  var _ref = entry,
-    width = _ref.width,
-    height = _ref.height,
-    mimeType = _ref.mimeType,
-    alt = _ref.alt;
-  var hasOwnAlt = typeof src.alt === "string";
-  return _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, src), width !== undefined ? {
-    width: width
-  } : {}), height !== undefined ? {
-    height: height
-  } : {}), mimeType !== undefined ? {
-    mimeType: mimeType
-  } : {}), !hasOwnAlt && typeof alt === "string" ? {
-    alt: alt
-  } : {});
+  var own = _objectSpread2({}, src);
+  var filled = {};
+  var _iterator = _createForOfIteratorHelper(GALLERY_FILE_FACTS),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      if (entry[key] !== undefined) {
+        filled[key] = entry[key];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = _createForOfIteratorHelper(GALLERY_DEFAULT_GROUPS),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var group = _step2.value;
+      if (group.some(function (key) {
+        return own[key] !== undefined;
+      })) {
+        continue;
+      }
+      var _iterator3 = _createForOfIteratorHelper(group),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _key = _step3.value;
+          var value = entry[_key];
+          if (value === undefined || value === null) {
+            continue;
+          }
+          if (_key === "alt" && typeof value !== "string") {
+            continue;
+          }
+          filled[_key] = value;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return _objectSpread2(_objectSpread2({}, src), filled);
+}
+function isPlainObject(value) {
+  return _typeof(value) === "object" && value !== null && !Array.isArray(value);
 }
 
 var EXT_TO_MIME_TYPES = {
@@ -3444,6 +3653,8 @@ var EXT_TO_MIME_TYPES = {
   qam: "application/vnd.epson.quickanime",
   qfx: "application/vnd.intu.qfx",
   mov: "video/quicktime",
+  vtt: "text/vtt",
+  mkv: "video/x-matroska",
   rar: "application/x-rar-compressed",
   ram: "audio/x-pn-realaudio",
   rmp: "audio/x-pn-realaudio-plugin",
@@ -4095,6 +4306,19 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
 /** An image of its own, carrying its own dimensions and mime type. */
 
 function image(options, galleryOptions) {
+  return imageOf(false, options, galleryOptions);
+}
+
+/**
+ * `s.image()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): the same schema, with `.remote()` already applied. See
+ * `initSchema`.
+ */
+
+function remoteImage(options, galleryOptions) {
+  return imageOf(true, options, galleryOptions);
+}
+function imageOf(remote, options, galleryOptions) {
   var isModule = !!options && !!Internal.getValPath(options);
   if (isModule) {
     var allModules = {};
@@ -4108,9 +4332,9 @@ function image(options, galleryOptions) {
     }
     return new ImageSchema((galleryOptions === null || galleryOptions === void 0 ? void 0 : galleryOptions.encode) !== undefined ? {
       encode: galleryOptions.encode
-    } : {}, false, false, [], allModules);
+    } : {}, false, remote, [], allModules);
   }
-  return new ImageSchema(options);
+  return new ImageSchema(options, false, remote);
 }
 
 var RouteSchema = /*#__PURE__*/function (_Schema) {
@@ -4369,6 +4593,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     var isHidden = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
     var description = arguments.length > 5 ? arguments[5] : undefined;
     var previewInput = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+    var imgRemote = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
     _classCallCheck(this, RichTextSchema);
     _this = _callSuper(this, RichTextSchema);
     _this.options = options;
@@ -4378,6 +4603,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     _this.isHidden = isHidden;
     _this.description = description;
     _this.previewInput = previewInput;
+    _this.imgRemote = imgRemote;
     return _this;
   }
 
@@ -4404,7 +4630,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
   return _createClass(RichTextSchema, [{
     key: "describe",
     value: function describe(description) {
-      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.previewInput);
+      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.previewInput, this.imgRemote);
     }
 
     /**
@@ -4424,7 +4650,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     value: function maxLength(max) {
       return new RichTextSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         maxLength: max
-      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.imgRemote);
     }
 
     /**
@@ -4444,7 +4670,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     value: function minLength(min) {
       return new RichTextSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         minLength: min
-      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.imgRemote);
     }
 
     /**
@@ -4472,7 +4698,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "validate",
     value: function validate(validationFunction) {
-      return new RichTextSchema(this.options, this.opt, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description, this.previewInput);
+      return new RichTextSchema(this.options, this.opt, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description, this.previewInput, this.imgRemote);
     }
   }, {
     key: "executeValidate",
@@ -4647,7 +4873,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
                   }
                   var srcPath = unsafeCreateSourcePath(path, "src");
                   var imgSchema = _this2.options.img;
-                  var imageValidationErrors = _typeof(imgSchema) === "object" ? imgSchema["executeValidate"](srcPath, node.src) : new ImageSchema({}, false, false)["executeValidate"](srcPath, node.src);
+                  var imageValidationErrors = _typeof(imgSchema) === "object" ? imgSchema["executeValidate"](srcPath, node.src) : new ImageSchema({}, false, _this2.imgRemote)["executeValidate"](srcPath, node.src);
                   if (imageValidationErrors) {
                     for (var _validationErrorPathS in imageValidationErrors) {
                       var _current$_validationE;
@@ -4916,19 +5142,19 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new RichTextSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      return new RichTextSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.imgRemote);
     }
   }, {
     key: "readonly",
     value: function readonly() {
       var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, isReadonly, this.isHidden, this.description, this.previewInput);
+      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, isReadonly, this.isHidden, this.description, this.previewInput, this.imgRemote);
     }
   }, {
     key: "hidden",
     value: function hidden() {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.previewInput);
+      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.previewInput, this.imgRemote);
     }
   }, {
     key: "executeCustomValidateAt",
@@ -4956,7 +5182,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "preview",
     value: function preview(select) {
-      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, select);
+      return new RichTextSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, select, this.imgRemote);
     }
   }, {
     key: "executePreviewItem",
@@ -5002,7 +5228,10 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
         ul: this.options.ul,
         ol: this.options.ol,
         a: serializeAnchorSchema(),
-        img: this.options.img && _typeof(this.options.img) === "object" ? this.options.img["executeSerialize"]() : this.options.img
+        img: this.options.img && _typeof(this.options.img) === "object" ? this.options.img["executeSerialize"]() :
+        // The Studio decides local or remote by the serialized image
+        // schema, and `true` carries no such answer.
+        this.options.img && this.imgRemote ? new ImageSchema(undefined, false, true)["executeSerialize"]() : this.options.img
       };
       return {
         type: "richtext",
@@ -5021,6 +5250,14 @@ var richtext = function richtext(options) {
   return new RichTextSchema(options !== null && options !== void 0 ? options : {});
 };
 
+/**
+ * `s.richtext()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): `img: true` is a remote image. See `initSchema`.
+ */
+var remoteRichtext = function remoteRichtext(options) {
+  return new RichTextSchema(options !== null && options !== void 0 ? options : {}, false, [], false, false, undefined, null, true);
+};
+
 function _regeneratorDefine(e, r, n, t) {
   var i = Object.defineProperty;
   try {
@@ -5469,6 +5706,207 @@ function missingDeclaredKeys(declared, present) {
   });
 }
 
+/**
+ * The checks of what one page chose about a video — its times, focal point,
+ * poster and captions — shared by the two places those choices are made: a
+ * field (`s.video()`) and the entry of a set (`s.videoset()`), which holds the
+ * same choices as the defaults every field picked from it starts from.
+ */
+
+function isRecord(value) {
+  return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+function stripQuery$1(path) {
+  return path.split("?")[0];
+}
+
+/**
+ * What is checked, typed as what it IS rather than what it should be: a
+ * field's value and a set's entry both reach here from hand-written JSON
+ * that never saw the type.
+ */
+
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function validateTimes(src, duration) {
+  var errors = [];
+  var _iterator = _createForOfIteratorHelper(["posterTime", "startTime", "endTime"]),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      var value = src[key];
+      if (value === undefined) {
+        continue;
+      }
+      if (!isNonNegativeNumber(value)) {
+        errors.push({
+          message: "'".concat(key, "' must be a number of seconds, 0 or more. Got: ").concat(JSON.stringify(value)),
+          value: src
+        });
+      } else if (duration !== undefined && value > duration) {
+        errors.push({
+          message: "'".concat(key, "' (").concat(value, "s) is after the end of the video (").concat(duration, "s)."),
+          value: src
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var startTime = src.startTime,
+    endTime = src.endTime;
+  if (isNonNegativeNumber(startTime) && isNonNegativeNumber(endTime) && startTime >= endTime) {
+    errors.push({
+      message: "'startTime' (".concat(startTime, "s) must be before 'endTime' (").concat(endTime, "s)."),
+      value: src
+    });
+  }
+  return errors;
+}
+function validateHotspot(src) {
+  if (src.hotspot === undefined) {
+    return [];
+  }
+  var hotspot = src.hotspot;
+  if (!isRecord(hotspot) || typeof hotspot.x !== "number" || typeof hotspot.y !== "number" || hotspot.x < 0 || hotspot.x > 1 || hotspot.y < 0 || hotspot.y > 1) {
+    return [{
+      message: "'hotspot' must be { x, y } with both between 0 and 1.",
+      value: src
+    }];
+  }
+  return [];
+}
+function validatePoster(src) {
+  if (src.poster === undefined) {
+    return [];
+  }
+  var poster = src.poster;
+  if (!isRecord(poster) || typeof poster.path !== "string") {
+    return [{
+      message: "'poster' must be an image object with a 'path'.",
+      value: src
+    }];
+  }
+  var mimeType = filenameToMimeType(stripQuery$1(poster.path));
+  if (!mimeType || !mimeType.startsWith("image/")) {
+    return [{
+      message: "The poster must be an image. Got: ".concat(poster.path),
+      value: src
+    }];
+  }
+  return [];
+}
+var CAPTION_KINDS = ["subtitles", "captions"];
+function validateCaptions(src) {
+  if (src.captions === undefined) {
+    return [];
+  }
+  if (!Array.isArray(src.captions)) {
+    return [{
+      message: "'captions' must be an array.",
+      value: src
+    }];
+  }
+  var errors = [];
+  var defaults = 0;
+  var seen = new Set();
+  src.captions.forEach(function (track, i) {
+    var at = "Caption track ".concat(i + 1);
+    if (!isRecord(track)) {
+      errors.push({
+        message: "".concat(at, " must be an object."),
+        value: src
+      });
+      return;
+    }
+    var t = track;
+    if (typeof t.path !== "string") {
+      errors.push({
+        message: "".concat(at, " has no 'path'."),
+        value: src
+      });
+    } else if (filenameToMimeType(stripQuery$1(t.path)) !== "text/vtt") {
+      errors.push({
+        message: "".concat(at, " must be a WebVTT (.vtt) file. Got: ").concat(t.path),
+        value: src
+      });
+    }
+    if (typeof t.srclang !== "string" || t.srclang.trim() === "") {
+      errors.push({
+        message: "".concat(at, " needs a language ('srclang'), e.g. \"en\"."),
+        value: src
+      });
+    }
+    if (t.label !== undefined && typeof t.label !== "string") {
+      errors.push({
+        message: "".concat(at, ": 'label' must be a string."),
+        value: src
+      });
+    }
+    if (t.kind !== undefined && (typeof t.kind !== "string" || !CAPTION_KINDS.includes(t.kind))) {
+      errors.push({
+        message: "".concat(at, ": 'kind' must be \"subtitles\" or \"captions\"."),
+        value: src
+      });
+    }
+    if (t["default"] !== undefined && typeof t["default"] !== "boolean") {
+      errors.push({
+        message: "".concat(at, ": 'default' must be true or false."),
+        value: src
+      });
+    }
+    if (t["default"] === true) {
+      defaults++;
+    }
+    if (typeof t.srclang === "string") {
+      var _t$kind;
+      var key = "".concat((_t$kind = t.kind) !== null && _t$kind !== void 0 ? _t$kind : "subtitles", ":").concat(t.srclang);
+      if (seen.has(key)) {
+        errors.push({
+          message: "".concat(at, " repeats the language '").concat(t.srclang, "'."),
+          value: src
+        });
+      }
+      seen.add(key);
+    }
+  });
+  if (defaults > 1) {
+    errors.push({
+      message: "At most one caption track can be the default. ".concat(defaults, " are."),
+      value: src
+    });
+  }
+  return errors;
+}
+
+function isObject(value) {
+  return _typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+
+/** What a media collection (`s.imageset`, `s.fileset`, `s.videoset`) holds. */
+
+/**
+ * The fix code a media collection of `type` reports for `check`.
+ *
+ * One function rather than a ternary at each site: there were two kinds of
+ * collection when every site was written as `type === "images" ? … : …`, and
+ * a third kind silently took the files branch.
+ */
+function mediaCollectionFix(type, check) {
+  return "".concat(type, ":").concat(check);
+}
+
+/** The singular a message uses for one entry of a collection of `type`. */
+var MEDIA_ENTRY_LABEL = {
+  files: "file",
+  images: "image",
+  videos: "video"
+};
+
 /**
  * `.render(...)` is for records whose entries the generic record editor draws.
  * A router's entries are pages and a gallery's are media, and both have UIs of
@@ -5660,7 +6098,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
         _iterator.f();
       }
       if (this.mediaOptions) {
-        var checkFix = this.mediaOptions.type === "images" ? "images:check-unique-folder" : "files:check-unique-folder";
+        var checkFix = mediaCollectionFix(this.mediaOptions.type, "check-unique-folder");
         var uniqueCheckError = {
           message: "Gallery directory '".concat(this.mediaOptions.dir, "' must be unique across all galleries"),
           value: {
@@ -5678,7 +6116,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
         } else {
           error = _defineProperty({}, path, [uniqueCheckError]);
         }
-        var allFilesCheckFix = this.mediaOptions.type === "images" ? "images:check-all-files" : "files:check-all-files";
+        var allFilesCheckFix = mediaCollectionFix(this.mediaOptions.type, "check-all-files");
         var allFilesCheckError = {
           message: "Directory '".concat(this.mediaOptions.dir, "' may have files not tracked by this gallery"),
           value: {
@@ -5732,7 +6170,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
             _this2.markKeyErrorsAtPath(keyErr, subPath);
           }
           error = _this2.mergeValidationErrors(error, keyErr);
-          var entryErr = _this2.validateMediaEntry(subPath, elem);
+          var entryErr = _this2.validateMediaEntry(subPath, key, elem);
           if (entryErr) {
             _this2.markKeyErrorsAtPath(entryErr, subPath);
           }
@@ -5846,8 +6284,8 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
         dir = _this$mediaOptions.dir,
         isRemote = _this$mediaOptions.remote,
         type = _this$mediaOptions.type;
-      var mediaLabel = type === "images" ? "images" : "files";
-      var checkRemoteFix = type === "images" ? "images:check-remote" : "files:check-remote";
+      var mediaLabel = type;
+      var checkRemoteFix = mediaCollectionFix(type, "check-remote");
       var isRemoteUrl = this.isRemoteUrl(key);
       var isLocalPath = key === dir || key.startsWith(dir + "/");
       if (isRemote) {
@@ -5880,9 +6318,9 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           }]);
         }
         // Local path in a remote gallery: needs to be uploaded to remote.
-        var uploadRemoteFix = type === "images" ? "images:upload-remote" : "files:upload-remote";
+        var uploadRemoteFix = mediaCollectionFix(type, "upload-remote");
         return _defineProperty({}, path, [{
-          message: "Expected a remote ".concat(type === "images" ? "image" : "file", ", but got a local path. Use Val tooling (CLI --fix, VS Code extension, or Val Studio) to upload it. Got: ").concat(key),
+          message: "Expected a remote ".concat(MEDIA_ENTRY_LABEL[type], ", but got a local path. Use Val tooling (CLI --fix, VS Code extension, or Val Studio) to upload it. Got: ").concat(key),
           value: key,
           fixes: [uploadRemoteFix]
         }]);
@@ -5906,7 +6344,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "validateMediaEntry",
-    value: function validateMediaEntry(path, entry) {
+    value: function validateMediaEntry(path, key, entry) {
       if (!this.mediaOptions) {
         return false;
       }
@@ -5922,6 +6360,40 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
       }
       var entryObj = entry;
       var errors = [];
+      if (type === "videos") {
+        // What is read from the bytes. Missing is a fix (the CLI reads them,
+        // from disk or — for a remote entry — over HTTP with Range requests);
+        // present and wrong is an error, because a fix that overwrote an
+        // authored number would be guessing which of the two was right.
+        var missing = ["mimeType", "width", "height", "duration"].filter(function (k) {
+          return entryObj[k] === undefined;
+        });
+        if (missing.length > 0) {
+          return _defineProperty({}, path, [{
+            message: "Video metadata is missing: ".concat(missing.join(", "), "."),
+            value: entry,
+            fixes: ["videos:add-metadata"]
+          }]);
+        }
+        var _iterator3 = _createForOfIteratorHelper(["width", "height", "duration"]),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var k = _step3.value;
+            var value = entryObj[k];
+            if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+              errors.push({
+                message: "Expected '".concat(k, "' to be a positive number, got '").concat(JSON.stringify(value), "'"),
+                value: entry
+              });
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
       if (type === "images") {
         // Validate width
         if (typeof entryObj.width !== "number" || entryObj.width <= 0) {
@@ -5946,6 +6418,15 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           message: "Expected 'mimeType' to be a string, got '".concat(_typeof(entryObj.mimeType), "'"),
           value: entry
         });
+      } else if (type === "videos" && entryObj.mimeType === HLS_MIME_TYPE) {
+        // A stream is what the Studio made of an upload that WAS accepted, so
+        // `accept` (which is about what may be picked) is not asked about it.
+        if (!key.split("?")[0].toLowerCase().endsWith(".m3u8")) {
+          errors.push({
+            message: "An HLS video must be keyed by its master playlist (.m3u8). Got: ".concat(key),
+            value: entry
+          });
+        }
       } else {
         var mimeTypeError = this.validateMediaMimeType(entryObj.mimeType, accept);
         if (mimeTypeError) {
@@ -5955,6 +6436,26 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           });
         }
       }
+      if (type === "videos") {
+        // The defaults every field picked from the set starts from, checked as
+        // a field's own would be: they are the same choices, made once.
+        var duration = typeof entryObj.duration === "number" && entryObj.duration > 0 ? entryObj.duration : undefined;
+        errors.push.apply(errors, _toConsumableArray(validateTimes(entryObj, duration)).concat(_toConsumableArray(validateHotspot(entryObj)), _toConsumableArray(validatePoster(entryObj)), _toConsumableArray(validateCaptions(entryObj))));
+        var misplaced = this.misplacedEntryFiles(key, entryObj);
+        if (misplaced.length > 0) {
+          var these = misplaced.length === 1 ? "this file is" : "".concat(misplaced.length, " files are");
+          errors.push(this.mediaOptions.remote ? {
+            message: "Expected the entry's files on Val Remote, but ".concat(these, " stored locally: ").concat(misplaced.join(", ")),
+            // The key, as a local key's upload error carries: the fix
+            // rewrites the entry under it.
+            value: key,
+            fixes: ["videos:upload-remote"]
+          } : {
+            message: "Expected the entry's files under ".concat(this.mediaOptions.dir, ", but ").concat(these, " remote: ").concat(misplaced.join(", ")),
+            value: entry
+          });
+        }
+      }
       if (type === "images") {
         // Validate hotspot if present
         if (entryObj.hotspot !== undefined) {
@@ -5966,7 +6467,8 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
             });
           }
         }
-
+      }
+      if (type === "images" || type === "videos") {
         // Validate alt using the alt schema
         var altPath = createValPathOfItem(path, "alt");
         if (altPath && altSchema) {
@@ -5981,16 +6483,59 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
       }
       return false;
     }
+
+    /**
+     * The poster and caption files of a set's entry that are not where the set
+     * keeps its files. Asked only once the key itself is in place: a local key
+     * in a remote set is reported (and uploaded) as the entry, files and all,
+     * and a second error for its poster would be the same one twice.
+     */
   }, {
-    key: "validateMediaMimeType",
-    value: function validateMediaMimeType(mimeType, accept) {
-      if (!mimeType.includes("/")) {
-        return "Invalid mime type format. Got: '".concat(mimeType, "'");
+    key: "misplacedEntryFiles",
+    value: function misplacedEntryFiles(key, entry) {
+      var _this3 = this;
+      if (!this.mediaOptions) {
+        return [];
       }
-      if (!mimeTypeMatchesAccept(mimeType, accept)) {
-        return "Mime type mismatch. Found '".concat(mimeType, "' but schema accepts '").concat(accept, "'");
+      var remote = this.mediaOptions.remote;
+      if (this.isRemoteUrl(key) !== remote) {
+        return [];
       }
-      return null;
+      var files = [];
+      var poster = entry.poster;
+      if (isObject(poster) && typeof poster.path === "string") {
+        files.push(poster.path);
+      }
+      if (Array.isArray(entry.captions)) {
+        var _iterator4 = _createForOfIteratorHelper(entry.captions),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var track = _step4.value;
+            if (isObject(track) && typeof track.path === "string") {
+              files.push(track.path);
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+      return files.filter(function (file) {
+        return _this3.isRemoteUrl(file) !== remote;
+      });
+    }
+  }, {
+    key: "validateMediaMimeType",
+    value: function validateMediaMimeType(mimeType, accept) {
+      if (!mimeType.includes("/")) {
+        return "Invalid mime type format. Got: '".concat(mimeType, "'");
+      }
+      if (!mimeTypeMatchesAccept(mimeType, accept)) {
+        return "Mime type mismatch. Found '".concat(mimeType, "' but schema accepts '").concat(accept, "'");
+      }
+      return null;
     }
   }, {
     key: "executeAssert",
@@ -6344,6 +6889,9 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
         if (this.mediaOptions.encode !== undefined) {
           result.encode = this.mediaOptions.encode;
         }
+        if (this.mediaOptions.stream !== undefined) {
+          result.stream = this.mediaOptions.stream;
+        }
         if (this.mediaOptions.altSchema) {
           result.alt = this.mediaOptions.altSchema["executeSerialize"]();
         }
@@ -10340,56 +10888,521 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
           }]));
         }
       }
-      var fileMimeType = Internal.filenameToMimeType(src.path);
-      if (!fileMimeType) {
-        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-          message: "Could not determine mime type from file extension. Got: ".concat(src.path),
-          value: src
-        }]));
+      var fileMimeType = Internal.filenameToMimeType(src.path);
+      if (!fileMimeType) {
+        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
+          message: "Could not determine mime type from file extension. Got: ".concat(src.path),
+          value: src
+        }]));
+      }
+
+      // Guarded on `mimeType` being set, as `ImageSchema` guards the same check.
+      // Without it, an absent mimeType reported "Mime type and file extension not
+      // matching. Mime type is 'undefined'" -- with no fix attached, so no quick
+      // fix was offered -- and the `file:add-metadata` branch below could never be
+      // reached for any file whose extension is recognized, which is all of them
+      // that get this far.
+      if (mimeType && fileMimeType !== mimeType) {
+        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
+          message: "Mime type and file extension not matching. Mime type is '".concat(mimeType, "' but file extension is '").concat(fileMimeType, "'"),
+          value: src
+        }]));
+      }
+
+      // The mime type read so far came from the filename. Whether it matches the
+      // bytes can only be answered by reading the file, which this package
+      // deliberately cannot do — so it is always handed on as a fix.
+      if (mimeType !== undefined) {
+        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
+          message: "File mimeType has not been checked against the file.",
+          value: src,
+          fixes: ["file:check-metadata"]
+        }]));
+      }
+      return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
+        message: "File metadata is missing: mimeType.",
+        value: src,
+        fixes: ["file:add-metadata"]
+      }]));
+    }
+
+    /**
+     * The entries of the gallery this field points at, or null when it is a
+     * standalone field.
+     */
+  }, {
+    key: "galleryEntries",
+    value: function galleryEntries() {
+      var modulePaths = Object.keys(this.moduleMetadata);
+      if (modulePaths.length === 0) {
+        return null;
+      }
+      return this.moduleMetadata[modulePaths[0]];
+    }
+  }, {
+    key: "executeAssert",
+    value: function executeAssert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected object, got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      if (!("path" in src) || typeof src.path !== "string") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "A file must be an object with a 'path' (error type: missing_path)",
+            typeError: true
+          }])
+        };
+      }
+      return {
+        success: true,
+        data: src
+      };
+    }
+  }, {
+    key: "nullable",
+    value: function nullable() {
+      return new FileSchema(this.options, true, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, this.isHidden, this.description, this.previewInput);
+    }
+  }, {
+    key: "readonly",
+    value: function readonly() {
+      var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, isReadonly, this.isHidden, this.description, this.previewInput);
+    }
+  }, {
+    key: "hidden",
+    value: function hidden() {
+      var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, isHidden, this.description, this.previewInput);
+    }
+  }, {
+    key: "executeCustomValidateAt",
+    value: function executeCustomValidateAt(path, src) {
+      return this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+    }
+
+    /**
+     * How this VALUE is shown where a preview of it is needed — a row in a
+     * sortable list, a reference dropdown, a search hit. Never how the field
+     * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.file().preview(({ val }) => ({ title: val.path })),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   { path: "/public/val/example.pdf", mimeType: "application/pdf" },
+     * ]);
+     */
+  }, {
+    key: "preview",
+    value: function preview(select) {
+      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, this.isHidden, this.description, select);
+    }
+  }, {
+    key: "executePreviewItem",
+    value: function executePreviewItem(src) {
+      if (this.previewInput === null) {
+        return null;
+      }
+      return this.previewInput({
+        val: src
+      });
+    }
+  }, {
+    key: "declaresItemPreview",
+    value: function declaresItemPreview() {
+      return this.previewInput !== null;
+    }
+  }, {
+    key: "executeSerialize",
+    value: function executeSerialize() {
+      var _this$customValidateF;
+      var modulePaths = this.moduleMetadata ? Object.keys(this.moduleMetadata) : [];
+      return {
+        type: "file",
+        preview: this.previewInput ? true : undefined,
+        options: this.options,
+        opt: this.opt,
+        remote: this.isRemote,
+        customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
+        referencedModule: modulePaths.length > 0 ? modulePaths[0] : undefined,
+        readonly: this.isReadonly,
+        hidden: this.isHidden,
+        description: this.description
+      };
+    }
+  }]);
+}(Schema);
+
+/**
+ * A file picked from a gallery. Its mime type lives in the gallery, so the
+ * field carries only the path.
+ */
+
+/** A file of its own, carrying its own mime type. */
+
+function file(options) {
+  return fileOf(false, options);
+}
+
+/**
+ * `s.file()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): the same schema, with `.remote()` already applied. See
+ * `initSchema`.
+ */
+
+function remoteFile(options) {
+  return fileOf(true, options);
+}
+function fileOf(remote, options) {
+  var isModule = !!options && !!Internal.getValPath(options);
+  if (isModule) {
+    var allModules = {};
+    for (var _i = 0, _arr = [options]; _i < _arr.length; _i++) {
+      var valModule = _arr[_i];
+      var modulePath = getValPath(valModule);
+      if (modulePath === undefined) {
+        throw new Error("Invalid argument passed to s.file(). Expected a ValModule constructed through c.define, but got an object without a valid module path.");
+      }
+      allModules[modulePath] = getSource(valModule);
+    }
+    return new FileSchema({}, false, remote, [], allModules);
+  }
+  return new FileSchema(options, false, remote);
+}
+
+/**
+ * Turn an upload into an HLS stream, in the browser, before it is uploaded.
+ *
+ * The Studio transcodes the picked file with WebCodecs into one rendition per
+ * entry of `renditions` (never upscaled: a 720p upload gets no 1080p
+ * rendition), segments each into CMAF and writes the playlists. What is stored
+ * is a directory beside the other uploads; the field's `path` is its master
+ * playlist. See `architecture/media.md`.
+ *
+ * `type` is required for the same reason it is on `ImageEncodeOptions`: a
+ * second kind of stream would then be additive.
+ */
+
+/** `false` (or absent) uploads the file as it was picked. */
+
+/**
+ * What a SET-BACKED field (`s.video(videosVal)`) may say for itself.
+ *
+ * Not `VideoOptions`: `dir` and `accept` belong to the set. `stream` is the
+ * exception, as `encode` is for an image: it is about what happens to an
+ * upload on its way in, so a field that wants the file as it was picked,
+ * where its set streams, has to be able to say `stream: false`.
+ */
+
+/**
+ * The set a field picks from: its entries as they were when the module was
+ * evaluated (the published set — see `GalleryImageSource` for why that is
+ * enough), and whether it stores its videos on Val Remote.
+ */
+
+var DEFAULT_VIDEO_ACCEPT = "video/*";
+var DEFAULT_VIDEO_RENDITIONS = [1080, 720, 480];
+var DEFAULT_VIDEO_SEGMENT_DURATION = 6;
+var VideoSchema = /*#__PURE__*/function (_Schema) {
+  function VideoSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var isRemote = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var customValidateFunctions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+    var isReadonly = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    var isHidden = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+    var description = arguments.length > 6 ? arguments[6] : undefined;
+    var renderInput = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
+    var previewInput = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : null;
+    var gallery = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;
+    _classCallCheck(this, VideoSchema);
+    _this = _callSuper(this, VideoSchema);
+    _this.options = options;
+    _this.opt = opt;
+    _this.isRemote = isRemote;
+    _this.customValidateFunctions = customValidateFunctions;
+    _this.isReadonly = isReadonly;
+    _this.isHidden = isHidden;
+    _this.description = description;
+    _this.renderInput = renderInput;
+    _this.previewInput = previewInput;
+    _this.gallery = gallery;
+    return _this;
+  }
+
+  /**
+   * Describe this field.
+   *
+   * The description is INPUT HELP: it is shown where this field's value is
+   * entered — beside its input in the Val editor, and for a record's key
+   * schema in every form that asks for a key — so it is where you say what an
+   * editor needs to know to fill it in RIGHT, which the field name cannot
+   * carry. It is not a name for the value: that is `.preview(...)`, and it is
+   * read somewhere else. The description also travels in the serialized
+   * schema, which is what the AI assistant and the MCP tools read.
+   *
+   * Pass `null` to clear a description set earlier.
+   *
+   * @example
+   * const schema = s.video().describe("Plays muted behind the headline");
+   * export default c.define("/example.val.ts", schema, {
+   *   path: "/public/val/example.mp4",
+   *   mimeType: "video/mp4",
+   * });
+   */
+  _inherits(VideoSchema, _Schema);
+  return _createClass(VideoSchema, [{
+    key: "describe",
+    value: function describe(description) {
+      return new VideoSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.renderInput, this.previewInput, this.gallery);
+    }
+
+    /**
+     * Store the video on Val's remote content host instead of in your
+     * repository.
+     *
+     * The bytes still go into the patch store when the video is uploaded — the
+     * push to the remote host happens at publish. What changes is where the
+     * published video lives: `path` (and the poster's, and each caption track's)
+     * becomes a remote URL rather than a path under `/public`, so the repository
+     * does not grow with every upload. Upload remote videos in the Studio.
+     *
+     * @example
+     * const schema = s.video().remote();
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "https://remote.val.build/file/p/my-project/b/01/v/1.0.0/h/8f2a1c/f/3b9d70/p/public/val/example.mp4",
+     *   mimeType: "video/mp4",
+     * });
+     */
+  }, {
+    key: "remote",
+    value: function remote() {
+      return new VideoSchema(this.options, this.opt, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput, this.gallery);
+    }
+
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * The second argument carries the `path` of the field being validated, for
+     * when the message needs to say where the problem is.
+     *
+     * @example
+     * const schema = s.video().validate((val) =>
+     *   (val.duration ?? 0) <= 30 ? false : "Keep it under 30 seconds",
+     * );
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "/public/val/example.mp4",
+     *   mimeType: "video/mp4",
+     *   duration: 12,
+     * });
+     */
+  }, {
+    key: "validate",
+    value: function validate(validationFunction) {
+      return new VideoSchema(this.options, this.opt, this.isRemote, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput, this.gallery);
+    }
+  }, {
+    key: "executeValidate",
+    value: function executeValidate(path, src) {
+      var customValidationErrors = this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+      var report = function report(errors) {
+        var all = [].concat(_toConsumableArray(customValidationErrors), _toConsumableArray(errors));
+        return all.length > 0 ? _defineProperty({}, path, all) : false;
+      };
+      if (src === null || src === undefined) {
+        if (this.opt) {
+          return report([]);
+        }
+        return report([{
+          message: "Non-optional video was null or undefined.",
+          value: src
+        }]);
+      }
+      if (_typeof(src) !== "object" || typeof src.path !== "string") {
+        return report([{
+          message: "A video must be an object with a 'path' string.",
+          value: src
+        }]);
+      }
+      if (this.gallery) {
+        return report(this.validateFromGallery(src, this.gallery));
+      }
+      return report(this.validateOwn(src));
+    }
+
+    /**
+     * A set-backed field: the file and what was read from it are the set's,
+     * so the field is checked for what is its own, and for pointing at an
+     * entry the set has.
+     */
+  }, {
+    key: "validateFromGallery",
+    value: function validateFromGallery(src, gallery) {
+      var own = ownMetadataOf(src);
+      var repeated = ["mimeType", "width", "height", "duration"].filter(function (key) {
+        return own[key] !== undefined;
+      });
+      if (repeated.length > 0) {
+        return [{
+          message: "A video from a set must not carry its own ".concat(repeated.join(", "), ": ").concat(repeated.length === 1 ? "it is" : "they are", " stored in the set."),
+          value: src
+        }];
+      }
+      var entry = gallery.entries === null ? null : gallery.entries[src.path];
+      if (entry === undefined) {
+        return [{
+          message: "The set does not have a video at '".concat(src.path, "'."),
+          value: src
+        }];
+      }
+      // The poster and the captions are the field's own files, and live where
+      // the set keeps its videos. The video itself is the set's to move.
+      var misplaced = filesOfVideoSource(src).slice(1).filter(function (file) {
+        return isRemoteMediaPath(file) !== gallery.remote;
+      });
+      if (misplaced.length > 0) {
+        return [misplacedError(src, misplaced, gallery.remote)];
+      }
+      var duration = entry !== null && typeof entry.duration === "number" && entry.duration > 0 ? entry.duration : undefined;
+      return [].concat(_toConsumableArray(validateTimes(src, duration)), _toConsumableArray(validateMixedTimes(src, entry)), _toConsumableArray(validateHotspot(src)), _toConsumableArray(validatePoster(src)), _toConsumableArray(validateCaptions(src)));
+    }
+
+    /** A video of its own: it carries the file, and what was read from it. */
+  }, {
+    key: "validateOwn",
+    value: function validateOwn(src) {
+      var _this2 = this;
+      var own = ownMetadataOf(src);
+      // Every file the video names has to be where the schema says, and one fix
+      // moves them all — a video on the content host with its poster still in
+      // the repository is half a migration, not a choice. The error is reported
+      // once for the whole video, never per file.
+      var misplaced = filesOfVideoSource(src).filter(function (file) {
+        return isRemoteMediaPath(file) !== _this2.isRemote;
+      });
+      if (misplaced.length > 0) {
+        return [misplacedError(src, misplaced, this.isRemote)];
+      }
+      var errors = [];
+      var isHls = isHlsVideo({
+        path: src.path,
+        mimeType: stringOrUndefined(own.mimeType)
+      });
+      var extensionMimeType = filenameToMimeType(stripQuery(src.path));
+      if (isHls) {
+        if (!stripQuery(src.path).toLowerCase().endsWith(".m3u8")) {
+          errors.push({
+            message: "An HLS video's path must be its master playlist (.m3u8). Got: ".concat(src.path),
+            value: src
+          });
+        }
+      } else if (!extensionMimeType || !extensionMimeType.startsWith("video/")) {
+        errors.push({
+          message: "Could not tell this is a video from its file extension. Got: ".concat(src.path),
+          value: src
+        });
+      } else if (own.mimeType !== undefined && extensionMimeType !== own.mimeType) {
+        errors.push({
+          message: "Mime type and file extension not matching. Mime type is '".concat(String(own.mimeType), "' but file extension is '").concat(extensionMimeType, "'"),
+          value: src
+        });
+      }
+      if (own.mimeType !== undefined && typeof own.mimeType !== "string") {
+        errors.push({
+          message: "'mimeType' must be a string.",
+          value: src
+        });
+      } else if (own.mimeType !== undefined && !isHls) {
+        var _this$options$accept, _this$options;
+        var accept = (_this$options$accept = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.accept) !== null && _this$options$accept !== void 0 ? _this$options$accept : DEFAULT_VIDEO_ACCEPT;
+        if (!mimeTypeMatchesAccept(own.mimeType, accept)) {
+          errors.push({
+            message: "Mime type mismatch. Found '".concat(own.mimeType, "' but schema accepts '").concat(accept, "'"),
+            value: src
+          });
+        }
+      }
+      var _iterator = _createForOfIteratorHelper(["width", "height", "duration"]),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          var value = own[key];
+          if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value) || value <= 0)) {
+            errors.push({
+              message: "'".concat(key, "' must be a positive number. Got: ").concat(JSON.stringify(value)),
+              value: src
+            });
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
-
-      // Guarded on `mimeType` being set, as `ImageSchema` guards the same check.
-      // Without it, an absent mimeType reported "Mime type and file extension not
-      // matching. Mime type is 'undefined'" -- with no fix attached, so no quick
-      // fix was offered -- and the `file:add-metadata` branch below could never be
-      // reached for any file whose extension is recognized, which is all of them
-      // that get this far.
-      if (mimeType && fileMimeType !== mimeType) {
-        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-          message: "Mime type and file extension not matching. Mime type is '".concat(mimeType, "' but file extension is '").concat(fileMimeType, "'"),
-          value: src
-        }]));
+      var duration = typeof own.duration === "number" && own.duration > 0 ? own.duration : undefined;
+      errors.push.apply(errors, _toConsumableArray(validateTimes(src, duration)));
+      errors.push.apply(errors, _toConsumableArray(validateHotspot(src)));
+      errors.push.apply(errors, _toConsumableArray(validatePoster(src)));
+      errors.push.apply(errors, _toConsumableArray(validateCaptions(src)));
+      if (errors.length > 0) {
+        return errors;
       }
 
-      // The mime type read so far came from the filename. Whether it matches the
-      // bytes can only be answered by reading the file, which this package
-      // deliberately cannot do — so it is always handed on as a fix.
-      if (mimeType !== undefined) {
-        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-          message: "File mimeType has not been checked against the file.",
+      // Everything authored is fine. What is left is what is read from the
+      // bytes, which this package cannot do — so it is handed on as a fix. The
+      // CLI reads a local file's headers from disk and a remote one's over
+      // HTTP, with Range requests, so neither is downloaded whole.
+      var missing = ["mimeType", "width", "height", "duration"].filter(function (key) {
+        return own[key] === undefined;
+      });
+      if (missing.length > 0) {
+        return [{
+          message: "Video metadata is missing: ".concat(missing.join(", "), "."),
           value: src,
-          fixes: ["file:check-metadata"]
-        }]));
-      }
-      return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-        message: "File metadata is missing: mimeType.",
-        value: src,
-        fixes: ["file:add-metadata"]
-      }]));
-    }
-
-    /**
-     * The entries of the gallery this field points at, or null when it is a
-     * standalone field.
-     */
-  }, {
-    key: "galleryEntries",
-    value: function galleryEntries() {
-      var modulePaths = Object.keys(this.moduleMetadata);
-      if (modulePaths.length === 0) {
-        return null;
+          fixes: ["video:add-metadata"]
+        }];
       }
-      return this.moduleMetadata[modulePaths[0]];
+      return [];
     }
   }, {
     key: "executeAssert",
@@ -10422,7 +11435,7 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
         return {
           success: false,
           errors: _defineProperty({}, path, [{
-            message: "A file must be an object with a 'path' (error type: missing_path)",
+            message: "A video must be an object with a 'path' (error type: missing_path)",
             typeError: true
           }])
         };
@@ -10435,19 +11448,19 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new FileSchema(this.options, true, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      return new VideoSchema(this.options, true, this.isRemote, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput, this.gallery);
     }
   }, {
     key: "readonly",
     value: function readonly() {
       var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, isReadonly, this.isHidden, this.description, this.previewInput);
+      return new VideoSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput, this.gallery);
     }
   }, {
     key: "hidden",
     value: function hidden() {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, isHidden, this.description, this.previewInput);
+      return new VideoSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.renderInput, this.previewInput, this.gallery);
     }
   }, {
     key: "executeCustomValidateAt",
@@ -10457,6 +11470,25 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
       });
     }
 
+    /**
+     * How this field is laid out in the editor when it is the item of an array
+     * or record: `{ as: "inline" }` renders the field itself inside each row,
+     * instead of a preview row that navigates to it.
+     *
+     * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.video().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, [
+     *   { path: "/public/val/example.mp4", mimeType: "video/mp4" },
+     * ]);
+     */
+  }, {
+    key: "render",
+    value: function render(input) {
+      return new VideoSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, input, this.previewInput, this.gallery);
+    }
+
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
      * sortable list, a reference dropdown, a search hit. Never how the field
@@ -10464,16 +11496,19 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
      *
      * @example
      * const schema = s.array(
-     *   s.file().preview(({ val }) => ({ title: val.path })),
+     *   s.video().preview(({ val }) => ({
+     *     title: val.alt ?? val.path,
+     *     image: val.poster,
+     *   })),
      * );
      * export default c.define("/example.val.ts", schema, [
-     *   { path: "/public/val/example.pdf", mimeType: "application/pdf" },
+     *   { path: "/public/val/example.mp4", mimeType: "video/mp4" },
      * ]);
      */
   }, {
     key: "preview",
     value: function preview(select) {
-      return new FileSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.moduleMetadata, this.isReadonly, this.isHidden, this.description, select);
+      return new VideoSchema(this.options, this.opt, this.isRemote, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, select, this.gallery);
     }
   }, {
     key: "executePreviewItem",
@@ -10493,16 +11528,16 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "executeSerialize",
     value: function executeSerialize() {
-      var _this$customValidateF;
-      var modulePaths = this.moduleMetadata ? Object.keys(this.moduleMetadata) : [];
+      var _this$renderInput, _this$customValidateF, _this$gallery;
       return {
-        type: "file",
+        type: "video",
+        render: (_this$renderInput = this.renderInput) !== null && _this$renderInput !== void 0 ? _this$renderInput : undefined,
         preview: this.previewInput ? true : undefined,
         options: this.options,
         opt: this.opt,
         remote: this.isRemote,
         customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
-        referencedModule: modulePaths.length > 0 ? modulePaths[0] : undefined,
+        referencedModule: (_this$gallery = this.gallery) === null || _this$gallery === void 0 ? void 0 : _this$gallery.modulePath,
         readonly: this.isReadonly,
         hidden: this.isHidden,
         description: this.description
@@ -10512,27 +11547,137 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
 }(Schema);
 
 /**
- * A file picked from a gallery. Its mime type lives in the gallery, so the
- * field carries only the path.
+ * Every file a video value names: the video, its poster and each caption
+ * track. An HLS stream's segments are not here — they are named by its
+ * playlists, not by the value.
  */
-
-/** A file of its own, carrying its own mime type. */
-
-function file(options) {
-  var isModule = !!options && !!Internal.getValPath(options);
-  if (isModule) {
-    var allModules = {};
-    for (var _i = 0, _arr = [options]; _i < _arr.length; _i++) {
-      var valModule = _arr[_i];
-      var modulePath = getValPath(valModule);
-      if (modulePath === undefined) {
-        throw new Error("Invalid argument passed to s.file(). Expected a ValModule constructed through c.define, but got an object without a valid module path.");
+function filesOfVideoSource(src) {
+  var files = [src.path];
+  if (src.poster && _typeof(src.poster) === "object" && typeof src.poster.path === "string") {
+    files.push(src.poster.path);
+  }
+  if (Array.isArray(src.captions)) {
+    var _iterator2 = _createForOfIteratorHelper(src.captions),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var track = _step2.value;
+        if (track && _typeof(track) === "object" && typeof track.path === "string") {
+          files.push(track.path);
+        }
       }
-      allModules[modulePath] = getSource(valModule);
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
     }
-    return new FileSchema({}, false, false, [], allModules);
   }
-  return new FileSchema(options);
+  return files;
+}
+
+/**
+ * What the value says about its file, typed as what it IS rather than what
+ * it should be: a set-backed field's type has none of these, and is checked
+ * for carrying them anyway, because hand-written JSON never saw the type.
+ */
+function ownMetadataOf(src) {
+  var value = _objectSpread2({}, src);
+  return {
+    mimeType: value.mimeType,
+    width: value.width,
+    height: value.height,
+    duration: value.duration
+  };
+}
+
+/**
+ * A start the field set against an end the set holds, or the reverse: each is
+ * fine alone, and the field's own times and the set's are each checked where
+ * they are written, so what is left is the pair the page will actually play.
+ */
+function validateMixedTimes(src, entry) {
+  var _src$startTime, _src$endTime;
+  if (entry === null || src.startTime === undefined === (src.endTime === undefined)) {
+    return [];
+  }
+  var start = (_src$startTime = src.startTime) !== null && _src$startTime !== void 0 ? _src$startTime : entry.startTime;
+  var end = (_src$endTime = src.endTime) !== null && _src$endTime !== void 0 ? _src$endTime : entry.endTime;
+  if (typeof start !== "number" || typeof end !== "number" || start < end) {
+    return [];
+  }
+  var whose = src.startTime === undefined ? "the start is the set's" : "the end is the set's";
+  return [{
+    message: "'startTime' (".concat(start, "s) must be before 'endTime' (").concat(end, "s) \u2014 ").concat(whose, "."),
+    value: src
+  }];
+}
+function stringOrUndefined(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function misplacedError(src, misplaced, shouldBeRemote) {
+  var these = misplaced.length === 1 ? "this file is" : "".concat(misplaced.length, " files are");
+  return shouldBeRemote ? {
+    message: "Expected a remote video, but ".concat(these, " stored locally: ").concat(misplaced.join(", ")),
+    value: src,
+    fixes: ["video:upload-remote"]
+  } : {
+    message: "Expected a local video (files under /public), but ".concat(these, " remote: ").concat(misplaced.join(", ")),
+    value: src,
+    fixes: ["video:download-remote"]
+  };
+}
+function stripQuery(path) {
+  return path.split("?")[0];
+}
+
+/**
+ * A video picked from a set (`s.videoset()`). What is true of the file —
+ * its type, size and length — lives in the set; the field carries what one
+ * page chose about it.
+ */
+
+/**
+ * Define a video: an `.mp4` / `.webm` file, or an HLS stream the Studio makes
+ * from an upload when `stream` is set.
+ */
+
+function video(options, galleryOptions) {
+  return videoOf(options, galleryOptions);
+}
+
+/**
+ * `s.video()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): the same schema, with `.remote()` already applied. See
+ * `initSchema`.
+ */
+
+function remoteVideo(options, galleryOptions) {
+  return videoOf(options, galleryOptions).remote();
+}
+function videoOf(options, galleryOptions) {
+  var _options$GetSchema, _setSchema$remote, _setSchema$remote2;
+  if (options === undefined || !isVideosetModule(options)) {
+    return new VideoSchema(options);
+  }
+  var modulePath = getValPath(options);
+  if (modulePath === undefined) {
+    throw new Error("Invalid argument passed to s.video(). Expected a ValModule constructed through c.define, but got an object without a valid module path.");
+  }
+  var setSchema = (_options$GetSchema = options[GetSchema]) === null || _options$GetSchema === void 0 ? void 0 : _options$GetSchema["executeSerialize"]();
+  if ((setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) !== "record" || setSchema.mediaType !== "videos") {
+    var _setSchema$mediaType, _setSchema$type;
+    throw new Error("s.video(".concat(modulePath, "): the module must be an s.videoset(). Got ").concat((setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) === "record" ? "a record of ".concat((_setSchema$mediaType = setSchema.mediaType) !== null && _setSchema$mediaType !== void 0 ? _setSchema$mediaType : "values") : (_setSchema$type = setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) !== null && _setSchema$type !== void 0 ? _setSchema$type : "no schema", "."));
+  }
+  return new VideoSchema((galleryOptions === null || galleryOptions === void 0 ? void 0 : galleryOptions.stream) !== undefined ? {
+    stream: galleryOptions.stream
+  } : undefined, false, (_setSchema$remote = setSchema.remote) !== null && _setSchema$remote !== void 0 ? _setSchema$remote : false, [], false, false, undefined, null, null, {
+    modulePath: modulePath,
+    entries: getSource(options),
+    remote: (_setSchema$remote2 = setSchema.remote) !== null && _setSchema$remote2 !== void 0 ? _setSchema$remote2 : false
+  });
+}
+function isVideosetModule(value) {
+  return GetSchema in value;
 }
 
 /**
@@ -11514,6 +12659,99 @@ var imageset = function imageset(options) {
   });
 };
 
+/**
+ * Options for s.videoset()
+ */
+
+/** See `ImagesetAltOption`: `alt` is optional only when it is the default. */
+
+/**
+ * One video of a set, keyed by its file path (an HLS stream by its master
+ * playlist).
+ *
+ * Two kinds of thing are here. What is TRUE OF THE FILE — what it is, how
+ * big, how long — is read from the bytes and is the set's alone. The rest —
+ * the description, focal point, poster, start and end, and captions — is what
+ * a page chooses about a video, and an entry holds it as the DEFAULT: every
+ * field picked from the set (`s.video(videosVal)`) starts from it and may
+ * override it key by key, so a video described and trimmed once is described
+ * and trimmed everywhere it is used. `fillFromGallery` is the one merge.
+ *
+ * The poster is also the set's thumbnail of the entry: there is no separate
+ * still for the gallery, because two stills of one video would disagree.
+ */
+
+/**
+ * Define a collection of videos — the video twin of `s.imageset()`.
+ *
+ * A field picks from it with `s.video(videosVal)`. An entry may hold the
+ * description, poster, start and end, focal point and captions as defaults,
+ * and a field overrides any of them by setting its own. Uploading in such a
+ * field adds to the set. Call `.remote()` on the result
+ * to store the set on Val Remote.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.videoset({
+ *   dir: "/public/val/videos",
+ *   stream: { type: "hls" },
+ * });
+ * export default c.define("/content/videos.val.ts", schema, {
+ *   "/public/val/videos/intro_51df2.mp4": {
+ *     mimeType: "video/mp4",
+ *     width: 1280,
+ *     height: 720,
+ *     duration: 12.5,
+ *     alt: "The team, introducing itself",
+ *     startTime: 1.5,
+ *   },
+ * });
+ * ```
+ */
+var videoset = function videoset(options) {
+  var _options$alt, _options$accept;
+  // The same assertion as in `imageset()`, and sound for the same reason:
+  // `VideosetAltOption` makes `alt` required unless `Alt` is the default.
+  var altSchema = (_options$alt = options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
+  var itemSchema = new ObjectSchema({
+    mimeType: new StringSchema({}, false),
+    width: new NumberSchema(undefined, false),
+    height: new NumberSchema(undefined, false),
+    duration: new NumberSchema(undefined, false),
+    alt: altSchema
+  }, false);
+  return new RecordSchema(itemSchema, false, [], null, null, {
+    type: "videos",
+    accept: (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_VIDEO_ACCEPT,
+    dir: options.dir,
+    remote: false,
+    altSchema: altSchema,
+    stream: options.stream
+  });
+};
+
+/**
+ * The video schema a set's entry is hashed against, for a remote ref.
+ *
+ * The set's item schema is an object, but a remote ref's validation hash is
+ * computed over a MEDIA schema, so one is synthesized from the set — the one
+ * definition the CLI's upload (`videos:upload-remote`) and the Studio's (the
+ * set's gallery) both use, because two copies are two hashes for the same
+ * file. `stream` is left out: it says what is done to an upload on its way
+ * in, not whether the bytes that arrived are valid.
+ */
+function videosetEntryVideoSchema(set) {
+  return {
+    type: "video",
+    opt: false,
+    options: _objectSpread2(_objectSpread2({}, set.accept ? {
+      accept: set.accept
+    } : {}), set.dir ? {
+      dir: set.dir
+    } : {})
+  };
+}
+
 // import type { F } from "ts-toolbelt";
 // import { i18n, I18n } from "./schema/future/i18n";
 // import { oneOf } from "./schema/future/oneOf";
@@ -11521,7 +12759,31 @@ var imageset = function imageset(options) {
 // export type InitSchemaLocalized<Locales extends readonly string[]> = {
 //   readonly i18n: I18n<Locales>;
 // };
-function initSchema() {
+
+function initSchema(options) {
+  var media = (options === null || options === void 0 ? void 0 : options.remote) === true ? {
+    image: remoteImage,
+    file: remoteFile,
+    video: remoteVideo,
+    richtext: remoteRichtext,
+    imageset: function (options) {
+      return imageset(options).remote();
+    },
+    fileset: function (options) {
+      return fileset(options).remote();
+    },
+    videoset: function (options) {
+      return videoset(options).remote();
+    }
+  } : {
+    image: image,
+    file: file,
+    video: video,
+    richtext: richtext,
+    imageset: imageset,
+    fileset: fileset,
+    videoset: videoset
+  };
   // locales: F.Narrow<Locales>
   return {
     string: string,
@@ -11533,14 +12795,15 @@ function initSchema() {
     "enum": enumSchema,
     union: union,
     // oneOf,
-    richtext: richtext,
-    image: image,
+    richtext: media.richtext,
+    image: media.image,
     literal: literal,
     keyOf: keyOf,
     view: view,
     record: record,
-    file: file,
-    fileset: fileset,
+    file: media.file,
+    video: media.video,
+    fileset: media.fileset,
     date: date,
     datetime: datetime,
     color: color,
@@ -11548,7 +12811,8 @@ function initSchema() {
     locale: locale,
     route: route,
     router: router,
-    imageset: imageset,
+    imageset: media.imageset,
+    videoset: media.videoset,
     settings: settings
     // i18n: i18n(locales),
   };
@@ -11566,8 +12830,11 @@ function initSchema() {
 
 // TODO: Rename to createValSystem (only to be used by internal things), we can then export * from '@valbuild/core' in the next package then.
 var initVal = function initVal(config) {
+  var _config$files;
   // const locales = options?.locales;
-  var s = initSchema();
+  var s = initSchema({
+    remote: (config === null || config === void 0 || (_config$files = config.files) === null || _config$files === void 0 ? void 0 : _config$files.remote) === true
+  });
   // if (locales?.required) {
   //   console.error("Locales / i18n currently not implemented");
   //   return {
@@ -12668,7 +13935,7 @@ function _extractValModules() {
  * instead would reintroduce exactly the silent skip described above.
  */
 function hasRemoteFileSchema(schema) {
-  if (schema.type === "file" || schema.type === "image") {
+  if (schema.type === "file" || schema.type === "image" || schema.type === "video") {
     return !!schema.remote;
   } else if (schema.type === "richtext") {
     var _schema$options;
@@ -12747,7 +14014,7 @@ function hasRemoteFileSchema(schema) {
  * already has a data-loss incident attached to it (see above).
  */
 function hasMediaSchema(schema) {
-  if (schema.type === "file" || schema.type === "image") {
+  if (schema.type === "file" || schema.type === "image" || schema.type === "video") {
     return true;
   } else if (schema.type === "richtext") {
     var _schema$options2;
@@ -13113,6 +14380,10 @@ function getValidationBasis(coreVersion, schema, fileExt, metadata, fileHash) {
   // bytes that arrived are valid. Leaving it in would mean that changing a
   // quality setting re-validates every remote file in the project.
   delete options.encode;
+  // `stream` likewise: it is what the Studio made of an upload (an HLS
+  // directory instead of one file), and every file it made is validated on its
+  // own merits.
+  delete options.stream;
   var schemaValidationBasis = {
     type: schema.type,
     opt: schema.opt,
@@ -13132,6 +14403,93 @@ function getFileHash(text) {
   return hashToRemoteFileHash(getSHA256Hash(new Uint8Array(text)));
 }
 
+var cache$1 = new WeakMap();
+
+/**
+ * The PUBLISHED entries of every gallery a module's fields pick from — an
+ * `s.image(galleryVal)`, `s.file(filesVal)` or `s.video(videosVal)` — by the
+ * gallery's module path.
+ *
+ * A gallery-backed value names its file and nothing else that is the
+ * gallery's, so a reader has to look the entry up (`fillFromGallery`). In
+ * draft mode the reader has every module's draft source to look in; outside
+ * it, nothing — and the page got a set-backed video with no type, size,
+ * poster or description, and an image with no dimensions. But the field's
+ * schema was built from the gallery module (`s.video(videosVal)` reads it at
+ * definition), so the published entries are already here, on the schema
+ * instance. This is where they are read from.
+ *
+ * Stops at a view: the module it points at is read on its own, with its own
+ * galleries.
+ */
+function galleriesOf(schema) {
+  if (schema === undefined) {
+    return new Map();
+  }
+  var cached = cache$1.get(schema);
+  if (cached) {
+    return cached;
+  }
+  var galleries = new Map();
+  var seen = new Set();
+  function walk(node) {
+    if (_typeof(node) !== "object" || node === null || seen.has(node)) {
+      return;
+    }
+    seen.add(node);
+    if (node instanceof ValViewSchema) {
+      return;
+    }
+    if (node instanceof ImageSchema) {
+      for (var _i = 0, _Object$entries = Object.entries(node["moduleMetadata"]); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          modulePath = _Object$entries$_i[0],
+          entries = _Object$entries$_i[1];
+        galleries.set(modulePath, entries);
+      }
+      return;
+    }
+    if (node instanceof FileSchema) {
+      for (var _i2 = 0, _Object$entries2 = Object.entries(node["moduleMetadata"]); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          _modulePath = _Object$entries2$_i[0],
+          _entries = _Object$entries2$_i[1];
+        galleries.set(_modulePath, _entries);
+      }
+      return;
+    }
+    if (node instanceof VideoSchema) {
+      var gallery = node["gallery"];
+      if (gallery && gallery.entries !== null) {
+        galleries.set(gallery.modulePath, gallery.entries);
+      }
+      return;
+    }
+    if (Array.isArray(node)) {
+      var _iterator = _createForOfIteratorHelper(node),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          walk(item);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return;
+    }
+    for (var _i3 = 0, _Object$values = Object.values(node); _i3 < _Object$values.length; _i3++) {
+      var value = _Object$values[_i3];
+      walk(value);
+    }
+  }
+  walk(schema);
+  cache$1.set(schema, galleries);
+  return galleries;
+}
+
 /**
  * The variant of a discriminated union that a value takes, by its tag.
  *
@@ -13337,7 +14695,7 @@ function deserializeSchema(serialized) {
   return schema;
 }
 function deserializeSchemaImpl(serialized) {
-  var _serialized$options, _serialized$options2, _serialized$multiline, _serialized$render, _serialized$accept, _serialized$dir, _serialized$remote, _serialized$jsonValue, _serialized$render2, _serialized$external, _serialized$render3, _serialized$readonly, _serialized$hidden;
+  var _serialized$options, _serialized$options2, _serialized$multiline, _serialized$render, _serialized$accept, _serialized$dir, _serialized$remote, _serialized$jsonValue, _serialized$render2, _serialized$external, _serialized$render3, _serialized$render4, _serialized$remote2, _serialized$readonly, _serialized$hidden;
   switch (serialized.type) {
     case "string":
       return new StringSchema(_objectSpread2(_objectSpread2({}, serialized.options), {}, {
@@ -13396,6 +14754,8 @@ function deserializeSchemaImpl(serialized) {
         accept: (_serialized$accept = serialized.accept) !== null && _serialized$accept !== void 0 ? _serialized$accept : "*/*",
         dir: (_serialized$dir = serialized.dir) !== null && _serialized$dir !== void 0 ? _serialized$dir : "/public/val",
         remote: (_serialized$remote = serialized.remote) !== null && _serialized$remote !== void 0 ? _serialized$remote : false,
+        encode: serialized.encode,
+        stream: serialized.stream,
         altSchema: serialized.alt ? deserializeSchema(serialized.alt) : undefined
       } : undefined, false, false, serialized.description, (_serialized$jsonValue = serialized.jsonValues) !== null && _serialized$jsonValue !== void 0 ? _serialized$jsonValue : false,
       // The preview closure cannot survive serialization; the render can.
@@ -13421,6 +14781,12 @@ function deserializeSchemaImpl(serialized) {
       return new FileSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description);
     case "image":
       return new ImageSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description);
+    case "video":
+      return new VideoSchema(serialized.options, serialized.opt, serialized.remote, [], false, false, serialized.description, (_serialized$render4 = serialized.render) !== null && _serialized$render4 !== void 0 ? _serialized$render4 : null, null, serialized.referencedModule ? {
+        modulePath: serialized.referencedModule,
+        entries: null,
+        remote: (_serialized$remote2 = serialized.remote) !== null && _serialized$remote2 !== void 0 ? _serialized$remote2 : false
+      } : null);
     case "date":
       return new DateSchema(serialized.options, serialized.opt, [], false, false, serialized.description);
     case "dateTime":
@@ -14116,7 +15482,7 @@ function isPageRouter(routerId) {
 
 var corePackageJson = {
 	name: "@valbuild/core",
-	version: "0.139.1",
+	version: "0.141.0",
 	"private": false,
 	description: "Val - supercharged hard-coded content",
 	repository: {
@@ -14205,6 +15571,7 @@ var Internal = {
   VERSION: {
     core: corePackageJson.version
   },
+  videosetEntryVideoSchema: videosetEntryVideoSchema,
   // A view's read-path plumbing: `Internal` rather than the public surface,
   // because an app never builds or unwraps a handle — it passes one to
   // `useVal`.
@@ -14215,9 +15582,15 @@ var Internal = {
   viewModulesOf: viewModulesOf,
   mediaUrl: mediaUrl,
   resolveMedia: resolveMedia,
+  resolveVideo: resolveVideo,
   isRemoteMediaPath: isRemoteMediaPath,
   media: {
-    fillFromGallery: fillFromGallery
+    fillFromGallery: fillFromGallery,
+    galleriesOf: galleriesOf,
+    galleryEntryOf: galleryEntryOf,
+    GALLERY_DEFAULT_GROUPS: GALLERY_DEFAULT_GROUPS,
+    isHlsVideo: isHlsVideo,
+    HLS_MIME_TYPE: HLS_MIME_TYPE
   },
   getSchema: getSchema,
   getValPath: getValPath,
@@ -14265,6 +15638,13 @@ var Internal = {
   isExternalFileRef: isExternalFileRef,
   createValPathOfItem: createValPathOfItem,
   getSHA256Hash: getSHA256Hash,
+  /**
+   * The same hash as `getSHA256Hash`, fed a chunk at a time: what a caller
+   * hashing hundreds of megabytes uses to give the thread back between chunks.
+   */
+  createSHA256Hash: function createSHA256Hash() {
+    return createHash("sha256");
+  },
   initSchema: initSchema,
   getMimeType: getMimeType,
   mimeTypeToFileExt: mimeTypeToFileExt,
@@ -14323,4 +15703,4 @@ function tryJsonParse(str) {
   }
 }
 
-export { COLOR_FORMATS as $, ArraySchema as A, BooleanSchema as B, SETTINGS_MODULE_CONVENTION as C, DEFAULT_CONTENT_HOST as D, isRootModuleFilePath as E, FATAL_ERROR_TYPES as F, GenericSelector as G, resolveSettingsModule as H, Internal as I, localeTagError as J, localeOfValue as K, LocaleSchema as L, ModuleFilePathSep as M, NumberSchema as N, ObjectSchema as O, PatchError as P, declaredKeySetOf as Q, RecordSchema as R, Schema as S, THEME_LOGO_DIRECTORY as T, missingDeclaredKeys as U, VAL_EXTENSION as V, discriminatedUnionBranchOf as W, ColorSchema as X, CodeSchema as Y, CODE_LANGUAGES as Z, _typeof as _, _slicedToArray as a, DEFAULT_COLOR_FORMAT as a0, DateTimeSchema as a1, KeyOfSchema as a2, ValViewSchema as a3, isValViewSource as a4, RouteSchema as a5, RichTextSchema as a6, DiscriminatedUnionSchema as a7, EnumSchema as a8, LiteralSchema as a9, deserializeSchema as aa, previewScope as ab, isInlineRender as ac, parseNextJsRoutePattern as ad, parseTanStackRoutePattern as ae, tanStackSegmentsOfRoutePath as af, validateUrlAgainstPattern as ag, getSourcePathFromRoute as ah, isPageRouter as ai, describeSchemeRejection as aj, isCheckableScheme as ak, rejectScheme as al, schemeOf as am, UNSAFE_URL_SCHEMES as an, _createClass as b, _classCallCheck as c, _toConsumableArray as d, DEFAULT_APP_HOST as e, DEFAULT_STATIC_HOST as f, extractValModules as g, computeValModuleShas as h, initVal as i, computeSourcesSha as j, computeSchemaSha as k, hasRemoteFileSchema as l, modules as m, hasMediaSchema as n, DEFAULT_VAL_REMOTE_HOST as o, derefPatch as p, StringSchema as q, ImageSchema as r, splitModuleFilePathAndModulePath as s, FileSchema as t, DateSchema as u, SettingsSchema as v, ASSISTANT_SETTINGS_MAX_LENGTH as w, THEME_RADIUS_STEPS as x, THEME_RADIUS_LENGTHS as y, assistantAvailability as z };
+export { discriminatedUnionBranchOf as $, ArraySchema as A, BooleanSchema as B, ASSISTANT_SETTINGS_MAX_LENGTH as C, DEFAULT_CONTENT_HOST as D, THEME_RADIUS_STEPS as E, FATAL_ERROR_TYPES as F, GenericSelector as G, THEME_RADIUS_LENGTHS as H, Internal as I, assistantAvailability as J, SETTINGS_MODULE_CONVENTION as K, isRootModuleFilePath as L, ModuleFilePathSep as M, NumberSchema as N, ObjectSchema as O, PatchError as P, resolveSettingsModule as Q, RecordSchema as R, Schema as S, THEME_LOGO_DIRECTORY as T, localeTagError as U, VAL_EXTENSION as V, localeOfValue as W, LocaleSchema as X, declaredKeySetOf as Y, missingDeclaredKeys as Z, _typeof as _, _slicedToArray as a, ColorSchema as a0, CodeSchema as a1, CODE_LANGUAGES as a2, COLOR_FORMATS as a3, DEFAULT_COLOR_FORMAT as a4, DateTimeSchema as a5, KeyOfSchema as a6, ValViewSchema as a7, isValViewSource as a8, RouteSchema as a9, RichTextSchema as aa, DiscriminatedUnionSchema as ab, EnumSchema as ac, LiteralSchema as ad, deserializeSchema as ae, previewScope as af, isInlineRender as ag, parseNextJsRoutePattern as ah, parseTanStackRoutePattern as ai, tanStackSegmentsOfRoutePath as aj, validateUrlAgainstPattern as ak, getSourcePathFromRoute as al, isPageRouter as am, describeSchemeRejection as an, isCheckableScheme as ao, rejectScheme as ap, schemeOf as aq, UNSAFE_URL_SCHEMES as ar, _createClass as b, _classCallCheck as c, _toConsumableArray as d, DEFAULT_APP_HOST as e, DEFAULT_STATIC_HOST as f, extractValModules as g, computeValModuleShas as h, initVal as i, computeSourcesSha as j, computeSchemaSha as k, hasRemoteFileSchema as l, modules as m, hasMediaSchema as n, DEFAULT_VAL_REMOTE_HOST as o, derefPatch as p, StringSchema as q, ImageSchema as r, splitModuleFilePathAndModulePath as s, FileSchema as t, VideoSchema as u, DEFAULT_VIDEO_ACCEPT as v, DEFAULT_VIDEO_RENDITIONS as w, DEFAULT_VIDEO_SEGMENT_DURATION as x, DateSchema as y, SettingsSchema as z };