@valbuild/core 0.139.1 → 0.143.0

package/CHANGELOG.md

@@ -1,5 +1,101 @@
 # @valbuild/core
 
+## 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
+
+- [#802](https://github.com/valbuild/val/pull/802) [`199e214`](https://github.com/valbuild/val/commit/199e21471d98806fb34c579cb876560078c928b9) Thanks [@freekh](https://github.com/freekh)! - New: `files: { remote: true }` in `val.config.ts` stores every image, file and video on Val's remote content host.
+
+  ```ts
+  const { s, c, val, config } = initVal({
+    project: "myorg/myproject",
+    files: { remote: true },
+  });
+  ```
+
+  With it, `s.image()`, `s.file()`, `s.video()`, `s.imageset()`, `s.fileset()`, `s.videoset()` and `s.richtext({ img: true })` behave as though `.remote()` had been written on them. Images already in the project are reported as `image:upload-remote` until they are uploaded; `npx val validate --fix` does that.
+
+  **Required in the Val app.** A project running there (`VAL_ENV=app`) refuses to start without it, with an error that says what to add, and `val publish` refuses before it builds.
+
+  **Breaking:** `files.directory` has been removed from `val.config.ts`. Local files that have no `dir` of their own are stored in `/public/val`, which was the default.
+
+- [#779](https://github.com/valbuild/val/pull/779) [`ba3f330`](https://github.com/valbuild/val/commit/ba3f3300a3dd8649e154097cdfca3b64db209d89) Thanks [@freekh](https://github.com/freekh)! - New: `s.video()`, for mp4/WebM files and HLS streams.
+
+  ```ts
+  const schema = s.object({
+    intro: s.video({ stream: { type: "hls" } }),
+  });
+  ```
+
+  - **Upload and play in the Studio.** A video field shows a player, the file's size and length, and progress while it uploads.
+  - **HLS streaming without a video service.** With `stream: { type: "hls" }`, the Studio converts an upload to an HLS stream in the editor's browser before it uploads it. It makes one H.264 rendition per height (1080p, 720p and 480p by default, and never larger than the upload) and stores them as a folder of files next to your other uploads. Nothing is installed in your app for this: the converter ships inside the Studio and is only downloaded when someone uploads to a streaming field. A browser that can't convert (no WebCodecs, or a non-https address) uploads the original file and says so.
+  - **Poster:** pause on a frame and choose "Use current frame". The frame is saved as an image, and `posterTime` records where it was taken.
+  - **Start and end:** play part of a video without cutting the file.
+  - **Focal point:** marks what must stay in frame when the page crops the video.
+  - **Description:** text for people who can't see the video.
+  - **Captions:** one WebVTT file per language. `.srt` files are converted on upload.
+  - **`<ValVideo>`** in `@valbuild/next` and `@valbuild/tanstack` renders all of the above and is click-to-edit. For HLS in browsers that can't play it natively, pass `hls={() => import("hls.js")}`. It is only loaded when it's needed.
+  - **Rename** a video in the Studio. An HLS stream is renamed as a whole: every playlist and segment moves to the new folder.
+  - `npx val validate --fix` fills in `mimeType`, `width`, `height` and `duration` for a hand-written `.mp4`, `.mov`, `.webm`, `.mkv` or HLS video, on disk or on Val Remote. A remote video is not downloaded: only its headers are read, usually in one to three small requests.
+  - `.remote()` works for videos. `npx val validate --fix` moves a video to Val Remote, or back into the project, together with its poster, captions and every file of an HLS stream.
+
+  A video value always has a `mimeType`: it is how a page knows whether it has an `.mp4` or an `.m3u8`.
+
+  New: `s.videoset()`, a collection of videos, like `s.imageset()` for images.
+
+  ```ts
+  const videosVal = c.define(
+    "/content/videos.val.ts",
+    s.videoset({ dir: "/public/val/videos", stream: { type: "hls" } }),
+    {},
+  );
+  const schema = s.object({ intro: s.video(videosVal) });
+  ```
+
+  - **Upload once, set it up once, use anywhere.** A set's entry holds what is true of the file (its type, size and length) and, as defaults, a description, poster, start and end, focal point and captions. A field that picks from the set (`s.video(videosVal)`) gets all of those, and can override any of them on its own. For example, the same clip can open one page at 0:02 and every other page where the set says.
+  - **Media in the Studio.** A set is listed under Media and opens as a gallery of videos, with each video's poster as its thumbnail. Hovering a video previews it, and the selected video plays in a real player (HLS streams too) beside the poster, times, focal point and captions you edit for it. You can upload into the set (with `stream`, uploads become HLS streams, and each upload gets a poster), rename a video, and delete a video that nothing uses. Renaming a video updates every field that uses it. An HLS stream is one entry, and renaming or deleting it moves or removes all of its files.
+  - **Picking.** A set-backed field picks from the set, or uploads into it. Each value the set provides is marked "From gallery · Override", and once overridden, "Overridden · Use gallery's".
+  - `useVal` and `fetchVal` fill in what the set holds (`mimeType`, `width`, `height`, `duration`, and every default the field does not override), so `<ValVideo>` works the same either way.
+  - `.remote()` works for sets. `npx val validate --fix` fills in missing metadata for an entry, adds untracked videos found in the set's directory, and moves a set's videos to Val Remote.
+
+  Image and file galleries use the same new gallery layout: a grid or list of entries, with the selected one open in a panel beside it.
+
+  - An `s.imageset()` entry can hold a default focal point, as well as its description. An `s.image(galleryVal)` field shows both, and can override either.
+  - Fixed: outside draft mode, `useVal` and `fetchVal` now fill a gallery-backed image or file from its gallery (dimensions, mime type, description). Before, a published page got only the `path`.
+
 ## 0.139.1
 
 ### Patch Changes

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

@@ -0,0 +1,55 @@
+/**
+ * From: https://github.com/kawanet/sha256-uint8array/commit/a035f83824c319d01ca1e7559fdcf1632c0cd6c4
+ *
+ * LICENSE:
+ *
+ * MIT License
+ * Copyright (c) 2020-2023 Yusuke Kawasaki
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * sha256-uint8array.ts
+ */
+export declare function createHash(algorithm?: string): Hash;
+export declare class Hash {
+    private A;
+    private B;
+    private C;
+    private D;
+    private E;
+    private F;
+    private G;
+    private H;
+    private _byte;
+    private _word;
+    private _size;
+    private _sp;
+    constructor();
+    update(data: string, encoding?: string): this;
+    update(data: Uint8Array): this;
+    update(data: ArrayBufferView): this;
+    private _uint8;
+    private _utf8;
+    private _int32;
+    digest(): Uint8Array;
+    digest(encoding: string): string;
+    private _hex;
+    private _bin;
+}
+export declare const getSHA256Hash: (bits: Uint8Array) => string;

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

@@ -6,6 +6,9 @@ export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/i
 export { hasRemoteFileSchema, hasMediaSchema, } from "./schema/hasRemoteFileSchema.js";
 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";
 export type { ValModule, SerializedModule, InferValModuleType } from "./module.js";
 export type { SourceObject, SourcePrimitive, Source } from "./source/index.js";
 export type { FileSource } from "./source/media.js";
@@ -15,7 +18,7 @@ export type { RemoteRef } from "./source/remote.js";
 export { DEFAULT_VAL_REMOTE_HOST } from "./schema/remote.js";
 export type { RawString } from "./schema/string.js";
 export type { ImageSource } from "./source/media.js";
-export type { MediaHotspot, MediaSource, GalleryImageSource, GalleryFileSource, } from "./source/media.js";
+export type { MediaHotspot, MediaSource, GalleryImageSource, GalleryFileSource, GalleryVideoSource, VideoDefaults, IsVideoSource, VideoSource, VideoPosterSource, VideoCaptionSource, ResolvedVideo, } from "./source/media.js";
 export type { AllRichTextOptions, Bold, Styles, HeadingNode, ImageNode, Italic, LineThrough, ListItemNode, LinkNode, OrderedListNode, ParagraphNode, BrNode, RichTextNode, RichTextOptions, SerializedRichTextOptions, RichTextSource, BlockNode, SpanNode, UnorderedListNode, } from "./source/richtext.js";
 export { type Val, type SerializedVal, type ModuleFilePath, type PatchId, type ModulePath, type SourcePath, type JsonOfSource, type ParentPatchId, } from "./val/index.js";
 export type { Json, JsonPrimitive, JsonArray, JsonObject } from "./Json.js";
@@ -32,7 +35,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";
@@ -43,16 +46,19 @@ import { createRenamedFilename } from "./source/filename.js";
 import { getValidationBasis, getValidationHash } from "./remote/validationBasis.js";
 import { getFileHash, hashToRemoteFileHash } from "./remote/fileHash.js";
 import { splitRemoteRef } from "./remote/splitRemoteRef.js";
-import { fillFromGallery, isRemoteMediaPath, mediaUrl, resolveMedia } from "./source/media.js";
+import { galleriesOf } from "./source/galleries.js";
+import { fillFromGallery, galleryEntryOf, 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";
-export { type SerializedRecordSchema, RecordSchema } from "./schema/record.js";
+export { type SerializedRecordSchema, type MediaCollectionType, RecordSchema, } from "./schema/record.js";
 export { type SerializedStringSchema, StringSchema } from "./schema/string.js";
 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";
 export { type SettingsSource, type AssistantSettingsSource, type LocalesSettingsSource, type AssistantAvailability, type ThemeSettingsSource, type StudioSettingsSource, type StudioCommitMessageMode, type ThemeRadius, ASSISTANT_SETTINGS_MAX_LENGTH, THEME_LOGO_DIRECTORY, THEME_RADIUS_STEPS, THEME_RADIUS_LENGTHS, assistantAvailability, } from "./source/settings.js";
@@ -128,6 +134,7 @@ declare const Internal: {
     VERSION: {
         core: string;
     };
+    videosetEntryVideoSchema: typeof videosetEntryVideoSchema;
     createViewHandle: typeof createViewHandle;
     isViewHandle: typeof isViewHandle;
     resolveViewedModule: typeof resolveViewedModule;
@@ -135,9 +142,15 @@ declare const Internal: {
     viewModulesOf: typeof viewModulesOf;
     mediaUrl: typeof mediaUrl;
     resolveMedia: typeof resolveMedia;
+    resolveVideo: typeof resolveVideo;
     isRemoteMediaPath: typeof isRemoteMediaPath;
     media: {
         fillFromGallery: typeof fillFromGallery;
+        galleriesOf: typeof galleriesOf;
+        galleryEntryOf: typeof galleryEntryOf;
+        GALLERY_DEFAULT_GROUPS: readonly (readonly string[])[];
+        isHlsVideo: typeof isHlsVideo;
+        HLS_MIME_TYPE: string;
     };
     getSchema: typeof getSchema;
     getValPath: typeof getValPath;
@@ -182,6 +195,11 @@ declare const Internal: {
     isExternalFileRef: typeof isExternalFileRef;
     createValPathOfItem: typeof createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
+    /**
+     * The same hash as `getSHA256Hash`, fed a chunk at a time: what a caller
+     * hashing hundreds of megabytes uses to give the thread back between chunks.
+     */
+    createSHA256Hash: () => import("./getSha256.js").Hash;
     initSchema: typeof initSchema;
     getMimeType: typeof getMimeType;
     mimeTypeToFileExt: typeof mimeTypeToFileExt;
@@ -191,6 +209,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,7 +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 { fontset } from "./schema/fontset.js";
 import { date } from "./schema/date.js";
 import { datetime } from "./schema/datetime.js";
 import { code } from "./schema/code.js";
@@ -22,6 +25,7 @@ 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 { settings } from "./schema/settings.js";
 export type InitSchema = {
     /**
@@ -217,6 +221,54 @@ export type InitSchema = {
      *
      */
     readonly file: typeof file;
+    /**
+     * A font picked from an `s.fontset()`: `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
+     * const schema = s.object({ headingFont: s.font(fontsVal) });
+     * // source: { headingFont: { path: "/public/val/fonts/inter_a1b2c.woff2" } }
+     * ```
+     */
+    readonly font: typeof font;
+    /**
+     * Define a video.
+     *
+     * A video is an object with a `path` and a `mimeType`: an `.mp4` / `.webm`
+     * file, or — with `stream: { type: "hls" }` — an HLS stream the Studio
+     * transcodes an upload into, in the browser. `width`, `height` and
+     * `duration` are read from the file (`npx val validate --fix` adds them);
+     * `posterTime`, `startTime`, `endTime`, `hotspot`, `alt` and `captions` are
+     * authored in the Studio.
+     *
+     * @example
+     * const schema = s.video({ stream: { type: "hls" } });
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "/public/val/intro_3b9d7/master.m3u8",
+     *   mimeType: "application/vnd.apple.mpegurl",
+     *   width: 1920,
+     *   height: 1080,
+     *   duration: 42.5,
+     *   startTime: 2,
+     *   alt: "The team walking into the office",
+     *   captions: [
+     *     { path: "/public/val/intro_en_8f2a1.vtt", srclang: "en", label: "English" },
+     *   ],
+     * });
+     *
+     * @example
+     * // Picked from a set: mimeType, width, height and duration live there.
+     * import videosVal from "./videos.val"; // an s.videoset() module
+     * const schema = s.video(videosVal);
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "/public/val/videos/intro_51df2.mp4",
+     *   startTime: 2,
+     * });
+     */
+    readonly video: typeof video;
     /**
      * Define a date.
      *
@@ -362,6 +414,44 @@ export type InitSchema = {
      * ```
      */
     readonly fileset: typeof fileset;
+    /**
+     * Define a collection of fonts: an `s.fileset()` that accepts the web font
+     * formats, and whose files the Studio previews as type. A field picks from
+     * it with `s.file(fontsVal)`.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.fontset({ dir: "/public/val/fonts" });
+     * export default c.define("/content/fonts.val.ts", schema, {
+     *   "/public/val/fonts/inter_a1b2c.woff2": {
+     *     mimeType: "font/woff2",
+     *   },
+     * });
+     * ```
+     */
+    readonly fontset: typeof fontset;
+    /**
+     * Define a collection of videos. A field picks from it with
+     * `s.video(videosVal)`.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.videoset({
+     *   dir: "/public/val/videos",
+     *   stream: { type: "hls" },
+     * });
+     * export default c.define("/content/videos.val.ts", schema, {
+     *   "/public/val/videos/intro_51df2.mp4": {
+     *     mimeType: "video/mp4",
+     *     width: 1280,
+     *     height: 720,
+     *     duration: 12.5,
+     *     alt: "The team, introducing itself",
+     *   },
+     * });
+     * ```
+     */
+    readonly videoset: typeof videoset;
     /**
      * Define the project's settings.
      *
@@ -388,59 +478,20 @@ export type InitSchema = {
      */
     readonly settings: typeof settings;
 };
-export declare function initSchema(): {
-    string: <T extends string>(options?: Record<string, never>) => import("./index.js").StringSchema<T>;
-    boolean: () => import("./index.js").BooleanSchema<boolean>;
-    array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./index.js").ArraySchema<S, import("./schema/index.js").SelectorOfSchema<S>[]>;
-    object: <Props extends {
-        [key: string]: import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>;
-    } & {
-        valPath?: never;
-        val?: never;
-        _type?: never;
-        _ref?: never;
-        view?: never;
-        andThen?: never;
-        assert?: never;
-        fold?: never;
-        patch_id?: never;
-    }>(schema: Props) => import("./index.js").ObjectSchema<Props, { [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
-    number: (options?: {
-        max?: number;
-        min?: number;
-    }) => import("./index.js").NumberSchema<number>;
-    discriminatedUnion: <Key extends string, T extends import("./schema/discriminatedUnion.js").DiscriminatedUnionItems<Key>>(key: Key, ...objects: T) => import("./index.js").DiscriminatedUnionSchema<Key, T, import("./index.js").DiscriminatedUnionSourceOf<Key, T>>;
-    enum: <T extends string>(values_0: T, ...values: T[]) => import("./index.js").EnumSchema<T>;
-    union: typeof union;
-    richtext: <O extends import("./index.js").RichTextOptions>(options?: O) => import("./index.js").RichTextSchema<O, import("./index.js").RichTextSource<O>>;
-    image: typeof image;
-    literal: <T extends string>(value: T) => import("./index.js").LiteralSchema<T>;
-    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./index.js").KeyOfSchema<Src, Src extends import("./selector/index.js").GenericSelector<infer S extends import("./source/index.js").Source, undefined> ? S extends readonly import("./source/index.js").Source[] ? number : S extends import("./source/index.js").SourceObject ? string extends keyof S ? import("./index.js").RawString : keyof S : S extends Record<string, import("./source/index.js").Source> ? import("./index.js").RawString : never : never>;
-    view: <M extends import("./selector/index.js").GenericSelector<import("./source/index.js").Source> & import("./module.js").ValModuleBrand>(valModule: M) => import("./index.js").ValViewSchema<import("./module.js").ModuleIdOf<M>, M extends import("./selector/index.js").GenericSelector<infer S extends import("./source/index.js").Source, undefined> ? S : never>;
-    record: typeof record;
-    file: typeof file;
-    fileset: (options: import("./schema/fileset.js").FilesetOptions) => import("./index.js").RecordSchema<import("./index.js").ObjectSchema<{
-        mimeType: import("./index.js").StringSchema<string>;
-    }, {
-        mimeType: string;
-    }>, import("./schema/index.js").Schema<string>, Record<string, import("./schema/fileset.js").FilesetEntryMetadata>>;
-    date: (options?: Record<string, never>) => import("./index.js").DateSchema<import("./index.js").RawString>;
-    datetime: (options?: Record<string, never>) => import("./index.js").DateTimeSchema<import("./index.js").RawString>;
-    color: (options?: import("./index.js").ColorOptions) => import("./index.js").ColorSchema<import("./index.js").RawString>;
-    code: (options?: import("./index.js").CodeOptions) => import("./index.js").CodeSchema<import("./index.js").RawString>;
-    locale: () => import("./index.js").LocaleSchema<string>;
-    route: <T extends string>(options?: Record<string, never>) => import("./index.js").RouteSchema<T>;
-    router: typeof router;
-    imageset: <Accept extends `image/${string}`, Alt extends import("./schema/imageset.js").AltSchema = import("./index.js").StringSchema<string | null>>(options: import("./schema/imageset.js").ImagesetOptions<Accept, Alt>) => import("./index.js").RecordSchema<import("./index.js").ObjectSchema<{
-        width: import("./index.js").NumberSchema<number>;
-        height: import("./index.js").NumberSchema<number>;
-        mimeType: import("./index.js").StringSchema<string>;
-        alt: Alt;
-    }, {
-        width: number;
-        height: number;
-        mimeType: string;
-        alt: import("./schema/index.js").SelectorOfSchema<Alt>;
-    }>, import("./schema/index.js").Schema<string>, Record<string, import("./schema/imageset.js").ImagesetEntryMetadata<import("./schema/imageset.js").AltSourceOf<Alt>>>>;
-    settings: typeof settings;
+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
+     * 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
+     * by hand.
+     *
+     * It is the factories that change, not the schemas, so a schema built here
+     * is indistinguishable from one written with `.remote()`.
+     */
+    remote?: boolean;
 };
+export declare function initSchema(options?: InitSchemaOptions): InitSchema;

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

@@ -76,7 +76,30 @@ export type ValConfig = {
     project?: string;
     root?: string;
     files?: {
-        directory: ConfigDirectory;
+        /**
+         * 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
+         * `.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.
+         *
+         * It is set here, in the project, rather than by the environment, so that
+         * every tool reads the project the same way. `val validate`, the VS Code
+         * extension and `pnpm dev` evaluate this file too, and a switch only the
+         * app could see would have them calling every remote image a mistake --
+         * and `val validate --fix` downloading it back into the repository.
+         *
+         * @example
+         * import { initVal } from "@valbuild/core";
+         * const { s, c, val, config } = initVal({
+         *   project: "myorg/myproject",
+         *   files: { remote: true },
+         * });
+         */
+        remote?: boolean;
     };
     gitCommit?: string;
     gitBranch?: string;
@@ -146,7 +169,7 @@ export type InitVal = {
      * import { initVal } from "@valbuild/core";
      * const { s, c, val, config } = initVal({
      *   project: "myorg/myproject",
-     *   files: { directory: "/public/val" },
+     *   files: { remote: true },
      * });
      * export { s, c, val, config };
      */

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.fontset()` 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. */
+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/remote/validationBasis.d.ts

@@ -1,5 +1,6 @@
 import { SerializedFileSchema } from "../schema/file.js";
 import { SerializedImageSchema } from "../schema/image.js";
+import { SerializedVideoSchema } from "../schema/video.js";
 /**
  * The validation basis is used in remote refs to determine if the remote content needs to be re-validated.
  *
@@ -9,5 +10,5 @@ import { SerializedImageSchema } from "../schema/image.js";
  *       This way we can rename a file, without having to re-validate it.
  *       The version is outside of the validation hash, so that it is possible to manually fix the version without having to re-validate.
  */
-export declare function getValidationBasis(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string): string;
-export declare function getValidationHash(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string, textEncoder: TextEncoder): string;
+export declare function getValidationBasis(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema | SerializedVideoSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string): string;
+export declare function getValidationHash(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema | SerializedVideoSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string, textEncoder: TextEncoder): string;

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

@@ -138,3 +138,10 @@ export declare class FileSchema<Src extends FileSource | null> extends Schema<Sr
 export declare function file(galleryModule: ValModule<Record<string, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
 /** A file of its own, carrying its own mime type. */
 export declare function file(options?: FileOptions): FileSchema<FileSource>;
+/**
+ * `s.file()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): the same schema, with `.remote()` already applied. See
+ * `initSchema`.
+ */
+export declare function remoteFile(galleryModule: ValModule<Record<string, FilesetEntryMetadata>>): FileSchema<GalleryFileSource>;
+export declare function remoteFile(options?: FileOptions): FileSchema<FileSource>;

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

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

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

@@ -0,0 +1,40 @@
+import { fileset, FilesetOptions } from "./fileset.js";
+/**
+ * Options for s.fontset()
+ */
+export type FontsetOptions = {
+    /**
+     * The directory where fonts should be stored.
+     * Must start with "/public" (e.g., "/public/val/fonts")
+     */
+    dir: FilesetOptions["dir"];
+    /**
+     * 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;
+};
+/**
+ * Define a collection of fonts.
+ *
+ * A fontset IS a fileset — the same source, the same `s.file(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 set: 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.fontset({ dir: "/public/val/fonts" });
+ * export default c.define("/content/fonts.val.ts", schema, {
+ *   "/public/val/fonts/inter_a1b2c.woff2": {
+ *     mimeType: "font/woff2",
+ *   },
+ * });
+ * ```
+ */
+export declare const fontset: (options: FontsetOptions) => ReturnType<typeof fileset>;

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

@@ -1,4 +1,4 @@
-import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult } from "./index.js";
 import { GalleryImageSource, ImageSource } from "../source/media.js";
 import { ModulePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -198,7 +198,7 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
     preview(select: ItemPreviewInput<Src>): ImageSchema<Src>;
     protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;
     protected declaresItemPreview(): boolean;
-    protected executeSerialize(): SerializedSchema;
+    protected executeSerialize(): SerializedImageSchema;
 }
 /**
  * An image picked from a gallery. Its dimensions and mime type live in the
@@ -207,3 +207,10 @@ export declare class ImageSchema<Src extends ImageSource | null> extends Schema<
 export declare function image(galleryModule: ValModule<Record<string, ImagesetEntryMetadata<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>;
+/**
+ * `s.image()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): the same schema, with `.remote()` already applied. See
+ * `initSchema`.
+ */
+export declare function remoteImage(galleryModule: ValModule<Record<string, ImagesetEntryMetadata<AltSource>>>, galleryOptions?: GalleryImageOptions): ImageSchema<GalleryImageSource>;
+export declare function remoteImage(options?: ImageOptions): ImageSchema<ImageSource>;