@valbuild/core 0.139.1 → 0.143.0

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];

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

@@ -0,0 +1,249 @@
+import { GalleryVideoSource, VideoSource } from "../source/media.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { SourcePath } from "../val/index.js";
+import type { ValModule } from "../module.js";
+import type { AltSource } from "./imageset.js";
+import type { VideosetEntryMetadata } from "./videoset.js";
+import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
+import { ItemPreviewInput, PreviewItem } from "../preview.js";
+import { FieldRender } from "../render.js";
+/**
+ * Turn an upload into an HLS stream, in the browser, before it is uploaded.
+ *
+ * The Studio transcodes the picked file with WebCodecs into one rendition per
+ * entry of `renditions` (never upscaled: a 720p upload gets no 1080p
+ * rendition), segments each into CMAF and writes the playlists. What is stored
+ * is a directory beside the other uploads; the field's `path` is its master
+ * playlist. See `architecture/media.md`.
+ *
+ * `type` is required for the same reason it is on `ImageEncodeOptions`: a
+ * second kind of stream would then be additive.
+ */
+export type VideoStreamOptions = {
+    type: "hls";
+    /**
+     * The heights of the renditions, in pixels. A rendition taller than the
+     * upload is skipped; if every one is, the upload's own height is used.
+     * @default [1080, 720, 480]
+     */
+    renditions?: number[];
+    /** Target length of each segment, in seconds. @default 6 */
+    segmentDuration?: number;
+};
+/** `false` (or absent) uploads the file as it was picked. */
+export type VideoStreamOption = false | VideoStreamOptions;
+export type VideoOptions = {
+    /** Where uploads land. @default "/public/val" */
+    dir?: string;
+    /**
+     * What may be UPLOADED, in `<input accept>` syntax. @default "video/*"
+     *
+     * Not checked against an HLS stream: the playlist is what the Studio made of
+     * an upload that was accepted, not something an editor picked.
+     */
+    accept?: string;
+    stream?: VideoStreamOption;
+};
+/**
+ * What a SET-BACKED field (`s.video(videosVal)`) may say for itself.
+ *
+ * Not `VideoOptions`: `dir` and `accept` belong to the set. `stream` is the
+ * exception, as `encode` is for an image: it is about what happens to an
+ * upload on its way in, so a field that wants the file as it was picked,
+ * where its set streams, has to be able to say `stream: false`.
+ */
+export type GalleryVideoOptions = {
+    stream?: VideoStreamOption;
+};
+/**
+ * The set a field picks from: its entries as they were when the module was
+ * evaluated (the published set — see `GalleryImageSource` for why that is
+ * enough), and whether it stores its videos on Val Remote.
+ */
+export type VideoGallery = {
+    modulePath: string;
+    /**
+     * `null` for a schema that was DESERIALIZED: the serialized form names the
+     * set, not its contents, so whether the set has the entry is a question
+     * for the set's own module — which the Studio validates anyway.
+     */
+    entries: Record<string, VideosetEntryMetadata<AltSource>> | null;
+    remote: boolean;
+};
+export type SerializedVideoSchema = {
+    type: "video";
+    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
+    render?: FieldRender;
+    /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
+    preview?: true;
+    options?: VideoOptions;
+    opt: boolean;
+    remote?: boolean;
+    customValidate?: boolean;
+    /** The `s.videoset()` module this field picks from, if it is set-backed. */
+    referencedModule?: string;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
+};
+export type VideoMetadata = {
+    mimeType?: string;
+    width?: number;
+    height?: number;
+    duration?: number;
+};
+export declare const DEFAULT_VIDEO_ACCEPT = "video/*";
+export declare const DEFAULT_VIDEO_RENDITIONS: number[];
+export declare const DEFAULT_VIDEO_SEGMENT_DURATION = 6;
+export declare class VideoSchema<Src extends GalleryVideoSource | null> extends Schema<Src> {
+    private readonly options?;
+    private readonly opt;
+    protected readonly isRemote: boolean;
+    private readonly customValidateFunctions;
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    private readonly renderInput;
+    private readonly previewInput;
+    private readonly gallery;
+    constructor(options?: VideoOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null, gallery?: VideoGallery | null);
+    /**
+     * Describe this field.
+     *
+     * The description is INPUT HELP: it is shown where this field's value is
+     * entered — beside its input in the Val editor, and for a record's key
+     * schema in every form that asks for a key — so it is where you say what an
+     * editor needs to know to fill it in RIGHT, which the field name cannot
+     * carry. It is not a name for the value: that is `.preview(...)`, and it is
+     * read somewhere else. The description also travels in the serialized
+     * schema, which is what the AI assistant and the MCP tools read.
+     *
+     * Pass `null` to clear a description set earlier.
+     *
+     * @example
+     * const schema = s.video().describe("Plays muted behind the headline");
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "/public/val/example.mp4",
+     *   mimeType: "video/mp4",
+     * });
+     */
+    describe(description: string | null): VideoSchema<Src>;
+    /**
+     * Store the video on Val's remote content host instead of in your
+     * repository.
+     *
+     * The bytes still go into the patch store when the video is uploaded — the
+     * push to the remote host happens at publish. What changes is where the
+     * published video lives: `path` (and the poster's, and each caption track's)
+     * becomes a remote URL rather than a path under `/public`, so the repository
+     * does not grow with every upload. Upload remote videos in the Studio.
+     *
+     * @example
+     * const schema = s.video().remote();
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "https://remote.val.build/file/p/my-project/b/01/v/1.0.0/h/8f2a1c/f/3b9d70/p/public/val/example.mp4",
+     *   mimeType: "video/mp4",
+     * });
+     */
+    remote(): VideoSchema<Src>;
+    /**
+     * Add a custom validation rule to this field.
+     *
+     * The function is called with the field's value and returns `false` when the
+     * value is fine, or a STRING with the message to show when it is not. Call it
+     * more than once to add more rules — they all run, and every message is
+     * reported.
+     *
+     * Write the check as a ternary, not as `ok || "message"`: that returns `true`
+     * when the value is fine, and `true` is not one of the two answers.
+     *
+     * Validation runs in the Studio as you type, in `npx val validate` and
+     * before a publish.
+     *
+     * The second argument carries the `path` of the field being validated, for
+     * when the message needs to say where the problem is.
+     *
+     * @example
+     * const schema = s.video().validate((val) =>
+     *   (val.duration ?? 0) <= 30 ? false : "Keep it under 30 seconds",
+     * );
+     * export default c.define("/example.val.ts", schema, {
+     *   path: "/public/val/example.mp4",
+     *   mimeType: "video/mp4",
+     *   duration: 12,
+     * });
+     */
+    validate(validationFunction: CustomValidateFunction<Src>): VideoSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    /**
+     * A set-backed field: the file and what was read from it are the set's,
+     * so the field is checked for what is its own, and for pointing at an
+     * entry the set has.
+     */
+    private validateFromGallery;
+    /** A video of its own: it carries the file, and what was read from it. */
+    private validateOwn;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): VideoSchema<Src | null>;
+    readonly(isReadonly?: boolean): VideoSchema<Src>;
+    hidden(isHidden?: boolean): VideoSchema<Src>;
+    protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
+    /**
+     * How this field is laid out in the editor when it is the item of an array
+     * or record: `{ as: "inline" }` renders the field itself inside each row,
+     * instead of a preview row that navigates to it.
+     *
+     * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.video().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, [
+     *   { path: "/public/val/example.mp4", mimeType: "video/mp4" },
+     * ]);
+     */
+    render(input: FieldRender): VideoSchema<Src>;
+    /**
+     * How this VALUE is shown where a preview of it is needed — a row in a
+     * sortable list, a reference dropdown, a search hit. Never how the field
+     * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.video().preview(({ val }) => ({
+     *     title: val.alt ?? val.path,
+     *     image: val.poster,
+     *   })),
+     * );
+     * export default c.define("/example.val.ts", schema, [
+     *   { path: "/public/val/example.mp4", mimeType: "video/mp4" },
+     * ]);
+     */
+    preview(select: ItemPreviewInput<Src>): VideoSchema<Src>;
+    protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;
+    protected declaresItemPreview(): boolean;
+    protected executeSerialize(): SerializedSchema;
+}
+/**
+ * Every file a video value names: the video, its poster and each caption
+ * track. An HLS stream's segments are not here — they are named by its
+ * playlists, not by the value.
+ */
+export declare function filesOfVideoSource(src: GalleryVideoSource): string[];
+/**
+ * A video picked from a set (`s.videoset()`). What is true of the file —
+ * its type, size and length — lives in the set; the field carries what one
+ * page chose about it.
+ */
+export declare function video(videosetModule: ValModule<Record<string, VideosetEntryMetadata<AltSource>>>, galleryOptions?: GalleryVideoOptions): VideoSchema<GalleryVideoSource>;
+/**
+ * Define a video: an `.mp4` / `.webm` file, or an HLS stream the Studio makes
+ * from an upload when `stream` is set.
+ */
+export declare function video(options?: VideoOptions): VideoSchema<VideoSource>;
+/**
+ * `s.video()` 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 remoteVideo(videosetModule: ValModule<Record<string, VideosetEntryMetadata<AltSource>>>, galleryOptions?: GalleryVideoOptions): VideoSchema<GalleryVideoSource>;
+export declare function remoteVideo(options?: VideoOptions): VideoSchema<VideoSource>;

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

@@ -0,0 +1,141 @@
+import { Schema } from "./index.js";
+import type { SerializedRecordSchema } from "./record.js";
+import { RecordSchema } from "./record.js";
+import { ObjectSchema } from "./object.js";
+import { StringSchema } from "./string.js";
+import { NumberSchema } from "./number.js";
+import type { AltSchema, AltSource, AltSourceOf } from "./imageset.js";
+import type { SerializedVideoSchema, VideoStreamOption } from "./video.js";
+import type { MediaHotspot, VideoCaptionSource, VideoPosterSource } from "../source/media.js";
+/**
+ * Options for s.videoset()
+ */
+export type VideosetOptions<Accept extends `video/${string}`, Alt extends AltSchema = StringSchema<string | null>> = VideosetOptionsBase<Accept> & VideosetAltOption<Alt>;
+/** See `ImagesetAltOption`: `alt` is optional only when it is the default. */
+type VideosetAltOption<Alt extends AltSchema> = [
+    StringSchema<string | null>
+] extends [Alt] ? {
+    /**
+     * Description schema. Can be:
+     * - s.string() for a required description
+     * - s.string().nullable() for an optional one (default)
+     * - s.record(s.string(), s.string()) for one per locale
+     */
+    alt?: Alt;
+} : {
+    /** Description schema — required, because it is not the default one. */
+    alt: Alt;
+};
+type VideosetOptionsBase<Accept extends `video/${string}`> = {
+    /**
+     * What may be UPLOADED, in `<input accept>` syntax. Must be a video type.
+     * Not checked against an HLS stream: see `VideoOptions.accept`.
+     * @default "video/*"
+     */
+    accept?: Accept;
+    /**
+     * The directory where videos are stored. Must start with "/public".
+     *
+     * Required for the same reason it is on `s.imageset()`: it decides where
+     * every upload in the set lands, and a default is a directory shared with
+     * every other set that did not say.
+     */
+    dir: "/public" | `/public/${string}`;
+    /**
+     * Turn every upload into an HLS stream, in the browser. See
+     * `VideoStreamOptions`. A field backed by this set (`s.video(videosVal)`)
+     * inherits it, as it inherits `accept` and `dir`.
+     */
+    stream?: VideoStreamOption;
+};
+/**
+ * One video of a set, keyed by its file path (an HLS stream by its master
+ * playlist).
+ *
+ * Two kinds of thing are here. What is TRUE OF THE FILE — what it is, how
+ * big, how long — is read from the bytes and is the set's alone. The rest —
+ * the description, focal point, poster, start and end, and captions — is what
+ * a page chooses about a video, and an entry holds it as the DEFAULT: every
+ * field picked from the set (`s.video(videosVal)`) starts from it and may
+ * override it key by key, so a video described and trimmed once is described
+ * and trimmed everywhere it is used. `fillFromGallery` is the one merge.
+ *
+ * The poster is also the set's thumbnail of the entry: there is no separate
+ * still for the gallery, because two stills of one video would disagree.
+ */
+export type VideosetEntryMetadata<Alt extends AltSource = string | null> = {
+    mimeType: string;
+    width: number;
+    height: number;
+    /** In seconds. */
+    duration: number;
+    alt: Alt;
+    hotspot?: MediaHotspot;
+    /** Seconds. The frame the poster was taken from. */
+    posterTime?: number;
+    poster?: VideoPosterSource;
+    /** Seconds. Where playback starts. */
+    startTime?: number;
+    /** Seconds. Where playback stops. */
+    endTime?: number;
+    /** Overridden as a whole: a field with its own tracks has none of these. */
+    captions?: readonly VideoCaptionSource[];
+};
+export type SerializedVideosetSchema = SerializedRecordSchema;
+type VideosetItemProps<Alt extends AltSchema> = {
+    mimeType: StringSchema<string>;
+    width: NumberSchema<number>;
+    height: NumberSchema<number>;
+    duration: NumberSchema<number>;
+    alt: Alt;
+};
+type VideosetItemSrc<Alt extends AltSchema> = {
+    mimeType: string;
+    width: number;
+    height: number;
+    duration: number;
+    alt: AltSourceOf<Alt>;
+};
+/**
+ * Define a collection of videos — the video twin of `s.imageset()`.
+ *
+ * A field picks from it with `s.video(videosVal)`. An entry may hold the
+ * description, poster, start and end, focal point and captions as defaults,
+ * and a field overrides any of them by setting its own. Uploading in such a
+ * field adds to the set. Call `.remote()` on the result
+ * to store the set on Val Remote.
+ *
+ * @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",
+ *     startTime: 1.5,
+ *   },
+ * });
+ * ```
+ */
+export declare const videoset: <Accept extends `video/${string}`, Alt extends AltSchema = StringSchema<string | null>>(options: VideosetOptions<Accept, Alt>) => RecordSchema<ObjectSchema<VideosetItemProps<Alt>, VideosetItemSrc<Alt>>, Schema<string>, Record<string, VideosetEntryMetadata<AltSourceOf<Alt>>>>;
+/**
+ * The video schema a set's entry is hashed against, for a remote ref.
+ *
+ * The set's item schema is an object, but a remote ref's validation hash is
+ * computed over a MEDIA schema, so one is synthesized from the set — the one
+ * definition the CLI's upload (`videos:upload-remote`) and the Studio's (the
+ * set's gallery) both use, because two copies are two hashes for the same
+ * file. `stream` is left out: it says what is done to an upload on its way
+ * in, not whether the bytes that arrived are valid.
+ */
+export declare function videosetEntryVideoSchema(set: {
+    accept?: string;
+    dir?: string;
+}): SerializedVideoSchema;
+export {};

package/dist/declarations/src/source/galleries.d.ts

@@ -0,0 +1,20 @@
+import type { Schema } from "../schema/index.js";
+import type { SelectorSource } from "../selector/index.js";
+/**
+ * The PUBLISHED entries of every gallery a module's fields pick from — an
+ * `s.image(galleryVal)`, `s.file(filesVal)` or `s.video(videosVal)` — by the
+ * gallery's module path.
+ *
+ * A gallery-backed value names its file and nothing else that is the
+ * gallery's, so a reader has to look the entry up (`fillFromGallery`). In
+ * draft mode the reader has every module's draft source to look in; outside
+ * it, nothing — and the page got a set-backed video with no type, size,
+ * poster or description, and an image with no dimensions. But the field's
+ * schema was built from the gallery module (`s.video(videosVal)` reads it at
+ * definition), so the published entries are already here, on the schema
+ * instance. This is where they are read from.
+ *
+ * Stops at a view: the module it points at is read on its own, with its own
+ * galleries.
+ */
+export declare function galleriesOf(schema: Schema<SelectorSource> | undefined): Map<string, unknown>;