@valbuild/core 0.141.0 → 0.144.0

package/CHANGELOG.md

@@ -1,5 +1,72 @@
 # @valbuild/core
 
+## 0.144.0
+
+### Minor Changes
+
+- [#826](https://github.com/valbuild/val/pull/826) [`860ab2b`](https://github.com/valbuild/val/commit/860ab2b87333daf95a48215b0e4a1b44f441c878) Thanks [@freekh](https://github.com/freekh)! - New names for the media collections: `s.imagedir()`, `s.filedir()`, `s.fontdir()` and `s.videodir()`. The directory the uploads land in is now the first argument instead of the `dir` option:
+
+  ```ts
+  // before
+  s.imageset({ dir: "/public/val/images", accept: "image/webp" });
+  s.fileset({ dir: "/public/val/docs", accept: "application/pdf" });
+  s.fontset({ dir: "/public/val/fonts" });
+  s.videoset({ dir: "/public/val/videos", stream: { type: "hls" } });
+
+  // after
+  s.imagedir("/public/val/images", { accept: "image/webp" });
+  s.filedir("/public/val/docs", { accept: "application/pdf" });
+  s.fontdir("/public/val/fonts");
+  s.videodir("/public/val/videos", { stream: { type: "hls" } });
+  ```
+
+  Every other option is unchanged, and so is the content: a module only needs its schema call changed. The options object can now be left out entirely where nothing else is set, as in `s.fontdir("/public/val/fonts")`.
+
+  `s.imageset()`, `s.fileset()`, `s.fontset()` and `s.videoset()` still work and build exactly the same schema, but are deprecated and will be removed in a later release. The exported `VideosetEntryMetadata`, `VideosetOptions` and `SerializedVideosetSchema` types are deprecated in favour of `VideodirEntryMetadata`, `VideodirOptions` and `SerializedVideodirSchema`, and the image, file and font equivalents (`ImagedirOptions`, `ImagedirEntryMetadata`, `FiledirOptions`, `FiledirEntryMetadata`, `FontdirOptions`, `MediaDir`, …) are now exported too.
+
+### Patch Changes
+
+- [#788](https://github.com/valbuild/val/pull/788) [`a84271c`](https://github.com/valbuild/val/commit/a84271c534822071c1e428cf9990602459682d25) Thanks [@freekh](https://github.com/freekh)! - Fixes to `npx val validate` for `s.imagedir()` and `s.filedir()`, and the `s.image(galleryVal)` / `s.file(filesVal)` fields that use them:
+
+  - **`--fix` now updates every field that uses an uploaded image or file.** When `--fix` moves an entry of an `s.imagedir(dir).remote()` or `s.filedir(dir, options).remote()` to Val Remote, the entry's key changes from the local path to the remote URL. Fields that held the old path were left pointing at it, and reported "The gallery does not have an image at …" with nothing to fix it. Now `s.image(galleryVal)` and `s.file(filesVal)` fields, and images in rich text (`s.richtext({ img: s.image(galleryVal) })`), are updated in the same run. The VS Code extension's "upload to Val Remote" updates them in the same edit, including fields inside `.jsonValues()` entries, which live in their own `*.val.json` files.
+  - **A field that uses an image or file from a `.remote()` gallery is no longer reported as "Expected local image, but found remote".** The gallery decides whether its files are on Val Remote; the field only has to name a file the gallery has. Before, `--fix` would download the file and point the field at a path the gallery did not have.
+  - **Images uploaded through a field into a `.remote()` gallery.** When you upload an image through an `s.image(galleryVal)` field in Val Studio, the field stores the remote URL and the gallery stores the image under its local path. Validation now accepts this, and `useVal` / `fetchVal` now fill in the image's `width`, `height` and `mimeType` from the gallery for it, as they do for every other gallery image.
+  - **Errors in a gallery's keys are reported.** A remote URL in a gallery that is not `.remote()`, a remote URL that is not valid, or one outside the gallery's `dir` was silently ignored by `npx val validate`. It is now reported as an error. `--fix` does not change it: you decide whether the key or the gallery's options are wrong.
+  - **A file is no longer reported as valid when it still has an error.** When `--fix` fixed one error in a file and another error was left, the file could be printed as "✔ valid".
+
+## 0.143.0
+
+### Minor Changes
+
+- [#813](https://github.com/valbuild/val/pull/813) [`f7c25bd`](https://github.com/valbuild/val/commit/f7c25bd4b44c288db8e5ab914e6d8a72c0216ba5) Thanks [@freekh](https://github.com/freekh)! - New: `s.font(fontsVal)`, a field that picks a font from an `s.fontset()`.
+
+  ```ts
+  s.object({
+    headingFont: s.font(fontsVal),
+    title: s.string(),
+  });
+  ```
+
+  It stores `{ path }` like `s.file(fontsVal)` does, and refuses a module that is not a font set. In the Studio, a font field is shown among its object's other fields as a small row — the letter "A" set in the chosen font, and the font's file name. Click it to open the field, which shows every font in the set to pick from, an upload button, and a full specimen of the chosen font. This applies to `s.file()` fields that point at a font set too.
+
+- [#813](https://github.com/valbuild/val/pull/813) [`729c4ed`](https://github.com/valbuild/val/commit/729c4edfa28f5a2942c435ccf225e65858b080cc) Thanks [@freekh](https://github.com/freekh)! - New: `s.fontset()`, a collection of fonts.
+
+  ```ts
+  const fontsVal = c.define(
+    "/content/fonts.val.ts",
+    s.fontset({ dir: "/public/val/fonts" }),
+    {},
+  );
+  // a field that picks one of them
+  s.object({ headingFont: s.file(fontsVal) });
+  ```
+
+  It is an `s.fileset()` whose `accept` defaults to the web font formats (`font/woff2`, `font/woff`, `font/ttf`, `font/otf`); pass `accept: "font/woff2"` to allow only WOFF2. Fonts are not converted on upload.
+
+  The Studio now previews fonts set in themselves — in the gallery, in the picker of a field that points at a font set, and in the field — wherever a file is a font, including fonts in an ordinary `s.fileset()`.
+
+  Font uploads are typed from their bytes, so a font is stored as `font/woff2`, `font/ttf` and so on even when the browser reports no type for it. Files ending in `.ttf`, `.otf` and `.woff` now map to the `font/` types rather than the older `application/x-font-*` names, which are still accepted where they are already stored.
+
 ## 0.141.0
 
 ### Minor Changes

package/dist/declarations/src/index.d.ts

@@ -7,8 +7,12 @@ export { hasRemoteFileSchema, hasMediaSchema, } from "./schema/hasRemoteFileSche
 export type { ImageMetadata, ImageEncodeOption, ImageEncodeOptions, } from "./schema/image.js";
 export type { FileMetadata } from "./schema/file.js";
 export type { GalleryVideoOptions, VideoMetadata, VideoOptions, VideoStreamOption, VideoStreamOptions, } from "./schema/video.js";
-import { videosetEntryVideoSchema } from "./schema/videoset.js";
-export type { VideosetEntryMetadata, VideosetOptions, SerializedVideosetSchema, } from "./schema/videoset.js";
+import { videosetEntryVideoSchema } from "./schema/videodir.js";
+export type { VideodirEntryMetadata, VideodirOptions, SerializedVideodirSchema, VideosetEntryMetadata, VideosetOptions, SerializedVideosetSchema, } from "./schema/videodir.js";
+export type { ImagedirEntryMetadata, ImagedirOptions, SerializedImagedirSchema, } from "./schema/imagedir.js";
+export type { FiledirEntryMetadata, FiledirOptions, SerializedFiledirSchema, } from "./schema/filedir.js";
+export type { FontdirOptions } from "./schema/fontdir.js";
+export type { MediaDir } from "./schema/record.js";
 export type { ValModule, SerializedModule, InferValModuleType } from "./module.js";
 export type { SourceObject, SourcePrimitive, Source } from "./source/index.js";
 export type { FileSource } from "./source/media.js";
@@ -35,7 +39,7 @@ import { ModulePath, SourcePath, getValPath, isVal } from "./val/index.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
 import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
-import { getMimeType, mimeTypeToFileExt, filenameToMimeType, mimeTypeMatchesAccept } from "./mimeType/index.js";
+import { getMimeType, mimeTypeToFileExt, filenameToMimeType, mimeTypeMatchesAccept, isFontMimeType, sniffFontMimeType } from "./mimeType/index.js";
 import { type ImageMetadata } from "./schema/image.js";
 import { type FileMetadata } from "./schema/file.js";
 import { isJson, getJsonImport, resolveJsonValues } from "./source/json.js";
@@ -47,7 +51,7 @@ import { getValidationBasis, getValidationHash } from "./remote/validationBasis.
 import { getFileHash, hashToRemoteFileHash } from "./remote/fileHash.js";
 import { splitRemoteRef } from "./remote/splitRemoteRef.js";
 import { galleriesOf } from "./source/galleries.js";
-import { fillFromGallery, galleryEntryOf, isHlsVideo, isRemoteMediaPath, mediaUrl, resolveMedia, resolveVideo } from "./source/media.js";
+import { fillFromGallery, galleryEntryOf, galleryKeyOf, isHlsVideo, isRemoteMediaPath, mediaUrl, resolveMedia, resolveVideo } from "./source/media.js";
 import { colorToHex, convertColor, detectColorFormat, formatColor, parseColor } from "./schema/colorFormat.js";
 export { type SerializedArraySchema, ArraySchema } from "./schema/array.js";
 export { type SerializedObjectSchema, ObjectSchema } from "./schema/object.js";
@@ -57,6 +61,7 @@ export { type SerializedNumberSchema, NumberSchema } from "./schema/number.js";
 export { type SerializedBooleanSchema, BooleanSchema } from "./schema/boolean.js";
 export { type SerializedImageSchema, ImageSchema } from "./schema/image.js";
 export { type SerializedFileSchema, FileSchema } from "./schema/file.js";
+export { DEFAULT_FONT_ACCEPT, FONT_MIME_TYPES } from "./mimeType/font.js";
 export { type SerializedVideoSchema, VideoSchema, DEFAULT_VIDEO_ACCEPT, DEFAULT_VIDEO_RENDITIONS, DEFAULT_VIDEO_SEGMENT_DURATION, } from "./schema/video.js";
 export { type SerializedDateSchema, DateSchema } from "./schema/date.js";
 export { type SerializedSettingsSchema, SettingsSchema, } from "./schema/settings.js";
@@ -147,6 +152,7 @@ declare const Internal: {
         fillFromGallery: typeof fillFromGallery;
         galleriesOf: typeof galleriesOf;
         galleryEntryOf: typeof galleryEntryOf;
+        galleryKeyOf: typeof galleryKeyOf;
         GALLERY_DEFAULT_GROUPS: readonly (readonly string[])[];
         isHlsVideo: typeof isHlsVideo;
         HLS_MIME_TYPE: string;
@@ -208,6 +214,9 @@ declare const Internal: {
     MIME_TYPES_TO_EXT: {
         [k: string]: string;
     };
+    FONT_MIME_TYPE_EXTENSIONS: Record<string, string>;
+    isFontMimeType: typeof isFontMimeType;
+    sniffFontMimeType: typeof sniffFontMimeType;
     ModuleFilePathSep: string;
     notFileOp: (op: Operation) => op is {
         op: "add";

package/dist/declarations/src/initSchema.d.ts

@@ -13,8 +13,10 @@ import { keyOf } from "./schema/keyOf.js";
 import { view } from "./schema/view.js";
 import { record } from "./schema/record.js";
 import { file } from "./schema/file.js";
+import { font } from "./schema/font.js";
 import { video } from "./schema/video.js";
-import { fileset } from "./schema/fileset.js";
+import { filedir, fileset } from "./schema/filedir.js";
+import { fontdir, fontset } from "./schema/fontdir.js";
 import { date } from "./schema/date.js";
 import { datetime } from "./schema/datetime.js";
 import { code } from "./schema/code.js";
@@ -22,8 +24,8 @@ import { color } from "./schema/color.js";
 import { locale } from "./schema/locale.js";
 import { route } from "./schema/route.js";
 import { router } from "./schema/router.js";
-import { imageset } from "./schema/imageset.js";
-import { videoset } from "./schema/videoset.js";
+import { imagedir, imageset } from "./schema/imagedir.js";
+import { videodir, videoset } from "./schema/videodir.js";
 import { settings } from "./schema/settings.js";
 export type InitSchema = {
     /**
@@ -151,7 +153,7 @@ export type InitSchema = {
      *
      * @example
      * // Backed by a gallery: width, height and mimeType live there.
-     * import galleryVal from "./gallery.val"; // an s.imageset() module
+     * import galleryVal from "./gallery.val"; // an s.imagedir() module
      * const schema = s.image(galleryVal);
      * export default c.define("/example.val.ts", schema, {
      *   path: "/public/val/example.png",
@@ -219,6 +221,19 @@ export type InitSchema = {
      *
      */
     readonly file: typeof file;
+    /**
+     * A font picked from an `s.fontdir()`: `s.file(fontsVal)` for fonts, which
+     * refuses a module that is not a font set. The Studio shows it in its parent
+     * as the font's "A" and file name, and opens it on the set to pick from.
+     *
+     * @example
+     * ```typescript
+     * import fontsVal from "./fonts.val"; // an s.fontdir() module
+     * const schema = s.object({ headingFont: s.font(fontsVal) });
+     * // source: { headingFont: { path: "/public/val/fonts/inter_a1b2c.woff2" } }
+     * ```
+     */
+    readonly font: typeof font;
     /**
      * Define a video.
      *
@@ -246,7 +261,7 @@ export type InitSchema = {
      *
      * @example
      * // Picked from a set: mimeType, width, height and duration live there.
-     * import videosVal from "./videos.val"; // an s.videoset() module
+     * import videosVal from "./videos.val"; // an s.videodir() module
      * const schema = s.video(videosVal);
      * export default c.define("/example.val.ts", schema, {
      *   path: "/public/val/videos/intro_51df2.mp4",
@@ -362,13 +377,16 @@ export type InitSchema = {
      */
     readonly router: typeof router;
     /**
-     * Define a collection of images.
+     * Define a directory of images: a whole module of images, keyed by file
+     * path, that fields pick from with `s.image(galleryVal)`.
+     *
+     * The first argument is the directory uploads land in, and must start with
+     * `/public`.
      *
      * @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, {
@@ -381,15 +399,18 @@ export type InitSchema = {
      * });
      * ```
      */
-    readonly imageset: typeof imageset;
+    readonly imagedir: typeof imagedir;
     /**
-     * Define a collection of files.
+     * Define a directory of files: a whole module of files, keyed by file path,
+     * that fields pick from with `s.file(filesVal)`.
+     *
+     * The first argument is the directory uploads land in, and must start with
+     * `/public`.
      *
      * @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": {
@@ -398,15 +419,30 @@ export type InitSchema = {
      * });
      * ```
      */
-    readonly fileset: typeof fileset;
+    readonly filedir: typeof filedir;
     /**
-     * Define a collection of videos. A field picks from it with
+     * Define a directory of fonts: an `s.filedir()` that accepts the web font
+     * formats, and whose files the Studio previews as type. A field picks from
+     * it with `s.font(fontsVal)`.
+     *
+     * @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",
+     *   },
+     * });
+     * ```
+     */
+    readonly fontdir: typeof fontdir;
+    /**
+     * Define a directory of videos. A field picks from it with
      * `s.video(videosVal)`.
      *
      * @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, {
@@ -420,6 +456,60 @@ export type InitSchema = {
      * });
      * ```
      */
+    readonly videodir: typeof videodir;
+    /**
+     * Define a collection of images.
+     *
+     * @deprecated Use `s.imagedir(dir, options)`: the directory moved out of the
+     * options and into the first argument.
+     *
+     * @example
+     * ```typescript
+     * // was: s.imageset({ dir: "/public/val/images", accept: "image/webp" })
+     * const schema = s.imagedir("/public/val/images", { accept: "image/webp" });
+     * ```
+     */
+    readonly imageset: typeof imageset;
+    /**
+     * Define a collection of files.
+     *
+     * @deprecated Use `s.filedir(dir, options)`: the directory moved out of the
+     * options and into the first argument.
+     *
+     * @example
+     * ```typescript
+     * // was: s.fileset({ dir: "/public/val/documents", accept: "application/pdf" })
+     * const schema = s.filedir("/public/val/documents", {
+     *   accept: "application/pdf",
+     * });
+     * ```
+     */
+    readonly fileset: typeof fileset;
+    /**
+     * Define a collection of fonts.
+     *
+     * @deprecated Use `s.fontdir(dir, options)`: the directory moved out of the
+     * options and into the first argument.
+     *
+     * @example
+     * ```typescript
+     * // was: s.fontset({ dir: "/public/val/fonts" })
+     * const schema = s.fontdir("/public/val/fonts");
+     * ```
+     */
+    readonly fontset: typeof fontset;
+    /**
+     * Define a collection of videos.
+     *
+     * @deprecated Use `s.videodir(dir, options)`: the directory moved out of the
+     * options and into the first argument.
+     *
+     * @example
+     * ```typescript
+     * // was: s.videoset({ dir: "/public/val/videos", stream: { type: "hls" } })
+     * const schema = s.videodir("/public/val/videos", { stream: { type: "hls" } });
+     * ```
+     */
     readonly videoset: typeof videoset;
     /**
      * Define the project's settings.
@@ -451,8 +541,8 @@ export type InitSchemaOptions = {
     /**
      * Every media schema is remote: `files.remote` in `val.config.ts`.
      *
-     * `s.image()`, `s.file()`, `s.video()`, `s.imageset()`, `s.fileset()` and
-     * `s.videoset()` come back with `.remote()` already applied, and so does the
+     * `s.image()`, `s.file()`, `s.video()`, `s.imagedir()`, `s.filedir()`,
+     * `s.fontdir()` and `s.videodir()` (and their deprecated `*set` names) come back with `.remote()` already applied, and so does the
      * image `s.richtext({ img: true })` builds for itself. Nothing downstream
      * needs to know: the Studio, the MCP tools, validation and publishing all
      * read `remote` off the schema, exactly as they do for a `.remote()` written

package/dist/declarations/src/initVal.d.ts

@@ -80,8 +80,8 @@ export type ValConfig = {
          * Store every image, file and video on Val's remote content host instead
          * of in the repository.
          *
-         * `s.image()`, `s.file()`, `s.video()`, `s.imageset()`, `s.fileset()`,
-         * `s.videoset()` and `s.richtext({ img: true })` all behave as though
+         * `s.image()`, `s.file()`, `s.video()`, `s.imagedir()`, `s.filedir()`,
+         * `s.fontdir()`, `s.videodir()` and `s.richtext({ img: true })` all behave as though
          * `.remote()` had been written on them. Required for a project in the Val
          * app, which has no repository for the bytes to go into: there the Val
          * server refuses to start without it.

package/dist/declarations/src/mimeType/font.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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. */
+export declare const FONT_MIME_TYPES: readonly ["font/woff2", "font/woff", "font/ttf", "font/otf"];
+/** `s.fontdir()`'s `accept` when none is given. */
+export declare const DEFAULT_FONT_ACCEPT: string;
+/**
+ * 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.
+ */
+export declare const FONT_MIME_TYPE_EXTENSIONS: Record<string, string>;
+/** `mimeType`, with a legacy font name read as its `font/` type. */
+export declare function canonicalFontMimeType(mimeType: string): string;
+/**
+ * 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.
+ */
+export declare function isFontMimeType(mimeType: string | null | undefined): boolean;
+/**
+ * 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`).
+ */
+export declare function sniffFontMimeType(bytes: Uint8Array): string | null;

package/dist/declarations/src/mimeType/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./convertMimeType.js";
 export * from "./all.js";
+export * from "./font.js";

package/dist/declarations/src/render.d.ts

@@ -75,7 +75,7 @@ import type { SerializedSchema } from "./schema/index.js";
  * `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

package/dist/declarations/src/schema/file.d.ts

@@ -5,7 +5,7 @@ import { ModulePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import { ValModule } from "../index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
-import { FilesetEntryMetadata } from "./fileset.js";
+import { FiledirEntryMetadata } from "./filedir.js";
 export type FileOptions = {
     accept?: string;
 };
@@ -32,7 +32,7 @@ export declare class FileSchema<Src extends FileSource | null> extends Schema<Sr
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
-    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FilesetEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, FiledirEntryMetadata>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -135,7 +135,7 @@ export declare class FileSchema<Src extends FileSource | null> extends Schema<Sr
  * A file picked from a gallery. Its mime type lives in the gallery, so the
  * field carries only the path.
  */
-export declare function file(galleryModule: ValModule<Record<string, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
+export declare function file(galleryModule: ValModule<Record<string, FiledirEntryMetadata>>): FileSchema<GalleryFileSource>;
 /** A file of its own, carrying its own mime type. */
 export declare function file(options?: FileOptions): FileSchema<FileSource>;
 /**
@@ -143,5 +143,5 @@ export declare function file(options?: FileOptions): FileSchema<FileSource>;
  * `val.config.ts`): the same schema, with `.remote()` already applied. See
  * `initSchema`.
  */
-export declare function remoteFile(galleryModule: ValModule<Record<string, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
+export declare function remoteFile(galleryModule: ValModule<Record<string, FiledirEntryMetadata>>): FileSchema<GalleryFileSource>;
 export declare function remoteFile(options?: FileOptions): FileSchema<FileSource>;

package/dist/declarations/src/schema/filedir.d.ts

@@ -0,0 +1,83 @@
+import { Schema } from "./index.js";
+import type { MediaDir, SerializedRecordSchema } from "./record.js";
+import { RecordSchema } from "./record.js";
+import { ObjectSchema } from "./object.js";
+import { StringSchema } from "./string.js";
+/**
+ * Options for `s.filedir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+export type FiledirOptions = {
+    /**
+     * The accepted mime type pattern (e.g., "application/pdf", "text/*", "*\/*")
+     */
+    accept: string;
+};
+/**
+ * Options for the deprecated `s.fileset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.filedir(dir, options)` and `FiledirOptions`.
+ */
+export type FilesetOptions = FiledirOptions & {
+    /**
+     * The directory where files should be stored.
+     * Must start with "/public" (e.g., "/public/val/files")
+     */
+    dir: MediaDir;
+};
+/**
+ * Metadata for a file entry in the files record
+ */
+export type FiledirEntryMetadata = {
+    mimeType: string;
+};
+/** @deprecated Use `FiledirEntryMetadata`. */
+export type FilesetEntryMetadata = FiledirEntryMetadata;
+export type SerializedFiledirSchema = SerializedRecordSchema;
+/** @deprecated Use `SerializedFiledirSchema`. */
+export type SerializedFilesetSchema = SerializedFiledirSchema;
+type FiledirItemProps = {
+    mimeType: StringSchema<string>;
+};
+type FiledirItemSrc = {
+    mimeType: string;
+};
+type FiledirSchema = RecordSchema<ObjectSchema<FiledirItemProps, FiledirItemSrc>, Schema<string>, Record<string, FiledirEntryMetadata>>;
+/**
+ * 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)`.
+ *
+ * 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.filedir("/public/val/documents", {
+ *   accept: "application/pdf",
+ * });
+ * export default c.define("/content/documents.val.ts", schema, {
+ *   "/public/val/documents/report.pdf": {
+ *     mimeType: "application/pdf",
+ *   },
+ * });
+ * ```
+ */
+export declare const filedir: (dir: MediaDir, options: FiledirOptions) => FiledirSchema;
+/**
+ * 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",
+ * });
+ * ```
+ */
+export declare const fileset: (options: FilesetOptions) => FiledirSchema;
+export {};

package/dist/declarations/src/schema/font.d.ts

@@ -0,0 +1,16 @@
+import { ValModule } from "../index.js";
+import { FileSchema } from "./file.js";
+import { FiledirEntryMetadata } from "./filedir.js";
+import { GalleryFileSource } from "../source/media.js";
+/**
+ * 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.
+ */
+export declare function font(fontsetModule: ValModule<Record<string, FiledirEntryMetadata>>): FileSchema<GalleryFileSource>;
+/** `s.font()` with `.remote()` applied: see `files.remote` in `initSchema`. */
+export declare function remoteFont(fontsetModule: ValModule<Record<string, FiledirEntryMetadata>>): FileSchema<GalleryFileSource>;

package/dist/declarations/src/schema/fontdir.d.ts

@@ -0,0 +1,63 @@
+import { filedir } from "./filedir.js";
+import type { MediaDir } from "./record.js";
+/**
+ * Options for `s.fontdir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+export type FontdirOptions = {
+    /**
+     * The accepted font types. Defaults to every web font format:
+     * `"font/woff2,font/woff,font/ttf,font/otf"`. Narrow it to `"font/woff2"` to
+     * keep the site's fonts to the one format every current browser reads and
+     * that is smallest on the wire.
+     */
+    accept?: string;
+};
+/**
+ * Options for the deprecated `s.fontset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.fontdir(dir, options)` and `FontdirOptions`.
+ */
+export type FontsetOptions = FontdirOptions & {
+    /**
+     * The directory where fonts should be stored.
+     * Must start with "/public" (e.g., "/public/val/fonts")
+     */
+    dir: MediaDir;
+};
+/**
+ * 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",
+ *   },
+ * });
+ * ```
+ */
+export declare const fontdir: (dir: MediaDir, options?: FontdirOptions) => ReturnType<typeof filedir>;
+/**
+ * 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");
+ * ```
+ */
+export declare const fontset: (options: FontsetOptions) => ReturnType<typeof filedir>;

package/dist/declarations/src/schema/hasRemoteFileSchema.d.ts

@@ -5,7 +5,7 @@ import type { SerializedSchema } from "./index.js";
  * 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.
@@ -43,8 +43,8 @@ export declare function hasRemoteFileSchema(schema: SerializedSchema): boolean;
  *
  * 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).