@valbuild/core 0.139.0 → 0.141.0

package/dist/{index-e13b725c.cjs.dev.js → index-fae161b5.cjs.dev.js}

@@ -2754,6 +2754,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] === "/") {
@@ -2795,6 +2817,8 @@ function splitRemoteRef(ref) {
   };
 }
 
+var _excluded = ["poster", "captions"];
+
 /** What must stay in frame when a page crops an image. */
 
 /**
@@ -2803,6 +2827,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.
  *
@@ -2856,66 +2950,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 = result._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 = result._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 = result._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 = {
@@ -3446,6 +3655,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",
@@ -4097,6 +4308,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 = {};
@@ -4110,9 +4334,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) {
@@ -4371,6 +4595,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;
@@ -4380,6 +4605,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     _this.isHidden = isHidden;
     _this.description = description;
     _this.previewInput = previewInput;
+    _this.imgRemote = imgRemote;
     return _this;
   }
 
@@ -4406,7 +4632,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);
     }
 
     /**
@@ -4426,7 +4652,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);
     }
 
     /**
@@ -4446,7 +4672,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);
     }
 
     /**
@@ -4474,7 +4700,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",
@@ -4649,7 +4875,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;
@@ -4918,19 +5144,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",
@@ -4958,7 +5184,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",
@@ -5004,7 +5230,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",
@@ -5023,6 +5252,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 {
@@ -5471,6 +5708,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 = result._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
@@ -5662,7 +6100,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: {
@@ -5680,7 +6118,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: {
@@ -5734,7 +6172,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);
           }
@@ -5848,8 +6286,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) {
@@ -5882,9 +6320,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]
         }]);
@@ -5908,7 +6346,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "validateMediaEntry",
-    value: function validateMediaEntry(path, entry) {
+    value: function validateMediaEntry(path, key, entry) {
       if (!this.mediaOptions) {
         return false;
       }
@@ -5924,6 +6362,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 = result._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) {
@@ -5948,6 +6420,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) {
@@ -5957,6 +6438,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) {
@@ -5968,7 +6469,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) {
@@ -5983,16 +6485,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 = result._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",
@@ -6346,6 +6891,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"]();
         }
@@ -10391,7 +10939,472 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
       if (modulePaths.length === 0) {
         return null;
       }
-      return this.moduleMetadata[modulePaths[0]];
+      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 = result._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();
+      }
+      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;
+      }
+
+      // 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: ["video:add-metadata"]
+        }];
+      }
+      return [];
     }
   }, {
     key: "executeAssert",
@@ -10424,7 +11437,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
           }])
         };
@@ -10437,19 +11450,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",
@@ -10459,6 +11472,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
@@ -10466,16 +11498,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",
@@ -10495,16 +11530,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
@@ -10514,27 +11549,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 = result._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;
 }
 
 /**
@@ -11516,6 +12661,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";
@@ -11523,7 +12761,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,
@@ -11535,14 +12797,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,
@@ -11550,7 +12813,8 @@ function initSchema() {
     locale: locale,
     route: route,
     router: router,
-    imageset: imageset,
+    imageset: media.imageset,
+    videoset: media.videoset,
     settings: settings
     // i18n: i18n(locales),
   };
@@ -11568,8 +12832,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 {
@@ -12359,6 +13626,43 @@ function computeSourcesSha(entries) {
   }
   return sourcesSha;
 }
+
+/**
+ * The `schemaSha` fold on its own: path and serialized schema, in `val.modules`
+ * order.
+ *
+ * Separate for the same reason as {@link computeSourcesSha}: the Studio folds
+ * the schemas of the bundle it is running and compares the answer with the
+ * `schemaSha` on `/stat`, which is how it learns that a new schema has been
+ * deployed under it. One implementation, so that comparison is between two
+ * runs of the same code.
+ */
+function computeSchemaSha(entries) {
+  var schemaSha = "";
+  var _iterator2 = result._createForOfIteratorHelper(entries),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _step2.value,
+        path = _step2$value.path,
+        serializedSchema = _step2$value.serializedSchema;
+      // The PATH is part of the schema set, not just the schema: renaming a
+      // module while leaving its schema byte-identical still changes which paths
+      // exist, and an open client keyed its schema cache by the old path. Hashing
+      // the schema alone left this SHA unchanged, so with no commitSha to fall
+      // back on the client never refetched /schema.
+      schemaSha = hash(schemaSha + JSON.stringify({
+        path: path,
+        schema: serializedSchema
+      }));
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return schemaSha;
+}
 function computeValModuleShas(config, entries, moduleErrors) {
   var configSha = hash(JSON.stringify(config));
   var sourcesSha = computeSourcesSha(entries);
@@ -12371,12 +13675,12 @@ function computeValModuleShas(config, entries, moduleErrors) {
   // `gitCommit: process.env.VERCEL_GIT_COMMIT_SHA` / `gitBranch`, which are
   // server-only env vars and therefore `undefined` in the browser. Seeding with
   // them made the two sides disagree on every production load.
-  var schemaSha = "";
-  var _iterator2 = result._createForOfIteratorHelper(entries),
-    _step2;
+  var schemaSha = computeSchemaSha(entries);
+  var _iterator3 = result._createForOfIteratorHelper(entries),
+    _step3;
   try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var entry = _step2.value;
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var entry = _step3.value;
       var path = entry.path,
         source = entry.source,
         serializedSchema = entry.serializedSchema;
@@ -12386,20 +13690,11 @@ function computeValModuleShas(config, entries, moduleErrors) {
         source: source,
         modulesErrors: moduleErrors.slice(0, entry.moduleErrorsAt)
       }));
-      // The PATH is part of the schema set, not just the schema: renaming a
-      // module while leaving its schema byte-identical still changes which paths
-      // exist, and an open client keyed its schema cache by the old path. Hashing
-      // the schema alone left this SHA unchanged, so with no commitSha to fall
-      // back on the client never refetched /schema.
-      schemaSha = hash(schemaSha + JSON.stringify({
-        path: path,
-        schema: serializedSchema
-      }));
     }
   } catch (err) {
-    _iterator2.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator2.f();
+    _iterator3.f();
   }
   return {
     baseSha: baseSha,
@@ -12421,7 +13716,7 @@ function extractValModules(_x) {
 }
 function _extractValModules() {
   _extractValModules = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(valModules) {
-    var moduleErrors, addModuleError, sources, schemas, serializedSchemas, shaEntries, moduleIdx, module, at, value, path, schema, source, serializedSchema, pathM, _iterator3, _step3, error, _iterator4, _step4, _error, _t, _t2;
+    var moduleErrors, addModuleError, sources, schemas, serializedSchemas, shaEntries, moduleIdx, module, at, value, path, schema, source, serializedSchema, pathM, _iterator4, _step4, error, _iterator5, _step5, _error, _t, _t2;
     return _regenerator().w(function (_context) {
       while (1) switch (_context.p = _context.n) {
         case 0:
@@ -12568,10 +13863,10 @@ function _extractValModules() {
           // Appended AFTER the loop on purpose: each entry's `moduleErrorsAt` is the
           // error count at the time it was folded in, so the SHAs stay a function of
           // the modules themselves.
-          _iterator3 = result._createForOfIteratorHelper(resolveSettingsModule(serializedSchemas).errors);
+          _iterator4 = result._createForOfIteratorHelper(resolveSettingsModule(serializedSchemas).errors);
           try {
-            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-              error = _step3.value;
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              error = _step4.value;
               moduleErrors.push(error);
             }
             // Same kind of rule, same reason it is here: a view cycle is a property of the
@@ -12579,20 +13874,20 @@ function _extractValModules() {
             // catches it either — a view stores a pointer, not content, so there is no
             // data cycle for a source walk to trip over.
           } catch (err) {
-            _iterator3.e(err);
+            _iterator4.e(err);
           } finally {
-            _iterator3.f();
+            _iterator4.f();
           }
-          _iterator4 = result._createForOfIteratorHelper(viewCycleErrors(serializedSchemas));
+          _iterator5 = result._createForOfIteratorHelper(viewCycleErrors(serializedSchemas));
           try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              _error = _step4.value;
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              _error = _step5.value;
               moduleErrors.push(_error);
             }
           } catch (err) {
-            _iterator4.e(err);
+            _iterator5.e(err);
           } finally {
-            _iterator4.f();
+            _iterator5.f();
           }
           return _context.a(2, _objectSpread2(_objectSpread2({
             sources: sources,
@@ -12642,7 +13937,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;
@@ -12721,7 +14016,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;
@@ -13087,6 +14382,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,
@@ -13106,6 +14405,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 = result._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.
  *
@@ -13311,7 +14697,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), {}, {
@@ -13370,6 +14756,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.
@@ -13395,6 +14783,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":
@@ -14090,7 +15484,7 @@ function isPageRouter(routerId) {
 
 var corePackageJson = {
 	name: "@valbuild/core",
-	version: "0.139.0",
+	version: "0.141.0",
 	"private": false,
 	description: "Val - supercharged hard-coded content",
 	repository: {
@@ -14179,6 +15573,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`.
@@ -14189,9 +15584,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,
@@ -14239,6 +15640,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,
@@ -14309,6 +15717,9 @@ exports.DEFAULT_COLOR_FORMAT = DEFAULT_COLOR_FORMAT;
 exports.DEFAULT_CONTENT_HOST = DEFAULT_CONTENT_HOST;
 exports.DEFAULT_STATIC_HOST = DEFAULT_STATIC_HOST;
 exports.DEFAULT_VAL_REMOTE_HOST = DEFAULT_VAL_REMOTE_HOST;
+exports.DEFAULT_VIDEO_ACCEPT = DEFAULT_VIDEO_ACCEPT;
+exports.DEFAULT_VIDEO_RENDITIONS = DEFAULT_VIDEO_RENDITIONS;
+exports.DEFAULT_VIDEO_SEGMENT_DURATION = DEFAULT_VIDEO_SEGMENT_DURATION;
 exports.DateSchema = DateSchema;
 exports.DateTimeSchema = DateTimeSchema;
 exports.DiscriminatedUnionSchema = DiscriminatedUnionSchema;
@@ -14338,12 +15749,14 @@ exports.THEME_RADIUS_STEPS = THEME_RADIUS_STEPS;
 exports.UNSAFE_URL_SCHEMES = UNSAFE_URL_SCHEMES;
 exports.VAL_EXTENSION = VAL_EXTENSION;
 exports.ValViewSchema = ValViewSchema;
+exports.VideoSchema = VideoSchema;
 exports._classCallCheck = _classCallCheck;
 exports._createClass = _createClass;
 exports._slicedToArray = _slicedToArray;
 exports._toConsumableArray = _toConsumableArray;
 exports._typeof = _typeof;
 exports.assistantAvailability = assistantAvailability;
+exports.computeSchemaSha = computeSchemaSha;
 exports.computeSourcesSha = computeSourcesSha;
 exports.computeValModuleShas = computeValModuleShas;
 exports.declaredKeySetOf = declaredKeySetOf;