@valbuild/core 0.141.0 → 0.144.0

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

@@ -2846,7 +2846,7 @@ var _excluded = ["poster", "captions"];
  * 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()`
+ * This is the whole value of a field picked from an `s.videodir()`
  * (`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
@@ -2858,7 +2858,7 @@ var _excluded = ["poster", "captions"];
 /**
  * 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
+ * (`s.videodir()`) carries them as DEFAULTS, which every field picked from the
  * set starts from and may override key by key. See {@link fillFromGallery}.
  */
 
@@ -3000,6 +3000,42 @@ function isMediaSchema(schema) {
   return _typeof(schema) === "object" && schema !== null && "type" in schema && (schema.type === "image" || schema.type === "file" || schema.type === "video");
 }
 
+/**
+ * The key of a gallery (an `s.imagedir()`, `s.filedir()` or `s.videodir()`)
+ * that a field's `path` names, or `null` when it names none.
+ *
+ * Usually the path IS the key. It is not for an image uploaded THROUGH an
+ * `s.image(remoteGallery)` field in the Studio, which stores the remote ref in
+ * the field and keys the entry by the local path inside it — so a path that is
+ * not a key falls back to that embedded path. Exact first, because a gallery
+ * can hold both shapes for one file, and the field then names the entry that
+ * IS its path.
+ *
+ * One implementation of the question, asked by everything that has to agree on
+ * the answer: reading a field (`galleryEntryOf`), validating it (`ImageSchema`
+ * and `FileSchema` ask whether the gallery has it), the Studio's reference
+ * scans and renames, and `val validate --fix` when it renames a key and has to
+ * find the fields that hold it.
+ *
+ * The embedded path is tried with its leading slash (how a key is written) and
+ * without (how `splitRemoteRef` returns it).
+ */
+function galleryKeyOf(path, isKey) {
+  if (isKey(path)) {
+    return path;
+  }
+  var split = splitRemoteRef(path);
+  if (split.status === "success") {
+    for (var _i = 0, _arr = ["/".concat(split.filePath), split.filePath]; _i < _arr.length; _i++) {
+      var embedded = _arr[_i];
+      if (isKey(embedded)) {
+        return embedded;
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * What a gallery entry holds as a DEFAULT for the fields picked from it, in
  * the groups a field overrides together.
@@ -3019,7 +3055,9 @@ var GALLERY_FILE_FACTS = ["width", "height", "mimeType", "duration"];
  * 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.
+ * remote URL while the file itself stays on disk under its local path, and an
+ * upload through the field does it the other way round (see
+ * {@link galleryKeyOf}).
  */
 function galleryEntryOf(src, schema, getModuleSource) {
   if (!isMediaSchema(schema) || !schema.referencedModule) {
@@ -3029,13 +3067,9 @@ function galleryEntryOf(src, schema, getModuleSource) {
   if (!isPlainObject(moduleSource)) {
     return 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 moduleSource) {
-      key = splitRemoteRefRes.filePath;
-    }
-  }
+  var key = galleryKeyOf(src.path, function (candidate) {
+    return candidate in moduleSource;
+  });
   if (key === null) {
     return null;
   }
@@ -3604,7 +3638,7 @@ var EXT_TO_MIME_TYPES = {
   sxw: "application/vnd.sun.xml.writer",
   sxg: "application/vnd.sun.xml.writer.global",
   stw: "application/vnd.sun.xml.writer.template",
-  otf: "application/x-font-otf",
+  otf: "font/otf",
   osfpvg: "application/vnd.yamaha.openscoreformat.osfpvg+xml",
   dp: "application/vnd.osgi.dp",
   pdb: "application/vnd.palm",
@@ -3754,7 +3788,8 @@ var EXT_TO_MIME_TYPES = {
   mxs: "application/vnd.triscape.mxs",
   t: "text/troff",
   tra: "application/vnd.trueapp",
-  ttf: "application/x-font-ttf",
+  ttf: "font/ttf",
+  ttc: "font/collection",
   ttl: "text/turtle",
   umj: "application/vnd.umajin",
   uoml: "application/vnd.uoml+xml",
@@ -3781,7 +3816,8 @@ var EXT_TO_MIME_TYPES = {
   wbmp: "image/vnd.wap.wbmp",
   wav: "audio/x-wav",
   davmount: "application/davmount+xml",
-  woff: "application/x-font-woff",
+  woff: "font/woff",
+  woff2: "font/woff2",
   wspolicy: "application/wspolicy+xml",
   webp: "image/webp",
   wtb: "application/vnd.webturbo",
@@ -3883,6 +3919,93 @@ function mimeTypeMatchesAccept(mimeType, accept) {
   });
 }
 
+/**
+ * Fonts, as far as a mime type can tell.
+ *
+ * The four web formats have IANA types under `font/` (RFC 8081), and those are
+ * what Val stores. Browsers and operating systems disagree about them: a file
+ * picker reports `.woff2` as `font/woff2`, `application/font-woff2` or nothing
+ * at all depending on the platform, and nothing at all reads as
+ * `application/octet-stream` once the file is a data URL. That is why an upload
+ * asks the BYTES ({@link sniffFontMimeType}) rather than trusting the picker.
+ */
+
+/** The formats `s.fontdir()` accepts unless told otherwise, best first. */
+var FONT_MIME_TYPES = ["font/woff2", "font/woff", "font/ttf", "font/otf"];
+
+/** `s.fontdir()`'s `accept` when none is given. */
+var DEFAULT_FONT_ACCEPT = FONT_MIME_TYPES.join(",");
+
+/**
+ * The extension of each font type, for a file input: a picker matches an
+ * `accept` of mime types through the operating system's own table, and where
+ * that table does not know `font/woff2` the file is greyed out.
+ */
+var FONT_MIME_TYPE_EXTENSIONS = {
+  "font/woff2": ".woff2",
+  "font/woff": ".woff",
+  "font/ttf": ".ttf",
+  "font/otf": ".otf",
+  "font/collection": ".ttc"
+};
+
+/**
+ * The names the extension table used for fonts before it used RFC 8081's.
+ * Content written then still carries them, and it is the same file.
+ */
+var LEGACY_FONT_MIME_TYPES = {
+  "application/x-font-ttf": "font/ttf",
+  "application/x-font-otf": "font/otf",
+  "application/x-font-woff": "font/woff"
+};
+
+/** `mimeType`, with a legacy font name read as its `font/` type. */
+function canonicalFontMimeType(mimeType) {
+  var _LEGACY_FONT_MIME_TYP;
+  return (_LEGACY_FONT_MIME_TYP = LEGACY_FONT_MIME_TYPES[mimeType]) !== null && _LEGACY_FONT_MIME_TYP !== void 0 ? _LEGACY_FONT_MIME_TYP : mimeType;
+}
+
+/**
+ * Whether a file of `mimeType` is a font a browser can draw: the `font/` types,
+ * and the pre-RFC 8081 names still found in older data.
+ */
+function isFontMimeType(mimeType) {
+  if (!mimeType) {
+    return false;
+  }
+  return mimeType.startsWith("font/") || mimeType.startsWith("application/x-font-") || mimeType === "application/font-woff" || mimeType === "application/font-woff2" || mimeType === "application/font-sfnt" || mimeType === "application/vnd.ms-opentype";
+}
+
+/**
+ * The font type of `bytes`, read from the signature every font format starts
+ * with, or `null` when they are not a font.
+ *
+ * Only the first four bytes are needed: the WOFF signatures (`wOFF`, `wOF2`),
+ * the SFNT versions of TrueType (`0x00010000`, or `true` from old Apple fonts)
+ * and of CFF-flavoured OpenType (`OTTO`), and a collection's tag (`ttcf`).
+ */
+function sniffFontMimeType(bytes) {
+  if (bytes.length < 4) {
+    return null;
+  }
+  var tag = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+  switch (tag) {
+    case "wOF2":
+      return "font/woff2";
+    case "wOFF":
+      return "font/woff";
+    case "OTTO":
+      return "font/otf";
+    case "true":
+    case "\0\x01\0\0":
+      return "font/ttf";
+    case "ttcf":
+      return "font/collection";
+    default:
+      return null;
+  }
+}
+
 /**
  * How an uploaded image is re-encoded in the browser, before it is uploaded.
  *
@@ -4049,24 +4172,31 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]));
       }
+      // A field picked from a gallery holds the gallery's KEY, and whether that
+      // key is a local path or a remote ref is the gallery's to decide — and its
+      // to fix: uploading an entry renames its key, and the fields that hold it
+      // with it. So such a field only asks whether the gallery has it, below.
+      // Asking here as well reported every image picked from a `.remote()`
+      // gallery as one to download, because the field itself is never remote.
+      var galleryEntries = this.galleryEntries();
       // Remote-ness is a property of the path, not of a marker on the value:
       // anything outside /public is remote.
       var isRemotePath = isRemoteMediaPath(src.path);
-      if (this.isRemote && !isRemotePath) {
+      if (!galleryEntries && this.isRemote && !isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected a remote image, but got a local image.",
           value: src,
           fixes: ["image:upload-remote"]
         }]));
       }
-      if (this.isRemote && isRemotePath) {
+      if (!galleryEntries && this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Remote image was not checked.",
           value: src,
           fixes: ["image:check-remote"]
         }]));
       }
-      if (!this.isRemote && isRemotePath) {
+      if (!galleryEntries && !this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected local image, but found remote.",
           value: src,
@@ -4081,7 +4211,6 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
           }]));
         }
       }
-      var galleryEntries = this.galleryEntries();
       if (galleryEntries) {
         // The dimensions and mime type of a gallery image are stored once, in the
         // gallery. Repeating them on the field is how the two get to disagree.
@@ -4094,7 +4223,11 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
             value: src
           }]));
         }
-        if (!(src.path in galleryEntries)) {
+        // The same match reading the field makes (`fillFromGallery`): the key,
+        // or the local path inside a ref an upload through the field stored.
+        if (galleryKeyOf(src.path, function (key) {
+          return key in galleryEntries;
+        }) === null) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
             message: "The gallery does not have an image at '".concat(src.path, "'."),
             value: src
@@ -5711,7 +5844,7 @@ 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
+ * field (`s.video()`) and the entry of a set (`s.videodir()`), which holds the
  * same choices as the defaults every field picked from it starts from.
  */
 
@@ -5889,7 +6022,25 @@ function isObject(value) {
   return _typeof(value) === "object" && value !== null && !Array.isArray(value);
 }
 
-/** What a media collection (`s.imageset`, `s.fileset`, `s.videoset`) holds. */
+/** What a media collection (`s.imagedir`, `s.filedir`, `s.videodir`) holds. */
+
+/**
+ * Where a media collection keeps its files: the first argument of
+ * `s.imagedir()`, `s.filedir()`, `s.fontdir()` and `s.videodir()`.
+ *
+ * Required, and deliberately so: it decides where every uploaded file in the
+ * collection lands. It used to default to "/public/val", which meant a
+ * collection that had simply not said where it wanted its files silently
+ * shared a directory with every other one. It is the first argument rather
+ * than an option because it is the one thing every collection has to say.
+ */
+
+/** The factory that builds a media collection of each type, for messages. */
+var mediaDirFactory = {
+  images: "imagedir",
+  files: "filedir",
+  videos: "videodir"
+};
 
 /**
  * The fix code a media collection of `type` reports for `check`.
@@ -5924,7 +6075,7 @@ function assertRenderable(router, mediaOptions, render) {
     throw new Error("`.render(...)` is not supported on `s.router(...)`: a router's entries are pages, which have their own UI.");
   }
   if (mediaOptions) {
-    throw new Error("`.render(...)` is not supported on `s.".concat(mediaOptions.type === "images" ? "imageset" : "fileset", "(...)`: media galleries have their own UI."));
+    throw new Error("`.render(...)` is not supported on `s.".concat(mediaDirFactory[mediaOptions.type], "(...)`: media galleries have their own UI."));
   }
 }
 
@@ -6641,7 +6792,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * Allow the files in this gallery to be stored on Val's remote content host
      * instead of in your repository.
      *
-     * For `s.imageset()` and `s.fileset()`, which are records of media. Remote is off
+     * For `s.imagedir()` and `s.filedir()`, which are records of media. Remote is off
      * until this is called.
      *
      * Each entry is then keyed by its URL on the content host rather than by a
@@ -6650,7 +6801,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * upload it and rewrite the key.
      *
      * @example
-     * const schema = s.imageset({ dir: "/public/val/images" }).remote();
+     * const schema = s.imagedir("/public/val/images").remote();
      * export default c.define("/content/images.val.ts", schema, {
      *   "https://remote.val.build/file/p/my-project/b/01/v/1.0.0/h/8f2a1c/f/3b9d70/p/public/val/images/hero.webp":
      *     {
@@ -6676,7 +6827,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * which lets the runtime, the Studio and validation work one entry at a time
      * so a record/router can scale to many thousands of entries.
      *
-     * Not supported on image/file galleries (`s.imageset()` / `s.fileset()`).
+     * Not supported on image/file galleries (`s.imagedir()` / `s.filedir()`).
      *
      * Only supported on a module's ROOT record/router — a `.jsonValues()` record
      * nested inside an object/array/record is rejected at startup with a module
@@ -6701,7 +6852,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     key: "jsonValues",
     value: function jsonValues() {
       if (this.mediaOptions) {
-        throw new Error(".jsonValues() cannot be used with image/file galleries (s.imageset()/s.fileset())");
+        throw new Error(".jsonValues() cannot be used with image/file galleries (s.imagedir()/s.filedir())");
       }
       if (this.customValidateFunctions.length > 0) {
         // `.jsonValues()` changes the source shape to JsonSource entries, so a
@@ -6730,7 +6881,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * bucket — instead of in the module.
      *
      * Available on every record-derived schema, which is `s.record()`,
-     * `s.router()`, `s.imageset()` and `s.fileset()` alike: a router is a
+     * `s.router()`, `s.imagedir()` and `s.filedir()` alike: a router is a
      * `RecordSchema` with a `ValRouter`, a gallery one with media options, so all
      * four get external storage from this one method.
      *
@@ -7060,7 +7211,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * draws each entry's own editor in place, labelled by its key, instead of a
      * preview row that navigates to it. It reaches the direct entries only.
      *
-     * Not for `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`: pages and
+     * Not for `s.router(...)`, `s.imagedir(...)` or `s.filedir(...)`: pages and
      * media have UIs of their own, so this throws on them.
      *
      * Static configuration, not a callback — see `render.ts`.
@@ -10833,31 +10984,37 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]));
       }
+      // A field picked from a gallery holds the gallery's KEY, and whether that
+      // key is a local path or a remote ref is the gallery's to decide — and its
+      // to fix: uploading an entry renames its key, and the fields that hold it
+      // with it. So such a field only asks whether the gallery has it, below.
+      // Asking here as well reported every file picked from a `.remote()`
+      // gallery as one to download, because the field itself is never remote.
+      var galleryEntries = this.galleryEntries();
       // Remote-ness is a property of the path, not of a marker on the value:
       // anything outside /public is remote.
       var isRemotePath = isRemoteMediaPath(src.path);
-      if (this.isRemote && !isRemotePath) {
+      if (!galleryEntries && this.isRemote && !isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected a remote file, but got a local file.",
           value: src,
           fixes: ["file:upload-remote"]
         }]));
       }
-      if (this.isRemote && isRemotePath) {
+      if (!galleryEntries && this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Remote file was not checked.",
           value: src,
           fixes: ["file:check-remote"]
         }]));
       }
-      if (!this.isRemote && isRemotePath) {
+      if (!galleryEntries && !this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected local file, but found remote.",
           value: src,
           fixes: ["file:download-remote"]
         }]));
       }
-      var galleryEntries = this.galleryEntries();
       if (galleryEntries) {
         if (src.mimeType !== undefined) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
@@ -10865,7 +11022,11 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
             value: src
           }]));
         }
-        if (!(src.path in galleryEntries)) {
+        // The same match reading the field makes (`fillFromGallery`): the key,
+        // or the local path inside a ref an upload through the field stored.
+        if (galleryKeyOf(src.path, function (key) {
+          return key in galleryEntries;
+        }) === null) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
             message: "The gallery does not have a file at '".concat(src.path, "'."),
             value: src
@@ -10904,7 +11065,9 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
       // fix was offered -- and the `file:add-metadata` branch below could never be
       // reached for any file whose extension is recognized, which is all of them
       // that get this far.
-      if (mimeType && fileMimeType !== mimeType) {
+      // A legacy font name (`application/x-font-ttf`) is what the extension
+      // table itself used to say, so it is not a mismatch.
+      if (mimeType && fileMimeType !== canonicalFontMimeType(mimeType)) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Mime type and file extension not matching. Mime type is '".concat(mimeType, "' but file extension is '").concat(fileMimeType, "'"),
           value: src
@@ -11098,6 +11261,38 @@ function fileOf(remote, options) {
   return new FileSchema(options, false, remote);
 }
 
+/**
+ * A font picked from an `s.fontdir()`.
+ *
+ * The same field `s.file(fontsVal)` is — it stores `{ path }` and serializes
+ * identically — with one thing more: it refuses a set that is not a font set,
+ * at definition, so a field called a font cannot end up offering PDFs. What the
+ * Studio does with it (a specimen in its parent, the set to pick from when
+ * opened) it does for any file field backed by a font set.
+ */
+function font(fontsetModule) {
+  assertFontset(fontsetModule);
+  return file(fontsetModule);
+}
+
+/** `s.font()` with `.remote()` applied: see `files.remote` in `initSchema`. */
+function remoteFont(fontsetModule) {
+  assertFontset(fontsetModule);
+  return remoteFile(fontsetModule);
+}
+function assertFontset(fontsetModule) {
+  var _getSchema;
+  var modulePath = getValPath(fontsetModule);
+  var serialized = (_getSchema = getSchema(fontsetModule)) === null || _getSchema === void 0 ? void 0 : _getSchema["executeSerialize"]();
+  var accept = (serialized === null || serialized === void 0 ? void 0 : serialized.type) === "record" && serialized.mediaType === "files" ? serialized.accept : undefined;
+  var isFontset = !!accept && accept.split(",").every(function (type) {
+    return isFontMimeType(type.trim());
+  });
+  if (!isFontset) {
+    throw new Error("s.font(".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "?", "): the module must be an s.fontdir(). Use s.file() to pick from a set of other files."));
+  }
+}
+
 /**
  * Turn an upload into an HLS stream, in the browser, before it is uploaded.
  *
@@ -11633,7 +11828,7 @@ function stripQuery(path) {
 }
 
 /**
- * A video picked from a set (`s.videoset()`). What is true of the file —
+ * A video picked from a set (`s.videodir()`). What is true of the file —
  * its type, size and length — lives in the set; the field carries what one
  * page chose about it.
  */
@@ -11668,7 +11863,7 @@ function videoOf(options, galleryOptions) {
   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", "."));
+    throw new Error("s.video(".concat(modulePath, "): the module must be an s.videodir(). 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
@@ -11683,23 +11878,37 @@ function isVideosetModule(value) {
 }
 
 /**
- * Options for s.fileset()
+ * Options for `s.filedir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.fileset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.filedir(dir, options)` and `FiledirOptions`.
  */
 
 /**
  * Metadata for a file entry in the files record
  */
 
+/** @deprecated Use `FiledirEntryMetadata`. */
+
+/** @deprecated Use `SerializedFiledirSchema`. */
+
 /**
- * Define a collection of files.
+ * Define a directory of files: a whole module that holds many files, keyed by
+ * their file path, that fields pick from with `s.file(filesVal)`.
  *
- * Remote is off by default: call `.remote()` on the result to allow remote files.
+ * The directory is the first argument and is required — it decides where
+ * uploads land. Remote is off by default: call `.remote()` on the result to
+ * allow remote files.
  *
  * @example
  * ```typescript
- * const schema = s.fileset({
+ * const schema = s.filedir("/public/val/documents", {
  *   accept: "application/pdf",
- *   dir: "/public/val/documents",
  * });
  * export default c.define("/content/documents.val.ts", schema, {
  *   "/public/val/documents/report.pdf": {
@@ -11708,8 +11917,7 @@ function isVideosetModule(value) {
  * });
  * ```
  */
-var fileset = function fileset(options) {
-  var dir = options.dir;
+var filedir = function filedir(dir, options) {
   var itemSchema = new ObjectSchema({
     mimeType: new StringSchema({}, false)
   }, false);
@@ -11721,6 +11929,91 @@ var fileset = function fileset(options) {
   });
 };
 
+/**
+ * Define a collection of files.
+ *
+ * @deprecated Use `s.filedir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.fileset({ dir: "/public/val/documents", accept: "application/pdf" })
+ * const schema = s.filedir("/public/val/documents", {
+ *   accept: "application/pdf",
+ * });
+ * ```
+ */
+var fileset = function fileset(options) {
+  return filedir(options.dir, options);
+};
+
+/**
+ * Options for `s.fontdir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.fontset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.fontdir(dir, options)` and `FontdirOptions`.
+ */
+
+/**
+ * Define a directory of fonts.
+ *
+ * A fontdir IS a filedir — the same source, the same `s.font(fontsVal)` field
+ * to pick from it, the same checks and fixes — with `accept` defaulting to the
+ * web font formats. What a font gets that any other file does not is decided
+ * by its mime type rather than by the directory: the Studio previews any file
+ * it knows is a font, wherever it is shown.
+ *
+ * Remote is off by default: call `.remote()` on the result to allow remote files.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.fontdir("/public/val/fonts");
+ * export default c.define("/content/fonts.val.ts", schema, {
+ *   "/public/val/fonts/inter_a1b2c.woff2": {
+ *     mimeType: "font/woff2",
+ *   },
+ * });
+ * ```
+ */
+var fontdir = function fontdir(dir, options) {
+  var _options$accept;
+  var accept = (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_FONT_ACCEPT;
+  var notFonts = accept.split(",").map(function (type) {
+    return type.trim();
+  }).filter(function (type) {
+    return !isFontMimeType(type);
+  });
+  if (notFonts.length > 0) {
+    // A fontdir that took a PDF would be a filedir under a name that says
+    // otherwise, and the Studio would draw a specimen of nothing.
+    throw new Error("s.fontdir(): 'accept' may only name font types (font/woff2, font/woff, font/ttf, font/otf or font/*). Got: ".concat(notFonts.join(", "), ". Use s.filedir() for other files."));
+  }
+  return filedir(dir, {
+    accept: accept
+  });
+};
+
+/**
+ * Define a collection of fonts.
+ *
+ * @deprecated Use `s.fontdir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.fontset({ dir: "/public/val/fonts" })
+ * const schema = s.fontdir("/public/val/fonts");
+ * ```
+ */
+var fontset = function fontset(options) {
+  return fontdir(options.dir, options);
+};
+
 var DateSchema = /*#__PURE__*/function (_Schema) {
   function DateSchema(options) {
     var _this;
@@ -12587,39 +12880,58 @@ function router(router, keyOrItem, maybeItem) {
 /** Every `alt` value any `AltSchema` can produce. */
 
 /**
- * Options for s.imageset()
+ * Options for `s.imagedir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.imageset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.imagedir(dir, options)` and `ImagedirOptions`.
  */
 
 /**
  * `alt` is optional only when it is the default schema.
  *
  * Naming a different `Alt` and then leaving `alt` out would make the fallback
- * in `imageset()` a lie — `Alt` would say `s.string()` while the value was a
+ * in `imagedir()` a lie — `Alt` would say `s.string()` while the value was a
  * nullable one. Requiring it in that case is what makes the fallback sound:
  * the branch that uses it is reachable only when `Alt` IS the default.
  */
 
+/**
+ * The options argument of `s.imagedir()`: optional only when `alt` is, for
+ * the reason `ImagedirAltOption` gives — leaving the whole object out leaves
+ * `alt` out with it.
+ */
+
 /**
  * Metadata for an image entry in the images record.
  *
  * `alt` follows the schema's `alt` option, so it defaults to `string | null`
  * and becomes `string` under `s.string()` or `Record<string, string>` under
- * `s.record(s.string())`. Write `ImagesetEntryMetadata<AltSource>` where a
+ * `s.record(s.string())`. Write `ImagedirEntryMetadata<AltSource>` where a
  * gallery of any alt shape is acceptable.
  */
 
+/** @deprecated Use `ImagedirEntryMetadata`. */
+
+/** @deprecated Use `SerializedImagedirSchema`. */
+
 /**
- * Define a collection of images.
+ * Define a directory of images: a whole module that holds many images, keyed
+ * by their file path, that fields pick from with `s.image(galleryVal)`.
  *
- * `directory` is required — it decides where uploads land, so it is not something
- * to be inferred. The rest defaults: any image type (`"image/*"`), nullable alt
- * text, remote disabled. Call `.remote()` on the result to allow remote images.
+ * The directory is the first argument and is required — it decides where
+ * uploads land, so it is not something to be inferred. The rest defaults: any
+ * image type (`"image/*"`), nullable alt text, remote disabled. Call
+ * `.remote()` on the result to allow remote images.
  *
  * @example
  * ```typescript
- * const schema = s.imageset({
+ * const schema = s.imagedir("/public/val/images", {
  *   accept: "image/webp",
- *   dir: "/public/val/images",
  *   alt: s.string().minLength(4),
  * });
  * export default c.define("/content/images.val.ts", schema, {
@@ -12632,19 +12944,26 @@ function router(router, keyOrItem, maybeItem) {
  * });
  * ```
  */
-var imageset = function imageset(options) {
+var imagedir = function imagedir(dir) {
+  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    _ref[_key - 1] = arguments[_key];
+  }
+  var options = _ref[0];
+  return imagedirOf(dir, options);
+};
+function imagedirOf(dir, options) {
   var _options$alt, _options$accept;
-  var dir = options.dir;
-  // `options.alt` is `Alt | undefined`, and the fallback is exactly the schema
+  // `options?.alt` is `Alt | undefined`, and the fallback is exactly the schema
   // `Alt` defaults to when `alt` is omitted. TypeScript will not narrow a type
   // parameter from the absence of a value, so it cannot see that the two agree,
   // and the fallback is asserted here.
   //
-  // Sound, not merely convenient: `ImagesetAltOption` makes `alt` REQUIRED
-  // unless `Alt` is the default, so this branch is unreachable for any other
+  // Sound, not merely convenient: `ImagedirAltOption` makes `alt` REQUIRED
+  // unless `Alt` is the default, and `ImagedirOptionsArg` makes the options
+  // object required with it, so this branch is unreachable for any other
   // `Alt`. The one assertion in this file, and it replaces the wider one that
   // used to sit on the ObjectSchema below.
-  var altSchema = (_options$alt = options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
+  var altSchema = (_options$alt = options === null || options === void 0 ? void 0 : options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
   var itemSchema = new ObjectSchema({
     width: new NumberSchema(undefined, false),
     height: new NumberSchema(undefined, false),
@@ -12653,19 +12972,57 @@ var imageset = function imageset(options) {
   }, false);
   return new RecordSchema(itemSchema, false, [], null, null, {
     type: "images",
-    accept: (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
+    accept: (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
     dir: dir,
     remote: false,
     altSchema: altSchema,
-    encode: options.encode
+    encode: options === null || options === void 0 ? void 0 : options.encode
   });
+}
+
+/**
+ * `s.imagedir()` with `.remote()` applied: what `s.imagedir` is under
+ * `files: { remote: true }`.
+ */
+var remoteImagedir = function remoteImagedir(dir) {
+  for (var _len2 = arguments.length, _ref2 = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    _ref2[_key2 - 1] = arguments[_key2];
+  }
+  var options = _ref2[0];
+  return imagedirOf(dir, options).remote();
 };
 
 /**
- * Options for s.videoset()
+ * Define a collection of images.
+ *
+ * @deprecated Use `s.imagedir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.imageset({ dir: "/public/val/images", accept: "image/webp" })
+ * const schema = s.imagedir("/public/val/images", { accept: "image/webp" });
+ * ```
  */
+var imageset = function imageset(options) {
+  return imagedirOf(options.dir, options);
+};
 
-/** See `ImagesetAltOption`: `alt` is optional only when it is the default. */
+/**
+ * Options for `s.videodir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.videoset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.videodir(dir, options)` and `VideodirOptions`.
+ */
+
+/** See `ImagedirAltOption`: `alt` is optional only when it is the default. */
+
+/** See `ImagedirOptionsArg`: the options are optional only when `alt` is. */
 
 /**
  * One video of a set, keyed by its file path (an HLS stream by its master
@@ -12683,19 +13040,22 @@ var imageset = function imageset(options) {
  * still for the gallery, because two stills of one video would disagree.
  */
 
+/** @deprecated Use `VideodirEntryMetadata`. */
+
+/** @deprecated Use `SerializedVideodirSchema`. */
+
 /**
- * Define a collection of videos — the video twin of `s.imageset()`.
+ * Define a directory of videos — the video twin of `s.imagedir()`.
  *
  * 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.
+ * field adds to the directory. Call `.remote()` on the result to store the
+ * videos on Val Remote.
  *
  * @example
  * ```typescript
- * const schema = s.videoset({
- *   dir: "/public/val/videos",
+ * const schema = s.videodir("/public/val/videos", {
  *   stream: { type: "hls" },
  * });
  * export default c.define("/content/videos.val.ts", schema, {
@@ -12710,11 +13070,46 @@ var imageset = function imageset(options) {
  * });
  * ```
  */
+var videodir = function videodir(dir) {
+  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    _ref[_key - 1] = arguments[_key];
+  }
+  var options = _ref[0];
+  return videodirOf(dir, options);
+};
+
+/**
+ * `s.videodir()` with `.remote()` applied: what `s.videodir` is under
+ * `files: { remote: true }`.
+ */
+var remoteVideodir = function remoteVideodir(dir) {
+  for (var _len2 = arguments.length, _ref2 = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    _ref2[_key2 - 1] = arguments[_key2];
+  }
+  var options = _ref2[0];
+  return videodirOf(dir, options).remote();
+};
+
+/**
+ * Define a collection of videos.
+ *
+ * @deprecated Use `s.videodir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.videoset({ dir: "/public/val/videos", stream: { type: "hls" } })
+ * const schema = s.videodir("/public/val/videos", { stream: { type: "hls" } });
+ * ```
+ */
 var videoset = function videoset(options) {
+  return videodirOf(options.dir, options);
+};
+function videodirOf(dir, 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();
+  // The same assertion as in `imagedir()`, and sound for the same reason:
+  // `VideodirAltOption` makes `alt` required unless `Alt` is the default.
+  var altSchema = (_options$alt = options === null || options === void 0 ? void 0 : options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
   var itemSchema = new ObjectSchema({
     mimeType: new StringSchema({}, false),
     width: new NumberSchema(undefined, false),
@@ -12724,13 +13119,13 @@ var videoset = function videoset(options) {
   }, 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,
+    accept: (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_VIDEO_ACCEPT,
+    dir: dir,
     remote: false,
     altSchema: altSchema,
-    stream: options.stream
+    stream: options === null || options === void 0 ? void 0 : options.stream
   });
-};
+}
 
 /**
  * The video schema a set's entry is hashed against, for a remote ref.
@@ -12766,24 +13161,42 @@ function initSchema(options) {
   var media = (options === null || options === void 0 ? void 0 : options.remote) === true ? {
     image: remoteImage,
     file: remoteFile,
+    font: remoteFont,
     video: remoteVideo,
     richtext: remoteRichtext,
+    imagedir: remoteImagedir,
+    filedir: function (dir, options) {
+      return filedir(dir, options).remote();
+    },
+    fontdir: function (dir, options) {
+      return fontdir(dir, options).remote();
+    },
+    videodir: remoteVideodir,
     imageset: function (options) {
       return imageset(options).remote();
     },
     fileset: function (options) {
       return fileset(options).remote();
     },
+    fontset: function (options) {
+      return fontset(options).remote();
+    },
     videoset: function (options) {
       return videoset(options).remote();
     }
   } : {
     image: image,
     file: file,
+    font: font,
     video: video,
     richtext: richtext,
+    imagedir: imagedir,
+    filedir: filedir,
+    fontdir: fontdir,
+    videodir: videodir,
     imageset: imageset,
     fileset: fileset,
+    fontset: fontset,
     videoset: videoset
   };
   // locales: F.Narrow<Locales>
@@ -12804,8 +13217,12 @@ function initSchema(options) {
     view: view,
     record: record,
     file: media.file,
+    font: media.font,
     video: media.video,
+    filedir: media.filedir,
+    fontdir: media.fontdir,
     fileset: media.fileset,
+    fontset: media.fontset,
     date: date,
     datetime: datetime,
     color: color,
@@ -12813,6 +13230,8 @@ function initSchema(options) {
     locale: locale,
     route: route,
     router: router,
+    imagedir: media.imagedir,
+    videodir: media.videodir,
     imageset: media.imageset,
     videoset: media.videoset,
     settings: settings
@@ -13909,7 +14328,7 @@ function _extractValModules() {
  * The one answer to that question. There used to be two — `hasRemoteFileSchema`
  * in the server, gating whether `/save` demands remote credentials, and
  * `findRequiredRemoteFiles` in the Studio, gating the `/remote/settings` fetch —
- * and they disagreed about `s.imageset({ ... }).remote()`: the Studio's version
+ * and they disagreed about `s.imagedir(dir, { ... }).remote()`: the Studio's version
  * counted a remote media record, the server's did not, because a media
  * collection serializes as a `record` of metadata rather than as an image
  * schema.
@@ -13949,7 +14368,7 @@ function hasRemoteFileSchema(schema) {
     return hasRemoteFileSchema(schema.item);
   } else if (schema.type === "record") {
     /**
-     * A media collection — `s.imageset()` / `s.fileset()` — is the case both of the
+     * A media collection — `s.imagedir()` / `s.filedir()` — is the case both of the
      * old functions were written around, and the one they disagreed on.
      *
      * It has no file or image schema inside it to find: `item` is an object of
@@ -14009,8 +14428,8 @@ function hasRemoteFileSchema(schema) {
  *
  * It is a walk over the SERIALIZED schema for the reasons given above, and for
  * one more that is specific to this question: the two cases most likely to be
- * missed are invisible to a value type. A media collection (`s.imageset()` /
- * `s.fileset()`) serializes as a record of metadata with no image schema inside
+ * missed are invisible to a value type. A media collection (`s.imagedir()` /
+ * `s.filedir()`) serializes as a record of metadata with no image schema inside
  * it, and a richtext inline image lives in a constructor argument. A check
  * written against the item TYPE would silently pass both — and the gallery case
  * already has a data-loss incident attached to it (see above).
@@ -14891,7 +15310,7 @@ function deserializeSchemaImpl(serialized) {
  * `s.array(s.object({ tags: s.array(s.string()) })).render({ as: "inline" })`
  * the objects are inline and `tags` keeps its own default.
  *
- * Not available on `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`:
+ * Not available on `s.router(...)`, `s.imagedir(...)` or `s.filedir(...)`:
  * pages and media have UIs of their own, and `RecordSchema.render` throws there.
  *
  * On `s.keyOf(...)` the same value means something else: the selected entry's
@@ -15484,7 +15903,7 @@ function isPageRouter(routerId) {
 
 var corePackageJson = {
 	name: "@valbuild/core",
-	version: "0.141.0",
+	version: "0.144.0",
 	"private": false,
 	description: "Val - supercharged hard-coded content",
 	repository: {
@@ -15590,6 +16009,7 @@ var Internal = {
     fillFromGallery: fillFromGallery,
     galleriesOf: galleriesOf,
     galleryEntryOf: galleryEntryOf,
+    galleryKeyOf: galleryKeyOf,
     GALLERY_DEFAULT_GROUPS: GALLERY_DEFAULT_GROUPS,
     isHlsVideo: isHlsVideo,
     HLS_MIME_TYPE: HLS_MIME_TYPE
@@ -15654,6 +16074,9 @@ var Internal = {
   mimeTypeMatchesAccept: mimeTypeMatchesAccept,
   EXT_TO_MIME_TYPES: EXT_TO_MIME_TYPES,
   MIME_TYPES_TO_EXT: MIME_TYPES_TO_EXT,
+  FONT_MIME_TYPE_EXTENSIONS: FONT_MIME_TYPE_EXTENSIONS,
+  isFontMimeType: isFontMimeType,
+  sniffFontMimeType: sniffFontMimeType,
   ModuleFilePathSep: ModuleFilePathSep,
   notFileOp: function notFileOp(op) {
     return op.op !== "file";
@@ -15715,6 +16138,7 @@ exports.ColorSchema = ColorSchema;
 exports.DEFAULT_APP_HOST = DEFAULT_APP_HOST;
 exports.DEFAULT_COLOR_FORMAT = DEFAULT_COLOR_FORMAT;
 exports.DEFAULT_CONTENT_HOST = DEFAULT_CONTENT_HOST;
+exports.DEFAULT_FONT_ACCEPT = DEFAULT_FONT_ACCEPT;
 exports.DEFAULT_STATIC_HOST = DEFAULT_STATIC_HOST;
 exports.DEFAULT_VAL_REMOTE_HOST = DEFAULT_VAL_REMOTE_HOST;
 exports.DEFAULT_VIDEO_ACCEPT = DEFAULT_VIDEO_ACCEPT;
@@ -15725,6 +16149,7 @@ exports.DateTimeSchema = DateTimeSchema;
 exports.DiscriminatedUnionSchema = DiscriminatedUnionSchema;
 exports.EnumSchema = EnumSchema;
 exports.FATAL_ERROR_TYPES = FATAL_ERROR_TYPES;
+exports.FONT_MIME_TYPES = FONT_MIME_TYPES;
 exports.FileSchema = FileSchema;
 exports.GenericSelector = GenericSelector;
 exports.ImageSchema = ImageSchema;