@valbuild/core 0.139.0 → 0.141.0

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # @valbuild/core
 
+## 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
+
+- [#780](https://github.com/valbuild/val/pull/780) [`db13bed`](https://github.com/valbuild/val/commit/db13bed902f9f9147feb5be07ce47fe8b5b143f9) Thanks [@freekh](https://github.com/freekh)! - When a new version of your site with a changed schema is deployed while Val Studio is open, the Studio now asks you to reload before you keep editing, instead of carrying on with the old schema.
+
 ## 0.139.0
 
 ### Minor Changes

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

@@ -85,6 +85,20 @@ export declare function computeSourcesSha(entries: readonly {
     path: string;
     source: unknown;
 }[]): string;
+/**
+ * The `schemaSha` fold on its own: path and serialized schema, in `val.modules`
+ * order.
+ *
+ * Separate for the same reason as {@link computeSourcesSha}: the Studio folds
+ * the schemas of the bundle it is running and compares the answer with the
+ * `schemaSha` on `/stat`, which is how it learns that a new schema has been
+ * deployed under it. One implementation, so that comparison is between two
+ * runs of the same code.
+ */
+export declare function computeSchemaSha(entries: readonly {
+    path: string;
+    serializedSchema: unknown;
+}[]): string;
 export declare function computeValModuleShas(config: ValModules["config"], entries: readonly ValModuleShaEntry[], moduleErrors: readonly ExtractedModuleError[]): ValModuleShas;
 /**
  * Extracts schemas and sources from a ValModules registry and computes the

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

@@ -1,11 +1,14 @@
 export { initVal, type ConfigDirectory } from "./initVal.js";
 export { modules, type ValModules } from "./modules.js";
-export { extractValModules, computeValModuleShas, computeSourcesSha, type ExtractedValModules, type ValModuleShaEntry, type ValModuleShas, type ExtractedModuleError, } from "./extractValModules.js";
+export { extractValModules, computeValModuleShas, computeSourcesSha, computeSchemaSha, type ExtractedValModules, type ValModuleShaEntry, type ValModuleShas, type ExtractedModuleError, } from "./extractValModules.js";
 export type { InitVal, ValConfig, ValConstructor, ContentConstructor, } from "./initVal.js";
 export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/index.js";
 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";
@@ -43,16 +46,18 @@ 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 { 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 +133,7 @@ declare const Internal: {
     VERSION: {
         core: string;
     };
+    videosetEntryVideoSchema: typeof videosetEntryVideoSchema;
     createViewHandle: typeof createViewHandle;
     isViewHandle: typeof isViewHandle;
     resolveViewedModule: typeof resolveViewedModule;
@@ -135,9 +141,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 +194,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;

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

@@ -13,6 +13,7 @@ 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 { video } from "./schema/video.js";
 import { fileset } from "./schema/fileset.js";
 import { date } from "./schema/date.js";
 import { datetime } from "./schema/datetime.js";
@@ -22,6 +23,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 +219,41 @@ export type InitSchema = {
      *
      */
     readonly file: typeof file;
+    /**
+     * 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 +399,28 @@ export type InitSchema = {
      * ```
      */
     readonly fileset: typeof fileset;
+    /**
+     * 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 +447,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()` 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.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/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/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>;

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

@@ -4,6 +4,7 @@ import { SerializedArraySchema } from "./array.js";
 import { SerializedBooleanSchema } from "./boolean.js";
 import { SerializedFileSchema } from "./file.js";
 import { SerializedImageSchema } from "./image.js";
+import { SerializedVideoSchema } from "./video.js";
 import { SerializedKeyOfSchema } from "./keyOf.js";
 import { SerializedValViewSchema } from "./view.js";
 import { SerializedLiteralSchema } from "./literal.js";
@@ -25,7 +26,7 @@ import { ValidationError, ValidationErrors } from "./validation/ValidationError.
 import { FileSource } from "../source/media.js";
 import { GenericRichTextSourceNode, RichTextSource } from "../source/richtext.js";
 import { ReifiedPreview, PreviewScope, PreviewItem } from "../preview.js";
-export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedDiscriminatedUnionSchema | SerializedEnumSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedDateTimeSchema | SerializedColorSchema | SerializedCodeSchema | SerializedRouteSchema | SerializedLocaleSchema | SerializedSettingsSchema | SerializedImageSchema | SerializedValViewSchema;
+export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedDiscriminatedUnionSchema | SerializedEnumSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedDateTimeSchema | SerializedColorSchema | SerializedCodeSchema | SerializedRouteSchema | SerializedLocaleSchema | SerializedSettingsSchema | SerializedImageSchema | SerializedVideoSchema | SerializedValViewSchema;
 type Primitives = number | string | boolean | null | FileSource;
 export type AssertError = {
     message: string;

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

@@ -8,15 +8,20 @@ import { ExternalRecordSrc } from "../source/external.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import type { ImageEncodeOption } from "./image.js";
+import type { VideoStreamOption } from "./video.js";
 type MediaOptions = {
-    type: "files" | "images";
+    type: MediaCollectionType;
     accept: string;
     dir: string;
     remote: boolean;
     altSchema?: Schema<SelectorSource>;
     /** Images only: how uploads are re-encoded in the browser. See `image.ts`. */
     encode?: ImageEncodeOption;
+    /** Videos only: whether uploads become HLS streams. See `video.ts`. */
+    stream?: VideoStreamOption;
 };
+/** What a media collection (`s.imageset`, `s.fileset`, `s.videoset`) holds. */
+export type MediaCollectionType = "files" | "images" | "videos";
 export type SerializedRecordSchema = {
     type: "record";
     item: SerializedSchema;
@@ -44,11 +49,13 @@ export type SerializedRecordSchema = {
      */
     routerSchemes?: string[];
     customValidate?: boolean;
-    mediaType?: "files" | "images";
+    mediaType?: MediaCollectionType;
     accept?: string;
     dir?: string;
     remote?: boolean;
     encode?: ImageEncodeOption;
+    /** Videos only: whether uploads become HLS streams. See `video.ts`. */
+    stream?: VideoStreamOption;
     alt?: SerializedSchema;
     jsonValues?: boolean;
     /**
@@ -203,6 +210,13 @@ RO extends boolean = false> extends Schema<Src> {
     private markKeyErrorsAtPath;
     private validateMediaKey;
     private validateMediaEntry;
+    /**
+     * The poster and caption files of a set's entry that are not where the set
+     * keeps its files. Asked only once the key itself is in place: a local key
+     * in a remote set is reported (and uploaded) as the entry, files and all,
+     * and a second error for its poster would be the same one twice.
+     */
+    private misplacedEntryFiles;
     private validateMediaMimeType;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): RecordSchema<T, K, Src | null>;

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

@@ -26,7 +26,21 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
-    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    /**
+     * Whether `img: true` means a REMOTE image. Set by `remoteRichtext`, for a
+     * project whose media is all remote (`files.remote` in `val.config.ts`):
+     * `img: s.image()` is already remote there, because `s.image()` is, but
+     * `img: true` builds its image schema here and has to be told.
+     */
+    private readonly imgRemote;
+    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, 
+    /**
+     * Whether `img: true` means a REMOTE image. Set by `remoteRichtext`, for a
+     * project whose media is all remote (`files.remote` in `val.config.ts`):
+     * `img: s.image()` is already remote there, because `s.image()` is, but
+     * `img: true` builds its image schema here and has to be told.
+     */
+    imgRemote?: boolean);
     /**
      * Describe this field.
      *
@@ -125,4 +139,9 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     protected executeSerialize(): SerializedSchema;
 }
 export declare const richtext: <O extends RichTextOptions>(options?: O) => RichTextSchema<O, RichTextSource<O>>;
+/**
+ * `s.richtext()` for a project whose media is all remote (`files.remote` in
+ * `val.config.ts`): `img: true` is a remote image. See `initSchema`.
+ */
+export declare const remoteRichtext: <O extends RichTextOptions>(options?: O) => RichTextSchema<O, RichTextSource<O>>;
 export {};

package/dist/declarations/src/schema/validation/ValidationFix.d.ts

@@ -1,2 +1,2 @@
-export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "keyof:check-keys", "router:check-route", "locale:check-locale", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "jsonValues:extract-entry", "record:fill-keys", "external:upload", "view:check-module"];
+export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "video:add-metadata", "video:upload-remote", "video:download-remote", "videos:add-metadata", "videos:check-remote", "videos:upload-remote", "keyof:check-keys", "router:check-route", "locale:check-locale", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "videos:check-unique-folder", "videos:check-all-files", "jsonValues:extract-entry", "record:fill-keys", "external:upload", "view:check-module"];
 export type ValidationFix = (typeof ValidationFix)[number];