@valbuild/core 0.143.0 → 0.144.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @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

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";
@@ -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";
@@ -148,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;

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

@@ -15,8 +15,8 @@ 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 { fontset } from "./schema/fontset.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";
@@ -24,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 = {
     /**
@@ -153,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",
@@ -222,13 +222,13 @@ export type InitSchema = {
      */
     readonly file: typeof file;
     /**
-     * A font picked from an `s.fontset()`: `s.file(fontsVal)` for fonts, which
+     * 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.fontset() module
+     * 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" } }
      * ```
@@ -261,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",
@@ -377,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, {
@@ -396,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": {
@@ -413,15 +419,15 @@ export type InitSchema = {
      * });
      * ```
      */
-    readonly fileset: typeof fileset;
+    readonly filedir: typeof filedir;
     /**
-     * Define a collection of fonts: an `s.fileset()` that accepts the web font
+     * 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.file(fontsVal)`.
+     * it with `s.font(fontsVal)`.
      *
      * @example
      * ```typescript
-     * const schema = s.fontset({ dir: "/public/val/fonts" });
+     * 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",
@@ -429,15 +435,14 @@ export type InitSchema = {
      * });
      * ```
      */
-    readonly fontset: typeof fontset;
+    readonly fontdir: typeof fontdir;
     /**
-     * Define a collection of videos. A field picks from it with
+     * 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, {
@@ -451,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.
@@ -482,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()`,
-     * `s.fontset()` 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.fontset()`, `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

@@ -8,9 +8,9 @@
  * `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.fontset()` accepts unless told otherwise, best first. */
+/** 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.fontset()`'s `accept` when none is given. */
+/** `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

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

@@ -1,9 +1,9 @@
 import { ValModule } from "../index.js";
 import { FileSchema } from "./file.js";
-import { FilesetEntryMetadata } from "./fileset.js";
+import { FiledirEntryMetadata } from "./filedir.js";
 import { GalleryFileSource } from "../source/media.js";
 /**
- * A font picked from an `s.fontset()`.
+ * 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,
@@ -11,6 +11,6 @@ import { GalleryFileSource } from "../source/media.js";
  * 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, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
+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, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
+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).

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

@@ -4,7 +4,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 { AltSource, ImagesetEntryMetadata } from "./imageset.js";
+import { AltSource, ImagedirEntryMetadata } from "./imagedir.js";
 /**
  * How an uploaded image is re-encoded in the browser, before it is uploaded.
  *
@@ -77,7 +77,7 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
-    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagesetEntryMetadata<AltSource>>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], moduleMetadata?: Record<ModulePath, Record<string, ImagedirEntryMetadata<AltSource>>>, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
     /**
      * Describe this field.
      *
@@ -204,7 +204,7 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
  * An image picked from a gallery. Its dimensions and mime type live in the
  * gallery, so the field carries only what a person typed.
  */
-export declare function image(galleryModule: ValModule<Record<string, ImagesetEntryMetadata<AltSource>>>, galleryOptions?: GalleryImageOptions): ImageSchema<GalleryImageSource>;
+export declare function image(galleryModule: ValModule<Record<string, ImagedirEntryMetadata<AltSource>>>, galleryOptions?: GalleryImageOptions): ImageSchema<GalleryImageSource>;
 /** An image of its own, carrying its own dimensions and mime type. */
 export declare function image(options?: ImageOptions): ImageSchema<ImageSource>;
 /**
@@ -212,5 +212,5 @@ export declare function image(options?: ImageOptions): ImageSchema<ImageSource>;
  * `val.config.ts`): the same schema, with `.remote()` already applied. See
  * `initSchema`.
  */
-export declare function remoteImage(galleryModule: ValModule<Record<string, ImagesetEntryMetadata<AltSource>>>, galleryOptions?: GalleryImageOptions): ImageSchema<GalleryImageSource>;
+export declare function remoteImage(galleryModule: ValModule<Record<string, ImagedirEntryMetadata<AltSource>>>, galleryOptions?: GalleryImageOptions): ImageSchema<GalleryImageSource>;
 export declare function remoteImage(options?: ImageOptions): ImageSchema<ImageSource>;